Listes Python II

Objectifs :

À la fin de cette séquence vous serez capable de :

• Générer une liste en compréhension
• Manipuler des séquences imbriquées

1. Compréhension de liste

L'idée d'une compréhension de liste est de rendre le code plus compact pour accomplir des tâches impliquant des listes.
a. Que référence la variable ages à la fin de l'exécution du programme ci-dessous ?

annees_de_naissance = [1998, 1999, 2000, 1998, 2002, 2003, 2000]
ages = []
for annee in annees_de_naissance:
    ages.append(2024 - annee)

On peut remplacer ces trois instructions par une seule :

ages = [2024 - annee for annee in annees_de_naissance]

On dit alors que la liste ages est définie en compréhension.

b. En utilisant la méthode du a., écrire de manière compacte le programme ci-dessous.

M = []
for k in range(10, 101, 10):
    M.append(k/5)

Que contient la liste M en fin de programme ?

Syntaxe

[expression(element) for element in iterable]

Chaque compréhension de liste nécessite au moins trois composants :

1. expression() est une expression Python qui renvoie une valeur concrète, et la plupart du temps, cette valeur dépend de element.
2. element est l'objet courant de iterable.
3. iterable peut être n'importe quel objet Python itérable, tel qu'une liste, un tuple, une chaîne...

La boucle for itère sur les éléments de iterable, tandis que expression(element) fournit l'élément de liste correspondant qui résulte de l'exécution de la compréhension.
Les compréhensions de liste offrent un moyen concis de créer des listes.

c. Quelle instruction permet de générer en compréhension la liste des cubes des entiers compris entre 1 et 30 ?
d. Quelle liste l’instruction suivante définit-elle ?

N = [x for x in range(101) if x % 3 == 0]

e. En procédant comme en d., écrire l’instruction permettant de générer la liste des diviseurs de 36.

f. On donne :

prenoms = ['CLAUDE','aLice','AMinata','rachid', "ben"]

Écrire, à l'aide d'une compréhension de liste, une instruction qui permet de générer, à partir de prenoms, une liste prenoms_en_majuscules avec tous les prénoms écrits en capital.

2. Les listes imbriquées (listes de listes)

2.1. Définition

Un tableau à plusieurs lignes et plusieurs colonnes est appelé une matrice.
Une matrice peut être représentée en Python par une liste de listes.

Exemples :

Matrice	Modélisation dans le langage Python
3 7 9 2 13 45 4 5 6 Ce tableau est formé de 3 lignes et 3 colonnes. On dit que c’est une matrice carrée d’ordre 3.
3 7 9 2 2 13 45 5 4 5 6 3 Ce tableau est formé de 3 lignes et 4 colonnes : On dit que c’est une matrice (3,4).

2.2.1 Déterminer le nombre de lignes d'une liste de listes

len(matrice2)

2.2.2 Accéder aux éléments d'une liste de listes

a. Quelle est la valeur renvoyée par chacune des instructions suivantes ?

matrice1[1]

matrice1[0][2]

b. Quelle expression permet de récupérer la valeur 4 de matrice2 ?

c. Écrire, à l’aide d’une boucle for un code, en Python, qui permet d’afficher les éléments de la deuxième ligne de matrice2 ?

d. Écrire, à l’aide d’une boucle for, un algorithme puis un code, en Python, qui permet d’afficher les éléments de matrice2.
Écrire, enfin ce code en utilisant une compréhension de liste.

3. Références partagées

a = [1, 2]
b = a # a et b référencent le même objet, [1, 2]
c = a[:] #copie superficielle de la liste a (shallow copy)

a[0] = 20

print(a)
print(b) # effet de bord les changements de b affectent a et vice versa
print(c)

id(a) == id(b)

id(a) == id(c)

id(a[0]) == id(c[0])

a = [1, ["a", "b"], 2]
b = a
c = a[:] # shallow copy

a[1][0] = "nsi"

print(a)
print(b) # effet de bord
print(c)

import copy
a = [1, ["a", "b"], 2]
b = a
c = a[:] #shallow copy
d = copy.deepcopy(a) # copy profonde

