Les comprehensions en Python

Pourquoi comprehensions en Python ?

Les listes, dictionnaires et ensembles sont des structures de données courantes dans la programmation Python. Les compréhensions en Python offrent une façon concise et lisible de créer ces structures à partir de séquences existantes. Elles permettent de transformer, filtrer et manipuler les données de manière élégante.

Un cas d'usage concret : imaginez que vous ayez une liste de nombres et que vous voulez obtenir une nouvelle liste contenant uniquement les nombres pairs. Aujourd'hui, vous pourriez utiliser une boucle for et une condition if pour le faire. Avec une compréhension en listes, cela pourrait être fait en une seule ligne de code.

Prerequis

Pour suivre ce tutoriel, il est nécessaire d'avoir les connaissances suivantes :

• Comprendre les structures de données : listes, dictionnaires et ensembles.
• Savoir utiliser des boucles for et if.
• Connaître les opérateurs de base en Python.

Vous n'avez pas besoin d'installer quoi que ce soit car vous travaillez directement avec le code Python.

Concepts fondamentaux

Compréhension en Liste

Une compréhension en liste est une structure qui permet de créer une nouvelle liste en itérant sur un itérable et appliquant une expression à chaque élément. La syntaxe générale est la suivante :

[expression for item in iterable if condition]

• expression : l'expression à évaluer pour chaque élément.
• item : le nom de la variable qui représente chaque élément de l'itérable.
• iterable : une séquence, un itérable ou tout autre objet itérable en Python.
• condition (optionnel) : une condition qui doit être vraie pour que l'élément soit inclus dans le résultat.

Exemple :

carrés_pairs = [x**2 for x in range(1, 11) if x % 2 == 0]
print(carrés_pairs)  # Output: [4, 16, 36, 64, 100]

Compréhension en Dictionnaire

Une compréhension en dictionnaire est similaire à une compréhension en liste, mais elle crée un dictionnaire. La syntaxe générale est la suivante :

{key_expression: value_expression for item in iterable if condition}

• key_expression : l'expression pour le clé du dictionnaire.
• value_expression : l'expression pour la valeur du dictionnaire.
• item : le nom de la variable qui représente chaque élément de l'itérable.
• iterable : une séquence, un itérable ou tout autre objet itérable en Python.
• condition (optionnel) : une condition qui doit être vraie pour que l'élément soit inclus dans le résultat.

Exemple :

carrés = {x: x**2 for x in range(1, 6)}
print(carrés)  # Output: {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

Compréhension en Ensemble

Une compréhension en ensemble est similaire à une compréhension en liste ou en dictionnaire, mais elle crée un ensemble. La syntaxe générale est la suivante :

{expression for item in iterable if condition}

• expression : l'expression à évaluer pour chaque élément.
• item : le nom de la variable qui représente chaque élément de l'itérable.
• iterable : une séquence, un itérable ou tout autre objet itérable en Python.
• condition (optionnel) : une condition qui doit être vraie pour que l'élément soit inclus dans le résultat.

Exemple :

carrés_pairs = {x**2 for x in range(1, 11) if x % 2 == 0}
print(carrés_pairs)  # Output: {4, 64, 36, 100, 16}

Mise en pratique : projet fil rouge

Nous allons construire un petit outil CLI pour gérer des tâches. L'outil permettra d'ajouter des tâches, de les lister et de marquer certaines comme terminées.

Étape 1 : Création du fichier principal

Créer un fichier nommé todo.py :

touch todo.py

Ajoutez le code suivant dans todo.py :

tâches = []

def ajouter_tâche(tâche):
    """Ajouter une nouvelle tâche à la liste."""
    tâches.append(tâche)
    print(f"Tâche ajoutée : {tâche}")

def lister_tâches():
    """Lister toutes les tâches."""
    if not tâches:
        print("Aucune tâche enregistrée.")
    else:
        print("Liste des tâches :")
        for i, t in enumerate(tâches, 1):
            print(f"{i}. {t}")

def marquer_tâche_complétée(num_tâche):
    """Marquer une tâche comme complétée."""
    if num_tâche < 1 or num_tâche > len(tâches):
        print("Numéro de tâche invalide.")
    else:
        tâche = tâches[num_tâche - 1]
        tâches[num_tâche - 1] += " (COMPLÉTÉ)"
        print(f"Tâche {num_tâche} marquée comme complétée.")

def afficher_menu():
    """Afficher le menu."""
    while True:
        print("\nMenu:")
        print("1. Ajouter une tâche")
        print("2. Lister les tâches")
        print("3. Marquer une tâche comme complétée")
        print("4. Quitter")
        
        choix = input("Entrez votre choix : ")
        
        if choix == '1':
            tâche = input("Ajoutez une nouvelle tâche : ")
            ajouter_tâche(tâche)
        elif choix == '2':
            lister_tâches()
        elif choix == '3':
            num_tâche = int(input("Numéro de la tâche à marquer comme complétée : "))
            marquer_tâche_complétée(num_tâche)
        elif choix == '4':
            print("Au revoir !")
            break
        else:
            print("Choix invalide. Veuillez entrer un numéro valide.")

