字典

　　字典是python中一种键值映射类型，采用key-value的存储方式。python对key进行哈希函数运算，根据计算的结果决定value的存储地址，所以字典是无序存储的，且key必须是可哈希的。（如果可变，那hash又要重新计算，对应关系常常改就不行了）。 但是在3.6中，字典变成了有序。

　　字典与列表的区别：

　　　　　　字典是通过键来存取的，hash键值来进行村春，查找速度飞快

　　　　　　列表是通过索引来存取的

一、定义字典

book = {
    'name':'python',
    'price':88
}
##############
也支持嵌套的方式
book = {
    'name':'python',
    'price':88
    ‘publish’:{
        'name':'北京出版社',
        ‘addr’:'北京裤衩楼'
    }
}

 

二、字典增删改查

2.1 增加

第一种单层
dict1 = {'user':'lh','password':'lou123'}
dict1['id'] = 5
print(dict1)

运行结果：
{'user': 'lh', 'password': 'lou123', 'id': 5}

第二种多层：
lh = { 'name':'louhui','city':'hangzhou'}
book={'name':'python','prince':88}
lh['book'] = book

2.2 删除

1) del python内置函数
dict1 = {'user':'lh','password':'lou123'}
del dict1['id']   #删除单项
del dict1         #删除字典,变量都不存在了

2）clearn 字典方法
dict1.clear()　　  #清空字典的项，但是字典的变量名还存在

 

2.3 修改

dict['id'] = 2  #如果id不存在就是增加了，存在就修改了，比较灵活

 

2.4 查

1. 取值

取值有两种方式：

一、直接使用key，key不存在则报错
dict1['name']
dict1['book']['name']   #嵌套的方式下

二、使用get查找,key不存在不会报错，可定义不存在的返回值，默认是None
dict1.get('name')
dict.get('book').get('name')

 

2.查询key

dict1 = {'user':'lh','password':'lou123','id':1}
s=dict1.keys()       # 注意这个是一个dict_keys类型，看着像列表，但不能使用索引的方式去取值，是一个可迭代的对象
li = [i for i in s]  #使用列表推导式去转换
print(li)

 

3. 查询items

for item in dict1.items()
for k,v in   dict1.items()

dict.items()的返回值也是一个类似列表的序列，但是也不能使用所用的方式

 2.5 设置默认值的两种方法

1.使用字典的方法 setdefault

　　setdefault的用法比较灵活

• • 　　当key已经存在的时候，返回对应key的v
  • 　　当key不存在的时候，直接设置值

my_dict = {}
my_dict['a']   #直接报错！

my_dict.setdefault('a','good')   #设置了一个默认值

2.使用第三方库

>>> from collections import defaultdict
>>> todo = defaultdict(lambda:'noting')
>>> todo['a']
'noting'

 

 

三、字典的内置方法

　　字典的内置方法，就辣么几个，我们一起征服吧！

 

 clear(...)

　　D.clear() -> None. Remove all items from D. 

　　无返回值，清空所有的项。

D = {'a':1,}
D.clear()

COPY

　　 D.copy() -> a shallow copy of D。

　　浅拷贝。 后面再介绍

fromkeys

　　  fromkeys(iterable, value=None, /) from builtins.type

　　 Returns a new dict with keys from iterable and values equal to value.

　　 方便生产一个列表。

　　两个参数：

　　　　第一个参数是一个可迭代的数据结构（str，list等）

　　　　第二个参数是value，默认是None

dict1 = dict.fromkeys([1,2,3])  　　#不赋值，默认为None
dict2 = dict.fromkeys('efsas','hui')
print(dict1)
print(dict2)

运行结果：
{1: None, 2: None, 3: None}
{'e': 'hui', 'f': 'hui', 's': 'hui', 'a': 'hui'}

get

　　D.get(k [,d]) -> D[k] if k in D, else d. d defaults to None.

　　有两个参数，第二个参数可选（[]代表可选）。 如果存在key，则返回对应的值，如果不存在则为 第二个参数（第二参数默认为None）。

dict1 = {'name':'louhui','age':19}
print(dict1.get('x','没有找到啊！'))

运行结果：
没有找到啊！

items
　　D.items() -> a set-like object providing a view on D's items
　　返回一个类似列表 包含多个二元数组。 在上面 查的方法有介绍。

dict1 = {'name':'louhui','age':19}
print(dict1.items())

运行结果：
dict_items([('name', 'louhui'), ('age', 19)])

keys

 D.keys() -> a set-like object providing a view on D's keys
　　在上面查key有介绍
pop
　　D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
　　If key is not found, d is returned if given, otherwise KeyError is raised

　　删除指定key，并返回相对应的v。

　　如果key不存在，第二参数存在，则返回第二参数。否则报错

>>> a = {'name':'hui','age':18}
>>> a.pop('name')
'hui'
>>> a.pop('name')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'name'
>>> a.pop('age','wo')
18
>>> a.pop('age','wo')
'wo'

popitem(...)
　　D.popitem() -> (k, v), remove and return some (key, value) pair as a 2-tuple; but raise KeyError if D is empty.

　　随机返回并删除字典中的一对键和值。删完以后就报错。

dict1 = {'name':'louhui','age':19,'city':'hangzhou'}
print(dict1.popitem())
print(dict1)

运行结果：
{'city':'hangzhou'}
{'name': 'louhui', 'age': 19}

但在python3.6中好像变成了 删除最后一个item了，3.6中字典变成了有序了

 

 

setdefault(...)
　　D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D

　　和get有点类似。如果key存在则不改变，如果key不存在就增加这个key。

dict1 = {'name':'hui','age':18}
dict1.setdefault('id')
print(dict1)
dict1.setdefault('book','python')
print(dict1)
dict1.setdefault('name','lh')
print(dict1)

运行结果
{'name': 'hui', 'age': 18, 'id': None}      　　　　　　　　#key不在字典中，直接增加，默认为None
{'name': 'hui', 'age': 18, 'id': None, 'book': 'python'} #key不在字典中，直接增加第二参数的v，并返回v
{'name': 'hui', 'age': 18, 'id': None, 'book': 'python'} #key存在，不修改，并返回对应的v

update(...)
　　D.update([E, ]**F) -> None. Update D from dict/iterable E and F.
 　　If E is present and has a .keys() method, then does: for k in E: D[k] = E[k]
　　If E is present and lacks a .keys() method, then does: for k, v in E: D[k] = v
　　In either case, this is followed by: for k in F: D[k] = F[k]

　　说简单点就是 

　　　　dict1.update(dict1)  把字典dict2的键/值对更新到dict1里

dict1 = {'name':'louhui','age':18}
dict2 = {'id':1}
dict1.update(dict2)
print(dict1)

运行结果：
{'name': 'louhui', 'age': 18, 'id': 1}

values(...)
　　D.values() -> an object providing a view on D's values

　　返回字典中所有的v，用一个类似列表的方式存储。

dict1.values()
dict_values(['louhui', 18, 1])