Python中的字典和集合_python怎么区分集合和字典

1. 字典（dict）

字典（dict,全称： dictionary ）是python内置的一种使用“键值对结构”存储数据的存储模型。在其它语言中也称为map或者是object(对象)

1.1 字典的操作

• 创建/查询/修改字典

  # 创建字典：变量名 = {键1：值1，键2：值2，……}
  d = {'kendny': 99, 'Mary': 88}
  # 添加数据：变量名[键] = 值	（字典中没有对应的键）
  d['Tom'] = 87	
  # 获取数据：	 变量名[键]
  d['kendny'] # 或 d.kendny
  # 修改数据：变量名[键] = 值	（字典中存在对应的键）
  d['kendny'] = 100
  
  # 通过键名取字典的值， 如果键名不存在， 就会报错； 通常可以通过 in或者get()方法判断键是否存在
  if 'Thomas' in d:
      value = d['Thomas']
      
   # 或者
  value = d.get('Thomas'); # 不存在value什么值都没有
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15

• 常见操作字典的函数

1.2 字典的特点

• 字典不具备索引的概念，但可以通过字典的键key操作字典中存储的数据值value
• 字典（dict）内部存放的顺序和键key放入的顺序是没有关系的。
• 字典可以根据键（key）进行数据的添加、删除、修改、查询等操作
• 字典通过键（key）计算位置的算法称为哈希算法（Hash）
• 要保证hash的正确性， 作为key的对象就不能变。 在Python中， 字符串、整数等不可变类型的数据可作为 字典的键
• 字典的key是唯一的且必须是不可变的类型（对象）， 如纯元素可以作为字典的key

*为什么字典dict*查找速度这么快？

因为dict的实现原理和查字典是一样的。假设字典包含了1万个汉字，我们要查某一个字，一个办法是把字典从第一页往后翻，直到找到我们想要的字为止，这种方法就是在list中查找元素的方法，list越大，查找越慢。

第二种方法是先在字典的索引表里（比如部首表）查这个字对应的页码，然后直接翻到该页，找到这个字。无论找哪个字，这种查找速度都非常快，不会随着字典大小的增加而变慢。

总结： 字典的查找方式就是第二种， 字典在内部可以直接通过键key直接计算出对应的存放值的内存地址， 直接取出来， 所以速度非常快。

2 集合（set）

集合（set）是python内置的一种存储无序不重复数据的数据存储模型

2. 1 集合的操作

• 创建集合

  s = {1, 2, 3} # 创建集合
  1

  集合是无序不重复数据的数据存储模型，它没有索引的概念，集合中的数据可以进行添加、删除等操作；

• 常见集合的函数

  函数	说明	实例
  len(s)	获取集合中元素的个数	len(s)
  s.add(data)	向集合s中添加数据data	s.add(4)
  s.remove(data)	从集合中删除指定的数据， 如果数据不存在将报错	s.remove(2)
  s.discard(data)	删除集合中的data元素， 若data不存在，什么都不做	s.remove(22)
  s.pop()	从集合中删除字典的第一个元素并返回（不需要参数）	s.pop()
  s.clear()	清空集合中的数据	s.clear()
  s.copy()	复制集合	ns=s.copy()
  s1.difference(s2)	计算2个集合的差集(在s1中， 但不在s2中)
  s1.union(s2)	计算2个集合的并集``
  s1.intersection(s2)	计算2个集合的交集

