容器类型的进阶使用（字典、集合）

字典的相关函数

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)   # error

dct.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))    # <class \'dict_key

values

将字典中的值组成一个叫做dict_values的可迭代对象当中，也是可以强转成其它的容器数据类型。

dct = {\'one\': 1, \'two\': 2, \'three\': 3}

res = dct.values()

print(res)          # dict_values([1, 2, 3])
print(type(res))    # <class \'dict_values\'>

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))    # <class \'dict_items\'>

集合的相关函数

集合的增删改查

集合是无序数据，因此不能进行查找和修改操作；

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()

集合的交叉并补

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)  # True

res = set1 > set0
print(res)  # False

res = 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)  # False

res = set1 < set0
print(res)  # True

res = 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)  # False


set0 = {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))   # <class \'frozenset\'>

fzs1 = frozenset(lstvar)
print(fzs1)         # frozenset({1, 2, 3, 4, 5})
print(type(fzs1))   # <class \'frozenset\'>

冰冻集合不能进行增删改查的操作

fzs0.clear()        # error

可以进行关于交叉并补的操作

res = fzs0.issuperset(fzs1)
print(res)              # False

冰冻集合没有解冻的方法，但是可以转换成为其它的数据类型，比如使用set函数将冰冻集合变成普通的集合。

lst = set(fzs1)
print(setvar)

集合交叉并补的简写为什么是运算符

简单的来说，交叉并补和位运算的本质都是一样的。

来源：https://www.cnblogs.com/msr20666/p/15998266.html
本站部分图文来源于网络，如有侵权请联系删除。