Python入门笔记4 - 字典

Posted 2022-11-22

• 参考书《Python基础教程（第三版）》—— Magnus Lie Hetland

---

文章目录

• ​​一、字典的用途​​
• ​​二、创建字典​​

• ​​（1）直接创建​​
• ​​（2）使用构造函数dict()​​

• ​​三、字典基本操作​​

• ​​（1） 字典的基本行为在很多方面类似序列​​
• ​​（2） 自动添加​​
• ​​（3） 关于成员资格的说明​​
• ​​（4） 综合示例​​

• ​​四、用字典简化字符串的格式设置​​
• ​​五、字典方法​​

• ​​（1） .clear():None​​
• ​​（2）.copy():dict​​
• ​​（3）.fromkeys(键列表,(初始值)):dict​​
• ​​（4）.get(键 , (查找失败返回值) ):value​​
• ​​（5）.item():字典视图​​
• ​​（6）.keys():字典视图​​
• ​​（7）.pop(键):value​​
• ​​（8）.popitem():(Key,Value)​​
• ​​（9）.setdefault(键,查找失败返回值): Value​​
• ​​（10）.update(字典)：None​​
• ​​（11）.values():字典视图​​

一、字典的用途

• 字典旨在让你轻松地找到特定的单词（键），以获得其定义（值）（看起来类C++ STL的map）
• 常见用途

1. 表示棋盘的状态，每个键都是坐标元组
2. 存储文件修改时间，其中键为文件名
3. 数字电话/地址譜

• 示例：

#假设有以下名单
>>> names = [Alice,Tom,Bill]
    
#现在要存储它们的电话号码，可以再创建一个列表
>>> numbers = [1234,1100,9987]

#可以这样访问一个人的号码
>>> numbers[names.index(Bill)]
    
#这种方法比较麻烦，我们希望以numbers[Bill]这种形式访问，这就要用到字典了

二、创建字典

• 字典：形如​​Alice:1234 , Tom:1100 , Bill:9987​​
• 字典由​​键值对​​​组成，上面​​Alice:1234​​​就是一个键值对，​​Alice​​​是键（Key），​​1234​​​是值(Value)，中间用键和值之间用​​:​​分割
• 同一个字典中键必须是独一无二的，值可以重复
• 字典内部是无序的，打印字典时键值对打印顺序不确定，没有下标索引
• 字典是python中唯一内置的映射类型
• 字典支持的数据类型：

1. 一个对象能不能作为字典的key，取决于其有没有__hash__方法。所以所有python自带类型中，除了list、dict、set和内部至少带有上述三种类型之一的tuple之外，其余的对象都能当key。（引用自：​​Python中字典的key都可以是什么？​​）
2. 可以作value的对象清单暂时没有找到，不过根据使用经验几乎所有类型的对象都可以为value

（1）直接创建

#创建一个字典
phoneBook = Alice:1234 , Tom:1100 , Bill:9987

#创建一个空字典
phoneBook = 

（2）使用构造函数dict()

• dict(序列) 函数可以从其他映射(如其他字典)、键值对序列、关键字实参创建字典

>>> items = [(name,Tom) , (age,18)]

#从元组序列创建  
>>> d = dict(iteams)
>>> d
name: Tom, age: 18
>>> d[name]
Tom
  
#从其他字典创建  
>>> d2 = dict(d)     
>>> d2
name: Tom, age: 18

#使用关键字实参来创建字典
>>> d = dict(name = Tom, age = 18)
>>> d
name: Tom, age: 18

#如果不写参数，创建空字典
>>> d = dict()
>>> d

三、字典基本操作

（1） 字典的基本行为在很多方面类似序列

1. ​​len(d)​​ 返回字典的键值对数量
2. ​​d[k]​​ 返回与键k相关的值
3. ​​d[k] = v​​ 将值v关联到k
4. ​​del d[k]​​ 删除键为k的项
5. ​​k in d​​ 检测d是否包含键为k的项

d = dict([(name,Tom) , (age,18)])   #dict()           创建字典
print("字典长度：".format(len(d)))       #len(字典)方法    返回字典长度 
print("姓名：".format(d[name]))        #d[键]             返回和键关联的值

d[name] = Bill                        #修改键关联的值
print("姓名：".format(d[name]))   
  
del d[name]                             #del d[键]         删除字典中一个键值对
print("字典长度：".format(len(d)))       #len(字典)        方法返回字典长度
 
print(name in d)                        #k in d  

#字典长度：2
#姓名：Tom
#姓名：Bill
#字典长度：1
#False

（2） 自动添加

• 即使是字典中原本没有的键，也可以给他赋值，这样会自动在字典中创建新项；
• 相比而言，如果不使用append或其他类似的方法，就不能给列表中没有的元素赋值

d = dict([(name,Tom) , (age,18)]) 
print("字典长度：".format(len(d)))   #长度是2 

d[score] = 100            #给不存在的键赋值，字典中自动加入键值对score:100
print("字典长度：".format(len(d)))   #长度是3

（3） 关于成员资格的说明

1. 表达式 k in dict（字典）查找的是键而不是值
2. 表达式 k in list（列表）查找的是值而不是键（索引）
   （相比查找指定的值是否存在，查找键的效率更高）

