Python 字典

1|0字典

1|1定义

字典用于存储一系列键值对，并且字典是动态的，与列表类似，可随时在字典中添加 键值对

其中每个 键 都与一个 值 相关联，知道了键就可以访问与其相关联的值

与键关联的可以是任意对象，例如：数字、字符串、列表以及字典等。

字典与列表、元组的表示方式不同，主要使用 花括号{}，在花括号中存放的是一个个键值对

diction = {'color': 'red', 'name' : 'Sean'}

字典使用 花括号 {}

列表使用 方括号 []

元组使用 圆括号 ()

键与值之间使用 冒号 : 分隔，键值对之间使用 逗号 分隔

字典中对于键值对个数是没有限制的，若定义的键值对较多，可以多行定义

>>> ages = {
...     'Bob' : 23,
...     'Mary' : 19,
...     'Kevin' : 30,
... 	}
>>> print(ages)
{'Bob': 23, 'Mary': 19, 'Kevin': 30}

注意：多行定义时，最后一个键值对后面最后加上一个 逗号，方便以后修改代码；并且右花括号最好与键对齐，显得美观

1|2空字典

使用空的花括号定义 空字典

方式：变量 = {}

>>> colors = {}
>>> print(colors)
{}
>>> type(colors)
<class 'dict'>

1|3创建字典的另外一种方法

若给定了多个 键，可以使用 fromkeys()函数 来创建字典，每个键都会被设置为默认值None，也可以传入另外一个参数来设置默认值

第一个参数的 多个键 可以使用 列表或者元组 来表示

方式：变量 = dict.fromkeys([], 默认值)

变量 = dict.fromkeys((), 默认值)

>>> diction1 = dict.fromkeys(['Bob', 'Jack'])
>>> print(diction1)
{'Bob': None, 'Jack': None}
>>> diction2 = dict.fromkeys(('Bob', 'Jack'))
>>> print(diction2)
{'Bob': None, 'Jack': None}
>>> diction3 = dict.fromkeys(('Bob', 'Jack'), 'DEFAUTL')
>>> print(diction3)
{'Bob': 'DEFAUTL', 'Jack': 'DEFAUTL'}
>>> diction4 = dict.fromkeys(['Bob', 'Jack'], 'DEFAUTL1')
>>> print(diction4)
{'Bob': 'DEFAUTL1', 'Jack': 'DEFAUTL1'}

1|4访问字典

• 方括号方式访问
• get() 函数
• setdefault() 函数

1|0方括号方式访问

若想获取字典中与 键 相关联的 值，需要指定 字典名，并在字典名后面的方括号中指定 键

方式：字典名[键]

>>> diction = {'color' : 'red', 'names' : 'sean'}
>>> print(diction['color'])
red

此处与元组、列表获取元素信息相似，都是在方括号内指定目标元素

元组：元组名[索引]

列表：列表名[索引]

字典：字典名[键]

若方括号内的键不存在，会报 键错误，KeyError

>>> names = {'name' : '1', 'age' : 2}
>>> print(names['grade'])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'grade'

1|0通过get()函数

该函数与 方括号方式访问 类似，区别在于：若方括号访问的键不存在，会报错误 KeyError，而若使用 get()函数，则会返回 None

方式：字典名.get(键)

>>> names = {'name' : '1', 'age' : 2}
>>> print(names.get('grade'))
None
>>> print(names.get('name'))
1

1|0setdefault() 函数

使用 setdefault() 函数，可以根据 键 来得到与其相关联的 值。

当 键 在字典中不存在时，该函数会为这个 键 设置一个默认值，再返回该 键 的值。

方式：字典名.setdefault(键， 值)

