第六章：基本数据类型（列表、元组、字典、集合）

第六章：基本数据类型（列表、元组、字典、集合）

一、列表 list()（可变序列）

1、作用

​ 按位置存放多个值，元素可以重复。属于序列，即存和取的顺序是一样的。

2、定义（可变类型）

​ list[索引不存在] = ‘添加的数据’ 会报错

# 定义空列表
lit = []
lit = list()
lit = [1]	# 只存放一个元素
lit = [1,'sunoeast']	# 存放多个元素用逗号隔开

# 列表中存放的数据必须是可迭代对象：list(可迭代对象)

lit = ['可迭代对象']
# 相当于：
l = []
for i in '可迭代对象'：
	l.append(i)		
# 最好不要直接用lit.append(i),不要随意更改原列表的内容

3、类型转换

​ 只要能够被for循环遍历的类型都可以当作参数传递给 函数list()转成列表。

result = list('hello world')
print(type(result))

result = list({'key1':111,'key2':222})
print(type(result))	
print(result)	# 这里for遍历的只有key，所以输出的列表也只有key

print(list(1))	# 整形不是可迭代对象，所以会报错

4、查找（取出）列表中的值

1、根据索引取值

​ 根据索引操作，无论是取值操作还是赋值操作：索引不存在则报错

lit = [1,'hello','world','sunoeast',[2,3,4]]
print(lit[0])	# 相应的索引取出对应的值/元素
print(lit[-1])
# print(lit[7])	#索引不存在会报错
print(lit[-1][1])	# 列表中嵌套的取值

# 修改
lit[0] = 2	# 修改索引为0的值的内容

2、根据切片取值

# 顾头不顾尾
lit = [1,'hello','world','sunoeast',[2,3,4]]
print(lit[0:2])		# [1, 'hello']
print(lit[0:4:2])	# [1, 'world']
print(lit[1:7])		# 超出范围不会报错，会输出开始索引的位置及后面的所有值

​ 根据切片修改

# 利用索引赋值必须赋值给可迭代对象类型
lit = [1,'hello','world','sunoeast',[2,3,4]]
lit[0:3] = '1'	# 触发list('1')
# lit[0:3] = 1	# 这里实际是触发了list(1),所以会报错TypeError

li = lit[:]	# 相当于拷贝，而且是浅拷贝
print(lit,id(lit))
print(li,id(li))

l = lit[::-1]	# 列表倒序，不会改变原列表，这里不是排序
print(l)	# [[2, 3, 4], 'sunoeast', 'world', 'hello', 1]
print(lit)	# [1, 'hello', 'world', 'sunoeast', [2, 3, 4]]

3、列表中查找方法index()

​ 列表中查找元素只有index()方法，没有找到元素会报错，通常可以用成员运算来判断这样使用起来更加安全。

lit = [1,2,2,3,4]
print(lit.index(2))	# 返回元素2首次出现的下标/索引 1 。

5、往列表中增元素

1、末尾追加 append()方法

​ 可以追加任何类型，但是一次只能追加一个元素或者一个整体

# 格式：需要追加的列表.append('追加的任何类型元素')
lit = [1,2]
lit.append(3)
print(lit)
# 结果：[1, 2, 3]

lit1 = [5,6]
    lit.append(lit1)	# 当成(一个元素)整体添加
print(lit)
# 结果：[1, 2, 3, [5, 6]]

2、追加到指定位置 insert()方法

​ 可以插入任何类型，但是一次只能插入一个元素。如果索引不存在添加到开头或末尾。

# 格式：需要追加的列表.insert(索引，'追加的任何类型元素')
lit = [1,2,3]
lit.insert(0,4)
print(lit)	# 结果：[4, 1, 2, 3]

lit1 = [6,7]
lit.insert(1,lit1)	# 当成一个元素添加
# 结果：[4, [6, 7, 5], 1, 2, 3]

# 如果索引不存在添加到开头或末尾
lit = [1,2,3]
lit.insert(7,5)
print(lit)	# 结果：[1, 2, 3, 5]

