logo

TechCodeview

__dict__ a Python

A Python, un diccionari és un conjunt no ordenat de valors de dades això podria ser s'utilitza per emmagatzemar valors de dades semblant a un mapa. A diferència d'altres tipus de dades, que només poden incloure un únic valor per element, els diccionaris també poden contenir a clau:valor parella. Per fer el diccionari més eficient , S'ofereix el valor clau.

què és l'ou de Pasqua d'Android

Quan es refereix a l'accés als atributs, el punt '.' (com a x.qualsevol_atribut ) és tot el que coneixen la majoria dels usuaris. Simplement dit, L'accés als atributs és el procés d'obtenció d'un objecte connectat a un que ja teniu . Pot semblar molt senzill per a algú que utilitza Python sense anar massa lluny en els detalls. No obstant això, hi ha moltes coses darrere de les escenes d'aquest procés relativament senzill.

Què és _dict_?

Cada mòdul té una propietat única anomenada __dicte__. Aquest diccionari conté la taula de símbols del mòdul . Les característiques (escrivibles) d'un element s'emmagatzemen en un diccionari o en l'altre objecte de mapatge.

Per dir-ho simplement, cada objecte de Python té un propietat que s'indica amb el símbol __dict__ . A més, aquest objecte té totes les propietats que s'han especificat per a ell. Un altre nom per a __dict__ és mappingproxy objecte. Podem utilitzar el diccionari via aplicant la propietat __dict__ a un objecte de classe.

Sintaxi:

 object.__dict__

Exemple:

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

Sortida: 

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

Exemple 2:

Aquest exemple demostrarà que mitjançant el __dict__ atribut , es podria crear un diccionari a partir de qualsevol objecte:

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

Sortida: 

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

Exemple 3:

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

Sortida: 

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

Ús del diccionari sense l'ús de __dict__ a Python:

Creació d'un diccionari:

A Python, es pot fer un diccionari adjuntant a llista d'entrades entre claudàtors i separant-les amb una coma . El diccionari emmagatzema parells de valors, on un element de parella és la clau i un altre és la seva Clau: valor . En contrast amb claus, quin no es poden repetir i han de ser immutables, valors en diccionaris pot ser de qualsevol tipus de dades i es pot duplicar .

Els elements són separades per comes , cada clau es distingeix del seu valor amb dos punts (:), i tota l'estructura està continguda claudàtors . Un diccionari que està completament desproveït de totes les paraules s'escriu de la següent manera: {} .

Les claus del diccionari han de ser immutable , tal com nombres enters, tuples o cadenes , encara que els valors poden ser de qualsevol tipus. Als diccionaris de Python, es considera el mateix nom de clau escrit de manera diferent una clau diferent. Si us plau, tingueu en compte que Les claus del diccionari distingeixen entre majúscules i minúscules ; les claus amb el nom similar però amb majúscules i minúscules diferents es tractaran de manera diferent.

Exemple: 

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

Sortida: 

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

El mètode integrat dict() també permet el creació de diccionaris . Simplement posant dues claus {} junts donaran lloc a un diccionari buit .

Exemple:

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

Sortida: 

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

Complexitats per crear un diccionari:

  • Complexitat temporal: O (longitud (dict))
  • Complexitat espacial: O(n)

Diccionaris imbricats:

És una forma de diccionari on un o més d'un keys té un diccionari adjunt com a valor de la clau.

Exemple: 

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

Sortida: 

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

Addició d'elements a un diccionari:

N'hi ha diversos mètodes per afegir elements a un diccionari de Python. Especificant el valor i la clau conjuntament, per exemple, Dict[Clau] = 'Valor', es pot afegir un valor a un diccionari alhora. Utilitzant el funció d'actualització integrada (). , es pot modificar un valor existent en un diccionari. També es pot ampliar amb un diccionari existent valors de clau imbricats .

Nota: quan s'afegeix un valor, el valor s'actualitza si la combinació clau-valor ja existeix. Si no, s'afegeix una clau i un valor nous al diccionari.

Exemple: 

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

Sortida: 

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

Complexitats per afegir elements a un diccionari:

  • Complexitat temporal: O(1)/O(n)
  • Complexitat espacial: O(1)

Accés als elements del diccionari:

Un diccionari empra claus , mentre que altres tipus de dades requereixen indexació per recuperar valors. Les claus es poden utilitzar amb funció get(). o dins de claudàtors [].

En el cas que a no es pot trobar la clau al diccionari, Es produeix KeyError si fem servir Claudàtors []. D'altra banda, si no es pot localitzar la clau, el La funció get() retorna Cap.

Exemple: 

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

Sortida: 

 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

Complexitats per accedir a elements en un diccionari:

  • Complexitat temporal: O(1)
  • Complexitat espacial: O(1)

Accés a l'element d'un diccionari imbricat:

Podem agafar l'ajuda del tècnica d'indexació [] per obtenir el valor d'una clau existent al fitxer diccionari imbricat .

Exemple: 

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

Sortida: 

 {3: 'JavatPoint'} JavatPoint Website

Mètodes de diccionari integrat:

clar():

La funció dict.clear() elimina tots els parells clau-valor del diccionari.

copiar():

A còpia menys profunda del diccionari es retorna pel mètode dict.copy().

fromkeys():

Utilitzant l'iterable subministrat (cadena, llista, conjunt o tupla) com a claus i el valor especificat, la funció dict.fromkeys() crea un nou diccionari .

aconseguir() :

Això dóna el valor associat amb la clau donada.

articles ():

A objecte de vista del diccionari , que ofereix una presentació dinàmica dels elements del diccionari com una llista de parells clau-valor es retorna mitjançant la funció dict.items(). Quan el diccionari s'actualitza, això L'objecte de visualització també s'actualitza .

dict.keys():

La funció dict.keys() retorna un objecte de vista de diccionari amb el diccionari llista de claus.

pop():

Això retorna el valor de la clau després d'eliminar-la . Si falta una clau al diccionari, o bé llança a KeyError o retorna el valor per defecte si se'n va proporcionar un.

beure():

Això elimina un element del diccionari i retorna una tupla de parells (clau, valor). El Últim entrant primer sortit (LIFO) La seqüència s'utilitza per retornar parells.

instal · lat per defecte() :

Això retorna el valor del diccionari per a la clau donada . Si no es pot descobrir la clau, la clau amb el subministrat valor per defecte s'afegeix. Es posa Cap com el valor per defecte si no es subministra.

valors ():

El objecte de vista de diccionari que ofereix una vista dinàmica de cada valor que és present al diccionari, es retorna mitjançant la funció dict.values(). Quan el diccionari s'actualitza, això L'objecte de visualització també s'actualitza .

actualització():

A diccionari o qualsevol iterable amb parells clau-valor , com una tupla, es pot actualitzar utilitzant la funció dict.update().

Exemple:

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

Sortida: 

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

Diferenciació entre un diccionari i una llista:

Estructures de dades com a llista i un diccionari són fonamentalment diferents. An sèrie ordenada d'articles es pot emmagatzemar en un llista perquè puguem indexar-hi o repetir-hi. Les llistes també es poden canviar fins i tot després que ja s'hagin generat, ja que són de tipus canviable. El Diccionari Python és un emmagatzematge de valor-clau i una implementació d'a taula hash . No segueix cap seqüència en particular i requereix claus hashable. A més, és ràpid per a cerques clau.

A llista Els elements contenen les característiques següents:

  • A menys que es reordena específicament, ells mantenir el seu ordre actual (per exemple, ordenant la llista).
  • Poden ser de qualsevol tipus, o fins i tot a combinació de tipus .
    • Mitjançant índexs numèrics (de base zero)., podem accedir-hi.

Les característiques de diccionari els elements són els següents:

  • Cada entrada té un valor i una clau .
  • Les comandes són no es garanteix .
    • Valors claus'utilitzen per accedir als elements.Qualsevol tipus de hashtable (que no sigui un dictat)es poden utilitzar per a valors clau i es poden combinar tipus.Qualsevol tipus de valor, inclosos altres dictats, està permès , i els tipus es poden combinar.

Ús :

Fem servir a diccionari si tenim un conjunt de claus diferents que corresponen a valors , però a llista quan tenim un grup ordenat de coses .

Conclusió:

  • En un llenguatge informàtic, Els diccionaris són una mena d'estructura de dades utilitzada per contenir informació que d'alguna manera està relacionat.
  • Cada mòdul té una propietat única anomenada __dicte__.
  • __dicte__ conté la taula de símbols del mòdul .
  • Les propietats d'un element s'emmagatzemen en a objecte de mapeig.
  • Cada objecte en Python té un propietat que s'indica amb el símbol __dict__ .
  • Un altre nom per a __dict__ també es coneix com objecte mappingproxy.
  • Els dos components d'un diccionari Python s'anomenen Claus i Valors .
  • Vostè podria no rebre les vostres dades en l'ordre similar en què les heu introduït, ja que els diccionaris no guarden les seves dades en cap ordre específic.
  • Les claus consistiran en només una cosa.
  • Els valors poden ser nombres enters, llistes, llistes dins de llistes , etc.
  • No hi pot haver més que una entrada per clau (no es permet cap clau duplicada)
  • Les claus del diccionari han de ser immutable , tal com nombres enters, tuples o cadenes , encara que els valors poden ser de qualsevol tipus.
  • Diccionari les claus distingeixen entre majúscules i minúscules ; als diccionaris de Python, el mateix nom de clau escrit de manera diferent es considera a clau diferent .