Python容器数据类型(字典、集合)

容器类型的进阶使用(字典、集合) 字典的相关函数

函数 作用
fromkeys 批量创建键值对,并设置默认值
pop 指定键删除指定的键值对,返回指定键对应的值。
popitem 删除最后一个键值对,以元组的形式返回被删除的键值对。
clear 清空字典,返回None
update 批量更新
get 查找数据, 获取指定键的值
keys 将字典中的键组成新的可迭代对象
values 将字典中的值祖晨新的可迭代对象
items 将字典中的键值对凑成一个个元组,组成一个新的可迭代对象
fromkeys 将一个容器中的全部元素都作为字典的键,并设置默认值,批量的创建键值对
lst = ['key0', 'key1', 'key2'] dct = {}.fromkeys(lst, None) print(dct)# {'key0': None, 'key1': None, 'key2': None}

但是我们要注意一个问题,因为这些键值对的值都是来自于同一个内存地址当中的,如果我们设置的默认值是一个可变的数据类型的话,那么修改其中的一个值,所有的键值的值都会发生改变,这是灾难性的。
lst = ['key0', 'key1', 'key2'] dct = {}.fromkeys(lst, [1]) print(dct)# {'key0': [1], 'key1': [1], 'key2': [1]}# 我们只是修改了key0的值,但是整个所有使用fromkeys创建的数据全部被修改了 dct['key0'][0] = 2 print(dct)# {'key0': [2], 'key1': [2], 'key2': [2]}

所以我们一般的情况下可以设置默认值为None,因为None默认开辟一个小数据池的地址,永远不会发生变化,且None表示什么也没有,对于内存地址的占用是独一致的,当None变成任何的数据类型的时候,都不用担心其它的None也一起修改。类似的数据类型还有1、2等数字类型,这些数据类型的特点就是具有内存的缓存机制作为保护。
详情可见,内存的缓存机制。
lst = ['key0', 'key1', 'key2'] dct = {}.fromkeys(lst, None) print(dct)# {'key0': None, 'key1': None, 'key2': None}dct['key0'] = 'msr20666' print(dct)# {'key0': 'msr20666', 'key1': None, 'key2': None}

pop 通过键删除指定的键值对,如果没有该键就会报错,但是可以设置默认值,防止找不到指定键而报错。
# 指定key0键删除 dct = {'key0': None, 'key1': None, 'key2': None} dct.pop('key0') print(dct)# {'key1': None, 'key2': None}# 指定key4键删除,但是没有该键,报错 # dct.pop('key4') # error# 指定默认值,预防报错 res = dct.pop('key4', '没有该键') print(dct)# {'key1': None, 'key2': None} print(res)# 没有该键

popitem 删除最后一个键值对。
dct = {'one': 1, 'two': 2, 'three': 3} dct.popitem() print(dct)# {'one': 1, 'two': 2}

clear 清空字典
dct = {'one': 1, 'two': 2, 'three': 3} dct.clear() print(dct)# {}

update 用来批量的更新字典的键,如果这键存在就更新对应的值,如果这个键不存在,就创建一个新的键值对。
# 方式一:定义一组新的字典,然后将新字典跟新至旧的字典当中(推荐使用) dct = {'one': 1, 'two': 2, 'three': 3} new_dct = {'one': 11, 'two': 22, 'six': 666}dct.update(new_dct) print(dct)# {'one': 11, 'two': 22, 'three': 3, 'six': 666}# 方式二:在函数中直接跟着更新键值对(不推荐使用) ''' 在函数当中的直接使用关键字参数进行字典键值对的更新,关键字表示键,对应的值就是值; 缺点是关键字的命名和变量的命名是一样的,比如不能使用数字开头,那么如果字典键是整型那么就不能修改它对应的值了。 ''' dct = {1:1, 2:2, 'one':1, 'two':2}# 关键字的命名不能使用数字开头,那么就无法修改键是整型的键值对 # 所以这也是推荐是按照变量名的标准去命名键名的原因之一 # dct.update(1=1)# errordct.update(one=11) print(dct)# {1: 1, 2: 2, 'one': 11, 'two': 2}# 可以一次性修改多个值 dct.update(one=111, two=22, three=33) print(dct)# {1: 1, 2: 2, 'one': 111, 'two': 22, 'three': 33}