lit.insert(-7,8)
print(lit)	# 结果：[8, 1, 2, 3, 5]

3、添加多个值 extend()方法

​ 只能添加可迭代对象。

# 格式：需要添加的列表.extend('添加的可迭代对象')
lit = [1,2,3]
lit1 = [4,5]
lit.extend(lit1)
print(lit)
# 结果：[1, 2, 3, 4, 5]

lit.extend('1')
print(lit)
# 结果：[1, 2, 3, 4, 5, '1']

# lit.extend(1) # 报错

# 底层代码逻辑：
for item in lit1:
	lit.append(item)
print(lit)

6、删除列表中的元素

通常需要先判断元素是否存在，不存在的值使用删除会引发程序报错。

1、通用的删除 del语句

​ 它没有返回值

lit = [1,2,3,4,5,6]
# 根据索引删除，索引不存在会报错
del lit[0]	# result = del lit[0] 抛出异常，del语句不支持赋值语法
print(lit)  # 结果：[2, 3, 4, 5, 6]

# 根据切片删除
del lit[0:3]
print(lit)  # 结果：[5, 6]

# 清空列表中的元素
del lit[:]
print(lit)	# 返回一个空列表

# 删除列表
del lit
# print(lit)    # 列表已经删除，会提示变量lit没有定义

2、取出元素 pop()方法

​ 可以根据索引取值，默认取出最后一个元素，返回值就是取出的元素。

默认就是取出最后一个元素，如果索引不存在会报错。

# 格式：需要取值的列表.pop('索引(不指定就是最后一个元素)')
lit = [1,2,3,4,5,6]
l = lit.pop()
print(l)	# 结果：6

li = lit.pop(1)
print(li)	# 结果：2

# lit1 = lit.pop(7)	# IndexError

3、根据指定的元素删除 remove()方法

​ 有元素会返回None，可以视为无返回值。删除的值不存在会报错。

# 格式：需要删除元素的列表.remove('需要删除的元素')
lit = [1,2,3,4,5,6]
lit.remove(3)
print(lit)	# [1, 2, 4, 5, 6]

# lit.remove(8)		# 会报错：ValueError

7、列表中的运算符

1、算术运算：+ 、 *

lit = [1,'hello','world','sunoeast']
lit1 = [1,2,3]
# 顺序跟列表在 + 号前后位置有关
print(lit + lit1)	# 连接两个列表，创建为一个新的列表
# 结果：[1, 'hello', 'world', 'sunoeast', 1, 2, 3]
print(lit1 + lit)
# 结果：[1, 2, 3, 1, 'hello', 'world', 'sunoeast']


print(lit1 * 3)		# 将元素重复三次放到一个新列表中
# 结果：[1, 2, 3, 1, 2, 3, 1, 2, 3]

2、成员运算 : in 、not in

lit = [1,2,3]
print(1 in lit)		# 结果：True
print(4 not in lit)	# True

3、身份运算：is 、is not

# 身份运算符比较的是id
lit = [1,2,3]
lit1 = lit
print(lit is lit1)	# 结果：True

# == 比较的是内容
lit1 = [1,2,3]	# 重新赋值
print(lit == lit1)	# 结果：True

4、比较大小

必须是同一类型才可以比较大小

# 字符串可以比大小，按照对应的位置的字符依比较
# 字符串的大小是按照ASCI码表的先后顺序加以区别，表中排在后面的字符大于前面的。
print('a'>'b')	# False
print('abd' > 'abcd') # True

# 列表也可以比大小,原理同字符串一样,但是对应位置的元素必须是同种类型
lit = [1,'abc','abb']
lit1 = [1,'abc','b']

print(lit < lit1)	# True

8、其他方法

1、计算列表长度 len()函数

# 格式：len(可迭代对象)
lit = [1,'hello','world','sunoeast',[2,3,4]]
print(len(lit))		# 结果：5

2、计算元素个数 count()方法

