Summary  
This chapter explains how to use the dictionary pop() method to delete a key-value pair while returning its value, and how a missing key triggers a KeyError.  

General domain of usage  
Inventory management systems

In this video, you will learn how to delete elements from Python dictionaries while retrieving their values using the `pop()` method. We will start by explaining the `pop()` method's purpose and syntax, demonstrating how it removes a key-value pair and returns the value associated with the specified key. You will see practical examples, including removing the 'copies' key from a book dictionary and observing the updated dictionary and returned value. The video will also cover what happens if you try to pop a key that does not exist—raising a `KeyError`—and how to recognize and handle this situation. Finally, you will work through an interactive coding task: removing 'Stephen King' and his books from an `authors_books` dictionary using the `pop()` method, and saving the result in a variable, reinforcing your understanding with hands-on practice. All demonstrations use Python 3.12.4, ensuring compatibility and clarity as you master Python dictionaries.

-- video metadata (use this info when making a video) --

Cut all examples of code to a minimum. Show only the essential code. Show code no longer than 10 lines. Remove all possible pieces to demonstrate some code feature. You may show not full code that will not start, but still demonstrates some feature theoritacally.
If code is longer than 8 lines, move code output  blocks to second column.

De methode `pop()` in Python-dictionaries maakt het mogelijk om een sleutel-waarde-paar te verwijderen op basis van de sleutel en geeft de bijbehorende waarde terug. Deze methode is vooral handig wanneer je een waarde wilt ophalen en verwerken terwijl je deze tegelijkertijd uit de dictionary verwijdert.

De syntaxis is:

```python
dictionary.pop(key)
```

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

# Remove the 'copies' key and retrieve its value
removed_copies = book.pop("copies")

print("Updated dictionary:", book)
print("Removed value:", removed_copies)

Als de sleutel niet bestaat in de dictionary, geeft Python een `KeyError`-foutmelding.

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

# Attempting to remove a non-existent key
removed_genre = book.pop("genre")

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_kings_books_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'kings_books'),
            "The variable `kings_books` is declared.",
            "Expected `kings_books` to be declared."
        )

    def test_kings_books_is_list(self):
        import user_code
        _dynamic_test(
            self,
            isinstance(user_code.kings_books, list),
            "The `kings_books` is of type `list`.",
            "Expected `kings_books` to be of type `list`."
        )

    def test_kings_books_contains_correct_titles(self):
        import user_code
        expected_books = ['It', 'The Shining', 'Carrie', 'Misery']
        _dynamic_test(
            self,
            set(user_code.kings_books) == set(expected_books),
            "The `kings_books` list contains the correct books.",
            f"Expected `kings_books` to contain {expected_books}, but got {user_code.kings_books}."
        )

    def test_stephen_king_removed_from_authors_books(self):
        import user_code
        _dynamic_test(
            self,
            'Stephen King' not in user_code.authors_books,
            "The key `Stephen King` is successfully removed from `authors_books`.",
            "Expected `Stephen King` to be removed from `authors_books`."
        )

    def test_other_authors_exist(self):
        import user_code
        expected_authors = {
            'William Shakespeare', 'J.K. Rowling', 'George Orwell', 'Agatha Christie'
        }
        _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_pop_method_used(self):
        with open('user_code.py', 'r') as file:
            user_code_source = file.read()
        _dynamic_test(
            self,
            "pop" in user_code_source,
            "The `pop()` method is used.",
            "Expected the `pop()` method to be used."
        )

if __name__ == '__main__':
    unittest.main()

test_main.py

Verken de fundamentele datastructuren van de programmeertaal Python, waaronder lijsten, woordenboeken, tuples en sets, en ontdek hoe deze effectief kunnen worden toegepast om praktische programmeeruitdagingen op te lossen.

Wat is een lijst? Een lijst is een geordende collectie die kan worden aangepast. Het staat ook dubbele elementen toe.

Wat is een dictionary? Een dictionary is een geordende, wijzigbare collectie die geen dubbele items toestaat. Het bestaat uit sleutel:waarde-paren, die worden gebruikt om de structuur te optimaliseren.

Wat is een tuple? Een tuple is een geordende verzameling die niet kan worden gewijzigd. Een tuple kan dubbele elementen bevatten. Hoewel het lijkt op een lijst, kunnen de waarden in een tuple van elk type zijn en worden ze geïndexeerd door gehele getallen. Hoewel het niet verplicht is, is het gebruikelijk om de waarden van een tuple tussen haakjes te plaatsen, waardoor ze in Python gemakkelijker te begrijpen zijn.

Wat is een set? In Python is een set een ongeordende verzameling die zowel itereerbaar als muteerbaar is, zonder herhaalde elementen. Hoewel de volgorde van items in een set niet vastligt, kan deze verschillende elementen bevatten. Een belangrijk voordeel van het gebruik van sets ten opzichte van lijsten is de zeer efficiënte methode om te bepalen of een element zich in de set bevindt.

Elementen Verwijderen met Retourwaarden

Oplossing