Vorteil

Ready to put your newfound language skills into use? Get 40% off CodeCrafter's real-world proficiency projects!

Sichere dir deinen Rabatt
Tracks
/
Python
Python
/
Lehrplan
/
Dict-Methoden
Di

Dict-Methoden in Python

2 Übungen

Über Dict-Methoden

Die dict-Klasse in Python bietet viele nützliche Methoden für die Arbeit mit Dictionaries. Einige davon wurden bereits im Konzept zu dicts vorgestellt. Hier behandeln wir noch ein paar weitere, zusammen mit einigen Techniken zum Durchlaufen und Bearbeiten von Dictionaries.

  • <dict>.setdefault() fügt automatisch Schlüssel hinzu, ohne einen KeyError auszulösen.
  • <dict>.fromkeys(<iterable>, <default value>) erstellt aus beliebig vielen Iterables ein neues dict.
  • <dict>.keys(), <dict>.values() und <dict>.items() liefern praktische Iteratoren.
  • sorted(<dict>.items()) kann Einträge in einem dict leicht umsortieren.
  • <dict_one>.update(<dict_two>) aktualisiert ein dict mit den überlappenden Werten eines anderen dict.
  • <dict> | <other_dict> und <dict> |= <other_dict> führen zwei dicts über Operatoren zusammen oder aktualisieren sie.
  • reversed(<dict>.keys()), reversed(<dict>.values()) oder reversed(<dict>.items()) erzeugen umgedrehte Ansichten.
  • <dict>.popitem() entfernt ein key-value-Paar und gibt es zurück.

setdefault() für fehlerfreies Einfügen

Im Dictionary-Konzept wurde bereits erklärt, dass <dict>.get(<key>, <default value>) einen vorhandenen value oder den default value zurückgibt, wenn ein key nicht im Dictionary gefunden wird, wodurch ein KeyError vermieden wird. Das funktioniert gut in Situationen, in denen du keine zusätzliche Fehlerbehandlung möchtest, aber nicht sicher sein kannst, dass ein gesuchter key vorhanden ist.

Für einen ähnlich „sicheren“ Einfügevorgang (ohne KeyError) gibt es die Methode <dict>.setdefault(<key>, <default value>). <dict>.setdefault(<key>, <default value>) gibt den value zurück, wenn der key im Dictionary gefunden wird. Wird der key nicht gefunden, fügt es das Paar (key, default value) ein und gibt den default value zur Verwendung zurück.

>>> palette_I = {'Grassy Green': '#9bc400', 'Purple Mountains Majesty': '#8076a3', 'Misty Mountain Pink': '#f9c5bd'}

# Looking for the value associated with key "Rock Brown".The key does not exist, 
# so it is added with the default value, and the value is returned.
>>> palette.setdefault('Rock Brown', '#694605')
'#694605'

# The (key, default value) pair has now been added to the dictionary.
>>> palette_I
{'Grassy Green': '#9bc400', 'Purple Mountains Majesty': '#8076a3', 'Misty Mountain Pink': '#f9c5bd', 'Rock Brown': '#694605'}

fromkeys() zum Befüllen eines Dictionarys aus einem Iterable

Um ein Dictionary schnell mit verschiedenen keys und Standardwerten zu befüllen, durchläuft die Klassenmethode fromkeys(<iterable>, <default value>) ein Iterable von keys und erstellt ein neues dict. Alle values werden auf den angegebenen default value gesetzt:

>>> new_dict = dict.fromkeys(['Grassy Green', 'Purple Mountains Majesty', 'Misty Mountain Pink'], 'fill in hex color here')

{'Grassy Green': 'fill in hex color here',
 'Purple Mountains Majesty': 'fill in hex color here',
 'Misty Mountain Pink': 'fill in hex color here'}

Ein (key, value)-Paar mit .popitem() entfernen und zurückgeben

.popitem() entfernt ein einzelnes Paar (key, value) aus einem Dictionary und gibt es zurück. Die Paare werden in der Reihenfolge Last-in-First-out (LIFO) zurückgegeben. Ist das Dictionary leer, löst der Aufruf von popitem() einen KeyError aus:

>>> palette_I = {'Grassy Green': '#9bc400', 
                 'Purple Mountains Majesty': '#8076a3', 
                 'Misty Mountain Pink': '#f9c5bd'}
>>> palette_I.popitem()
('Misty Mountain Pink', '#f9c5bd')

