一、字典对象方法
1、keys/values/items
dict.keys():获取字典dict中的所有键，并以列表形式存放，返回视图；
dict.values():获取字典dict中的所有值，并以列表形式存放，返回视图；
dict.items():获取字典dict中的所有键值对，并以元组形式放在一起，以列表形式存放，返回视图；
# 例如
dict1 = {'姓名': 'Lisa', '年龄': 18, '性别': '女'}
print(dict1.keys())
print(dict1.values())
print(dict1.items())
print(type(dict1.keys()))
print(type(dict1.values()))
print(type(dict1.items()))
# 终端输出
dict_keys(['姓名', '年龄', '性别'])
dict_values(['Lisa', 18, '女'])
dict_items([('姓名', 'Lisa'), ('年龄', 18), ('性别', '女')])
<class 'dict_keys'> # type类型为视图
<class 'dict_values'> # type类型为视图
<class 'dict_items'> # type类型为视图
可以发现，这三者输出的结果均为视图，视图是一个类方法，当原数据发生改变的时候，视图也会实时更新，视图是可迭代对象；
# 例如
dict1 = {'姓名': 'Lisa', '年龄': 18, '性别': '女'}
res = dict1.keys()
res1 = dict1.values()
res2 = dict1.items()
print(res)
print(res1)
print(res2)
dict1['身高'] = 170
print(dict1)
print(res)
print(res1)
print(res2)
# 终端显示
dict_keys(['姓名', '年龄', '性别'])
dict_values(['Lisa', 18, '女'])
dict_items([('姓名', 'Lisa'), ('年龄', 18), ('性别', '女')])
{'姓名': 'Lisa', '年龄': 18, '性别': '女', '身高': 170}
dict_keys(['姓名', '年龄', '性别', '身高']) # 实时更新
dict_values(['Lisa', 18, '女', 170]) # 实时更新
dict_items([('姓名', 'Lisa'), ('年龄', 18), ('性别', '女'), ('身高', 170)]) # 实时更新
2、get
dict.get(key,default =None):返回指定键key对应的值，如果该key不存在，则返回default的值，默认为None；
# 例如
dict1 = {'姓名': 'Lisa', '年龄': 18, '性别': '女'}
print(dict1.get('性别'))
print(dict1.get('爱好'))
print(dict1.get('爱好', '不存在')) # 指定default = '不存在'
# 终端显示
女
None
不存在
3、update
dict1.update([other])：使用来自other的字典键值对更新原字典dict1,如若键相同，则覆盖掉原数据，other为包含键值对的可迭代对象；
# 例如
dict1 = {'姓名': 'Lisa', '年龄': 18, '性别': '女'}
dict1.update(dict(zip(['爱好'], ['无'])))
print(dict1)
dict1.update(dict(头发 = '长发'))
print(dict1)
dict1.update(dict([('身高', '170')]))
print(dict1)
dict1.update(dict(年龄 = 20))
print(dict1)
# 终端显示
{'姓名': 'Lisa', '年龄': 18, '性别': '女', '爱好': '无'}
{'姓名': 'Lisa', '年龄': 18, '性别': '女', '爱好': '无', '头发': '长发'}
{'姓名': 'Lisa', '年龄': 18, '性别': '女', '爱好': '无', '头发': '长发', '身高': '170'}
{'姓名': 'Lisa', '年龄': 20, '性别': '女', '爱好': '无', '头发': '长发', '身高': '170'}
注意：如果update的other中，键值对在原dict中存在，则会替换掉原dict中对应的值，如果不存在，则会在原dict中新增；
4、pop
dict.pop(key[,default]):移除键对应的键值对，并返回键对应的值，default为找不到时返回的值；如果不传default，则在找不到该键时会报错KeyError;
# 例如
dict1 = {'姓名': 'Lisa', '年龄': 18, '性别': '女'}
print(dict1.pop('姓名'))
print(dict1.pop('姓名', '不存在'))
print(dict1.pop('姓名'))
# 终端显示
Lisa
不存在
KeyError: '姓名'
5、popitem
dict.popitem():移除最后一对键值对，并以元组的形式返回他们；
# 例如
dict1 = {'姓名': 'Lisa', '年龄': 18, '性别': '女'}
res = dict1.popitem()
print(res)
dict2 = {}
res1 = dict2.popitem()
print(res1)
# 终端显示
('性别', '女')
KeyError: 'popitem(): dictionary is empty' # 如果字典已经为空，则报错
6、setdefault
dict.setdefault(key,default = None):如果key存在，则返回key的值如果key不存在，则在dict中加入名为key的键，其值default默认为空;
# 例如
dict1 = {'姓名': 'Lisa', '年龄': 18, '性别': '女'}
res = dict1.setdefault('姓名')
print(res)
res1 = dict1.setdefault('爱好')
print(res1)
print(dict1)
res2 = dict1.setdefault('兴趣', '读书')
print(res2)
print(dict1)
# 终端显示
Lisa
None
{'姓名': 'Lisa', '年龄': 18, '性别': '女', '爱好': None}
读书
{'姓名': 'Lisa', '年龄': 18, '性别': '女', '爱好': None, '兴趣': '读书'}
7、copy
dict.copy():复制一个新的字典；
8、clear
dict.clear():清空字典中所有数据；
二、集合
1、set
集合(Set)是可变的；
集合与字典均用{}表示，空集合用set()表示；
集合中不能存放可变元素，集合中的元素中也不能包含可变元素；
集合中元素是无序的，且不会重复；
# 例如
set1 = {'a', 'b', 'c', 1, 2, 3, 'b', 'c'}
print(set1)
# 终端显示
{1, 2, 3, 'b', 'c', 'a'}
2、frozenset
frozenset为冻结集合，与set相对应，frozenset是不可变集合；
frozenset([iterable]):除不可变外具有set的其他特性，即在集合set中可以插入冻结集合frozenset;
3、集合关系测试
# 例如
a = set("abdefga")
b = set("abc")
c = set("aef")
print(c >= a) # 判断c是否是a的父集
print(c <= a) # 判断c是否是a的子集
print(a - b) # 返回a和b的差集
print(a | b) # 返回a和b的并集
print(a & b) # 返回a和b的交集
print(a ^ b) # 返回a和b中不同时存在的元素（对称差）
print(a | b | c)
print(a ^ b ^ a) # 返回b本身
print(a ^ a ^ b) # 返回b
# 终端显示
False
True
{'d', 'g', 'f', 'e'}
{'c', 'g', 'a', 'e', 'f', 'b', 'd'}
{'b', 'a'}
{'c', 'g', 'e', 'f', 'd'}
{'c', 'g', 'e', 'a', 'f', 'b', 'd'}
{'c', 'a', 'b'}
{'b', 'c', 'a'}
三、集合对象方法
1、set和frozenset都适用的方法
(1)isdisjoint
set.isdisjoint(other):判断两个集合是否不相交，other必须是可迭代对象，当other不是集合时，判断other中元素是否相交，当两者相交时返回False，当两者不相交的时候返回True；
# 例如
a = set("abdefga")
b = set("abc")
c = 'adji' #字符串
d = ['a', 's', 'h'] # 列表
e = ('m', 'n') # 元组
f = {'一': 1, '二': 2} # 字典
print(a.isdisjoint(b))
print(a.isdisjoint(c))
print(a.isdisjoint(d))
print(a.isdisjoint(e))
print(a.isdisjoint(f))
# 终端显示
False
False
False
True
True
(2)issubset / issuperset
set.issubset(other):判断集合set是否为可迭代变量other的子集，返回bool值；
set.issuperset(other):判断集合set是否为可迭代变量other的父集，返回bool值；
# 例如
set1 = set("abcdefga")
set2 = set("abc")
print(set1.issubset(set2))
print(set1.issuperset(set2))
# 终端显示
False
True
注意： 此处other可以是任何可迭代对象，参考isdisjoint效果；
(3)union / intersection / difference / symmetric_difference
set.union(*others):求set与多个可迭代对象others的并集，并返回一个新的集合；
set.intersection(*others):求set与多个可迭代对象others的交集，并返回一个新的集合；
set.difference(*others):求set与多个可迭代对象others的差集，并返回一个新的集合；
set.symmetric_difference(others):求set与多个可迭代对象others的对称差集，并返回一个新的集合；
# 例如
set1 = set("abdefga")
set2 = set("abc")
set3 = 'adji'
set4 = ['a', 's', 'h']
set5 = ('m', 'n')
set6 = {'一': 1, '二': 2}
print(set1.union(set4, set5))
print(set1.intersection(set2, set3))
print(set2.difference(set3, set4))
print(set1.symmetric_difference(set2))
# 终端显示
{'e', 'a', 'm', 'n', 'f', 'g', 'h', 's', 'd', 'b'}
{'a'}
{'c', 'b'}
{'f', 'e', 'c', 'g', 'd'}
注意：(*others)是不定长参数，即可以是多个可迭代对象；
(4)copy
set.copy():复制并返回一个集合；
# 例如
set1 = set("abdefga")
set2 = set1.copy()
print(set2)
# 终端显示
{'g', 'd', 'e', 'a', 'b', 'f'}
2、只有set适用的对象方法（inplace操作）
(1)update
set.update(*others):更新集合，添加来自可迭代对象others中的元素，因为集合有去重功能，因此update还有求并集的作用；
# 例如
set1 = set("abdefga")
set2 = set("abc")
# 终端显示
{'c', 'b', 'f', 'd', 'j', 'e', 'g', 'i', 'a'}
(2)intersection_update / difference_update / symmetric_difference_update
set.intersection_update(*others):更新集合，只保留在其他所有集合中共有的部分，即求交集；
# 例如
set1 = set("abdefga")
set2 = set("abc")
set3 = 'adji'
set1.intersection_update(set2, set3)
print(set1)
# 终端显示
{'a'}
set.difference_update(*others):更新集合，移除在其他元素中出现的部分，即求差集；
# 例如
set2 = set("abc")
set3 = 'adji'
set4 = ['a', 's', 'h']
set2.difference_update(set3, set4)
print(set2)
# 终端显示
{'c', 'b'}
set.symmetric_difference_update(others):更新集合，只保留存在于一方而非共同存在的元素，即求对称差（并集-交集）；
# 例如
set1 = set("abdefga")
set2 = set("abc")
set1.symmetric_difference_update(set2)
print(set1)
# 终端显示
{'f', 'g', 'd', 'e', 'c'}
(3)add
set.add(elem):将元素elem添加到集合中，如果elem已经存在，则无影响；
# 例如
set2 = set("abc")
set2.add("abc")
print(set2)
set2.add("abc")
print(set2)
# 终端显示
{'a', 'b', 'abc', 'c'}
{'a', 'b', 'abc', 'c'}
(4)remove / discard / pop / clear
set.remove(elem):移除元素elem,如果该元素不存在，会报错Key Error;
# 例如
set1 = {"ab,", 123, 4, ('xyz', 123)}
set1.remove(4)
print(set1)
set1.remove(5)
# 终端显示
{123, 'ab,', ('xyz', 123)}
KeyError: 5 # 结果报错
set.discard(elem):移除元素elem,如果该元素不存在，不会报错，无任何操作;
# 例如
set1 = {"ab,", 123, 4, ('xyz', 123)}
set1.discard(123)
print(set1)
set1.discard(5)
# 终端显示
{4, 'ab,', ('xyz', 123)}
{4, 'ab,', ('xyz', 123)} # 结果无报错，且无任何操作
set.pop():移除任意一个元素并返回，如果集合为空，则报错；
# 例如
set1 = {"ab,"}
res = set1.pop()
print(res)
print(set1)
res1 = set1.pop()
print(res1)
print(set1)
# 终端显示
ab,
set()
KeyError: 'pop from an empty set' # 当集合为空时报错
set.clear():清空集合；
# 例如
set1 = {"ab,", 123, 4, ('xyz', 123)}
set1.clear()
print(set1)
# 终端显示
set()
四、总结
六种标准数据类型是否可变、是否可迭代、是否序列；
| 类型 | 是否可迭代 | 是否序列 | 是否可变 |
|---|---|---|---|
| 数字（Number） | 否 | 否 | 否 |
| 字符串（String） | 是 | 是 | 否 |
| 列表（List） | 是 | 是 | 是 |
| 元组（Tuple） | 是 | 是 | 否 |
| 字典（Dictionary） | 是 | 否 | 是 |
| 集合（Set） | 是 | 否 | 是 |
417
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
