python字典用法大全

目录

序言：

1.0 dict()函数

2.0 clear()函数

3.0 copy()函数

4.0 fromkeys()函数

5.0 get()函数

6.0 items()函数

7.0 keys()函数

8.0 values()函数

9.0 pop()函数

10.0 popitem()函数

11.0 setdefault()函数

12.0 update()函数

---

 

序言：

字典是映射类型的典型代表，字典是 键-值 元素项的组合，每一个元素是一个键值对，表示为(key,value)。字典与集合具有类似的性质，即字典中的键值对之间是无序的，并且不能重复，也没有下标索引。

python中字典用大括号 { } 表示，表示方式如下：

{<键1>:<值1>,<键2>:<值2>,<键3>:<值3>,...,<键n>:<值n>}

1.0 dict()函数

描述：生成一个字典。

语法：

① dict() -> 生成一个空字典。

程序示例：

d = dict() #创建空字典
dt = {} #创建的是空字典，不是空集合
print(d,dt,type(d),type(dt))

 程序运行结果：

{} {}  

② dict(mapping) -> 从映射对象（键，值）对新字典进行初始化。 

程序示例：

d1 = dict(zip([1,2,3],["a","b","c"]))  #具有明显的映射关系
d2 = dict(zip(("a","b","c"),(1,2,3,5))) #第二个元组多个5，不影响映射。
d3 = dict({1:"a",2:"b",5:"c"})
print(d1,d2,d3)

程序运行结果：

{1: 'a', 2: 'b', 3: 'c'} {'a': 1, 'b': 2, 'c': 3} {1: 'a', 2: 'b', 5: 'c'}
In [ ]:

③ dict(iterable) -> 通过iterable(可迭代对象)对新字典进行初始化。

等效于以下代码：

d = {}
for k, v in iterable:
    d[k] = v

程序示例：

d1 = dict([("a",66),(2,5)]) #可迭代的对象的元素只能是值，不能是未定义的变量。
print(d1)

#d1 等效于：
"""d = {}
iterable = [("a",66),(2,5)]
for k, v in iterable:
    d[k] = v"""

d2 = dict([(1,c),(2,"a")]) #程序报错，c可做变量，但未定义。
print(d2)

程序运行结果：

{'a': 66, 2: 5}
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
 in ()
      8     d[k] = v"""
      9 
---> 10 d2 = dict([(1,c),(2,"a")]) #程序报错，b可做变量，但未定义。
     11 print(d2)

NameError: name 'c' is not defined

④ dict(**kwargs) ->在关键字参数列表中使用name = value对新字典进行初始化。

例如：dict(one=1, two=2)  注：关键字参数的等号左边必须为一个变量，且右边必须为一个值，不可为变量，否则会报错。

程序示例：

d1 = dict(one=1,two=2,three=3)
print(d1)

"""d2 = dict(1="a",2="b") #程序报错，1,2不是变量
print(d2)"""

程序运行结果：

{'two': 2, 'one': 1, 'three': 3}

""" File "", line 1
    d2 = dict(1="a",2="b") #程序报错，1,2不是变量
             ^
SyntaxError: keyword can't be an expression"""

• mapping ——元素的容器。
• iterable ——可迭代对象
• **kwargs ——关键字

2.0 clear()函数

描述：删除字典d中所有的键值对。

语法： d.clear() -> None 返回一个空字典

程序示例：

d = {"one":1,"two":2,"three":3}
print("清空前:",d)
d.clear() #清空字典d所有键值对
print("清空后:",d)

程序运行结果：

清空前: {'two': 2, 'one': 1, 'three': 3}
清空后: {}

3.0 copy()函数

描述：生成一个新字典，浅复制字典d中的所有键值对。即父对象不变，但子对象改变。

语法： d.copy() ->返回字典d的浅拷贝

程序示例：

import copy

d1 = {"小明":98,"小红":99,"小东":[33,56,65]}
print("原始数据：",d1)