>>> palette_I.popitem()
('Purple Mountains Majesty', '#8076a3')

>>> palette_I.popitem()
('Grassy Green', '#9bc400')

# All (key, value) pairs have been removed.
>>> palette_I.popitem()
Traceback (most recent call last):
  line 1, in <module>
    palette_I.popitem()
KeyError: 'popitem(): dictionary is empty'

Über Einträge eines Dictionarys mit Ansichten iterieren

Die Methoden .keys(), .values() und .items() geben iterierbare Ansichten eines Dictionarys zurück.

Mit diesen Ansichten kannst du leicht über Einträge iterieren, ohne sie zu verändern. Ansichten sind außerdem dynamisch: Wenn sich die zugrunde liegenden Dictionary-Daten ändern, spiegelt das zugehörige view object die Änderung wider:

>>> palette_I = {'Grassy Green': '#9bc400', 
                 'Purple Mountains Majesty': '#8076a3', 
                 'Misty Mountain Pink': '#f9c5bd'}

# Using .keys() returns a list of keys.
>>> palette_I.keys()
dict_keys(['Grassy Green', 'Purple Mountains Majesty', 'Misty Mountain Pink'])

# Using .values() returns a list of values.
>>> palette_I.values()
dict_values(['#9bc400', '#8076a3', '#f9c5bd'])

# Using .items() returns a list of (key, value) tuples.
>>> palette_I.items()
dict_items([('Grassy Green', '#9bc400'), ('Purple Mountains Majesty', '#8076a3'), ('Misty Mountain Pink', '#f9c5bd')])

# Views are dynamic.  Changing values in the dict 
# changes all of the associated views.
>>> palette_I['Purple Mountains Majesty'] = (128, 118, 163)
>>> palette_I['Deep Red'] = '#932432'

>>> palette_I.values()
dict_values(['#9bc400', (128, 118, 163), '#f9c5bd', '#932432'])

>>> palette_I.keys()
dict_keys(['Grassy Green', 'Purple Mountains Majesty', 'Misty Mountain Pink', 'Deep Red'])

>>> palette_I.items()
dict_items([('Grassy Green', '#9bc400'), ('Purple Mountains Majesty', (128, 118, 163)), ('Misty Mountain Pink', '#f9c5bd'), ('Deep Red', '#932432')])

Mehr zu .keys(), .values() und .items()

Ab Python 3.7+ behalten dicts die Reihenfolge bei, in der Einträge eingefügt werden. Das ermöglicht eine First-in-First-out-Iteration (FIFO) bei Verwendung von .keys(), .values() oder .items().

Ab Python 3.8+ sind Ansichten außerdem umkehrbar. Damit lassen sich keys, values oder (key, value)-Paare mithilfe von reversed(<dict>.keys()), reversed(<dict>.values()) oder reversed(<dict>.items()) in der Reihenfolge Last-in-First-out (LIFO) durchlaufen:

>>> palette_II = {'Factory Stone Purple': '#7c677f', 
                  'Green Treeline': '#478559', 
                  'Purple baseline': '#161748'}
>>> for item in palette_II.items():
...     print(item)
...
('Factory Stone Purple', '#7c677f')
('Green Treeline', '#478559')
('Purple baseline', '#161748')

>>> for item in reversed(palette_II.items()):
...     print(item)
...
('Purple baseline', '#161748')
('Green Treeline', '#478559')
('Factory Stone Purple', '#7c677f')

Dictionaries mit .update() zusammenführen

Mit <dict_one>.update(<dict_two>) kannst du zwei Dictionaries zusammenführen. Diese Methode nimmt die (key,value)-Paare von <dict_two> und schreibt sie in <dict_one>:

>>> palette_I = {'Grassy Green': '#9bc400',
                 'Purple Mountains Majesty': '#8076a3',
                  'Misty Mountain Pink': '#f9c5bd'}
>>> palette_II = {'Factory Stone Purple': '#7c677f',
                  'Green Treeline': '#478559',
                  'Purple Baseline': '#161748'}

>>> palette_I.update(palette_II)

# Note that new items from palette_II are added.
>>> palette_I
{'Grassy Green': '#9bc400', 'Purple Mountains Majesty': '#8076a3', 'Misty Mountain Pink': '#f9c5bd', 'Factory Stone Purple': '#7c677f', 'Green Treeline': '#478559', 'Purple Baseline': '#161748'}

