python字典和集合

Posted 2021-02-01 Sakura

构造方法与字典推导式

>>> a = dict(one=1, two=2, three=3)    #法一
>>> b = {‘one‘: 1, ‘two‘: 2, ‘three‘: 3}    #法二
>>> c = dict(zip([‘one‘, ‘two‘, ‘three‘], [1, 2, 3]))    #法三
>>> d = dict([(‘two‘, 2), (‘one‘, 1), (‘three‘, 3)])    #法四
>>> e = dict({‘three‘: 3, ‘one‘: 1, ‘two‘: 2})    #法五
>>> a == b == c == d == e
True    

DIAL_CODES = [    #承载成对数据的列表，用于字典推导   
    (86, ‘China‘),
    (91, ‘india‘),
    (1, ‘United States‘),
    (7, ‘Russia‘),
    (81, ‘Japan‘), ]
country_code = {country: code for code, country in DIAL_CODES}  #字典推导式，类似于列表推导式
print(country_code)
new_country_code = {code: country.upper() for country, code in country_code.items() if code > 80}　　#筛选code值大于60的并将country改为大写
print(new_country_code)
#结果
{‘United States‘: 1, ‘Japan‘: 81, ‘Russia‘: 7, ‘india‘: 91, ‘China‘: 86}
{81: ‘JAPAN‘, 91: ‘INDIA‘, 86: ‘CHINA‘}

dict常见方法(collections库中的defaultdict,Orderedict同样有这些方法)

1 dict.clear()　　//删除字典内所有元素　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　
2 dict.copy()　　//返回一个字典的浅复制
3 dict.fromkeys(seq[, val])　　//创建一个新字典，以序列 seq 中元素做字典的键，val 为字典所有键对应的初始值
4 dict.get(key, default=None)　　//返回指定键的值，如果值不在字典中返回default值
5 dict.has_key(key)　　　//如果键在字典dict里返回true，否则返回false　　　　（可用key in dict代替）
6 dict.items()　　//以列表返回可遍历的(键, 值) 元组数组
7 dict.keys()　　//以列表返回一个字典所有的键
8 dict.setdefault(key, default=None)　　//和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
9 dict.update(dict2)　　//把字典dict2的键/值对更新到dict里
10 dict.values()　　//以列表返回字典中的所有值以列表返回字典中的所有值
11 pop(key[,default])　　//删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。
12 popitem()　　//随机返回并删除字典中的一对键和值。

找不到键时的选择

1.当字典d[k]不能找到正确的键的时候，会抛出keyError异常。上述方法中的dict.get(key, default=None)和dict.setdefault(key, default=None)均可解决问题。

而需要正确区分两个函数的合适场合，当需要更新某个键对应的值时，使用setdefault这个函数则更为合适，因为get函数只是返回default值，并不对字典进行更新。

 

2.使用collections中.defaultdict创建字典而不是dict

实例化defaultdict时，需要给构造方法提供一个可调用对象，这个可调用对象会在__getitem__碰到找不到的键的时候被调用，让__getitem__返回某个默认值。

以list为例，新建字典d = defaultdict(list)，如果new_key在字典中不存在，则d[new_key]会按照以下步骤：

1)调用list来新建一个列表

2)把这个列表作为值，‘new_key’作为键，放到d中

3)返回列表引用。

 

其他映射类型

collections.OrderedDict　　//特点：添加键时保持顺序。popitem()方法删除的是最后一个元素，类似栈；而可用popitem(last=False)来删除第一个元素，类似队列。

collections.ChainMap    //特点：可以容纳多个不同的映射对象，查找时，这些对象会被当做一个整体逐一查找，直到键被找到。

collections.Counter      //特点：为键(key)维护一个计数器，每次更新一个键时会增加这个计数器。实现了+和-运算来合并记录。most_commot([n])方法，按照次序返回映射里面最常见的n个键和他们的计数。下例：

from collections import Counter
ct = Counter(‘trueorfalse‘)
print(ct)
ct.update(‘tree‘)    #更新
print(ct)
print(ct.most_common(3))    #获取最多的三个键
new_ct = Counter(‘tree‘)
print(ct + new_ct)    #加号
print(ct - new_ct)     #减号
Counter({‘r‘: 2, ‘e‘: 2, ‘u‘: 1, ‘o‘: 1, ‘a‘: 1, ‘t‘: 1, ‘s‘: 1, ‘l‘: 1, ‘f‘: 1})
Counter({‘e‘: 4, ‘r‘: 3, ‘t‘: 2, ‘u‘: 1, ‘o‘: 1, ‘a‘: 1, ‘s‘: 1, ‘l‘: 1, ‘f‘: 1})
[(‘e‘, 4), (‘r‘, 3), (‘t‘, 2)]
Counter({‘e‘: 6, ‘r‘: 4, ‘t‘: 3, ‘u‘: 1, ‘o‘: 1, ‘a‘: 1, ‘f‘: 1, ‘l‘: 1, ‘s‘: 1})
Counter({‘r‘: 2, ‘e‘: 2, ‘u‘: 1, ‘o‘: 1, ‘a‘: 1, ‘t‘: 1, ‘f‘: 1, ‘l‘: 1, ‘s‘: 1})

 

