python字典的常用方法,python里字典的基本用法(包括嵌套字典)

　　本文的python版本为3.7.X在阅读本文之前，你需要了解Python字典的基本用法。

　　介绍

　　Dictionary (Dict)是Python内置的数据结构，由多个键值对组成。键和值由冒号分隔，每个键-值对由逗号(，)分隔。整个字典都包含在花括号({})中。键必须是唯一的，值可以采用任何类型，但键必须是不可变的，比如字符串、数字或元组。

　　推荐： 《python教程》

　　底层哈希表用于关联键和值，dict是无序的。功能包括：

　　搜插速度极快，不会随着key的增加而变慢；

　　需要占用更多内存。

　　所以dict是一种用空间换时间的数据结构，应用于需要快速搜索的场景。

　　操作：常用方法

　　get()

　　返回指定键的值。如果该键不存在，它将无错误地返回默认值(默认值为None)。语法是dict.get(key)。

　　dict_1[年龄]=24

　　in[7]: print(dict _ 1 . get( age ))

　　24

　　in[11]: print(dict _ 1 . get( NAMA ))

　　没有人

　　in[12]: print(dict _ 1[ NAMA ])

　　-

　　KeyError Traceback(最近一次调用)

　　模块中的ipython-input-12-ef61a380920e

　　- 1个打印件(字典_1[nama])

　　关键错误： NAMA key in dict

　　使用in运算符确定字典中是否存在该键。如果存在，则返回True，否则返回False。语法是：key in dict。

　　在[15]:字典_1

　　Out[15]: { 姓名 :无，年龄 : 24，性别 :无}

　　In [16]: print(字典_1中的“名称”)

　　真实的

　　In [17]: print(字典1中的“nama”)

　　在python 2中，该函数由False _ key()方法实现。

　　items()

　　使用语法dict.items()以列表形式返回可遍历(键，值)元组的数组。

　　在[18]:字典1中

　　Out[18]: { 姓名 :无，年龄 : 24，性别 :无}

　　In [19]: print(dict_1.items())

　　dict_items([(姓名，无)，(年龄，24)，(性别，无)])

　　In [20]: for key，dict_1.items():中的值

　　.打印(键，值)

　　.

　　不命名

　　24岁

　　无性别keys()

　　以列表形式返回字典的所有键：dict.keys()

　　在[21]:字典_1

　　Out[21]: { 姓名 :无，年龄 : 24，性别 :无}

　　In [22]: print(dict_1.keys())

　　dict_keys([姓名，年龄，性别])values()

　　以列表形式返回字典中的所有值：dict.values()

　　在[27]:字典_1中

