Python-woordenboek - Alles wat u moet weten

Python-woordenboeken zijn een ongelooflijk nuttige gegevensstructuur waar je vaak naar zult grijpen tijdens je programmeerinspanningen. Hun unieke vermogen om sleutels toe te wijzen aan hun respectievelijke waarden zorgt voor snelle, efficiënte toegang en vereenvoudigde code bij het beheer van complexe datasets.

Python-woordenboeken zijn in wezen een implementatie van associatieve arrays. Ze bieden een flexibele en efficiënte manier om gegevens op te slaan en te manipuleren in de vorm van sleutel-waardeparen.

Ze zijn zeer veelzijdig en bieden plaats aan veranderlijke en geordende collecties zonder dubbele sleutels toe te staan.

Als we in dit artikel in Python- woordenboeken duiken , zult u merken dat dit krachtige hulpmiddelen zijn voor het organiseren en openen van uw gegevens.

Zorg er dus voor dat u vertrouwd raakt met de ins en outs van Python- woordenboeken om hun volledige potentieel in uw projecten te ontsluiten!

Inhoudsopgave

• Python-woordenboeken begrijpen
• Hoe een Python-woordenboek te maken
  • Gebruik van accolades
  • Dict Constructor gebruiken
• Hoe toegang te krijgen tot woordenboekelementen
  • Sleutels gebruiken
  • Get-methode gebruiken
• Woordenboekelementen wijzigen
  • Nieuwe elementen toevoegen
  • Actualiseren van bestaande elementen
• Woordenboekelementen verwijderen
  • Del-trefwoord
  • Duidelijke methode
• Wat zijn enkele algemene woordenboekmethoden?
  • Sleutels
  • Waarden
  • Artikelen
  • Update
  • Knal
  • Popitem
• Python-woordenboeken gebruiken
  • Woordenboeken doorlopen
  • Wat zijn woordenboekbegrippen?
  • Wat zijn geneste woordenboeken?
• Veelvoorkomende gevallen van woordenboekgebruik

Python-woordenboeken begrijpen

Een woordenboek in Python is een krachtige en flexibele gegevensstructuur waarmee u een verzameling sleutel-waardeparen kunt opslaan. Beschouw een woordenboek als een manier om sleutels toe te wijzen aan hun corresponderende waarden, waardoor het gemakkelijk wordt om informatie op te halen die gerelateerd is aan een specifieke identifier.

Om een ​​woordenboek te maken, kunt u accolades ( { } ) gebruiken die een door komma's gescheiden lijst van sleutel-waardeparen omsluiten. Bijvoorbeeld:

your_dict = {"key1": "value1", "key2": "value2", "key3": "value3"}

Houd er rekening mee dat woordenboeken in Python kunnen worden gewijzigd, wat betekent dat u hun inhoud kunt wijzigen nadat ze zijn gemaakt. Gebruik de volgende syntaxis om een ​​sleutel-waardepaar toe te voegen of bij te werken:

your_dict["new_key"] = "new_value"

#You can also update an old key's value
your_dict["old_key"] = "new_value"

Als het gaat om toegang tot waarden in een woordenboek, hebt u alleen de sleutel nodig:

value = your_dict["key1"]

Als u toegang probeert te krijgen tot een sleutel die niet in het woordenboek voorkomt, krijgt u een KeyError. Om dit te voorkomen, kunt u de methode get() gebruiken:

value = your_dict.get("non_existent_key", "default_value")

Een ding dat u moet onthouden, is dat een Python-woordenboek geen dubbele sleutels kan bevatten. Elke sleutel moet uniek zijn en van een onveranderlijk gegevenstype zijn.

U kunt bijvoorbeeld een tuple, String, Integer of zelfs een Boolean gebruiken voor uw sleutel. U kunt echter geen lijsten, woordenboeken of sets gebruiken.

Er zijn geen dergelijke beperkingen voor waarden. U kunt zowel veranderlijke als onveranderlijke gegevenstypen gebruiken.

