python字典常用技巧

Python字典及基本操作（超级详细）http://c.biancheng.net/view/2212.html 

目录

一、将dataframe中的两列数据转换成字典dict

二、字典 key 和 value反转

三、dict排序

四、dict用法

五、两个list转dict

六、复制一个list

七、dict 保存为pickle格式、读取

八、merger合并两个字典

九、通过value索引key

十、defaultdict

---

一、将dataframe中的两列数据转换成字典dict

方法一：

df 为dataframe对象，包含'word', 'count'两列数据

result_dic = df.groupby('word')['count'].apply(lambda x:str(x)).to_dict()

result_dic = df.groupby('word')['count'].apply(lambda x:x).to_dict()

第一个应用了 str(x) 将 元素转换为字符串类型了，第二种没有转换还是原来的类型(实现不了)。

result_dic = df.groupby('word')['count'].apply(list).to_dict() 
# 对于同一个key对应多个value，则把同一key的value构成一个list

deed_code, score_value两列都是数字：

result_dic = df.groupby('deed_code')['score_value'].apply(int).to_dict()

方法二：

result_dic = df.set_index('word').T.to_dict()

结果

形如{key:{'count':value}}

二、字典 key 和 value反转

方法一：

dict(map(lambda t:(t[1],t[0]), dic.items()))

方法二： 

new_dic = {value: key for key, value in dic.items()}

等同于： 

new_dict = {}
for key,val in result_dic.items():
    new_dict[val] = key

三、dict排序

 key_value={}

按键(key)排序：

sorted(key_value) 返回重新排序的列表

按值(value)排序:

print ("按值(value)排序:")   
print(sorted(key_value.items(), key = lambda kv:(kv[1], kv[0])))  

https://www.runoob.com/python3/python-sort-dictionaries-by-key-or-value.html 

四、dict用法

Python内置了字典：dict的支持，dict全称dictionary，在其他语言中也称为map，使用键-值（key-value）存储，具有极快的查找速度。原理：先在字典的索引表里（比如部首表）查这个字对应的页码，然后直接翻到该页，找到这个字。无论找哪个字，这种查找速度都非常快，不会随着字典大小的增加而变慢。

>>> d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
>>> d['Michael']
95

把数据放入dict的方法，通过key放入：

>>> d['Adam'] = 67
>>> d['Adam']
67

• 一个key只能对应一个value，所以，多次对一个key放入value，后面的值会把前面的值冲掉：
• 如果key不存在，dict就会报错：

避免key不存在的错误，有两种办法，一是通过in判断key是否存在：

>>> 'Thomas' in d
False

二是通过dict提供的get()方法，如果key不存在，可以返回None，或者自己指定的value：

>>> d.get('Thomas')
>>> d.get('Thomas', -1)
-1

注意：返回None的时候Python的交互环境不显示结果。

 要删除一个key，用pop(key)方法，对应的value也会从dict中删除：

>>> d.pop('Bob')
75
>>> d
{'Michael': 95, 'Tracy': 85}

请务必注意，dict内部存放的顺序和key放入的顺序是没有关系的。

和list比较，dict有以下几个特点：

1. 查找和插入的速度极快，不会随着key的增加而变慢；
2. 需要占用大量的内存，内存浪费多。

而list相反：

1. 查找和插入的时间随着元素的增加而增加；
2. 占用空间小，浪费内存很少。

所以，dict是用空间来换取时间的一种方法。

五、两个list转dict

keys = ["price","toalAmount"]
 
values = ["0.01","10000"]
 
d = dict(zip(keys,values))
 
 
{'price': '0.01', 'toalAmount': '10000'}

六、复制一个list

问题：a = b 相当于浅复制：a和b指向同一个内存；如下图所示

其中：id(a)  = id(b)

现在想将b复制一个新的a，然后对a进行操作(添加或删除元素、排序），要求不影响b本身

a  =  b * 1

id(a)  不等于 id(b)，说明a复制了一个b的内存副本；

a  =  b[:]

id(a)  不等于 id(b)

import copy
e = copy.copy(a)
f = copy.deepcopy(a)

使用 a[:], list(a), a*1, copy.copy(a)四种方式复制列表结果都可以得到一个新的列表，但是如果列表中含有列表，所有b, c, d, e四个新列表的子列表都是指引到同一个对象上。只有使用copy.deepcopy(a)方法得到的新列表f才是包括子列表在内的完全复制。

七、dict 保存为pickle格式、读取

mydict = {"1": 10, "3": 30}
with open("./data/medFile/test.pickle", "wb") as fp:   #Pickling
    pickle.dump(mydict, fp, protocol = pickle.HIGHEST_PROTOCOL)      
with open("./data/medFile/test.pickle", "rb") as fp:   #Pickling
    mydict = pickle.load(fp)     
mydict

八、merger合并两个字典

def Merge(dict1, dict2): 
    return(dict2.update(dict1)) 
      
# 两个字典
dict1 = {'a': 10, 'b': 8} 
dict2 = {'d': 6, 'c': 4} 
  
# 返回  None 
print(Merge(dict1, dict2)) 
  
# dict2 合并了 dict1
print(dict2)

def Merge(dict1, dict2): 
    res = {**dict1, **dict2} 
    return res 
      
# 两个字典
dict1 = {'a': 10, 'b': 8} 
dict2 = {'d': 6, 'c': 4} 
dict3 = Merge(dict1, dict2) 
print(dict3)

以上两种方法都不会叠加频率（value）

以下方法适用多字典存在相同key需要合并相加的场景。

from functools import reduce
def sum_dict(a,b):
    temp = {}
    # python3,dict_keys类似set； | 并集
    for key in a.keys()| b.keys():
        temp[key] = sum([d.get(key, 0) for d in (a, b)])
    return temp

def test():
    # [a,b,c]列表中的参数可以2个也可以多个，自己尝试。
    return reduce(sum_dict,[a,b,c])

a = {'a': 1, 'b': 2, 'c': 3}
b = {'a':1,'b':3,'d':4}
c = {'g':3,'f':5,'a':10}
print(test())

九、通过value索引key

dict = {
    1:[1,6],
    2:[1,7],
    3:[3,2],
    4:[3,1],
    5:[2,4],
    6:[2,5],
    7:[6,1]
}

get_keys(dict, [1,6])

1

十、defaultdict

1、调用普通的 dict 前提是 key 在字典里，如果不在字典里就会报错。

2、defaultdict 的作用是在于，当字典里的key不存在但被查找时，返回的不是keyError而是一个默认值

3、

dict =defaultdict( factory_function)

这个factory_function可以是list、set、str等等，作用是当key不存在时，返回的是工厂函数的默认值，比如list对应[ ]，str对应的是空字符串，set对应set( )，int对应0，如下举例：

from collections import defaultdict

dict1 = defaultdict(int)
dict2 = defaultdict(set)
dict3 = defaultdict(str)
dict4 = defaultdict(list)
dict1[2] ='two'

print(dict1[1])
print(dict2[1])
print(dict3[1])
print(dict4[1])

输出：

0
set()

[]