get 查找数据,指定一个键获取对应的值
dct = {'one': 1, 'two': 2, 'three': 3}# 指定键获取数据 res = dct.get('one') print(res)# 1# 如果没有这个键,就返回None res = dct.get('six') print(res)# None# 可以设置默认值,如果查不到数据就返回设置的默认值 res = dct.get('six', '没有找到这个键') print(res)# 没有找到这个键# 也可以直接指定键来查看对应的数据,但是如果没有这个键就会直接报错 # res = dct['six']# error 找不到该数据

keys 将字典的键组成一个叫做dict_keys的可迭代对象,这是一个特殊的数据类型,可以强转成为其它的数据类型。
dct = {'one': 1, 'two': 2, 'three': 3}res = dct.keys()print(res)# dict_keys(['one', 'two', 'three']) print(type(res))#

values 将字典中的值组成一个叫做dict_values的可迭代对象当中,也是可以强转成其它的容器数据类型。
dct = {'one': 1, 'two': 2, 'three': 3}res = dct.values()print(res)# dict_values([1, 2, 3]) print(type(res))#

items 将字典中的键值对凑成一个个的元组,组成叫做dict_items的可迭代对象中。
dct = {'one': 1, 'two': 2, 'three': 3}res = dct.items()print(res)# dict_items([('one', 1), ('two', 2), ('three', 3)]) print(type(res))#

集合的相关函数
函数 作用
add 向集合中添加数据,一次只能添加一个, 返回None
update 向集合中迭代添加数据,一次可以添加多个,返回None
pop 随机删除集合中的一个数据,返回被删除的值
remove 删除集合中指定的一个值,如果这个值不存在就报错,返回None
discard 删除集合中指定的一个值,如果这个值不存在也不会报错,返回None
clear 清空集合
intersection 返回交集
difference 返回差集
union 返回并集
symmetric_difference 返回对称差集或者是补集
issuperset 判断是否是指定集合的父集
issubset 判断是否是指定集合的子集
isdisjoint 判断两个集合是否不相交()
frozenset 将容器强转成为冰冻集合类型
集合的增删改查 【Python容器数据类型(字典、集合)】集合是无序数据,因此不能进行查找和修改操作;
add 往集合中单个的添加数据
setvar = {1, 2, 3, 'hello', 'msr', 'msr20666'} setvar.add('motherland') print(setvar)# {1, 2, 3, 'motherland', 'hello', 'msr20666', 'msr'}

update 迭代的添加数据
setvar = {1, 2, 3, 'hello', 'msr', 'msr20666'} lst = ('china', 'america', 'russia') setvar.update(lst) print(setvar)# {1, 2, 3, 'msr', 'america', 'russia', 'china', 'hello', 'msr20666'}

pop 随机的删除其中的一个数据
setvar = {1, 2, 3, 'hello', 'msr', 'msr20666'} setvar.pop() print(setvar)# {2, 3, 'msr', 'msr20666', 'hello'}

remove 删除集合中指定的一个值,如果这个值不存在,就会报错
setvar = {1, 2, 3, 'hello', 'msr', 'msr20666'} setvar.remove('hello') print(setvar)# {1, 2, 3, 'msr', 'msr20666'}setvar.remove(4)# error,这个值不存在

discard 删除集合中指定的一个值,如果这个值不存在也不会报错
setvar = {1, 2, 3, 'hello', 'msr', 'msr20666'} setvar.discard('hello') print(setvar)# {1, 2, 3, 'msr20666', 'msr'}res = setvar.discard(4) print(res)# None

clear 清空集合
setvar = {1, 2, 3, 'hello', 'msr', 'msr20666'} setvar.clear() print(setvar)# set()

集合的交叉并补 Python容器数据类型(字典、集合)
文章图片

