一、字典

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

  字典的定义:

  字典通过花括号中用逗号分隔的元素(键-值。键-值对使用冒号分隔),格式如下:

{键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}