Python 中的 dict

2024 年 08 月 29 日 | 阅读 9 分钟

在 Python 中，字典是一种 **无序的数据值集合**，可以像映射一样 **用于存储数据值**。与其他只能为每个元素包含单个值的数据类型不同，字典还可以包含 **键:值** 对。为了使字典 **更高效**，提供了键值对。

在属性访问方面，大多数用户只熟悉 **"."**（例如 **x.any_attribute**）。简而言之，**属性访问就是获取与您已拥有的对象相关联的对象的過程**。对于不深入研究细节而使用 Python 的人来说，这看起来非常简单。然而，对于这个相对简单的过程，幕后还有很多工作要做。

什么是 _dict_ ？

每个模块都有一个名为 **__dict__** 的独特属性。此字典 **包含模块的符号表**。对象的（可写）特性存储在字典或其他映射对象中。

简单来说，Python 中的每个对象都有一个 **由 __dict__ 符号表示的属性**。此外，该对象拥有为其指定的所有属性。__dict__ 的另一个名称是 **mappingproxy** 对象。我们可以通过 **将 __dict__ 属性应用于类对象** 来使用字典。

语法

示例

class AnimalClass:
    def __init__(self,identity,age):
        self.identity = identity
        self.age = age
    
    def feature(self):
        if self.age == "10":
            return True
        else:
            return False
ac = AnimalClass('Lion','10')
print(ac.__dict__)

输出

{'identity': 'Lion', 'age': '10'}

示例 2

此示例将演示，通过 **__dict__ 属性**，可以从任何对象创建一个字典

# class Flowers is defined
class Flowers:
	
	# constructor
	def __init__(self):
		
		# keys are being initialized with
		# their corresponding values
		self.Rose = 'red'
		self.Lily = 'white'
		self.Lotus = 'pink'

	def displayit(self):
		print("The Dictionary from object fields belongs to the class Flowers :")


# object animal of class Animals
flower = Flowers()

# calling displayit function
flower.displayit()
# calling the attribute __dict__ on flower
# object and making it print it
print(flower.__dict__)

输出

The Dictionary from object fields belongs to the class Flowers :
{'Rose': 'red', 'Lily': 'white', 'Lotus': 'pink'}

示例 3

def funct():

    pass

funct.practice = 1

print(funct.__dict__)

class PracticeClass:

    x = 1

    def practice_function(self):

        pass

print(PracticeClass.__dict__)

输出

{'practice': 1}
{'__module__': '__main__', 'x': 1, 'practice_function': , '__dict__': , '__weakref__': , '__doc__': None}

在 Python 中使用字典而不使用 dict

创建字典

在 Python 中，可以通过将 **条目列表放在花括号中并用逗号分隔** 来创建字典。字典存储值对，其中一个元素是键，另一个是其 **键:值**。与**键**（**不能重复且必须是不可变的**）相反，字典中的**值**可以是**任何数据类型且可以重复**。

元素**用逗号分隔**，每个键**用冒号 (:)** 与其值区分开，并且整个结构包含在**花括号中**。一个完全不含任何内容的字典的写法如下： **{}**。

字典的键必须是**不可变的**，例如**整数、元组或字符串**，但值可以是任何类型。在 Python 字典中，拼写不同的相同键名被视为**不同的键**。请注意，**字典键是区分大小写的**；具有相同名称但大小写不同的键将得到不同处理。

示例

# Creating a Dictionary
# using Integer Keys only
Dict = {1: 'JAVA', 2: 'T', 3: 'POINT'}
print("\nCreating a Dictionary by using Integer Keys : ")
print(Dict)

# Creating a Dictionary
# using various Mixed keys
Dict = {'Company': 'JavaTpoint', 7: [22, 35, 46, 97]}
print("\nCreating a Dictionary by using Mixed Keys : ")
print(Dict)

输出