• 集合中的其它操作

  s = {1, 2, 3}
  >>> 2 in s    #True 集合的成员检测
  >>> {'*' + i '*' for i in s} # 集合推导式
  >>> {i for i in s if i>1} # 带有条件的集合推导式
  
  # 多循环集合推导式
  >>>colors = {'red','blue','pink'}
  >>>sizes = {36,37,38,39}
  >>>result = {c + str(s) for c in colors for s in sizes}
  print(result)
  
  #difference() 计算2个集合的差集
  dreamers = {'ljl','wc','xy','zb','lsy'}
  girls = {'mmf','lsy','syj'}
  result = dreamers.difference(girls)# result = a + b
  print(result)
  
  #difference_update()  计算2个集合的差集(差集更新操作)
  dreamers = {'ljl','wc','xy','zb','lsy'}
  girls = {'mmf','lsy','syj'}
  dreamers.difference_update(girls)#a = a + b  a += b
  print(dreamers)
  
  #union()  并集操作
  dreamers = {'ljl','wc','xy','zb','lsy'}
  girls = {'mmf','lsy','syj'}
  result = dreamers.union(girls)
  print(result)
  
  #update()  并集更新操作
  dreamers = {'ljl','wc','xy','zb','lsy'}
  girls = {'mmf','lsy','syj'}
  dreamers.update(girls)
  print(dreamers)
  
  #intersection()  计算2个集合的交集
  dreamers = {'ljl','wc','xy','zb','lsy'}
  girls = {'mmf','lsy','syj'}
  result = dreamers.intersection(girls)
  print(result)
  
  #intersection_update  交集更新操作
  dreamers = {'ljl','wc','xy','zb','lsy'}
  girls = {'mmf','lsy','syj'}
  dreamers.intersection_update(girls)
  print(dreamers)
  
  #超集和子集
  boys = {'zzy','yqw','dw','wzc','lyb','wym','chy'}
  zoudu = {'wzc','lyb','wym'}
  girls = {'lsy','mmf','syj'}
  
  #issuperset()  检测当前集合是否是另一个集合的超集
  result = boys.issuperset(zoudu)
  print(result)
  
  #issubset()  检测当前集合是否是另一个集合的子集
  result = zoudu.issubset(boys)
  print(result)
  
  #isdisjoint()  检测2个集合是否不存在交集  存在交集 False
  result = boys.isdisjoint(girls)
  print(result)
  
  #symmetric_difference()  对称差集
  dreamers = {'ljl','wc','xy','zb','lsy'}
  girls = {'mmf','lsy','syj'}
  result = dreamers.symmetric_difference(girls)
  print(result)
  
  #symmetric_difference_update()  对称更新差集
  dreamers = {'ljl','wc','xy','zb','lsy'}
  girls = {'mmf','lsy','syj'}
  dreamers.symmetric_difference_update(girls)
  print(dreamers)
  
  #冰冻集合
  #冰冻集合是一种特殊的集合类型,也是集合(集合是列表的话,冰冻集合就是元组)
  #创建冰冻集合
  #一般不会创建空的冰冻集合
  var = frozenset()
  print(var,type(var))
  
  #带有数据的冰冻集合
  var = frozenset(('qs','szx','bjh','acs'))
  print(var,type(var))
  
  #成员检测
  result = 'szx' in var
  print(result)
  
  #遍历冰冻集合
  for i in var:
      print(i)
  
  #集合推导式(无法得到冰冻集合,可以得到集合,列表,元组,字典类型)
  result = {i for i in var}
  print(result,type(result))
  
  #函数
  #冰冻集合可以使用集合的函数(不修改集合本身的函数都可以使用)
  var = frozenset(('qs','szx','bjh','acs'))
  
  #copy()
  result = var.copy()
  print(result)
  
  #集合操作  交集,并集,差集,对称差集等  不修改冰冻集合本身就能使用:冰冻集合的操作结果都是冰冻集合
  var1 = frozenset(('qs','szx','bjh','acs'))
  var2 = {'szx','bjh','lc','wb'}
  
  #冰冻集合操作
  result = var1.union(var2)
  print(result)
  
  #普通集合操作(冰冻集合是参考集合)
  result = var2.union(var1)
  print(result)
  
  # 集合支持一系列标准操作，包括并集、交集、差集和对称差集
  a = t | s          # t 和 s的并集 
     
  b = t & s          # t 和 s的交集 
     
  c = t – s          # 求差集（项在t中，但不在s中） 
     
  d = t ^ s          # 对称差集（项在t或s中，但不会同时出现在二者中）
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31
  32
  33
  34
  35
  36
  37
  38
  39
  40
  41
  42
  43
  44
  45
  46
  47
  48
  49
  50
  51
  52
  53
  54
  55
  56
  57
  58
  59
  60
  61
  62
  63
  64
  65
  66
  67
  68
  69
  70
  71
  72
  73
  74
  75
  76
  77
  78
  79
  80
  81
  82
  83
  84
  85
  86
  87
  88
  89
  90
  91
  92
  93
  94
  95
  96
  97
  98
  99
  100
  101
  102
  103
  104
  105
  106
  107
  108
  109
  110
  111
  112
  113
  114
  115
  116
  117
  118
  119
  120
  121
  122
  123
  124
  125
  126
  127

3 字典和几种常见的存储数据型比较

• 列表list和dict

  ​ 在进行数据存储与查找方面，列表list是用时间换取空间， 它存储数据占用的空间小，浪费内存很少。但是查找和插入的时间随着元素的增加而增加； 字典dict是用空间换取时间， 它存储数据占用大量的空间， 内存浪费多。

• 字典set和dict

  ​ 集合和字典检索的原理是一样的， 唯一区别就是没有存储对应的value值； 字典的键值和集合的元素不可以放入可变对象， 因为无法判断两个可变对象是否相等， 也就无法保证集合（字典键值）不会有重复的元素。

• 将列表/元组转化成集合

  l = [1, 2, 3, 4]
  s1 = set(l)
  
  t = (1, 2, 3, 4)
  s2 = set(t)
  
  1
  2
  3
  4
  5
  6

说明： 后面我将逐渐将我的blog转移到我的个人网站 http://www.kendny.cn, 欢迎关注并评论！