Python-ordbøger 101: En detaljeret visuel introduktion

Velkommen

I denne artikel lærer du at arbejde med Python-ordbøger, en utrolig hjælpsom indbygget datatype, som du helt sikkert vil bruge i dine projekter.

Især vil du lære:

  • Hvad ordbøger bruges til og deres vigtigste egenskaber.
  • Hvorfor de er vigtige for dine programmeringsprojekter.
  • "Anatomi" i en ordbog: nøgler, værdier og nøgleværdipar.
  • De specifikke regler, der bestemmer, om en værdi kan være en nøgle.
  • Sådan får du adgang til, tilføjer, ændrer og sletter nøgleværdipar.
  • Sådan kontrolleres, om en nøgle er i en ordbog.
  • Hvad længden af ​​en ordbog repræsenterer.
  • Sådan gentages ordbøger ved hjælp af sløjfer.
  • Hvilke indbyggede ordbogsmetoder kan du bruge til at udnytte styrken ved denne datatype.

I slutningen af ​​denne artikel vil vi dykke ned i et simpelt projekt for at anvende din viden: vi skriver en funktion, der opretter og returnerer en ordbog med et bestemt formål.

Lad os begynde! ⭐️

? Ordbøger i sammenhæng

Lad os starte med at diskutere vigtigheden af ​​ordbøger. For at illustrere dette, lad mig lave en hurtig sammenligning med en anden datatype, som du sandsynligvis er bekendt med: lister.

Når du arbejder med lister i Python, kan du få adgang til et element ved hjælp af et indeks, et heltal, der beskriver elementets placering på listen. Indeks starter fra nul for det første element og øges med et for hvert efterfølgende element på listen. Du kan se et eksempel lige her:

Men hvad hvis vi har brug for at gemme to relaterede værdier og beholde denne "forbindelse" i vores kode? Lige nu har vi kun enkelte uafhængige værdier gemt på en liste.

Lad os sige, at vi vil gemme elevernes navne og "forbinde" hvert navn med karaktererne for hver enkelt elev. Vi ønsker at bevare "forbindelsen" mellem dem. Hvordan ville du gøre det i Python?

Hvis du bruger indlejrede lister, vil tingene blive meget komplekse og ineffektive efter kun at have tilføjet et par emner, fordi du bliver nødt til at bruge to eller flere indekser for at få adgang til hver værdi afhængigt af den endelige liste. Det er her, Python-ordbøger kommer til undsætning.

Mød ordbøger

En Python-ordbog ser sådan ud (se nedenfor). Med en ordbog kan du "forbinde" en værdi til en anden værdi for at repræsentere forholdet mellem dem i din kode. I dette eksempel er "Gino" "forbundet" til heltal 15, og strengen "Nora" er "forbundet" til heltal 30.

Lad os se de forskellige elementer, der danner en ordbog.

? "Anatomi" i en Python-ordbog

Da en ordbog "forbinder" to værdier, har den to typer elementer:

  • Taster: en nøgle er en værdi, der bruges til at få adgang til en anden værdi. Nøgler svarer til "indekser" i strenge, lister og tupler. I ordbøger bruger du nøglen, som er selve en værdi, for at få adgang til en værdi.
  • Værdier: disse er de værdier, som du kan få adgang til med deres tilsvarende nøgle.

Disse to elementer danner det, der kaldes et nøgleværdipar (en nøgle med dens tilsvarende værdi).

Syntaks

Dette er et eksempel på en Python Dictionary, der kortlægger strengen "Gino" til nummeret 15 og strengen "Nora" til nummeret 30:

>>> {"Gino": 15, "Nora": 30}
  • For at oprette en ordbog bruger vi krøllede parenteser{ } .
  • Mellem disse krøllede parenteser skriver vi nøgleværdipar adskilt af et komma.
  • For nøgleværdiparene skriver vi nøglen efterfulgt af et kolon, et mellemrum og den værdi, der svarer til nøglen.

