Une liste est un conteneur, les éléments sont rangés de manière ordonnée.

Création

En extension

Pour créer une liste, on utilise des crochets :

  >>> L = [1,2,5,3,2,1,5,2] 
  >>> L
  [1, 2, 5, 3, 2, 1, 5, 2]

Par ajout

On peut aussi ajouter des éléments à une liste vide. On crée une liste vide ainsi :

  >>> L = []

Pour ajouter un élément, on utilise la méthode append :

  >>> L.append(5)
  >>> L.append('a')
  >>> L
  [5, 'a']

On constate qu'une liste peut posséder des éléments de types différents (ici, entier et caractère).

Avec range

Enfin, pour créer des listes d'entiers en progression arithmétique, on peut utiliser la méthode range :

  >>> L = range(7)
  >>> L
  [0, 1, 2, 3, 4, 5, 6]
  >>> range(2,7)
  [2, 3, 4, 5, 6]
  >>> range(2,17,2)
  [2, 4, 6, 8, 10, 12, 14, 16]

Accession

A un élément quelconque

On peut accéder à un élément avec sa position, et le modifier :

  >>> L[0]
  5
  >>> L[0] = 7
  >>> L
  [7, 'a']

On se souviendra que le premier élément d'une liste est l'élément 0.

Aux derniers éléments

La fonction len renvoie la longueur d'une liste :

  >>> len(L)
  2

Donc si on peut atteindre le dernier élément de L, on peut procéder ainsi :

  >>> n = len(L)
  >>> print L[n-1]
  'a'

en se rappelant que, puisque l'on commence à 0, le dernier élément est n-1.

Une autre méthode consiste à utiliser une particularité de la syntaxe python : L[-1] représente le dernier élément, L[-2] l'avant dernier, etc.

  >>> print L[-1]
  'a'

Slicing (tranches)

On peut extraire facilement des éléments d'une liste :

  >>> L = range(1,10)
  >>> L
  [1, 2, 3, 4, 5, 6, 7, 8, 9]
  >>> L[3:6]
  [4, 5, 6]

Les méthodes

count

Pour compter le nombre d'occurrences d'un élément dans une liste.

  >>> M = [1, 2, 3, 1, 2, 3, 1, 2, 3]

  3

extend

Soient M et L deux listes. M.extend(L) est équivalent à M = M + L (concaténation de deux listes).

  >>> M = [1,2,3]

  >>> M.extend(L)
  >>> M
  [1, 2, 3, 4, 5, 6]

index

L.index(x) retourne l'indice de la première occurrence de l'élément x dans la liste L :

  >>> L = [1, 2, 3, 1, 2, 3, 1, 2, 3, 'a']

  0
  >>> L.index(3)
  2

insert

L.insert(n,x) insère l'élément x dans la liste L, en position n :

  >>> L = [1, 2, 3, 1, 2, 3, 1, 2, 3, 'a']

  0
  >>> L.index(3) 
  2
  >>> L.insert(3,1234)
  >>> L
  [1, 2, 3, 1234, 1, 2, 3, 1, 2, 3, 'a']

pop

L.pop() retourne le dernier élément de la liste L, et le supprime de L :

  >>> L

  >>> L.pop()
  'a'
  >>> L
  [1, 2, 3, 1234, 1, 2, 3, 1, 2, 3]

Cela peut aussi s'appliquer à un autre élément, dont l'indice est passé en argument :

  >>> L
  [1, 2, 3, 1234, 1, 2, 3, 1, 2, 3]
  >>> L.pop(3)
  1234
  >>> L
  [1, 2, 3, 1, 2, 3, 1, 2, 3]

remove

L.remove(x) supprime la première occurence de l'élément x dans la liste L :

  >>> L

  >>> L.remove(3)
  >>> L
  [1, 2, 1, 2, 3, 1, 2, 3]

reverse

Renverse la liste.

  >>> L

  >>> L.reverse()
  >>> L
  [3, 2, 1, 3, 2, 1, 2, 1]

sort

Trie la liste.

  >>> L

  >>> L.sort()
  >>> L
  [1, 1, 1, 2, 2, 2, 3, 3]

On peut trier par ordre décroissant :

  >>> L.sort(reverse = True)
  >>> L
  [3, 3, 2, 2, 2, 1, 1, 1]