Het verwijderen van een element uit een woordenboek wordt gedaan door het sleutelwoord del te gebruiken :

del your_dict["key1"]

Ze bieden ook verschillende methoden om door hun inhoud te bladeren. U kunt bijvoorbeeld de woordenboeksleutels, waarden of zelfs beide herhalen:

for key in your_dict.keys():
    print(key)

for value in your_dict.values():
    print(value)

for key, value in your_dict.items():
    print(key, value)

U kunt nu deze woordenboekmethoden en -technieken gebruiken om gegevens efficiënt op te slaan, op te halen en te manipuleren terwijl u met Python werkt .

Hoe een Python-woordenboek te maken

Er zijn twee manieren om Python-woordenboeken te maken: accolades gebruiken en de dict() -constructor.

Gebruik van accolades

Een methode die u kunt gebruiken om een ​​woordenboek te maken, is door accolades ( {} ) te gebruiken. Om een ​​leeg woordenboek te initialiseren, kunt u eenvoudig empty_dict = {} gebruiken .

Als u een woordenlijst met sleutel-waardeparen wilt maken, scheidt u de sleutels en waarden met dubbele punten. Scheid vervolgens elk paar met een komma:

python_dict = {
    'key1': 'value1',
    'key2': 'value2',
    'key3': 'value3'
}

Met deze indeling hebt u een Python-woordenboek gemaakt met drie sleutel-waardeparen. Onthoud dat de sleutels uniek moeten zijn, terwijl de woordenboekwaarden kunnen worden gedupliceerd.

Dict Constructor gebruiken

Een andere methode voor het maken van een Python-woordenboek is het gebruik van de dict() -constructor. Om een ​​leeg woordenboek te maken, roep je gewoon deze functie aan zonder enige argumenten: empty_dict = dict() .

Om een ​​woordenboek te maken met behulp van de dict()- constructor, kunt u de volgende syntaxis gebruiken:

python_dict = dict(
    key1='value1',
    key2='value2',
    key3='value3'
)

Deze methode maakt ook een Python-woordenboek met drie sleutel-waarde-elementen. Merk op dat, in tegenstelling tot de methode met accolades, de constructor dict() geen aanhalingstekens rond de sleutels vereist.

De woordenboekwaarden hebben echter nog steeds aanhalingstekens nodig

Nu u bekend bent met twee manieren om Python-woordenboeken te maken, kunt u ze gaan implementeren in uw code en hun krachtige functies in uw toepassingen benutten.

Hoe toegang te krijgen tot woordenboekelementen

In deze sectie leert u over verschillende manieren om toegang te krijgen tot elementen in een woordenboek. Woordenboeken slaan gegevens op in sleutel-waardeparen en u hebt toegang tot elke woordenboekwaarde met behulp van hun respectievelijke sleutels.

We behandelen twee populaire methoden: Sleutels gebruiken en de get- methode.

Sleutels gebruiken

Een van de eenvoudigste manieren om toegang te krijgen tot woordenboekelementen is door de toetsen te gebruiken. Om de waarde van een bepaalde woordenboeksleutel te krijgen, plaatst u de sleutel eenvoudig tussen vierkante haken naast de woordenboeknaam:

my_dict = {'name': 'John', 'age': 30, 'city': 'New York'}
name_value = my_dict['name']

phone_value = mydict['phone-number']

In dit voorbeeld zou naam_waarde de tekenreeks 'John' opslaan . Merk op dat als u toegang probeert te krijgen tot een niet-bestaande sleutel, Python een KeyError zal genereren .

Get-methode gebruiken

Een alternatief voor het rechtstreeks gebruiken van sleutels is de get() methode, waarmee u toegang krijgt tot woordenboekelementen zonder het risico van een KeyError. In plaats daarvan retourneert de methode get een standaardwaarde als de opgegeven sleutel niet wordt gevonden:

my_dict = {'name': 'John', 'age': 30, 'city': 'New York'}
name_value = my_dict.get('name', 'Key not found')
country_value = my_dict.get('country', 'Key not found')

