Python 程序设计入门（012）—— 字典的操作（1）：字典的基本操作

Python 程序设计入门（012）—— 字典的操作（1）：字典的基本操作

在 Python 中，字典是常见的序列结构之一。字典与列表类似，也是可变序列，与列表不同的是，字典是无序的可变序列，保存的内容是以【键值对】的形式存放的。

字典中的每个元素都包含两个部分：即【键】和【值】。【键】和【值】之间用冒号（:）分隔，相邻两个元素用逗号（,）分隔。所有元素放在一个大括号 {} 中。

一、字典的定义

Python 中的字典具有如下特征：

（1）字典是一种可变的容器，可以存储任意类型的数据；
（2）字典中的每个数据都是用【键（key）】 进行索引，而不像序列可以用下标进行索引；
（3）字典中的数据没有先后关系，字典的存储是无序的；
（4）字典是 Python 中唯一的映射类型，采用键值对（key-value）的形式存储数据。key必须是不可变类型，如：数字、字符串、元组。
（5）字典的表示方式是以 {} 括起来，以冒号（:）分割的键值对，各键值对之间用逗号（,）分隔开；
（6）字典的键一般是唯一的，如果重复最后的一个键值对会替换前面的。

1、通过赋值方式创建字典

语法格式如下：

dictname = {
    
    "key1":"value1", "key2":"value2", ... ,"keyn":"valuen" }

例如：

dict1 = {
    
    }   # 创建一个空字典
dict2 = {
    
    "BookName":"Java入门到精通","Author":"刘鹏","Price":79.5}
dict3 = {
    
    "Name":"Jack","Age":20,"Name":"zs"} # 有重复的key
print("dict1:",dict1)
print("dict2:",dict2)
print("dict3:",dict3)

运行结果如下：
===================== RESTART: C:\Python\Python38\First.py =====================
dict1: {
    
    }
dict2: {
    
    'BookName': 'Java入门到精通', 'Author': '刘鹏', 'Price': 79.5}
dict3: {
    
    'Name': 'zs', 'Age': 20}

2、使用 dict() 函数创建字典

通过 dict() 函数创建数据字典主要有以下两种格式：

格式一：
dictname = dict(zip(list1, list2))
格式二：
dictname = dict(key1=value1, key2=value2, ... ,keyn=valuen)

例如：

dict1 = dict(Name="刘鹏", Sex="男", Age=30)
dict2 = dict(zip(["Name", "Sex", "Age"], ["刘鹏", "男", 30]))
dict3 = dict([("Name", "刘鹏"), ("Sex", "男"), ("Age", 30)])
dict4 = dict({
    
    "Name": "刘鹏", "Sex": "男","Age": 30})
dict5 = dict({
    
    "Name": "刘鹏", "Sex": "男"}, Age=30)
print("dict1:",dict1)
print("dict2:",dict2)
print("dict3:",dict3)
print("dict4:",dict4)
print("dict5:",dict5)

运行结果如下：
===================== RESTART: C:\Python\Python38\First.py =====================
dict1: {
    
    'Name': '刘鹏', 'Sex': '男', 'Age': 30}
dict2: {
    
    'Name': '刘鹏', 'Sex': '男', 'Age': 30}
dict3: {
    
    'Name': '刘鹏', 'Sex': '男', 'Age': 30}
dict4: {
    
    'Name': '刘鹏', 'Sex': '男', 'Age': 30}
dict5: {
    
    'Name': '刘鹏', 'Sex': '男', 'Age': 30}

3、使用 fromkeys() 方法创建字典

fromkeys() 方法用于创建一个新字典，以序列 seq 中的元素作为字典的键，用 value 作为字典中所有键对应的值。fromkeys() 方法的语法格式如下：

dict.fromkeys(seq[,value])

说明：

（1）seq 为序列（如字符串、列表、元组等），作为新字典的键。

（2）value 为可选参数，如果提供 value 值，该值将设置为字典的值，字典中的所有键对应同一个值。如果不提供 value，则默认为 None。

例如：

list1 = [1,2,3,4,5]
str1 = "ABCD"
set1 = ("Mon","Tue","Wed","Thu","Fri")
dict1 = dict.fromkeys(list1)
dict2 = dict.fromkeys(str1,"Python")
dict3 = dict.fromkeys(set1,"工作日")
print(dict1)
print(dict2)
print(dict3)

