❖ Les listes : création et parcours

♦ Parcourir une liste

Reprenons l'exemple de notre liste de courses :

In [1]:
courses=['oignons','huile','sel','chips','orange']

On rappelle que cette liste peut être représenté par le schéma suivant : liste_courses.png

Supposons qu'on veuille afficher les éléments de cette liste, il s'agit donc :

  • de parcourir la liste élément par élément
  • d'effectuer un traitement sur chaque élément, ici un simple affichage

Parcours par indice

Une première façon de faire et de parcourir les indices des éléments de la liste (deuxième ligne du schéma ci-dessus), et de retrouver les éléments par leur indice. Les indices allant de 0 à 4, un range(5) suffit. On remarque que 5 est justement la longueur de la liste et que cela permet de généraliser un parcourt par indice pour n'importe quelle taille de liste :

In [2]:
# Parcours de la liste par indice, affichage des éléments :
for indice in range(len(courses)):
    print(courses[indice])

oignons
huile
sel
chips
orange

Détaillons le programme ci-dessus :

  • courses est de longueur 5
  • indice prend donc les valeurs 0, 1, 2, 3 et 4 (on rappelle que la dernière valeur est exclue).
  • course[indice] va donc prendre successivement les valeurs course[0] (donc "oignons"), course[1] (donc "huile"), ...
  • print permet de produire l'affichage souhaité

Parcours par élément

On peut aussi parcourir la liste directement par ses éléments, c'est à dire en créant une variable qui prendra successivement chaque élement de la liste pour valeur (on est sur la ligne des éléments sur le schéma ci-dessus). On fait toujours une boucle for mais cette fois, il n'y a pas d'instruction range et c'est directement le nom de la liste qui suit le in :

In [3]:
### Parcours de la liste par élement, affichage de éléments :
for element in courses:
    print(element)

oignons
huile
sel
chips
orange

Détaillons le programme ci-dessus :

  • element prend successivement les valeurs présentes dans la liste
  • print permet de produire l'affichage souhaité
⚡ A retenir :
    • On peut parcourir une liste par indice. Dans ce cas, on crée une boucle for avec la syntaxe habituel, le range allant de 0 à la longueur de la liste. Et on utilise la notation avec les crochets pour accéder aux élements : liste[indice]
    • On peut parcourir une liste par élément, la syntaxe de la boucle for est alors : for element in liste :. La variable element prendra alors successivement chaque valeur contenu dans la liste.

✎ Exercices

  1. Créer la liste des sept jours de la semaine.
  2. Ecrire un parcours par indice de cette liste permettant d'afficher chaque jour de la semaine
  3. Même question avec un parcours par élément
In [4]:
# Votre réponses ici
# Question 1
semaine = ["Lundi", "Mardi", "Mercredi", "Jeudi", "Vendredi", "Samedi", "Dimanche"]

# Question 2
for indice in range(len(semaine)):
    print(semaine[indice])

print()
# Question 2
for jour in semaine:
    print(jour)

Lundi
Mardi
Mercredi
Jeudi
Vendredi
Samedi
Dimanche

Lundi
Mardi
Mercredi
Jeudi
Vendredi
Samedi
Dimanche

♦ Traitement lors du parcours

Dans les exemples précédents, nous avons simplement affiché les éléments de la liste, on peut effectuer bien sur d'autres types de traitement sur les éléments de la liste. Par exemple supposons qu'on dispose d'une liste de nombres :

In [5]:
nombres = [12, 9, 18, 11]

On veut calculer la somme des éléments de cette liste, et on suppose que les éléments sont pris un à un successivement, c'est à dire qu'on aura d'abord la valeur 12, puis le 9, puis le 18 et ainsi de suite ... Pour effectuer ce calcul mentalement, probablement qu'on mettra en mémoire le premier nombre, puis dès qu'on aura le second on l'ajoutera à la valeur en mémoire et ainsi de suite jusqu'à la fin c'est à dire qu'on a deux phases :

  1. on a aucun nombre donc la somme vaut pour le moment 0 somme = 0, c'est l'initialisation
  2. on prend successivement chaque nombre et on l'ajoute à la somme, c'est le parcours
    • on prend le 12 donc on l'ajoute à la somme en mémoire : somme=0 somme = 0 + 12 = 12
    • on prend le 9 donc on l'ajoute à la somme en mémoire : somme=12 somme = 12 + 9 = 21
    • on prend le 18 donc on l'ajoute à la somme en mémoire : somme=21 somme = 21 + 18 = 39
    • on prend le 11 donc on l'ajouteà la somme en mémoire : somme=39 somme = 39 + 11 = 50

