Les bases de la programmation Python par l’exemple

VII. Les listes▲

VII-A. Assignation des variables de liste▲

Listes simples et récupération d’éléments de liste.

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.

>>> vowels = ['a', 'e', 'i', 'o', 'u']
>>> vowels
['a', 'e', 'i', 'o', 'u']
>>> vowels[0]
'a'
>>> vowels[2]
'i'
>>> vowels[10]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range
 
>>> even_numbers = list(range(2, 11, 2))
>>> even_numbers
[2, 4, 6, 8, 10]
>>> even_numbers[-1]
10
>>> even_numbers[-2]
8
>>> even_numbers[-15]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range

Mélange des types de données et listes multidimensionnelles.

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.
9.

>>> student = ['learnbyexample', 2016, 'Linux, Vim, Python']
>>> print(student)
['learnbyexample', 2016, 'Linux, Vim, Python']
 
>>> list_2D = [[1, 3, 2, 10], [1.2, -0.2, 0, 2]]
>>> list_2D[0][0]
1
>>> list_2D[1][0]
1.2

Python docs – lists .

VII-B. Découpage et modification des listes▲

Comme la fonction « range() », l’index de la liste a le format « start:stop:step » , la valeur « stop » étant non inclusive.

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.

>>> books = ['Harry Potter', 'Sherlock Holmes', 'To Kill a Mocking Bird']
>>> books[2] = "Ender's Game"
>>> print(books)
['Harry Potter', 'Sherlock Holmes', "Ender's Game"]
 
>>> prime = [2, 3, 5, 7, 11]
>>> prime[2:4]
[5, 7]
>>> prime[:3]
[2, 3, 5]
>>> prime[3:]
[7, 11]
 
>>> prime[-1]
11
>>> prime[-1:]
[11]
>>> prime[-2:]
[7, 11]
 
 
>>> prime[::1]
[2, 3, 5, 7, 11]
>>> prime[::2]
[2, 5, 11]
>>> prime[3:1:-1]
[7, 5]
>>> prime[::-1]
[11, 7, 5, 3, 2]
>>> prime[:]
[2, 3, 5, 7, 11]

Quand les valeurs « start » et « stop« sont les mêmes.
Utiles quand elles sont générées par programmation, regardez l’exercice sur le traitement de texte comme exemple.

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.
9.

>>> nums = [1.2, -0.2, 0, 2]
>>> nums[0:0]
[]
>>> nums[2:2]
[]
>>> nums[-1:-1]
[]
>>> nums[21:21]
[]

Le format d’indexation peut être utilisé pour extraire une variable de la liste ou se modifier.

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.

>>> nums = [1.2, -0.2, 0, 2]
>>> nums[:2] = [1]
>>> nums
[1, 0, 2]
 
>>> nums = [1.2, -0.2, 0, 2, 4, 23]
>>> nums[:5:2] = [1, 4, 3]
>>> nums
[1, -0.2, 4, 2, 3, 23]
 
>>> nums = [1, 2, 3, 23]
>>> nums[::-1] = [1, 4, 5, 2]
>>> nums
[2, 5, 4, 1]

Ceci aide à modifier une liste sans changer son id, ce qui est utile si le nom de variable est référencé autre part (regardez la section suivante)

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.

>>> id(nums)
140598790579336
>>> nums[:] = [1, 2, 5, 4.3]
>>> nums
[1, 2, 5, 4.3]
>>> id(nums)
140598790579336
 
# l’affectation sans utiliser [:] changera son id
>>> nums = [1.2, -0.2, 0, 2]
>>> id(nums)
140598782943752

VII-C. Copie des listes▲

Les variables dans Python contiennent une référence aux objets.
Par exemple, quand une variable d’entier est modifiée, la référence de la variable est mise à jour avec un nouvel objet.
La fonction « id() » retourne l’ « identité » d’un objet.
La distinction entre les variables se référant à des types immuables comme integer et strings, ne cause généralement pas une confusion lors de leur usage.

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.

>>> a = 5
>>> id(a)
10105952
>>> a = 10
>>> id(a)
10106112
 
>>> b = a
>>> id(b)
10106112
>>> b = 4
>>> b
4
>>> a
10
>>> id(b)
10105920

