一、引言

学习Python编程，列表和字典是两个特别重要的知识点，在Python编程中使用甚广，想要学好编程，尤其要深入学习和理解列表和字典的概念，熟练掌握其方法，尤其是要熟练掌握列表和字典地结合使用。

本篇作为列表和字典知识整理系列的姊妹篇，本篇将主要讲述和学习字典这一知识点。

本篇首先会花大量篇幅来讲述字典的常用知识点。

二、字典

字典(Dictionary)是Python中内建的数据结构，是一种可变容器模型，而且是一种具有弹性存储能力的数据结构，其可以存储任何具有映射关系的类型对象。虽然字典可以存放很多中类型的对象，但从实际意义出发不建议将不同类型的元素放到同一个字典中。

字典中的每个元素由键(key)和值(value)成对构成，key和value之间使用英文冒号(:)分割，当字典中有多个元素，元素之间要使用英文逗号(,)分割，整个字典的元素存放在一对花括号({})中。

不同于序列使用使用整数索引，字典是使用key值做索引。可以通过key值做索引访问字典中的元素value值，如果被访问的key值不存在，会抛出KeyErrord的异常错误。

字典中的键(key)必须是可以哈希的值，而且一个字典中的key必须唯一，不能有重复的key。字典中的key是不可变的，这一特性就决定了字典中的key可以为（数字、字符串、元组）这些不可变类型，因为列表和字典是可变类型，所以无法使用列表和字典做字典的key。

字典在Python3.6之前是无序的，Python3.6改写了字典的内部算法，所以Python3.6及以后的版本中字典都是有序的，无需再通过 import collections引入包定义有序字典。

注意：dict作为Python的内置函数和关键字，不建议使用dict定义字典变量名。

2.1 声明字典

-- 声明一个空字典,使用{}符号即可声明一个不含元素的空字典
# 声明一个空字典
dic01 = {}
# 打印该字典内容
print(dic01)

-- 打印输出结果
{}
*************************************************
-- 声明一个有元素字典，字典会将所有元素存放在{}内
# 声明字典
dic01 = {'k1': 'v1', 'k1': 'v2'}
# 打印该字典内容
print(dic01)

-- 打印输出结果
{'k1': 'v1', 'k2': 'v2'}

*************************************************
-- 声明使用数字做字典key
dic01 = {1:'v1',2:3}
print(dic01)

-- 打印输出结果
{1: 'v1', 2: 3}

*************************************************
-- 当字典中拥有相同的key值时，打印字典会只显示字典右边最最后一个key和对应value
# 声明字典
dic01 = {'k1': 'v4', 'k1': 'v1', 'k1': 'v2', 'k1': 'v3'}
# 打印该字典内容
print(dic01)

-- 打印输出结果
{'k1': 'v3'}

*************************************************
-- 声明一个使用元组做字典key
dic01 = {('L1','L2'): 'V1'}
print(dic01)

-- 打印输出结果
{('L1', 'L2'): 'V1'}

*************************************************
-- 如果使用列表做key，就会报错，如下所示
dic01 = {['L1','L2']: 'V1'}
print(dic01)

-- 打印输出结果
    dic01 = {['L1','L2']: 'V1'}
TypeError: unhashable type: 'list'

*************************************************
-- 如果使用字典做key，也会报错，如下所示
dic01 = {{'k1': 'v1'}: 'vdic'}
print(dic01)

-- 打印输出结果
    dic01 = {{'k1': 'v1'}: 'vdic'}
TypeError: unhashable type: 'dict'

2.2 访问字典键值

将字典中元素所对应的key放入到[]括号中，即可获得元素键(key)所对应的value值。

languages = {'Java': 'James Gosling', 'C++': 'Bjarne Stroustrup', 'C': 'Dennis MacAlistair Ritchie',
			 'Python': 'Guido van Rossum', 'PHP': 'Rasmus Lerdorf'}
print(f"C语言之父: {languages['C']}")
print(f"Java语言之父: {languages['Java']}")
print(f"Ruby语言之父: {languages['Ruby']}")  # 因为字典中不含有Ruby这一key，所以执行会报错

