Laboratoire listes - solution

Les listes

But du laboratoire

  • Manipuler les listes simples et à deux dimensions.

  • Utilisation du débogueur pour voir le contenu des variables.

Exercice 1 : manipulation de listes - échauffement

Créez une liste contenant les éléments suivants : [71, 55, 30, 42, 25, 68, 15].

À chacune des réponses aux questions suivantes, vous devez stocker le résultat dans une variable ayant un nom significatif. Vous devez également afficher le résultat de manière claire et professionnelle.

  • Vérifiez si l'élément d’indice 2 de la liste est divisible par 5.

  • Vérifiez si le dernier élément de la liste est pair.

  • Vérifiez si l’élément 55 de la liste est impair.

  • Incrémentez de 100 le premier élément de la liste (à la position 0).

  • Échangez (permutez) les positions des valeurs 30 et 68 dans la liste.

  • Triez la liste par ordre croissant.

  • Inversez la liste. Voici deux façons d’inverser une liste, testez-les sur la console Python pour comprendre leur fonctionnement et choisissez celle qui vous convient :

    • liste_inversee = liste[::-1] --> Cette méthode retourne la liste inversée.

    • liste.reverse() --> Cette méthode inverse la liste elle même.

  • Utilisez la méthode liste.index(element) pour trouver l’indice de l’élément 68.

  • Divisez la liste en deux parties pour créer deux listes distinctes.

Exercice 2 : calcul moyenne

Écrire un programme en Python qui demande à l’utilisateur de saisir quatre notes d’examens d’un étudiant (en %). Ces notes doivent être stockées dans une liste.

  • Calculez la moyenne des notes d’examen de la liste de deux façons : avec et sans utiliser les fonctions spéciales sum et len sur les listes.

  • Le programme doit afficher le résultat en répondant par vrai ou faux à la question : Est-ce que l’étudiant a une moyenne supérieure à 60% ? Vrai/Faux

Solution
def saisir_notes():
    """
    Demande à l'utilisateur de saisir quatre notes d'examen et les stocke dans une liste.

    Returns:
        list: Une liste contenant les quatre notes d'examens en pourcentage.
    """
    notes = []

    for i in range(4):
        try:
            note = float(input(f"Saisir la note {i + 1} (en %): "))
            if 0 <= note <= 100:
                notes.append(note)
            else:
                print("Erreur: La note doit être comprise entre 0 et 100.")

        except ValueError:
            print("Erreur: Veuillez entrer un nombre valide.")

    return notes


def calculer_moyenne_sum_len(notes: list):
    """
    Calcule la moyenne des notes en utilisant les fonctions sum et len.
    :param notes: Liste des notes d'examen.
    :return: La moyenne des notes.
    """

    return sum(notes) / len(notes)


def calculer_moyenne(notes):
    """
    Calcule la moyenne des notes sans utiliser les fonctions sum et len.
    :param notes: Liste des notes d'examen.
    :return: La moyenne des notes.
    """

    total = 0
    compteur = 0

    for note in notes:
        total += note
        compteur += 1

    return total / compteur


def est_superieure_a_60(moyenne):
    """
    Vérifie si la moyenne est supérieure à 60 %.
    :param moyenne: La moyenne des notes.
    :return: True si la moyenne est supérieure à 60, sinon False.
    """
    
    return moyenne > 60


if __name__ == "__main__":
    notes_examen = saisir_notes()

    moyenne_avec_sum_len = calculer_moyenne_sum_len(notes_examen)
    print(f"Moyenne (avec sum et len): {moyenne_avec_sum_len:.2f}%")

    moyenne_sans_sum_len = calculer_moyenne(notes_examen)
    print(f"Moyenne (sans sum ni len): {moyenne_sans_sum_len:.2f}%")

    resultat = est_superieure_a_60(moyenne_avec_sum_len)
    print(f"Est-ce que l'étudiant a une moyenne supérieure à 60 % ? {resultat}")

Exercice 3 : Palindrome

Définition: Un palindrome est un mot, une phrase, un nombre ou une séquence qui se lit de la même manière de gauche à droite et de droite à gauche.

Exemple : "Un radar nu" se lit de la même manière de gauche à droite et de droite à gauche. C'est cette exemple qui sera utilisé dans votre exercice.

Dans cet exercice, nous allons faire quelques opérations sur une chaîne de caractères "Un radata na." pour la transformer en "un radar nu" qui est un palindrome. Une vérification sera faite à la fin.

Soit la chaîne de caractères suivante :

palindrome = "Un radata na."

Ce qui nous intéresse sont les listes. Il est possible de transformer cette chaîne de caractères en une liste de lettres successives. Faites le comme ceci :

liste_palindrome = list(palindrome)