# 格式：需要计算的列表.count('元素')
lit = [1,2,1,3,1]
lit.count(1)	# 结果：3

3、清空列表中元素 clear()方法

# 格式：需要清理的列表.clear()
lit = [1,2,3]
'''
del lit[:]
print(lit)	# 返回一个空列表
'''
lit.clear()
print(lit)	# 返回一个空列表

4、将列表倒过来 reverse()方法

​ reverse()方法不是排序，只是将列表反转

lit = [2,1,3]
lit.reverse()
print(lit)	# [3,1,2]

5、对列表进行排序 sort()方法和sorted()函数

# sort()方法，默认从小到大排列，列表中的元素必须是同一种类型
lit = [5,2,7,1,3]
lit.sort()		# 升序
print(lit)	# [1, 2, 3, 5, 7]

lit.sort(reverse=True)	# 降序
print(lit)	# [7, 5, 3, 2, 1]

lit = ['b','a','c']	# 也可以排序
lit.sort(reverse=True)	
print(lit)	# ['c', 'b', 'a']

lit = ['a',1,'b']
#print(lit.sort())	# TypeError

# sorted()函数与sort()方法类似
lit = [5,2,7,1,3]
print(sorted(lit,reverse=True))	# [7, 5, 3, 2, 1]
print(lit)	# 原列表不变 

# [::-1]逆序列表中的元素
lit = [5,2,7,1,3]
print(lit[::-1])	# [3, 1, 7, 2, 5]
print(lit)	# 原列表不变

排序小结

​ 1、reverse()和sort()方法，会直接改变原列表。

​ 2、reverse()方法不是排序，只是改变列表的位置结构(对列表进行逆序)。

​ 3、sorted()函数不会改变原有的数据，而是生成一个新的列表。元组用sorted()函数会生成一个新的有序的列表。

​ 4、切片[::-1]，只是逆序打印列表中的元素。

深浅拷贝

lit = ['hello','world',[2,7]]

# 1、连个列表分割不开，lit发生改变lit1也跟着改，它们指向同一个地址
lit1 = lit 	# 这不是复制/拷贝
lit[1] = 'sunoeast'
print(lit1)		# ['hello', 'sunoeast', [2, 7]]

什么是拷贝
1、复制原列表，产生新的列表
2、两个列表完全独立开，主要针对的是改操作独立，不是读操作。

1、浅拷贝 copy()方法

​ 把列表中的不可变元素完整拷贝给新的列表，对于可变类型只拷贝内存地址。

# 1、对于不可变类型的赋值，是产生了新值，让原列表的索引指向新的内存地址，并不会影响新列表。
old_lit = ['hello','world',[2,7]]
new_lit = old_lit.copy()
old_lit[0] = 'goog'
old_lit[1] = 'morning'

print(old_lit)	# ['goog', 'morning', [2, 7]]
print(new_lit)	# 新列表值不发生改变['hello','world',[2,7]]

# 2、对于可变类型的赋值，因为新列表拷贝的是可变类型的内存地址，原列表中的内容虽然发生改变，但是它指向的内存地址是不变的。所以新列表会跟着改变
old_lit = ['hello','world',[2,7]]
new_lit = old_lit.copy()
old_lit[2][0] = 222
old_lit[2][1] = 777

print(old_lit)
print(new_lit)	# old_lit[2][0] = 222
old_lit[2][1] = 777

print(old_lit)
print(new_lit)	# ['hello', 'world', [222, 777]]

2、深拷贝 模块deepcopy()

​ 根据浅拷贝不难看出对于不可变类型是完全复制，新、旧列表之间的改操作互不影响。而对于可变类型的改操作会同步改变。深拷贝就是在浅拷贝的基础上针对可变类型的完全复制。

import copy


old_lit = ['hello', 'world', [2, 7]]
new_lit = copy.deepcopy(old_lit)

# 原列表对不可变类型的修改
old_lit[0] = 'good'
old_lit[1] = 'morning'

