📦 II - Fiche d'exercice : Les tuples et les listes

⚠️ Attention

Tous les exercices, s'ils sont réalisés par des boucles for, doivent être faits avec une boucle sur les indices et une boucle sur les valeurs.

   l = [1,2,3,4]
   # for par valeur:
   for elt in l:
      print(l)

   # for par indice (utilisation de len() qui permet d'avoir la taille d'une séquence):
   for i in range(len(l)):
      print(l[i])

🎯 Exercices d'introduction

Créer un tuple nommé mon_tuple qui contient les éléments 1,2,3,4,5 et une liste ma_liste qui contient les éléments suivants 'a','b','c','d','e'. Les afficher dans le terminal. ⭐

✅ Correction

   mon_tuple = (1,2,3,4,5)
   ma_liste = ['a','b','c','d','e']

Afficher dans le terminal le troisième élément de mon_tupleet le premier élément de ma_liste. ⭐
Modifier le deuxième élément de ma_liste par 'z'.
Vérifier la modification en affichant la liste dans le terminal. ⭐
Ajouter l'élément 'f' dans ma_liste. Supprimer le premier élément de ma_liste.
Vérifier les modifications en affichant la liste dans le terminal. ⭐
Afficher dans le terminal tous les éléments de mon_tuple et ma_liste un à un à l'aide d'une boucle for. ⭐
Créer une liste nombres qui contient les chiffres allant de 1 à 9. (Proposer une version par compréhension). Afficher dans le terminal les 5 premiers éléments de la liste en utilisant une boucle while. Afficher les éléments du quatrième au huitième en utilisant une boucle for.
Afficher les éléments de la liste nombres dans le sens inverse en utilisant une boucle while. ⭐⭐

🌟 Niveau Facile

💻 Somme d'éléments ⭐

Écrire une fonction somme_elements qui prend une liste de nombres en paramètres et renvoie la somme de tous les éléments.
Exemple :
somme_elements([1, 2, 3, 4]) doit renvoyer 10.

✅ Correction

def somme_elements(liste:list)->int:
  somme = 0
  for elt in liste:
     somme = somme + elt
  return somme

Compter les nombres pairs

Écrire une fonction compter_pairs qui prend une liste d'entiers et renvoie le nombre d'éléments pairs dans cette liste.
Exemple :

  >>> compter_pairs([1,2,3,4,5])
  2

✅ Correction

def compter_pairs(liste:list)->int:
    nombre_pairs = 0
    for elt in liste:
        if elt % 2 == 0:
            nombre_pairs = nombre_pairs + 1
    return nombre_pairs

Longueur des chaînes

Écrire une fonction longueur_chaines qui prend une liste de chaînes de caractères et renvoie une liste contenant la longueur de chaque chaîne.
Exemple :

>>> longueur_chaines(["abc", "de", "fghi"])
[3, 2, 4]

✅ Correction

def longueur_chaines(liste:list)->list:
    liste_longueurs = []
    for elt in liste:
        taille_elt = len(elt)
        liste_longueurs.append(taille_elt)
    return liste_longueurs

Produit d'éléments

Écrire une fonction produit_elements qui prend une liste d'entiers et renvoie le produit de tous les éléments. Attention aux cas où la liste est vide.
Exemple :

>>> produit_elements([2, 3, 4])
24
>>> produit_elements([])
1

✅ Correction

def produit_elements(liste:list)->int:
    if not liste:  # si la liste est vide
        return 1
    produit = 1
    for elt in liste:
        produit = produit * elt
    return produit

Compter les occurrences

Écrire une fonction compter_occurrences qui prend une liste et un élément, et renvoie le nombre de fois que cet élément apparaît dans la liste.
Exemple :

>>> compter_occurrences([1, 2, 2, 3, 2], 2)
3

✅ Correction

def compter_occurrences(liste:list, valeur: int)->int:
    occurrences = 0
    for elt in liste:
        if elt == valeur:
            occurrences = occurrences + 1
    return occurrences

Recherche d'un élément : Algorithme à connaître

Écrire une fonction presence qui prend en paramètre une valeur et une liste et renvoie True si la valeur demandée est dans la liste, False sinon.
Exemple :

>>> presence(3, [1, 2, 3, 4])
True
>>> presence(5, [1, 2, 3, 4])
False

Correction

def presence(valeur: int, liste:list)->bool:
    present = False
    for elt in liste:
        if elt == valeur:
            present = True
    return present

Calcul de moyenne

Écrire une fonction moyenne qui prend en paramètre une liste d'entiers et renvoie la moyenne de tous les nombres présents dans cette liste.
Exemple :

>>> moyenne([1, 2, 3, 4, 5])
3.0
>>> moyenne([])
0