C'est ainsi que procède Python dans le programme suivant, observer bien que somme = somme + nombres[indice] permet de remplacer l'ancienne valeur de sommepar la nouvelle

In [6]:
# Parcours de la liste nombres par indice et ajout dans somme
somme = 0
for indice in range(len(nombres)):
    somme = somme + nombres[indice]
In [7]:
#Vérifions que la somme est bien calculée :
somme
Out[7]:
50

Même programme mais avec un parcours par élément :

In [8]:
# Parcours de la liste nombres par élement et ajout dans somme
somme = 0
for nb in nombres:
    somme = somme + nb
In [9]:
# Verifions qu'on obtient bien la même somme :
somme
Out[9]:
50
⚡ A retenir :
  • Le parcours d'une liste est à la base de nombreux algorithmes que nous verrons cette année.
  • En effet, lors du parcours on peut effectuer un traitement sur les éléments rencontrés

✎ Exercices

  1. Créer la liste de nombres suivants : 15, 1, 22, 10, 19, 4, 13, 17, 12, 16, 28
  2. Ecrire un parcours par indice permettant d'afficher tous les nombres plus petits ou égaux à 10.
  3. Même question avec un parcours par élément
In [10]:
# Votre réponse ici
nombres = [15, 1, 22, 10, 19, 4, 13, 17, 12, 16, 28]

# question 5
for indice in range(len(nombres)):
    if nombres[indice] <= 10:
        print(nombres[indice])
    
print()

# question 5
for nb in nombres:
    if nb<= 10:
        print(nb)

print()
# autre chose
liste = []
for nb in nombres:
    if nb<= 10:
        liste.append(nb)
print(liste)
        

1
10
4

1
10
4

[1, 10, 4]

♦ Chaîne de caractères et listes

Les chaînes de caractères sont traitées presque comme des listes par Python, on peut donc utiliser sur les chaines de caractères certaines des notations vues sur les listes et notamment la notation entre crochets pour récupérer un élément par son numéro.

In [11]:
a = "Python"
# a est une chaine de caractères mais la notation [] fonctionne
a[-1]
Out[11]:
'n'
In [12]:
# Remarquons aussi qu'on peut effectuer un parcours par élément comme pour les listes :
for lettre in a:
    print(lettre)

P
y
t
h
o
n

✎ Exercices

  1. Créer la liste des mois de l'année, parcourir cette liste par élément et afficher les noms des mois commençant par un `J`. On rapelle que si la variable `var` est une chaine de caractère, alors `var[0]` est le premier caractère de cette chaine. Par exemple si `mois = "Mars"` alors `mois[0]` est `M`
In [36]:
# Votre réponse ici
annee = ["Janvier", "Février", "Mars", "Avril", "Mai", "Juin", "Juillet", "Août", "Septembre", "Octobre", "Novembre", "Décembre"]

for mois in annee:
    if mois[0] == "J":
        print(mois)

Janvier
Juin
Juillet

♦ Génération de liste

Le langage Python offre plusieurs possibilités pour créer des listes.

En donnant explicitement la liste des éléments

On peut créer une liste en donnant tout simplement ces éléments :

In [14]:
ma_liste = [1,2,3,4,5]
ma_liste
Out[14]:
[1, 2, 3, 4, 5]

Lorsque la liste est composée de la répétition du même élément, on peut utiliser * de la même façons que pour les chaines de caractères :

In [15]:
des_zeros = [0] * 10
des_zeros
Out[15]:
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

Remarquez bien que * apparaît après avoir fermé le crochet : on écrit [0]*10 (et pas [0 * 10])

Par ajout successif d'élements :

C'est la méthode déjà vu dans ce cours et qui consiste à partir d'une liste vide et à ajouter des éléments en fin de liste à l'aide de append

In [16]:
ma_liste = []
ma_liste.append(1)
ma_liste.append(2)
ma_liste.append(3)
ma_liste.append(4)
ma_liste.append(5)
ma_liste
Out[16]:
[1, 2, 3, 4, 5]

