从零开始学python---容器

一、数据容器入门

为了容纳多个数据而不需要多次定义->数据容器
什么是数据容器：一种可以容纳多份数据的数据类型，每一份数据称为元素，容器可以存储任意类型的数据，如字符串，布尔，数字等等
python中所带有的数据容器分为5种：列表，元组，字符串，集合，字典

二、列表list

2.1 列表的定义

'''定义列表变量'''
"变量名称" = [元素1,元素2,...,元素n]
'''定义空列表'''
变量名称 = []
变量名称 = list[]
列表中的数据使用逗号隔开
使用[]作为列表标识

#一个列表定义的示例
wjm = ["wjm","041006"]
print(wjm)
print(type(wjm))
'''
输出结果
['wjm', '041006']
<class 'list'>
'''

note：列表存入的类型可以是任意类型，也可以存储列表，称之为列表的嵌套

2.2 列表的下标

使用列表的下标索引取出列表特定位置的数据，第一个元素下标索引为0，后面依次增加
例如

wjm = ["wjm","041006"]
print(wjm[0])
print(wjm[1])
'''
结果为
wjm
041006
'''

如果元素本身也为列表只需要写两层下标索引即可，即列表[][]
例如

wjm = ["wjm",[0,4,1,0,0,6]]
print(wjm[0])
print(wjm[1][2])
'''结果为
wjm
1
'''

2.3列表的常用操作

list提供的函数

1.查询：index函数

wjm = [0,4,1,0,0,6]
#查询某元素下标
#index函数，返回查询值的下标
print(wjm.index(4))
#返回的是查询值的第一个位置
print(wjm.index(0))
#元素不存在则会报错
print(wjm.index(10))
'''
结果为
1
0
ValueError: 10 is not in list
'''

2.重新赋值

列表名[i] = 新值，给列表的下标为i的元素更换为新值

3.插入：insert函数
 

wjm = [0,4,1,0,0,6]
#insert函数，在列表中指定下标插入新值
wjm.insert(0,"wjm")
print(wjm)

'''
结果为
['wjm', 0, 4, 1, 0, 0, 6]
'''

4.追加：append

wjm = [0,4,1,0,0,6]
#将某一元素追加到列表的尾部
wjm.append("wjm")
print(wjm)

'''
结果为
[0, 4, 1, 0, 0, 6, 'wjm']
'''

5.容器追加

wjm = ['w','j','m']
wjm_1 = [0,4,1,0,0,6]
#将某一容器的内容依此取出追加到列表的尾部
wjm.extend(wjm_1)
print(wjm)

'''
结果为
['w', 'j', 'm', 0, 4, 1, 0, 0, 6]
'''

6.元素的删除

6.1 下标删除法：del和pop

#del可以删除列表中内容
wjm = ['w','j','m']
del wjm[1]
print(wjm)
#pop不仅可以删除，还可以把删除的内容作为返回值得到
wjm = ['w','j','m']
wjm_1 = wjm.pop(1)
print(wjm_1)
print(wjm)

'''
结果为
['w', 'm']
j
['w', 'm']
'''

6.2 元素删除法：remove

wjm = ['w','j','m']
#remove 删除某元素在列表中的第一个匹配项
wjm.remove("j")
print(wjm)
#note remove只能删除一个指定元素，如果想多次删除，需要多次调用remove
'''
结果为
['w', 'm']
'''

7.列表的清空：clear

wjm = ['w','j','m']
#clear 清除列表中的全部元素
wjm.clear()
#注意不需要任何参数
print(wjm)
'''
结果为
[]
'''

8.统计某一元素在列表中数量：count

wjm = ['w','j','m']
#count 统计列表中某一元素数量
wjm_num = wjm.count('w')
#注意不需要任何参数
print(wjm_num)
'''
结果为
1
'''

9.计算列表长度：len

wjm = ['w','j','m']
#len 计算列表数量
wjm_num = len(wjm)
#注意不需要任何参数
print(wjm_num)
'''
结果为
3
'''

10.简单总结

2.4 列表的遍历操作

1.while循环

wjm = ['w','j','m']
index = 0
while index < len(wjm):
    print(wjm[index])
    index += 1
'''
结果为
w
j
m
'''

2.for循环

wjm = ['w','j','m']
for index in wjm:
    print(index)
'''
结果为
w
j
m
'''

note ：while循环适用于所有场景，可以是无限循环，for循环是有限循环

