Python字典&集合

字典&集合

字典

字典以键值对形式存在：{ key: value }
其中key值会进行hash运算，生成hash表，所以字典的访问效率 要优于普通序列数据类型(列表，元组)
key值由于需要通过hash，则一些可变数据类型不可以做key值，而value的类型没有限制，可以是任意数据类型
由于进行了hash运算，那么在内存中字典其中的数据元素是无序的，没有办法进行一些像索引和切片一样的操作 (但是在Python3.6后 ，字典数据类型已经被更改为有序数据类型 ；查阅地址；(from collections import OrderedDict))
字典中的key值是唯一的
字典为可变数据类型

创建方式

大括号包裹键值对：mydict = {1:'a' , 2:'b' }

css 复制代码

>>> mydict = {1:'a',2:'b'}
>>> mydict
{1: 'a', 2: 'b'}

工厂方法创建：mydict = dict(([1,'a'],[2,'b']))

css 复制代码

>>> mydict = dict(([1,'a'],[2,'b']))
>>> mydict
{1: 'a', 2: 'b'}

字典内建方法：mydict = dict.fromkeys([1,2],'a')

python 复制代码

>>> mydict = dict.fromkeys([1,2],'a')
>>> mydict
{1: 'a', 2: 'a'}
#这样可以批量创建key值，但是缺点也暴露出来无法单独分配value值

访问字典

获得所有key值：dict.keys()

ini 复制代码

>>> mydict = {1:'a',2:'b'}
>>> mydict.keys()
dict_keys([1, 2])

获取所有value值：dict.values()

css 复制代码

>>> mydict = {1:'a',2:'b'}
>>> mydict.values()
dict_values(['a', 'b'])

通过key值获取value： dict[key] ，这个操作类似索引和切片，但实际为字典访问value值，所以不要混淆
- 注意：在访问一个不存在的key值会引发KeyError的错误

css 复制代码

>>> mydict = {1:'a',2:'b'}
>>> mydict[1]
'a'
>>> mydict[2]
'b'
>>> mydict[3]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 3

通过get方法获取，获取不到返回none或者get方法所传递的参数默认值

csharp 复制代码

dict.get('key',default)

迭代获取其中key值：for key in dict: 迭代访问到的数据为key值

python 复制代码

>>> for key in mydict:
...     print(key)
...     print(mydict[key])
...
1
a
2
b

判断某key

使用 in 还有 not in 判断是否在字典中有对应Key值，返回值为bool类型

python 复制代码

>>> mydict = {1:'a',2:'b'}
>>> 1 in mydict
True
>>> 3 in mydict
False
#由于value值是可以重复的，所以判断value是没有意义的

更新字典

通过对应key值访问到value值之后，重新赋值 给它则可进行更新

python 复制代码

>>> mydict = {1:'a',2:'b'}
>>> mydict[1] = 'c'
>>> mydict
{1: 'c', 2: 'b'}

删除

使用del语句删除对应key值所关联的value值，会把这个键值对删除掉

css 复制代码

>>> mydict = {1:'a',2:'b'}
>>> del mydict[1]
>>> mydict
{2: 'b'}

pop(obj) 函数删除字典中的某个值，并将被删除值返回

python 复制代码

>>> mydict = {1:'a',2:'b'}
>>> mydict.pop(1)
'a'
>>> mydict
{2: 'b'}

清空字典

dict.clear() 函数会将这个字典重新成为一个新的空字典

python 复制代码

>>> mydict = {1:'a',2:'b'}
>>> mydict.clear()
>>> mydict
{}

del语句直接删除字典变量，这也是最粗暴的方式

python 复制代码

>>> mydict = {1:'a',2:'b'}
>>> del mydict
>>> mydict
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'mydict' is not defined
#字典被删除之后连变量都不见了

集合

集合：把不同元素 组合在一起形成的一个数据集合
集合分为两种：可变集合 (set)，不可变集合(frozenset)
集合的内部结构和字典类似，但是不存储value，其中的元素也会进行hash运算，可以称的上是一个没有value的字典
集合中数据元素不能为可变数据对象

arduino 复制代码

>>> myset = {[1,2,3]}
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'
#可变数据对象不可hash，所以不能成为集合中数据元素

创建集合

可变集合

ini 复制代码

>>> myset = {1,2,3,4,5}
#直接通过大括号创建
>>> myset = set([1,2,3,1,2,3])
>>> myset
{1, 2, 3}
#通过工厂函数接收一个可迭代对象

不可变集合

python 复制代码

>>> myset = frozenset([1,2,3,1,2,3])
>>> myset
frozenset({1, 2, 3})

