11Python基础-字典Dict

已于 2022-04-03 15:49:15 修改
阅读量1.2k 收藏 1
点赞数
分类专栏： python 文章标签： python 开发语言 函数
于 2022-03-26 17:27:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/i_mycode/article/details/123756152
版权

Python基础-字典Dict

什么是字典

字典是Python中另一种可变容器模型，且可存储任意类型对象。字典的每个键值 key=>value 对用冒号 : 分割，每个对之间用逗号(,)分割，整个字典包括在花括号 {} 中 。顾名思义，就像是在查字典一样。有了拼音或偏旁部首（key）去找到想找的字（value）。
在这里插入图片描述

字典的特点

  1. Python 字典是由多个键值对（key-value）组成的集合，每一个 key 和一个 value 相关联（键必须是唯一的，但值则不必）。
  2. 键值对中的 value 可以是数字、字符串、列表、元组或者其他字典。实际上，可以是任何有效的数据类型。
  3. 键值对中的 key 必须是不可变对象。也就是说，它不能被改变，具体包括数字、字符串、元组等。（值可以取任何数据类型，但键必须是不可变的，如字符串，数字）

创建字典

需要注意的是如何创建空字段

# 使用{} 创建字段
dict1 = {"username":"i_mycode", "platform":"CSDN"}
print(dict1) #{'username': 'i_mycode', 'platform': 'CSDN'}
# 创建空字典
dict2 = {}
print(dict2) #{}

# 使用内建函数 dict() 创建字典
dict3 = dict(username="i_mycode", platform="CSDN")
print(dict3) #{'username': 'i_mycode', 'platform': 'CSDN'}
# 创建空字典
dict4 = dict()
print(dict4) #{}

其他还有创建字典的方式，可以参看下文创建字典对象的9种方式

字典元素查增改删

字段存储KV信息，重点在于对信息的增删改查，下面一起看下如何对字典内元素的增删改查。

查询字典元素

如果想要访问 key 关联的 value，可以将其放入方括号内:

  1. 字典对象名[key]
# 有字典dict5
dict5 = {"username":"i_mycode", "age":25, "interest":"Python"}
print(dict5["username"]) #i_mycode
print(dict5["age"]) # 25
print(dict5["interest"]) # Python

当使用上述方式访问到一个key，这个key不存在与字典中，则会报错KeyError。

print(dict5["address"]) 
#Traceback (most recent call last):
#  File "E:/code_py/myPython/test.py", line 3, in <module>
#    print(dict5["address"]) 
#KeyError: 'address'
  1. get()
    此时可以使用字典的get()方法来获取自己不知道字典中是否存在的key的value值。如果不存在则返回None。
    get()还可以赋默认值。当key不存在时，返回设置的默认值，见下例：
print(dict5["address"]) #None
print(dict5["address","不存在"]) #不存在
  1. setdefault()
    同get()找不到不会报KeyError，且可赋默认值，不再赘述。

添加字典元素

  1. 使用[]
dict6 = {"username":"i_mycode", "age":25, "interest":"Python"}
#想添加一个kV address="北京"
dict6["address"] = "北京"
print(dict6) #{"username":"i_mycode", "age":25, "interest":"Python", "address":"北京"}
  1. update()方法
    下面介绍3中update的使用，核心是当update传入的key值如果不在字典中，则添加到字典。如果已存在于字典中，则修改该字典中的该key对应的值
#有字典dict7
dict7 = {"username":"i_mycode", "age":25, "interest":"Python"}
#1.update()参数是字典对象
#当添加的key值原不存在于字典
dict7.update({"address":"北京"})
print(dict7) #{'username': 'i_mycode', 'age': 25, 'interest': 'Python', 'address': '北京'}

#当添加的key值原已存在于字典
dict7.update({"age":24})
print(dict7) #{'username': 'i_mycode', 'age': 24, 'interest': 'Python', 'address': '北京'}