-- 打印输出结果
C语言之父: Dennis MacAlistair Ritchie
Java语言之父: James Gosling
    print(f"Ruby语言之父: {languages['Ruby']}")
KeyError: 'Ruby'

2.3 添加修改字典键值

可以向字典中添加新元素，如果添加的新元素对应的key存在，则修改原key对应的value值，如果key不存在，怎添加该新元素至字典中。

DB = {'A': 'Oracle', 'B': 'MySQL', 'C': 'SqlServer'}
DB['D'] = 'Informix'   # 因为'D'在原字典中不存在，则将该对象添加到字典中
print(f"当前DB字典的内容为: {DB}")
print()
DB['C'] = 'Sybase'     # 因为'C'在原字典中已有同名key存在，所以该操作为修改原字典中的'C'所对应的value值
print(f"当前DB字典的内容为: {DB}")

-- 打印输出结果
当前DB字典的内容为: {'A': 'Oracle', 'B': 'MySQL', 'C': 'SqlServer', 'D': 'Informix'}

当前DB字典的内容为: {'A': 'Oracle', 'B': 'MySQL', 'C': 'Sybase', 'D': 'Informix'}

2.4 删除字典元素

可以使用del命令来删除字典中的一个元素，另外使用del命令还可以删除字典。

使用clear()方法可以一次性清空字典中的所有元素。

1） 使用del命令删除字典元素或字典

DB = {'A': 'Oracle', 'B': 'MySQL', 'C': 'SqlServer', 'D': 'Sybase'}
del DB['D']
print(f'删除DB中的D键后字典内容为: {DB}')
del DB
print(f'DB字典内容为：{DB}')

-- 打印输出结果
删除DB中的D键后字典内容为: {'A': 'Oracle', 'B': 'MySQL', 'C': 'SqlServer'}
    print(f'DB字典内容为：{DB}')
NameError: name 'DB' is not defined

2）使用clear()方法清空字典

DB = {'A': 'Oracle', 'B': 'MySQL', 'C': 'SqlServer', 'D': 'Sybase'}
DB.clear()
print(f"DB字典当前内容为：{DB}")

-- 打印输出结果
DB字典当前内容为：{}

2.5 判断键是否存在字典中

可以使用in 或 not in 来判断一个键(key)是否存在字典中，输出结果将返回一个布尔值。

DB = {'A': 'Oracle', 'B': 'MySQL', 'C': 'SqlServer', 'D': 'Sybase'}
print("C键是否存在字典中：",'C' in DB)      # 因为C键存在字典中，所以返回True
print("A键是否存在字典中：",'A' not in DB)  # 因为A键存在字典中，所以使用not in 会返回 False

-- 打印输出结果
C键是否存在字典中： True
A键是否存在字典中： False

2.6 循环变量字典

使用for循环可以遍历Python字典中的信息，是一种非常高效的方法。

使用for语句结合索引或其它多个方法可以遍历字典中的元素信息。

2.6.1 使用for + 对象索引遍历字典

使用for 语句结合对象索引，可以迭代遍历字典信息。

languages = {'Java': 'James Gosling', 'C++': 'Bjarne Stroustrup', 'C': 'Dennis MacAlistair Ritchie',
 			 'Python': 'Guido van Rossum', 'PHP': 'Rasmus Lerdorf'}
for key in languages:
	print(key,"语言之父为",":",languages[key])

-- 打印输出结果
Java 语言之父为 : James Gosling
C++ 语言之父为 : Bjarne Stroustrup
C 语言之父为 : Dennis MacAlistair Ritchie
Python 语言之父为 : Guido van Rossum
PHP 语言之父为 : Rasmus Lerdorf

2.6.2 使用for + keys()方法遍历字典

使用for结合字典keys()内置方法可以迭代遍历字典信息。

languages = {'Java': 'James Gosling', 'C++': 'Bjarne Stroustrup', 'C': 'Dennis MacAlistair Ritchie',
 			 'Python': 'Guido van Rossum', 'PHP': 'Rasmus Lerdorf'}
for key in languages.keys():
	print(key,"语言之父为",":",languages[key])