运行结果如下：
===================== RESTART: C:\Python\Python38\First.py =====================
{
    
    1: None, 2: None, 3: None, 4: None, 5: None}
{
    
    'A': 'Python', 'B': 'Python', 'C': 'Python', 'D': 'Python'}
{
    
    'Mon': '工作日', 'Tue': '工作日', 'Wed': '工作日', 'Thu': '工作日', 'Fri': '工作日'}

二、访问字典中的值

1、使用 dictname[key]

使用 dictname[key] 返回键 key 对应的值 value，如果 key 不在字典中，将会返回 KeyError。格式如下：

dictname[key] 

例如：

dict1 = {
    
    "BookName":"Java入门到精通","Author":"刘鹏","Price":79.5}
dict2 = {
    
    1:"张静静",2:"刘刚",3:"王菲",4:"马芸"}
print(dict1["BookName"])
print(dict2[2])
print(dict2[0])  # key 不存在

运行结果如下：
===================== RESTART: C:\Python\Python38\First.py =====================
Java入门到精通
刘刚
Traceback (most recent call last):
  File "C:\Python\Python38\First.py", line 5, in <module>
    print(dict2[0])
KeyError: 0

2、使用 get() 方法

使用 get() 方法返回指定键的值，如果值不在字典中则返回 default 值。get() 方法语法格式如下：

dictname.get(key, default)

说明：

（1）key：要查找的键。

（2）default：如果指定键的值不存在时，返回该默认值。如果不指定，则默认值为 None。

例如：

dict1= {
    
    11:"Java",22:"Python",33:"C++",44:"Go"}
print(dict1.get(22,"要查找的值不存在"))
print(dict1.get(44,"要查找的值不存在"))
print(dict1.get(66,"要查找的值不存在"))

运行结果如下：
===================== RESTART: C:\Python\Python38\First.py =====================
Python
Go
要查找的值不存在

3、使用【key in dictname】格式

查看一个 key 是否在字典中，可以使用如下形式：

key in dictname

例如：

dict1 = {
    
    "BookName":"Java入门到精通","Author":"刘鹏","Price":79.5}
dict2 = {
    
    1:"张静静",2:"刘刚",3:"王菲",4:"马芸"}
if "BookName" in dict1:
    print(dict1["BookName"])
print(2 in dict2)
print(0 in dict2)

运行结果如下：
===================== RESTART: C:\Python\Python38\First.py =====================
Java入门到精通
True
False

三、字典的遍历

1、遍历字典的键（key）

字典的 keys() 方法用于获取字典中的所有键，返回一个可迭代对象（返回一个包含字典所有 key 的列表）。可以使用 list() 函数将其转换为列表。keys() 方法的语法格式如下：

dictname.keys()

例如：

dict1 = {
    
    "BookName":"Java入门到精通","Author":"刘鹏","Price":79.5}
k = dict1.keys()
list2 = list(k)
print(k)
print(type(k))
print(list2)
print(type(list2))

运行结果如下：
===================== RESTART: C:\Python\Python38\First.py =====================
dict_keys(['BookName', 'Author', 'Price'])
<class 'dict_keys'>
['BookName', 'Author', 'Price']
<class 'list'>

遍历字典的所有键：

dict1 = {
    
    "BookName":"Java入门到精通","Author":"刘鹏","Price":79.5}
for k in dict1.keys():
    print(k)
    
运行结果如下：
===================== RESTART: C:\Python\Python38\First.py =====================
BookName
Author
Price

2、遍历字典的值（value）

字典的 values() 方法用于获取字典中的所有值，返回一个可迭代对象（返回一个包含字典所有 value 的列表），可以使用 list() 函数将其转换为列表。values() 方法的语法格式如下：

dictname.values()

例如：

dict1 = {
    
    "BookName":"Java入门到精通","Author":"刘鹏","Price":79.5}
v = dict1.values()
list2 = list(v)
print(v)
print(type(v))
print(list2)
print(type(list2))

运行结果如下：
===================== RESTART: C:\Python\Python38\First.py =====================
dict_values(['Java入门到精通', '刘鹏', 79.5])
<class 'dict_values'>
['Java入门到精通', '刘鹏', 79.5]
<class 'list'>

