引见
字典(dict)是Python中内置的一个数据构造,由多个键值对组成,键(key)以及值(value)用冒号分隔,每一个键值对之间用逗号(,)分隔,整个字典包罗正在年夜括号中({}),键必需是惟一的,值能够取任何类型,然而键必需是不成变类型,如字符串,数字或元组。
保举:《python教程》
底层应用了hash表来联系关系key以及value,dict是无序的。特性包罗:
● 查找以及拔出的速率极快,没有会跟着key的添加而变慢;
● 需求占用的内存较多
以是,dict是一种以空间换取工夫的数据构造,使用于需求疾速查找的场景。
操作:罕用办法
get()
前往指定键的值,假如key没有存正在,则前往默许值(默许为None),而没有会报错,语法为dict.get(key)。
dict_1['age'] = 24 In [7]: print(dict_1.get('age')) 24 In [11]: print(dict_1.get('nama')) None In [12]: print(dict_1['nama']) --------------------------------------------------------------------------- KeyError Traceback (most recent call last) <ipython-input-12-ef61a380920e> in <module> ----> 1 print(dict_1['nama']) KeyError: 'nama'
key in dict
应用in操作符来判别键能否存正在于字典中,存正在则前往True,不然前往False,语法为:key in dict。
In [15]: dict_1 Out[15]: {'name': None, 'age': 24, 'sex': None} In [16]: print('name' in dict_1) True In [17]: print('nama' in dict_1) False
正在python 2中该性能应用has_key()办法完成。
items()
以列表方式前往可遍历的(键, 值)元组数组,语法为dict.items()。
In [18]: dict_1 Out[18]: {'name': None, 'age': 24, 'sex': None} In [19]: print(dict_1.items()) dict_items([('name', None), ('age', 24), ('sex', None)]) In [20]: for key, value in dict_1.items(): ...: print(key, value) ...: name None age 24 sex None
keys()
以列表前往一个字典的一切键:dict.keys()
In [21]: dict_1 Out[21]: {'name': None, 'age': 24, 'sex': None} In [22]: print(dict_1.keys()) dict_keys(['name', 'age', 'sex'])
values()
以列表方式前往字典中的一切值:dict.values()
In [27]: dict_1 Out[27]: {'name': None, 'age': 24, 'sex': None, 'sub_name': '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': ''}
clear()
删除了字典中的一切项,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]: {}
copy()
浅拷贝原始字典,前往一个具备相反键值对的新字典,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]}
fromkeys()
创立一个新字典,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}
update()
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}
借助字典的dict(d1, **d2)办法
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外部保护了一个双向链表,它会依据元素退出的程序来陈列键的地位,这也就招致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}
本文来自 python教程 栏目,欢送学习!
以上就是Python字典中你必需晓得的用法的具体内容,更多请存眷资源魔其它相干文章!
标签: 用法 python教程 python编程 python使用问题 字典
抱歉,评论功能暂时关闭!