【漫漫转码路】Python Day 05

一、字典对象方法

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）	是	否	是