>>> names = {'name' : '1', 'age' : '2', 'day' : '30'}
>>> print(names.setdefault('name'))
1
>>> print(names.setdefault('money'))
None
>>> print(names)
{'name': '1', 'age': '2', 'day': '30', 'money': None}
>>> print(names.setdefault('name', '3'))
1
>>> print(names)
{'name': '1', 'age': '2', 'day': '30', 'money': None}
>>> print(names.setdefault('job', '35'))
35
>>> print(names)
{'name': '1', 'age': '2', 'day': '30', 'money': None, 'job': '35'}

由上面的代码可知：

• 若目标键存在，则该函数会返回与其关联的值
• 若目标键存在，且第二个参数也设置了值，则 新值 不会修改 原值，即字典不会变
• 若目标键不存在，且第二个参数未赋值，则会为该 键 设置默认值，并添加该 键值对 到字典中（默认值通常是 None）
• 若目标键不存在，且第二个参数赋值了，则会将该 键值对 添加到字典中

1|5修改字典

字典是动态的，可以随时修改字典

1|0添加键值对

• 使用方括号形式添加
• 使用 update() 函数
• 使用 setdefault() 函数

1|0方括号赋值

添加键值对时，需要指定 字典名、新添加的键名 以及 与键关联的值

方式：字典名[键] = 值

>>> diction = {'color' : 'red', 'names' : 'sean'}
>>> print(diction)
{'color': 'red', 'names': 'sean'}
>>> diction['age'] = 24
>>> print(diction)
{'color': 'red', 'names': 'sean', 'age': 24}

列表中，添加元素的方法主要是 append(值)、insert(索引， 值)

元组不能动态增加，只能是重新对元组变量赋值

键值对的排列顺序与其添加顺序并不相同，Python更加关注 键和值之间的关联关系，而不是 键值对的添加顺序。同理，在获取字典时，获取的顺序是不可预测的。

1|0update() 函数

update() 函数可以实现对字典键值对的更新

若键已存在，则将新值覆盖原本与键相关联的值

若键不存在，则会将这个键值对添加到字典中

方式：字典名.update({键:值, 键:值, ...})

>>> names = {'name' : '1', 'age' : 2}
>>> names.update({'name' : '2'})
>>> print(names)
{'name': '2', 'age': 2}
>>> names.update({'day' : '88'})
>>> print(names)
{'name': '2', 'age': 2, 'day': '88'}

1|0setdefault() 函数

方式：字典名.setdefault(键， 值)

若目标键在字典中不存在，且第二个参数未赋值，则会对该键设置默认值None，并将该键值对添加到字典中

若目标键在字典中不存在，且第二个参数赋值了，则会将该键值对添加到字典中

>>> names = {'name' : '1', 'age' : '2', 'day' : '30'}
>>> print(names.setdefault('money'))
None
>>> print(names)
{'name': '1', 'age': '2', 'day': '30', 'money': None}
>>> print(names.setdefault('job', '35'))
35
>>> print(names)
{'name': '1', 'age': '2', 'day': '30', 'money': None, 'job': '35'}

1|0删除键值对

• del语句
• pop() 函数

1|0del语句

使用 del语句 可以删除不需要的键值对，这种删除是彻底删除，永远消失了

需要指定需要删除的 字典名 与 键

方式：del 字典名[键]

>>> diction = {'color' : 'red', 'names' : 'sean'}
>>> print(diction)
{'color': 'red', 'names': 'sean'}
>>> del diction['names']
>>> print(diction)
{'color': 'red'}

删除列表的元素可以使用：del语句、pop()、pop(索引)、remove(值)

删除元组可以使用：del语句

1|0pop() 函数

pop()函数的参数是 要删除的键，该函数会返回该键的值，并且删除该键值对

>>> names = {'name' : '1', 'age' : 2}
>>> name = names.pop('name')
>>> print(name)
1
>>> print(names)
{'age': 2}

1|0删除整个字典

使用 del语句 还可以直接删除整个字典

方式：del 字典名

>>> diction = {'color' : 'red', 'names' : 'sean'}
>>> print(diction)
{'color': 'red', 'names': 'sean'}
>>> del diction
>>> print(diction)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'diction' is not defined