? Tip:

  • Til læsbarhed og stilformål anbefales det at tilføje et mellemrum efter hvert komma for at adskille nøgleværdiparene.
  • Du kan oprette en tom ordbog med et tomt par krøllede parenteser {}.

Vigtige regler for nøgler

Ikke alle værdier kan være en nøgle i en Python-ordbog. Nøgler skal følge et sæt regler:

Ifølge Python-dokumentationen:

  • Taster skal være unikke inden for en ordbog.
Det er bedst at tænke på en ordbog som et sæt nøgler: værdipar med kravet om, at tasterne er unikke (inden for en ordbog).
  • Nøgler skal være uforanderlige.
I modsætning til sekvenser, der er indekseret af en række tal, indekseres ordbøger med nøgler , som kan være af enhver uforanderlig type; strenge og tal kan altid være nøgler.
  • Hvis nøglen er en tupel, kan den kun indeholde strenge, tal eller tupler.
Tuples kan bruges som nøgler, hvis de kun indeholder strenge, tal eller tuples; hvis en tuple indeholder et eller andet ændret objekt, enten direkte eller indirekte, kan det ikke bruges som en nøgle.
  • Lister kan ikke være nøgler, fordi de kan ændres. Dette er en konsekvens af den tidligere regel.
Du kan ikke bruge lister som nøgler, da lister kan ændres på plads ved hjælp af indeksetildelinger, skiveopgaver eller metoder som append()og extend().

? Bemærk: Værdier har ingen specifikke regler, de kan være enten ændrede eller uforanderlige værdier.  

? Ordbøger i aktion

Lad os nu se, hvordan vi kan arbejde med ordbøger i Python. Vi skal få adgang til, tilføje, ændre og slette nøgleværdipar.

Vi begynder at arbejde med denne ordbog, der er tildelt agesvariablen:

>>> ages = {"Gino": 15, "Nora": 30}

Adgang til værdier ved hjælp af taster

If we need to access the value associated with a specific key, we write the name of the variable that references the dictionary followed by square brackets [] and, within the square brackets, the key that corresponds to the value:

[]

This is an example of how we can access the value that corresponds to the string "Gino":

>>> ages = {"Gino": 15, "Nora": 30} >>> ages["Gino"] 15

Notice that the syntax is very similar to indexing a string, tuple, or list, but now we are using the key as the index instead of an integer.

If we want to access the value that corresponds to "Nora", we would do this:

>>> ages = {"Gino": 15, "Nora": 30} >>> ages["Nora"] 30

? Tip: If you try to access a key that does not exist in the dictionary, you will get a KeyError:

>>> ages = {"Gino": 15, "Nora": 30} >>> ages["Talina"] Traceback (most recent call last): File "", line 1, in  ages["Talina"] KeyError: 'Talina'

Add Key-Value Pairs

If a key-value pair doesn't exist in the dictionary, we can add it. To do this, we write the variable that references the dictionary followed by the key within square brackets, an equal sign, and the new value:

This is an example in IDLE:

>>> ages = {"Gino": 15, "Nora": 30} # Add the key-value pair "Talina": 24 >>> ages["Talina"] = 24 # The dictionary now has this key-value pair >>> ages {'Gino': 15, 'Nora': 30, 'Talina': 24}

Modify a Key-Value Pair

To modify the value associated to a specific key, we use the same syntax that we use to add a new key-value pair, but now we will be assigning the new value to an existing key:

>>> ages = {"Gino": 15, "Nora": 30} # The key "Gino" already exists in the dictionary, so its associated value # will be updated to 45. >>> ages["Gino"] = 45 # The value was updated to 45. >>> ages {'Gino': 45, 'Nora': 30}

Deleting a Key-Value Pair

To delete a key-value pair, you would use the del keyword followed by the name of the variable that references the dictionary and, within square brackets [], the key of the key-value pair:

This is an example in IDLE:

>>> ages = {"Gino": 15, "Nora": 30, "Talina": 45} # Delete the key-value pair "Gino": 15. >>> del ages["Gino"] # The key-value pair was deleted. >>> ages {'Nora': 30, 'Talina': 45}