if __name__ == "__main__":
    afficher_menu()

Étape 2 : Exécution du programme

Exécutez le fichier todo.py avec Python :

python todo.py

Vous devriez voir le menu principal s'afficher et vous permettre d'ajouter, de lister et de marquer des tâches comme complétées.

Erreurs frequentes et debugging

1. Erreur : NameError lors de l'utilisation d'une variable non définie

Code incorrect :

carrés_pairs = [x**2 for x in range(1, 11) if y % 2 == 0]

Code correct :

carrés_pairs = [x**2 for x in range(1, 11) if x % 2 == 0]

2. Erreur : IndexError lors d'essayer d'accéder à un index invalide

Code incorrect :

tâches = ["Acheter du pain", "Faire la lessive"]
marquer_tâche_complétée(3)

Code correct :

tâches = ["Acheter du pain", "Faire la lessive"]
marquer_tâche_complétée(1)

3. Erreur : SyntaxError lors d'une compréhension en set qui manque de deux-points

Code incorrect :

carrés_pairs = {x**2 for x in range(1, 11) if x % 2 == 0

Code correct :

carrés_pairs = {x**2 for x in range(1, 11) if x % 2 == 0}

Pour aller plus loin

Piste 1 : Compréhensions imbriquées

Explorez la façon de créer des structures complexes à partir de séquences imbriquées. Par exemple, créez une liste de tuples contenant les nombres de 1 à 5 et leurs carrés.

tuples_carrés = [(x, x**2) for x in range(1, 6)]

Piste 2 : Compréhensions avec des fonctions

Utilisez des compréhensions en listes pour générer une liste de nombres aléatoires et appliquer une fonction à chaque élément.

import random

nombres = [random.randint(1, 100) for _ in range(10)]
carrés = [x**2 for x in nombres]

Piste 3 : Compréhensions en dictionnaire avec des clés dynamiques

Créez un dictionnaire où les clés sont les lettres de l'alphabet et les valeurs sont les indices de ces lettres dans la chaîne "Python".

alphabet = "Python"
dico_alphabet = {letter: index for index, letter in enumerate(alphabet)}

Défi pratique : Mini-projet - Gestionnaire de contacts

Créez un gestionnaire de contacts qui permet d'ajouter des contacts, de les lister et de rechercher un contact par nom. Utilisez des compréhensions en listes pour simplifier le code.

Structure du projet :

• contacts.py : Contient la classe GestionnaireContacts.
• main.py : Point d'entrée du programme où vous testerez les fonctionnalités.

Code pour contacts.py :

class GestionnaireContacts:
    def __init__(self):
        self.contacts = []

    def ajouter_contact(self, nom, numéro):
        contact = {"nom": nom, "numéro": numéro}
        self.contacts.append(contact)
        print(f"Contact {nom} ajouté.")

    def lister_contacts(self):
        if not self.contacts:
            print("Aucun contact enregistré.")
        else:
            for contact in self.contacts:
                print(f"{contact['nom']}: {contact['numéro']}")

    def rechercher_contact(self, nom_recherche):
        contacts_trouvés = [contact for contact in self.contacts if contact["nom"].lower() == nom_recherche.lower()]
        if not contacts_trouvés:
            print("Aucun contact trouvé.")
        else:
            for contact in contacts_trouvés:
                print(f"{contact['nom']}: {contact['numéro']}")

if __name__ == "__main__":
    pass

Code pour main.py :

from contacts import GestionnaireContacts

gestionnaire = GestionnaireContacts()

while True:
    print("\nMenu:")
    print("1. Ajouter un contact")
    print("2. Lister les contacts")
    print("3. Rechercher un contact")
    print("4. Quitter")
    
    choix = input("Entrez votre choix : ")
    
    if choix == '1':
        nom = input("Nom du contact : ")
        numéro = input("Numéro de téléphone : ")
        gestionnaire.ajouter_contact(nom, numéro)
    elif choix == '2':
        gestionnaire.lister_contacts()
    elif choix == '3':
        nom_recherche = input("Rechercher contact par nom : ")
        gestionnaire.rechercher_contact(nom_recherche)
    elif choix == '4':
        print("Au revoir !")
        break
    else:
        print("Choix invalide. Veuillez entrer un numéro valide.")

En suivant ces étapes, vous aurez créé un mini-projet complet en utilisant des compréhensions en listes et d'autres concepts de Python.