访问集合

迭代访问集合

python 复制代码

>>> myset  = {1,2,3}
>>> for var in myset:
...     print(var)
...
1
2
3
#集合虽然无序，但是可以通过for循环迭代访问

更新集合

set.add()：更新可hash数据类型到集合中，并维持数据类型

由于集合中的数据元素需要进行hash运算，可变数据类型是不可以进行hash运算的，也就不能传递进来被更新

python 复制代码

>>> myset = {1,2}
>>> myset.add('abc') #更新字符串到集合中
>>> myset
{1, 2, 'abc'}
>>> myset.add((1,2,3)) #更新元组到集合中
>>> myset
{1, 2, 'abc', (1, 2, 3)}
>>> myset.add([1,2,3]) #更新列表到集合中报错
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

set.update()：如果传入的是一个序列，将被拆分成单个元素，并且去重

python 复制代码

>>> myset = {1,2}
>>> myset.update('abc') #更新字符串
>>> myset
{1, 2, 'b', 'c', 'a'} #字符串被拆开
>>> myset.update([1,2,3]) #更新列表
>>> myset
{1, 2, 3, 'b', 'c', 'a'} #这里列表支持更新是因为存储的数据已经不再是列表，而是列表中的每一个实际数据
>>> myset.update((3,4,5)) #更新元组
>>> myset
{1, 2, 3, 4, 'b', 5, 'c', 'a'} #元组中的每一个数据都被拿出更新到集合中，并且去重

可变集合支持更新操作，不可变 集合不支持更新操作

python 复制代码

>>> myset = frozenset('abc')
>>> myset
frozenset({'a', 'b', 'c'})
>>> myset.add()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'frozenset' object has no attribute 'add'
#不可变集合不支持add更新
>>> myset.update()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'frozenset' object has no attribute 'update'
#不可变集合不支持update更新

删除集合中的元素

s.remove(obj)：删除obj元素从集合s中

该函数在删除一个不存在的数据时会引发KeyError

python 复制代码

>>> myset = {1,2,3}
>>> myset.remove(3)
>>> myset
{1, 2}
>>> myset.remove(5)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 5

s.discard(obj) ：如果obj是集合s中的元素，从集合s中删除对象obj

该函数在删除一个不存在 的数据时不会报错

python 复制代码

>>> myset = {1,2}
>>> myset.discard(1)
>>> myset
{2}
>>> myset = {1,2}
>>> myset.discard(3)
>>> myset
{1, 2}

del myset：删除这个集合变量

python 复制代码

>>> myset = {1,2,3}
>>> del myset
>>> myset
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'myset' is not defined

集合类型操作符

in 和 not in可以判断某个元素是否在集合中

python 复制代码

>>> myset = {1,2}
>>> 1 in myset
True
>>> 3 in myset
False
>>> 2 not in myset
False

子集和超集：
- a < b：a是否是b的子集a.issubset(b)
  - a的元素b都有
- a > b：a是否是b的超集a.issuperset(b)
  - 超集就代表a中的元素囊括了所有b的集合元素

css 复制代码

>>> a = {1,2}
>>> b = {1,2,3,4}
>>> a < b
True
>>> a.issubset(b)
True

集合的交、并、补操作

联合：在a集合中和b集合去重数据元素，剩下的组合到一起返回一个新的集合
- 操作符：a | b
- 函数：a.union(b)

python 复制代码

>>> a = {1,2,'a','b'}
>>> b = {1,3,'a','c'}
>>> a | b
{1, 2, 3, 'c', 'b', 'a'}

交集：在a集合和b集合中，共同含有的集合成员去掉重复数据，组成到一起返回一个新的集合
- 操作符：a &b
- 函数：a.intersection(b)

css 复制代码

>>> a = {1,2,'a','b'}
>>> b = {1,3,'a','c'}
>>> a & b
{'a', 1}

差补：在a集合中去掉所有与b集合中相同的元素，只在a中保留b中没有的集合成员
- 操作符：a -- b
- 函数：a.difference(b)

css 复制代码

>>> a = {1,2,'a','b'}
>>> b = {1,3,'a','c'}
>>> a - b
{2, 'b'}

对称差分 ：找出两个集合中，只属于 集合a或集合b的元素；也就是去掉共有元素后，返回一个新的集合
- 操作符：a ^ b
- 函数：a.symmetric_differenc(b)

python 复制代码

>>> a = {1,2,'a','b'}
>>> b = {1,3,'a','c'}
>>> a ^ b
{2, 3, 'b', 'c'}