logo

TechCodeview

__dict__ em Python

Em Python, um dicionário é um conjunto não ordenado de valores de dados isso poderia ser usado para armazenar valores de dados de forma semelhante a um mapa. Ao contrário de outros tipos de dados, que só podem incluir um único valor por elemento, os dicionários também podem conter um valor chave par. Para fazer o dicionário mais eficiente , o valor-chave é oferecido.

Quando se trata de atributo de acesso, o ponto '.' (como em x.qualquer_atributo ) é tudo o que a maioria dos usuários está familiarizada. Simplesmente dito, acesso a atributos é o processo de obtenção de um objeto que está conectado a outro que você já possui . Pode parecer muito simples para alguém que usa Python sem ir muito longe nos detalhes. No entanto, há muita coisa acontecendo nos bastidores desse processo relativamente simples.

O que é _dict_?

Cada módulo possui uma propriedade única chamada __dict__. Este dicionário contém a tabela de símbolos para o módulo . As características (graváveis) de um item são armazenadas em um dicionário ou outro objeto de mapeamento.

Simplificando, todo objeto em Python tem um propriedade que é indicada pelo símbolo __dict__ . Além disso, este objeto possui todas as propriedades que foram especificadas para ele. Outro nome para __dict__ é proxy de mapeamento objeto. Podemos usar o dicionário via aplicando a propriedade __dict__ para um objeto de classe.

Sintaxe:

 object.__dict__

Exemplo :

 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__)

Saída: 

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

Exemplo 2:

Este exemplo demonstrará que, por meio do Atributo __dict__ , pode-se criar um dicionário a partir de qualquer objeto:

 # 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__)

Saída: 

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

Exemplo 3:

 def funct(): pass funct.practice = 1 print(funct.__dict__) class PracticeClass: x = 1 def practice_function(self): pass print(PracticeClass.__dict__)

Saída: 

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

Usando Dicionário sem o uso de __dict__ em Python:

Criando um dicionário:

Em Python, um dicionário pode ser feito colocando um lista de entradas entre colchetes e separando-as com uma vírgula . O dicionário armazena pares de valores, onde um elemento do par é a chave e outro é o seu Valor chave . Em contraste com chaves, qual não podem ser repetidos e devem ser imutáveis, os valores em dicionários pode ser de qualquer tipo de dados e pode ser duplicado .

Os elementos são separados por vírgulas , cada chave é diferenciada de seu valor por dois pontos (:), e toda a estrutura está contida em colchetes . Um dicionário completamente desprovido de todas as palavras é escrito da seguinte forma: {} .

As chaves do dicionário devem ser imutável , como inteiros, tuplas ou strings , embora os valores possam ser de qualquer tipo. Nos dicionários Python, o mesmo nome de chave escrito de forma diferente é considerado como uma chave distinta. Por favor, tome nota que chaves de dicionário diferenciam maiúsculas de minúsculas ; chaves com nome semelhante, mas com maiúsculas e minúsculas distintas, serão tratadas de maneira diferente.

Exemplo : 

 # Creating a Dictionary # using Integer Keys only Dict = {1: 'JAVA', 2: 'T', 3: 'POINT'} print('
Creating a Dictionary by using Integer Keys : ') print(Dict) # Creating a Dictionary # using various Mixed keys Dict = {'Company': 'JavaTpoint', 7: [22, 35, 46, 97]} print('
Creating a Dictionary by using Mixed Keys : ') print(Dict)

Saída: 

 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]}

O método interno dict() também permite a criação de dicionários . Simplesmente colocando duas chaves {} juntos resultarão em um dicionário vazio .

Exemplo :

 # 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('
Creating 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('
Creating a Dictionary by using each item as a different pair : ') print(myDict)

Saída: 

 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'}

Complexidades para criar um Dicionário:

  • Complexidade de tempo: O(comprimento(dict))
  • Complexidade Espacial: Sobre)

Dicionários aninhados:

É uma forma de dicionário onde um ou mais de um chaves tem um dicionário anexado a ela como um valor da chave.

roda do mouse não rola corretamente

Exemplo : 

 # 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('
Creating a Nested Dictionary : ') print(myDict)

Saída: 

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

Adição de elementos a um dicionário:

Há vários métodos para adicionar elementos para um dicionário Python. Ao especificar o valor e a chave juntos, por exemplo, Dict[Chave] = 'Valor', um valor pode ser adicionado a um dicionário por vez. Usando o função update() integrada , pode-se modificar um valor existente em um Dicionário. Um Dicionário existente também pode ser expandido com valores-chave aninhados .

Nota: Ao adicionar um valor, o valor é atualizado se a combinação de valores-chave já existir. Caso contrário, uma nova chave e um novo valor serão adicionados ao dicionário.

Exemplo : 

 # 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('