# 原列表对可变类型的修改
old_lit[2][0] = 222
old_lit[2][1] = 777

print(old_lit)  # ['good', 'morning', [222, 777]]
print(new_lit)  # ['hello', 'world', [2, 7]]

补充

1、队列 FIFO先进先出（first in first out)

lit = []
# 入队操作
lit.append('first')
lit.append('second')
lit.append('third')
print(lit)
# 出队操作
print(lit.pop(0))
print(lit.pop(0))
print(lit.pop(0))

2、堆栈LIFO先进后出（last in first out)

# 2、堆栈：LIFO,后进先出
lit = []
# 入栈操作
lit.append('first')
lit.append('second')
lit.append('third')

print(lit)
# 出栈操作
print(l.pop())
print(l.pop())
print(l.pop())

二、元组 tuple()（不可变序列）

1、作用

​ 元组就是一个不可变的列表，所以它相较于列表更省内存（只用读，不用写内存）。也是按照索引存放多个值的序列。

2、定义（不可变类型）

​ 多个任意类型的元素放在小（）内用逗号分隔开。只能是不可变类型，不能放嵌套的同种可变类型。

# 定义空元表
tup = ()
tup = tuple()

# 只存放一个元素必须加逗号,单独一个括号代表包含的意思。
# tup = (1,)	# 报错.放一个元素必须是可迭代对象
tup = ('1',)
tup = (1,'sunoeast')	# 存放多个元素用逗号隔开

# tup = (1,'a',2.2)代表的意思是：
# tup(索引0-->值1的内存地址，1-->值'a'的内存地址，2-->值2.2d的 内存地址)
# 所谓不可变就是变量指向的内存地址不变，只要内存地址不改变值发生改变就可以更改元组中的值。
tup = (1,[2,3])
print(id(tup[1]))

tup[1][1] = 0	# 这样的修改没有意义，只是在特殊情况。元组的意义就是读取操作，不是修改元素。
print(tup)	# (1, [2, 0])
print(id(tup([1])))

# 存放时需要注意
# tup = ([[1],2],1)	# 报错

tup = ([1,2],{'3':3})
print(type(tup))	# tuple类型

3、类型转换

result = tuple('hello world')
print(type(result))

result = tuple({'key1': 111, 'key2': 222})
print(type(result))
print(result)  # 这里for遍历的只有key，所以输出的元组也只有key

4、元组的操作

​ 元组的作用只用于读不用于改，所以元组没有修改元素的方法。元组查找元素的方法与列表类似。

1、根据索引取值

​ 根据索引操作，无论是取值操作还是赋值操作：索引不存在则报错

tup = (1,'hello','world','sunoeast',[2,3,4])
print(tup[0])	# 相应的索引取出对应的值/元素
# 1

print(tup[-1])
# [2，3，4]

# print(tup[7])	#索引不存在会报错
print(tup[-1][1])	# 列表中嵌套的取值
# 3

# 修改
# tup[0] = 2	# 修改值会报错

2、根据切片取值

# 顾头不顾尾
tup = (1, 'hello', 'world', 'sunoeast', [2, 3, 4])
print(tup[0:2])		# (1, 'hello')
print(tup[0:4:2])	# (1, 'world')
print(tup[1:7])		# 超出范围不会报错，会输出开始索引的位置及后面的所有值

print(tup[::-1])	# 只是逆序打印元组中的元素，不会修改元组。
print(id(tup[:]))	# 复制元组，元组只是为了取值，没有必要
print(id(tup))

3、元组中的查找方法 index()

​ 最好先用成员运算判断是否存在，元组中查找元素也只有index()方法，没有找到元素会报错

tup = (1,2,3,1,2,4)
print(tup.index(2))	# 返回首次找到的下标

4、统计元组中元素个数 count()方法

tup = (1,2,3,1,2,4)
print(tup.count(2))

​ 方法小结：元组只支持index()和count()方法，del语句删除整个元组。

5、利用sorted()函数创建列表