# 2.update()参数是关键字参数
# 当添加的key值原不存在于字典
dict7.update(gender="男")
print(dict7) #{'username': 'i_mycode', 'age': 24, 'interest': 'Python', 'address': '北京', 'gender': '男'}

# 当添加的key值原已存在于字典
dict7.update(address="上海") 
print(dict7) #{'username': 'i_mycode', 'age': 25, 'interest': 'Python', 'address': '上海', 'gender': '男'}


#3.update()参数是字典解包
# 当添加的key值原不存在于字典
add_dict = {"a":1, "b":2}
dict7.update(**add_dict)
print(dict7) #{'username': 'i_mycode', 'age': 24, 'interest': 'Python', 'address': '上海', 'gender': '男', 'a': 1, 'b': 2}

# 当添加的key值原已存在于字典
add_dict1 = {"address":"bj", "age":26}
dict7.update(**add_dict1)
print(dict7) #{'username': 'i_mycode', 'age': 26, 'interest': 'Python', 'address': 'bj', 'gender': '男', 'a': 1, 'b': 2}

修改字典元素

  1. 直接修改已知的key
dict8 = {"username":"i_mycode", "age":25, "interest":"Python"}
#想将age改为26
dict8["age"] = 26
print(dict8) #{"username":"i_mycode", "age":26, "interest":"Python"}
  1. 上述增加时已经存在于字典中的key则都是修改了，不再赘述

删除字典元素

  1. del key值
dict9 = {"username":"i_mycode", "age":25, "interest":"Python"}
#删除key：age
del dict9["age"] 
print(dict9) #{"username":"i_mycode", "interest":"Python"}
  1. pop()方法
    删除不存在的key时会报错，有参数容错，删不存在的key时，可以指定返回值。
dict9 = {"username":"i_mycode", "age":25, "interest":"Python"}
#删除key：age
a = dict9.pop("age")
print(dict9) #{"username":"i_mycode", "interest":"Python"}
print(a) # 25

dict9.pop("age1")
print(dict9) 
# Traceback (most recent call last):
#   File "E:/code_py/myPython/test.py", line 6, in <module>
#     dict9.pop("age1")
# KeyError: 'age1'

b = dict9.pop("age1","不存在")
print(dict9) #{"username":"i_mycode", "interest":"Python"}
print(b) # 不存在
  1. clear()
    清除字典中所有的kv
dict9 = {"username":"i_mycode", "age":25, "interest":"Python"}
dict9.clear()
print(dict9) # {}
  1. del 字典对象
    直接干掉字典对象
dict9 = {"username":"i_mycode", "age":25, "interest":"Python"}
del dict9
  1. popitem()
    随机删除一个Entry，然后返回删除的Entry（每个Entry是key与value组成的一个Tuple对象）
dict9 = {"username":"i_mycode", "age":25, "interest":"Python"}
res = dict9.popitem()
print(dict9) # {'username': 'i_mycode', 'age': 25}
print(res) # ('interest', 'Python')

字典遍历

  1. for循环遍历字典
    想要遍历字典中的键值对，可以使用一个 for 循环，指定两个代表键和值的变量，用于解包列表中的元组。

Python 字典提供了一个 items() 方法，可以返回一个包含键值对列表的对象，类似于一个元组构成的列表。例如：

person = {
    'username': 'i_mycode',
    'age': 25,
    'interest': ['Python', 'java'],
    "address":"bj"
}
print(person.items())# dict_items([('username', 'i_mycode'), ('age', 25), ('interest', ['Python', 'java']), ('address', 'bj')])

# for循环
for key, value in person.items():
    print(f"{key}: {value}")
# username: i_mycode
# age: 25
# interest: ['Python', 'java']
# address: bj
  1. 遍历所有的key
    有时候我们只需要遍历字典中的键，这种情况下可以使用 for 循环加上 keys() 方法。keys() 方法用于返回一个包含字典键的对象。或者直接遍历字典对象也是默认返回所有的key对象。