-- 打印输出结果
Java 语言之父为 : James Gosling
C++ 语言之父为 : Bjarne Stroustrup
C 语言之父为 : Dennis MacAlistair Ritchie
Python 语言之父为 : Guido van Rossum
PHP 语言之父为 : Rasmus Lerdorf

2.6.3 使用for + items()方法遍历字典

使用for结合字典的items()内置方法可以遍历字典信息。

languages = {'Java': 'James Gosling', 'C++': 'Bjarne Stroustrup', 'C': 'Dennis MacAlistair Ritchie',
			 'Python': 'Guido van Rossum', 'PHP': 'Rasmus Lerdorf'}
for k, v in languages.items():
	print(k, "语言之父为", ":", v)

-- 打印输出结果
Java 语言之父为 : James Gosling
C++ 语言之父为 : Bjarne Stroustrup
C 语言之父为 : Dennis MacAlistair Ritchie
Python 语言之父为 : Guido van Rossum
PHP 语言之父为 : Rasmus Lerdorf

2.7 浅拷贝与深拷贝

Python里对直接赋值、浅拷贝及深拷贝的直接定义是这样的：

直接赋值：将一对象赋值给一变量时，并未拷贝该对象，只是拷贝了该对象的引用(别名)；

浅拷贝：浅拷贝是指使用copy，拷贝父对象，不会拷贝对象内部的子对象；

深拷贝：深拷贝是指使用deepcopy，是copy模块的deepcopy方法，完全拷贝了父对象及子对象。

2.7.1 直接赋值

Python字典的直接赋值就是对原对象的一个引用，相当于起了一个别名，类似文件的链接，两个变量的地址相同。

# 直接赋值测试
database01 = {'DB1': 'Oracle', 'DB2': 'MySQL'}
database02 = database01
print("database01初始内容是{}:", database01, ";", "\t", "database01初始地址是：", id(database01))
print("database02初始内容是{}:", database02, ";", "\t", "database02初始地址是：", id(database02))
print("\n")
# 测试为database01 追加一个值
database01.setdefault('DB3', 'SqlServer')
print("database01追加值后内容是{}:", database01, ";", "\t", "database01追加值后地址是：", id(database01))
print("database02内容是{}:", database02, ";", "\t", "database02此时地址是：", id(database02))

-- 打印输出结果
database01初始内容是{}: {'DB1': 'Oracle', 'DB2': 'MySQL'} ; 	 database01初始地址是： 20528136
database02初始内容是{}: {'DB1': 'Oracle', 'DB2': 'MySQL'} ; 	 database02初始地址是： 20528136


database01追加值后内容是{}: {'DB1': 'Oracle', 'DB2': 'MySQL', 'DB3': 'SqlServer'} ; 	 database01追加值后地址是： 20528136
database02内容是{}: {'DB1': 'Oracle', 'DB2': 'MySQL', 'DB3': 'SqlServer'} ; 	 database02此时地址是： 20528136

从上述测试可看到直接赋值，两个变量其实指向同一个地址，当一个变量追加值后，被直接赋值的另一变量也同样指向同一地址。

2.7.2 浅拷贝

执行浅拷贝，如执行dic02=dic01.copy()命令后，dic01和 dic02两个父对象各自是一个独立的对象，引用的内存地址不同，但拷贝前后两个字典中的子对象还是指向统一对象内存地址。

# 浅拷贝测试
dic01 = {'k1': 'V1', 'k2': [1,2,3]}
dic02 = dic01.copy()
print(f"dic01字典内容：{dic01}", "\t", f"dic01字典地址: {id(dic01)}", "\t", f"dic01字典中列表地址: {id(dic01['k2'])}")
print(f"dic02字典内容：{dic02}", "\t", f"dic02字典地址: {id(dic02)}", "\t", f"dic02字典中列表地址: {id(dic02['k2'])}")

-- 打印输出结果
dic01字典内容：{'k1': 'V1', 'k2': [1, 2, 3]} 	 dic01字典地址: 25050120 	 dic01字典中列表地址: 30659752
dic02字典内容：{'k1': 'V1', 'k2': [1, 2, 3]} 	 dic02字典地址: 25050200 	 dic02字典中列表地址: 30659752

