Summary  
This chapter explains how to dynamically add new key-value pairs to a dictionary and update existing values by assigning to dictionary keys.

General domain of usage  
Book cataloging systems

Dictionaries sind dynamisch, das bedeutet, dass nach der Erstellung des Dictionaries **Elemente hinzugefügt**, **aktualisiert** oder **entfernt** werden können. Im Folgenden wird gezeigt, wie neue Elemente zu einem Dictionary hinzugefügt werden können.

Beginne mit der Erstellung eines Dictionaries namens `book` mit einigen Anfangsdaten:

book = {"title": "Pride and Prejudice", "author": "Jane Austen", "year": 1813}
print(book)

Um unser Dictionary zu vervollständigen, kann ein neues Schlüssel-Wert-Paar hinzugefügt werden. Zum Beispiel könnte das `genre` des Buches ergänzt werden:

book = {"title": "Pride and Prejudice", "author": "Jane Austen", "year": 1813}

book["genre"] = "Romance"
print(book)

Nach dem Hinzufügen des neuen Schlüssel-Wert-Paares enthält das Dictionary nun:

## Aktualisieren eines vorhandenen Schlüssel-Wert-Paares
Um den Wert eines vorhandenen Schlüssels zu aktualisieren, kann diesem Schlüssel ein neuer Wert zugewiesen werden. Angenommen, das Veröffentlichungsjahr des Buches wurde auf `1815` korrigiert:

book = {"title": "Pride and Prejudice", "author": "Jane Austen", "year": 1813, "genre": "Romance"}

book["year"] = 1815
print(book)

Einfache `' '` und doppelte `" "` Anführungszeichen in Python sind austauschbar und gleichwertig.

Hinweis

import unittest
import importlib

def _dynamic_test(test_case, condition, success_message, failure_message):
    """
    A reusable function for handling assertions dynamically.
    """
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

class TestUserCode(unittest.TestCase):

    def test_authors_books_is_declared(self):
        """
        Test to ensure `authors_books` is declared.
        """
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'authors_books'),
            "The `authors_books` dictionary is declared.",
            "Expected `authors_books` to be declared."
        )

    def test_authors_books_is_dict(self):
        """
        Test to ensure `authors_books` is of type dictionary.
        """
        import user_code
        _dynamic_test(
            self,
            isinstance(user_code.authors_books, dict),
            "The `authors_books` is of type `dict`.",
            "Expected `authors_books` to be of type `dict`."
        )
    
    def test_new_author_added(self):
        """
        Test to ensure the new author is added to `authors_books`.
        """
        import user_code
        expected_author = "F. Scott Fitzgerald"
        _dynamic_test(
            self,
            expected_author in user_code.authors_books,
            "The new author `F. Scott Fitzgerald` is added to `authors_books`.",
            "Expected `F. Scott Fitzgerald` to be added to `authors_books`."
        )

    def test_new_author_books_are_list(self):
        """
        Test to ensure the books of the new author are stored as a list.
        """
        import user_code
        expected_author = "F. Scott Fitzgerald"
        _dynamic_test(
            self,
            isinstance(user_code.authors_books.get(expected_author, []), list),
            "The books for `F. Scott Fitzgerald` are stored as a list.",
            "Expected books for `F. Scott Fitzgerald` to be stored as a list."
        )
    
    def test_new_author_books_correct(self):
        """
        Test to ensure the books of the new author match expected values.
        """
        import user_code
        expected_author = "F. Scott Fitzgerald"
        expected_books = [
            "The Great Gatsby", "Tender Is the Night", "This Side of Paradise", 
            "The Beautiful and Damned", "The Last Tycoon"
        ]
        _dynamic_test(
            self,
            set(user_code.authors_books.get(expected_author, [])) == set(expected_books),
            "The books for `F. Scott Fitzgerald` are correctly added.",
            f"Expected books for `F. Scott Fitzgerald` to be {expected_books}, but got {user_code.authors_books.get(expected_author, [])}."
        )
    
if __name__ == '__main__':
    unittest.main()

test_main.py

Erkunden Sie die grundlegenden Datenstrukturen der Programmiersprache Python, einschließlich Listen, Dictionaries, Tupel und Sets, und erfahren Sie, wie Sie diese effektiv zur Lösung praxisnaher Programmieraufgaben einsetzen können.

Was ist eine Liste? Eine Liste ist eine geordnete Sammlung, die verändert werden kann. Sie erlaubt außerdem doppelte Elemente.

Was ist ein Dictionary? Ein Dictionary ist eine geordnete, veränderbare Sammlung, die keine doppelten Einträge zulässt. Es besteht aus Schlüssel:Wert-Paaren, die zur Optimierung seiner Struktur verwendet werden.

Was ist ein Tupel? Ein Tupel ist eine geordnete Sammlung, die nicht verändert werden kann. Es kann doppelte Elemente enthalten. Obwohl es einer Liste ähnelt, können die Werte in einem Tupel beliebigen Typs sein und werden durch Ganzzahlen indiziert. Es ist zwar nicht zwingend erforderlich, aber üblich, die Werte eines Tupels in Klammern zu setzen, um sie in Python leichter verständlich zu machen.

Was ist eine Menge? In Python ist eine Menge eine ungeordnete Sammlung, die sowohl iterierbar als auch veränderbar ist und keine doppelten Elemente enthält. Obwohl die Reihenfolge der Elemente in einer Menge nicht festgelegt ist, kann sie verschiedene Elemente umfassen. Ein wesentlicher Vorteil der Verwendung von Mengen gegenüber Listen ist die äußerst effiziente Methode zur Überprüfung, ob ein Element in der Menge vorhanden ist.

Hinzufügen von Elementen zu einem Dictionary: Aktualisierung von Schlüssel-Wert-Paaren

Aktualisieren eines vorhandenen Schlüssel-Wert-Paares

Lösung