元组，字典和集合

元组，字典和集合

---

元组（tuple）

元组是一个不可变序列，一般当我们不希望存储的数据改变时，我们使用元组，其他情况一般使用列表。

# tup = (1,2,4,5,6)
# tup[3] = 12  #TypeError: 'tuple' object does not support item assignment
# print(tup)

元组的创建

# tup = (1,2,4,5,6)
# tup = 1,2,3,4,5
# tup = 10,     # 当元组不为空时，里面至少有一个逗号
# print(tup,type(tup))

元组的解包

# 需要与元组元素个数相同的变量
# tup = (1,2,3,4,5)
# a,b,c,d,e = tup
# a,b = tup  #ValueError: too many values to unpack
# print(a,b)

# 在变量前面加上*号，可以使多个元组的元素值赋予这个变量，以列表的形式
# a,b,*c = tup
# a,*b,c = tup
# *a,b,c = tup
# print(a,b,c)

---

字典（dict）

• 字典是可变序列，与列表类似都是存储数据的容器，字典的存储性能较差，查询性能较好，与列表相反
• 字典是一种映射结构，字典里每个值（value）都有唯一的一个名字对应，通过找到这个名字就可以访问值；我们称这个名字为键（key）
• 字典里的每一项都有键值对组成（key-value），因此我们又称字典为键值对结构
• 字典里的值可以是任何对象，字典的键可以是任何不可变对象
• 字典的键是唯一的，如果出现重复地，后面出现的会覆盖前面的

字典的创建

# dct = {'name':'Sleet','age':19,'gender':'男'}
# 如果字典里的项较多，为方便阅读，通常如下写法
# dct = {
#     'name':'Sleet',
#     'age':19,
#     'gender':'男'
# }
# dct = dict(name='Sleet',age=19,gender='男')
# dct = dict([('name','Sleet'),('age',19),('gender','男')])
# print(dct)

查询字典里的值（value）

# dct = {'name':'Sleet','age':19,'gender':'男'}
# print(dct['name'])
# key = 'name'
# print(dct[key])

字典的使用

len()

# dct = {'name':'Sleet','age':19,'gender':'男'}

# 返回字典长度
# print(len(dct))

修改键的值

# dct = {'name':'Sleet','age':19,'gender':'男'}
# dct['name'] = 'Jerry'
# dct['hobby'] = 'basketball'   # 如果修改的键不存在，则自动进行创建

增加

# dct = {'name':'Sleet','age':19,'gender':'男'}
# dct['hobby'] = 'basketball'
# r = dct.setdefault('hobby','basketball')  # 有返回值，返回值为键值对的值
# dct.setdefault('name','Jerry')  # 如果字典中存在该键，则不进行任何操作

删减

# dct = {'name':'Sleet','age':19,'gender':'男'}
# dct.popitem()  # 随机删除字典中的一项（一般都是从后面开始删除）
# dct.popitem()   # {'name': 'Sleet', 'age': 19}
# r = dct.popitem()  # 有返回值，返回值的形式为元组，返回的是双值子序列

# pop()  # 通过key来删除项
# dct.pop('name')
# r = dct.pop('hobby','没有这个键')  # 如果不存在键，可以返回第二个参数
# r = dct.pop('name')  # 有返回值，返回值为键值对的值

# clear()   # 清空字典
# dct.clear()

# del dct['name'] # 用关键字进行删除

更新字典

# dct = {'name':'Sleet','age':19,'gender':'男'}
# update(字典)  # 用另一个字典来更新当前字典
# dct_1 = {
#     'name':'Jerry',
#     'hobby_1':'basketball',
#     'hobby_2':'tennis',
#     'hobby_3':'badminton'
# }
# dct.update(dct_1)   # 如果更新的字典里有与原字典重名的键，则更新后会进行覆盖
# print(dct)

get()

# 根据键来获取字典的值，第二个参数可以指定一个值，当获取不到值的时候返回这个值，默认为None
# value = dct.get('name')
# value = dct.get('hobby')
# value = dct.get('hobby','没有这个键')
# print(value)

---

集合（set）

集合与列表类似

不同点：

• 集合存储的对象是不可变的
• 集合里的元素是无序的（不是按照插入的顺序进行排序）
• 集合的对象是不能重复的

集合的创建

# 集合的创建
# s = {1,2,3,4,5}
# s = set([1,2,3,4,5])
# s = set('hello')  # 无重复元素
# s = set(1,2,3)   # TypeError: set expected at most 1 argument, got 3
# s = set(1)    # TypeError: 'int' object is not iterable
# s = {100,10,1,2,3,4} # 无序
# s = {1,1,2,3,4,4} # 元素不重复
# print(s)

• 可以通过s = {1,2,…}创建；注意：当s = {}时创建的是空的字典
• 可以通过s = set()创建；如果没有传递参数，则返回set()，这就是空集合；set()传递的参数只能有一个，而且必须是可迭代的对象

集合的使用

add(x)

add(x)：在集合中增加一个元素

# s = {1,2,3,4,5}
# s.add(6)
# print(s)

remove(x)

remove(x)：删除集合中的指定元素

# s = {1,2,3,4,5}
# s.remove(5)
# print(s)

pop()

pop()：随机删除集合中的一个元素，有返回值，返回被删除的元素

# s = {'a','b','c','d',1,2,3,4,}
# r = s.pop()
# print(r)
# print(s)

clear()

clear()：清空集合

# s = {'a','b','c','d',1,2,3,4,}
# s.clear()
# print(s)

update(集合)

用另一个集合更新当前集合

# s = {'a','b','c','d',1,2,3,4,}
# s2 = set('python')
# s.update(s2)
# print(s)
# print(s2)

集合的运算

&（交集运算）

# s1 = {1,2,3,4}
# s2 = {3,4,5,6}
# r = s1 & s2
# print(r)

|（并集运算）

# s1 = {1,2,3,4}
# s2 = {3,4,5,6}
# r = s1 | s2
# print(r)

-（差集运算）

# s1 = {1,2,3,4}
# s2 = {3,4,5,6}
# r = s1 - s2
# print(r)

^（异或集）

# s1 = {1,2,3,4}
# s2 = {3,4,5,6}
# r = s1 ^ s2
# print(r)

<(<=)和>(>=)

• a<b：a是b的真子集
• a<=b：a是b的子集
• a>b：a是b的真超集
• a>=b：a是b的超集

# s3 = {1,2,3,4}
# s4 = {1,2,3,4}
# s5 = {1,2,3,4,5}
# print(s3<=s4)
# print(s3<s4)
# print(s3<s5)

---

以上内容为个人总结+资料查找
欢迎各位批评指正~