三、元组

3.1元组的定义

定义：只读的list，元组中的元素不可修改
 

'''定义元组变量'''
"变量名称" = (元素1,元素2,...,元素n)
'''定义空元组'''
变量名称 = ()
变量名称 = tuple()
元组中的数据使用逗号隔开
使用()作为元组标识

note：元组中的数据也可是任意类型，必须带有逗号，如果你的元组中只具有一个数据的话也要带括号

3.2 元组的方法

元组的下标索引，查找，统计，长度计算都和列表一样，只是不能修改罢了（修改元组内容会造成报错）
while和for循环遍历也同列表相同
这里不做具体描述了
note:如果元组里面嵌套了list，那么list里面的元素是可以修改的

四、字符串

把字符串视为容器，那么字符串里面的每一个字符就是字符串里面的元素

4.1 字符串的方法:

1.查找：下标，index

#定义一个字符串
wjm = "wjm041006"
#1.索引
wjm_1 = wjm[3]
print(wjm_1)
'''结果为0'''

#note 字符串是无法修改的
# wjm[3] = 'l'
'''TypeError: 'str' object does not support item assignment'''

'''常用操作'''
#index查找操作
wjm_2 = wjm.index('j')
print(wjm_2)
'''结果为1'''

2.替换;replace

wjm = "wjm041006"
#replace将字符串中的a替换为b
#note 这是产生一个新的字符串，而不是对老字符换修改
wjm_3 = wjm.replace('0','1')
print(wjm_3)
'''结果为wjm141116'''

3.分割split

#定义一个字符串
wjm = "wjm 041006"
#split 按照指定的分隔符字符串，将字符串划分为多个字符串，并存入列表中
#字符串本身不变，而是得到一个列表对象
wjm_1,wjm_2 = wjm.split(" ")
print(wjm_1,wjm_2)
'''结果为wjm 041006'''

4.规整操作：strip

#定义一个字符串
wjm = "  wjm 041006  "
#strip 去掉前后空格和回车符号
wjm_1 = wjm.strip()
print(wjm_1)
#如果传入参数，那么去除前后参数
wjm = "12 wjm 041006  21"
wjm_2 = wjm.strip("12")
#加入参数就不会默认去除空格了，注意去除的为两个小子串
print(wjm_2)
'''
结果为
wjm 041006
 wjm 041006 
 '''

5.其它操作

count和len函数使用方法等同于列表

6.小总结

五、容器（序列）的切片操作

 5.1 序列的定义

序列的定义：内容连续、有序，可以使用下表索引的一类数据容器
例如：前面所写的列表，数组，字符串

5.2 序列的切片

从一个序列中取出一个子序列

'''
序列语法
[起始下标:结束下标:步长]
从序列中，从指定位置开始，到指定位置结束
按照步长依此取出新元素，构建新序列
起始下标为空视为从头开始
取元素的时候不包含结束下标
不写步长的时候视为步长为1
'''

六、集合

6.1 集合的定义

内部无序（输出出来是乱序的），自带去重功能

'''定义集合变量'''
"变量名称" = {元素1,元素2,...,元素n}
'''定义空集合'''
变量名称 = set()
集合中的数据使用逗号隔开
使用{}作为集合标识
#note：空的大括号被字典占用了

wjm = {"wjm","041006","wjm","041006","wjm","041006"}
wjm_1 = set()
print(wjm)
print(wjm_1)
'''
结果为：
{'wjm', '041006'}
set()
'''

6.2 集合常用操作

集合是无序的，不支持索引操作，但集合是允许修改的

1.添加新元素：add

wjm = {"wjm","041006"}
wjm.add("1117")
print(wjm)

'''
结果为：
{'041006', '1117', 'wjm'}
'''

2.移除元素：remove

wjm = {"wjm","041006"}
wjm.add("1117")
print(wjm)
wjm.remove("1117")
print(wjm)

'''
结果为：
{'1117', '041006', 'wjm'}
{'041006', 'wjm'}
'''

3.随机取出元素：pop

wjm = {"wjm","041006"}
wjm.add("1117")
wjm_1 = wjm.pop()
print(wjm_1)
print(wjm)

'''
结果为：
wjm
{'041006', '1117'}
'''

4.清空集合：clear

wjm = {"wjm","041006"}
wjm.clear()
print(wjm)

'''
结果为：
set()
'''

5.取集合差集得到一个新集合：differenece

