目录
序言：
字典是映射类型的典型代表，字典是 键-值 元素项的组合，每一个元素是一个键值对，表示为(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))
程序运行结果：
{} {} <class 'dict'> <class 'dict'>
② 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)
程序运行结果：
③ 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)
-
<ipython-input-50-b6cfcff029fa> in
<module>()
-
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 "
<ipython-input-65-aa17f57e0b8d>", 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)
程序运行结果：
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)
#深拷贝，父对象，子对象都不改变。
程序运行结果：
总结：(原始字典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
程序运行结果：
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
程序运行结果：
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)]) <class 'dict_items'>
7.0 keys()函数
描述：返回字典d中所有键的信息。
语法：d.keys()
程序示例：
-
d = {
"one":
1,
"two":
2,
"three":
3}
-
print(d.keys(),type(d.keys()))
程序运行结果：
dict_keys(['two', 'one', 'three']) <class 'dict_keys'>
8.0 values()函数
描述：返回字典d中所有值的信息。
语法：d.values()
程序示例：
-
d = {
"one":
1,
"two":
2,
"three":
3}
-
print(d.values(),type(d.values()))
程序运行结果：
dict_values([2, 1, 3]) <class 'dict_values'>
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)
-
<ipython-input-162-3859af2a44e8> in
<module>()
-
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)
<class 'builtin_function_or_method'>
-
---------------------------------------------------------------------------
-
KeyError Traceback (most recent call last)
-
<ipython-input-173-20b7d2dafbc3> in
<module>()
-
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增加了一对新的键值对。
程序运行结果：
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))
#返回值为空
程序运行结果：
1044
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
