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 = list(range(7))
  >>> L
  [0, 1, 2, 3, 4, 5, 6]
  >>> list(range(2,7))
  [2, 3, 4, 5, 6]
  >>> list(range(2,17,2))
  [2, 4, 6, 8, 10, 12, 14, 16]

Travaux pratiques

• Afficher la liste des nombres pairs jusqu'à 25. Faire de même avec les nombres impairs.
• Afficher la liste des 30 premières puissances de 2, et calculer leur somme. On rappelle que la puissance s'obtient, en python, par deux étoiles.
• Demander à l'utilisateur de saisir un mot, et afficher la liste de ses

voyelles.

• Etant donné une liste :
  • en afficher son élément le plus fréquent,
  • afficher l'indice de son maximum.

Accession et modification

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 = list(range(1,10))
  >>> L
  [1, 2, 3, 4, 5, 6, 7, 8, 9]
  >>> L[3:6]
  [4, 5, 6]

On peut aussi ne pas spécifier le premier (ou le dernier) élément, voire utiliser des entiers négatifs :

  >>> L[:5]
  [0, 1, 2, 3, 4]
  >>> L[-3:]
  [7, 8, 9]
  >>> L[7:]
  [7, 8, 9]

On peut enfin fixer le pas en troisième argument, par exemple :

  >>> L[::2]
  [1, 3, 5, 7, 9]

pour ne récupérer qu'un terme sur deux, ou :

  >>> L[::-1]
 [9, 8, 7, 6, 5, 4, 3, 2, 1]

pour inverser une liste.

Manipulation des listes

Les méthodes de base

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 occurrence de l'élément x dans la liste L :

  >>> L

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

del

Supprime la valeur à une position donnée

  >>> L

  >>> del L[1]
  >>> L
  [1, 3, 1, 2, 3, 1, 2, 3]

On a ci-dessus supprimé l'élément qui était positionné en L[1].

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 = list(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

Écrire 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

Écrire 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.

Transposition d'une liste de listes

Écrire un programme qui "transpose" une liste de listes, i.e., qui transforme par exemple [ ['a', 'b'], ['c', 'd'], ['e', 'f'] ] en [ ('a', 'c', 'e'), ('b', 'd', 'f') ].

N.B.: Une manière pythonique de faire cela :

  >>> chars = [ ['a', 'b'], ['c', 'd'], ['e', 'f'] ]
  >>> list(zip(*chars))
  [ ('a', 'c', 'e'), ('b', 'd', 'f') ]

Agrégation par accumulation

Faire un programme qui transforme une liste en une liste croissante, de la manière suivante :

• Si l'élément en position t+1 est supérieur ou égal à l'élément en position t, on le garde,
• Sinon on le remplace par celui en position t.

Ainsi, [3, 4, 1, 3, 5, 6, 9, 0, 1] est transformé en [3, 4, 4, 4, 5, 6, 9, 9, 9]. Vérifiez vos résultats sur des listes tirées aléatoirement, et en comparant avec :

  from itertools import accumulate
  list(accumulate(data, max))

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], ... ]