Wo sich die keys der beiden Dictionaries überschneiden, wird der value in dict_one durch den entsprechenden value aus dict_two überschrieben:

>>> palette_I = {'Grassy Green': '#9bc400', 
                 'Purple Mountains Majesty': '#8076a3', 
                 'Misty Mountain Pink': '#f9c5bd', 
                 'Factory Stone Purple': '#7c677f', 
                 'Green Treeline': '#478559', 
                 'Purple baseline': '#161748'}
                   
>>> palette_III = {'Grassy Green': (155, 196, 0), 
                   'Purple Mountains Majesty': (128, 118, 163),
                   'Misty Mountain Pink': (249, 197, 189)}
>>> palette_I.update(palette_III)

# Overlapping values in palette_I are replaced with 
# values from palette_III
>>> palette_I
{'Grassy Green': (155, 196, 0),
  'Purple Mountains Majesty': (128, 118, 163), 
  'Misty Mountain Pink': (249, 197, 189), 
  'Factory Stone Purple': '#7c677f', 
  'Green Treeline': '#478559', 'Purple baseline': '#161748'}

Dictionaries mit den Union-Operatoren (| und |=) zusammenführen oder aktualisieren

Python 3.9 führt eine andere Möglichkeit ein, dicts zusammenzuführen: die union-Operatoren. dict_one | dict_two erstellt ein neues Dictionary, das aus den (key, value)-Paaren von dict_one und dict_two besteht. Wenn beide Dictionaries gemeinsame Keys haben, haben die Werte von dict_two Vorrang.

>>> palette_I = {'Grassy Green': '#9bc400', 
                 'Purple Mountains Majesty': '#8076a3', 
                 'Misty Mountain Pink': '#f9c5bd'}

>>> palette_II = {'Factory Stone Purple': '#7c677f', 
                  'Green Treeline': '#478559', 
                  'Purple baseline': '#161748'}

>>> new_dict = palette_I | palette_II
>>> new_dict
...
{'Grassy Green': '#9bc400',
 'Purple Mountains Majesty': '#8076a3',
 'Misty Mountain Pink': '#f9c5bd',
 'Factory Stone Purple': '#7c677f',
 'Green Treeline': '#478559',
 'Purple baseline': '#161748'}

dict_one |= other verhält sich ähnlich wie <dict_one>.update(<other>), aber in diesem Fall kann other entweder ein dict oder ein Iterable von (key, value)-Paaren sein:

>>> palette_III = {'Grassy Green': (155, 196, 0),
                   'Purple Mountains Majesty': (128, 118, 163),
                   'Misty Mountain Pink': (249, 197, 189)}
>>> new_dict |= palette_III
>>> new_dict
...
{'Grassy Green': (155, 196, 0),
'Purple Mountains Majesty': (128, 118, 163),
'Misty Mountain Pink': (249, 197, 189),
'Factory Stone Purple': '#7c677f',
'Green Treeline': '#478559',
'Purple baseline': '#161748'}

Ein Dictionary sortieren

Dictionaries haben keine eingebaute Sortiermethode. Du kannst jedoch eine dict-Ansicht mit der eingebauten Funktion sorted() zusammen mit .items() sortieren. Die sortierte Ansicht kannst du dann verwenden, um ein neues Dictionary zu erstellen. Wenn kein Sortierschlüssel angegeben wird, sortiert die Standardeinstellung nach den keys des Dictionarys.

# Default ordering for a dictionary is last in, first out (LIFO).
>>> color_palette = {'Grassy Green': '#9bc400', 
                    'Purple Mountains Majesty': '#8076a3', 
                    'Misty Mountain Pink': '#f9c5bd', 
                    'Factory Stone Purple': '#7c677f', 
                    'Green Treeline': '#478559', 
                    'Purple baseline': '#161748'}
 
 
# The default sort order for a dictionary uses the keys.
>>> sorted_palette = dict(sorted(color_palette.items()))
>>> sorted_palette
{'Factory Stone Purple': '#7c677f',
 'Grassy Green': '#9bc400',
 'Green Treeline': '#478559',
 'Misty Mountain Pink': '#f9c5bd',
 'Purple Mountains Majesty': '#8076a3',
 'Purple baseline': '#161748'}


