Feuille 2 : Les listes

Dans cette feuille d’exercice, on utilise indifféremment le mot « tableau » ou le mot « liste » car, en python, les tableaux sont appelés des listes.

Exercice 1 : Nombre d’occurrences d’une valeur dans une liste

Écrire une fonction occurrences(v, li) qui renvoie le nombre d’occurrences de la valeur v dans la liste li, c'est-à-dire le nombre de fois que la valeur v apparait dans la liste. On proposera deux versions, l'une avec un parcours par valeurs, l'autre avec un parcours par indices.

Afficher la correction

Version avec un parcours de liste par indices :

def occurences(v, li):
nb_occ = 0
for i in range(len(li)):
    if li[i] == v:
        nb_occ = nb_occ + 1
return nb_occ

# Programme principal pour tester la fonction
li = [4,8,6,9,8,7]
print(occurences(8,li) == 2)
print(occurences(5,li) == 0)

Version avec un parcours de liste par valeurs :

def occurences(v, li):
nb_occ = 0
for val in li:
    if val == v:
        nb_occ = nb_occ + 1
return nb_occ

# Programme principal pour tester la fonction
li = [4,8,6,9,8,7]
print(occurences(8,li) == 2)
print(occurences(5,li) == 0)

Exercice 2 : Somme des éléments d’une liste

Écrire une fonction sum_liste(...) qui prend une liste de nombres en paramètre et renvoie la somme de ces nombres.

Afficher la correction

Version avec un parcours de liste par valeurs :

def somme_liste(li):
s = 0
for val in li:
    s = s + val
return s

# Programme principal pour tester la fonction
print(somme_liste([1,2,3,4]) == 10)
print(somme_liste([]) == 0)

Exercice 3 : Plus grande valeur d’une liste de nombres aléatoires

1) Écrire une fonction liste_nb_aleat() qui construit une liste de 20 entiers entre 0 et 99 et la renvoie.

2) Écrire une fonction max_liste(li) qui renvoie la plus grande valeur de la liste li.

3) Écrire le programme qui permet de tester ces deux fonctions.

Afficher la correction

from random import randint
def liste_20_aleat():
    """
    Renvoie une liste de 20 nombres aléatoires compris entre 0 et 99
    """
    l = []
    for _ in range(20):
        l.append(randint(0,99))
    return l

def max_liste(li):
    """
    Renvoie la plus grande valeur d'une liste non vide.
    """
    val_max = li[0]
    for val in li:
        if val > val_max:
            val_max = val
    return val_max

# Programme principal pour tester les fonctions
liste1 = liste_20_aleat()
print(liste1)
print(max_liste(liste1))

Exercice 4 : Dé à six faces

1) Écrire une fonction qui simule un dé à six faces, c’est-à-dire qui renvoie un nombre entier entre 1 et 6.

2) Écrire une fonction qui réalise 600 tirages d’un dé et renvoie dans une liste de longueur 6 le nombre de fois que chaque valeur a été tirée.

3) Écrire le programme principal qui affiche proprement le résultat.

Afficher la correction

from random import randint

def de6():
    """
    Renvoie un nombre entier aléatoire entre 1 et 6
    """
    return randint(1,6)

def liste_resultats_600_tirages():
    """
    """
    resultat = [0, 0, 0, 0, 0, 0]
    for _ in range(600):
        val = de6()
        resultat[val-1] = resultat[val-1] + 1
    return resultat

# Programme principal
liste_resultats = liste_resultats_600_tirages()
for i in range(6):
    print("La face " + str(i+1) + " a été tirée " + str(liste_resultats[i]) + " fois.")

Exercice 5 : Échange de deux éléments d’une liste

Écrire une fonction echange(li, i, j) qui échange dans la liste li les éléments qui sont aux indices i et j. Cette fonction ne renverra rien, mais aura un effet de bord sur le paramètre li.

Afficher la correction