✅ Correction

def moyenne(liste:list)->float:
    if not liste:  # si la liste est vide
        return 0
    taille_liste = len(liste)
    somme = 0
    for elt in liste:
        somme = somme + elt
    return somme / taille_liste

Niveau Intermédiaire

Filtrer les nombres positifs

Écrire une fonction filtrer_positifs qui prend une liste de nombres et renvoie une nouvelle liste contenant uniquement les nombres positifs.
Exemple :

>>> filtrer_positifs([-1, 0, 3, -7, 8])
[3, 8]

✅ Correction

def filtrer_positifs(liste:list)->list:
    positifs = []
    for elt in liste:
        if elt > 0:
            positifs.append(elt)
    return positifs

Maximum d'une liste : Algorithme à connaître

Écrire une fonction maximum qui prend une liste d'entiers prévue non vide et renvoie l'entier maximum.
Exemple :

>>> maximum([3, 1, 9, 2])
9

Correction

Comme on ne sait pas la composition de nos listes, pour éviter des soucis, on initialise notre maximum à la première valeur de la liste. Exemple, si l'on met 0 à maximum et que la liste est composée de négatifs, on ne trouvera jamais l'élément maximum.

def maximum(liste:list)->int:
    maxi = liste[0]
    for elt in liste:
        if elt > maxi:
            maxi = elt
    return maxi

Minimum d'une liste : Algorithme à connaître

Écrire une fonction minimum qui prend une liste d'entiers et renvoie l'entier minimum.
Exemple :

>>> minimum([3, 1, 9, 2])
1

Correction

Comme on ne sait pas la composition de nos listes, pour éviter des soucis, on initialise notre minimum à la première valeur de la liste. Exemple, si l'on met une valeur arbitraire et que la liste est composée de nombres supérieurs à celui-ci, on ne trouvera jamais l'élément minimum.

def minimum(liste:list)->int:
    mini = liste[0]
    for elt in liste:
        if elt < mini:
            mini = elt
    return mini

Concaténer des chaînes

Écrire une fonction concatener_chaines qui prend une liste de chaînes de caractères et renvoie une seule chaîne qui est la concaténation de toutes les chaînes de la liste.
Exemple :

>>> concatener_chaines(["Bonjour", " ", "le", " ", "monde"])
"Bonjour le monde"

✅ Correction

def concatener_chaines(liste:list)->str:
    concatenation = ""
    for chaine in liste:
        concatenation = concatenation + chaine
    return concatenation

Inverser une liste

Écrire une fonction inverser_liste qui prend une liste et renvoie une nouvelle liste avec les éléments dans l'ordre inverse.
Exemple :

>>> inverser_liste([1, 2, 3])
[3, 2, 1]

✅ Correction

def inverser_liste(liste:list)->list:
    liste_inversee = []
    for i in range(len(liste)-1, -1, -1):
        liste_inversee.append(liste[i])
    return liste_inversee

Valeurs uniques

Écrire une fonction valeurs_uniques qui prend une liste et renvoie une nouvelle liste contenant les éléments sans doublons (dans l'ordre d'apparition).
Exemple :

>>> valeurs_uniques([1, 2, 2, 3, 4, 4])
[1, 2, 3, 4]

✅ Correction

def valeurs_uniques(liste:list)->list:
    liste_valeurs = []
    for elt in liste:
        if elt not in liste_valeurs:
            liste_valeurs.append(elt)
    return liste_valeurs

Séparer pairs et impairs

Écrire une fonction separer_pairs_impairs qui prend une liste d'entiers et renvoie deux listes : une avec les éléments pairs et une autre avec les éléments impairs. Exemple :

>>> separer_pairs_impairs([1, 2, 3, 4, 5])
([2, 4], [1, 3, 5])

✅ Correction

def separer_pairs_impairs(liste:list)->tuple:
    pairs = []
    impairs = []
    for elt in liste:
        if elt % 2 == 0:
            pairs.append(elt)
        else:
            impairs.append(elt)
    return pairs, impairs

Recherche des diviseurs

Écrire une fonction diviseurs qui prend un entier en paramètre et renvoie la liste de ses diviseurs. Exemple :

>>> diviseurs(6)
[1, 2, 3, 6]
>>> diviseurs(10)
[1, 2, 5, 10]

✅ Correction

def diviseurs(valeur:int)->list:
    diviseurs = []
    for i in range(1, valeur+1):  # On commence à 1 pour éviter la division par 0
        if valeur % i == 0:
            diviseurs.append(i)
    return diviseurs

Liste croissante

Écrire une fonction est_croissante qui prend une liste d'entiers en paramètre et renvoie True si les éléments de la liste sont dans l'ordre croissant, False sinon. Exemple :