# A sort key can be provided in the form
# of an anonymous function (lambda). 
>>> value_sorted_palette = dict(sorted(color_palette.items(), key=lambda color: color[1]))
>>> value_sorted_palette
{'Purple baseline': '#161748',
 'Green Treeline': '#478559',
 'Factory Stone Purple': '#7c677f',
 'Purple Mountains Majesty': '#8076a3',
 'Grassy Green': '#9bc400',
 'Misty Mountain Pink': '#f9c5bd'}

Schlüssel und Werte eines Dictionarys vertauschen

Das zuverlässige Vertauschen von Keys und Werten in einem Dictionary ist etwas Arbeit, lässt sich aber mit einer loop über dict.items() oder in einer Dictionary-Comprehension bewerkstelligen. Ein sicheres Vertauschen setzt voraus, dass sowohl die keys als auch die values eines dict hashable sind.

color_reference = {'Purple Mountains Majesty': '#8076a3',
                   'Misty Mountain Pink': '#f9c5bd',
                   'Factory Stone Purple': '#7c677f',
                   'Green Treeline': '#478559',
                   'Purple baseline': '#161748'}

# Creating a new dictionary to hold the swapped entries.
>>> swapped_color_reference = {}

# Iterating through the dictionary, using values as keys.
>>> for key, value in color_reference.items():
...     swapped_color_reference[value] = key

>>> swapped_color_reference
{'#8076a3': 'Purple Mountains Majesty',
 '#f9c5bd': 'Misty Mountain Pink',
 '#7c677f': 'Factory Stone Purple',
 '#478559': 'Green Treeline',
 '#161748': 'Purple baseline'}

 
# A dictionary comprehension can also be used to swap entries.
>>> swapped = {value: key for key, value in
               color_reference.items()}
>>> swapped
{'#8076a3': 'Purple Mountains Majesty',
 '#f9c5bd': 'Misty Mountain Pink',
 '#7c677f': 'Factory Stone Purple',
 '#478559': 'Green Treeline',
 '#161748': 'Purple baseline'}

Wenn die im dict gespeicherten Werte nicht eindeutig sind, sind zusätzliche Prüfungen nötig, bevor du Keys und Werte vertauschen kannst:

# Things become more complicated if there are duplicates in 
# potential key values.This dict is arranged by hex, RGB, and HSL
# keys, but values repeat.
>>> extended_colors = {'#8076a3': 'Purple Mountains Majesty',
                       (128, 118, 163): 'Purple Mountains Majesty',
                       (21, 28, 0, 36): 'Purple Mountains Majesty',
                       '#f9c5bd': 'Misty Mountain Pink',
                       (249, 197, 189): 'Misty Mountain Pink',
                       (0, 21, 24, 2): 'Misty Mountain Pink',
                       '#7c677f': 'Factory Stone Purple',
                       (124, 103, 127): 'Factory Stone Purple',
                       (2, 19, 0, 50): 'Factory Stone Purple',
                       '#478559': 'Green Treeline',
                       (71, 133, 89): 'Green Treeline',
                       (47, 0, 33, 48): 'Green Treeline'}
                                
# New empty dictionary for holding swapped entries.
>>> consolidated_colors = {}

# Iterating over (key, value) pairs using .items()
>>> for key, value in extended_color_reference.items():
...    if value in consolidated_colors: # <--Check if key has already been created.
...        consolidated_colors[value].append(key)
...    else:
...        consolidated_colors[value] = [key]  # <--Create a value list with the former key in it.

>>> consolidated_colors
{'Purple Mountains Majesty': ['#8076a3', (128, 118, 163), (21, 28, 0, 36)],
 'Misty Mountain Pink': ['#f9c5bd', (249, 197, 189), (0, 21, 24, 2)],
 'Factory Stone Purple': ['#7c677f', (124, 103, 127), (2, 19, 0, 50)],
 'Green Treeline': ['#478559', (71, 133, 89), (47, 0, 33, 48)]}

Für eine ausführliche Erklärung von Dictionaries und Methoden für die Arbeit mit ihnen sind das offizielle Tutorial und die offizielle Bibliotheksreferenz hervorragende Ausgangspunkte.

Real Python und Finxter haben ebenfalls sehr gründliche Artikel zu Python-Dictionaries.

Mehr zum Sortieren findest du im Sorting HOW TO in der Python-Dokumentation.

Mehr erfahren

Über GitHub bearbeiten Der Link öffnet sich in einem neuen Fenster oder Tab

Lerne Dict-Methoden

Das Üben ist gesperrt

Schalte 3 weitere Übungen frei, um Dict-Methoden zu üben