cours python gratuit d’initiation —- UTILISEZ LES LISTES

C’est le cours python numéro 11 de la série des cours d’initiation à python.

DES TYPES DE DONNÉES PLUS COMPLEXES

Imaginons avoir à programmer un logiciel pour gérer les notes d’une classe scolaire. La première chose qui peut venir à l’esprit est de créer une variable pour chaque élève. Comme nous ne connaissons pas à l’avance les noms et numéros des élèves, nous écrirons probablement quelque chose comme Etudiant1, Etudiant2, Etudiant3, etc. Maintenant, pour chaque étudiant, nous devrons probablement créer la variable Student Name1, Student Prename1, Student Votes1, Student Absences1 etc. En pratique, le programme contiendrait un très grand nombre de variables et il serait très difficile de les gérer.

C’est pourquoi tous les langages de programmation permettent d’agréger de nombreuses variables dans de nouveaux types de données, généralement appelés types de données dérivés. Les types de données vus jusqu’ici (int, float, bool) sont appelés types de données atomiques (ou élémentaires) : un type de données dérivé est donc un ensemble de données atomiques (mais aussi dérivées) agrégées en une seule variable. Parfois, les données du composant doivent toutes être du même type (c’est-à-dire tous les nombres ou toutes les chaînes), parfois elles peuvent être de types différents.

Revenant à notre exemple, je pourrais définir un étudiant comme un objet composé d’un prénom (str), d’un nom de famille (str), d’une absence donnée, (int) etc. Ensuite, je pourrais définir une classe d’école comme un ensemble d’élèves, et ainsi de suite. Certes, je devrais avoir des instructions capables de sélectionner les données (atomiques) que je veux lire ou écrire. Donc, si aujourd’hui j’interrogeais le cinquième élève de I A et que je lui mettais 8, je devrais pouvoir dire à la langue : attribuez la valeur de 8 à la note de l’élève 5 de la classe I A.

Voyons les instructions que Python met à notre disposition.

LES LISTES

L’une des fonctionnalités les plus puissantes de Python est la présence native d’un grand nombre de types de données dérivés et la simplicité de la syntaxe pour les manipuler.

Le type de données dérivées le plus utilisé est sans aucun doute la liste (en anglais : list). Une liste est un ensemble de données (appelées éléments) auquel une commande est associée. Il peut contenir des éléments de différents types et peut également contenir plusieurs fois le même élément.

Pour définir une liste, écrivez ses éléments, séparés par des virgules, entre crochets. Faisons quelques exemples directement dans IDLE (comme d’habitude, vous pouvez omettre les commentaires).

>>> ville = ["Rome", "Milan", "Florence", "Bologne"] # une liste de 4 chaînes
>>> nombres = [1, 4, 5, 12, 23, 40]   # une liste de 6 entiers
>>> mixte = [1, "deux", 3, "quatre"]  # éléments de types différents
>>> nombres_égaux = [1, 4, 1, 6, 6, 4, 7, 7, 7, 1, 6] # éléments répétés
>>> vide = [] # liste vide, sans éléments
>>> ville
['Rome', 'Milan', 'Florence', 'Bologne']
>>> numéros
[1, 4, 5, 12, 23, 40] 

Notez que dans la première instruction, j’ai affecté une liste complète de quatre chaînes à la variable city. Lorsque, plus bas, je demande la valeur de la variable citta, IDLE répond en réimprimant les chaînes entre crochets. La chose est similaire pour les autres listes.

Même sur des listes on peut effectuer les opérations d’addition et de multiplication par un entier, comme pour les chaînes, et utiliser la fonction type() ; continuez dans IDLE comme ceci:

>>> ville
['Rome', 'Milan', 'Florence', 'Bologne']
>>> numéros
[1, 4, 5, 12, 23, 40]
>>> ville + chiffres
['Rome', 'Milan', 'Florence', 'Bologne', 1, 4, 5, 12, 23, 40]
>>> Ville 2*
['Rome', 'Milan', 'Florence', 'Bologne', 'Rome', 'Milan', 'Florence', 'Bologne']
>>> genre (mixte)
<classe 'liste'>

Étant donné que lors de la définition d’une liste, il arrive souvent que vous deviez écrire de très longues lignes de code, Python vous permet de parcourir librement les éléments de la liste. Attention à ne pas oublier les virgules : je suggère, lorsque vous passez à un saut de ligne, de toujours écrire la virgule comme dernier caractère de la ligne du haut. IDLE nous fait comprendre que la ligne suivante est une continuation en écrivant les caractères les plus à droite.

>>> long_list = ["un", 2, "trois", 4,
"cinq", 6, "sept",
8, "neuf", 10]

FONCTIONS SUR LES LISTES

Sur les objets de type liste nous pouvons appliquer un grand nombre de fonctions. La plupart d’entre eux sont cependant appelés non pas avec la syntaxe que nous connaissons déjà, mais avec une syntaxe similaire à celle que nous avons déjà vue pour les modules.