On peut aussi utiliser son propre ordre : une fonction prenant deux arguments x et y, et retournant -1, 0, ou 1, suivant que x est inférieur, égal ou supérieur à y pour ce nouvel ordre :

  >>> def nouvelOrdre(x,y):
  ...     if abs(x)>abs(y): return 1
  ...     elif abs(x)<abs(y): return -1
  ...     else : return 0
  ... 
  >>> L.sort(cmp = nouvelOrdre)
  >>> L
  [-1, 3, 4, -6, 7, -7]

Arithmétique des listes

On peut utiliser l'addition + pour concaténer deux listes :

  >>> L = [1,2,3]
  >>> L+[1, 2]
  [1, 2, 3, 1, 2]

et la multiplication * permet de reproduire plusieurs fois le contenu d'une liste :

  >>> L = [1,2,3]
  >>> L*3
  [1, 2, 3, 1, 2, 3, 1, 2, 3]

Le mapping

Le mapping consiste à appliquer une fonction à tous les éléments d'une liste. Ainsi, map(f,[a,b,c,...]) renvoie la liste [f(a), f(b), f(c), ...]. Par exemple, pour obtenir la liste des carrés des 10 premiers entiers :

  >>> L = range(10)
  >>> L
  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  >>> def carre(x) : return x**2
  ... 
  >>> map(carre,L)
  [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Cet outil tend à disparaître dans les versions nouvelles de python, avec l'apparition d'un nouvel objet plus puissant : les listes compréhensives.

Les listes compréhensives

Présentation

Cet outil, puissant et élégant, permet de créer des listes à partir d'autres listes, en se basant sur l'existence d'un test d'appartenance à une liste :

  >>> L
  [49, 30, 18, 26, 49]
  >>> 30 in L
  True
  >>> 31 in L
  False

Opération simple

Supposons que l'on souhaite constituer la liste des divisions par 2 des éléments de L. Au lieu d'utiliser map, en créant une fonction intermédiaire, on peut penser aux listes compréhensives :

  >>> L
  [49, 30, 18, 26, 49]
  >>> M = [x/2 for x in L]
  >>> M
  [24, 15, 9, 13, 24]

Ajout d'une condition

On peut inclure une condition dans les listes compréhensives.

Supposons, par exemple, que l'on ait constitué aléatoirement une liste de 20 entiers inférieurs à 100 :

  >>> from random import randint
  >>> L=[]
  >>> for k in range(20):
  ...     L.append(randint(1,100))
  ... 
  >>> L
  [88, 93, 97, 90, 6, 1, 9, 99, 60, 36, 53, 98, 41, 48, 10, 68, 88, 37, 13, 22]

Si on veut extraire de L la liste des entiers divisibles par 3, on peut procéder ainsi :

  >>> M = [x for x in L if x%3 == 0]
  >>> M
  [93, 90, 6, 9, 99, 60, 36, 48]

On peut ajouter une opération dans les listes compréhensives. Par exemple, si on souhaite constituer la liste des carrés des nombres divisibles par 3, on peut procéder ainsi :

  >>> M = [x**2 for x in L if x%3 == 0]
  >>> M
  [8649, 8100, 36, 81, 9801, 3600, 1296, 2304]

Travaux pratiques

Une liste de sinus

Ecrire un script qui crée automatiquement la liste des sinus des angles de 0^o à 90^o par pas de 5^o. Attention : la fonction sin() du module math s'applique à des angles fournis en radians.

Diviseurs d'un entier

Ecrire un programme qui demande à l'utilisateur de saisir un entier naturel $n$ et qui affiche ensuite la liste des diviseurs positifs de $n$ rangés dans l'ordre croissant. On utilisera une liste compréhensive.

Statistiques

On donne la répartition des 95 employés d'une entreprise en fonction de leur salaire annuel (exprimé en milliers d'euros).

$\begin{array}{|cl|c|c|c|c|c|c|} \mathrm{salaire} &x_i & 13.2 & 14.4 & 15 & 16.8 & 18 & 28.8 \\ \mathrm{effectif}& n_i & 27 & 22 & 18 & 15 & 10 & 3 \\ \end{array}$

1. Définir les données ci-dessus sous la formes de deux listes distinctes $x_i$ et $n_i$.
2. Créer la liste des fréquences de cette série statistique (la fréquence $f_i$ d'une valeur $i$ est égale au nombre de fois que cette valeur apparaît divisé par le nombre total de valeurs)
3. Faire calculer la moyenne, la variance et l'écart-type de cette série. La variance est la somme des $f_i x_i^2$, moins la moyenne au carré.
4. Fusionner les deux listes xi et ni en une seule liste formée de couples sous la forme : [ [13.2,27] , [14.4,22], ... ]