Cependant, il est important de savoir, pour les variables de types muables comme « lists », comment ces variables sont copiées et transmises aux fonctions.
Quand un élément d’une liste de variables est modifié, Python le fait en changeant la valeur (mutation) d’un objet à cet index.

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.

>>> a = [1, 2, 5, 4.3]
>>> a
[1, 2, 5, 4.3]
>>> b = a
>>> b
[1, 2, 5, 4.3]
>>> id(a)
140684757120264
>>> id(b)
140684757120264
>>> b[0] = 'xyz'
>>> b
['xyz', 2, 5, 4.3]
>>> a
['xyz', 2, 5, 4.3]

Évitez de copier des listes utilisant un format d’indexation, car ceci fonctionne pour des listes d’une seule dimension et non pour des dimensions supérieures.

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.

>>> prime = [2, 3, 5, 7, 11]
>>> b = prime[:]
>>> id(prime)
140684818101064
>>> id(b)
140684818886024
>>> b[0] = 'a'
>>> b
['a', 3, 5, 7, 11]
>>> prime
[2, 3, 5, 7, 11]
 
>>> list_2D = [[1, 3, 2, 10], [1.2, -0.2, 0, 2]]
>>> a = list_2D[:]
>>> id(list_2D)
140684818102344
>>> id(a)
140684818103048
>>> a
[[1, 3, 2, 10], [1.2, -0.2, 0, 2]]
>>> a[0][0] = 'a'
>>> a
[['a', 3, 2, 10], [1.2, -0.2, 0, 2]]
>>> list_2D
[['a', 3, 2, 10], [1.2, -0.2, 0, 2]]

Utilisez à la place le module « copy ».

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.

>>> import copy
>>> list_2D = [[1, 3, 2, 10], [1.2, -0.2, 0, 2]]
>>> c = copy.deepcopy(list_2D)
>>> c[0][0] = 'a'
>>> c
[['a', 3, 2, 10], [1.2, -0.2, 0, 2]]
>>> list_2D
[[1, 3, 2, 10], [1.2, -0.2, 0, 2]]

VII-D. Méthodes de liste et divers▲

Ajout d’éléments à une liste.

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.

>>> books = []
>>> books
[]
>>> books.append('Harry Potter')
>>> books
['Harry Potter']
 
>>> even_numbers = [2, 4, 6, 8, 10]
>>> even_numbers += [12, 14, 16, 18, 20]
>>> even_numbers
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
 
>>> even_numbers = [2, 4, 6, 8, 10]
>>> even_numbers.extend([12, 14, 16, 18, 20])
>>> even_numbers
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
 
>>> a = [[1, 3], [2, 4]]
>>> a.extend([[5, 6]])
>>> a
[[1, 3], [2, 4], [5, 6]]

Suppression d’éléments d’une liste en fonction d’un index.

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.

>>> prime = [2, 3, 5, 7, 11]
>>> prime.pop()
11
>>> prime
[2, 3, 5, 7]
>>> prime.pop(0)
2
>>> prime
[3, 5, 7]
 
>>> list_2D = [[1, 3, 2, 10], [1.2, -0.2, 0, 2]]
>>> list_2D[0].pop(0)
1
>>> list_2D
[[3, 2, 10], [1.2, -0.2, 0, 2]]
 
>>> list_2D.pop(1)
[1.2, -0.2, 0, 2]
>>> list_2D
[[3, 2, 10]]

Utilisation de « del » pour supprimer des éléments.

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.

>>> nums = [1.2, -0.2, 0, 2, 4, 23]
>>> del nums[1]
>>> nums
[1.2, 0, 2, 4, 23]
# vous pouvez utiliser aussi bien la notation de découpage
>>> del nums[1:4]
>>> nums
[1.2, 23]
 
>>> list_2D = [[1, 3, 2, 10], [1.2, -0.2, 0, 2]]
>>> del list_2D[0][1]
>>> list_2D
[[1, 2, 10], [1.2, -0.2, 0, 2]]
 
>>> del list_2D[0]
>>> list_2D
[[1.2, -0.2, 0, 2]]

Effacement d’une liste.

Sélectionnez

1.
2.
3.
4.

>>> prime = [2, 3, 5, 7, 11]
>>> prime.clear()
>>> prime
[]

