Summary  
This chapter covers how to retrieve all keys from a dictionary, iterate through those keys, and check whether a specific key exists using the `keys()` method and the `in` keyword.

General domain of usage  
Library catalog management

Pour accéder aux clés d'un dictionnaire en Python, vous pouvez utiliser la méthode `keys()`. Celle-ci retourne un objet vue qui affiche 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(key)

### Vérification de l'existence d'une clé
Utilisation du 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."
        )

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

    def test_keys_contains_correct_values(self):
        import user_code
        expected_keys = list(user_code.authors_books.keys())
        _dynamic_test(
            self,
            set(user_code.keys) == set(expected_keys),
            "The `keys` list contains the correct author names.",
            f"Expected `keys` to contain {expected_keys}, but got {user_code.keys}."
        )

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

    def test_all_books_variable_is_list(self):
        import user_code
        _dynamic_test(
            self,
            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
        expected_books = [book for books in user_code.authors_books.values() for book in books]
        _dynamic_test(
            self,
            set(user_code.all_books) == set(expected_books),
            "The `all_books` list contains all book titles.",
            f"Expected `all_books` to contain {expected_books}, but got {user_code.all_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 problèmes de programmation concrets.

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

Qu'est-ce qu'un dictionnaire ? Un dictionnaire est une collection ordonnée qui peut être modifiée, mais qui n'autorise pas les entrées en double. Il se compose de paires `key:value`, qui sont 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 avoir des éléments en double. Bien qu'il soit similaire à une liste, les valeurs dans un tuple peuvent être de n'importe quel type et sont indexées par des entiers. Bien que non obligatoire, il est courant d'enfermer les valeurs d'un tuple entre parenthèses, ce qui les rend plus faciles à comprendre en Python.

Qu'est-ce qu'un ensemble ? En Python, un `set` est une collection non ordonnée qui est à la fois `iterable` 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