? Check if a Key is in a Dictionary

Sometimes, it can be very helpful to check if a key already exists in a dictionary (remember that keys have to be unique).

Ifølge Python-dokumentationen:

Brug nøgleordet for at kontrollere, om en enkelt nøgle er i ordbogen in.
>>> ages = {"Gino": 15, "Nora": 30, "Talina": 45} >>> "Talina" in ages True >>> "Gino" in ages True >>> "Lulu" in ages False

Den inOperatøren kontrollerer nøglerne, ikke værdier. Hvis vi skriver dette:

>>> 15 in ages False

Vi kontrollerer, om nøglen 15 er i ordbogen, ikke værdien. Dette er grunden til, at udtrykket evalueres til False.

? Tip: Du kan bruge inoperatøren at kontrollere, om en værdi i en ordbog med .values ().

>>> ages = {"Gino": 15, "Nora": 30, "Talina": 45} >>> 30 in ages.values() True >>> 10 in ages.values() False

? Længde af en Python-ordbog

Længden af ​​en ordbog er antallet af nøgleværdipar, den indeholder. Du kan kontrollere længden af ​​en ordbog med funktionen len (), som vi ofte bruger, ligesom vi kontrollerer længden på lister, tupler og strenge:

# Two key-value pairs. Length 2. >>> ages = {"Gino": 15, "Nora": 30} >>> len(ages) 2 # Three key-value pairs. Length 3. >>> ages = {"Gino": 15, "Nora": 30, "Talina": 45} >>> len(ages) 3

? Iterere over ordbøger i Python

You can iterate over dictionaries using a for loop. There are various approaches to do this and they are all equally relevant. You should choose the approach that works best for you, depending on what you are trying to accomplish.

First Option - Iterate over the Keys

We can iterate over the keys of a dictionary like this:

for  in : # Do this

For example:

>>> ages = {"Gino": 15, "Nora": 30, "Talina": 45} >>> for student in ages: print(student) Gino Nora Talina

Second Option - Iterate over the Key-Value Pairs

To do this, we need to use the built-in method .items(), which allows us to iterate over the key-value pairs as tuples of this format (key, value).

for  in .items(): # Do this

For example:

>>> ages = {"Gino": 15, "Nora": 30, "Talina": 45} >>> for pair in ages.items(): print(pair) ('Gino', 15) ('Nora', 30) ('Talina', 45)

Third Option - Assign Keys and Values to Individual Variables

With .items() and for loops, you can use the power of a tuple assignment to directly assign the keys and values to individual variables that you can use within the loop:

>>> ages = {"Gino": 15, "Nora": 30, "Talina": 45} # Tuple assignment to assign the key to the variable key # and the value to the variable value. >>> for key, value in ages.items(): print("Key:", key, "; Value:", value) Key: Gino ; Value: 15 Key: Nora ; Value: 30 Key: Talina ; Value: 45

Fourth Option - Iterate over the Values

You can iterate over the values of a dictionary using the .values() method.

>>> ages = {"Gino": 15, "Nora": 30, "Talina": 45} >>> for age in ages.values(): print(age) 15 30 45

? Dictionary Methods

Dictionaries include very helpful built-in methods that can save you time and work to perform common functionality:

.clear()

This method removes all the key-value pairs from the dictionary.

>>> ages = {"Gino": 15, "Nora": 30, "Talina": 45} >>> ages.clear() >>> ages {}

.get(, )

This method returns the value associated with the key. Otherwise, it returns the default value that was provided as the second argument (this second argument is optional).

>>> ages = {"Gino": 15, "Nora": 30, "Talina": 45} >>> ages.get("Nora") 30 >>> ages.get("Nor", "Not Found") 'Not Found'

If you don't add a second argument, this is equivalent to the previous syntax with square brackets []that you learned:

>>> ages = {"Gino": 15, "Nora": 30, "Talina": 45} >>> ages["Nora"] 30 >>> ages.get("Nora") 30

.pop(, )

This method removes the key-value pair from the dictionary and returns the value.