Suppression d’éléments d’une liste en fonction de la valeur.

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.

>>> even_numbers = [2, 4, 6, 8, 10]
>>> even_numbers.remove(8)
>>> even_numbers
[2, 4, 6, 10]
>>> even_numbers.remove(12)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: list.remove(x): x not in list

Insertion d’éléments à une position d’index particulière.

Sélectionnez

1.
2.
3.
4.

>>> books = ['Harry Potter', 'Sherlock Holmes', 'To Kill a Mocking Bird']
>>> books.insert(2, "The Martian")
>>> books
['Harry Potter', 'Sherlock Holmes', 'The Martian', 'To Kill a Mocking Bird']

Obtention d’un index d’un élément.

Sélectionnez

1.
2.
3.
4.
5.
6.
7.

>>> even_numbers = [2, 4, 6, 8, 10]
>>> even_numbers.index(6)
2
>>> even_numbers.index(12)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: 12 is not in list

Vérification de présence d’un élément.

Sélectionnez

1.
2.
3.
4.
5.

>>> prime = [2, 3, 5, 7, 11]
>>> 3 in prime
True
>>> 13 in prime
False

Tri .

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.
9.

>>> a = [1, 5.3, 321, 0, 1, 2]
>>> a.sort()
>>> a
[0, 1, 1, 2, 5.3, 321]
 
>>> a = [1, 5.3, 321, 0, 1, 2]
>>> a.sort(reverse=True)
>>> a
[321, 5.3, 2, 1, 1, 0]

Triez en vous basant sur une clef , par exemple en vous basant sur la longueur d’une chaîne.
L es expressions lambda sont utiles pour transmettre une seule expression personnalisée, par exemple un tri basé sur la deuxième lettre.

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.

>>> words = ['fuliginous', 'crusado', 'morello', 'irk', 'seam']
>>> words.sort(key=len)
>>> words
['irk', 'seam', 'crusado', 'morello', 'fuliginous']
 
>>> words.sort(key=lambda x: x[1])
>>> words
['seam', 'morello', 'irk', 'crusado', 'fuliginous']

Si la liste originale ne doit pas changer, utilisez une fonction triée .

Sélectionnez

1.
2.
3.
4.
5.
6.
7.

>>> nums = [-1, 34, 0.2, -4, 309]
>>> nums_desc = sorted(nums, reverse=True)
>>> nums_desc
[309, 34, 0.2, -1, -4]
 
>>> sorted(nums, key=abs)
[0.2, -1, -4, 34, 309]

min et max.

Sélectionnez

1.
2.
3.
4.
5.

>>> a = [321, 899.232, 5.3, 2, 1, -1]
>>> min(a)
-1
>>> max(a)
899.232

Nombre de fois qu’un élément est présent.

Sélectionnez

1.
2.
3.
4.
5.
6.
7.

>>> nums = [15, 99, 19, 382, 43, 19]
>>> nums.count(99)
1
>>> nums.count(19)
2
>>> nums.count(23)
0

Liste inversée

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.

>>> prime = [2, 3, 5, 7, 11]
>>> id(prime)
140684818102088
>>> prime.reverse()
>>> prime
[11, 7, 5, 3, 2]
>>> id(prime)
140684818102088
 
>>> a = [1, 5.3, 321, 0, 1, 2]
>>> id(a)
140684818886024
>>> a = a[::-1]
>>> a
[2, 1, 0, 321, 5.3, 1]
>>> id(a)
140684818102664

Fonction len permettant d’obtenir la taille d’une liste.

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.

>>> prime = [2, 3, 5, 7, 11]
>>> len(prime)
5
 
>>> s = len(prime) // 2
>>> s
2
>>> prime[:s]
[2, 3]
>>> prime[s:]
[5, 7, 11]
>>>

Somme des listes numériques.

Sélectionnez

1.
2.
3.

>>> a = [321, 5.3, 2, 1, 1, 0]
>>> sum(a)
330.3

Fonctions all et any .

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.

>>> conditions = [True, False, True]
>>> all(conditions)
False
>>> any(conditions)
True
 
>>> conditions[1] = True
>>> all(conditions)
True
 