2.7.3 深拷贝

执行深拷贝，要首先通过 import copy 引入copy模块，执行深拷贝的命令是dic02 = copy.deepcopy(dic01)，当执行了深拷贝，是将dic01和dic02两个字典父对象及其字典中的子对象都做了完全拷贝，两者完全独立。

import copy
# 深拷贝测试
dic01 = {'k1': 'V1', 'k2': [1,2,3]}
dic02 = copy.deepcopy(dic01)
print(f"dic01字典内容：{dic01}", "\t", f"dic01字典地址: {id(dic01)}", "\t", f"dic01字典中列表地址: {id(dic01['k2'])}")
print(f"dic02字典内容：{dic02}", "\t", f"dic02字典地址: {id(dic02)}", "\t", f"dic02字典中列表地址: {id(dic02['k2'])}")
print()
# 修改dic01字典中信息
dic01['k1'] = 'AA1'
dic01['k2'] = '1,2,3,4'
print(f"dic01字典内容：{dic01}", "\t", f"dic01字典地址: {id(dic01)}", "\t", f"dic01字典中列表地址: {id(dic01['k2'])}")
print(f"dic02字典内容：{dic02}", "\t", f"dic02字典地址: {id(dic02)}", "\t", f"dic02字典中列表地址: {id(dic02['k2'])}")

-- 打印输出结果
dic01字典内容：{'k1': 'V1', 'k2': [1, 2, 3]} 	 dic01字典地址: 11156488 	 dic01字典中列表地址: 23685160
dic02字典内容：{'k1': 'V1', 'k2': [1, 2, 3]} 	 dic02字典地址: 23677840 	 dic02字典中列表地址: 23775368

dic01字典内容：{'k1': 'AA1', 'k2': '1,2,3,4'} 	 dic01字典地址: 11156488 	 dic01字典中列表地址: 23846240
dic02字典内容：{'k1': 'V1', 'k2': [1, 2, 3]} 	 dic02字典地址: 23677840 	 dic02字典中列表地址: 23775368

2.8 字典推导式

类似于Python列表，字典也有相应的推导式。字典推导式的格式为：{key_expr: value_expr for value in collection } 或 { key_expr: value_expr for value in collection if condition }。

字典推导式和列表推导式在有些地方稍有不同，不同之处在于：

• 不使用中括号，使用大括号

• 结果中无重复

• 结果是一个set()集合，集合里面是一个序列

# 定义一个列表
dic01 = {'Java', 'C++', 'C', 'Python', 'PHP'}
# 将列表中各字符串作为key，各字符串的长度作为value，组成字典的键值对
dic02 = {k: len(k) for k in dic01}
print(dic02)

-- 打印输出结果
{'C': 1, 'Java': 4, 'C++': 3, 'PHP': 3, 'Python': 6}

*************************************************
# 提供三个数字，以三个数字为键，三个数字的平方为值来创建字典
dic01 = {x: x ** 2 for x in (2, 4, 6)}
print(dic01)

-- 打印输出结果
{2: 4, 4: 16, 6: 36}

2.9 字典内置方法

Python字典内置了多个内置函数和方法。其中在日常编程中使用较频繁的是如下一些内置方法，然后我们基于这些内置方法来详细讲解其用法。

2.9.1 get()方法

Python的get()方法用来返回字典中指定键(key)所对应的value值。语法格式为：dict.get(key[, value]) ，value是可选项。在使用get()方法时，如果设置了value默认值，当指定的(key)键不存在，则会返回该value默认值，如果未设置value默认值，当指定的(key)键不存在，则返回None。使用get(key)方法优于dict[key]方法，因为当key不存在时，dict[key]会触发 KeyError 异常。

languages = {'Java': 'James Gosling', 'C++': 'Bjarne Stroustrup', 'C': 'Dennis MacAlistair Ritchie',
			 'Python': 'Guido van Rossum', 'PHP': 'Rasmus Lerdorf'}