　　Out[27]: { 姓名 :无，年龄 : 24，性别 :无，子名

　　e': 'Tony'}

　　In [28]: print(dict_1.values())

　　dict_values([None, 24, None, 'Tony'])

　　setdefault()

　　和get()类似，用户获得与给顶尖相关联的值，不同的是，该方法如果键不存在时会添加键并将值设为默认值，语法为：dict.setdefault(key, default=None)。

　　In [23]: dict_1

　　Out[23]: {'name': None, 'age': 24, 'sex': None}

　　In [24]: print(dict_1.setdefault('name'))

　　None

　　In [25]: print(dict_1.setdefault('name', 'Tony'))

　　None

　　In [26]: print(dict_1.setdefault('sub_name', 'Tony'))

　　Tony

　　In [27]: dict_1

　　Out[27]: {'name': None, 'age': 24, 'sex': None, 'sub_name': 'Tony'}update()

　　语法为：dict_1.update(dict_2)，用于把dict_2的键值对更新到dict_1中，如果有相同的键会被覆盖。

In [31]: dict_1
　　Out[31]: {'name': None, 'age': 24, 'sex': None, 'sub_name': 'Tony'}
　　In [32]: dict_2
　　Out[32]: {'name': 'Mary', 'age': 18, 'sex': None, 'sub_name': ''}
　　In [33]: dict_1.update(dict_2)
　　In [34]: dict_1
　　Out[34]: {'name': 'Mary', 'age': 18, 'sex': None, 'sub_name': ''}

　　删除字典中的所有项，dict.clear()，举个例子：

In [1]: dict_1 = dict(name="Tony", age=24)
　　In [2]: dict_2 = dict_1
　　In [3]: print(dict_2)
　　{'name': 'Tony', 'age': 24}
　　In [4]: dict_2.clear()
　　In [5]: dict_2
　　Out[5]: {}
　　In [6]: dict_1
　　Out[6]: {}

　　浅拷贝原始字典，返回一个具有相同键值对的新字典，dict.copy()，举个例子：

In [1]: dict_1 = dict(name='Tony', info=['boy', 24])
　　In [2]: dict_3 = dict_1.copy()
　　In [3]: dict_3['name'] = "Ring"
　　In [4]: dict_3['info'].remove('boy')
　　In [5]: dict_3
　　Out[5]: {'name': 'Ring', 'info': [24]}
　　In [6]: dict_1
　　Out[6]: {'name': 'Tony', 'info': [24]}

　　创建一个新字典，dict.fromkeys(seq[, value])，以序列seq中的元素做字典的键，value为字典所有键对应的初始值，其中value为可选参数， 默认为None。适用于数据初始化，举个例子：

In [1]: info = ['name', 'age', 'sex']
　　In [2]: dict_1 = dict.fromkeys(info)
　　In [3]: dict_1
　　Out[3]: {'name': None, 'age': None, 'sex': None}

　　合并字典

　　有四种方式：

　　常规处理

In [15]: dict_1
　　Out[15]: {'Tony': 24}
　　In [16]: dict_2
　　Out[16]: {'ben': 18}
　　In [17]: dict3 = dict()
　　In [18]: for key, value in dict_1.items():
　　 ...: dict_3[key] = value
　　 ...:
　　In [19]: for key, value in dict_2.items():
　　 ...: dict_3[key] = value
　　 ...:
　　In [20]: dict_3
　　Out[20]: {'Tony': 24, 'ben': 18}

In [9]: dict_1
　　Out[9]: {'Tony': 24}
　　In [10]: dict_2
　　Out[10]: {'ben': 18}
　　In [12]: dict_3 = dict_1.copy()
　　In [13]: dict_3.update(dict_2)
　　In [14]: dict_3
　　Out[14]: {'Tony': 24, 'ben': 18}

In [33]: dict_1
　　Out[33]: {'Tony': 24}
　　In [34]: dict_2
　　Out[34]: {'ben': 18}
　　In [35]: dict_3 = dict(dict_1, **dict_2)
　　In [36]: dict_3
　　Out[36]: {'Tony': 24, 'ben': 18}

　　字典推导式

　　和列表推导式类似，优点是底层用C实现，会快很多，推荐使用。

　　对换字典的键值

　　使用字典推导式可以轻松对换一个字典的键值：

In [42]: dict_4
　　Out[42]: {24: 'Tony', 18: 'ben'}
　　In [43]: dict_3
　　Out[43]: {'Tony': 24, 'ben': 18}
　　In [44]: dict_4 = {k:v for v, k in dict_3.items()}
　　In [45]: dict_4
　　Out[45]: {24: 'Tony', 18: 'ben'}

　　想创建一个字典，其本身是另一个字典的子集。

　　举个例子：

In [88]: a = {'Ben': 18, 'Jack': 12, 'Ring': 23, 'Tony': 24}
　　In [89]: b = {k:v for k, v in a.items() if v > 18}
　　In [90]: b
　　Out[90]: {'Ring': 23, 'Tony': 24}

　　在Python3.6之前的字典是无序的，但是有时候我们需要保持字典的有序性，orderDict可以在dict的基础上实现字典的有序性，这里的有序指的是按照字典key插入的顺序来排列，这样就实现了一个先进先出的dict，当容量超出限制时，先删除最早添加的key。

　　举例：

In [49]: from collections import OrderedDict
　　In [50]: ordered_dict = OrderedDict([('a', 2), ('b', 4), ('c', 5)])
　　In [51]: for key, value in ordered_dict.items():
　　 ...: print(key, value)
　　 ...:
　　a 2
　　b 4
　　c 5

　　原理：OrderedDict内部维护了一个双向链表，它会根据元素加入的顺序来排列键的位置，这也就导致OrderedDict的大小是普通字典的2倍多。

　　合并列表中key相同的字典

　　也就是生成所谓的一键多值字典，需要将对应的多个值保存在其它容器比如列表或集合，取决于多值是否需要保证唯一性。

　　举个例子：

In [64]: from collections import defaultdict
　　In [65]: a = [{'a': 1}, {'b': 3}, {'c': 4}, {'a':5}, {'b':2}, {'b': 4}]
　　In [66]: b = defaultdict(list)
　　In [67]: [b[k].append(v) for item in a for k, v in item.items()]
　　Out[67]: [None, None, None, None, None, None]
　　In [68]: b
　　Out[68]: defaultdict(list, {'a': [1, 5], 'b': [3, 2, 4], 'c': [4]})
　　In [69]: b['a']
　　Out[69]: [1, 5]

　　场景：寻找两个字典中的异同，包括相同的键或者相同的值。

　　分析：字典是一系列键值之间的映射集合，有以下特点：

　　keys()会返回字典中的所有键，并且字典的键是支持集合操作的，所以利用集合的交叉并补即可对字典的键进行处理；

　　items()返回(key, value)组成的对象，支持集合操作；

　　values()并不支持集合操作，因为并不能保证所有的值是唯一的，但是如果必须要判断操作，可以先将值转化为集合来实现。

　　举例：

In [78]: a = {'a':1, 'b':2, 'c':3}
　　In [79]: b = {'b':3, 'c':3, 'd':4}
　　In [80]: a.keys() & b.keys()
　　Out[80]: {'b', 'c'}
　　In [81]: a.keys() - b.keys()
　　Out[81]: {'a'}
　　In [82]: a.items() & b.items()
　　Out[82]: {('c', 3)}

In [85]: a
　　Out[85]: {'a': 1, 'b': 2, 'c': 3}
　　In [86]: c = {k: a[key] for k in a.keys() - {'b'}}
　　In [87]: c
　　Out[87]: {'a': 3, 'c': 3}

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。