Pythonissa sanakirja on järjestämätön joukko tietoarvoja se voisi olla käytetään data-arvojen tallentamiseen samalla tavalla kuin kartta. Toisin kuin muut tietotyypit, jotka voivat sisältää vain yhden arvon elementtiä kohden, sanakirjat voivat sisältää myös a avain:arvo pari. Sanakirjan tekemiseen tehokkaampi , Avainarvo tarjotaan.

Kun se koskee pääsyn määrittämistä, piste '.' (kuten x.any_attribute ) on kaikki, jonka suurin osa käyttäjistä tuntee. Yksinkertaisesti sanottuna, attribuutin käyttö on prosessi, jolla hankitaan objekti, joka on yhdistetty jo olemassa olevaan kohteeseen . Se voi näyttää hyvin yksinkertaiselta sellaiselle, joka käyttää Pythonia menemättä liian pitkälle yksityiskohtiin. Tämän suhteellisen yksinkertaisen prosessin kulissien takana tapahtuu kuitenkin paljon.

Mikä on _dict_?

Jokaisella moduulilla on ainutlaatuinen ominaisuus nimeltään __sane__. Tämä sanakirja sisältää moduulin symbolitaulukon . Kohteen (kirjoitettavat) ominaisuudet tallennetaan sanakirjaan tai muuhun kartoitusobjektiin.

Yksinkertaisesti sanottuna jokaisella Python-objektilla on a ominaisuus, joka on merkitty symbolilla __dict__ . Lisäksi tällä objektilla on kaikki sille määritetyt ominaisuudet. Toinen nimi sanalle __dict__ on kartoitusproxy esine. Voimme käyttää sanakirjaa kautta käyttämällä ominaisuutta __dict__ luokkaobjektiin.

Syntaksi :

 object.__dict__ 

Esimerkki:

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

Lähtö:

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

Esimerkki 2:

Tämä esimerkki osoittaa, että __dict__-attribuutti , voit luoda sanakirjan mistä tahansa objektista:

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

Lähtö:

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

Esimerkki 3:

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

Lähtö:

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

Sanakirjan käyttäminen ilman sanan __dict__ käyttöä Pythonissa:

Sanakirjan luominen:

Pythonissa sanakirja voidaan tehdä liittämällä a luettelo hakasulkeissa olevista merkinnöistä ja erottamalla ne pilkulla . Sanakirja tallentaa arvopareja, joissa yksi parielementti on avain ja toinen sen Avain: arvo . Toisin kuin avaimet, joka ei voida toistaa, ja niiden on oltava muuttumattomia, arvoja sanakirjoissa voi olla mitä tahansa dataa ja niitä voidaan kopioida .

Elementit ovat Pilkuin erotettu , jokainen avain erotetaan arvostaan kaksoispisteellä (:), ja koko rakenne sisältyy siihen kiharat hakasulkeet . Sanakirja, joka on täysin vailla kaikkia sanoja, on kirjoitettu seuraavasti: {} .

Sanakirjan avainten on oltava muuttumaton , kuten kokonaislukuja, monikoita tai merkkijonoja , vaikka arvot voivat olla mitä tahansa. Python-sanakirjoissa samaa avaimen nimeä pidetään eri tavalla kirjoitettuna erillinen avain. Ota se huomioon sanakirjanäppäimissä kirjainkoolla on merkitystä ; avaimia, joilla on samanlainen nimi, mutta erillinen kirjainkoko, käsitellään eri tavalla.

Esimerkki:

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

Lähtö:

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

The sisäänrakennettu menetelmä dict() mahdollistaa myös sanakirjojen luominen . Yksinkertaisesti laittaa kaksi kiharaa aaltosuljetta {} yhdessä tuloksena on tyhjä sanakirja .

Esimerkki:

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

Lähtö:

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

Sanakirjan luomisen monimutkaisuus:

• Aika monimutkaisuus: O(pituus(dikt))
• Avaruuden monimutkaisuus: Päällä)

Sisäkkäiset sanakirjat:

Se on sanakirjan muoto, jossa yksi tai useampi avaimiin on liitetty arvona sanakirja avaimesta.

Esimerkki:

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

Lähtö:

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

Elementtien lisääminen sanakirjaan:

On useita tapoja lisätä elementtejä Python-sanakirjaan. Määrittämällä arvon ja avaimen yhdessä esim. Dict[Key] = 'Arvo', sanakirjaan voidaan lisätä yksi arvo kerrallaan. Käyttämällä sisäänrakennettu update()-funktio , voidaan muokata olemassa olevaa arvoa sanakirjassa. Myös olemassa olevaa sanakirjaa voidaan laajentaa sisäkkäisiä avainarvoja .

Huomautus: Arvoa lisättäessä arvo päivitetään, jos avain-arvo-yhdistelmä on jo olemassa. Jos ei, sanakirjaan lisätään uusi avain ja arvo.

Esimerkki:

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

Lähtö:

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

Monimutkaisuus elementtien lisäämiseksi sanakirjaan:

• Aika monimutkaisuus: O(1)/O(n)
• Avaruuden monimutkaisuus: O(1)

Sanakirjan elementtien käyttö:

Sanakirja työllistää avaimet , kun taas muut tietotyypit vaativat indeksoinnin arvojen hakemiseksi. Avaimia voidaan käyttää get()-funktio tai hakasulkeissa [].

Siinä tapauksessa, että a avainta ei löydy sanakirjassa, KeyError tuotetaan jos käytämme hakasulkeet []. Toisaalta, jos avainta ei löydy, get()-funktio palauttaa Ei mitään.

Esimerkki:

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

Lähtö:

 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 

Sanakirjan elementtien käytön monimutkaisuus:

• Aika monimutkaisuus: O(1)
• Avaruuden monimutkaisuus: O(1)

Sisäkkäisen sanakirjan elementin käyttäminen:

Voimme ottaa avun indeksointi [] tekniikka saadaksesi olemassa olevan avaimen arvon sisäkkäinen sanakirja .

Esimerkki:

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

Lähtö:

 {3: 'JavatPoint'} JavatPoint Website 

Sisäänrakennetut sanakirjamenetelmät:

asia selvä() :

Funktio dict.clear() eliminoi jokaisen avain-arvo-parin sanakirjasta.

kopio() :

A matalampi kopio sanakirjasta palautetaan dict.copy()-menetelmällä.

fromkeys() :

Mukana toimitetun iterable-ohjelman avulla (merkkijono, lista, joukko tai monikko) avaimina ja määritetty arvo, funktio dict.fromkeys() luo uuden sanakirjan .

saada() :

Tämä antaa siihen liittyvän arvon annetulla avaimella.

tuotteet() :

A sanakirjanäkymäobjekti , joka tarjoaa sanakirjan kohteiden dynaamisen esityksen avainarvoparien luettelona palautetaan dict.items() -funktiolla. Kun sanakirja päivitetään, tämä näkymäobjekti myös päivitetään .

dict.keys() :

Funktio dict.keys() palauttaa sanakirjanäkymäobjektin sanakirjan kanssa avainten luettelo.

pop() :

Tämä palauttaa avaimen arvon sen poistamisen jälkeen . Jos avain puuttuu sanakirjasta, se joko heittää a KeyError tai palauttaa oletusarvo jos sellainen tarjottiin.

juoma():

Tämä poistaa yhden kohteen sanakirjasta ja palauttaa monikon (avain, arvo) pareista. The Last In First Out (LIFO) sekvenssiä käytetään parien palauttamiseen.

aseta oletus() :

Tämä palauttaa sanakirjan arvon annetulle avaimelle . Jos avainta ei löydy, avain mukana toimitetulla oletusarvo on lisätty. Se asettaa Ei mitään kuin oletusarvo jos sitä ei toimiteta.

