乐趣区

关于python: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)   # 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 向汇合中增加数据,一次只能增加一个,返回 None
update 向汇合中迭代增加数据,一次能够增加多个,返回 None
pop 随机删除汇合中的一个数据,返回被删除的值
remove 删除汇合中指定的一个值,如果这个值不存在就报错,返回 None
discard 删除汇合中指定的一个值,如果这个值不存在也不会报错,返回 None
clear 清空集合
intersection 返回交加
difference 返回差集
union 返回并集
symmetric_difference 返回对称差集或者是补集
issuperset 判断是否是指定汇合的父集
issubset 判断是否是指定汇合的子集
isdisjoint 判断两个汇合是否不相交()
frozenset 将容器强转成为冰冻汇合类型

汇合的增删改查

汇合是无序数据,因而不能进行查找和批改操作;

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)

汇合穿插并补的简写为什么是运算符

简略的来说,穿插并补和位运算的实质都是一样的。

穿插并补 位运算 符号 相同之处
交加 按位与 & 两者之间独特存在的保留下来
并集 按位或 \ 两者之间的全副保留下来
对称差集 按位异或 ^ 除了都有的,其它的保留下来
退出移动版