Dictionary after the addition of 3 elements: ') print(myDict) # Adding a set of values # to a particular Key myDict['settingValues'] = 7, 8, 9 print('
Dictionary after the adding a set of values to a key : ') print(myDict) # Updating the existing Key's Value myDict[3] = 'tPoint' print('
Dictionary after Updated key value: ') print(myDict) # Adding Nested Key value to Dictionary myDict[8] = {'Nested' :{'A' : 'boy', 'B' : 'Girl'}} print('
Dictionary after Addition of a Nested Key: ') print(myDict)

Saída: 

 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'}}}

Complexidades para adicionar elementos a um Dicionário:

  • Complexidade de tempo: O(1)/O(n)
  • Complexidade Espacial: O(1)

Acessando elementos do dicionário:

Um dicionário emprega chaves , enquanto outros tipos de dados exigem indexação para recuperar valores. As chaves podem ser utilizadas com o função get() ou entre colchetes [].

Caso um a chave não pode ser encontrada no dicionário, KeyError é produzido se usarmos colchetes []. Por outro lado, se a chave não puder ser localizada, o A função get() retorna Nenhum.

Exemplo : 

 # 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))

Saída: 

 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

Complexidades para acessar elementos em um Dicionário:

  • Complexidade de tempo: O(1)
  • Complexidade Espacial: O(1)

Acessando o elemento de um dicionário aninhado:

Podemos contar com a ajuda do técnica de indexação [] para obter o valor de uma chave existente no dicionário aninhado .

Exemplo : 

 # 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.'])

Saída: 

 {3: 'JavatPoint'} JavatPoint Website

Métodos de dicionário integrados:

claro() :

A função dict.clear() elimina todos os pares de valores-chave do dicionário.

cópia de() :

A cópia mais superficial do dicionário é retornado pelo método dict.copy().

fromkeys() :

Usando o iterável fornecido (string, lista, conjunto ou tupla) como chaves e o valor especificado, a função dict.fromkeys() cria um novo dicionário .

pegar() :

Esse dá o valor associado com a chave fornecida.

Unid() :

A objeto de visualização de dicionário , que oferece uma apresentação dinâmica dos itens do dicionário como uma lista de pares de valores-chave é retornado pela função dict.items(). Quando o dicionário é atualizado, isso o objeto de visualização também é atualizado .

dict.keys() :

A função dict.keys() retorna um objeto de visualização de dicionário com o dicionário lista de chaves.

pop():

Esse retorna o valor da chave após removê-la . Se uma chave estiver faltando no dicionário, ele lança um KeyError ou devolve o valor padrão se um fosse fornecido.

bebida() :

Esse remove um item do dicionário e retorna uma tupla de pares (chave, valor). O Último a entrar, primeiro a sair (LIFO) sequência é usada para retornar pares.

conjunto padrão() :

Esse retorna o valor do dicionário para a chave fornecida . Se a chave não puder ser descoberta, a chave com o código fornecido valor padrão Está adicionado. Ele define Nenhum Enquanto o valor padrão se não for fornecido.

valores():

O objeto de visualização de dicionário que oferece uma visualização dinâmica de cada valor que é presente no dicionário, é retornado pela função dict.values(). Quando o dicionário é atualizado, isso o objeto de visualização também é atualizado .

atualizar() :

A dicionário ou qualquer iterável com pares de valores-chave , como uma tupla, pode ser atualizado usando a função dict.update().

Exemplo :

 # 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())

Saída: 

 {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++'])

Diferenciando entre um dicionário e uma lista:

Estruturas de dados como lista e um dicionário são fundamentalmente diferentes. Um série ordenada de itens pode ser armazenado em um lista para que possamos indexá-lo ou iterá-lo. As listas também podem ser alteradas mesmo depois de já terem sido geradas, pois são de um tipo mutável. O Dicionário Python é um armazenamento de valores-chave e uma implementação de um tabela hash . Ele não segue nenhuma sequência específica e requer chaves hash. Além disso, é rápido para pesquisas importantes.

A lista elementos contêm os seguintes recursos:

  • A menos que sejam especificamente reordenados, eles manter a ordem atual (por exemplo, ordenando a lista).
  • Eles podem ser de qualquer tipo, ou mesmo um combinação de tipos .
    • Através de índices numéricos (base zero), podemos acessá-los.

As características de dicionário elementos são os seguintes:

  • Cada entrada tem um valor e uma chave .
  • Os pedidos são não garantido .
    • Valores-chavesão usados ​​para acessar elementos.Qualquer tipo de hashtable (exceto um dict)podem ser usados ​​para valores-chave e os tipos podem ser combinados.Qualquer tipo de valor, incluindo outros dictos, é permitido e os tipos podem ser combinados.

Uso:

Usamos um dicionário se tivermos um conjunto de chaves distintas que correspondem a valores , mas um lista quando temos um grupo ordenado de coisas .

Conclusão:

  • Em uma linguagem de computador, dicionários são uma espécie de estrutura de dados usada para armazenar informações isso está de alguma forma relacionado.
  • Cada módulo possui uma propriedade única chamada __dict__.
  • __dict__ contém a tabela de símbolos para o módulo .
  • As propriedades de um elemento são armazenadas em um objeto de mapeamento.
  • Todo objeto em Python tem um propriedade que é indicada pelo símbolo __dict__ .
  • Outro nome para __dict__ também é conhecido como objeto mapeamentoproxy.
  • Os dois componentes de um dicionário Python são chamados Chaves e Valores .
  • Você pode não receber seus dados na ordem semelhante em que você os inseriu, pois os dicionários não mantêm seus dados em nenhuma ordem específica.
  • As chaves consistirão em apenas uma Coisa.
  • Os valores podem ser inteiros, listas, listas dentro de listas , etc.
  • Não pode haver mais do que uma entrada por chave (nenhuma chave duplicada é permitida)
  • As chaves do dicionário devem ser imutável , como inteiros, tuplas ou strings , embora os valores possam ser de qualquer tipo.
  • Dicionário as chaves diferenciam maiúsculas de minúsculas ; nos dicionários Python, o mesmo nome de chave escrito de forma diferente é considerado um chave distinta .