Creating a Dictionary by using Integer Keys : 
{1: 'JAVA', 2: 'T', 3: 'POINT'}

Creating a Dictionary by using Mixed Keys : 
{'Company': 'JavaTpoint', 7: [22, 35, 46, 97]}

**内置方法 dict()** 也允许**创建字典**。只需将**两个花括号 {}** 放在一起即可创建一个**空字典**。

示例

# Creating an empty Dictionary
myDict = {}
print("This is an Empty Dictionary: ")
print(myDict)

# Creating a Dictionary
# using the dict() method
myDict = dict({1: 'JAVA', 2: 'T', 3: 'POINT'})
print("\nCreating a Dictionary by using the dict() method : ")
print(myDict)

# Creating a Dictionary
# using each item as a different Pair
myDict = dict([(1, 'JavaTpoint'), (2, 'Great')])
print("\nCreating a Dictionary by using each item as a different pair : ")
print(myDict)

输出

This is an Empty Dictionary: 
{}

Creating a Dictionary by using the dict() method : 
{1: 'JAVA', 2: 'T', 3: 'POINT'}

Creating a Dictionary by using each item as a different pair : 
{1: 'JavaTpoint', 2: 'Great'}

创建字典的复杂性

时间复杂度： **O(length(dict))**
空间复杂度： **O(n)**

嵌套字典

这是一种字典，其中一个或多个**键将一个字典作为其值的键**。

示例

# Creating a Nested Dictionary
# as mentioned above using a dictionary as a value to a key in 
# a dictionary
myDict = dict({1: 'JAVA', 2: 'T', 3: 'POINT', 4: {1: 'JavaTpoint', 2: 'Great'}})
print("\nCreating a Nested Dictionary : ")
print(myDict)

输出

Creating a Nested Dictionary : {1: 'JAVA', 2: 'T', 3: 'POINT', 4: {1: 'JavaTpoint', 2: 'Great'}}

向字典添加元素

有**多种方法可以向 Python 字典添加元素**。例如，通过同时指定值和键 **Dict[Key] = "Value"**，可以一次向字典添加一个值。使用**内置的 update() 函数**，可以修改字典中的现有值。还可以使用**嵌套键值**来扩展现有字典。

注意：添加值时，如果键值对已存在，则会更新该值。如果不存在，则将新的键值添加到字典中。

示例

# Creating Empty Dictionary
myDict = {}
print("Empty Dictionary: ")
print(myDict)

# Adding elements only one at a time
myDict[0] = 'Java'
myDict[3] = 'T'
myDict[6] = 41
print("\nDictionary after the addition of 3 elements: ")
print(myDict)

# Adding a set of values
# to a particular Key
myDict['settingValues'] = 7, 8, 9
print("\nDictionary after the adding a set of values to a key : ")
print(myDict)

# Updating the existing Key's Value
myDict[3] = 'tPoint'
print("\nDictionary after Updated key value: ")
print(myDict)

# Adding Nested Key value to Dictionary
myDict[8] = {'Nested' :{'A' : 'boy', 'B' : 'Girl'}}
print("\nDictionary after Addition of a Nested Key: ")
print(myDict)

输出

Empty Dictionary: 
{}

Dictionary after the addition of 3 elements: 
{0: 'Java', 3: 'T', 6: 41}

Dictionary after the adding a set of values to a key : 
{0: 'Java', 3: 'T', 6: 41, 'settingValues': (7, 8, 9)}
Dictionary after Updated key value: 
{0: 'Java', 3: 'tPoint', 6: 41, 'settingValues': (7, 8, 9)}

Dictionary after Addition of a Nested Key: 
{0: 'Java', 3: 'tPoint', 6: 41, 'settingValues': (7, 8, 9), 8: {'Nested': {'A': 'boy', 'B': 'Girl'}}}

向字典添加元素的复杂性

时间复杂度： **O(1)/O(n)**
空间复杂度： **O(1)**