tup = (1,2,3,1,2,4)
print(sorted(tup))	# [1, 1, 2, 2, 3, 4]

6、元组中的运算符

​ 与列表类似

# 算术运算符 + *
tup = (1,2,3,1,2,4)
tup1 = (4,5)
print(tup + tup1)   # 创建新元组 (1, 2, 3, 1, 2, 4, 4, 5)

print(tup1 * 3)     # 创建新元组 (4, 5, 4, 5, 4, 5)

# 成员运算符 in、 not in
tup = (1,2,3,1,2,4)
print(2 in tup)

# 身份运算符 is、 is not
tup = (1,2,3)
tup1 = tup
print(tup1 is tup)

三、字典 dict()（可变无序）

1、作用

​ 是存储信息的一种方式。以 键-值对存储信息，键是对值的一种补充说明，所以也常用字符串做为键。键必须是不可变类型。

2、定义(可变类型，无序的容器)

​ 花括号{}内用逗号隔开多个key:value。其中value值可以是任意类型，但是key必须是唯一且不可变的类型，如果有多个同样的key，最后面的key——value会覆盖前面所有相同的键和值。

# 创建空字典
d = {}
d = dict()
# 只存放一个元素
d = {'age':18}
# 存放多个元素	方式1
d = {'name':'sunoeast','age':18}
# 快速创建字典方式2
d = dict(name='suoeast', age=18)
print(d)	# {'name': 'suoeast', 'age': 18}

# 取值：字典是无序的，取值必须根据key来取value
d = {'name':'sunoeast','age':18}
print(d['age'])	# 18

3、类型转换

# 创造字典，方式3
d = [['name', 'sunoeast'], ['age', 18], ['height', 60]]
dic = dict(d)	# dict()函数转换
print(dic)

# dict()底层原理
dic = {}
for item in d:
    # print(item)
    dic[item[0]] = item[1]
print(dic)

dic = {}
for key, value in d:  # 解压赋值：kye,value = ['name','sunoeast']
    dic[key] = value
print(dic)
# 输出结果：{'name': 'sunoeast', 'age': 18, 'height': 60}

# 创造字典，方式4：快速初始化一个字典
keys = ['name', 'age', 'height']
dic = {}
for k in keys:
    dic[k] = None
print(dic)

d = {}.fromkeys(keys, None)  # 一行代码搞定上述for循环的工作
print(d)
# {'name': None, 'age': None, 'height': None}

# 这里的值通常用不可变类型，这样可以避免值之间修改会引起的互相干扰
d = {}.fromkeys(keys,[1, 2])
d['name'] = [111, 2]	#这样会影响到age和height键所对应的值

4、字典的操作

1、按key存取值：可存可取

​ 针对赋值操作，key存在,修改为新的key——value,不存在就创建。

dic = {'name':'sunoeast'}
dic['name'] = 'jack'	# 修改
print(dic)
dic['age'] = 18		# 创建
print(dic)

2、获取字典中元素的长度 len()函数

dic = {'age':18,'k1':1,'k2':2,'k1':3}
print(dic)	# {'age': 18, 'k1': 3, 'k2': 2}
print(len(dic))	# 3

3、字典中的运算符

​ 字典中不支持算术运算符

​ in、not in与前面的列表、元组类似。不同的是字典比较的是键

dic = {'name': 'sunoeast', 'age': 18, 'height': 180}
print('name' in dic)
print(18 not in dic)
# True

​ is、is not比较的的字典中的内存id是否一样

4、删除

# 1、通用删除del语句
dic = {'name': 'sunoeast', 'age': 18, 'height': 180}
del dic['name']
print(dic)      # {'age': 18, 'height': 180}
del dic     # 删除字典

# 2、pop方法根据提供的key 取出字典中的值
dic = {'name': 'sunoeast', 'age': 18, 'height': 180}
# print(dic.pop('weight')) 如果没有对应的键会报错
result = dic.pop('name')
print(result)   # 返回取出键所对应的值:sunoeast

