In Python is een woordenboek een ongeordende set gegevenswaarden dat zou kunnen zijn gebruikt om gegevenswaarden op te slaan vergelijkbaar met een kaart. In tegenstelling tot andere gegevenstypen, die slechts één waarde per element kunnen bevatten, kunnen woordenboeken ook een sleutel waarde paar. Om het woordenboek te maken efficiënter , Key-Value wordt aangeboden.
Als het om attribuuttoegang gaat, wordt de punt '.' (als in x.any_attribuut ) is alles waar de meerderheid van de gebruikers bekend mee is. Simpel gezegd, attribuuttoegang is het proces waarbij u een object verkrijgt dat is verbonden met een object dat u al heeft . Het ziet er misschien heel eenvoudig uit voor iemand die Python gebruikt, zonder al te ver in de details te gaan. Er gebeurt echter achter de schermen veel aan dit relatief eenvoudige proces.
Wat is _dict_?
Elke module heeft een unieke eigenschap genaamd __dict__. Dit woordenboek bevat de symbooltabel voor de module . De (schrijfbare) kenmerken van een item worden opgeslagen in een woordenboek of het andere mappingobject.
Simpel gezegd: elk object in Python heeft een eigenschap die wordt aangegeven door het symbool __dict__ . Bovendien beschikt dit object over alle eigenschappen die ervoor zijn opgegeven. Een andere naam voor __dict__ is mappingproxy voorwerp. We kunnen het woordenboek gebruiken via het toepassen van de eigenschap __dict__ naar een klasseobject.
Syntaxis:
object.__dict__
Voorbeeld :
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__)
Uitgang:
{'identity': 'Lion', 'age': '10'} Voorbeeld 2:
Dit voorbeeld zal aantonen dat door middel van de __dict__ attribuut , zou je van elk object een woordenboek kunnen maken:
# 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__)
Uitgang:
The Dictionary from object fields belongs to the class Flowers : {'Rose': 'red', 'Lily': 'white', 'Lotus': 'pink'} Voorbeeld 3:
def funct(): pass funct.practice = 1 print(funct.__dict__) class PracticeClass: x = 1 def practice_function(self): pass print(PracticeClass.__dict__)
Uitgang:
{'practice': 1} {'__module__': '__main__', 'x': 1, 'practice_function': , '__dict__': , '__weakref__': , '__doc__': None} Woordenboek gebruiken zonder het gebruik van __dict__ in Python:
Een woordenboek maken:
In Python kan een woordenboek worden gemaakt door een lijst met vermeldingen tussen accolades en gescheiden door een komma . Woordenboek slaat waardenparen op, waarbij één paarelement de sleutel is en een ander de sleutel Sleutel waarde . In contrast met sleutels, welke waarden kunnen niet worden herhaald en moeten onveranderlijk zijn in woordenboeken kan van elk type gegevens zijn en kan worden gedupliceerd .
De elementen zijn gescheiden door comma's , onderscheidt elke sleutel zich van zijn waarde door een dubbele punt (:), en de hele structuur zit erin accolades . Een woordenboek dat volledig verstoken is van alle woorden, wordt als volgt geschreven: {} .
De sleutels van het woordenboek moeten zijn onveranderlijk , zoals gehele getallen, tupels of tekenreeksen , hoewel de waarden van elk type kunnen zijn. In Python-woordenboeken wordt dezelfde sleutelnaam, anders gespeld, beschouwd als een aparte sleutel. Houd er rekening mee dat woordenboeksleutels zijn hoofdlettergevoelig ; Sleutels met dezelfde naam, maar met verschillende hoofdletters, worden anders behandeld.
Voorbeeld :
# 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) Uitgang:
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]} De ingebouwde methode dict() maakt het ook mogelijk het maken van woordenboeken . Simpel gezegd twee accolades {} samen zal resulteren in een leeg woordenboek .
Voorbeeld :
# 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) Uitgang:
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'} Complexiteiten bij het maken van een woordenboek:
- Tijdcomplexiteit: O(lengte(dict))
- Ruimtecomplexiteit: Op)
Geneste woordenboeken:
Het is een vorm van woordenboek waarbij één of meer dan één Aan sleutels is een woordenboek als waarde gekoppeld van de sleutel.
knipprogramma in ubuntu
Voorbeeld :
# 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) Uitgang:
Creating a Nested Dictionary : {1: 'JAVA', 2: 'T', 3: 'POINT', 4: {1: 'JavaTpoint', 2: 'Great'}} Toevoeging van elementen aan een woordenboek:
Er zijn verschillende methoden voor het toevoegen van elementen naar een Python-woordenboek. Door bijvoorbeeld de waarde en de sleutel samen op te geven, Dict[Sleutel] = 'Waarde', Er kan één waarde tegelijk aan een woordenboek worden toegevoegd. De ... gebruiken ingebouwde update()-functie , kan men een bestaande waarde in een woordenboek wijzigen. Een bestaand Woordenboek kan eventueel ook uitgebreid worden met geneste sleutelwaarden .
Opmerking: wanneer u een waarde toevoegt, wordt de waarde bijgewerkt als de sleutel-waardecombinatie al bestaat. Als dit niet het geval is, worden er een nieuwe sleutel en waarde aan het woordenboek toegevoegd.
Voorbeeld :
# 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) Uitgang:
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'}}} Complexiteiten bij het toevoegen van elementen aan een woordenboek:
- Tijdcomplexiteit: O(1)/O(n)
- Ruimtecomplexiteit: O(1)
Toegang tot woordenboekelementen:
Een woordenboek maakt gebruik van sleutels , terwijl andere gegevenstypen indexering vereisen om waarden op te halen. Sleutels kunnen worden gebruikt met de get() functie of tussen vierkante haken [].
In het geval dat een sleutel kan niet worden gevonden in het woordenboek, KeyError wordt geproduceerd als we gebruiken vierkante haakjes []. Aan de andere kant, als de sleutel niet kan worden gevonden, wordt de get() functie retourneert Geen.
Voorbeeld :
virtueel geheugen
# 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)) Uitgang:
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
Complexiteiten voor toegang tot elementen in een woordenboek:
- Tijdcomplexiteit: O(1)
- Ruimtecomplexiteit: O(1)
Toegang tot het element van een genest woordenboek:
Wij kunnen daarbij de hulp inroepen van de indexering [] techniek om de waarde van een bestaande sleutel in het genest woordenboek .
Voorbeeld :
# 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.']) Uitgang:
{3: 'JavatPoint'} JavatPoint Website Ingebouwde woordenboekmethoden:
duidelijk() :
De functie dict.clear() elimineert elk sleutel-waardepaar uit het woordenboek.
kopiëren() :
A ondiepere kopie van het woordenboek wordt geretourneerd door de methode dict.copy().
vantoetsen() :
Met behulp van de meegeleverde iterabele (string, list, set of tuple) als sleutels en de opgegeven waarde, de functie dict.fromkeys() maakt een nieuw woordenboek aan .
krijgen() :
Dit geeft de bijbehorende waarde met de opgegeven sleutel.
artikelen() :
A woordenboekweergaveobject , dat een dynamische presentatie van de woordenboekitems biedt als een lijst met sleutel-waardeparen wordt geretourneerd door de functie dict.items(). Wanneer het woordenboek is bijgewerkt, wordt dit weergegeven weergaveobject wordt ook bijgewerkt .
dict.keys() :
De functie dict.keys() retourneert een woordenboekweergaveobject met het woordenboek lijst met sleutels.
pop() :
Dit retourneert de waarde van de sleutel nadat deze is verwijderd . Als er een sleutel ontbreekt in het woordenboek, wordt er een a gegenereerd Sleutelfout of retourneert de standaardwaarde als er een werd verstrekt.
drankje() :
Dit verwijdert één item uit het woordenboek en retourneert een tupel van (sleutel, waarde)paren. De Laatste in, eerst uit (LIFO) reeks wordt gebruikt voor het retourneren van paren.
standaard instellen() :
Dit retourneert de waarde van het woordenboek voor de opgegeven sleutel . Indien de sleutel niet gevonden kan worden, wordt de sleutel bijgeleverd standaardwaarde is toegevoegd. Het gaat onder Geen als de standaardwaarde als deze niet wordt meegeleverd.
waarden() :
De woordenboekweergaveobject dat een dynamische weergave biedt van elke waarde die is aanwezig in het woordenboek, wordt geretourneerd door de functie dict.values(). Wanneer het woordenboek is bijgewerkt, wordt dit weergegeven weergaveobject wordt ook bijgewerkt .
update() :
A woordenboek of een iterabel bestand met sleutel-waardeparen , zoals een tupel, kan worden bijgewerkt met behulp van de functie dict.update().
Java versus c++
Voorbeeld :
# 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()) Uitgang:
{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++']) Onderscheid maken tussen een woordenboek en een lijst:
Datastructuren zoals a lijst en een woordenboek zijn fundamenteel verschillend. Een bestelde serie artikelen kan worden opgeslagen in een lijst zodat we erin kunnen indexeren of eroverheen kunnen itereren. Lijsten kunnen ook worden gewijzigd, zelfs nadat ze al zijn gegenereerd, omdat ze van een veranderlijk type zijn. De Python-woordenboek is een opslag van sleutelwaarden en een implementatie van a hash-tabel . Het volgt geen bepaalde volgorde en vereist hashbare sleutels. Bovendien is het snel voor het opzoeken van sleutels.
A lijst elementen bevatten de volgende kenmerken:
- Tenzij specifiek opnieuw geordend, zij hun huidige volgorde behouden (bijvoorbeeld door de lijst te sorteren).
- Ze kunnen van welk type dan ook zijn, of zelfs een combinatie van soorten .
De kenmerken van woordenboek elementen zijn als volgt:
- Elke inzending heeft een waarde en een sleutel .
- Bestellingen zijn niet gegarandeerd .
Gebruik:
Wij gebruiken een woordenboek als we een een reeks afzonderlijke sleutels die overeenkomen met waarden , maar een lijst wanneer we een geordende groep dingen .
Conclusie :
- In een computertaal, woordenboeken zijn een soort gegevensstructuur die wordt gebruikt om informatie vast te houden dat heeft ergens mee te maken.
- Elke module heeft een unieke eigenschap genaamd __dict__.
- __dict__ bevat de symbooltabel voor de module .
- De eigenschappen van een element worden opgeslagen in a object in kaart brengen.
- Elk object in Python heeft een eigenschap die wordt aangegeven door het symbool __dict__ .
- Een andere naam voor __dict__ is ook bekend als mappingproxy-object.
- De twee componenten van een Python-woordenboek worden genoemd Sleutels en waarden .
- Jij misschien niet ontvangen uw gegevens terug in dezelfde volgorde als waarin u ze invoert, aangezien woordenboeken hun gegevens niet in een specifieke volgorde bewaren.
- Sleutels bestaan uit slechts een ding.
- Waarden kunnen zijn gehele getallen, lijsten, lijsten binnen lijsten , enz.
- Er kan niet meer zijn dan één invoer per sleutel (er is geen dubbele sleutel toegestaan)
- De sleutels van het woordenboek moeten zijn onveranderlijk , zoals gehele getallen, tupels of tekenreeksen , hoewel de waarden van elk type kunnen zijn.
- Woordenboek toetsen zijn hoofdlettergevoelig ; in Python-woordenboeken wordt dezelfde sleutelnaam, anders gespeld, beschouwd als a aparte sleutel .