print('PHP语言之父:',languages.get('PHP'))  # 有该key，正常输出
print('Ruby语言之父:',languages.get('Ruby','对不起，Ruby信息不存在'))  # 未有Ruby这一key，但设置了默认值，返回默认值
print('.Net语言之父:',languages.get('.Net'))    # 未有.Net这一key，也未设置默认值，返回None

-- 打印输出结果
PHP语言之父: Rasmus Lerdorf
Ruby语言之父: 对不起，Ruby信息不存在
.Net语言之父: None

***************************************************
-- 对比dict[key]方法
languages = {'Java': 'James Gosling', 'C++': 'Bjarne Stroustrup', 'C': 'Dennis MacAlistair Ritchie',
 			 'Python': 'Guido van Rossum', 'PHP': 'Rasmus Lerdorf'}
print('.Net语言之父:',languages['.Net'])

-- 打印输出结果
    print('.Net语言之父:',languages['.Net'])
KeyError: '.Net'

2.9.2 setdefault()方法

Python中setdefault()方法与get()方法很类似，即当key存在时，将返回该key对应的value值，当key不存在字典中时，会将该key添加至字典并为其设置默认值。

setdefault()语法格式为：dict.setdefault(key, default=None),默认是None。

languages = {'Java': 'James Gosling', 'C++': 'Bjarne Stroustrup', 'C': 'Dennis MacAlistair Ritchie',
			 'Python': 'Guido van Rossum', 'PHP': 'Rasmus Lerdorf'}
print('Java语言之父:',languages.setdefault('Java','John'))  # 字典中已有该key，会返回原字典中的key对应value值
print('Basic语言之父:',languages.setdefault('Basic','John G. Kemeny')) # 字典中未有该key，会添加该默认值
print(f"当前字典的内容信息是: {languages}")

-- 打印输出结果
Java语言之父: James Gosling
Basic语言之父: John G. Kemeny
当前字典的内容信息是: {'Java': 'James Gosling', 'C++': 'Bjarne Stroustrup', 'C': 'Dennis MacAlistair Ritchie', 'Python': 'Guido van Rossum', 'PHP': 'Rasmus Lerdorf', 'Basic': 'John G. Kemeny'}

2.9.3 keys()方法

Python中keys()方法返回字典中的所有键组成的一个可迭代序列，使用keys()可以获得字典中所有对象的key。

keys()方法语法格式为：dict.keys()。

Database = {'DB1': 'Oracle', 'DB2': 'MySQL', 'DB3': 'OceanBase', 'DB4': 'TIDB'}
print(list(Database.keys()))
for db_num in Database.keys():   # 和for 循环语句同时使用
	print(db_num)

-- 打印输出结果
['DB1', 'DB2', 'DB3', 'DB4']
DB1
DB2
DB3
DB4

2.9.4 values()方法

Python中的keys()方法用来返回字典中的key信息，与之对应，values()方法用来返回字典中的value值信息。

values()方法语法格式为：dict.values()，用来返回字典的key对应的value值。

Database = {'DB1': 'Oracle', 'DB2': 'MySQL', 'DB3': 'OceanBase', 'DB4': 'TIDB'}
print(list(Database.values()))
print()
for db_name in Database.values():
	print(db_name)

-- 打印输出结果
['Oracle', 'MySQL', 'OceanBase', 'TIDB']

Oracle
MySQL
OceanBase
TIDB

**************************************************
-- 还可以通过values()方法来比较两个字典的值
name1 = {'bear':'熊大'}
name2 = {'bear':'熊二'}
print(name1.values() == name2.values())

-- 打印输出结果
False

2.9.5 items()方法

Python中dict.items()方法以列表的形式用来遍历返回字典中的key及其所对应的value值。

items()语法格式为：dict.items()。items()方法通常和for相结合，来循环遍历字典中的key及value值。

注意，Python中的keys()、values()、items()这三个方法返回的都是视图对象，提供了字典的动态视图，类似于数据库的动态视图，当其依赖的字典发生了改变，这三个方法的返回结果也会随之发生改变。