>>> ages = {"Gino": 15, "Nora": 30, "Talina": 45} >>> ages.pop("Talina") 45 >>> ages {'Gino': 15, 'Nora': 30}

.update()

This method replaces the values of a dictionary with the values of another dictionary only for those keys that exist in both dictionaries.

An example of this would be a dictionary with the original grades of three students (see code below). We only want to replace the grades of the students who took the make-up exam (in this case, only one student took the make-up exam, so the other grades should remain unchanged).

>>> grades = {"Gino": 0, "Nora": 98, "Talina": 99} >>> new_grades = {"Gino": 67} >>> grades.update(new_grades) >>> grades {'Gino': 67, 'Nora': 98, 'Talina': 99}

By using the .update() method, we could update the value associated with the string "Gino" in the original dictionary since this is the only common key in both dictionaries.

The original value would be replaced by the value associated with this key in the dictionary that was passed as argument to .update().

? Tips: To learn more about dictionary methods, I recommend reading this article in the Python Documentation.

? Mini Project - A Frequencies Dictionary

Now you will apply your knowledge by writing a function freq_dict that creates and returns a dictionary with the frequency of each element of a list, string, or tuple (the number of times the element appears). The elements will be the keys and the frequencies will be the values.

Code

We will be writing the function step-by-step to see the logic behind each line of code.

  • Step 1: The first thing that we need to do is to write the function header. Notice that this function only takes one argument, the list, string or tuple, which we call data.
def freq_dict(data):
  • Step 2: Then, we need to create an empty dictionary that will map each element of the list, string, or tuple to its corresponding frequency.
def freq_dict(data): freq = {}
  • Step 3: Then, we need to iterate over the list, string, or tuple to determine what to do with each element.
def freq_dict(data): freq = {} for elem in data: 
  • Step 4: If the element has already been included in the dictionary, then the element appears more than once and we need to add 1 to its current frequency. Else, if the element is not in the dictionary already, it's the first time it appears and its initial value should be 1.
def freq_dict(data): freq = {} for elem in data: if elem in freq: freq[elem] += 1 else: freq[elem] = 1
  • Step 5: Finally, we need to return the dictionary.
def freq_dict(data): freq = {} for elem in data: if elem in freq: freq[elem] += 1 else: freq[elem] = 1 return freq

❗️Important: Since we are assigning the elements as the keys of the dictionary, they have to be of an immutable data type.

Examples

Here we have an example of the use of this function. Notice how the dictionary maps each character of the string to how many times it occurs.

>>> def freq_dict(data): freq = {} for elem in data: if elem in freq: freq[elem] += 1 else: freq[elem] = 1 return freq >>> freq_dict("Hello, how are you?") {'H': 1, 'e': 2, 'l': 2, 'o': 3, ',': 1, ' ': 3, 'h': 1, 'w': 1, 'a': 1, 'r': 1, 'y': 1, 'u': 1, '?': 1}

Dette er et andet eksempel anvendt på en liste over heltal:

>>> def freq_dict(data): freq = {} for elem in data: if elem in freq: freq[elem] += 1 else: freq[elem] = 1 return freq >>> freq_dict([5, 2, 6, 2, 6, 5, 2, 2, 2]) {5: 2, 2: 5, 6: 2}

Flot arbejde! Nu har vi den sidste funktion.

? Sammenfattende

  • Ordbøger er indbyggede datatyper i Python, der knytter (kort) nøgler til værdier og danner nøgleværdipar.
  • Du kan få adgang til en værdi med den tilsvarende nøgle.  
  • Nøgler skal være af en uforanderlig datatype.
  • Du kan få adgang til, tilføje, ændre og slette nøgleværdipar.
  • Ordbøger tilbyder en bred vifte af metoder, der kan hjælpe dig med at udføre fælles funktionalitet.

Jeg håber virkelig, du kunne lide min artikel og fandt det nyttigt. Nu kan du arbejde med ordbøger i dine Python-projekter. Tjek mine online kurser. Følg mig på Twitter. ⭐️