# 3、popitem删除，随机删除，返回元组（删除的key,删除的value)
dic = {'name': 'sunoeast', 'age': 18, 'height': 180}
result = dic.popitem()
print(result)   # 随机

5、取出字典中的元素

# 1、键keys()
dic = {'name': 'sunoeast', 'age': 18, 'height': 180}
k = dic.keys()  # 将键返回，放在列表中
print(type(k))  # <class 'dict_keys'>
print(k)
# dict_keys(['name', 'age', 'height'])

# 2、值values()
v = dic.values()    # 将值返回放在列表中
print(v)
# dict_values(['sunoeast', 18, 180])

# 3、键值对items()
i = dic.items() # 将键——值对，以元组作为元素，放在列表中
print(i)
# dict_items([('name', 'sunoeast'), ('age', 18), ('height', 180)])

6、循环

dic = {'name': 'sunoeast', 'age': 18, 'height': 180}
for k in dic.keys():
    print(k)    # 遍历所有的键

for item in dic:    # for循环遍历只能遍历字典中的键
    print(item)

for v in dic.values():  # 遍历字典中的值
    print(v)

for k, v in dic.items():    # 解压赋值:k,v = ['name':'sunoeast']
    print(k, v)

# 将上面的所有类型转换为列表打印，相当于调用了一个for循环
print(list(dic.keys()))
print(list(dic.values()))
print(list(dic.items()))

5、内置方法

1、清除字典中的所有元素 clear()方法

dic = {'name': 'sunoeast', 'age': 18, 'height': 180}
dic.clear()
print(dic)  # 空字典

2、更新字典，添加多个元素 update()方法

​ 字典中已有元素就修改它的值，没有就添加键值对

# 格式：需要添加的字典.update(字典)
dic = {'name': 'sunoeast', 'age': 18, 'height': 180}
dic1 = {'weight':60}
dic.update(dic1)    # 1、添加
print(dic)
# {'name': 'sunoeast', 'age': 18, 'height': 180, 'weight': 60}

dic.update({'age':20})  # 2、修改
print(dic)
# {'name': 'sunoeast', 'age': 20, 'height': 180, 'weight': 60}

3、get（）方法取值（容错性好）

​ 根据key取值，如果不存在就返回None，不会报错

# 格式：需要操作的字典.get(字典的键)
dic = {'name': 'sunoeast', 'age': 18, 'height': 180}
print(dic.get('name'))      # 返回键'name'对应的值
print(dic.get('hello'))    # 返回None,不报错

4、添加单个元素 setdefault(key,value)

通过setdefault(k,default)方法进行添加，参数k为指定的键，参数default为默认值。当字典中存在指定的键时，能够返回该键所对应的值；如果不存在指定的键时，则会返回参数default中设置的值，同时，在字典中会添加新元素，新元素的键即为参数k，值即为参数default

dic = {'name': 'sunoeast', 'age': 18, 'height': 180}
dic.setdefault('name', 'jack')	# 返回字典中已有的value
print(dic)  
# 有key不做任何修改：{'name': 'sunoeast', 'age': 18, 'height': 180}

dic.setdefault('weight', 60)	# 返回字典中添加的value
print(dic)
# 添加：{'name': 'sunoeast', 'age': 18, 'height': 180, 'weight': 60}

# 等同于
dic = {}
if 'name' in dic:
    ...  # 相当于pass
else:
    dic['name'] = 'sunoeast'

四、集合（可变无序）

1、作用

重点在于关系运算
​ 集合存在的目的不是为了取值，主要用于一个整体的关系运算和去重。

2、定义（可变类型，无序的容器）

与元组存放元素类似，只能存放不可变类型
​ 元素放在 {} 内用逗号隔开，可以存放多个元素。集合内的元素必须是不可变类型，集合内的元素是无序的，集合内的元素 是没有重复的。

# 定义空集合
s = set()	# 不能直接等于{}，这个是字典。
# 只存放一个元素
s = {1}
s = {1,2}	# 存放多个元素