（4） 综合示例

# 一个简单的数据查询示例
people =           #people字典，键值对构成是字符串:字典
  Alice:   
      phone:1234,
      score:100
  ,

  Bill:
    phone:1100,
    score:80
  


reqList = [phone,score] #reqList列表

name = input("Name：")
request = input("The items you want to query is (phone or score)：")

if name in people and request in reqList: #字典的in方法和列表的in方法
  print(people[name][request])
else:
  print("Name or item does not exist!!")

四、用字典简化字符串的格式设置

• 通过在字典中存储一系列命名的值，可以让string的format方法更简洁
• 利用string的format_map方法指出你将通过字典传递所需的信息

>>>phoneBook =  Alice:1234 , Tom:1100 , Bill:9987
>>> print("Alices phone number is Alice".format_map(phoneBook))   
Alices phone number is 1234

（似乎这个方法要求键必须是字符串，且在格式中写键时不要加’’）

People =   
      name:[john,peter],
      age:[56,64] 
    
    
#打印My name is john,i am 56 old      
print(My name is name[0],i am age[0] old.format_map(People))

五、字典方法

（1） .clear():None

• 删除字典中所有字典项，此操作就地执行，无返回值

（2）.copy():dict

• 复制字典中所有项，返回一个新字典（这是浅复制）：如果替换副本中的值，原件不受影响，但若就地修改副本的值，原件受到影响
• 为了实现深复制，使副本和原件完全区别，可以用copy模块中的​​deepcopy(dict)​​方法

>>> from copy import deepcopy
>>> ...      #初始化字典d
>>> dc = deepcopy(d) #dc和d完全无关了

（3）.fromkeys(键列表,(初始值)):dict

• 返回一个新字典，其中包含指定的键，且每个键对应的值都是None，也可以指定所有键的初始值。可以用类名​​dict.fromkeys()​​​调用，也可以用对象名​​object.fromkeys()​​调用（不会影响原对象）

>>> dct = 1:A
>>> dct.fromkeys([3,4,5])  
3: None, 4: None, 5: None
>>> dct                #原对象没有受到影响
1: A

>>> .fromkeys([name,age])    #先创建了一个空字典，再用fromkeys方法
name:None , age:None

>>> dct.fromkeys([name,age]) #直接对dct（类名）调用fromkeys方法
age: None, name: None
  
>>> dct.fromkeys([name,age], (unkonwn))  #设置初始化值
age:(unkonwn) , name:(unkonwn)

（4）.get(键 , (查找失败返回值) ):value

• 方法get避免了访问字典中不存在的键时出错，当键不存在时返回你设定的值，如果没有设定，返回None
• 如果查找的键存在，效果和普通的[]查找返回一致

>>> d.get(name)  #假设字典中没有name键
>>> None

>>> d.get(name,N/A)  #假设字典中没有name键
>>> N/A
        
>>> d.get(name,N/A)  #假设字典中有键值对name:123
>>> 123

• 如果返回的是可变类型（列表、字典…），修改会影响原字典

d = 1:[A,A], 2:[B,B]
l = d.get(1)
l[0] = B
print(d.get(1))   #打印:B A

（5）.item():字典视图

• item()方法返回一个包含所有字典项的特殊列表，其中每个元素都是(key,value)形式，字典项在列表中的排序顺序不确定
• 返回值是一种叫字典视图的特殊类型，可以用于迭代，还可以对它求长度和进行成员资格检查
• 视图的一个优点是不复制，即使调用item()方法后修改原始字典，变化也会在先前的字典视图中反映出来
• 可以用list()把字典视图转为普通list

>>> dct
1: A, 2: B
>>> dct.items()
dict_items([(1, A), (2, B)])  #这是一个 “字典视图”

>>> it = dct.items()
>>> (1,A) in it
True

>>> dct[1] = a
>>> (1,A) in it      #对底层字典的修改，会即时反映在字典的 “字典视图”中
False
>>> (1,a) in it
True

（6）.keys():字典视图

• 返回一个字典视图，包含指定字典中的键

（7）.pop(键):value

• 返回字典中键对应的值，同时把此键值对从字典删除

>>> d = x:1,y:2
>>> d.pop(x)
1
>>> d
y:2

（8）.popitem():(Key,Value)

• 从字典中随机返回一个键值对（字典是无序的），并把此键值对从字典删除

（9）.setdefault(键,查找失败返回值): Value

• 类似.get(键,查找失败返回值)，区别在于，这个在查找失败时，不但返回预设值，并且把这个键和预设值组成的键值对加入字典

（10）.update(字典)：None

• 使用参数字典中的项来更新当前字典
• 如果当前字典中和参数字典包含由相同的键的项，替换他
  如果当前字典中没有参数字典中的某些项，将这些 “键值对” 加入原字典
• 可以像dict(类型构造函数)那些调用update方法，即调用update()时，可以向它提供一个映射、一个由键值对组成的序列或关键字参数

（11）.values():字典视图

• 返回一个由字典中的所有值组成的字典视图
• 返回的视图中可能包含重复的元素

>>> d = 
>>> d[1] = 1
>>> d[2] = 2
>>> d[3] = 3
>>> d[4] = 1
>>> d.values()
dict_values([1,2,3,1])