person = {
    'username': 'i_mycode',
    'age': 25,
    'interest': ['Python', 'java'],
    "address":"bj"
}
print(person.keys()) #dict_keys(['username', 'age', 'interest', 'address'])

for key in person.keys():
    print(key)
# username
# age
# interest
# address

for key in person:
    print(key)
# username
# age
# interest
# address
  1. 遍历所有的value
    字典的 values() 方法可以返回一个包含全部值的列表。使用 for 循环加上 values() 方法可以遍历字典中的全部值
person = {
    'username': 'i_mycode',
    'age': 25,
    'interest': ['Python', 'java'],
    "address":"bj"
}
print(person.values()) #dict_values(['i_mycode', 25, ['Python', 'java'], 'bj'])

for value in person.values():
    print(value)
# i_mycode
# 25
# ['Python', 'java']
# bj

字典推导式

字典推导式可以针对字典执行一个 for 循环，对每个元素执行某些操作（例如变换或者过滤），然后返回一个新的字典。与 for 循环不同，字典推导式提供了一个更具表达能力和简洁性的语法。以下是字典推导式的基本语法：

{key:value for (key,value) in dict.items() if condition}

例如：将字典中每个key的value值做数学运算

my_dict = {
	"语文":60,
	"数学":80,
	"英语":70,
	"历史":65,
	"政治":68
}
# 可以利用循环遍历的方式处理
new_dict = {}
for k,v in my_dict.items():
	new_dict[k] = v + 5
print(new_dict) # {'语文': 65, '数学': 85, '英语': 75, '历史': 70, '政治': 73}

# 利用字典推导式
new_dict1 = {k:v+5 for (k,v) in my_dict.items()}
print(new_dict1) # {'语文': 65, '数学': 85, '英语': 75, '历史': 70, '政治': 73}

#过滤value值小于70的元素
new_dict2 = {k:v for (k,v) in my_dict.items() if v >= 70}
print(new_dict2) # {'数学': 80, '英语': 70}

字典key的特性

字典值可以是任何的 python 对象，既可以是标准的对象，也可以是用户定义的，但键不行。
两个重要的点需要记住：

  1. 不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住。
    可以看到下面的代码中person字段中有两个address。此时后面的"address":"sh"会被记住
person = {
    'username': 'i_mycode',
    'age': 25,
    'interest': ['Python', 'java'],
    "address":"bj",
    "address":"sh"
}
print(person["address"]) # sh
  1. 键必须不可变，所以可以用数字，字符串或元组充当，例如用列表（可变）就不行。
person = {
    'username': 'i_mycode',
    'age': 25,
    'interest': ['Python', 'java'],
    "address":"bj",
    ["csdn"]:"nice"
}
print(person)
# Traceback (most recent call last):
#   File "E:/code_py/myPython/test.py", line 6, in <module>
#     ["csdn"]:"nice"
# TypeError: unhashable type: 'list'

字典内置函数及方法

字典中有丰富的内置函数及方法供使用，这里学习几个经常使用到的。

字典内置函数

len(dict)
  • 计算字典元素个数，即键的"去重"总数。当key有重复时最后一个key的值被记住。len()返回的是去重key数字
  • 举例：
dict_len = {"a":1,"b":2,"c":3}
print(len(dict_len)) # 3

dict_len = {"a":1,"b":2,"c":3,"c":4}
print(len(dict_len)) # 3
str(dict)
  • 输出字典，可以打印的字符串表示。
  • 举例：
dict_str = {"a":1,"b":2,"c":3}
print(str(dict_str)) #{'a': 1, 'b': 2, 'c': 3} 此时是个字符串被输出

dict_str = {}
print(str(dict_str)) #{}
type(variable)
  • 返回输入的变量类型，如果变量是字典就返回字典类型
  • 举例：
dict_type = {"a":1,"b":2,"c":3}
print(type(dict_type)) #<class 'dict'>

字典方法