In dit voorbeeld zou naam_waarde de tekenreeks ' John ' opslaan zoals voorheen, aangezien de sleutel ' naam ' aanwezig is in het woordenboek. Country_value slaat echter de standaardwaarde ' Sleutel niet gevonden ' op, aangezien de ' country' -sleutel niet bestaat in het woordenboek.

De methode get() biedt een flexibelere manier om toegang te krijgen tot woordenboekelementen, omdat u ontbrekende sleutels netjes kunt afhandelen. U kunt ervoor kiezen om beide methoden te gebruiken, afhankelijk van uw vereisten en de mogelijkheid om niet-bestaande sleutels tegen te komen.

Woordenboekelementen wijzigen

In deze sectie leert u hoe u elementen in een Python-woordenboek kunt wijzigen. Er zijn twee primaire bewerkingen om dit te bereiken: nieuwe elementen toevoegen en bestaande bijwerken.

Beide methoden helpen u de nauwkeurigheid en bruikbaarheid van uw woordenboek te behouden. Laten we ze eens bekijken:

1. Nieuwe elementen toevoegen

Het toevoegen van een nieuw element aan een woordenboek is eenvoudig. Geef hiervoor het nieuwe sleutel-waardepaar op met behulp van een toewijzingsoperator, zoals deze:

your_dict = {"key1": "value1", "key2": "value2"}
your_dict["new_key"] = "new_value"

Na het uitvoeren van het bovenstaande codefragment, bevat uw woordenboek nu het nieuwe paar:

{"key1": "value1", "key2": "value2", "new_key": "new_value"}

U kunt ook meerdere sleutel-waardeparen tegelijk toevoegen met behulp van de update()- methode van het woordenboek

new_elements = {"key3": "value3", "key4": "value4"}
your_dict.update(new_elements)

Nu bevat uw woordenboek de volgende vermeldingen:

{"key1": "value1", "key2": "value2", "key3": "value3", "key4": "value4"}

1. Actualiseren van bestaande elementen

Om de waarde van een bestaand element bij te werken, hoeft u alleen maar naar de sleutel te verwijzen en er een nieuwe waarde aan toe te wijzen:

your_dict["key1"] = "updated_value1"

Deze wijziging resulteert in het volgende woordenboek:

{"key1": "updated_value1", "key2": "value2", "key3": "value3", "key4": "value4"}

Als u meerdere elementen tegelijk moet bijwerken, gebruikt u de methode update() opnieuw. Om het te gebruiken, geeft u een nieuw woordenboek door met de gewenste wijzigingen.

Laten we bijvoorbeeld het your_dict-woordenboek bijwerken met de waarden uit het updates-woordenboek:

updates = {"key2": "updated_value2", "key4": "updated_value4"}
your_dict.update(updates)

Als deze updates zijn toegepast, ziet het your_dict-woordenboek er als volgt uit:

{"key1": "updated_value1", "key2": "updated_value2", "key3": "value3", "key4": "updated_value4"}

Deze bewerkingen zijn essentiële hulpmiddelen bij het werken, omdat ze u in staat stellen uw gegevensstructuren up-to-date en nauwkeurig te houden.

Woordenboekelementen verwijderen

In deze sectie zullen we twee veelgebruikte manieren onderzoeken om woordenboekelementen in Python te verwijderen: het del- trefwoord en de clear()- methode.

1. Del-trefwoord

Het sleutelwoord del wordt gebruikt om een ​​specifiek sleutel-waardepaar uit een woordenboek te verwijderen. Het werkt in-place en genereert een KeyError als de sleutel niet in het woordenboek voorkomt. Gebruik de volgende syntaxis om een ​​element te verwijderen:

del my_dict[key]

Als u bijvoorbeeld een sleutel met de naam " brand " wilt verwijderen uit een woordenboek met de naam my_dict, schrijft u:

del my_dict["brand"]

Houd er rekening mee dat het een goede gewoonte is om ervoor te zorgen dat de sleutel in het woordenboek bestaat voordat u het del-trefwoord gebruikt. U kunt dit doen door te controleren of de sleutel in het woordenboek staat:

if "brand" in my_dict:
    del my_dict["brand"]

1. Duidelijke methode

The clear() method is another way to delete dictionary elements. This method removes all dictionary keys and values in one operation, resulting in an empty dictionary.

To use the clear() method on your dictionary, simply call it. For example, if you have an existing dictionary named my_dict and you want to remove all its contents, you would write:

my_dict.clear()

In conclusion, you have learned two methods to delete elements from a Python dictionary: the del keyword for removing individual key-value pairs and the clear() method for emptying an entire dictionary.

What Are Some Common Dictionary Methods?

In this section, we will explore some common Python dictionary methods. These built-in methods will help you manipulate and modify dictionaries to suit your needs.

Keys

To retrieve all the keys from your dictionary, you can use the keys() method. This will return a view object containing all the dictionary’s keys.

For example:

your_dict = {'a': 1, 'b': 2, 'c': 3}
key_view = your_dict.keys()
print(key_view)
# Output: dict_keys(['a', 'b', 'c'])

Values

Similarly, the values() method allows you to obtain all the values stored in the dictionary. This is also presented as a view object.

For instance:

value_view = your_dict.values()
print(value_view)
# Output: dict_values([1, 2, 3])

Items

If you need to access both keys and values simultaneously, use the items() method. This returns a view object containing key-value pairs in the form of tuples.

Let’s look at an example:

item_view = your_dict.items()
print(item_view)
# Output: dict_items([('a', 1), ('b', 2), ('c', 3)])

Update

The update() method allows you to modify your dictionary by adding or updating key-value elements. To use the method, you have to provide a dictionary as an argument.

To merge two dictionaries or update specific keys, use this method:

your_dict.update({'d': 4, 'e': 5})
print(your_dict)
# Output: {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}

Pop

Met de methode pop() kunt u een specifiek item uit het woordenboek verwijderen. Om het te gebruiken, geeft u de sleutel op die moet worden verwijderd als een argument in de methode.

De methode retourneert de waarde die is gekoppeld aan de opgegeven sleutel en verwijdert deze uit het woordenboek:

removed_value = your_dict.pop('a')
print(removed_value)
# Output: 1
print(your_dict)
# Output: {'b': 2, 'c': 3, 'd': 4, 'e': 5}

Popitem

De methode popitem() verwijdert het laatste sleutel-waardepaar in het woordenboek. Het retourneert een tuple die de verwijderde sleutel en waarde bevat. Bijvoorbeeld:

removed_item = your_dict.popitem()
print(removed_item)
# Output: ('e', 5)
print(your_dict)
# Output: {'b': 2, 'c': 3, 'd': 4}

Door deze methoden te gebruiken, kunt u uw woordenboeken effectief beheren en manipuleren om een ​​verscheidenheid aan taken uit te voeren.

Python-woordenboeken gebruiken

In dit gedeelte leert u verschillende technieken om met woordenboeken te werken, zoals het doorlussen ervan, het gebruik van woordenboekbegrippen en het werken met geneste woordenboeken.

Woordenboeken doorlopen

Om een ​​woordenboek te doorlopen, kunt u de ingebouwde methode items() gebruiken om sleutel-waardeparen te herhalen. Hierdoor kunt u bewerkingen op zowel sleutels als waarden op een leesbare en efficiënte manier uitvoeren.

Hier is een voorbeeld:

my_dict = {"apple": 1, "banana": 2, "cherry": 3}

for key, value in my_dict.items():
    print(key, value)

U kunt ook de methoden keys() en waarden() gebruiken om exclusief de woordenboeksleutels of waarden te herhalen.

Wat zijn woordenboekbegrippen?

Woordenboekbegrippen zijn een beknopte manier om woordenboeken te maken met behulp van een enkele regel code. Ze lijken op lijstbegrippen, maar werken in plaats daarvan met woordenboeken.

Hier is een voorbeeld van een woordenboekbegrip dat de getallen van 1 tot 5 kwadrateert:

squared_numbers = {num: num**2 for num in range(1, 6)}

Woordenboekbegrippen kunnen zeer waardevol zijn voor taken zoals het filteren van woordenboeken of het transformeren van hun waarden.

Wat zijn geneste woordenboeken?

Geneste woordenboeken zijn woordenboeken die andere woordenboeken als waarden bevatten. Ze kunnen worden gebruikt om complexe hiërarchische gegevensstructuren weer te geven.

Hier is een voorbeeld van een genest woordenboek:

nested_dict = {
    "person1": {"name": "Alice", "age": 30},
    "person2": {"name": "Bob", "age": 24}
}

Gebruik meervoudige indexering om toegang te krijgen tot een element in een geneste woordenlijst:

name_p1 = nested_dict["person1"]["name"]

U kunt naar behoefte elementen in de geneste woordenboeken verder bewerken of manipuleren. Vergeet niet om de sleutels en nestniveaus bij te houden wanneer u met complexe geneste woordenboeken werkt om verwarring of fouten te voorkomen.

Veelvoorkomende gevallen van woordenboekgebruik

Python-woordenboeken zijn veelzijdig, waardoor u verschillende gegevenstypen kunt organiseren en beheren. In deze sectie onderzoekt u enkele veelvoorkomende use-cases voor woordenboeken, die uw begrip zullen vergroten en u zullen helpen ze effectief in uw projecten te implementeren.

1. Sleutel-waardegegevens opslaan : woordenboeken zijn ideaal voor het opslaan van gegevens met unieke sleutels en bijbehorende waarden, zoals gebruikersnamen en gebruikersinformatie of product-ID's en productdetails:

{
  "username1": {"name": "Alice", "email": "[email protected]"},
  "username2": {"name": "Bob", "email": "[email protected]"}
}

Een voorbeeld hiervan is te zien in deze video over het bouwen van een Google News Aggregator in LuckyTemplates met behulp van Python.

https://youtu.be/InsDb_DR15E

In deze video gebruiken we een woordenboek om gegevenswaarden op te slaan die zijn verkregen via een GoogleNews API-aanroep.

2. Aantal voorkomens : u kunt woordenboeken gebruiken om het aantal keren dat items voorkomen, zoals de frequentie van woorden in een document, te tellen. Door sleutels te gebruiken om de unieke items weer te geven en waarden om het aantal aan te geven, kunt u dergelijke gegevens effectief beheren.

Leuk weetje, je kunt dit doen met de klasse Counter in de module Python Collections. Het neemt een ongeordende lijst op en retourneert een woordenboek met elk uniek element als een sleutel en hun frequentie als hun respectieve waarde.

3. Sleutels toewijzen aan meerdere waarden : Als u meerdere waarden voor elke woordenboeksleutel moet opslaan, kunt u lijsten of sets gebruiken als waarden in uw woordenboek:

{
  "fruits": ["apple", "banana", "mango"],
  "vegetables": ["carrot", "broccoli", "spinach"]
}

4. Berekende resultaten cachen : woordenboeken kunnen worden gebruikt voor het cachen van resultaten van dure bewerkingen. Dit is vooral handig bij memovormingstechnieken en dynamisch programmeren, waarbij u de resultaten van berekeningen opslaat om overbodige berekeningen te voorkomen.

5. Omgekeerde indexen maken : in gevallen zoals zoekmachines hebt u mogelijk een omgekeerde index nodig die elke zoekterm toewijst aan een lijst met bronnen die de term bevatten. Door woordenboeken te gebruiken, kunt u deze gegevens efficiënt opslaan:

{
  "python": ["resource1", "resource3"],
  "dictionary": ["resource2", "resource3", "resource4"]
}

Dit zijn slechts enkele voorbeelden om de kracht en veelzijdigheid van Python-woordenboeken te illustreren. Door deze use cases en hun toepassingen te begrijpen, kunt u het volledige potentieel van woordenboeken benutten om efficiënte oplossingen voor uw programmeertaken te bouwen!