>>> a = [321, 5.3, 2, 1, 1, 0]
>>> all(a)
False
>>> any(a)
True

Comparaison des listes.

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.

>>> prime
[2, 3, 5, 7, 11]
>>> a = [4, 2]
>>> prime == a
False
 
>>> prime == [2, 3, 5, 11, 7]
False
>>> prime == [2, 3, 5, 7, 11]
True

VII-E. Lecture complémentaire▲

VII-F. Les boucles▲

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.

#!/usr/bin/python3
 
numbers = [2, 12, 3, 25, 624, 21, 5, 9, 12]
odd_numbers  = []
even_numbers = []
 
for num in numbers:
    odd_numbers.append(num) if(num % 2) else even_numbers.append(num)
 
print("nombres :      {}".format(numbers))
print("nombres_impairs :  {}".format(odd_numbers))
print("nombres_pairs : {}".format(even_numbers))

Généralement, il suffit de traiter chaque élément d’une liste sans avoir besoin des valeurs d’index de ces éléments.

Sélectionnez

1.
2.
3.
4.

$ ./list_looping.py 
numbers:      [2, 12, 3, 25, 624, 21, 5, 9, 12]
odd_numbers:  [3, 25, 21, 5, 9]
even_numbers: [2, 12, 624, 12]

Utilisez « enumerate() » si vous avez besoin d’un index et d’un élément.

Sélectionnez

1.
2.
3.
4.
5.
6.
7.

#!/usr/bin/python3
 
north_dishes = ['Aloo tikki', 'Baati', 'Khichdi', 'Makki roti', 'Poha']
 
print("Mes vaisselles favorites du nord de l’Inde :")
for idx, item in enumerate(north_dishes):
    print("{}. {}".format(idx + 1, item))

Dans ce cas, on obtient un « tupleTuples » à chaque itération consistant en un compte (valeur par défaut 0) et un élément de la liste.
Python docs – enumerate .

Sélectionnez

1.
2.
3.
4.
5.
6.
7.

$ ./list_looping_enumeration.py
Mes vaisselles favorites du nord de l’Inde :
1. Aloo tikki
2. Baati
3. Khichdi
4. Makki roti
5. Poha

Une valeur de départ peut aussi être spécifiée.

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.
9.

>>> north_dishes = ['Aloo tikki', 'Baati', 'Khichdi', 'Makki roti', 'Poha']
>>> for idx, item in enumerate(north_dishes, start=1):
...     print(idx, item, sep='. ')
... 
1. Aloo tikki
2. Baati
3. Khichdi
4. Makki roti
5. Poha

Utilisez « zip() » pour parcourir deux listes ou plus simultanément.
Python docs - zip

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.

>>> odd = [1, 3, 5]
>>> even = [2, 4, 6]
>>> for i, j in zip(odd, even):
...     print(i + j)
... 
3
7
11

VII-G. Compréhension d’une liste▲

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.

#!/usr/bin/python3
 
import time
 
numbers = list(range(1,100001))
fl_square_numbers = []
 
# référencer time
t0 = time.perf_counter()
 
# ------------ la boucle for ------------
for num in numbers:
    fl_square_numbers.append(num * num)
 
# référencer time
t1 = time.perf_counter()
 
# ------- compréhension de la liste -------
lc_square_numbers = [num * num for num in numbers]
 
# performance des résultats
t2 = time.perf_counter()
fl_time = t1 - t0
lc_time = t2 - t1
improvement = (fl_time - lc_time) / fl_time * 100
 
print("Temps avec la boucle for :           {:.4f}".format(fl_time))
print("Temps avec la liste de compréhension : {:.4f}".format(lc_time))
print("Amélioration :                  {:.2f}%".format(improvement))
 
if fl_square_numbers == lc_square_numbers:
    print("\nfl_square_numbers et lc_square_numbers sont équivalents")
else:
    print("\nfl_square_numbers et lc_square_numbers ne sont PAS équivalents")

La liste de compréhension est une façon de construire certaines boucles usuelles dans le langage python
C’est une option plus lisible et plus rapide que les boucles.
Dans cet exemple, ne pas avoir l’obligation d’utiliser la méthode « append() » permet aussi de gagner beaucoup de temps dans le cas de compréhension de liste.
Les valeurs de temps dans cet exemple sont indicatives et ne devraient pas être considérées comme absolues
Elles varient même entre deux exécutions, que dire de machines différentes.