d2 = d1 # 引用拷贝 d1和d2指向同一个内存地址，d2只是d1的一个别名。
d3 = d1.copy() #浅拷贝，d3和d2的父对象相互独立，但子对象[33,56,65]指向同一个内存地址。
d4 = copy.copy(d1) #深拷贝，父对象，子对象都相互对立。

d1["小明"] = 86 #将字典d1中父对象"小明"的分数修改为 86
d2["小东"].append(95)  #向字典d1中子对象列表[33,56,65]添加一个元素 95

print("修改后的数据:",d1) 
print("引用拷贝:",d2) #引用拷贝，父对象，子对象都改变
print("浅拷贝:",d3) #浅拷贝，父对象不改变，但子对象改变
print("深拷贝:",d4) #深拷贝，父对象，子对象都不改变。

程序运行结果：

原始数据： {'小明': 98, '小红': 99, '小东': [33, 56, 65]}
修改后的数据: {'小明': 86, '小红': 99, '小东': [33, 56, 65, 95]}
引用拷贝: {'小明': 86, '小红': 99, '小东': [33, 56, 65, 95]}
浅拷贝: {'小明': 98, '小红': 99, '小东': [33, 56, 65, 95]}
深拷贝: {'小明': 98, '小红': 99, '小东': [33, 56, 65, 95]}

总结：(原始字典d1,浅拷贝字典d2， 深拷贝字典d3)   

对于浅拷贝 —— 无论是改变 原始字典d1 的子对象，还是改变浅拷贝字典d2 的子对象，字典d1,字典d2的子对象都会改变。但父对象互不影响。

对于深拷贝——整个字典独立，互不影响。

4.0 fromkeys()函数

描述：创建一个新字典，以可迭代对象iterable中元素做字典的键，value 为字典所有键对应的初始值，默认值为None。

语法：fromkeys(iterable, value=None, /)

• iterable —— 可迭代的对象。如 列表，元组，集合，字典，字符串等
• value —— 可迭代的对象或数字，字母。如 列表，元组，集合，字典，字符串等可迭代对象

程序示例：

d1 = {}
d2 = {}
d3 = {}
d4 = {}

print(d1.fromkeys("123")) # iterable为字符串，value为默认值None
print(d2.fromkeys([1,2,"a"],["a",1])) #iterable为列表，value为列表
print(d3.fromkeys({1,"b",2},(1,2))) #iterable为集合，value为元组
print(d4.fromkeys({"a":1,"b":2},1)) #iterable为字典，value为数字 1

程序运行结果：

{'2': None, '3': None, '1': None}
{'a': ['a', 1], 1: ['a', 1], 2: ['a', 1]}
{1: (1, 2), 2: (1, 2), 'b': (1, 2)}
{'a': 1, 'b': 1}

5.0 get()函数

描述：返回d[k],若字典d中无k键，则返回d

语法： d.get(k,d) -> D[k] if k in D, else d. d 默认值为 None.

• k —— 键
• d —— 若k不在字典d中，则返回自定义的d,d默认值为None.

程序示例：

d = {"one":1,"two":2,"three":3}
print(d.get("one",666)) #键"one"存在，返回d["one"]，不返回d值 666
print(d.get("five",666)) #键"five"不存在，返回d值 666
print(d.get("five")) #键"five"不存在，返回d的默认值 None

程序运行结果：

1
666
None

6.0 items()函数

描述：返回字典d中所有键值对

语法： d.items() 

程序示例：

d = {"one":1,"two":2,"three":3}
print(d.items(),type(d.items()))

程序运行结果：

dict_items([('two', 2), ('one', 1), ('three', 3)]) 

7.0 keys()函数

描述：返回字典d中所有键的信息。

语法：d.keys()

程序示例：

d = {"one":1,"two":2,"three":3}
print(d.keys(),type(d.keys()))

程序运行结果：

dict_keys(['two', 'one', 'three']) 

8.0 values()函数

描述：返回字典d中所有值的信息。

语法：d.values()

程序示例：

