4-python数据容器
数据容器：可以存储多个元素的数据类型
列表list、元祖tuple、字符串str、集合set、字典dict
列表：可修改，元素可重复，元素间有序，可下标索引
元组：不可修改，元素可重复，元素间有序，可下标索引
字符串：不可修改，元素可重复，元素间有序，可下标索引
集合：可修改，元素不可重复，元素间无序（因此不支持下标索引访问）
字典：可修改，元素不可重复，不支持下标索引访问
存字符串选字符串，不可修改选元组，不可重复选集合，键值选字典，其他选列表
文章目录
- 1.列表 list
- 2.元组 tuple
- 3.切片
- 4.集合 set
- 5.字典 dict
1.列表 list
a=["hello",1,1.5]
print(a) # ['hello', 1, 1.5]
print(a[0]) # hello
print(a[-1]) # 1.5
print(a[0:2]) # ['hello', 1]
a[2]=6
print(a[2]) # 6
a.append("新增") # 通过append新增元素
print(a) # ['hello', 1, 6, '新增']
a.extend([1,2,3,4,5]) # 通过extend一次增加多个值
print(a) # ['hello', 1, 6, '新增', 1, 2, 3, 4, 5]
del a[1] # 通过del删除元素
print(a) # ['hello', 6, '新增', 1, 2, 3, 4, 5]
print(len(a)) # 8 通过len求元素个数(列表长度)
b=["ha",2]
c=a+b #列表拼接
print(c) # ['hello', 6, '新增', 1, 2, 3, 4, 5, 'ha', 2]
print(b*4) # ['ha', 2, 'ha', 2, 'ha', 2, 'ha', 2] 列表重复输出四次
print([2,"ao"]*3) # [2, 'ao', 2, 'ao', 2, 'ao'] 给定列表输出
# if 判断
b=["ha",2]
if 2 in b:
print("1")
else:
print("2")
# 1
# for循环
b=["ha",2]
for x in b:
print(x)
"""
ha
2
"""
# while
b=["ha",2]
i=0
while i<len(b): # 列表b的元素个数
print(b[i])
i+=1
"""
ha
2
"""
#嵌套
print(a) # ['hello', 6, '新增', 1, 2, 3, 4, 5]
print(b) # ['ha', 2]
y=[a,b]
print(y) # [['hello', 6, '新增', 1, 2, 3, 4, 5], ['ha', 2]]
print(y[1][1]) # 2 第1组第1个(从0起)
#列表比较
import operator
a=[1,2]
b=[2,3]
c=[2,3]
print(operator.eq(a,b)) # False
print(operator.eq(b,c)) # True
# 最值(min同理)
a,b=["apple","bpple","cpple"],[1,2,3]
print(max(a)) # cpple 比较第一个字符的ASCLL码，若相等再同时比较第二个
print(max(b)) # 3
a=["apple",6]
#print(max(a)) # error 只能比较相同元素类型
# 统计某个元素的出现次数 list.count(obj)
a=[2,2,2,2,2,5,6,7,8,9,4,"haha"]
print(a.count(2)) # 5
# 索引index
a=[3,2,1,4,3,1,2,3]
print(a.index(1)) # 2 列表a中第一次出现1的位置
print(a.index(1,3,7)) # 5 从下标3到7，找到首次出现1的位置
# 移除列表中的元素，并且返回值 a.pop()
a=[]
a.append("a")
a.extend([1,2,3])
print(a) # ['a', 1, 2, 3]
del a[3] # 删除下标3的元素
print(a) # ['a', 1, 2]
print(a.pop(1)) # 1 删除了下标为1的元素1，返回值为被删除元素
print(a) # ['a', 2]
print(a.pop()) # 2 不写参数默认删除最后一个
# 移除列表某个值的第一个匹配项 remove()
a=["haha","aoao","hehe","aoao"]
a.remove("aoao")
print(a) # ['haha', 'hehe', 'aoao']
# 列表元素取反
a=[1,2,3,4,5]
a.reverse()
print(a) # [5, 4, 3, 2, 1]
# 排序
a=[2,3,1,5,6]
a.sort()
print(a) # [1, 2, 3, 5, 6]
a.sort(reverse=True) # False升序(默认)
print(a) # [6, 5, 3, 2, 1]
# 清空列表 clear()
a=[1,2]
a.clear()
print(a) # []
# 列表复制
a=[1,2]
b=a.copy()
print(b) # [1, 2]
# 元素插入 insert在指定位置插入元素
a=[]
a.append(1) # 添加到尾部
print(a) # [1]
a.insert(0,"hello") # 下标位置、插入元素
print(a) # ['hello', 1]
a.extend(["da",2,3]) # 批量添加
print(a) # ['hello', 1, 'da', 2, 3]
2.元组 tuple
元组不能修改元素内容（增加/删除某个元素/更新），但可以修改元组中的列表
a=("haha",1,2)
b="haha",1,2,3
print(a) # ('haha', 1, 2)
print(b) # ('haha', 1, 2, 3)
print(a[1]) # 1
print(a[0:2]) # ('haha', 1)
print(a[-1]) # 2
print(a+b) # ('haha', 1, 2, 'haha', 1, 2, 3)
print(len(a)) # 3
#a[0]=1 # error 元组中的元素值不能修改
#del a[0[ # error 元组中的元素值不能删除
del a #可以通过del删除元组
#print(a) # error 删除后无法使用(未定义)
a=(10)
print(type(a)) # 3.切片
元组、列表、字符串都可以进行切片
切片不会对原字符串修改，会返回一个新的字符串
a[start: end :step]
步长可省略，默认为1
省略start表示从头(含)/尾(含)开始
省略end表示到尾(含)/头(含)结束
列表
b=["ha",1,2,3,4,5]
b1=b[1:5:2] #下标从1到4，步长为2
print(b) # ['ha', 1, 2, 3, 4, 5]
print(b1) # [1, 3]
元组
c=("dd",6,7,8,9,10)
c1=c[:] # 从起始到结束(含)，步长为1
print(c1) # ('dd', 6, 7, 8, 9, 10)
字符串
a="hello world"
a1=a[::2] # 从头到尾，步长为2
print(a1) # hlowrd
a="hello world"
a1=a[::-1] # 步长为-1,表示从尾到头切片
print(a1) # dlrow olleh
a1=a[7:3:-1] #从7号到3号(不含)切片，步长为-1
print(a1) # ow o
a1=a[7:3:-2] # 步长为-2
print(a1) # o
4.集合 set
确定性、互异性、无序性
（1）定义
a={"as","sad","da"}
b=set(("as","sad","da")) # 集合的参数列表是元组
c=set(["as","sad","da"]) # 集合的参数列表是列表
print(a)
print(b)
print(c)
# 输出均为:{'da', 'sad', 'as'}
a=set("abcdefg")
print(a) # {'c', 'b', 'e', 'g', 'f', 'a', 'd'}
a=set() # 空集合
print(a) # set()
（2）运算
a=set("abcde")
b=set("defgh")
print(a-b) # {'a', 'c', 'b'}
print(a.difference(b)) # {'b', 'c', 'a'}
#差集,与a-b相同,即在a中但不在b中的元素
print(a|b) # {'d', 'h', 'c', 'g', 'f', 'e', 'a', 'b'}
print(a&b) # {'d', 'e'}
print(a^b) # {'g', 'f', 'a', 'h', 'c', 'b'}
# 不同时在a、b中,即 (a|b)-(a&b)
（3）添加
添加的参数可以是列表、元组、字典等
a=set()
a.add(1) # add每次只能加一个
print(a) # {1}
a.update({2})
print(a) # {1, 2}
a.update({3,"ao"})
print(a) # {1, 2, 3, 'ao'}
a.update([5,"haha"])
print(a) # {1, 2, 3, 5, 'haha', 'ao'}
（4）移除
a={1,2,3,4,5,6}
a.remove(3) # 移除元素3，若3不存在会报错
print(a) # {1, 2, 4, 5, 6}
a.discard(4) # 移除元素4，若4不存在不会报错
print(a) # {1, 2, 5, 6}
a.pop() # 随机删除一个元素，集合不支持下标索引，所以不能指定
# pop有返回值，可用变量接收
print(a) # {2, 5, 6}
（5）计数&清空
a=set(("apple","bpple","cpple","dpple"))
print(len(a)) # 4
a.clear() # 清空集合
print(a) # set()
（6）判断元素是否在集合中存在
a=set(("apple","bpple"))
print("bpple" in a) # True
（7）消除交集/保留差集
a={1,2,3,4,5}
b={3,4,5,6,7}
print(a.difference(b)) # {1, 2}
a.difference_update(b) # 在a中消除两个集合相同的元素
# a-(a&b)=a-b 即a的值改为差集的值,即a独有的值
print(a) # {1, 2}
print(b) # 不变 {3, 4, 5, 6, 7}
（8）集合合并
集合a、b的值不变
a={1,2,3}
b={1,5,6}
print(a.union(b)) # {1, 2, 3, 5, 6} 注意集合的互异性
（9）for循环
a={1,2,3,4,5}
for x in a:
print(x,end="") # 12345
5.字典 dict
name叫做键(key)，键必须唯一，且不能修改
black叫做值(value)，值可以不唯一，可以修改
键可以用数字、字符串、元组，但不能用列表
值可以取任意数据类型
如果有多个相同的key，只会保留最后一个
a={"name":"black","age":18,"likes":"basketball"}
print(a) # {'name': 'black', 'age': 18, 'likes': 'basketball'}
a={} # 空字典
b=dict() # 空字典
print(a) # {}
print(b) # {}
（1）访问值
a={"name":"black","age":18,"likes":"basketball"}
print(a["name"]) # black
print(a["age"]) # 18
（2）修改与插入
a={"name":"black","age":18,"likes":"basketball"}
a["name"]="red" # 已有更新
print(a) # {'name': 'red', 'age': 18, 'likes': 'basketball'}
a={"age":18,"name":"jack"}
a["likes"]="basketball" # 没有新增
print(a) # {'age': 18, 'name': 'jack', 'likes': 'basketball'}
（3）删除
clear与del
a={"name":"black","age":18,"likes":"basketball"}
del a["name"]
print(a) # {'age': 18, 'likes': 'basketball'}
a.clear() # 删除字典中所有元素，但不删除字典
print(a) # {}
del a # 删除字典
print(a) # error: name 'a' is not defined
pop
a={"age":18,"name":"jack"}
b=a.pop("name") #返回值为被删除元素的value
print(a) # {'age': 18}
print(b) # jack
a.pop("sasa") # error 不存在此键，引发异常
print(a.pop("sasa","提示信息")) # 输出:提示信息
# 通过提示信息处理异常，使程序正常运行
popitem
采用LIFO的方式，删除最后一个插入的键值/末尾的键值（元组返回）
a={"age":18,"name":"jack"}
b=a.popitem() # 返回值为元组形式，存入b
print(a) # {'age': 18}
print(b) # ('name', 'jack')
print(type(b)) # （4）len
a={"name":"black","age":18,"likes":"basketball"}
print(len(a)) # 3
（5）拷贝
a={"name":"black","age":18,"likes":"basketball"}
b=a.copy() # 深拷贝:拷贝副对象,他不会随a的修改而修改
print(b) # {'name': 'black', 'age': 18, 'likes': 'basketball'}
c=a # 浅拷贝:引用对象,即c作为a的别名,a改变c也会改变
print(c) # {'name': 'black', 'age': 18, 'likes': 'basketball'}
a["name"]="red"
print(b) # {'name': 'black', 'age': 18, 'likes': 'basketball'}
print(c) # {'name': 'red', 'age': 18, 'likes': 'basketball'}
（6）创建新字典fromkeys()
seq=("name","age","likes")
a=dict.fromkeys(seq) #从seq中取键生成字典给a,值为默认None
print(a) # {'name': None, 'age': None, 'likes': None}
a=dict.fromkeys(seq,10) # 值均为10
print(a) # {'name': 10, 'age': 10, 'likes': 10}
（7）get()与setdefault()方法
get(key) 当键不存在时返回默认值None
get(key,value) 当键不存在时返回value
dict[key] 当键不存在时触发异常
a={"name":"black","age":18,"likes":"basketball"}
print(a.get("name")) # black
print(a["name"]) # black
print(a.get("aaaa")) # None
print(a.get("aaaa",6)) # 如果aaaa不在字典的键中，返回6
print(a["aaaa"]) # error 找不到
setdefault()
当键不存在时，会返回None(默认)或设置的值，并且将所查询的key值加入字典中，新加入的key对应的键值为None(默认)或设置值
a={"name":"black","age":18}
print(a.setdefault("aaaaa")) # None
print(a) # {'name': 'black', 'age': 18, 'aaaaa': None}
print(a.setdefault("bbbbb",6)) # 6
print(a) # {'name': 'black', 'age': 18, 'aaaaa': None, 'bbbbb': 6}
嵌套
a={"name":{"age":18}}
print(a) # {'name': {'age': 18}}
b=a.get("name")
print(b) # {'age': 18}
b=a.get("name").get("age")
print(b) # 18
a={
"xiaoming":{
"语文":100,
"数学":99
},
"xiaohong":{
"语文":99,
"数学":100
}
}
print(a)
# {'xiaoming': {'语文': 100, '数学': 99}, 'xiaohong': {'语文': 99, '数学': 100}}
print(a["xiaoming"]["语文"]) # 100
（8）in操作符
a={"name":"black","age":18,"likes":"basketball"}
if "name" in a:
print(1)
if "aaaa" not in a:
print(2)
（9）items以列表返回一个视图对象
将字典中的所有项，以列表的方式返回，字典是无序的，所以items返回的结果也是无序的
a={"name":"black","age":18}
print(a.items()) # dict_items([('name', 'black'), ('age', 18)])
for i in a: # i为视图中所有key的值
print(i,end=" ") # name age
for i,j in a.items(): # items中的key给i，value给j
print(j)
"""
black
18
"""
# 求平均分
a = {"apple": 100, "bpple": 99, "cpple": 98, "dpple": 97}
sum = 0
for key, value in a.items():
sum = sum + value # 求和
print(key, ':', value)
print('平均分为:', sum / len(a))
"""
apple : 100
bpple : 99
cpple : 98
dpple : 97
平均分为: 98.5
"""
视图对象不是列表，不支持索引，可以使用list()转换为列表
不能对视图对象进行任何的修改，字典的视图是只读的
a={"name":"black","age":18}
b=list(a.items())
print(b[0]) # ('name', 'black')
（10）keys与values
a={"name":"black","age":18}
jian=a.keys()
zhi=a.values()
print(jian) # dict_keys(['name', 'age'])
print(zhi) # dict_values(['black', 18])
for x in jian:
print(x) # 当前键
print(a[x]) # 当前键对应的值
"""
name
black
age
18
"""
（11）update更新
a={"age":18}
b={"name":"jack"}
a.update(b)
print(a) # {'age': 18, 'name': 'jack'}
（12）max
max比较的是键首字母的ASCII码大小，不关心value
a={"apple":5,"bpple":3}
print(max(a)) # bpple
字符串相关见 7.字符串