遍历字典的所有值：

dict1 = {
    
    "BookName":"Java入门到精通","Author":"刘鹏","Price":79.5}
for v in dict1.values():
    print(v)
    
运行结果如下：
===================== RESTART: C:\Python\Python38\First.py =====================
Java入门到精通
刘鹏
79.5

3、遍历字典的元素（item）

字典的 items() 方法用于获取字典的键值对，返回一个可迭代对象（返回一个包含所有（键，值）元组的列表），可以使用 list() 函数将其转换为列表。items() 方法的语法格式如下：

dictname.items()

例如：

dict1 = {
    
    "BookName":"Java入门到精通","Author":"刘鹏","Price":79.5}
v = dict1.items()
list1 = list(v)
print(v)
print(type(v))
print(list1)
print(type(list1))

运行结果如下：
===================== RESTART: C:\Python\Python38\First.py =====================
dict_items([('BookName', 'Java入门到精通'), ('Author', '刘鹏'), ('Price', 79.5)])
<class 'dict_items'>
[('BookName', 'Java入门到精通'), ('Author', '刘鹏'), ('Price', 79.5)]
<class 'list'>

4、遍历字典的 key-value

如下形式可以取出字典中元素的 key 和 value。语法格式如下：

for item，value in dictname.items():
    ...

例如：

dict1 = {
    
    "BookName":"Java入门到精通","Author":"刘鹏","Price":79.5}
for item in dict1.items():
    print(item)    # item 对应字典中的元素
print("="*50)    
for item in dict1.items():
    print(item[0],item[1])   # item[0]对应字典中元素的key, item[1]对应字典中元素的value
print("="*50) 
for key,value in dict1.items():
    print(key,value)        # key 对应字典中元素的key，value对应字典中元素的value
   
运行结果如下：
===================== RESTART: C:\Python\Python38\First.py =====================
('BookName', 'Java入门到精通')
('Author', '刘鹏')
('Price', 79.5)
==================================================
BookName Java入门到精通
Author 刘鹏
Price 79.5
==================================================
BookName Java入门到精通
Author 刘鹏
Price 79.5

四、字典的编辑

1、更新字典中某个元素的 value

可以使用如下形式为字典中的某个元素赋值：

dictname[key] = value

例如：

dict1 = {
    
    "BookName":"Java入门到精通","Author":"刘鹏","Price":79.5}
dict1["Price"]=68.5
dict1["Publisher"]="人民邮电出版社"  # 添加一个元素（key不存在表示添加元素）
print(dict1)
   
运行结果如下：
===================== RESTART: C:\Python\Python38\First.py =====================
{
    
    'BookName': 'Java入门到精通', 'Author': '刘鹏', 'Price': 68.5, 'Publisher': '人民邮电出版社'}

2、使用 update() 方法更新字典

字典的 update() 方法用于更新字典，此方法无返回值。update() 方法的语法格式如下：

dictname.update(args)

update() 方法的参数 args 有以下几种形式：

（1）键值对用【=】隔开

dictname.update(age = 180)

例如：

dict1 = {
    
    "BookName":"Java入门到精通","Author":"刘鹏","Price":79.5}
dict1.update(Price = 86.5)                 # 更新已有的值
print(dict1)
dict1.update(Publisher = "人民邮电出版社")  # 添加新的键值对
print(dict1)
   
运行结果如下：
===================== RESTART: C:\Python\Python38\First.py =====================
{
    
    'BookName': 'Java入门到精通', 'Author': '刘鹏', 'Price': 86.5}
{
    
    'BookName': 'Java入门到精通', 'Author': '刘鹏', 'Price': 86.5, 'Publisher': '人民邮电出版社'}

（2）指定一个字典

dictname.update(dictname)

例如：

dict1 = {
    
    "BookName":"Java入门到精通","Author":"刘鹏","Price":79.5}
dict2 = {
    
    "Publisher":"人民邮电出版社","Remark":"教材"}
dict3 = {
    
    1:"Tom",2:"Mark",3:"Jerry"}
dict1.update(dict2)  # 把一个字典的所有元素添加到当前字典中
print(dict1)
dict3.update({
    
    4:"Johun"})
print(dict3)
dict3.update({
    
    5:"Zhang",6:"Wang"})
print(dict3)

