字典和集合

字典构造方法：

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([('one',1),('two',2),('three',3)]) e = dict({'one':1, 'two':2, 'three':3}) print(a==b==c==d==e)输出：True

 

字典新增元素

cat_names = ['andy','bob','candy'] cat_ages = [12,3,6] cat_dict = dict(zip(cat_names,cat_ages)) print('origin dict:',cat_dict) print('-' * 20,'__setitem__','-' * 50) # 向dict增加键值对 cat_dict['fancl']=13 print('after inserted:',cat_dict) print('-' * 20,'setdefault()','-' * 50) # setdefault()方法：若键已存在，则返回相应的值；若键不存在，则将键值对新增到dict中 print('andy:',cat_dict.setdefault('andy',10)) print('david:',cat_dict.setdefault('david',10)) print('after inserted:',cat_dict)输出：

origin dict: {'andy': 12, 'bob': 3, 'candy': 6}-------------------- __setitem__ --------------------------------------------------after inserted: {'andy': 12, 'bob': 3, 'candy': 6, 'fancl': 13}-------------------- setdefault() --------------------------------------------------andy: 12david: 10after inserted: {'andy': 12, 'bob': 3, 'candy': 6, 'fancl': 13, 'david': 10}

 

 

 

字典推导

　　字典推导可以从任何以键值对作为元素的可迭代对象中构建出字典

numbers = [('one',1),('two',2),('three',3)] num_dict = {value:name for name,value in numbers} print(num_dict) num_dict_upper = {value:name.upper() for value,name in num_dict.items()} print(num_dict_upper)输出：

{1: 'one', 2: 'two', 3: 'three'}{1: 'ONE', 2: 'TWO', 3: 'THREE'}

 

字典迭代

cat_names = ['andy','bob','candy'] cat_ages = [12,3,6] # 用zip初始化字典 cat_dict = dict(zip(cat_names,cat_ages)) # iter函数获取到的是键的迭代器 for idx in iter(cat_dict): print(idx) print('-' * 100) # 也可以用keys()方法返回所有键 for idx in cat_dict.keys(): print(idx) print('-' * 100) # items()方法返回所有键值对 for item in cat_dict.items(): print(item)输出：

andybobcandy----------------------------------------------------------------------------------------------------andybobcandy----------------------------------------------------------------------------------------------------('andy', 12)('bob', 3)('candy', 6)

 

 

dict.update方法

numbers = [('one',1),('two',2),('three',3)] # 字典的键是内置类型 num_dict = {name:value for name,value in numbers} print(num_dict) # update会根据键更新值 num_dict.update({'two':4}) print(num_dict) # 没有找到需要更新的键，则添加进字典 num_dict.update({'five':5}) print(num_dict) print('-' * 100) # 一个实现了__eq__和__hash__的自定义类 class myname: def __init__(self,name): self.name=name def __eq__(self, other): return self.name==other.name def __str__(self): return self.name def __repr__(self): return self.name def __hash__(self): return hash(self.name) numbers = [(myname('one'),1),(myname('two'),2),(myname('three'),3)] # 字典的键是自定义类型 num_dict = {name:value for name,value in numbers} print(num_dict) # 但也可以根据__eq__实现根据键的更新 num_dict.update({myname('two'):4}) print(num_dict)输出：

{'one': 1, 'two': 2, 'three': 3}{'one': 1, 'two': 4, 'three': 3}{'one': 1, 'two': 4, 'three': 3, 'five': 5}----------------------------------------------------------------------------------------------------{one: 1, two: 2, three: 3}{one: 1, two: 4, three: 3}

 

dict.setdefault

import re s = '''dog hits cat, cat hates dog, you eat dog but not cat. ''' patt = re.compile(r'\w+') index = {} for match in patt.finditer(s): word = match.group() # word存在取出相应的值 # word不存在向字典中添加一个项目，key=word,value=0，返回0 count = index.setdefault(word,0) index.update({word:count+1}) # 按照word出现次数排序输出 for word,count in sorted(index.items(),key=lambda item:item[1],reverse=True): print(word,':',count)输出：

dog : 3cat : 3hits : 1hates : 1you : 1eat : 1but : 1not : 1

 defaultdict

import re import collections s = '''dog hits cat, cat hates dog, you eat dog but not cat. ''' patt = re.compile(r'\w+') # defaultdict需要传一个可调用对象作为参数，在赋默认值时使用 index = collections.defaultdict(int) for match in patt.finditer(s): word = match.group() # 使用defaultdict，自动给不存在的word赋默认值0 index[word]+=1 # 按照word出现次数排序输出 for word,count in sorted(index.items(),key=lambda item:item[1],reverse=True): print(word,':',count)输出：

dog : 3cat : 3hits : 1hates : 1you : 1eat : 1but : 1not : 1

 

import re from collections import defaultdict ''' contents in dogcat.txt: a dog sits by a cat a cat sits by a dog two animals sit together ''' word_re = re.compile(r'\w+') index = defaultdict(list) with open('d:\\dogcat.txt') as fp: for line_no,line in enumerate(fp): for match in word_re.finditer(line): word = match.group() col_no = match.start()+1 location = (line_no,col_no) # defalutdict会根据构造函数的参数， # 对不在映射内的键自动初始化一个值，这里是list() index[word].append(location) for word in sorted(index,key=str.upper): print(word,index[word])输出：