Database = {'DB1': 'Oracle', 'DB2': 'MySQL', 'DB3': 'OceanBase', 'DB4': 'TIDB'}
print(Database.items())    # 直接使用items()方法会生成一个列表，该列表中的每个key及其对应的value组成一个元组
print()
for k, v in Database.items():
	print(f"数据库编号：{k},数据库名称：{v}")

print()
# 以下生成一个新列表，列表中的元素是由原列表中的key和value共同组成
AllDatabases = []
for k, v in Database.items():
	AllDatabases.append(k)
	AllDatabases.append(v)
print(f"新列表内容为：{AllDatabases}")

-- 打印输出结果
dict_items([('DB1', 'Oracle'), ('DB2', 'MySQL'), ('DB3', 'OceanBase'), ('DB4', 'TIDB')])

数据库编号：DB1,数据库名称：Oracle
数据库编号：DB2,数据库名称：MySQL
数据库编号：DB3,数据库名称：OceanBase
数据库编号：DB4,数据库名称：TIDB

新列表内容为：['DB1', 'Oracle', 'DB2', 'MySQL', 'DB3', 'OceanBase', 'DB4', 'TIDB']

2.9.6 pop()方法

Python中的pop()方法用来删除字典中的指定的key所对应的value值，并放回被删除的value值。

pop()方法的语法格式为：pop(key[,default])，该方法中key为要删除的key键，default是当计划删除的key不存在时所设置的默认返回值。

对于pop()方法有三种情形：

• 若key存在字典中，使用pop(key)会删除该key所对应的value，并返回被删除的value值信息。

• 若key不存在字典中，且未给pop(key)方法设置默认值，则会报KeyError异常错误。

• 若key不存在字典中，且已给pop(key)方法设置了默认值，则会返回默认值

languages = {'Java': 'James Gosling', 'C++': 'Bjarne Stroustrup', 'C': 'Dennis MacAlistair Ritchie',
 			 'Python': 'Guido van Rossum', 'PHP': 'Rasmus Lerdorf'}
print(f'删除PHP语言之父:',languages.pop('PHP'))  # 字典中有PHP这一key，会正常返回被删除值信息
print()
print(f'删除Basic语言之父:',languages.pop('Basic','John G. Kemeny')) # 字典中不存在Basic这一key，但设置了默认值
print()
print(f'当前languages字典内容信息是：{languages}')
print()
print(f'删除Ruby语言之父:',languages.pop('Ruby'))  # 字典中不存在Ruby这一key，且未设置默认值

-- 打印输出结果
删除PHP语言之父: Rasmus Lerdorf

删除Basic语言之父: John G. Kemeny

当前languages字典内容信息是：{'Java': 'James Gosling', 'C++': 'Bjarne Stroustrup', 'C': 'Dennis MacAlistair Ritchie', 'Python': 'Guido van Rossum'}

    print(f'删除Ruby语言之父:',languages.pop('Ruby'))
KeyError: 'Ruby'

2.9.7 popitem()方法

popitem()方法的语法格式为：popitem()，其删除字典中元素后会有返回值。如果字典为空，调用popitem()会抛出KeyError异常错误。

需要特别注意的是，popitem()方法在Python2和Python3中虽然都可以删除字典中的元素，但被删除顺序却不同，在Python2中popitem()会随机删除一个key及其对应的value值，但在Python3中popitem()会删除字典中最后一个key及其对应的value值。

1）Python2版本