dict.clear()
  • 删除字典内所有元素
  • 举例：
tinydict = {'Name': 'Zara', 'Age': 7}

print("字典长度 : %d" %  len(tinydict)) # 字典长度 : 2
tinydict.clear()
print("字典删除后长度 : %d" %  len(tinydict)) # 字典删除后长度 : 0
dict.copy()
  • 返回一个字典的浅复制
  • 举例：
dict1 = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
 
dict2 = dict1.copy()
print ("新复制的字典为 : ",dict2)
字典的深浅拷贝

这里说一下字典的直接复制，浅拷贝(copy) 和 深拷贝(deepcopy)。

  • 直接赋值：其实就是对象的引用（别名）。
  • 浅拷贝(copy)：拷贝父对象，不会拷贝对象的内部的子对象。
  • 深拷贝(deepcopy)： copy 模块的 deepcopy 方法，完全拷贝了父对象及其子对象。
  1. 直接赋值

举例：

a = {1: [1,2,3]}
b = a
print(a,b) # ({1: [1, 2, 3]}, {1: [1, 2, 3]})

解析：
在这里插入图片描述

  1. 字典的浅拷贝

举例：

a = {1: [1,2,3]}
b = a.copy()
print(a, b) #({1: [1, 2, 3]}, {1: [1, 2, 3]})
a[1].append(4)
print(a, b) #({1: [1, 2, 3, 4]}, {1: [1, 2, 3, 4]})

解析：

  1. 字典的深拷贝
    深拷贝需要引入 copy 模块
    举例：
import copy

a = {1: [1,2,3]}
b = copy.deepcopy(a)
print(a, b) # ({1: [1, 2, 3, 4]}, {1: [1, 2, 3, 4]})
a[1].append(5)
print(a, b) # ({1: [1, 2, 3, 4, 5]}, {1: [1, 2, 3, 4]})

解析：
在这里插入图片描述

dict.fromkeys()
  • 创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
  • dict.fromkeys(seq[, value])
  • 举例：
seq = ('name', 'age', 'sex')
 
tinydict = dict.fromkeys(seq)
print("新的字典为 : %s" %  str(tinydict)) # 新的字典为 : {'name': None, 'age': None, 'sex': None}
 
tinydict = dict.fromkeys(seq, 10)
print("新的字典为 : %s" %  str(tinydict)) # 新的字典为 : {'name': 10, 'age': 10, 'sex': 10}
dict.get(key, default=None)
  • 返回指定键的值，如果键不在字典中返回 default 设置的默认值
  • 前面已经介绍了该方法，不再赘述
key in dict
  • 如果键在字典dict里返回true，否则返回false
  • 举例：
seq = {1:1, 2:2, 3:3}
if 1 in seq:
	print("1中存在seq中")