def echange(li, i, j):
    """
    Echange deux éléments d'une liste
    Paramètres:
        li (list) : liste non vide
        i (int) : position du premier élément à échanger (i doit être plus petit que la longueur de la liste)
        j (int) : position du deuxième élément à échanger (j doit être plus petit que la longueur de la liste)
    Return:
        None
    Effet de bord:
        Le paramètre li est modifié.
    """
    temporaire = li[i]
    li[i] = li[j]
    li[j] = temporaire

# programme principal pour tester la fonction
liste = ["a", "b", "c", "d"]
print(liste)
echange(liste, 0, 1)
print(liste)

Exercice 6 (*) : Mélange des éléments d’une liste

Pour mélanger les éléments d’une liste, il existe une méthode très simple : on parcourt la liste et on échange chaque élément d’indice i (en commençant à 1) avec un élément d’indice j compris en 0 et i (inclus) tiré aléatoirement.

Remarque : cet algorithme donne toutes les permutations avec la même probabilité.

Histoire : cet algorithme a été proposé par Fisher et Yates en 1938.

1) Écrire la fonction melange(li).

2) Écrire une fonction liste_entiers(n) qui renvoie la liste des entiers de 0 à n-1.

3) Écrire le programme principal qui permet de « visualiser » le mélange en utilisant la fonction liste_entiers.

Afficher la correction

from random import randint

def melange(li:list):
    """
    Mélange les éléments d'une liste.
    Cette fonction a un effet de bord sur la liste passée en paramètre.
    """
    # Parcours de la liste
    for i in range(1, len(li)):
        # Tirage de la deuxième position pour l'échange
        j = randint(0, i)
        # Echange des valeurs en i et en j
        tempo = li[i]
        li[i] = li[j]
        li[j] = tempo

def liste_entiers(n):
    """
    Renvoie la liste des entiers de 0 à n.
    """
    liste = []
    for i in range(n):
        liste.append(i)
    return liste

# Programme principal pour tester les fonction
liste_0 = liste_entiers(0)
liste_1 = liste_entiers(1)
liste_5 = liste_entiers(5)
print(liste_0)
print(liste_1)
print(liste_5)
melange(liste_0)
melange(liste_1)
melange(liste_5)
print(liste_0)
print(liste_1)
print(liste_5)

Exercice 7 (*) : Suppression des doublons d’une liste

Écrire une fonction sans_doublons(liste:list) qui renvoie une nouvelle liste identique à celle passée en paramètre, mais sans les doublons.

On rappelle l’existence de l’opérateur d’appartenance in qui permet de tester la présence ou non d’un élément dans une liste.

Exemple : sans_doublons([1, 2, 2, 1, 3, 2, 1]) doit renvoyer [1, 2, 3].

Afficher la correction

def sans_doublons(li):
    """
    Renvoie une nouvelle liste qui contient les mêmes élément que la liste passée en paramètre, mais sans doublons.
    """
    liste_sans_doublons = []
    for val in li:
        if val not in liste_sans_doublons:
            liste_sans_doublons.append(val)
    return liste_sans_doublons

# Programme principal pour tester la fonction
print(sans_doublons([]) == [])
print(sans_doublons([1]) == [1])
print(sans_doublons([5,5,5]) == [5])
print(sans_doublons([1,2,3]) == [1,2,3])
print(sans_doublons([1,1,2,2,3,3]) == [1,2,3])

Exercice 8 (*) : Créer une liste avec les éléments de l’utilisateur

Écrire une fonction creer_liste() qui demande à l’utilisateur d’entrer des nombres entiers positifs jusqu’à ce que l’utilisateur entre la valeur 0. L’ensemble des nombres entrés par l’utilisateur seront placés dans une liste et la liste sera renvoyée par la fonction.

Afficher la correction

def creer_liste():
    val = -1
    liste = []
    while val != 0:
        val = int(input("Entrer un nombre entier positif à ajouter à la liste (0 pour terminer) : "))
        if val != 0:
            liste.append(val)
    return liste

# Programme principal pour tester la fonction
li = creer_liste()
print(li)