python字典操作 - 不止于python

点击上方蓝字关注我们

字典定义

以键值对方式存在的无序数据的组合就是字典

字典基本操作

1. 创建空字典

    变量 = {}

    变量 = dict()

In [1]: d1 = {}  
In [2]: d1  
Out[2]: {}  
  
In [3]: d1 = dict()  
In [4]: d1  
Out[4]: {}

2. 创建多个元素的字典

    2.1 变量 = {键:值,键:值….}

In [5]: d1 = {"a": 1, "b": 2}  
In [6]: d1  
Out[6]: {'a': 1, 'b': 2}

    2.2 变量 = dict({键:值,键:值….})

In [7]: d2 = dict({"c": 3})  
In [8]: d2  
Out[8]: {'c': 3}

    2.3

        变量 = dict(键=值,键=值…)

In [9]: d2 = dict(c=3)  
In [10]: d2  
Out[10]: {'c': 3}

    2.4

        变量 = dict([(键,值),(键,值)…])

        变量 = dict([[键,值],[键,值]…])

        变量 = dict(((键,值),(键,值)…))

In [11]: d3 = dict([("a", 1),("b", 2)])  
In [12]: d3  
Out[12]: {'a': 1, 'b': 2}

    2.5

        变量 = dict(zip((键，键…),(值,值…)))

In [13]: d4 = dict(zip(("a", "b"),(1,2)))  
In [14]: d4  
Out[14]: {'a': 1, 'b': 2}

3. 访问字典元素

    变量[键]

In [18]: d5 = {"a": 1, "b": 2}  
In [19]: d5["a"]  
Out[19]: 1

4. 添加字典元素

    变量[新键] = 值

In [20]: d5["c"] = 3  
In [21]: d5  
Out[21]: {'a': 1, 'b': 2, 'c': 3}

5. 修改字典元素

    变量[键] = 新值

In [22]: d5["c"] = 33  
In [23]: d5  
Out[23]: {'a': 1, 'b': 2, 'c': 33}

6. 删除字典元素

    del 变量[键]

In [24]: del d5["c"]  
In [25]: d5  
Out[25]: {'a': 1, 'b': 2}

7. 检测键是否在字典中

    值 in 字典

In [25]: d5  
Out[25]: {'a': 1, 'b': 2}  
  
In [26]: "a" in d5  
Out[26]: True  
  
In [27]: "c" in d5  
Out[27]: False

8. 检测键是否不在字典中

    值 not in 字典

In [28]: "a" not in d5  
Out[28]: False  
  
In [29]: "c" not in d5  
Out[29]: True

9. 遍历字典

    9.1 遍历键

for 变量 in 字典:

    #使用变量遍历所有的键，有键就可以通过变量访问其值

In [30]: for i in d5:  
    ...:     print(i)  
a  
b

    9.2 遍历键和值

for 变量i，变量j in 字典.items():

    #使用变量i遍历所有键，通过变量j遍历所有值

In [31]: for k,v in d5.items():  
    ...:     print(k,v)  
a 1  
b 2

字典常用函数操作

1. get(键, 不存在返回值): 根据键获取指定的值

In [35]: d5  
Out[35]: {'a': 1, 'b': 2}  
In [36]: d5.get("a", None)  
Out[36]: 1  
In [37]: d5.get("c", None)

2. len(字典): 字典长度

In [40]: len(d5)  
Out[40]: 2

3. max(字典): 字典中的最大的键

In [38]: max(d5)  
Out[38]: 'b'

4. min(字典): 字典中的最小的键

In [73]: min(d9)  
Out[73]: 2

5. clear(): 清空字典

In [49]: d55  
Out[49]: {'a': 1, 'b': 2}  
In [50]: d55.clear()  
In [51]: d55  
Out[51]: {}

6. copy(): 复制字典

In [45]: d55 = d5.copy()  
In [46]: d55  
Out[46]: {'a': 1, 'b': 2}

7. items(): 将字典的键值转化成类似元组的形式方便遍历

In [43]: d5.items()  
Out[43]: dict_items([('a', 1), ('b', 2)])

8. keys(): 将字典的所有键组成一个序列

In [42]: d5.keys()  
Out[42]: dict_keys(['a', 'b'])

9. values(): 将字典的所有值组成一个序列

In [44]: d5.values()  
Out[44]: dict_values([1, 2])

10. pop(键, 不存在返回值): 移除字典中指定的元素

    不填默认值: 不存在会报错

In [52]: d5  
Out[52]: {'a': 1, 'b': 2}  
In [53]: d5.pop("a", None)  
Out[53]: 1  
In [54]: d5.pop("a", None)  
In [55]: d5.pop("a")  
---------------------------------------------------------------------------  
KeyError Traceback (most recent call last)  
<ipython-input-55-c14e784d38a1> in <module>  
----> 1 d5.pop("a")  
KeyError: 'a'  
In [58]: d5  
Out[58]: {'b': 2}

11. popitem(): 移除字典中的键值对, 字典为空的话会报错

In [58]: d5  
Out[58]: {'b': 2}  
In [59]: d5.popitem()  
Out[59]: ('b', 2)

12. setdefault(键, 默认值): 添加一个元素

如果键存在, 则不会进行任何操作

如果键不存在, 如果有默认值, 则添加, 如果没有, 值为None

In [60]: d5.setdefault("a", 1)  
Out[60]: 1  
In [61]: d5  
Out[61]: {'a': 1}

13. update(): 修改字典中的值

    13.1 字典.update(键=值)

In [63]: d5  
Out[63]: {'a': 1}  
In [64]: d5.update(b=2)  
In [65]: d5  
Out[65]: {'a': 1, 'b': 2}

    13.2 字典.update({键:值})

In [66]: d5.update({"c": 3})  
In [67]: d5  
Out[67]: {'a': 1, 'b': 2, 'c': 3}

字典推导式

1. 普通的字典推导式

    变量= {key:value for key,value in 字典.items()}

In [68]: d5  
Out[68]: {'a': 1, 'b': 2, 'c': 3}  
In [69]: d6 = {k:v for k,v in d5.items()}  
In [70]: d6  
Out[70]: {'a': 1, 'b': 2, 'c': 3}

2. 带有判断条件的字典推导式

    变量= {key:value for key,value in 字典.items() if 条件表达式}

In [71]: d7 = {k:v for k,v in d5.items() if k != "c"}  
In [72]: d7  
Out[72]: {'a': 1, 'b': 2}

3. 多个循环的字典推导式

新的字典中元素个数=字典1中元素个数 * 字典2中的元素个数

变量 = {i+x:j+y for i，j in 字典1.items for x，y in 字典2.items()}

In [75]: d8 = {k+k1:v+v1 for k,v in d5.items() for k1, v1 in d7.items()}  
In [76]: d8  
Out[76]: {'aa': 2, 'ab': 3, 'ba': 3, 'bb': 4, 'ca': 4, 'cb': 5}

4. 带有判断条件的多个循环的字典推导式

新的字典数量由判断条件决定 = 符合条件的剩余的字典1个数 * 符合条件的剩余的字典2个数

变量 = {i+x:j+y for i，j in 字典1.items for x，y in 字典2.items() if 条件表达式}

In [83]: d9 = {k+k1:v+v1 for k,v in d5.items() for k1, v1 in d7.items() if k != "a" and v1 > 1}  
In [84]: d9  
Out[84]: {'bb': 4, 'cb': 5}