Python 字典

字典

定义

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

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

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

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

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

字典使用花括号 {}

列表使用方括号 []

元组使用圆括号 ()

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

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

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

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

空字典

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

方式：变量 = {}

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

创建字典的另外一种方法

若给定了多个键，可以使用 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'}

访问字典

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

方括号方式访问

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

方式：字典名[键]

>>> 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'

通过get()函数

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

方式：字典名.get(键)

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

setdefault() 函数

使用 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）
若目标键不存在，且第二个参数赋值了，则会将该键值对添加到字典中

修改字典

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

添加键值对

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

方括号赋值

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

方式：字典名[键] = 值

>>> 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更加关注 键和值之间的关联关系，而不是键值对的添加顺序。同理，在获取字典时，获取的顺序是不可预测的。

update() 函数

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'}

setdefault() 函数

方式：字典名.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'}

删除键值对

del语句
pop() 函数

del语句

使用 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语句

pop() 函数

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

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

删除整个字典

使用 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

修改字典中的值

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

方式：字典名[键] = 值

>>> 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}

清空键值对

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

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

随机弹出一个键值对

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

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

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

遍历字典

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

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

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

if i in diction.values:
    print(i)

遍历所有键值对

关键：两个临时变量、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不关心键值对的存储顺序，只关注键与值直接的关联关系

遍历字典中的所有键

当只需要遍历字典中所有的键时，只需要将 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

遍历字典中所有的值

与遍历所有的键类似，遍历所有的值时，字典变量调用的函数是 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()函数返回的值列表的顺序也并非字典定义时值的顺序

字典与列表、字典结合

字典列表

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

>>> 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 里面的每个元素都是字典

在字典中存储列表

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

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

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

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

>>> 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

在字典中存储字典

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

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

需要两个临时变量，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

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

posted @ 2021-02-05 20:41 SeanSiyang 阅读(64) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

在青青草原上抓羊

Python 字典

字典

定义

空字典

创建字典的另外一种方法

访问字典

方括号方式访问

通过get()函数

setdefault() 函数

修改字典

添加键值对

方括号赋值

update() 函数

setdefault() 函数

删除键值对

del语句

pop() 函数

删除整个字典

修改字典中的值

清空键值对

随机弹出一个键值对

遍历字典

遍历所有键值对

遍历字典中的所有键

遍历字典中所有的值

字典与列表、字典结合

字典列表

在字典中存储列表

在字典中存储字典

公告