访问字典元素

字典使用**键**，而其他数据类型需要索引来检索值。键可以使用 **get() 函数** 或**方括号 []** 来使用。

如果**字典中找不到键**，使用**方括号 []** 会**引发 KeyError**。另一方面，如果找不到键，**get() 函数会返回 None**。

示例

# Python program to demonstrate the
# accessing of an element, from a Dictionary

# Creating a Dictionary
myDict = {1: 'Java', 'name': 'T', 2: 'Point', 4: 'Website'}

# accessing an element using key
print("Accessing an element using the key:")
print(myDict['name'])

print("Accessing another element using the key:")
print(myDict[4])

# accessing an element using the get() method
print("Accessing an using the get() method:")
print(myDict.get(2))

print("Accessing another using the get() method:")
print(myDict.get(1))

输出

Accessing an element using the key:
T
Accessing another element using the key:
Website

Accessing an using the get() method:
Point
Accessing another using the get() method:
Java

访问字典元素时的复杂性

时间复杂度： **O(1)**
空间复杂度： **O(1)**

访问嵌套字典的元素

我们可以借助**索引 [] 技术**来获取**嵌套字典**中现有键的值。

示例

# Creating a Dictionary
myDict = {'myDict1': {3: 'JavatPoint'},
		'myDict2': {'Info.': 'Website'}}

# Accessing the elements using the key
print(myDict['myDict1'])
print(myDict['myDict1'][3])
print(myDict['myDict2']['Info.'])

输出

{3: 'JavatPoint'}
JavatPoint
Website

内置字典方法

clear()

dict.clear() 函数**删除字典中的所有键值对**。

copy()

dict.copy() 方法**返回字典的浅拷贝**。

fromkeys()

dict.fromkeys() 函数**使用提供的可迭代对象**（字符串、列表、集合或元组）作为键，并使用指定的默认值，**创建一个新字典**。

get()

这**给出与给定键关联的值**。

items()

该函数 dict.items() **返回一个字典视图对象**，它提供对字典项的动态表示，作为键值对的列表。当字典更新时，这个**视图对象也会更新**。

dict.keys()

dict.keys() 函数**返回一个字典视图对象**，其中包含字典的**键列表**。

pop()

这**返回键的值，然后将其删除**。如果字典中缺少键，它要么引发 **KeyError**，要么在提供了默认值的情况下返回**默认值**。

popitem()

这**从字典中删除一个项目并返回一个 (键, 值) 对的元组**。返回对时使用**后进先出 (LIFO)** 顺序。

setdefault()

这**返回给定键的字典值**。如果找不到键，则会添加具有提供的**默认值**的键。如果未提供默认值，它会将**None** 设置为**默认值**。

values()

该函数 dict.values() **返回一个字典视图对象，该对象提供对字典中每个值的动态视图**。当字典更新时，这个**视图对象也会更新**。

update()

使用 dict.update() 函数，可以**更新字典或任何包含键值对的可迭代对象**，例如元组。

示例

# Example to demonstrate all dictionary methods
#Creating a Dictionary
mydict1={1:"HTML",2:"CSS",3:"Javascript",4:"Python"}

#copy method
mydict2=mydict1.copy()
print(mydict2)

#clear method
mydict1.clear()
print(mydict1)

#get method
print(mydict2.get(1))

#items method
print(mydict2.items())

#keys method
print(mydict2.keys())

#pop method
mydict2.pop(4)
print(mydict2)

#popitem method
mydict2.popitem()
print(mydict2)

#update method
mydict2.update({2:"C++"})
print(mydict2)

#values method
print(mydict2.values())

输出

{1: 'HTML', 2: 'CSS', 3: 'Javascript', 4: 'Python'}
{}
HTML
dict_items([(1, 'HTML'), (2, 'CSS'), (3, 'Javascript'), (4, 'Python')])
dict_keys([1, 2, 3, 4])
{1: 'HTML', 2: 'CSS', 3: 'Javascript'}
{1: 'HTML', 2: 'CSS'}
{1: 'HTML', 2: 'C++'}
dict_values(['HTML', 'C++'])

