@ccueil Colles

Programmation en Python

Listes, suites, vecteurs et tableaux



Définition d'une liste

Une liste en python est une variable qui peut elle même contenir plusieurs variables.
Par exemple, avec
V=[1,2,6,78];
print(V)
on définit une liste V contenant 4 nombres, qu'on affiche ensuite en utilisant, comme on l'aurait fait avec n'importe quelle autre variable, la fonction print().
Une liste peut contenir tout type de données, par exemple la liste
V=["a","b","cd","efg",12,24,2.37];
contient à la fois du texte et des nombres, entiers (integer) et décimaux (ou flottants, float numbers)

Les listes sont des objets fondamentaux, pas qu'en algorithmique/informatique. À ce titre, on peut leur trouver bien des dénominations:
Coordonnées, de points ou de vecteurs, en 2D
#Point A(xA,yA), et vecteur V(x,y)
A=[2,5]
V=[-4,2.6]
#et donc, par exemple, l'abscisse de A est A[0], son ordonnée A[1]
de même en 3D (ou plus …)
#Point A(xA,yA,zA)
A=[2,5,-7.2]
Suite (mathématique)
En mathématique, la notion de suite est fondamentale et centrale dans de très nombreux problèmes. La position de l'élément dans la liste s'appelle alors son rang, qu'on note mathématiquement en général en indice: v0, v1, v2, … la suite elle-même, ensemble de tous les nombres, se note quant à elle (vn).


Utilisation et manipulation

Une fois une liste définie, on peut accéder à ces éléménts, les manipuler, les modifier, …
V=[1,2,6,78];
print(V[0])
#affiche 1
print(V[2])
#affiche 6
V[2]=3
print(V)
#affiche [1,2,3,78]
V[3]=V[0]+V[1]+V[2]
print(V)
#affiche [1,2,3,6]
Remarque 1:
python commence à numéroter les éléments d'une liste à partir de 0: le 1er élément est V[0], le 2ème V[1], …
Remarque 2:
Une liste n'est pas une fonction (voir fonctions en python), et on n'utilise donc pas de parenthèses mais des crochets: V(1) est l'appel de la fonction V avec la comme paramètre, ou variable, 1. Si V n'est pas une fonction, mais une liste par exemple, python retourn une erreur du type TypeError: object is not callable.

Ajout d'éléments à une liste

On peut ajouter un nouvel élement à une liste avec la méthode append (ajouter, en anglais), par exemple
V=[1,2,3]
print(V)
#affiche [1,2,3]
V.append(4)
print(V)
#affiche [1,2,3,4]

Initialisation d'une liste

Comme toutes les variables en python, on peut initialiser une liste directement en la définissant (comme dans tous les exemples précédents).
Si on y tient vraiment, par exemple pour éviter les interférences avec une variable du même qui pourrait avoir été utilisée auparavant, la commande
L=[]
fait l'affaire.
On peut aussi choisir d'initialiser une liste de la taille souhaitée, avec des zéros par exemple.
En utilisant la méthode append:
L=[]
for i in range(10):
    L.append(0)
print(L)
ou, plus efficacement en python, mais plus astucieux (voir liste en compréhension):
V=[0 for i in range(10)]


Opérations sur les listes

Longueur d'une liste - Nombre d'éléments

Le nombre d'éléments d'une liste est facilement donné par la fonction len (pour length, longueur en anglais):
V=[1,2,5,78]
n=len(V)
print(n)
#affiche 4
Ainsi, dès qu'on veut par exemple manipuler tous les éléments d'une liste, on peut combiner utilement les fonctions range() et len().
Par exemple, pour afficher les éléments d'une liste:
L=[1,2,5,78]
for i in range(len(L)):
    print(L[i])
#affiche 4

Ajouter un élément

On a vu un peu plus haut qu'on ajoute un élément à une liste avec la méthode append
L=[1,2,3]
print(V)
#affiche [1,2,3]
L.append(4)
print(V)
#affiche [1,2,3,4]

Effacer un élément