运行结果如下：
===================== RESTART: C:\Python\Python38\First.py =====================
{
    
    'BookName': 'Java入门到精通', 'Author': '刘鹏', 'Price': 79.5, 'Publisher': '人民邮电出版社', 'Remark': '教材'}
{
    
    1: 'Tom', 2: 'Mark', 3: 'Jerry', 4: 'Johun'}
{
    
    1: 'Tom', 2: 'Mark', 3: 'Jerry', 4: 'Johun', 5: 'Zhang', 6: 'Wang'}

（3）指定一个列表（列表的元素为元组，每个元组包含两个元素，作为字典的键值对）

dictname.update(listname)

例如：

dict1 = {
    
    11:"Java",22:"Python",33:"C++"}
dict1.update([(44,"Go")])
print(dict1)
dict1.update([(55,"C#"),(66,"Rust")])
print(dict1)

运行结果如下：
===================== RESTART: C:\Python\Python38\First.py =====================
{
    
    11: 'Java', 22: 'Python', 33: 'C++', 44: 'Go'}
{
    
    11: 'Java', 22: 'Python', 33: 'C++', 44: 'Go', 55: 'C#', 66: 'Rust'}

（4）指定一个集合

dictname.update(setname)

例如：

dict1 = {
    
    11:"Java",22:"Python",33:"C++"}
set1 = {
    
    (55,"C#"),(66,"Rust")}
print(set1)
print(type(set1))
dict1.update(set1)
print(dict1)

运行结果如下：
===================== RESTART: C:\Python\Python38\First.py =====================
{
    
    (55, 'C#'), (66, 'Rust')}
<class 'set'>
{
    
    11: 'Java', 22: 'Python', 33: 'C++', 55: 'C#', 66: 'Rust'}

（5）指定一个元组

dictname.update(tuplename)

例如：

dict1 = {
    
    11:"Java",22:"Python",33:"C++"}
tuple1 = ((55,"C#"),(66,"Rust"))
print(tuple1)
print(type(tuple1))
dict1.update(tuple1)
print(dict1)

运行结果如下：
===================== RESTART: C:\Python\Python38\First.py =====================
((55, 'C#'), (66, 'Rust'))
<class 'tuple'>
{
    
    11: 'Java', 22: 'Python', 33: 'C++', 55: 'C#', 66: 'Rust'}

3、使用 setdefault() 方法查看或更新字典

如果键不存在于字典中，将会添加键并将值设为默认值。如果存在，则返回该字段的值。setdefault() 方法的语法格式如下：

dictname.setdefault(key, default)

参数说明：

（1）key：要查找的键。

（2）default：要查找的键不存在时，设置的默认键值。如果不指定，默认值为 None。

例如：

dict1= {
    
    11:"Java",22:"Python",33:"C++",44:"Go"}
print(dict1.setdefault(22,"要查找的值不存在"))
print(dict1)
print(dict1.setdefault(44,"要查找的值不存在"))
print(dict1)
print(dict1.setdefault(66,"要查找的值不存在"))
print(dict1)

运行结果如下：
===================== RESTART: C:\Python\Python38\First.py =====================
Python
{
    
    11: 'Java', 22: 'Python', 33: 'C++', 44: 'Go'}
Go
{
    
    11: 'Java', 22: 'Python', 33: 'C++', 44: 'Go'}
要查找的值不存在
{
    
    11: 'Java', 22: 'Python', 33: 'C++', 44: 'Go', 66: '要查找的值不存在'}

4、使用 pop() 方法删除字典中的元素

使用 pop() 方法删除字典中指定键对应的键值对，并返回被删除的值。pop() 方法的语法格式如下：

dictname.pop(key[,default])

参数说明：

（1）key：指定要删除的键。

（2）default：如果要删除的 key 不存在，返回 default 值。

（3）如果字典中要删除的键不存，并且没有指定 default 参数，则抛出 keyerror 异常。

例如：

dict1= {
    
    11:"Java",22:"Python",33:"C++",44:"Go",55:"Rust"}
item1 = dict1.pop(11,"要删除的值不存在")
print("pop()函数的返回值为：",item1)
print(type(item1))
print(dict1)
item1 = dict1.pop(12,"要删除的值不存在")
print("pop()函数的返回值为：",item1)
print(type(item1))
print(dict1)
item1 = dict1.pop(13)  # 出错
print("返回值为：",item1)
print(type(item1))
print(dict1)