Sélectionnez

1.
2.
3.
4.
5.
6.

$ ./list_comprehension.py
Temps avec la boucle for :           0.0142
Temps avec liste de compréhension : 0.0062
Amélioration :                  56.36%
 
fl_square_numbers et lc_square_numbers sont équivalents

Compréhension de la liste conditionnelle.

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.

# utilisation de la condition if-else dans la compréhension de liste
numbers = [2, 12, 3, 25, 624, 21, 5, 9, 12]
odd_numbers  = []
even_numbers = []
[odd_numbers.append(num) if(num % 2) else even_numbers.append(num) for num in numbers]
 
# ou d’une façon plus simple et lisible
numbers = [2, 12, 3, 25, 624, 21, 5, 9, 12]
odd_numbers  = [num for num in numbers if num % 2]
even_numbers = [num for num in numbers if not num % 2]

Exemple d’utilisation de la fonction zip.

Sélectionnez

1.
2.
3.
4.
5.
6.

>>> p = [1, 3, 5]
>>> q = [3, 214, 53]
>>> [i+j for i,j in zip(p, q)]
[4, 217, 58]
>>> [i*j for i,j in zip(p, q)]
[3, 642, 265]

Utilisez un générateur d’expression , la séquence doit être transmise à une autre fonction

Sélectionnez

1.
2.

>>> sum(i*j for i,j in zip(p, q))
910

VII-H. Lecture complémentaire▲

Pour plus d’exemples, y compris les boucles imbriquées, veuillez voir ici :

VII-I. Obtention de la liste comme entrée utilisateur▲

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.

>>> b = input('Entrez des mots séparés par des espaces : ').split()
Entrez des mots séparés par des espaces : foo bar baz
>>> b
['foo', 'bar', 'baz']
 
>>> nums = [int(n) for n in input('Entrez des nombres séparés par des espaces : ').split()]
Entrez des numéros séparés par des espaces : 1 23 5
>>> nums
[1, 23, 5]
 
>>> ip_str = input('Entrez des nombres premiers séparés par des virgules : ')
Entrez des nombres premiers séparés par des virgules : 3,5,7
>>> primes = [int(n) for n in ip_str.split(',')]
>>> primes
[3, 5, 7]

Étant donné que les entrées de l’utilisateur sont toutes traitées comme des chaînes, il est nécessaire de traiter en fonction du délimiteur convenu et du type de données requis.

VII-J. Obtention d’éléments aléatoires de la liste▲

Obtenir un élément aléatoirement.

Sélectionnez

1.
2.
3.
4.
5.
6.

>>> import random
>>> a = [4, 5, 2, 76]
>>> random.choice(a)
76
>>> random.choice(a)
4

Réarranger aléatoirement des éléments d’une liste.

Sélectionnez

1.
2.
3.

>>> random.shuffle(a)
>>> a
[5, 2, 76, 4]

Obtenir aléatoirement une partie d’une liste, ce qui ne modifie pas la variable de liste.

Sélectionnez

1.
2.
3.
4.
5.

>>> random.sample(a, k=3)
[76, 2, 5]
 
>>> random.sample(range(1000), k=5)
[68, 203, 15, 757, 580]

Obtenir des éléments aléatoires d’une liste sans répétition en créant une fonction itérable en utilisant Python docs – iter.
La différence par rapport à la simple utilisation d’une liste aléatoire est que cela évite le besoin de maintenir un compteur d’index séparé et qu’une exception automatique est déclenchée si elle sort de la plage.

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.

>>> nums = [1, 3, 6, -12, 1.2, 3.14]
>>> random.shuffle(nums)
>>> nums_iter = iter(nums)
>>> print(next(nums_iter))
3.14
>>> print(next(nums_iter))
1.2
>>> for n in nums_iter:
...     print(n)
... 
1
3
-12
6
>>> print(next(nums_iter))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

Python docs - random pour plus d’informations.
- Nouveau dans la version 3.6 - random.choices.
Python docs – next.

Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © 2018 Sundeep Agarwal. Aucune reproduction, même partielle, ne peut être faite de ce site ni de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.