d = {"one":1,"two":2,"three":3}
print(d.values(),type(d.values()))

程序运行结果：

dict_values([2, 1, 3]) 

9.0 pop()函数

描述：键存在则返回相应的值，同时删除该键值对，否者返回默认值d。

语法： d.pop(key,d) -> v  删除指定的键并返回相应的值。如果未找到key，则返回d（如果给定），否则引发KeyError错误

• key —— 要删除的键
• d —— 如果没有指定要删除的key,则返回d值。

程序示例：

d = {"one":1,"two":2,"three":3,"four":4,"five":5}
print(d.pop("one")) #返回 键"one"的值
print(d.pop("six",6)) #字典d中无 "six"键，返回d值给定
print(d)
print(d.pop("seven")) #字典d中无 "seven"键，且没有给定d值，程序报错

程序运行结果：

1
6
{'two': 2, 'five': 5, 'four': 4, 'three': 3}
---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
 in ()
      3 print(d.pop("six",6)) #字典d中无 "six"键，返回d值给定
      4 print(d)
----> 5 print(d.pop("seven")) #字典d中无 "seven"键，且没有给定d值，程序报错

KeyError: 'seven'

10.0 popitem()函数

描述：随机从字典d中取出一个键值对，并以元组(key,value)的形式返回,同时将该键值对从字典d中删除。若字典d为空，则引发KeyError。

语法：d.popitem()  -> (k, v) 返回键值对

程序示例：

d = {"one":1,"two":2,"three":3,"four":4,"five":5}
d1 = dict() #创建空字典
print(d.popitem(),type(d.popitem))
print(d1.popitem()) #字典d1为空，程序会报错

程序运行结果：

('two', 2) 
---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
 in ()
      2 d1 = dict()
      3 print(d.popitem(),type(d.popitem))
----> 4 print(d1.popitem()) #字典d1为空，程序会报错

KeyError: 'popitem(): dictionary is empty'

注意 pop()函数 和 popitem()函数 的区别。

11.0 setdefault()函数

描述：如果字典d存在键k，则返回d[k],否者返回d,并将d[k]的值设为d,且将该键值对(k,d)保存在字典d中。

语法：d.setdefault(k,d)  -> d.get(k,d) , also set d[k]=d if k not in d

• k —— 要查找或想要添加的键
• d —— 如果字典d不存在k键，则返回d

程序示例：

d = {"one":1,"two":2,"three":3,"four":4,"five":5}
print(d.setdefault("one",36)) #字典d中存在键"one",返回键"one",对应的值
print(d.setdefault("six",6)) # 字典d中不存在键 "six",返回6,并将("six",6)键值对保存在字典d中
print(d) #字典d增加了一对新的键值对。

程序运行结果：

1
6
{'two': 2, 'five': 5, 'six': 6, 'three': 3, 'four': 4, 'one': 1}

12.0 update()函数

描述：将a中的所有对象添加到字典d中

语法：d.update(a) -> None 返回值为空

a —— 可以是：

• ①一个字典                                                                                                       
• ②关键字 如 six=6
• ③一个包含一个及一个以上元组的列表
• ④一个包含一个及一个以上列表的元组
• ⑤一个zip()函数 如 zip(["a","b"],[1,2])   等

程序示例：

d = {"one":1,"two":2}
d1 = {"three":3,"five":5} #字典
ls = [("six",6),("seven",7)] #包含元组的列表
t = (["eight",8],["ten",10]) #包含列表的元组
d.update(d1)
d.update(ls)
d.update(t)
d.update(eleven=11,twelve=12) #关键字
d.update(zip(["thirteen","fourteen"],[13,14])) #zip
print(d)
print(d.update(d1)) #返回值为空

程序运行结果：

{'seven': 7, 'eight': 8, 'six': 6, 'ten': 10, 'eleven': 11, 'twelve': 12, 'two': 2, 'five': 5, 'thirteen': 13, 'three': 3, 'one': 1, 'fourteen': 14}
None