>>> est_croissante([1, 2, 3, 4])
True
>>> est_croissante([1, 3, 2, 4])
False

✅ Correction

def est_croissante(liste:list)->bool:
    i = 0
    while i < len(liste) - 1 and liste[i] <= liste[i+1]:
        i = i + 1
    return i == len(liste)-1

Échange de valeurs

Écrire une fonction echange qui prend en paramètres une liste et deux indices, et échange les valeurs aux positions i et j dans la liste passée en paramètres. Exemple :

>>> liste1 = [1, 2, 3, 4]
>>> echange(liste1, 1, 2)
>>> liste1
[1, 3, 2, 4]
>>> liste2 = [5, 10, 15]
>>> echange(liste2, 0, 2)
>>> liste2
[15, 10, 5]

✅ Correction

#1ère solution : passer par une troisième valeur
def echange(liste:list, i:int, j:int)->None:
    temp = liste[i]
    liste[i] = liste[j]
    liste[j] = temp

#2e solution : solution Python-esque
def echange(liste:list, i:int, j:int)->None:
    liste[i], liste[j] = liste[j], liste[i]

Rangement de valeurs

Écrire une fonction rangement_valeurs qui prend en paramètre une liste et un élément, et renvoie 3 listes : une liste contenant les valeurs inférieures à l'élément, une liste avec l'élément si présent, et une liste avec les valeurs supérieures.
Exemple :

>>> rangement_valeurs([1, 7, 4, 3, 6, 2, 8], 5)
([1, 4, 3, 2], [], [7, 6, 8])
>>> rangement_valeurs([1, 2, 4, 3, 6, 2, 8], 2)
([1], [2, 2], [4, 3, 6, 8])

✅ Correction

def rangement_valeurs(liste:list, valeur:int)->tuple[list, list, list]:
    inferieures = []
    egales = []
    superieures = []
    for elt in liste:
        if elt > valeur:
            superieures.append(elt)
        elif elt == valeur:
            egales.append(elt)
        else:
            inferieures.append(elt)
    return inferieures, egales, superieures

Niveau Difficile

Compteur de voyelles

Écrire une fonction compter_voyelles qui prend une liste de chaînes de caractères et renvoie le nombre total de voyelles présentes dans toutes les chaînes.
Exemple :

>>> compter_voyelles(["chat", "chien"])
3
>>> compter_voyelles(["bonjour", "python"])
4

✅ Correction

def compter_voyelles(liste:list)->int:
    voyelles = "aeiouyAEIOUY"
    nombre_voyelles = 0
    for mot in liste:
        for lettre in mot:
            if lettre in voyelles:
                nombre_voyelles += 1
    return nombre_voyelles

Éléments en double

Écrire une fonction valeurs_en_double qui prend une liste et renvoie une nouvelle liste contenant uniquement les éléments qui apparaissent plus d'une fois (sans répétitions supplémentaires).
Exemple :

>>> valeurs_en_double([1, 2, 2, 3, 4, 4, 5])
[2, 4]
>>> valeurs_en_double(["a", "b", "a", "c", "b", "d"])
["a", "b"]

✅ Correction

def valeurs_en_double(liste:list)->list:
    doublons = []
    deja_vus = []
    for elt in liste:
        if elt in deja_vus and elt not in doublons:
            doublons.append(elt)
        else:
            deja_vus.append(elt)
    return doublons

Recherche d'indice

Écrire une fonction indice_element qui prend une liste et un élément, et renvoie l'indice de la première occurrence de cet élément dans la liste, ou -1 s'il n'est pas présent.
Exemple :

>>> indice_element([10, 20, 30], 20)
1
>>> indice_element([10, 20, 30], 40)
-1

✅ Correction

def indice_element(liste:list, valeur:int)->int:
    i = 0
    while i < len(liste) and liste[i] != valeur:
        i += 1
    if i == len(liste):
        return -1
    return i

Fusion sans doublons

Écrire une fonction fusionner_sans_doublons qui prend en paramètres deux listes et renvoie une nouvelle liste contenant tous les éléments des deux listes sans doublons.
Exemple :

>>> fusionner_sans_doublons([1, 2, 3], [2, 3, 4])
[1, 2, 3, 4]
>>> fusionner_sans_doublons(['a', 'b'], ['b', 'c', 'a'])
['a', 'b', 'c']

✅ Correction

def fusionner_sans_doublons(liste1:list, liste2:list)->list:
    resultat = []
    # On ajoute les éléments de la première liste
    for elt in liste1:
        if elt not in resultat:
            resultat.append(elt)
    # On ajoute les éléments de la deuxième liste
    for elt in liste2:
        if elt not in resultat:
            resultat.append(elt)
    return resultat