Si nom_liste est une variable de type liste, on peut appeler une fonction nom_fonction qui lui est appliquée avec la syntaxe :

nom_liste.nom_fonction (arguments …)

De cette façon, le nom de la liste à laquelle on applique la fonction n’apparaît pas parmi les arguments de la fonction (c’est-à-dire entre les crochets), mais devient une sorte de paramètre « spécial » qui s’écrit devant le nom de la fonction. Pour connaître toutes les fonctions de ce type on peut taper dans IDLE :

>>> help(list)

Voyons les plus utilisées (dans le tableau on suppose que la variable l contient une liste) :

Une fonction	Signification
l.append(a)	Ajouter l’élément a à la fin de la liste l
l.insert(n, a)	Ajoutez l’élément a à la place n dans la liste (les places sont numérotées à partir de 0, voir ci-dessous)
l.remove(a)	Supprime l’élément a de la liste l. Si a n’appartient pas à la liste, il provoque une ValueError
l.sort()	Trie les éléments de la liste par ordre alphabétique ou numérique
l.reverse()	Inverse l’ordre des éléments dans la liste
l.count(a)	Renvoie (en int) le nombre d’occurrences de a dans la liste (c’est-à-dire combien de fois l’élément a est contenu dans l, 0 s’il n’est pas présent)
l.pop(a) l.pop()	Supprime l’élément a de la liste et le renvoie comme résultat de la fonction. Utilisé sans paramètre, il supprime le dernier élément
l.clear()	Supprimer tous les éléments : la liste l devient vide

D’autres fonctions doivent à la place être appelées avec la syntaxe que nous avons déjà vue, en insérant la liste comme paramètre de la fonction elle-même.

Une fonction	Signification
len(l)	Renvoie (en entier) la longueur de la liste, c’est-à-dire le nombre de ses éléments
max(l)	Renvoie l’élément le plus grand de la liste (par ordre alphabétique ou numérique). Si les objets ne sont pas comparables (par exemple, des nombres et des chaînes) par une TypeError
min(l)	Renvoie le plus petit élément de la liste
sum(l)	Renvoie la somme de tous les éléments de la liste. Ils doivent tous être des nombres sinon d’un TypeError

C’est une autre situation qui peut être déroutante pour un débutant : certaines fonctions doivent être appelées d’une manière, d’autres d’une manière différente. La raison de tout cela est assez obscure et difficile à comprendre pour ceux qui n’ont pas déjà une certaine expérience des langages de programmation. Pour le moment il est utile d’essayer de beaucoup s’entraîner afin de bien se souvenir de l’utilisation des fonctions sur les listes et de ne pas s’embrouiller sur leur syntaxe.

LA SÉLECTION DES ÉLÉMENTS

Comment lire ou écrire un seul élément appartenant à une liste ? Le truc est simple : chaque élément est associé à un numéro, appelé index, qui correspond à sa position dans la liste. Le premier élément a l’index 0 (encore une fois cette tradition dérive du langage C) donc le dernier a l’index égal à la longueur de la liste moins 1 (peut être obtenu avec la fonction len()).

Pour accéder à un élément, il faut écrire le nom de la liste et immédiatement après l’index de l’élément entre crochets, selon la syntaxe nom_liste [index] aussi bien en lecture qu’en écriture. Essayons à nouveau dans IDLE :

>>> ville = ["Rome", "Milan", "Venise", "Florence", "Bologne"]
>>> ville [4]
'Bologne'
>>> ville [2] = "Naples"
>>> ville
['Rome', 'Milan', 'Naples', 'Florence', 'Bologne']
>>> ville [0] + ville [1]
'RomeMilan'

Il est très facile d’être confus lors de l’utilisation des index. Rappelez-vous toujours que le premier élément a l’indice 0, le nième élément a l’indice n – 1, le dernier len ​​- 1. Si nous écrivons un index qui n’existe pas, nous obtenons un nouveau type d’erreur : IndexError.

Enfin on peut utiliser les opérateurs booléens in et not in qui nous disent si un élément appartient à une liste ou non.

>>> citta.index ("Rome")
0
>>> citta.index ("Florence")
3
>>> citta.index ("Turin")
Traceback (dernier appel le plus récent) :
   Fichier "<pyshell # 3>", ligne 1, dans <module>
     citta.index ("Turin")
ValueError : 'Turin' n'est pas dans la liste

Il est très facile d’être confus lors de l’utilisation des index. Rappelez-vous toujours que le premier élément a l’indice 0, le nième élément a l’indice n – 1, le dernier len ​​- 1. Si nous écrivons un index qui n’existe pas, nous obtenons un nouveau type d’erreur : IndexError.

Enfin on peut utiliser les opérateurs booléens in et not in qui nous disent si un élément appartient à une liste ou non.

>>> "Rome" dans la ville
Vrai
>>> "Catanzaro" dans la ville
Faux
>>> "Milan" n'est pas dans la ville
Faux
>>> "Sassari" pas dans la ville
Vrai