Python字典中你必须知道的用法
本文Python版本为3.7.X,阅读本文之前需了解python字典的基本用法。
介绍
字典(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教程 栏目,欢迎学习!
Atas ialah kandungan terperinci Python字典中你必须知道的用法. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!

Alat AI Hot

Undresser.AI Undress
Apl berkuasa AI untuk mencipta foto bogel yang realistik

AI Clothes Remover
Alat AI dalam talian untuk mengeluarkan pakaian daripada foto.

Undress AI Tool
Gambar buka pakaian secara percuma

Clothoff.io
Penyingkiran pakaian AI

AI Hentai Generator
Menjana ai hentai secara percuma.

Artikel Panas

Alat panas

Notepad++7.3.1
Editor kod yang mudah digunakan dan percuma

SublimeText3 versi Cina
Versi Cina, sangat mudah digunakan

Hantar Studio 13.0.1
Persekitaran pembangunan bersepadu PHP yang berkuasa

Dreamweaver CS6
Alat pembangunan web visual

SublimeText3 versi Mac
Perisian penyuntingan kod peringkat Tuhan (SublimeText3)

Topik panas

Python ialah bahasa pengaturcaraan peringkat tinggi yang ditafsirkan, berorientasikan objek, dengan semantik dinamik. Dibangunkan oleh GudioVanRossum pada tahun 1991. Ia menyokong pelbagai paradigma pengaturcaraan, termasuk pengaturcaraan berstruktur, berorientasikan objek dan berfungsi. Sebelum kita menyelami topik ini, mari kita semak semula konsep asas yang berkaitan dengan soalan yang kami sediakan. Kamus ialah set item yang unik, boleh ubah dan teratur. Pendakap kerinting digunakan semasa menulis kamus, dan ia mengandungi kunci dan nilai: nama kunci boleh digunakan untuk merujuk kepada objek kamus. Nilai data disimpan dalam kamus dalam bentuk pasangan kunci:nilai. Maksud tertib dan tidak tersusun Apabila kita mengatakan kamus itu tersusun, maksudnya kandungannya mempunyai susunan tertentu dan tidak berubah. Item yang tidak dipesan tidak mempunyai pesanan yang jelas dan oleh itu tidak boleh digunakan

Klasifikasi dan Analisis Penggunaan Komen JSP Komen JSP terbahagi kepada dua jenis: komen satu baris: berakhir dengan, hanya satu baris kod boleh diulas. Komen berbilang baris: bermula dengan /* dan berakhir dengan */, anda boleh mengulas berbilang baris kod. Contoh ulasan satu baris Contoh ulasan berbilang baris/**Ini ialah ulasan berbilang baris*Boleh mengulas pada berbilang baris kod*/Penggunaan ulasan JSP Komen JSP boleh digunakan untuk mengulas kod JSP agar lebih mudah dibaca

Kamus dalam Python ialah struktur data yang fleksibel dan berkuasa yang boleh menyimpan pasangan nilai kunci dan mempunyai fungsi carian dan sisipan pantas. Walau bagaimanapun, jika anda tidak berhati-hati dengan pasangan nilai kunci kamus, anda mungkin menghadapi masalah kekunci kamus kosong. Masalah ini sering menyebabkan kod ranap atau mengeluarkan hasil yang tidak dijangka. Artikel ini akan memperkenalkan dua kaedah untuk menyelesaikan ralat kunci kamus kosong dalam Python. Kaedah 1: Gunakan penyataan jika untuk menghalang kekunci kamus kosong, kamus Python tidak boleh mempunyai kunci pendua, jika tidak pasangan nilai kunci sebelumnya akan ditimpa. Apabila nilai kunci kamus kosong

Kamus ialah jenis data yang berkuasa dalam Python. Ia terdiri daripada pasangan nilai kunci. Operasi carian, penambahan dan lain-lain boleh diselesaikan dengan cekap melalui jenis data ini. Walaupun mengakses nilai dalam kamus adalah mudah, mungkin terdapat situasi di mana anda perlu mencari kunci seterusnya dalam kamus. Python menyediakan beberapa cara untuk mencapai ini, bergantung pada keperluan khusus anda. Dalam artikel ini, kami akan meneroka cara yang berbeza untuk mendapatkan kunci seterusnya dalam kamus dalam Python. Menggunakan kunci dan kaedah indeks kamus adalah koleksi tidak tertib dalam Python. Oleh itu, kita perlu menukar kunci ke dalam bentuk yang disusun terlebih dahulu. Mula-mula kita boleh menambahkan semua kunci dalam bentuk senarai. Seterusnya, kita boleh mencari kunci seterusnya dengan mengindeks senarai. Dengan bantuan kunci kita juga boleh

Cara menggunakan fungsi keluar dalam bahasa C memerlukan contoh kod khusus Dalam bahasa C, kita selalunya perlu menamatkan pelaksanaan program pada awal program, atau keluar dari program dalam keadaan tertentu. Bahasa C menyediakan fungsi exit() untuk melaksanakan fungsi ini. Artikel ini akan memperkenalkan penggunaan fungsi exit() dan memberikan contoh kod yang sepadan. Fungsi exit() ialah fungsi perpustakaan standard dalam bahasa C dan disertakan dalam fail pengepala. Fungsinya adalah untuk menamatkan pelaksanaan program, dan boleh mengambil integer

WPS ialah suite perisian pejabat yang biasa digunakan, dan fungsi jadual WPS digunakan secara meluas untuk pemprosesan dan pengiraan data. Dalam jadual WPS, terdapat fungsi yang sangat berguna, fungsi DATEDIF, yang digunakan untuk mengira perbezaan masa antara dua tarikh. Fungsi DATEDIF ialah singkatan daripada perkataan Inggeris DateDifference Sintaksnya adalah seperti berikut: DATEDIF(start_date,end_date,unit) dengan start_date mewakili tarikh mula.

Pengenalan kepada fungsi Python: penggunaan dan contoh fungsi abs 1. Pengenalan kepada penggunaan fungsi abs Dalam Python, fungsi abs ialah fungsi terbina dalam yang digunakan untuk mengira nilai mutlak nilai tertentu. Ia boleh menerima hujah berangka dan mengembalikan nilai mutlak nombor itu. Sintaks asas fungsi abs adalah seperti berikut: abs(x) dengan x ialah parameter berangka untuk mengira nilai mutlak, yang boleh menjadi integer atau nombor titik terapung. 2. Contoh fungsi abs Di bawah kami akan menunjukkan penggunaan fungsi abs melalui beberapa contoh khusus: Contoh 1: Pengiraan

C++ berbeza daripada Python dari segi kamus dengan nama yang sama, tetapi ia mempunyai struktur data yang sama dengan fungsi yang serupa. C++ menyokong pemetaan, yang boleh digunakan dalam kelas STL std::map. Objek peta mengandungi sepasang nilai dalam setiap entri, satu adalah nilai utama dan satu lagi adalah nilai peta. Nilai utama digunakan untuk mencari dan mengenal pasti secara unik entri dalam peta. Walaupun nilai yang dipetakan tidak semestinya unik, nilai utama mestilah sentiasa unik dalam peta. Mari kita lihat cara menggunakan pemetaan. Mula-mula, mari lihat cara untuk menentukan struktur data yang dipetakan dalam C++. Sintaks #includemap<data_type1,data_type2>myMap Mari kita ambil contoh untuk melihat cara melakukan ini − Contoh #incl