Appliquez les changements suivantes sur la liste liste_palindrome:

  • Remplacez le premier élément "U" par "u".

  • Remplacez le 8ème élément de la liste par "r".

  • Remplacez le 4ème "a" de la liste par "u".

  • Supprimez le caractère "."

  • Supprimez le 3ème "a" de la liste.

  • Supprimez tous les caractères espaces de la liste.

  • Créez une nouvelle liste appelée liste_palindrome_inversee qui contiendra l’inverse de la liste liste_palindrome.

  • Comparez les deux listes liste_palindrome_inversee et liste_palindrome. Si le résultat est vrai, alors vos opérations sur la liste sont correctes et vous avez vérifié que votre phrase est un palindrome. Affichez le résultat de la comparaison de façon claire.

Exercice 4 : générer des adresses courriels

Avant d’écrire votre programme, pensez à la solution de votre choix et notez les étapes sous forme de commentaires # TODO. Passez ensuite à l’écriture de votre programme en syntaxe Python.

Créez un programme qui demande à l’utilisateur d’entrer trois fois un nom et un prénom que vous devez mettre dans une liste. Il doit également demander le nom de domaine à utiliser pour les trois personnes (par exemple: gmail.com, cegepoutauais.qc.ca, hotmail.com, etc.).

Le programme doit transformer les noms, prénoms et nom de domaine en trois adresses courriel au format suivant :

[prenom].[nom]@[domaine]

Solution
def generer_adresses_courriel(prenoms:list, noms:list, domaine:str):
    """
    Génère des adresses courriel au format [prenom].[nom]@[domaine].
    :param prenoms: Une liste contenant les prénoms.
    :param noms: Une liste contenant les noms.
    :param domaine: Le nom de domaine à utiliser pour les adresses courriel.
    :return: Une liste contenant les adresses courriel générées.
    """

    adresses_courriel = []

    for i in range(len(prenoms)):
        prenom = prenoms[i]
        nom = noms[i]

        email = f"{prenom.lower()}.{nom.lower()}@{domaine}"  # Minuscule et suppression des espaces
        adresses_courriel.append(email)

    return adresses_courriel


if __name__ == "__main__":

    prenoms = []
    noms = []

    for i in range(3):
        prenom = input(f"Entrez le prénom de la personne {i + 1}: ")
        nom = input(f"Entrez le nom de la personne {i + 1}: ")

        # Utilisation de strip() pour enlever les espaces superflus
        noms.append(nom.strip())
        prenoms.append(prenom.strip())

    nom_domaine = input(f"Quel est le nom de domaine à utiliser ? ")

    adresses_courriel = generer_adresses_courriel(prenoms, noms, nom_domaine)

    print("\nAdresses courriel générées :")
    for adresse in adresses_courriel:
        print(adresse)

Exercice 5 : listes à deux dimensions

Soit la liste suivante de noms de technologies suivante :

technologies = ["Python", "JavaScript", "Java", "C++", "C#",
                "MySQL", "PostgreSQL", "MongoDB", "Oracle",
                "HTML", "CSS", "React", "Node.js",
                "Linux", "Windows", "macOS", "iOS", "Android"]

Sachant que :

  • Les éléments aux indices 0 à 4 sont des langages de programmation.

  • Les éléments aux indices 5 à 8 sont des Bases de données.

  • Les éléments aux indices 9 à 12 sont des technologies web.

  • Les éléments aux indices 13 à 17 sont des systèmes d’exploitation.

créez une nouvelle liste contenant des éléments qui sont eux-mêmes des listes. Ces dernières listes sont, respectivement, celles des langages de programmation, des bases de données, des technologies web et des systèmes d’exploitation.

Liste à deux dimensions attendue :

[["Python", "JavaScript", "Java", "C++", "C#"],
["MySQL", "PostgreSQL", "MongoDB", "Oracle"],
["HTML", "CSS", "React", "Node.js"],
["Linux", "Windows", "macOS", "iOS", "Android"]]

Affichez chacune des sous listes de technologies à partir de la liste à deux dimensions (en utilisant des indices).

Résultat attendu :

Les langages de programmation : ["Python", "JavaScript", "Java", "C++", "C#"]
Les bases de données : ["MySQL", "PostgreSQL", "MongoDB", "Oracle"]
Les technologies web : ["HTML", "CSS", "React", "Node.js"]
Les systèmes d'exploitation : ["Linux", "Windows", "macOS", "iOS", "Android"]

Exercice 6

Faites la même chose que l'exercice 5 avec la liste suivante qui est légèrement différente de la précédente. À vous de remarquer les différences.

technologies = ["Langages de programmation", "Python", "JavaScript", "Java", "C++", "C#",
                "Bases de données", "MySQL", "PostgreSQL", "MongoDB", "Oracle",
                "Web", "HTML", "CSS", "React", "Node.js",
                "Systèmes d'exploitation", "Linux", "Windows", "macOS", "iOS", "Android"]
PreviousLes opérations sur les listesNextLes dictionnaires

Last updated