wjm = {"wjm","041006"}
wjm_1 = {"wjm","123456"}
#集合1.difference(集合2)
#这个函数的意思是用集合1中有的而集合而集合二中没有的创建一个新集合
wjm_2 = wjm.difference(wjm_1)
print(wjm_2)
'''
结果为：
{'041006'}
'''

6.删除集合1，2中相同的元素：differenece_update

wjm = {"wjm","041006"}
wjm_1 = {"wjm","123456"}
#集合1.difference_update(集合2)
#这个函数的意思删除集合1中集合1，2共有的元素
wjm.difference_update(wjm_1)
print(wjm)
'''
结果为：
{'041006'}
'''
#note：函数的返回值为None

note：上述两个删除函数集合2都不改变

7.集合合并：union

wjm = {"wjm","041006"}
wjm_1 = {"wjm","123456"}
#集合1.union(集合2)
#这个函数的意思合并集合1，2共有的元素到集合3中,而集合1，2没有发生改变
wjm_2 = wjm.union(wjm_1)
print(wjm_2)
'''
结果为：
{'wjm', '123456', '041006'}
'''

8.其它方法

len：计算集合长度，计算的为不重复的数据个数
集合不支持下标索引，不能使用while循环遍历
集合支持for循环的遍历，可以把所有元素取出

七、字典

7.1 定义

通过key去寻找value，比如通过名字找寻成绩，就是通过一个东西找到与关联的东西

'''定义字典变量'''
"变量名称" = {key:value,key:value,...,key:value}
#note：字典中的元素是键值对
'''定义空字典'''
变量名称 = {}
变量名称 = dict()
字典中的不同元素使用逗号隔开，一个键值对用冒号隔开key和value
使用{}作为字典标识

note：字典定义时key不允许重复，如果重复，只保留后面的内容，不可使用下标索引，只可以使用key索引

wjm = {"w":40,"w":10,"m":60}
print(wjm)
'''
结果为
{'w': 10, 'm': 60}
'''
wjm = {"w":40,"j":10,"m":60}
print(wjm['w'])
'''
结果为
40
'''

note:字典中的key和value可以是任何数据类型：but key不可以是字典
字典也可以进行嵌套，使value为一个字典
和前面嵌套的使用一样：字典名["value_key"]["value"]

7.2 字典常用操作

1.字典的修改和新增

wjm = {"w":40,"j":10,"m":60}
#如果这个键值对字典中没有，相当于新增元素
wjm["L"] = 88
print(wjm)
#如果这个元素字典中存在，那么相当于更新元素
wjm["w"] = 66
print(wjm)
'''
结果为
{'w': 40, 'j': 10, 'm': 60, 'L': 88}
{'w': 66, 'j': 10, 'm': 60, 'L': 88}
'''

2.字典删除元素：pop

wjm = {"w":40,"j":10,"m":60}
#将对应key的value返回，并将对应键值对从字典中删除
wjm_1 = wjm.pop("w")
print(wjm_1)
print(wjm)
'''
结果为
40
{'j': 10, 'm': 60}
'''

清空元素：clear 这里不多做介绍

3.获取全部key：keys

wjm = {"w":40,"j":10,"m":60}
#获取全部的key值
wjm_1 = wjm.keys()
print(wjm_1)

'''
结果为
dict_keys(['w', 'j', 'm'])
'''

使用keys函数可以实现对字典的遍历
 

wjm = {"w":40,"j":10,"m":60}
#遍历操作
wjm_1 = wjm.keys()
print(wjm_1)
for w in wjm_1:
    print(wjm[w])

'''
结果为
dict_keys(['w', 'j', 'm'])
40
10
60
'''

第二种遍历操作，直接使用for循环

wjm = {"w":40,"j":10,"m":60}
#遍历操作
for w in wjm:
    print(wjm[w])
'''
结果为
40
10
60
'''

len统计字典的元素个数，这里不做介绍

八：应用场景

 九：容器都支持的操作：

len：统计容器元素个数
max：统计容器中最大元素
min：统计容器中最小元素

转换：
list：将容器转换为列表
str：将容器转换为字符串
tuple：将容器转换为元组
set：将容器转换为集合
note：字典转列表，元组，集合会抛弃所有的value，只有转字符串才会保留value

其它功能：
sort(容器，True or Flase) 对容器进行排序操作，后面的参数默认为Flase，为升序排序
排序过后会变成列表