区分字典和列表

像**列表和字典**这样的数据结构在根本上是不同的。**列表**可以存储**有序的项序列**，这样我们就可以对其进行索引或迭代。列表也可以在生成后进行修改，因为它们是可变的类型。**Python 字典**是**键值存储**和**哈希表的实现**。它不遵循任何特定顺序，并且需要可哈希的键。此外，它对于键查找速度很快。

**列表**的元素包含以下特征：

除非明确重新排序（例如，通过对列表进行排序），否则它们**会保持其当前顺序**。
它们可以是任何类型，甚至是**类型的组合**。
**通过数字（从零开始）索引**，我们可以访问它们。

**字典**元素的特征如下：

每个条目都有一个**值和一个键**。
**不保证顺序**。
**使用键值**来访问元素。
**任何可哈希类型（字典除外）**都可以用作键值，并且类型可以组合。
**任何类型的值**，包括其他字典，**都是允许的**，并且类型可以组合。

用途

当我们拥有**一组不同的键对应值**时，我们使用**字典**；当我们拥有**一组有序的事物**时，我们使用**列表**。

结论

在计算机语言中，**字典是一种用于存储某种相关信息的数据结构**。
每个模块都有一个名为 **__dict__** 的独特属性。
**__dict__ 包含模块的符号表**。
元素的属性存储在**映射对象中**。
Python 中的每个对象都有一个**由 __dict__ 符号表示的属性**。
__dict__ 的另一个名称也称为**mappingproxy 对象**。
Python 字典的两个组成部分称为**键和值**。
由于字典不以任何特定顺序存储数据，因此**您可能不会按照输入数据的相同顺序取回数据**。
键将只包含**一个项目**。
值可以是**整数、列表、列表中的列表**等。
每个键最多只能有一个**条目（不允许重复键）**
字典的键必须是**不可变的**，例如**整数、元组或字符串**，但值可以是任何类型。
字典**键区分大小写**；在 Python 字典中，拼写不同的相同键名被视为**不同的键**。

下一主题Python 中的简单待办事项列表 GUI 应用程序

Python 中的 dict

什么是 _dict_ ？

语法

示例

示例 2

示例 3

在 Python 中使用字典而不使用 dict

创建字典

示例

创建字典的复杂性

嵌套字典

向字典添加元素

注意：添加值时，如果键值对已存在，则会更新该值。如果不存在，则将新的键值添加到字典中。

向字典添加元素的复杂性

访问字典元素

访问字典元素时的复杂性

访问嵌套字典的元素

内置字典方法

示例

区分字典和列表

用途

结论

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

Python 问题

Python 中的 __dict__

什么是 _dict_ ？

语法

示例

示例 2

示例 3

在 Python 中使用字典而不使用 __dict__

创建字典

示例

创建字典的复杂性

嵌套字典

向字典添加元素

注意：添加值时，如果键值对已存在，则会更新该值。如果不存在，则将新的键值添加到字典中。

向字典添加元素的复杂性

访问字典元素

访问字典元素时的复杂性

访问嵌套字典的元素

内置字典方法

示例

区分字典和列表

用途

结论

相关帖子

Python 中的 Web 开发是什么

将 Pandas DataFrame 中的列类型从字符串转换为 Datetime 格式

Python 中的链式比较运算符

如何在 Python 中将字符串转换为字典

如何在 Python 中读取文本文件

使用 Matplotlib 在 Python 中绘制箱线图

Tensor Flow

Python 中的 Caesar 密码

使用 Python 进行机器学习模型的评估指标及代码

如何在 Python 中将列表转换为字典

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器

Python 中的 dict

在 Python 中使用字典而不使用 dict