On efface un élément (la longueur de la liste est alors diminuée de 1) avec la fonction del
L=[1,2,5,78]
print(L)
#affiche [1,2,5,78]
del(L[0])
print(L)
#affiche [2,5,78]

Fusionner des listes - Concaténation

Pour fusionner des listes, c'est-à-dire faire une liste à partir de deux listes, on peut utiliser la méthode extend.
A=[1,3,5,7]
B=[2,4,6,8]
A.extend(B)
print("A=",A)
#affiche A= [1, 3, 5, 7, 2, 4, 6, 8]
On parle aussi de concaténation des listes A et B.
L'opérateur de concaténation est simplement + en python (mais attention au sens, ce n'est pas vraiment l'addition usuelle de nombres !)
print("2+3=",2+3)
#affiche 2+3=5
A=[1,3,5,7]
B=[2,4,6,8]
print("A+B=",A+B)
#affiche A+B=[1, 3, 5, 7, 2, 4, 6, 8]
a="abc"
b="defg"
print("a+b=",a+b)
#affiche a+b= abcdefg
Pour des manipulations plus précises, on peut plus généralement définir une nouvelle liste, qu'on remplit comme souhaité, par exemple
A=[1,3,5,7]
B=[2,4,6,8]
C=[]
for i in range(len(A)):
    C.append(A[i])
    C.append(B[i])
print(C)
#affiche cette fois C= [1, 2, 3, 4, 5, 6, 7, 8]

Extraire des éléments d'une liste - Sous-listes

On peut extraire des éléments à loisir d'une liste en en construisant une nouvelle comme dans l'exemple précédant.
Il existe aussi des méthodes simples et efficaces pour cela.
On a tout d'abord simplement pour une liste A, A[0] est le 1er élément, A[1] est le 2ème élément, …
Python permet de compter aussi négativement; on part alors de la fin de la liste: A[-1] est le dernier élément, A[-2] est l'avant dernier élément, …
On peut extraire aussi toute une sous-liste: A[2:4] désigne la sous-liste de A, du 3ème élément (comme A[2]) au 4ème.
Par défaut, si dans l'intervalle i:j, i est omis, python considère que i=0, et si j est omis, python considère que j=len(A).
A=[1,3,18,87,105,200]
print(A)
#affiche [1, 3, 18, 87, 105, 200]
print(A[2])
#affiche 18
print(A[2:4])
#affiche [18, 87]
print(A[:3])
#affiche [1, 3, 18], et qui est équivalent à A[0:3]
print(A[4:])
#affiche [105, 200], et qui est équivalent à A[4:len(A)]
print(A[-1])
#affiche 200, le dernier élément
print(A[-2])
#affiche 105, l'avant dernier élément
print(A[2:2])
#affiche [], liste vide
print(A[2:3])
#affiche [18], liste d'un seul élément: A[2]
Remarque:
A[i] est ici un nombre (entier), tandis que A[i:j] est une liste. Par ailleurs, A[2] est, comme A[2:3] le 3ème élément de la liste A; néanmoins, A[2] est un nombre entier tandis A[2:3] est une liste contenant un seul élément.

Opérations terme à terme sur les éléments d'une liste

Pour les opérations sur les listes, terme à terme entre autre entre deux listes, on peut généralement balayer tous les éléments avec une boucle.
Par exemple pour jouter deux listes, terme à terme:
A=[1,2,3,4]
B=[5,6,7,8]
C=[]
for i in range(len(A)):
    C.append(A[i]+B[i])
print(C)
#affiche [6, 8, 10, 12]
ou pour multiplier par 3 tous les éléments d'une liste:
A=[1,2,3,4]
for i in range(len(A)):
    A[i]=A[i]*3
print(A)
#affiche [3, 6, 9, 12]

Copie d'une liste