✎ Exercices

  1. Créer la liste [1,2,3,4,5,6,7,8,9,10] par ajout successif d'élement mais en utilisant une boucle for
In [38]:
# Votre réponse ici
nouvelle_liste = []
for i in range(1, 11):
    nouvelle_liste.append(i)

nouvelle_liste
Out[38]:
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
  1. Créer la liste contenant 26 fois la lettre "x" en utilisant le caractère *
In [41]:
# Votre réponse ici
des_x = ["x"] * 26

des_x
Out[41]:
['x',
 'x',
 'x',
 'x',
 'x',
 'x',
 'x',
 'x',
 'x',
 'x',
 'x',
 'x',
 'x',
 'x',
 'x',
 'x',
 'x',
 'x',
 'x',
 'x',
 'x',
 'x',
 'x',
 'x',
 'x',
 'x']

Par utilisation des fonctions range() et list()

L'instruction range() est une fonction spéciale en Python qui génère des nombres entiers compris dans un intervalle.

Lorsqu'elle est utilisée en combinaison avec la fonction list(), on obtient une liste d'entiers.

In [44]:
list(range(10))
Out[44]:
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

La commande list(range(10)) a généré une liste contenant tous les nombres entiers de 0 inclus à 10 exclu.

Dans l'exemple ci-dessus, la fonction range() a pris un argument, mais elle peut également prendre deux ou trois arguments, voyez plutôt :

In [42]:
list(range(0, 5))
Out[42]:
[0, 1, 2, 3, 4]
In [43]:
list(range(15, 20))
Out[43]:
[15, 16, 17, 18, 19]
In [46]:
list(range(0, 1000, 200))
Out[46]:
[0, 200, 400, 600, 800]
In [45]:
list(range(2, -2, -1))
Out[45]:
[2, 1, 0, -1]

L'instruction range() fonctionne sur le modèle range([début], fin, [pas]).

Les arguments entre crochets sont optionnels.

Il faudrait, par exemple, préciser un pas de -1 pour obtenir une liste d'entiers décroissants :

