Python 基础

字典是另一种可变容器模型，且可存储任意类型对象。

字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中 ,格式如下所示：

d = {key1 : value1, key2 : value2 }

键必须是唯一的，但值则不必。

值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。

特点：

1、key-value结构
2、key必须可以hash，且必须为不可变数据类型，必须唯一
3、键与值用冒号“：”分开；
4、项与项用逗号“，”分开；
5、字典中的键必须是唯一的，而值可以不唯一。
6、无序
7、查找速度快

字典类型与序列类型的区别：

1、存取和访问数据的方式不同。
2、序列类型只用数字类型的键（从序列的开始按数值顺序索引）；
3、映射类型可以用其他对象类型作键（如：数字、字符串、元祖，一般用字符串作键），和序列类型的键不同，映射类型的键直4.接或间接地和存储数据值相关联。
5、映射类型中的数据是无序排列的。这和序列类型是不一样的，序列类型是以数值序排列的。
6、映射类型用键直接“映射”到值。

常用操作

• 增加
• 删除
• 改写
• 查询

1. 增加

In [242]: info = {'name':'caimengzhi','age':18}

In [243]: info
Out[243]: {'age': 18, 'name': 'caimengzhi'}

2. 删除

pop

pop(...) method of builtins.dict instance
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，要是key没有，且没有给定返回值就抛出异常

# pop 删除
In [259]: info
Out[259]: {'age': 20, 'name': 'caimengzhi'}

In [260]: info.pop('age')  # 删除 指定的值，同时返回该值
Out[260]: 20 

In [261]: info
Out[261]: {'name': 'caimengzhi'}

　In [56]: info.pop('abc',"None") # 要是没有该key就返回None
　Out[56]: 'None'

　In [262]: info.clear()   # 清空字典

　In [263]: info
　Out[263]: {}

# 删除字典 del 

　In [281]: info　　

　Out[281]: {4: 5, 'name': 'caimengzhi'}

　In [282]: del info[4]

　In [283]: info

　Out[283]: {'name': 'caimengzhi'}

　In [264]: del info   

　In [265]: info
　---------------------------------------------------------------------------
　NameError Traceback (most recent call last)
　<ipython-input-265-efd7c8e9aa90> in <module>()
　----> 1 info

　NameError: name 'info' is not defined 

# 随机删除
In [271]: info={1:1,2:3,4:5,'name':'caimengzhi','age':18}

In [272]: info.popitem()
Out[272]: (1, 1)

In [273]: info
Out[273]: {2: 3, 4: 5, 'age': 18, 'name': 'caimengzhi'}

In [274]: info.popitem()
Out[274]: (2, 3)

In [275]: info
Out[275]: {4: 5, 'age': 18, 'name': 'caimengzhi'}

In [276]: info.popitem()
Out[276]: ('age', 18)

In [277]: info
Out[277]: {4: 5, 'name': 'caimengzhi'}

3. 改

In [286]: info
Out[286]: {4: 5, 'age': 18, 'name': 'caimengzhi'}

In [287]: info[4]=100

In [288]: info
Out[288]: {4: 100, 'age': 18, 'name': 'caimengzhi'}

4. 查询

In [252]: info
Out[252]: {'age': 20, 'name': 'caimengzhi'}

In [253]: info.get('age')
Out[253]: 20

In [254]: info.get('age1')  # 没有就返回空

In [255]: info['age']
Out[255]: 20

In [256]: info['age1']  # 没有就报错
---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
<ipython-input-256-9b09fc7c3af1> in <module>()
----> 1 info['age1']

KeyError: 'age1'

所以在查询的时候使用get方法，有就返回key对应的值，没有就返回空

 常见字典函数操作

1. keys, 所有keys

In [297]: info
Out[297]: {'alice': [23, 'HR'], 'cmz': [24, 'IT'], 'jack': 22}

In [298]: info.keys()
Out[298]: ['cmz', 'alice', 'jack']

2. values 所有values

In [299]: info.values()
Out[299]: [[24, 'IT'], [23, 'HR'], 22]

3.intems 把字典转换为列表

In [301]: info.items()
Out[301]: [('cmz', [24, 'IT']), ('alice', [23, 'HR']), ('jack', 22)]

4. update字典合并

In [304]: info
Out[304]: {'alice': [23, 'HR'], 'cmz': [24, 'IT'], 'jack': 22}

In [305]: info_2={1:2,2:3,'jack':[22,'Jack ma','Alibba']}

In [306]: info.update(info_2)

In [307]: info
Out[307]: 
{1: 2,
 2: 3,
 'alice': [23, 'HR'],
 'cmz': [24, 'IT'],
 'jack': [22, 'Jack ma', 'Alibba']} # 把之前的有的key，对应的key的值替换掉，没有对应的key就添加

5. setdefault创建

In [316]: info.setdefault('2','new 2')  # 若是有该key就不创建

In [317]: info
Out[317]: 
{1: 2,
 2: 3,
 '2': None,
 'alice': [23, 'HR'],
 'cmz': [24, 'IT'],
 'jack': [22, 'Jack ma', 'Alibba']}

In [318]: info.setdefault('test','new 2') # 没有该key就创建，有就不创建
Out[318]: 'new 2'
In [319]: info
Out[319]: 
{1: 2,
 2: 3,
 '2': None,
 '200': None,
 'alice': [23, 'HR'],
 'cmz': [24, 'IT'],
 'jack': [22, 'Jack ma', 'Alibba'],
 'test': 'new 2'}

6. fromkeys 批量生产字典

In [9]: info.fromkeys(['a','b','c'])
Out[9]: {'b': None, 'a': None, 'c': None}

In [10]: info.fromkeys(['a','b','c'],'nanjing')
Out[10]: {'b': 'nanjing', 'a': 'nanjing', 'c': 'nanjing'}

7. clear 清除字典

In [11]: info
Out[11]: {'jack': 22, 'cmz': [24, 'IT'], 'alice': [23, 'HR']}

In [12]: info.clear() # 字典还在，只是清除所有key和values值

In [13]: info
Out[13]: {}

8. copy

In [14]: info={1:2,3:4,5:6}

In [17]: info_2 = info.copy()  # 浅拷贝

In [18]: info_2
Out[18]: {1: 2, 3: 4, 5: 6}

In [19]: info_2[1]=100

In [20]: info_2
Out[20]: {1: 100, 3: 4, 5: 6}

In [21]: info
Out[21]: {1: 2, 3: 4, 5: 6}

循环

　In [26]: info
　Out[26]: {1: 2, 3: 4, 5: 6}

In [27]: for k in info:  # 效率比较高
   ....:     print(k,info[k])
   ....:     
1 2
3 4
5 6

或者（但是这个是字典转换成列表，所以效率比较低）

In [31]: info
Out[31]: {1: 2, 3: 4, 5: 6}

In [32]: for k,v  in info.items():
   ....:     print(k,v)
   ....:     
1 2
3 4
5 6