Une liste étant aussi une variable, on peut s'attendre à pouvoir la manipuler exactement comme toute variable.
Sur un point ce n'est pas vrai, et il faut y prendre garde.
Par exemple, pour des variables qui ont des valeurs numériques:
x=3
y=x
x=18
print("x=",x," et y=",y)
#affiche x= 18  et y= 3
Par contre, avec des listes:
A=[1,2,3,4]
B=A
A[1]=18
print("A=",A," et B=",B)
#affiche A= [1, 18, 3, 4]  et B= [1, 18, 3, 4]
En fait, l'instruction B=A ne créé pas une deuxième liste B dont les valeurs seraient égales à celles de A, mais duplique simplement la liste A: la variable B pointe vers les valeurs de A.
Ainsi, un changement de A est aussi un changement, et le même, pour B.

Pour créer une "vraie" copie indépendante, il faut copier toutes les valeurs. L'ensemble des valeurs étant simplement A[:], il suffit de faire:
A=[1,2,3,4]
B=A[:]
A[1]=18
print("A=",A," et B=",B)
#affiche A= [1, 18, 3, 4]  et B= [1, 2, 3, 4]
Une autre manière, à la fois efficace et élégante de manipuler les éléments d'une liste, et la définition de listes en compréhension.

Liste en compréhension

Python est un langage qui permet de définir des listes en compréhension, c'est-à-dire des listes définie par filtrage, ou opération terme à terme, sur le contenu d'une autre liste.
Cette construction est assez similaire à celle utilisée en mathématiques, plus précisément en théorie des ensembles (ce qui n'est pas si étonnant, une liste étant un ensemble…).
Par exemple, pour ajouter terme à terme les éléments de deux listes (de même taille bien sûr):
L=[0,1,2]
M=[3,4,5]
N=[L[i]+M[i] for i in range(len(L))]
print(N)
#retourne [3,5,7]
On peut ainsi aussi faire des calculs terme à terme sur les éléments d'un liste:
L=[0,1,2]
N=[3*x+2 for x in L]
print(N)
#retourne [2,5,8]
ou encore très simplement recopier une liste (plus simple que ça ?)
L=[0,1,2]
N=[x for x in L]

Liste en compréhension avec condition if

La syntaxe d'une liste en compréhension permet de plus de spécifier une condition, par exemple pour ajouter terme à terme les éléments de deux listes, seulement si la somme obtenue est inférieure à une valeur:
L=[0,1,2]
M=[3,4,5]
N=[L[i]+M[i] for i in range(len(L)) if (L[i]+M[i])<=5]
print(N)
#retourne cette fois [3,5]
ou filtrer tous les termes positifs d'une liste:
L=[1,-1,2,12,-35,7]
M=[x for x in L if x>0]
#retourne [1,2,12,7]

Liste en compréhension avec condition if et else

On peut y ajouter une condition avec la structure plus complète if … else par exemple pour calculer un tableau de valeurs pour la fonction définie par morceaux:
\[f(x)=\la\begin{array}{lll}
3x-1 &\text{ si } &x\leqslant 1 \\[.5em]
x^2+1 &\text{ si } &x>1\enar\right.\]
listx=range(-5,5)
listy=[3*x-1 if x<=1 else x**2+1 for x in listx]

Liste en compréhension avec condition if, elif et else

On peut encore compléter, en reprenant l'exemple précédent pour une fonction définie par 3 morceaux (ou plus).

Par exemple ici, pour donner le signe des éléments: 3 cas "+", "-" et "0":
L=[1,-1,0,2,12,-35,0,7]
M=["+" if x>0 else "-" if x<0 else "0" for x in L]
print("M=",M)

Chaîne de caractères

Une chaîne de caractères (string en anglais) sont des listes de caractères. À ce titre, elles peuvent se manipuler comme les listes, par exemple:
s="mon permier (bref) texte !" 
print(s[0])
#affiche le 1er caractère: m
print(s[:3])
#affiche: mon
print(s[-7:])
#affiche: texte !
ou encore, pour extraire le premier mot, du début jusqu'au premier espace:
s="mon permier (bref) texte !" 
e1=s.index(" ")
print(e1)
#affiche: 3
print(s[:e1])
#affiche: mon

Top Programmation en python