Summary  
This chapter explains how to use a dictionary’s keys() method to retrieve all keys, iterate through them with a for loop, and check for a specific key’s existence using the in keyword.

General domain of usage  
Structured data processing

In this video, you will learn how to access dictionary keys in Python. Discover how the `keys()` method works to retrieve all keys from a dictionary as a view object. See how to iterate through dictionary keys using a `for` loop, and how to check if a specific key exists in the dictionary with the `in` keyword.

Key points covered:

- Using `keys()` to get all keys from a dictionary;
- Iterating through keys with a `for` loop;
- Checking for the existence of a key using `in`;
- Practical code examples:

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

# Access all keys
dict_keys_obj = book.keys()
print(dict_keys_obj)  # Output: dict_keys(['title', 'author', 'year', 'genre'])

# Iterate through keys
for key in book.keys():
    print(key)

# Check if a key exists
if "author" in book:
    print("The 'author' key exists in the dictionary.")
```

By the end of this video, you will be able to confidently access, iterate, and check for keys in any Python dictionary.

-- 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.

Pour accéder aux clés d'un dictionnaire en Python, il est possible d'utiliser la méthode `keys()`. Celle-ci retourne un objet vue affichant toutes les clés du dictionnaire.

book = {
    "title": "Pride and Prejudice",
    "author": "Jane Austen",
    "year": 1813,
    "genre": "Romance"
}
keys = book.keys()
print(keys)  # Output: dict_keys(['title', 'author', 'year', 'genre'])

### Parcours des clés
Il est possible de parcourir les clés d'un dictionnaire à l'aide d'une boucle `for` :

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

for item in book.keys():
    print(item)

### Vérification de l'existence d'une clé
Utiliser le mot-clé `in` pour vérifier si une clé spécifique existe dans le dictionnaire :

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

if "author" in book:
    print("The 'author' key exists in the dictionary.")

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. Please ensure you have a variable named 'authors_books'."
        )

    def test_authors_books_is_dict(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'authors_books') and isinstance(user_code.authors_books, dict),
            "The `authors_books` is of type `dict`.",
            "Expected `authors_books` to be of type `dict`."
        )

    def test_keys_variable_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'keys'),
            "The `keys` variable is declared.",
            "Expected `keys` to be declared. Please ensure you have a variable named 'keys'."
        )

    def test_keys_contains_correct_values(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'authors_books') and hasattr(user_code, 'keys'),
            "Both `authors_books` and `keys` are present.",
            "Missing either 'authors_books' or 'keys'. Please check your variable names."
        )
        expected_keys = list(user_code.authors_books.keys())
        # Accept both dict_keys and list types for keys
        user_keys = user_code.keys
        if hasattr(user_keys, '__iter__'):
            user_keys_list = list(user_keys)
        else:
            user_keys_list = []
        _dynamic_test(
            self,
            set(user_keys_list) == set(expected_keys),
            "The `keys` variable contains the correct author names.",
            f"Expected `keys` to contain {expected_keys}, but got {user_keys_list}."
        )

    def test_all_books_variable_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'all_books'),
            "The `all_books` list is declared.",
            "Expected `all_books` to be declared. Please ensure you have a variable named 'all_books'."
        )

    def test_all_books_variable_is_list(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'all_books') and isinstance(user_code.all_books, list),
            "The `all_books` is of type `list`.",
            "Expected `all_books` to be of type `list`."
        )

    def test_all_books_contains_all_titles(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'authors_books') and hasattr(user_code, 'all_books'),
            "Both `authors_books` and `all_books` are present.",
            "Missing either 'authors_books' or 'all_books'. Please check your variable names."
        )
        expected_books = [book for books in user_code.authors_books.values() for book in books]
        actual_books = user_code.all_books if hasattr(user_code, 'all_books') else []
        _dynamic_test(
            self,
            set(actual_books) == set(expected_books),
            "The `all_books` list contains all book titles.",
            f"Expected `all_books` to contain {expected_books}, but got {actual_books}."
        )

    def test_append_method_used(self):
        with open('user_code.py', 'r') as file:
            user_code_source = file.read()
        _dynamic_test(
            self,
            ".append(" in user_code_source,
            "The `append()` method is used for adding books.",
            "Expected the `append()` method to be used to add books."
        )

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

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


test_main.py

Explorez les structures de données fondamentales du langage de programmation Python, y compris les listes, les dictionnaires, les tuples et les ensembles, et découvrez comment les appliquer efficacement pour résoudre des défis de programmation réels.

Qu'est-ce qu'une liste ? Une liste est une collection ordonnée qui peut être modifiée. Elle permet également la présence d'éléments en double.

Qu'est-ce qu'un dictionnaire ? Un dictionnaire est une collection ordonnée et modifiable qui n'autorise pas les doublons. Il se compose de paires clé:valeur, utilisées pour optimiser sa structure.

Qu'est-ce qu'un tuple ? Un tuple est une collection ordonnée qui ne peut pas être modifiée. Il peut contenir des éléments dupliqués. Bien qu'il soit similaire à une liste, les valeurs d'un tuple peuvent être de tout type et sont indexées par des entiers. Bien que cela ne soit pas obligatoire, il est courant d'entourer les valeurs d'un tuple de parenthèses, ce qui les rend plus compréhensibles en Python.

Qu'est-ce qu'un ensemble ? En Python, un ensemble est une collection non ordonnée, à la fois itérable et mutable, sans éléments répétés. Bien que l'ordre des éléments dans un ensemble ne soit pas fixe, il peut inclure une variété d'éléments. Un avantage clé de l'utilisation des ensembles par rapport aux listes est leur méthode très efficace pour déterminer si un élément existe dans l'ensemble.

Accès aux clés du dictionnaire

Parcours des clés

Vérification de l'existence d'une clé

Solution