Python-dictionary aanvullen: zo voeg je key-valueparen toe

In Python zijn dictionaries enorm veelzijdig: je slaat er gegevens in op als key-valueparen, zodat je data efficiënt kunt beheren en opvragen. Als je net met Python begint, is het belangrijk om te begrijpen hoe je deze dictionaries bewerkt. Dat maakt een groot verschil in hoe je data in allerlei toepassingen verwerkt. Of je nu instellingen configureert, complexe datasets beheert of gegevens snel wilt opzoeken: dictionaries zijn je vriend.

Een van de belangrijkste bewerkingen die je vaak nodig hebt, is het toevoegen van elementen aan een dictionary. In dit artikel laten we verschillende manieren zien om items toe te voegen aan een dictionary in Python, van de basis met notatie tussen rechte haken tot meer geavanceerde technieken zoals de update()-methode en de merge-operator. 

Ben je nieuw met dictionaries in Python? Lees dan ook onze Python Dictionaries Tutorial of onze Python Dictionary Comprehension Tutorial. Dat zijn uitstekende bronnen om key-valueparen en andere basisideeën achter dictionaries te leren. Ook kan onze Getting Started with Python Cheat Sheet handig zijn als snelle naslag wanneer je je Python-syntaxis en -functies wilt opfrissen.

Kort antwoord: hoe voeg je toe aan een dictionary in Python

Zoek je een snelle manier om elementen aan een Python-dictionary toe te voegen? De update()-methode is een van de meest gebruikte en gebruiksvriendelijke opties:

# Initial dictionary with information for one person
people_info = {
    'person_1': {
        'name': 'Alice',
        'city': 'New York'
    }
}

# Updating Alice's information and adding another person
people_info.update({
    'person_1': {
        'name': 'Alice',
        'city': 'Los Angeles',  # Updated city
        'age': 30               # Added new detail
    },
    'person_2': {
        'name': 'Bob',
        'city': 'San Francisco'
    }
})

print(people_info)

# {
#     'person_1': {'name': 'Alice', 'city': 'Los Angeles', 'age': 30},
#     'person_2': {'name': 'Bob', 'city': 'San Francisco'}
# }

In dit voorbeeld werkt de update()-methode Alice’ informatie onder de key 'person_1' bij: haar city verandert naar 'Los Angeles' en er komt een nieuw detail age: 30 bij. Ook wordt een nieuw persoon, Bob, toegevoegd onder de key 'person_2'.

Python-dictionaries begrijpen

Laten we beginnen met wat Python-dictionaries zijn en waarom ze zo belangrijk zijn bij het programmeren.

Wat is een Python-dictionary?

Een dictionary in Python is een verzameling key-valueparen. Elke key in een dictionary is uniek en wijst naar een value, die elk datatype kan hebben (zoals strings, integers, lijsten of zelfs andere dictionaries). Met deze structuur kun je gegevens opvragen, toevoegen en wijzigen. Hier is een simpel voorbeeld van een Python-dictionary:

# Example of a dictionary
person = {
    'name': 'Alice',
    'age': 25,
    'city': 'New York'
}

# Accessing a value
print(person['name'])  # Output: Alice

In dit voorbeeld zijn 'name', 'age' en 'city' keys, en 'Alice', 25 en 'New York' de bijbehorende waarden.

Structuur van een Python-dictionary

Dictionaries zijn ongeordende verzamelingen, wat betekent dat items geen vaste volgorde hebben. Vanaf Python 3.7 behouden dictionaries echter wel de invoegvolgorde, wat in veel toepassingen handig kan zijn. Hier is een uitgebreider voorbeeld om de structuur te laten zien:

# A more complex dictionary
employee = {
    'id': 101,
    'name': 'John Doe',
    'age': 30,
    'department': 'Engineering',
    'skills': ['Python', 'Machine Learning', 'Data Analysis'],
    'address': {
        'street': '123 Main St',
        'city': 'San Francisco',
        'state': 'CA',
        'zip': '94105'
    }
}

# Accessing nested data
print(employee['skills'][1])  # Output: Machine Learning
print(employee['address']['city'])  # Output: San Francisco

In dit voorbeeld bevat de dictionary employee verschillende datatypen, waaronder een lijst ('skills') en een andere dictionary ('address'). Dit laat zien hoe je dictionaries kunt gebruiken om complexe datastructuren op te slaan en te organiseren.

Nu we de basis hebben gehad, bekijken we de verschillende manieren om elementen aan een dictionary toe te voegen in meer detail.

Methoden om elementen aan een dictionary toe te voegen in Python

Elementen toevoegen aan een dictionary is een veelvoorkomende taak in Python. Er zijn meerdere manieren, elk met eigen toepassingsgebieden en voordelen. Laten we ze één voor één doornemen.

