CPGE OUJDA SUP
Listes
C’est une structure qui peut être très utile. Une liste peut contenir des données de types différents. En Python, une liste se note entre crochets avec la virgule comme séparateur.
>>> a = [9, 7, 6, 9]
La numérotation des éléments de la liste commence à 0.
>>> a = [9, 7, 6, 9]
>>> print(a[0])
9
>>>print( a[2])
6
Il peut être utile de connaitre ce que l’on appelle la longueur d’une liste.
>>> a = [9, 7, 6, 9]
>>> print(len(a))
4
On peut vouloir ordonner une liste de nombres dans l’ordre croissant.
>>> a = [9, 7, 6, 9]
>>> a.sort()
>>> print(a)
[6, 7, 9, 9]
On peut vouloir ajouter un nombre à la liste, dans le sens d’agrandir la liste d’un élément.
>>> a = [9, 7, 6, 9]
>>> a.append(2)
>>> pint(a)
[9, 7, 6, 9, 2]
Puis il y a des listes toutes faites que l’on obtient grâce à la fonction range.
>>> a = range(5, 15, 2)
>>> print(list(a))
[5, 7, 9, 11, 13]
On a donc obtenu les entiers de 5 (inclus) à 15 (exclu) de 2 en 2 (on dit que l’incrément est 2). On peut ne pas préciser l’incrément et dans ce cas, l’incrément est 1.
>>> B = range(3, 9)
>>> print(list(B))
[3, 4, 5, 6, 7, 8]
On peut en plus ne pas préciser l’entier de départ. Et dans ce cas, la valeur de départ est automatiquement 0.
>>> x = range(5)
>>> print(list(x))
[0, 1, 2, 3, 4]
Notez finalement que la liste vide s’écrit []
copie de la liste
Dans sa version la plus simple, la syntaxe est [x for x in ma_liste], où x est une variable muette et ma_liste est la liste à parcourir.
[x for x in ma_liste] peut se lire «les x quand x parcourt la liste ma_liste».
>>> liste = [1, 2, 3]
>>> [print(x) for x in liste]
[1, 2, 3]
On obtient une copie de la liste, ce qui n’est à vrai dire pas très intéressant. De plus on pouvait le faire encore plus facilement avec liste[:].
Avec filtrage par un test
Ici, si la condition suivant le if est vraie, l’élément correspondant sera inclus dans la liste finale, et sera exclu sinon. Notez que nous n’avons pas besoin de else.
[print(x) for x in ma_liste if condition_sur_x] peut se lire «la liste des x quand x parcourt la liste ma_liste mais seulement les x pour lesquels la condition est vraie».
>>> liste = [1, 2, 3]
>>> [print(x) for x in liste if x > 1]
[2, 3]
Les tests peuvent aussi être donnés sous la forme de Fonctions. En effet, si test est une fonction qui retourne un booléen ,alors on peut l’utiliser pour filtrer avec la syntaxe [x for x in ma_liste if test(x)].
[print(x) for x in ma_liste if test(x)] peut se lire «la liste des x quand x parcourt la liste ma_liste, tels que test(x) est vrai».
>>> def pair(nbre):
... return nbre % 2 == 0
...
>>> [print(x) for x in range(0, 10) if pair(x)]
[0, 2, 4, 6, 8]
Avec application d’une fonction
Une fois qu’une fonction est définie ,elle peut être appliquée au nombres de la liste de départ, les images constitueront la liste d’arrivée.
[print(f(x)) for x in ma_liste] peut se lire «la liste des f(x) quand x parcourt la liste ma_liste».
On obtient le même résultat en mettant directement une expression en x à la place de f(x).
[print(2*x) for x in ma_liste] peut se lire «la liste des doubles de x quand x parcourt la liste ma_liste».
>>> [print(2*x) for x in range(0, 10)]
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
Filtrage et application d’une fonction
Les deux derniers paragraphes peuvent se combiner. [f(x) for x in ma_liste if test(x)] peut se lire «la liste des f(x) quand x parcourt la liste ma_liste, tels que test(x) est vrai».
NB :pour python3 il faut utiliser la fonction print pour l’affichage
>>> maliste = [0, "un", 2] # on définit une liste pour faire des tests
>>> len(maliste) # on demande sa longueur (length en anglais)
3
>>> maliste[0] # on demande le premier élément (rang ou index 0)
0
>>> maliste[1] # le deuxième (index 1)
'un'
>>> "un" in maliste # on demande si le texte "un" est un élément de la liste
True
>>> "deux" in maliste
False
>>> maliste.index("un") # on demande l'index (rang) de l'élément "un"
1
>>> maliste.count("un") # on demande le nombre d'apparitions de l'élément "un"
1
Note :Puisque Python considère qu’une chaîne est une liste de caractères, tout ce que nous venons de dire sur les listes est encore valable.
>>> montexte = "Blabla bli bloubloublou."
>>> len(montexte)
>>> montexte[0]
'B'
>>> montexte[1]
'l'
>>> montexte[23]
'.'
>>> "a" in montexte
True
>>> "z" in montexte
False
>>> montexte.index("B")
0
>>> montexte.index("b")
>>> montexte.index(".")
>>> montexte.count("b")
Certaines manipulations sont propres aux chaînes.
>>> montexte.lower()
'blabla bli bloubloublou.'
>>> montexte.strip(".")
'Blabla bli bloubloublou'
>>> montexte.split()
['Blabla', 'bli', 'bloubloublou.']
>>> montexte.lower().strip(".").split()
['blabla', 'bli', 'bloubloublou']
>>> montexte + " Merci."
'Blabla bli bloubloublou. Merci.'
>>> montexte
'Blabla bli bloubloublou.'
>>> montexte = montexte + " Merci."
>>> montexte
'Blabla bli bloubloublou. Merci.'
>>> montexte += " Beaucoup."
>>> montexte
'Blabla bli bloubloublou. Merci. Beaucoup.'
>>> # On reprend une liste de test, un peu plus longue cette fois, et homogène.
>>> maliste = ["zéro", "un", "deux", "trois", "quatre", "cinq"]
>>> maliste[-1] # on demande le dernier élément
'cinq'
>>> maliste[-2] # l’avant-dernier
'quatre'
>>> maliste[-3] # l’avant-avant-dernier (ou antépénultième), et ainsi de suite…
'trois'
>>> maliste[1:3] # Ici on demande une partie de la liste et non un élément seul.
['un', 'deux']
>>> # On remarque que cela fonctionne comme range(1,3), le 3 n’est pas compris.
>>> # Voyons maintenant si l’on ne précise pas l’indice de départ ou d’arrivée:
>>> maliste[1:] # Sans indice d’arrivée, on ne s’arrête qu’à la fin,
['un', 'deux', 'trois', 'quatre', 'cinq']
>>> maliste[:3] # sans indice de départ, on commence du tout début.
['zéro', 'un', 'deux']
On présente ici un petit algorithme qui trouve le mot le plus long dans le texte stocké dans la variable texte.
>>> texte = "voici une suite de mots presque en vrac"
>>> mot_long = "" # Cette variable contiendra le mot cherché.
>>> # Le recordman de longueur en quelque sorte.
... # Pour l’instant on stocke le mot vide "" dedans.
... mots = texte.split() # On construit la liste des mots.
>>> for mot in mots: # On parcourt cette liste (boucle for).
... if len(mot) > len(mot_long): # Si le mot rencontré bat le record de longueur,
... mot_long = mot # on le proclame recordman.
...
>>> mot_long # On affiche le résultat.
'presque'
>>> mot = "apparition"
>>> rangs = [] # Cette liste va accumuler les rangs de la lettre *i*.
>>> for rang in range(len(mot)): # La variable rang parcourt les entiers de 0 au rang de la dernière lettre du mot.
... if mot[rang] == 'i':
... rangs.append(rang) # Si la lettre du mot est 'i', on stocke le rang dans notre liste.
...
>>> rangs # On affiche le résultat.
[5, 7]
>>> # On reprend une liste de test, un peu plus longue cette fois, et homogène.
>>> maliste = ["zéro", "un", "deux", "trois", "quatre", "cinq"]
>>> maliste[-1] # on demande le dernier élément
'cinq'
>>> maliste[-2] # l’avant-dernier
'quatre'
>>> maliste[-3] # l’avant-avant-dernier (ou antépénultième), et ainsi de suite…
'trois'
>>> maliste[1:3] # Ici on demande une partie de la liste et non un élément seul.
['un', 'deux']
>>> # On remarque que cela fonctionne comme range(1,3), le 3 n’est pas compris.
>>> # Voyons maintenant si l’on ne précise pas l’indice de départ ou d’arrivée:
>>> maliste[1:] # Sans indice d’arrivée, on ne s’arrête qu’à la fin,
['un', 'deux', 'trois', 'quatre', 'cinq']
>>> maliste[:3] # sans indice de départ, on commence du tout début.['zéro', 'un', 'deux']