1|0修改字典中的值

修改字典中的值的方式类似于 添加键值对，只不过所指定的 键名 是字典中已存在的键名，而添加键值对时所指定的键是字典中不存在的键

方式：字典名[键] = 值

>>> diction = {'color' : 'red', 'names' : 'sean'}
>>> print(diction)
{'color': 'red', 'names': 'sean'}
>>> diction['color'] = 'blue'
>>> print(diction)
{'color': 'blue', 'names': 'sean'}

列表中修改元素的值：列表名[索引] = 值

要修改元组的值，只能是重新定义整个元组变量

使用 update() 函数同样可以实现修改字典中的值

>>> names = {'name' : '1', 'age' : 2}
>>> names.update({'name' : '2'})
>>> print(names)
{'name': '2', 'age': 2}

1|0清空键值对

使用 clear()函数 可以清空字典中所有的键值对，字典会变成空字典

>>> names = {'name' : '1', 'age' : 2}
>>> print(names)
{'name': '1', 'age': 2}
>>> names.clear()
>>> print(names)
{}

1|0随机弹出一个键值对

使用 popitem() 函数，可以随机弹出字典中的一个键值对

注意：该函数弹出的键值对是一个元组

>>> names = {'name' : '1', 'age' : '2', 'day' : '30'}
>>> print(names.popitem())
('day', '30')
>>> print(names)
{'name': '1', 'age': '2'}

1|6遍历字典

遍历字典的方式主要有三种：

• 遍历字典的所有键值对 items()函数
• 遍历字典的所有键 默认是遍历所有键或显式调用keys()函数
• 遍历字典所有的值 values()函数

注：对于这三个函数的使用不要死板，它们的返回值是个列表，不一定非得遍历时才能用，在判断一个值是否是该字典的键或者值时也可以使用

if i in diction.values:
    print(i)

1|0遍历所有键值对

关键：两个临时变量、for 循环、对字典变量调用 items() 函数获取键值对列表

由于字典有键与值，所以使用 for 循环遍历字典时，需要使用两个临时变量，用于在每次循环中存储键值对的键与值，例如：k 与 v、key 与 value

并且使用for循环时，要对字典变量调用 items() 函数进行处理，该函数会返回字典的键值对列表

>>> users = {
...     'username' : 'sean',
...     'age' : '24',
...     'color' : 'yellow',
...     }
>>> for key, value in users.items():
...     print("Key: " + key)
...     print("Value: " + value + "\n")
... 
Key: username
Value: sean

Key: age
Value: 24

Key: color
Value: yellow

如果值有数字的话，输出时最好将其通过 str() 函数转换为 字符串输出，否则会报类型错误

>>> users = {
...     'username' : 'sean',
...     'age' : 24,
...     'color' : 'yellow',
...     }
>>> for key, value in users.items():
...     print("Key: " + key)
...     print("Value: " + str(value) + "\n")
... 
Key: username
Value: sean

Key: age
Value: 24

Key: color
Value: yellow

注意：遍历字典时，items() 函数返回的键值对顺序可能与字典的存储顺序不同，进而导致遍历输出的字典顺序与其存储顺序不同。因为Python不关心键值对的存储顺序，只关注键与值直接的关联关系

1|0遍历字典中的所有键

当只需要遍历字典中所有的键时，只需要将 items() 函数 换为 keys() 函数

key() 函数会以列表的形式返回该字典所有的键

但由于遍历字典时，默认是遍历字典所有的键，所以在 for循环 中，直接指定 字典名 即可，不需要再对字典变量调用任何函数

即，若对字典变量显式地调用 keys() 函数，与对字典变量不调用任何函数的效果一样，因为默认遍历字典所有的键

由于只需要键的信息，所以只需要一个临时变量

>>> colors = {
...     'Bob' : '1',
...     'Jack' : '2',
...     'Kevin' : '3',
...     }
>>> for key in colors:
...     print(key)
... 
Bob
Jack
Kevin
>>> for key in colors.keys():
...     print(key)
... 
Bob
Jack
Kevin