a[1][0] = "spam"

print(a)
print(b) # effet de bord
print(c)
print(d)

4. Généralisation : Séquences imbriquées

scores = [("Marie", 100),
          ("Armand", 30),
          ("Martin", 75),
          ("Béatrice", 205)
         ]

1. Écrire une expression qui permet de récupérer le troisième élément de scores.

scores[2]

2. Écrire une expression qui permet de récupérer le score de Béatrice.

scores[3][1]

3. Écrire une expression qui permet de récupérer "b".

s = [("a", 1), [], [2, 3, ["b", "c", "d"]]]

4. Déballage d'une séquence : affectation simultannée

nom, score = ("Marie", 100)

print(nom)

print(score)

a, b = [1, 2]

print(a)

print(b)

c, *d = scores

print(d)

Faites-vous plaisir 1 :

1. Créez une liste contenant les nombres de 1 à 20.
2. Utilisez une compréhension de liste pour créer une nouvelle liste contenant uniquement les nombres pairs.

Faites-vous plaisir 2 :

1. Créez une liste contenant les mots suivants : "python", "java", "c++", "ruby".
2. Utilisez une compréhension de liste pour convertir tous les mots en majuscules.

Faites-vous plaisir 3 :

1. Créez une liste contenant les mots suivants : ["chien", "chat", "souris", "oiseau", "vache", "loup"].
2. Utiliser une compréhension de liste pour créer une nouvelle liste contenant uniquement les mots ayant plus de 4 lettres.

Faites-vous plaisir 4 :

1. Créez une liste contenant les mots suivants : ["chat", "chien", "rat", "lapin", "poisson", "corbeau"].
2. Utiliser une compréhension de liste pour créer une nouvelle liste contenant uniquement les mots qui contiennent la lettre a.

Faites-vous plaisir 5 :

lst_imbriquees = [
    [1, 2, 3], 
    [4, 5, 6], 
    [7, 8, 9]
]

1. Afficher chaque sous-liste.
2. Afficher chaque élément de la matrice.
3. Générer, à l'aide d'une compréhension de liste, à partir de lst_imbriquees, la liste suivante : [1, 2, 3, 4, 5, 6, 7, 8, 9].

lst_imbriquees = [
    [1, 2, 3], 
    [4, 5, 6], 
    [7, 8, 9]
]

lst_aplati_avec_extend = []
for ligne in lst_imbriquees:
    lst_aplati_avec_extend.extend(ligne)

print(lst_aplati)

lst_aplati_par_concat = []
for ligne in lst_imbriquees:
    lst_aplati_par_concat += ligne

print(lst_aplati_par_concat)

lst_par_comprehension = [elt for ligne in lst_imbriquees for elt in ligne]
print(lst_par_comprehension)

Faites-vous plaisir 6 :
Écrire une fonction recherche_doublons qui prend en entrée une liste et renvoie une nouvelle liste contenant les éléments dupliqués (sans doublons). Tester cette fonction avec la liste [1, 2, 2, 3, 4, 4, 5, 6, 6, 6].

Faites-vous plaisir 7 :

1. Créer une liste contenant les tuples suivants : [(1, 2), (3, 4), (5, 6), (7, 8)].
2. Utiliser une compréhension de liste pour créer une nouvelle liste contenant uniquement le premier élément de chaque tuple.

Faites-vous plaisir 8 :
Donner l'affichage de chacun des programmes 1 et 2.

# Programme 1
list_nombres = [1, 2, 3, 4]
lists_nombres_imbriquees = []
for _ in range(4):
    lists_nombres_imbriquees.append(list_nombres)
lists_nombres_imbriquees[1][3] = 10

print(lists_nombres_imbriquees)

# Programme 2
lists_nombres_imbriquees = []
for _ in range(4):
    list_nombres = [1, 2, 3, 4]
    lists_nombres_imbriquees.append(list_nombres)
lists_nombres_imbriquees[1][3] = 10

print(lists_nombres_imbriquees)