自定义类型   UserDict

UserDict不是dict的子类，但UserDict有一个data属性，是dict的实例，data是UserDict最终存储数据的地方。

UserDict继承的是MutableMapping，MutableMapping继承的是Mapping。

MutableMapping.update不但可直接使用，而且用在__init__中，让构造方法可以利用各种参数(其他映射类型，可迭代的(key,value)元组对)来新建事例。

Mapping.get方法在键不存在时，将键转化为字符串查询。

 

不可变映射类型 types.MappingProxyType　　//返回一个动态视图

from types import MappingProxyType
d = {1: ‘A‘}
d_proxy = MappingProxyType(d)
print(d_proxy)
{1: ‘A‘}
d_proxy[2] = ‘x‘    #不可变，抛出异常
Traceback (most recent call last):
  File "<input>", line 1, in <module>
TypeError: ‘mappingproxy‘ object does not support item assignment
d[2] = ‘x‘
print(d_proxy)     #动态变化
mappingproxy({1: ‘A‘, 2: ‘x‘})

 

集合 (set和frozenset)

set本身元素必须是可散列的，但frozenset可以。

构造方法

s = {1,2,3}    //速度快
s = set{[1,2,3]}    //常用
s = frozenset([1, 2, 3, 4, 5, 4])
s = {i for i in range(5)}    //集合推导式

一个陷阱：{ }构造的是一个字典而非集合，需用set()方法。

集合数学运算符(集合s和集合z,，以下方法会修改s)

交集　　s & z　　s &= z

并集　　s | z　　  s |= z

差集　　s z   　　s = z

对称差集　　s ^ z   s ^= z

集合比较运算符(集合s和集合z,返回布尔值）

属于　　e in s　

子集　　s <= z

真子集　　s < z

父集　　s >= z

真父集　　s > z

其他常用方法

add(e) 　　//向集合中添加元素e

clear() 　　//清空集合

copy() 　　//返回集合的浅拷贝

pop() 　　//删除并返回任意的集合元素（如果集合为空，会引发 KeyError）

remove(e) 　　//删除集合中的e元素（如果元素不存在，会引发 KeyError）

内置方法

all() 　　//如果集合中的所有元素都是 True（或者集合为空），则返回 True。
any() 　　//如果集合中的所有元素都是 True，则返回 True；如果集合为空，则返回 False。
enumerate() 　　//返回一个枚举对象，其中包含了集合中所有元素的索引和值（配对）。
len() 　　//返回集合的长度（元素个数）
max() 　　//返回集合中的最大项
min() 　　//返回集合中的最小项
sorted() 　　//从集合中的元素返回新的排序列表（不排序集合本身）
sum() 　　//返回集合的所有元素之和

字典实现方式（散列表）

4个问题

【1】字典和集合的效率？

【2】字典为什么是无序的？

【3】所有对象均可作为python中的键？

【4】为什么不能在迭代时往dict或set中添加元素。

散列表是一个稀疏数组(含有大量空白元素的数组)，散列表单元称为表元。dict的散列表中，每个键值对占用一个表元，分为键的引用和值的引用两部分。表元大小一致，故通过偏移量来读取某个单元。python会设法保证大概有1/3的空白表元【1】，当达到这个阈值时，散列表会被复制到一个新的更大的空间中【2】【4】。（复制时会使用散列表算法）

散列性和相等性：字典必须保证键是可散列的【3】(在生命周期中，散列值是不变的对象)；另外如果两个散列对象相等，那么他们的散列值相等，例如1和1.0。

散列表算法：获取d[k]的值时，会调用hash(k)来计算k的散列值，把这个值最低几位数字当做偏移量【5】，在散列表中查找表元，若表元为空，会抛出keyError异常；若不是空的，则产生散列冲突，算法会在散列值中另取几位，用特殊方法处理后，得到新的偏移量来查找表元。->反复如上步骤，直到产生keyError异常或查找到匹配的键。

上述特性分别决定了：

【1】字典在内存中开销巨大

【2】字典是可能是乱序的；【4】无论何时添加新的键都有可能让字典产生扩容，而这个过程会发生新的散列冲突，导致新散列表的键次序变化；而在迭代时修改字典可能会跳过一些键或迭代字典中已有的键。

【3】键必须是可散列的

【5】键查询很快