@nanami
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Python数据分析实战4.1-字典dict映射【python】
12-21
【课程4.1】 字典dict基本概念 字典是另一种可变容器模型，且可存储任意类型对象。 字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中 键必须是唯一的，但值则不必...
字典中把所有的键和值分别取出来，把键和值分别各自放到一个列表中
weixin_44274975的博客
03-16 1万+
dicts = {“员工1”:“经理1”,“员工2”:“经理2”,“员工3”:“主管2”,“经理1”:“主管1”,“经理2”:“主管1”,“主管1”: “总监1”,“主管2”: “总监1”,“总监1”: “CTO”} #把字典所有的键取出来放在一个列表中 work_keys = dicts.keys() dict_keys([‘主管1’, ‘总监1’, ‘经理2’, ‘主管2’, ‘员工2’, ‘...
Python 字典
zzyy17的专栏
10-10 627
字典 字典Dictionary，在一些变成语言中也称为hash, map, 是一种由键值对组成的数据结构。 顾名思义，我们把键值想象成字典中的单词，值想象成词对应的定义，那么—— 一个词可以对应一个或者多个定义，但是这些定义只能通过这个词来进行查询。 基本操作 空字典 Python使用{}或者dict{}来创建一个个空的字典： a = {} type{a} a = ...
字典与集合
m0_51534043的博客
11-24 550
字典与集合 一.字典 1.字典的概念 在Python中，字典也如现实生活中的字典一样，使用词-语义进行数据的构建，其中词对应键（key），词义对应值（value），即键与值构成某种关系，通常将两者称为键值对，这样通过键可以快速找到对应的值。字典是由元素构成的，其中每个元素都是一个键值对。 students=｛name:小乔,id:123456'',score`:｝ 示例中，字典由3个元素构成，元素之间用逗号隔开，整体用大括号括起来。每个元素是一个键值对，键与值之间用冒号隔开，如’name’:‘xiaoqia
python中Dict 字典类型（键值对）
erxiong111的博客
08-16 2028
python中Dict 字典类型 字典也是用于存储一组或者多组数据时使用 字典是 键值对 的存储方式 name : admin 键和值之间使用冒号分隔 键必须是字符串或者数字类型,键可以是任意类型 键名不能重复,值可以重复 比如需要记录一本树相关数据 书名,作者,价格… vard = [{‘title’:’<鬼谷子>’,‘author’:‘鬼谷子’,‘price’:‘29’},{‘title’:’<鬼谷子>’,‘author’:‘鬼谷子’,‘price’:‘30’}] pr
python创建字典多种方式
Ydoing的专栏
04-21 3万+
1.创建空字典>>> dic = {} >>> type(dic) <type 'dict'>2.直接赋值创建>>> dic = {'spam':1, 'egg':2, 'bar':3} >>> dic {'bar': 3, 'egg': 2, 'spam': 1}3.通过关键字dict和关键字参数创建>>> dic = dict(spam = 1, egg = 2, bar =3) >>> dic
第7章-python字典和集合-python基础-快速入门-课件教程.pptx
06-13
第七章 Python字典和集合 字典的表示 字典的使用 1 2 5 字典的遍历和嵌套 集合的表示和使用 4 字典的相关方法 3 第7章-python字典和集合-python基础-快速入门-课件教程全文共31页，当前为第1页。 1 字典的表示 ...
python-dict-方法.docx
06-11
在本文中，我们将介绍Python字典的一些常用方法。 1. 创建字典 在Python中，可以使用大括号{}或dict()函数来创建一个字典。例如： ``` # 使用大括号创建字典 my_dict = {'name': 'Alice', 'age': 25, 'city': 'New ...
Python 的字典（Dict）是如何存储的
09-19
主要介绍了Python 的字典（Dict）是如何存储的,文中介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Python数据类型之Dict字典实例详解
09-19
主要介绍了Python数据类型之Dict字典,结合具体实例形式详细分析了Python字典的概念、原理、定义、元素添加、删除、遍历等相关操作技巧,需要的朋友可以参考下
python 获取字典键值对
热门推荐
非猿
06-19 6万+
获 得 字 典 键、 值 的 函 数 有：items/ iteritems/ keys/ iterkeys/ values/ itervalues， 通 过 这 些 函 数 得 到 的 是 键 或 者 值 的 列 表。 a_dict = {" name": "qiwsir", "lang": "python", "email": "qiwsir@ gmail.com", "website": "...
python中字典的键必须是不可变的吗_不可变字典，仅用作另一个字典的键
weixin_39520013的博客
12-05 4649
我需要实现一个可散列的dict，这样我就可以使用一个字典作为另一个字典的键。不过，我收到一位同事的通知，他说：“这并不是一成不变的，因此不安全。”。你可以用它，但它确实让我感觉像只悲伤的熊猫。所以我开始四处寻找创造一个不变的。我不需要将“键dict”与另一个“键dict”进行比较。它的唯一用途是作为另一本字典的钥匙。我想到了以下几点：class HashableDict(dict):"""Hash...
python字典长度可变吗_为什么Python中字典的key必须是不可变的？
weixin_39736934的博客
11-28 252
为什么字典的key必须是不可变的？字典的哈希表实现使用从键值计算的哈希值来查找键。如果键是可变对象，则其值可能会发生变化，因此其哈希值也会发生变化。但是，由于无论谁更改键对象都无法判断它是否被用作字典键值，因此无法在字典中修改条目。然后，当你尝试在字典中查找相同的对象时，将无法找到它，因为其哈希值不同。如果你尝试查找旧值，也不会找到它，因为在该哈希表中找到的对象的值会有所不同。如果你想要一个用列表...
python字典
pasdf的博客
11-30 115
#字典 字典 dictionary ，在一些编程语言中也称为 hash ， map ，是一种由键值对组成的数据结构。 顾名思义，我们把键想象成字典中的单词，值想象成词对应的定义，那么—— 一个词可以对应一个或者多个定义，但是这些定义只能通过这个词来进行查询。 基本操作 空字典 a = {} type(a) #dict a = di...
Python dict字典基本操作（包括添加、修改、删除键值对
weixin_44769957的博客
11-03 7823
由于字典属于可变序列， 所以我们可以任意操作字典中的键值对（key-value）。 Python 中，常见的字典操作有以下几种： 向现有字典中添加新的键值对。 修改现有字典中的键值对。 从现有字典中删除指定的键值对。 判断现有字典中是否存在指定的键值对 初学者要牢记， 字典是由一个一个的 key-value 构成的， key 是找到数据的关键， Python 对字典的操作都是通过 key 来完成的。 Python字典添加键值对 a = {'数学':95} print(a)#{'数学'
Python dict字典基本操作（包括添加、修改、删除键值对）
yinlu521wang的博客
08-13 5万+
由于字典属于可变序列，所以我们可以任意操作字典中的键值对（key-value 对）。Python中，常见的字典操作有以下几种： 向现有字典中添加新的键值对。 修改现有字典中的键值对。 从现有字典中删除指定的键值对。 判断现有字典中是否存在指定的键值对。 初学者要牢记，字典中常常包含多个键值对，而 key 是字典的关键数据，字典的基本操作都是围绕 key 值实现的。 Python字典添加...
python取字典键值对组成列表_Python 补漏——列表和字典
weixin_30313365的博客
01-16 3986
列表和“+”合并不同的是，append不用产生新对象，所以执行起来通常比较快。你也可以用聪明的分片运算模拟append：L[len(L):]=[X]就与L.append(X)一样，而L[:0]=[X]就好像在列表前端附加那样。两者都会删除空分片，并插入X，快速地在适当之处修改L，就像append一样。对列表元素进行遍历操作运行效率循环语句运行结果可以看出，map对象转化为list需耗费大量时间，但...
python遍历字典键值对
百雨的博客
12-27 2万+
先看成果： 代码： user_0 = { 'username': 'efermi', 'first': 'enrico', 'last': 'fermi' } for key, value in user_0.items(): print('\nkey:'+ key) print('value::'+ value)...
十二.Python中的字典dict(键值对)以及存储原理
神言如殇的博客
05-20 2万+
字典是"键值对"的无序可变序列,字典中的每个元素都是一个"键值对",包含:"键对象",和"值对象".可以通过"键对象"实现快速获取,删除,更新对应的"值对象". 列表中我们通过"下标数字"找到对应的对象,字典中通过"键对象"找到对应的"值对象"."键"是任意的不可变数据,比如:整数,浮点数,字符串,元组.但是:列表,字典,集合这些可变的对象,不能作为"键".并且"键"不可重复."值"可以是任意的...
python 字典dict
最新发布
08-18
字典（dict）是 Python 中一种非常有用的数据结构，用于存储键值对。字典是可变的，可以根据需要动态添加、修改或删除其中的元素。下面是一些关于字典的基本操作和示例： 1. 创建字典： ```python my_dict = {'key...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

@nanami

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值