intersection 交集,就是两个集合中相同的数据,两个集合的交集是相同的,简写 &
set0 = {1, 2, 3, 4, 5, 6} set1 = {1, 2, 3, 7, 8, 9, 0}res = set0.intersection(set1) print(res)# {1, 2, 3}res = set1 & set0 print(res)# {1, 2, 3}

difference 差集,差集就是两个集合当中不相同的数据,注意两个集合中的差集是不同的,简写 -
set0 = {1, 2, 3, 4, 5, 6} set1 = {1, 2, 3, 7, 8, 9, 0}res = set0.difference(set1) print(res)# {4, 5, 6}res = set1 - set0 print(res)# {0, 8, 9, 7}

union 并集,是两个集合的所有数据,但是交集部分只会存在一个,两个集合的并集是相同的,简写使用 |
set0 = {1, 2, 3, 4, 5, 6} set1 = {1, 2, 3, 7, 8, 9, 0}res = set0.union(set1) print(res)# {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}res = set1 | set0 print(res)# {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

symmetric_difference 对称差集,是两个集合中除去并集的数据,就是两者的差集,两者的对称差集是相同的,简写使用 ^
set0 = {1, 2, 3, 4, 5, 6} set1 = {1, 2, 3, 7, 8, 9, 0}res = set0.symmetric_difference(set1) print(res)# {0, 4, 5, 6, 7, 8, 9}res = set1 ^ set0 print(res)# {0, 4, 5, 6, 7, 8, 9}

补集,如果两个集合,其中的一个集合包含另一个集合的所有数据,那么这个集合就是另一个集合的父集,反之就是子集,父集当中子集不存在的数据就是子集的补集
set0 = {1, 2, 3, 4, 5, 6, 7, 8} set1 = {1, 2, 3, 4}res = set0.symmetric_difference(set1) print(res)# {8, 5, 6, 7}res = set1.symmetric_difference(set0) print(res)# {5, 6, 7, 8}

issuperset 判断是否是指定集合的父集,返回布尔值,简写使用 > 或者 =+
set0 = {1, 2, 3, 4, 5, 6, 7, 8} set1 = {1, 2, 3, 4}res = set0.issuperset(set1) print(res)# Trueres = set1 > set0 print(res)# Falseres = set1 >= set0 print(res)# False

issubset 判断是否是指定集合的子集,返回布尔值,简写使用 < 或者 <=
set0 = {1, 2, 3, 4, 5, 6, 7, 8} set1 = {1, 2, 3, 4}res = set0.issubset(set1) print(res)# Falseres = set1 < set0 print(res)# Trueres = set1 <= set0 print(res)# True

isdisjoint 检测两个集合是否不相交
set0 = {1, 2, 3, 4, 5, 6, 7, 8} set1 = {1, 2, 3, 4} res = set0.isdisjoint(set1) print(res)# Falseset0 = {1, 2, 3} set1 = {4, 5, 6} res = set0.isdisjoint(set1) print(res)# True

冰冻集合 冰冻集合可以理解为将集合冰冻封印,这样集合不能进行添加删除元素等操作,只能进行交叉并补的操作。
setvar = {1, 2, 3, 4} lstvar = [1, 2, 3, 4, 5]fzs0 = frozenset(setvar) print(fzs0)# # frozenset({1, 2, 3, 4}) print(type(fzs0))# fzs1 = frozenset(lstvar) print(fzs1)# frozenset({1, 2, 3, 4, 5}) print(type(fzs1))#

冰冻集合不能进行增删改查的操作
fzs0.clear()# error

可以进行关于交叉并补的操作
res = fzs0.issuperset(fzs1) print(res)# False

冰冻集合没有解冻的方法,但是可以转换成为其它的数据类型,比如使用set函数将冰冻集合变成普通的集合。
lst = set(fzs1) print(setvar)

集合交叉并补的简写为什么是运算符 简单的来说,交叉并补和位运算的本质都是一样的。
交叉并补 位运算 符号 相同之处
交集 按位与 & 两者之间共同存在的保留下来
并集 按位或 \ 两者之间的全部保留下来
对称差集 按位异或 ^ 除了都有的,其它的保留下来

    推荐阅读