-- 在Python2版本中会随机删除字典中的key及其对应的value
[root@oceanbase-db1 scripts]# python
Python 2.7.5 (default, Jun 28 2022, 15:30:04) 
[GCC 4.8.5 20150623 (Red Hat 4.8.5-44)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> dic01 = {'K1':'V1','K2':'V2','K3':'V3','K4':'V4','K5':'V5'}
>>> print(dic01.popitem())
('K3', 'V3')
>>> print(dic01.popitem())
('K2', 'V2')
>>> print(dic01.popitem())
('K1', 'V1')
>>> print(dic01.popitem())
('K5', 'V5')
>>> print(dic01.popitem())
('K4', 'V4')
>>> print(dic01.popitem())
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'popitem(): dictionary is empty'   # 因为dic01已为空，继续执行popitem()方法会报错

2）Python3版本

-- 在Python3版本中会删除字典中最后一个对象所对应的key及其value值
[root@xsky-node1 ~]# python
Python 3.6.13 (default, Jun  9 2021, 11:13:11) 
[GCC 4.4.6 20110731 (Red Hat 4.4.6-4)] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> dic01 = {'K1':'V1','K2':'V2','K3':'V3','K4':'V4','K5':'V5'}
>>> print(dic01.popitem())
('K5', 'V5')
>>> print(dic01.popitem())
('K4', 'V4')
>>> print(dic01.popitem())
('K3', 'V3')
>>> print(dic01.popitem())
('K2', 'V2')
>>> print(dic01.popitem())
('K1', 'V1')
>>> print(dic01.popitem())
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'popitem(): dictionary is empty'

2.9.8 update()方法

Python中的update()方法用来将一个字典中的键/值更新到其它字典里。

update()语法格式为：dict1.update(dict2)，表示将dict2字典中的信息添加到dict1字典中，该方法无返回值。

使用dict1.update(dict2)，有以下几种情形：

• 若dict1中不存在dict2中的key，会将dict2中的key及value添加到dict1中。

• 若dict1中存在dict2中的key，会将dict2中key所对应的value更新dict1中同名key的value值。

• 如dict1中不存在dict2中的key，在Python2和Python3中key被添加到dict1中的序列位置也不同，因为Python2中字典是无序的，在Python3.6之后，字典是有序的。

1）Python2版本

[root@oceanbase-db1 ~]# python
Python 2.7.5 (default, Jun 28 2022, 15:30:04) 
[GCC 4.8.5 20150623 (Red Hat 4.8.5-44)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> num1 = {'k1':'V1','K2':'V2','K3':'V3'}
>>> num2 = {'k1':'V2','K2':'V2','K4':'V4'}
>>> print(num1.update(num2))
None
>>> print(num1)
{'K3': 'V3', 'K2': 'V2', 'k1': 'V2', 'K4': 'V4'}

2）Python3版本

[root@xsky-node1 ~]# python
Python 3.6.13 (default, Jun  9 2021, 11:13:11) 
[GCC 4.4.6 20110731 (Red Hat 4.4.6-4)] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> num1 = {'k1':'V1','K2':'V2','K3':'V3'}
>>> num2 = {'k1':'V2','K2':'V2','K4':'V4'}
>>> print(num1.update(num2))
None
>>> print(num1)
{'k1': 'V2', 'K2': 'V2', 'K3': 'V3', 'K4': 'V4'}

2.9.9 fromkeys()方法

Python中的fromkeys()方法语法格式为：dict.fromkeys(seq[, value])，使用该方法会生成一个新字典，在该方法语法格式中，seq是代表新字典键值列表，value是可选参数，用来设置新字典中seq所对应的value初始值值，若未设置，则新字典中key的value默认值为None。

fromkeys()方法有返回值，返回值是一个字典。

salary = {'zhangsan', 'lisi', 'wangwu'}
newSalary = dict.fromkeys(salary)
print(f'newSalary字典信息为：{newSalary}')
print()
message = {'News1', 'News2', 'News'}
newMessage = dict.fromkeys(message,'Good News')
print(f'newMessage字典信息为：{newMessage}')

-- 打印输出结果
newSalary字典信息为：{'zhangsan': None, 'lisi': None, 'wangwu': None}

newMessage字典信息为：{'News2': 'Good News', 'News1': 'Good News', 'News': 'Good News'}

三、练习题

3.1 列表嵌套字典

dic01 = [{'a': 1}, {'b': 2}, {'c': 3}]
-- 要求循环获取字典里每个键值对

3.2 字典嵌套字典

data = {
    '192.168.1.1':{'cpu':'0.23','内存':'16','硬盘':'500'},
    '192.168.1.2':{'cpu':'3.22','内存':'64','硬盘':'700'},
    '192.168.1.3':{'cpu':'1.99','内存':'32','硬盘':'800'},
}
-- 要求以IP地址: cpu xxx 内存 xxx 硬盘 xxx 这种方式打印每台服务器信息