1.13 Python基础知识 - 字典和集合

一、字典

　　字典是一组键-值对的数据结构。每个键对应一个值。在字典中，键不能重复。根据键可以查询到值。字典是键和值的映射关系

　　字典的定义：

　　字典通过花括号中用逗号分隔的元素（键-值。键-值对使用冒号分隔），格式如下：

{键1：值1,[键2:值2,...,键n:值n]}
 
# 值可以为任意对象。字典中的键是唯一的，不能重复。

　　字典也可以通过创建dict对象来创建，格式如下：

# 创建一个空字典
dict()
 
# 使用关键字参数，创建一个新的字典
dict(**kwargs)
 
# 从一个字典对象创建一个新的字典
dict(mapping)
 
# 使用序列，创建一个新的字典
dict(iterable)

　　

　　1、字典的访问操作，基本格式：

# 返回键为key的value；如果ket不存在，则导致KeyError
d[key]
 
# 设置d[key]的值为value；如果key不存在，则添加键/值对
d[key]=value
 
# 删除字典元素；如果ket不存在，则导致KeyError
del d[key]

　　2、动态访问字典的数据

　　d.keys：返回字典d的键key的列表

　　d.values：返回字典d的值values的列表

　　d.items()：返回字典d的（key，value）对的列表

　　3、判断字典键是否存在

　　# 如果为True，则表示存在

　　key in d

　　# 如果为True，则表示不存在

　　key not in d

　　

　　4、字典对象的方法

　　我们定义一个字典：

　d = {1:'food',2:'drink',3:'fruit'}
　　

# 删除所有元素
d.clear()
print(d)
 
# 输出结果
 
{}

# 浅拷贝字典
d1 = d.copy()
print(d)
print(d1)
 
# 输出结果
 
{1: 'food', 2: 'drink', 3: 'fruit'}
{1: 'food', 2: 'drink', 3: 'fruit'}

#返回键k对应的值，如果key不存在，返回None
print(d.get(1))
print(d.get(5))
 
# 输出结果
 
food
None

#返回键k对应的值，如果key不存在，返回v
print(d.get(1,'无'))
print(d.get(5,'无'))
 
# 输出结果
 
food
无

# 如果键k存在，返回其值，并删除该元素；否则导致KeyError
print(d.pop(1))
print(d)
 
# 输出结果

food
{2: 'drink', 3: 'fruit'}

# 如果键k存在，返回其值，并删除该元素；否则返回v
print(d.pop(5,'无'))
print(d)
 
# 输出结果
 
无
{1: 'food', 2: 'drink', 3: 'fruit'}

# 如果键k存在，返回其值；否则添加元素k=v,v默认为None
print(d.setdefault(1))
 
print(d.setdefault(4))
print(d)
 
# 输出结果
 
food
None
{1: 'food', 2: 'drink', 3: 'fruit', 4: None}

# 使用字典或键值对，更新或添加元素到字典d
d1 = {1:'食物',4:'书籍'}
d.update(d1)
print(d)
 
# 输出结果
 
{1: '食物', 2: 'drink', 3: 'fruit', 4: '书籍'}

二、集合

　　集合数据类型是没有顺序的简单对象的聚合，且集合中元素不重复。

　　集合的定义：花括号中用逗号分隔元素进行定义的，格式如下：

　　{x1,[x2,...,xn]}

　　也可以通过set对象方法创建集合，格式如下：

　　set()：创建一个空的集合

　　set(iterable)：创建一个集合，包含的元素为可枚举对象iterable中的元素

　　1、判断集合元素是否存在

　　　　判断一个元素x是否在集合s中，方法如下：

　　　　x in s ：如果为True，则表示存在

　　　　x in not s ：如果为True，则表示不存在

s  = set('hello')
 
print('h' in s )
 
print('H' not in s)
 
# 输出结果
 
True
True

　　2、集合的运算：并集、交集、差集和对称差集

　　　　1）并集

s1 = {1,2,3}
s2 = {2,3,4}
 
# 对象方法
print(s1.union(s2))
 
# 运算符方法
print(s1 | s2)
 
# 输出结果
 
{1, 2, 3, 4}
{1, 2, 3, 4}

　　　　2）交集

s1 = {1,2,3}
s2 = {2,3,4}
 
# 对象方法
print(s1.intersection(s2))
 
# 运算符方法
print(s1 & s2)
 
#输出结果
 
{2, 3}
{2, 3}

　　　　3）差集

s1 = {1,2,3}
s2 = {2,3,4}
 
# 对象方法
print(s1.difference(s2))
 
#运算符方法
print(s1 - s2)
 
#输出结果
 
{1}
{1}

　　　　4）对称差集

s1 = {1,2,3}
s2 = {2,3,4}
 
# 对象方法
print(s1.symmetric_difference(s2))
 
#运算符方法
print(s1 ^ s2)
 
# 输出结果
 
{1, 4}
{1, 4}

　　

　　3、集合的比较运算：相等、子集和超集（又称父集）

　　　　1）相等

s1 = {1,2,3}
s2 = {2,3,4}
 
print(s1 == s2)
print(s1 != s2)
 
# 输出结果
False
True

　　　　2）子集

s1 = {1,2,3}
s2 = {3,2,1}
s3 = {1,2}
s4 = {7,9}
 
# 对象方法
print(s3.issubset(s1))
 
# 运算符方法
print(s3 < s1)
 
输出结果
True
True

　　　　3）超集

s1 = {1,2,3}
s2 = {3,2,1}
s3 = {1,2}
s4 = {7,9}
 
# 对象方法
print(s2.issuperset(s3))
 
#运算符方法
print(s2 > s3)
 
#输出结果
True
True

　　4、集合的其他方法

　　　　1）更新

s1 = {1,2,3}
s2 = {2,3,4}
 
s1.update(s2)
print(s1)
 
# 输出结果
{1, 2, 3, 4}

　　　　2）添加

s1 = {1,2,3}
 
s1.add('a')
print(s1)
 
# 输出结果
{1, 2, 3, 'a'}

　　　　3）删除

　　　　　　remove

s1 = {1,2,3}
 
# 从集合中删除元素1，若不存在，则导致KeyError
s1.remove(1)
print(s1)
 
#输出结果
{2, 3}

　　　　　　discard

s1 = {1,2,3}
 
# 从集合中删除元素3，若不存在，不做任何操作
s1.discard(3)
 
print(s1)
 
#输出结果
{1, 2}

　　　　　　pop

s1 = {1,2,3}
 
# 从集合中随机弹出一个元素，如果s为空，则导致KeyError
s1.pop()
 
print(s1)
 
#输出结果
{2, 3}