1|0遍历字典中所有的值

与遍历所有的键类似，遍历所有的值时，字典变量调用的函数是 values()

value()函数 返回一个值列表，不包含任何键

写for循环时，也只需要一个临时变量即可

>>> colors = {
...     'Bob' : '1',
...     'Jerry' : '2',
...     'Kevin' : '3',
...     }
>>> for value in colors.values():
...     print(value)
... 
1
2
3

values()函数 默认是不处理重复的值，若需要去除重复的值，可以将返回的值列表使用 set()函数 转换为集合

>>> numbers = {
...     'Bob' : '1',
...     'Jerry' : '1',
...     'Kevin' : '3',
...     }
>>> for value in set(numbers.values()):
...     print(value)
... 
3
1

从此处也能发现，values()函数返回的值列表的顺序也并非字典定义时值的顺序

1|7字典与列表、字典结合

1|0字典列表

在列表中包含大量的字典，这种列表中的每个元素都是一个字典，而其中每个字典都包含特定对象的众多信息

>>> lists = []
>>> for i in range(0, 10):
...     people = {'names' : 'Sean', 'age' : 24}
...     lists.append(people)
... 
>>> for i in lists[:5]:
...     print(i)
... 
{'names': 'Sean', 'age': 24}
{'names': 'Sean', 'age': 24}
{'names': 'Sean', 'age': 24}
{'names': 'Sean', 'age': 24}
{'names': 'Sean', 'age': 24}
>>> type(lists)
<class 'list'>
>>> for i in lists[:5]:
...     for k in i.values():
...             print(k)
... 
Sean
24
Sean
24
Sean
24
Sean
24
Sean
24

可以看出，lists 里面的每个元素都是 字典

1|0在字典中存储列表

当要在字典中将一个键与多个值关联时，就要在字典中嵌套一个列表

在定义字典时，与键相关联的值 是一个列表

所以访问该列表时，需要指名 字典名 与 相关联的键名

并且可以对该列表进行遍历

>>> person = {
...     'names' : 'Sean',
...     'colors' : ['red', 'yellow', 'blue'],
...     }
>>> print(person['colors'])
['red', 'yellow', 'blue']
>>> print(person['colors'][0])
red
>>> for i in person['colors']:
...     print(i)
... 
red
yellow
blue

若字典中每个键相关联的值都是列表，若要对每个列表都遍历：

>>> colors = {
...     'Bob' : ['red', 'blue'],
...     'Kevin' : ['yellow', 'black'],
...     'David' : ['white', 'green'],
...     }
>>> for k, v in colors.items():
...     print(k + " likes :")
...     for i in v:
...             print("\t" + i)
... 
Bob likes :
	red
	blue
Kevin likes :
	yellow
	black
David likes :
	white
	green

1|0在字典中存储字典

字典中的键不能是字典，但与键相关联的值可以是字典

应注意，每个键对应的字典定义完后，右花括号后面不要遗忘 逗号

需要两个临时变量，k 存储 大字典的键，v存储 与键相关联的字典

>>> persons = {
...     'Bob' : {
...             'name' : 'Bob',
...             'age' : '19',
...             },
...     'David' : {
...             'name' : 'David',
...             'age' : '24',
...             },
...     }
>>> for k, v in persons.items():
...     print(v['name'] + "\t" + v['age'])
... 
Bob	19
David	24

注意：在使用这种字典嵌套字典的结构时，为了编写代码更加方便，最好内部的字典的结构要都相同

__EOF__

本文作者：在青青草原上抓羊
本文链接：https://www.cnblogs.com/seansheep/p/14379669.html
关于博主：评论和私信会在第一时间回复。或者直接私信我。
版权声明：本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！
声援博主：如果您觉得文章对您有帮助，可以点击文章右下角【推荐】一下。您的鼓励是博主的最大动力！