Python __dict__

Python __dict__

在Python中，字典是一个无序的数据值集合，可以用来存储数据值，类似于映射。与其他数据类型不同，字典还可以包含键值对。为了使字典更高效，提供了键-值对。

在属性访问方面，大多数用户都熟悉使用点”.”（例如x.any_attribute）来访问属性。简单来说，属性访问是获取已连接到已有对象的对象的过程。对于没有深入了解Python的用户来说，这可能看起来很简单。然而，对于这个相对简单的过程，背后有很多事情发生。

什么是__dict__

每个模块都有一个称为__dict__的独特属性。这个字典包含了该模块的符号表。项目的（可写）特征被存储在字典或其他映射对象中。

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

语法

object.__dict__

示例1

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__。
• __dict__包含模块的符号表。
• 元素的属性存储在 映射对象 中。
• Python中的每个对象都有一个 由符号__dict__指示的属性 。
• dict的另一个名称也被称为 mappingproxy对象 。
• Python字典的两个组成部分称为 键和值 。
• 由于字典不会按特定顺序保留其数据，因此 您可能不会以相同的顺序获得输入的数据 。
• 键将只包含 一个元素 。
• 值可以是 整数、列表、列表中的列表等 。
• 每个键 最多只能有一个条目 （不允许重复键）。
• 字典的键必须是 不可变的，如整数、元组或字符串 ，而值可以是任何类型。
• 字典 键区分大小写 ；在Python字典中，不同拼写的相同键名被视为 不同的键 。