a [(0, 1), (0, 15), (1, 1), (1, 15)]animals [(2, 5)]by [(0, 12), (1, 12)]cat [(0, 17), (1, 3)]dog [(0, 3), (1, 17)]sit [(2, 13)]sits [(0, 7), (1, 7)]together [(2, 17)]two [(2, 1)]

 

dict.__missing__方法

　　__missing__方法只会被__getitem__调用

　　提供__missing__方法时get或者__contains__的使用都没有影响

class StrKeyDict0(dict): # __getitem__方法未获取到key时，调用__missing__方法 def __missing__(self, key): if(isinstance(key,str)): raise KeyError(key) return self[str(key)] # 这里利用self[key]把属性获取委托给__getitem__ def get(self, key,default=None): try: return self[key] except KeyError: return default def __contains__(self, item): return item in self.keys() or str(item) in self.keys() sk = StrKeyDict0([('2','two'),('4','four')]) # 调用__getitem__ print(sk[2]) # 调用get print(sk.get(4))输出：

twofour

 popitem()：dict和OrderedDict比较

　　OrderedDict在添加键的时候会保持顺序，因此键的迭代顺序与输入保持一致

　　OrderedDict的popitem方法默认删除并返回字典里最后一个元素，但传递last=False参数，那么它删除并返回第一个被添加进去的元素

 

from collections import OrderedDict dog_names = ['daniel','fancl','grace'] dog_ages = [9,10,11] dog_dict = dict(zip(dog_names,dog_ages)) print('before pop:',dog_dict) # 随机移除元素 print('pop item:',dog_dict.popitem()) print('after pop:',dog_dict) print('-'*100) cat_names = ['andy','bob','candy'] cat_ages = [12,3,6] cat_dict = OrderedDict(zip(cat_names,cat_ages)) #cat_dict.move_to_end('bob',False) print('before pop:',cat_dict) # last=False按先进先出顺序移除 # last=True按后进先出顺序移除 print('pop item:',cat_dict.popitem(last=False)) print('after pop:',cat_dict)输出：

before pop: {'daniel': 9, 'fancl': 10, 'grace': 11}pop item: ('grace', 11)after pop: {'daniel': 9, 'fancl': 10}----------------------------------------------------------------------------------------------------before pop: OrderedDict([('andy', 12), ('bob', 3), ('candy', 6)])pop item: ('andy', 12)after pop: OrderedDict([('bob', 3), ('candy', 6)])

 

 

collections.Counter

　　一个计数器字典

　　对传入的可迭代对象进行计数，形成一个字典

　　每次update的时候会增加这个计数器

　　most_common(n)会按照次序返回映射里最常见的n个键和它们的计数

import collections count = collections.Counter('abrabcablle') print('count :',count) count.update('abrabcablle') print('count :',count) print('count.most_common(2) : ',count.most_common(2))输出：

count : Counter({'a': 3, 'b': 3, 'l': 2, 'r': 1, 'c': 1, 'e': 1})count : Counter({'a': 6, 'b': 6, 'l': 4, 'r': 2, 'c': 2, 'e': 2})count.most_common(2) : [('a', 6), ('b', 6)]

 

继承collections.UserDict

　　UserDict不是dict的子类，但UserDict有一个叫data的属性，是dict的实例

import collections class StrKeyDict(collections.UserDict): def __missing__(self, key): if(isinstance(key,str)): raise KeyError(key) return self.data[str(key)] def __setitem__(self, key, value): self.data[str(key)] = value def __contains__(self, item): return str(item) in self.data sk = StrKeyDict([('2','two'),('4','four')]) # 调用__getitem__ print(sk[2]) # 调用get # UserDict继承Mapping.get方法，源码与StrKeyDict0中的写法相同，所以不需要再改写 print(sk.get(4))输出：

twofour

 

不可变映射类型

　　标准库里的所有映射都是可变的

　　types模块引入了一个封装类名叫MappingProxyType，如果给这个类一个映射，会返回一个只读的映射视图

　　但它是动态的，意味着如果对原映射做出改动，我们通过这个视图可以观察到

from types import MappingProxyType d = dict([(1,'one')]) md = MappingProxyType(d) print('md :',md) print('md[1] : ',md[1]) # 只读的视图，不允许赋值 # TypeError: 'mappingproxy' object does not support item assignment # md[2] = 'two' d[2] = 'two' # 但会根据原映射动态修改 print('md :',md)输出：

md : {1: 'one'}md[1] : onemd : {1: 'one', 2: 'two'}

 

建立集合和frozenset

# 建立空集合 s = set() print(s) # 用字面量建立集合 s = {1,2,3} print(s) # 集合推导 s = {x for x in range(10)} print(s) # 建立frozenset fs = frozenset(s) print(fs)输出：

set(){1, 2, 3}{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})

 

关于字典和集合的散列

　　如果你实现了一个类的__eq__方法，并且希望它是可散列的，那么它一定要有个恰当的__hash__方法，保证在a==b为真的情况下hash(a)==hash(b)也必定为真。否则会破坏恒定的散列表算法

　　另一方面，如果一个含有自定义的__eq__依赖的类处于可变的状态，那就不要在这个类中实现__hash__方法，因为它的实例是不可散列的

转载于:https://www.cnblogs.com/StackNeverOverFlow/p/9873764.html