Met notatie tussen rechte haken

De meest directe manier om één key-valuepaar toe te voegen, is met notatie tussen rechte haken. Deze methode is simpel en efficiënt voor losse elementen. Dit is de syntaxis:

dictionary[key] = value

Hier is een voorbeeld met de notatie tussen rechte haken:

# Initialize a dictionary
my_dict = {'name': 'Alice', 'age': 25}

# Add a new key-value pair
my_dict['city'] = 'New York'

# Print the updated dictionary
print(my_dict)
# Output: {'name': 'Alice', 'age': 25, 'city': 'New York'}

Deze methode voegt het key-valuepaar direct toe aan de dictionary of werkt het bij. Bestaat de key al, dan wordt de waarde geüpdatet.

Als je met de notatie tussen rechte haken een key toevoegt die al bestaat, wordt de bijbehorende waarde bijgewerkt. Dat kan zowel handig als riskant zijn, afhankelijk van je doel. Hier is een voorbeeld dat laat zien hoe je met bestaande keys omgaat:

# Initialize a dictionary
my_dict = {'name': 'Alice', 'age': 25}

# Add a new key-value pair
my_dict['city'] = 'New York'

# Update an existing key-value pair
my_dict['age'] = 30

# Print the updated dictionary
print(my_dict)
# Output: {'name': 'Alice', 'age': 30, 'city': 'New York'}

In dit voorbeeld is de waarde van de key 'age' bijgewerkt van 25 naar 30.

De .update()-methode gebruiken

Met de .update()-methode kun je in één keer meerdere key-valueparen toevoegen. Je kunt een andere dictionary of een iterable met key-valueparen doorgeven. Dit is de syntaxis:

dictionary.update(other)

Hier is een voorbeeld met de .update()-methode:

# Initialize a dictionary
my_dict = {'name': 'Alice', 'age': 25}

# Add new key-value pairs using update()
my_dict.update({'city': 'New York', 'email': '[email protected]'})

# Print the updated dictionary
print(my_dict)
# Output: {'name': 'Alice', 'age': 25, 'city': 'New York', 'email': '[email protected]'}

De .update()-methode werkt ook met een iterable van key-valueparen. Hier is een voorbeeld:

# Initialize a dictionary
my_dict = {'name': 'Alice', 'age': 25}

# Add new key-value pairs using update() with an iterable
my_dict.update([('city', 'New York'), ('email', '[email protected]')])

# Print the updated dictionary
print(my_dict)
# Output: {'name': 'Alice', 'age': 25, 'city': 'New York', 'email': '[email protected]'}

De .update()-methode is vooral handig als je de dictionary in één keer met meerdere nieuwe entries wilt bijwerken. Als een key al bestaat, wordt de waarde bijgewerkt.

De .setdefault()-methode gebruiken

De .setdefault()-methode voegt alleen een key-valuepaar toe als de key nog niet bestaat. Bestaat de key wel, dan geeft deze de huidige waarde terug. Dit is de syntaxis:

dictionary.setdefault(key, default_value)

Hier is een voorbeeld met de .setdefault()-methode:

# Initialize a dictionary
my_dict = {'name': 'Alice', 'age': 25}

# Use setdefault to add a new key-value pair
my_dict.setdefault('city', 'New York')

# Attempt to add an existing key
my_dict.setdefault('age', 30)

# Print the updated dictionary
print(my_dict)
# Output: {'name': 'Alice', 'age': 25, 'city': 'New York'}

In dit voorbeeld voegt de .setdefault()-methode de key 'city' met de waarde 'New York' toe, omdat die nog niet bestond. Bij de poging om de key 'age' toe te voegen, verandert de bestaande waarde 25 niet, omdat de key al aanwezig is.

Deze aanpak is geschikt wanneer je zeker wilt weten dat een key een standaardwaarde heeft als die nog niet bestaat. Je kunt hem ook gebruiken om nieuwe key-valueparen toe te voegen zonder bestaande te overschrijven.

De dict()-constructor gebruiken

Je kunt ook een nieuwe dictionary maken met extra key-valueparen met de dict()-constructor. Dit is handig als je een nieuwe dictionary wilt baseren op een bestaande. Dit is de syntaxis:

new_dict = dict(existing_dict, key1=value1, key2=value2)

Hier is een voorbeeld met de dict()-constructor:

# Initialize a dictionary
my_dict = {'name': 'Alice', 'age': 25}

# Create a new dictionary with additional key-value pairs
new_dict = dict(my_dict, city='New York', email='[email protected]')

# Print the new dictionary
print(new_dict)
# Output: {'name': 'Alice', 'age': 25, 'city': 'New York', 'email': '[email protected]'}