s = {1,[2,3]}	# 集合中的元素必须是不可变的
s = {3，1，2}		# 集合中的元素是无序的
s = {1,1,2,3,2}	# 集合中的元素不能重复

3、类型转换

# 字符串、列表、元组、字典都可以转为集合
s = set('hello')
s = set([1, 2, 3])
print(s)
# s = set([1,2,3],4,5)  报错

s = set((1, 2, 3))
print(s)

print(set({'k1':1,'k2':2})) # 只能取到字典的键
# {'k1', 'k2'}

4、集合的操作

1、 关系运算

# 取出两个列表中共有的元素
number1 = ["zero","one","two","three"]
number2 = ["seven","one","four","three"]

lit = []
for i in number1:
    if i in number2:
        lit.append(i)
print(lit)

number1 = {"zero", "one", "two", "three"}
number2 = {"seven", "one", "four", "three"}

# 1、取交集：两个集合中的相同元素
# 符号 & ，方法： intersection() 。没有顺序要求。
result = number1 & number2
print(result)
result = number1.intersection(number2)
print(result)  # {'three', 'one'}

# 2、取并集/合集，去除重复后的两个集合中所有元素
# 符号 | ，方法：union() 。没有顺序要求
result = number1 | number2
print(result)
result = number1.union(number2)
print(result)

# 3、取差集，取出每个集合的独有元素
# 符号 - ，方法：difference()
# 取出number1独有的元素
result = number1 - number2  # 有顺序要求，前面的减去共有的，返回剩下的元素
print(result)
result = number1.difference(number2)
print(result)

# 4、对称差集，取出两个集合中除共有元素的所有元素
# 符号 ^ ,方法:symmetric_difference()   没有顺序要求
result = number1 ^ number2
print(result)
result = number1.symmetric_difference(number2)
print(result)

# 5、父子集，包含关系
# 符号：< 、> 、== ,方法：issuperset()、issubset()
s1 = {1, 2, 3}
s2 = {1, 2, 4}
# 不存在包含关系，下面比较均为False
print(s1 > s2)
print(s1 < s2)

s1 = {1, 2, 3}
s2 = {1, 2}
print(s1 > s2)  # 当s1大于或等于s2时，才能说是s1是s2他爹
print(s1.issuperset(s2))
print(s2.issubset(s1))  # s1 < s2  =>True

s1 = {1, 2, 3}
s2 = {1, 2, 3}
print(s1 == s2)  # s1与s2互为父子
print(s1.issuperset(s2))
print(s2.issuperset(s1))

​ 成员运算和身份运算与前面的容器一样

2 、 去重

​ 只能针对不可变类型去重，无法保证原来的顺序

print(set('hello'))

3、计算集合元素长度len()函数

s = {1,2,3}
print(len(s))	# 3

4、删除集合中元素的discard()方法

​ 相较remove()方法不会报错

s = {1,2,3}
s.discard(7)	# 不会报错，返回None

5、更新集合 update()方法

# 格式：.update(集合类型)
s = {1,2,3}
s.update({2,5})	

6、取出元素的 pop()方法

s = {1,2,3}
s.pop	# 随机取出

7、添加元素 add()方法

​ 每次只能添加一个元素

s = {1,2,3}
result = s.add(7)

8、判断集合是否完全没有交集 isdisjoint()

s = {1,2,3}
result = s.isdisjoint({3,4,5,6}) # 两个集合完全独立、没有共同部分，返回True
print(res)

​ 其他方法

s = {1,2,3}
s.difference_update({3,4,5})
print(s)
# 相当于
s=s.difference({3,4,5})
print(s)	# {1,2}

总结

可变与不可变

什么是可变：值改变，id不变，改动的值是原值，所以原值是可以被改变的。

什么是不可变：值改变，id也变了，证明是产生新的值，压根没有改变原值，证明原值是不可以被修改的

数字型、字符串、元组为不可变类型。列表、字典、集合都是可变类型。