kartoitus koneella

arvot() :

The sanakirjanäkymäobjekti, joka tarjoaa dynaamisen näkymän jokaisesta arvosta, joka on sanakirjassa, palautetaan funktiolla dict.values(). Kun sanakirja päivitetään, tämä näkymäobjekti myös päivitetään .

päivitys() :

A sanakirjaa tai mitä tahansa iteroitavaa avain-arvo-parien kanssa , kuten monikko, voidaan päivittää käyttämällä dict.update()-funktiota.

Esimerkki:

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

Lähtö:

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

Sanakirjan ja luettelon välinen ero:

Tietorakenteet, kuten a luettelo ja sanakirja ovat pohjimmiltaan erilaisia. An tilattu tuotesarja voidaan säilyttää a lista jotta voimme indeksoida siihen tai iteroida sen yli. Listoja voidaan muuttaa myös sen jälkeen, kun ne on jo luotu, koska ne ovat vaihdettavia tyyppejä. The Python-sanakirja on avainarvojen tallennus ja a hash-taulukko . Se ei noudata mitään tiettyä järjestystä ja vaatii tiivistettävät avaimet. Lisäksi se on nopea avainhakuihin.

A listan elementit sisältävät seuraavat ominaisuudet:

• Ellei niitä erikseen tilata uudelleen, he pitää nykyisen järjestyksensä (esimerkiksi lajittelemalla luetteloa).
• Ne voivat olla mitä tahansa tyyppiä tai jopa a lajien yhdistelmä .
Numeeristen (nollaperusteisten) indeksien kautta, voimme käyttää niitä.

Ominaisuudet sanakirja elementit ovat seuraavat:

• Jokaisessa merkinnässä on a arvo ja avain .
• Tilaukset ovat ei taattu .
Keskeiset arvotkäytetään pääsyyn elementteihin.Mikä tahansa hashtable-tyyppi (muu kuin sanelu)voidaan käyttää avainarvoille, ja tyyppejä voidaan yhdistää.Mikä tahansa arvo, mukaan lukien muut sanat, on sallittu , ja tyyppejä voidaan yhdistää.

Käyttö:

Käytämme a sanakirja jos meillä on a joukko erillisiä avaimia, jotka vastaavat arvoja , mutta a lista kun meillä on tilattu joukko asioita .

Johtopäätös:

• Tietokonekielellä, sanakirjat ovat eräänlainen tietorakenne, jota käytetään tietojen säilyttämiseen se liittyy jotenkin.
• Jokaisella moduulilla on ainutlaatuinen ominaisuus nimeltään __sane__.
• __sanella__ sisältää moduulin symbolitaulukon .
• Elementin ominaisuudet tallennetaan a kartoitusobjekti.
• Jokaisella Python-objektilla on a ominaisuus, joka on merkitty symbolilla __dict__ .
• Toinen nimi sanalle __dict__ tunnetaan myös nimellä mappingproxy-objekti.
• Python-sanakirjan kahta komponenttia kutsutaan Avaimet ja arvot .
• Sinä ei ehkä saa tietosi takaisin samassa järjestyksessä kuin syötät ne, koska sanakirjat eivät säilytä tietojaan missään tietyssä järjestyksessä.
• Avaimet koostuvat vain yksi asia.
• Arvot voivat olla kokonaisluvut, luettelot, luettelot luetteloiden sisällä , jne.
• Ei voi olla enempää kuin yksi syöttö per avainta (kaksoiskappaletta ei sallita)
• Sanakirjan avainten tulee olla muuttumaton , kuten kokonaislukuja, monikoita tai merkkijonoja , vaikka arvot voivat olla mitä tahansa.
• Sanakirja näppäimissä kirjainkoolla on merkitystä ; Python-sanakirjoissa samaa avaimen nimeä eri tavalla kirjoitettuna pidetään a erillinen avain .