In dit voorbeeld gebruik je de dict()-constructor om een nieuwe dictionary new_dict te maken, die de oorspronkelijke key-valueparen uit my_dict bevat plus de extra paren 'city': 'New York' en 'email': '[email protected]'.

Deze aanpak is handig als je een nieuwe dictionary wilt maken door bestaande dictionaries en extra key-valueparen te combineren. Je kunt hem ook gebruiken als je een nieuwe dictionary met enkele aanpassingen wilt maken, terwijl de oorspronkelijke dictionary ongewijzigd blijft.

Vergelijkingstabel

Hier is een snelle referentietabel voor de methoden die we in deze tutorial hebben behandeld:

Geavanceerde technieken om toe te voegen aan dictionaries in Python

De basis van dictionary-bewerking is essentieel, maar om dictionaries echt in de vingers te krijgen, is het belangrijk om ook geavanceerdere technieken te bekijken. Deze methoden helpen je om dictionaries efficiënter te beheren en te manipuleren in complexere scenario’s.

Toevoegen aan lijsten binnen een dictionary

Vaak gebruik je dictionaries om lijsten als waarden op te slaan. Elementen aan die lijsten toevoegen vraagt een iets andere aanpak. Zo doe je dat met .append():

# Initialize a dictionary with a list as a value
dictionary_w_list = {'fruits': ['apple', 'banana']}

# Append an element to the list within the dictionary
dictionary_w_list['fruits'].append('cherry')

# Print the updated dictionary
print(dictionary_w_list)
# Output: {'fruits': ['apple', 'banana', 'cherry']}

In dit voorbeeld beginnen we met dictionary_w_list, waarbij de key 'fruits' wijst naar de lijst ['apple', 'banana']. Met de methode .append() voegen we 'cherry' toe. Deze techniek is vooral handig als je verzamelingen items binnen één dictionary beheert.

Dictionaries combineren met de merge-operator

Python 3.9 introduceerde de merge-operator (|) om dictionaries te combineren. Hiermee merge je moeiteloos twee dictionaries tot een nieuwe:

# Initialize two dictionaries
first_dictionary = {'name': 'Alice', 'age': 25}
second_dictionary = {'city': 'New York', 'email': '[email protected]'}

# Merge the dictionaries using the merge operator
merged_dictionary = first_dictionary | second_dictionary

# Print the merged dictionary
print(merged_dictionary)
# Output: {'name': 'Alice', 'age': 25, 'city': 'New York', 'email': '[email protected]'}

In dit voorbeeld worden first_dictionary en second_dictionary samengevoegd tot een nieuwe dictionary, merged_dictionary. De merge-operator (|) combineert de key-valueparen van beide dictionaries. Dat is snel en handig om dictionaries te mergen.

De update-operator gebruiken

Voor in-place updates introduceerde Python 3.9 ook de update-|=-operator. Daarmee werk je de oorspronkelijke dictionary bij met de key-valueparen uit een andere dictionary.

# Initialize two dictionaries
first_dictionary = {'name': 'Alice', 'age': 25}
second_dictionary = {'city': 'New York', 'email': '[email protected]'}

# Update dict1 in-place using the update |= operator
first_dictionary |= second_dictionary

# Print the updated dictionary
print(first_dictionary)
# Output: {'name': 'Alice', 'age': 25, 'city': 'New York', 'email': '[email protected]'}

Hier werkt de update-|=-operator first_dictionary in place bij met de inhoud van second_dictionary. Met andere woorden: first_dictionary wordt direct aangepast. Dit is vooral nuttig als je een bestaande dictionary wilt bijwerken zonder een nieuwe te maken.

Conclusie

In dit artikel heb je geleerd over Python-dictionaries en de manieren om key-valueparen toe te voegen. We begonnen met basistechnieken zoals de notatie tussen rechte haken en de .update()-methode, die ideaal zijn voor snelle, eenvoudige updates. Daarna keken we naar geavanceerdere technieken, zoals toevoegen aan lijsten binnen dictionaries, dictionaries mergen met de merge-operator (|) en in-place updates met de update-|=-operator. Deze methoden geven je krachtige tools om complexe datastructuren te beheren en efficiënt te werken.

We hebben ook een aantal bronnen om je Python-vaardigheden verder te ontwikkelen. Bekijk de cursus Introduction to Python, een uitstekend startpunt met een solide basis in Python, gericht op data science-toepassingen. De skill track Python Programming biedt bovendien een compleet curriculum dat je van beginner naar vaardig programmeur brengt.

Onze career track Python Developer is ook ontworpen voor iedereen die dieper in Python-programmeren wil duiken. Deze track behandelt uitgebreid complexere programmeerconstructies en -technieken.