Summary  
This chapter covers how to use the `popitem()` method to remove and return the last inserted key-value pair from a dictionary.

General domain of usage  
Dynamic data structure manipulation within applications.

Dictionaries verfügen außerdem über die Methode `popitem()`, die das zuletzt eingefügte Schlüssel-Wert-Paar entfernt und zurückgibt.

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

# Removing the last key-value pair using popitem()
popped_item = book.popitem()

# Printing the updated dictionary and the removed pair
print("Removed item:", popped_item)
print("Updated dictionary:", book)

import unittest
import importlib

def _dynamic_test(test_case, condition, success_message, failure_message):
    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):
        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):
        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_removed_element_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'removed_element'),
            "The `removed_element` variable is declared.",
            "Expected `removed_element` to be declared."
        )

    def test_removed_element_was_last(self):
        import user_code
        expected_last_key = 'Agatha Christie'
        _dynamic_test(
            self,
            isinstance(user_code.removed_element, tuple) and user_code.removed_element[0] == expected_last_key,
            "The last element was correctly removed using `popitem()`.",
            "Expected only the last element to be removed using `popitem()`"
        )

    def test_mark_twain_is_added(self):
        import user_code
        expected_books = [
            'The Adventures of Tom Sawyer',
            'Adventures of Huckleberry Finn',
            'The Prince and the Pauper'
        ]
        _dynamic_test(
            self,
            'Mark Twain' in user_code.authors_books and user_code.authors_books['Mark Twain'] == expected_books,
            "The `Mark Twain` entry was added correctly.",
            "Expected `Mark Twain` to be in `authors_books` with the correct book list."
        )

    def test_other_authors_exist(self):
        import user_code
        expected_authors = {
            'William Shakespeare', 'J.K. Rowling', 'George Orwell', 'Stephen King'
        }
        _dynamic_test(
            self,
            expected_authors.issubset(set(user_code.authors_books.keys())),
            "Other authors are still present in `authors_books`.",
            "Some expected authors are missing from `authors_books`."
        )

    def test_popitem_method_used(self):
        with open('user_code.py', 'r') as file:
            user_code_source = file.read()
        _dynamic_test(
            self,
            "popitem()" in user_code_source,
            "The `popitem()` method is used to remove the last element.",
            "Expected the `popitem()` method to be used to remove the last element."
        )

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.

Verwendung der Popitem()-Methode: Entfernen des Zuletzt Eingefügten Elements

Lösung