运行结果如下：
===================== RESTART: C:\Python\Python38\First.py =====================
pop()函数的返回值为： Java
<class 'str'>
{
    
    22: 'Python', 33: 'C++', 44: 'Go', 55: 'Rust'}
pop()函数的返回值为： 要删除的值不存在
<class 'str'>
{
    
    22: 'Python', 33: 'C++', 44: 'Go', 55: 'Rust'}
Traceback (most recent call last):
  File "C:\Python\Python38\First.py", line 10, in <module>
    item1 = dict1.pop(13)  # 出错
KeyError: 13

5、使用 popitem() 方法删除字典元素（键值对）

使用 popitem() 方法删除字典中的最后一个键值对，并以元组的形式返回这一键值对。popitem() 方法的语法格式如下：

dictname.popitem()

说明：pop 和 popitem 都可以删除字典中的元素。pop 是以字典的【键】为参数，删除指定的键值对。popitem() 方法删除字典中的最后一个键值对。

例如：

dict1 = {
    
    11:"Java",22:"Python",33:"C++",44:"C#",55:"Rust"}
item1 = dict1.popitem()
print("返回值：",item1)
print("返回值类型：",type(item1))
print(dict1)
item1 = dict1.popitem()
print(dict1)

运行结果如下：
===================== RESTART: C:\Python\Python38\First.py =====================
返回值： (55, 'Rust')
返回值类型： <class 'tuple'>
{
    
    11: 'Java', 22: 'Python', 33: 'C++', 44: 'C#'}
{
    
    11: 'Java', 22: 'Python', 33: 'C++'}

6、使用 clear() 方法清空字典

使用 clear() 方法可以删除字典中的所有元素，字典将变成空字典。clear() 方法的语法格式如下：

dictname.clear()

例如：

dict1 = {
    
    11:"Java",22:"Python",33:"C++"}
dict1.clear()  # 清空字典
print(dict1)
del dict1      # 删除字典对象
print(dict1)

运行结果如下：
===================== RESTART: C:\Python\Python38\First.py =====================
{
    
    }
Traceback (most recent call last):
  File "C:\Python\Python38\First.py", line 5, in <module>
    print(dict1)
NameError: name 'dict1' is not defined

7、复制字典

使用 copy() 方法可以返回一个与原字典具有相同键值对的新字典。copy() 方法的语法格式如下：

dictname.copy()

例如：

dict1 = {
    
    11:"Java",22:"Python",33:"C++",44:"C#",55:"Rust"}
dict2 = dict1  # 把dict2和dict1指向同一个字典
print(dict1)
print(dict2)
dict1[55] = "C"  # 修改dict1
print("dict1:",dict1) #dict1被修改
print("dict2:",dict2) #dict2也被修改

dict1 = {
    
    11:"Java",22:"Python",33:"C++",44:"C#",55:"Rust"}
dict2 = dict1.copy()  # dict2指向dict1的一个副本
print(dict1)
print(dict2)
dict1[55] = "C"  # 修改dict1
print("dict1:",dict1)  #dict1被修改
print("dict2:",dict2)  #dict2内容不变

运行结果如下：
===================== RESTART: C:\Python\Python38\First.py =====================
{
    
    11: 'Java', 22: 'Python', 33: 'C++', 44: 'C#', 55: 'Rust'}
{
    
    11: 'Java', 22: 'Python', 33: 'C++', 44: 'C#', 55: 'Rust'}
dict1: {
    
    11: 'Java', 22: 'Python', 33: 'C++', 44: 'C#', 55: 'C'}
dict2: {
    
    11: 'Java', 22: 'Python', 33: 'C++', 44: 'C#', 55: 'C'}
{
    
    11: 'Java', 22: 'Python', 33: 'C++', 44: 'C#', 55: 'Rust'}
{
    
    11: 'Java', 22: 'Python', 33: 'C++', 44: 'C#', 55: 'Rust'}
dict1: {
    
    11: 'Java', 22: 'Python', 33: 'C++', 44: 'C#', 55: 'C'}
dict2: {
    
    11: 'Java', 22: 'Python', 33: 'C++', 44: 'C#', 55: 'Rust'}