In [47]:
list(range(10,0,-1))
Out[47]:
[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

Par compréhension

On peut aussi créer une liste par compréhension, c'est à dire en indiquant à l'aide d'une boucle for les éléments qui composent la liste (à la façon dont on définit parfois des ensembles en mathématiques)

In [48]:
ma_liste = [entier for entier in range(10)]
ma_liste
Out[48]:
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Cette façon de faire permet de créer rapidement par exemple la liste des 10 premiers entiers pairs en indiquant qu'ils sont les doubles des premiers entiers :

In [49]:
pairs = [2*entier for entier in range(10)]
pairs
Out[49]:
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

Les compréhensions de tableau permettent de rajouter une condition (if) :

In [50]:
listes = [1, 7, 9, 15, 5, 20, 10, 8]

nombres = [p for p in listes if p > 10]
nombres
Out[50]:
[15, 20]
In [51]:
listes = [1, 7, 9, 15, 5, 20, 10, 8]

nombres = [p**2 for p in listes if p < 10]
nombres
Out[51]:
[1, 49, 81, 25, 64]

✎ Exercices

  1. Créer la liste des carrés des entiers de 1 à 10 par ajout successifs
In [52]:
# Votre réponse ici
carres = []
for i in range(1, 11):
    carres.append(i**2)

carres
Out[52]:
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
  1. Créer la liste des carrés des entiers de 1 à 10 par compréhension
In [59]:
# Votre réponse ici
carres_bis = [p**2 for p in range(1, 11)]

carres_bis
Out[59]:
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
  1. Créer la liste des entiers impairs de 1 à 99 par ajouts successifs
In [67]:
# Votre réponse ici
impairs = []
for i in range(0, 50):
    impairs.append(2*i+1)

impairs
Out[67]:
[1,
 3,
 5,
 7,
 9,
 11,
 13,
 15,
 17,
 19,
 21,
 23,
 25,
 27,
 29,
 31,
 33,
 35,
 37,
 39,
 41,
 43,
 45,
 47,
 49,
 51,
 53,
 55,
 57,
 59,
 61,
 63,
 65,
 67,
 69,
 71,
 73,
 75,
 77,
 79,
 81,
 83,
 85,
 87,
 89,
 91,
 93,
 95,
 97,
 99]
  1. Créer la liste des entiers impairs de 1 à 99 par compréhension
In [69]:
# Votre réponse ici
impairs_bis = [2*p+1 for p in range(0, 50)]

impairs_bis
Out[69]:
[1,
 3,
 5,
 7,
 9,
 11,
 13,
 15,
 17,
 19,
 21,
 23,
 25,
 27,
 29,
 31,
 33,
 35,
 37,
 39,
 41,
 43,
 45,
 47,
 49,
 51,
 53,
 55,
 57,
 59,
 61,
 63,
 65,
 67,
 69,
 71,
 73,
 75,
 77,
 79,
 81,
 83,
 85,
 87,
 89,
 91,
 93,
 95,
 97,
 99]
  1. Créer une liste de 100 nombres au hasard entre 1 et 1000
In [73]:
# Votre réponse ici
from random import randint

liste = []
for i in range(100):
    liste.append( randint(1, 1000) )

liste
Out[73]:
[213,
 158,
 298,
 660,
 750,
 325,
 411,
 129,
 28,
 406,
 411,
 192,
 545,
 191,
 875,
 386,
 964,
 858,
 898,
 327,
 75,
 803,
 1000,
 53,
 667,
 238,
 192,
 494,
 614,
 475,
 322,
 211,
 162,
 104,
 472,
 249,
 328,
 849,
 979,
 801,
 177,
 585,
 648,
 116,
 574,
 655,
 866,
 926,
 889,
 45,
 892,
 645,
 87,
 982,
 183,
 348,
 963,
 320,
 943,
 337,
 887,
 781,
 512,
 367,
 679,
 518,
 671,
 672,
 906,
 994,
 105,
 808,
 957,
 569,
 445,
 236,
 887,
 967,
 130,
 905,
 383,
 195,
 314,
 290,
 435,
 473,
 177,
 678,
 429,
 184,
 31,
 417,
 568,
 50,
 275,
 979,
 897,
 974,
 214,
 204]
In [77]:
# En utilisant la définition par compréhention
from random import randint

liste = [randint(1, 1000) for i in range(100)]

liste
Out[77]:
[104,
 755,
 17,
 376,
 391,
 63,
 364,
 505,
 349,
 798,
 568,
 882,
 98,
 400,
 6,
 370,
 480,
 705,
 867,
 519,
 158,
 495,
 406,
 134,
 765,
 784,
 116,
 91,
 927,
 138,
 200,
 104,
 300,
 99,
 452,
 337,
 662,
 421,
 203,
 944,
 827,
 755,
 380,
 92,
 117,
 648,
 468,
 349,
 493,
 838,
 210,
 127,
 867,
 876,
 311,
 398,
 331,
 770,
 743,
 975,
 363,
 961,
 250,
 26,
 252,
 475,
 632,
 530,
 342,
 244,
 737,
 174,
 940,
 836,
 20,
 423,
 380,
 751,
 977,
 646,
 899,
 732,
 642,
 650,
 654,
 408,
 56,
 176,
 207,
 51,
 430,
 462,
 217,
 34,
 440,
 913,
 128,
 565,
 419,
 824]
  1. Ecrire un traitement sur cette liste afin d'en trouver le maximum
In [78]:
# Votre réponse ici
maximum = liste[0]
for element in liste:
    if element > maximum:
        maximum = element
maximum
Out[78]:
977
  1. Au jeu du pendu, il faut remplacer toutes les lettres d'un mot exceptés la première et la dernière par le caractère - afin de le faire deviner ensuite au joueur, écrire une fonction masque(mot) qui prend en argument un mot et renvoie ce mot en remplaçant toutes ses lettres par des tirets. Par exemple masque("Python") doit renvoyer "P----n"
In [119]:
# Votre réponse ici
def masque(mot):
    nouveau_mot = mot[0]
    for i in range(1, len(mot)-1):
        nouveau_mot = nouveau_mot + "-"
    nouveau_mot = nouveau_mot + mot[-1]
    return nouveau_mot

masque("Python")
Out[119]:
'P----n'
In [120]:
# Une autre version avec les listes

def masque_bis(mot):
    mot = list(mot) #  transforme une chaîne de caractères en listes
    for i in range(1, len(mot)-1):
        mot[i] = "-"
    mot = "".join(mot) #  transforme une listes de chaînes de caractères en une chaine de carctères 
    return mot

masque_bis("Python")
Out[120]:
'P----n'
In [ ]: