\chapter{Les listes}
\label{chap:listes}

\newpage
\pagestyle{main}

\section{Introduction}

\subsection{Définition}

Une \textit{liste} est un ensemble d'objets de tout type (nombres, chaînes de caractères, booléens, ...).

Une liste est définie:
\begin{itemize}
\item soit par le mot-clé \texttt{list})\index{Mot-cle@Mot-clé!list}
\item soit par des crochets et ses éléments sont séparés par une virgule.
\end{itemize} 

Chaque élément est \textit{indexé} par un nombre allant de 0 à $n-1$, où $n$ est le nombre d'éléments de la liste.

\begin{exemple}
\begin{enumerate}
\item Une liste de nombres :
\begin{console}
>>> A = list() # A est une liste vide
>>> L = [5 , 12 , 5 , -1 , 3 , 7]
>>> L[0]
5
>>> L[3]
-1
>>> L[-1]
7
\end{console}

\texttt{L[-1]} représente le dernier élément de la liste.

\texttt{L[-2]} représente l'avant-dernier.

etc.

\item Une liste de chaînes de caractères :
\begin{console}
>>> noms = [ 'Luc' , 'Nathan' , 'Virginie' , 'Paul' ]
>>> noms[0]
'Luc'
>>> noms[2]
'Virginie'
\end{console}
\end{enumerate}
\end{exemple}

Il sera plutôt rare d'utiliser des listes de chaînes de caractères en mathématiques.

\begin{rem}
Dans la pratique, il est assez rare que l'on définisse une liste par le mot-clé \texttt{list}. Très souvent, pour déclarer une liste vide, on écrira:

\begin{console}
>>> L = []
\end{console}
\end{rem}

\newpage


\subsection{Parcourir une liste}

Il existe plusieurs façons de parcourir une liste.

\subsubsection{Directement}

\begin{console}
>>> L = [ 2 , 5 , 6 ]
>>> for i in L:
		print(i)
2
5
6
\end{console}

Cette méthode est utilisée pour parcourir une liste sans avoir nécessairement besoin de l'index des éléments.


\subsubsection{Par index}

\begin{console}
>>> L = [ 2 , 5 , 6 ]
>>> for i in range( len(L) ):
		print( L[i] )
2
5
6
\end{console}

Cette méthode peut servir pour trouver l'index de tous les éléments égaux à un certain nombre.

\begin{exemple}
On souhaite afficher l'index de tous les éléments d'une liste égaux à 5.

\medskip
\index{Liste!len (longueur)}
\index{Mot-cle@Mot-clé!len}

\begin{minipage}{0.6\linewidth}
Programme :

\begin{python}
L = [ 1 , 5 , 2 , 5 , 6 , 5 , 7 , 9 ]

for i in range( len(L) ):
    if L[i] == 5:
        print(i)
\end{python}
\end{minipage}
\hfill
\begin{minipage}{0.35\linewidth}
Résultat en mode \og console \fg{}:
\begin{console}
1
3
5
\end{console}
\end{minipage}
\end{exemple}

\begin{rem}
Notez ici la présence du mot-clé \texttt{len}, qui désigne la longueur (\textit{length} en anglais) de son argument. L'argument peut aussi être une chaîne de caractères.
\end{rem}


\newpage

\subsection{Connaître l'index d'un élément}
\index{Listes!index}

Si une liste est composée d'éléments deux à deux distincts, c'est-à-dire si aucun élément n'apparaît plus d'une seule fois, on peut connaître l'index de chaque élément à l'aide de la syntaxe suivante :

\begin{console}
>>> L = [1 , 2 , 3 ]
>>> L.index(2)
1
\end{console}

Ce résultat signifie que \texttt{L[1]} contient la valeur \og 2 \fg.

\medskip

Si la liste contient plusieurs \og 2 \fg{} alors \texttt{L.index(2)} retourne l'index du premier élément égal à 2.



\section{Opérations diverses} 

\subsection{Définir une liste vide}

On peut définir une variable comme étant une liste vide de deux manières :

\begin{console}
>>> L = []
>>> G = list()
\end{console}

On préfèrera très souvent la première syntaxe car plus courte et rapide.

\subsection{Ajouter un élément}

On utilise la \textit{méthode} \texttt{append()}.
\index{Liste!append}

\begin{console}
>>> L.append(5)
>>> L
[5]
>>> L.append(3)
>>> L
[5, 3]
\end{console}

Cette méthode ajoute \textit{en fin de liste} l'élément mis entre parenthèses.

\subsection{Ajouter plusieurs éléments}
\index{Liste!extend}

La méthode \texttt{append} ne permet d'ajouter qu'un élément à chaque fois. Aussi, pour ajouter plusieurs éléments en même temps, on utilise la méthode \texttt{extend} :

\begin{console}
>>> L.extend([2,7])
>>> L
[5, 3, 2, 7]
\end{console}

mais on peut aussi écrire :

\begin{console}
>>> L = L + [2,7]
\end{console}

\subsection{Liste par compréhension}
\index{Liste par compréhension}
\index{Compréhension (liste)}

Il est quelques fois utile de construire une liste en s'appuyant sur une formule.

\begin{exemple}
On souhaite créer la liste des 10 premiers nombres entiers élevés au carré :
\begin{center}
\texttt{L = [0 , 1 , 4 , 9 , 16 , ... , 81 ]}
\end{center}

On pourrait bien entendu utiliser une boucle \texttt{for} de la manière suivante :

\begin{console}
>>> L = []
>>> for n in range(10):
		L.append(n**2)
\end{console}

Mais il existe une manière plus courte de faire cela : construire la liste \textit{par compréhension} :

\begin{console}
>>> L = [ n**2 for n in range(10) ]
>>> L
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
\end{console}
\end{exemple}

\subsection{Liste composée d'un même nombre}

Si l'on souhaite construire une liste de 10 \og 0 \fg{} (par exemple), on pourra écrire :

\begin{console}
>>> L = [0] * 10
>>> L 
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
\end{console}

Après, si un élément est changé en \og 1 \fg, par exemple le 5\ieme{} élément, on pourra écrire :

\begin{console}
>>> L[4] = 1
>>> L
[0, 0, 0, 0, 1, 0, 0, 0, 0, 0]
\end{console}

\newpage

\section{Matrices}
\index{Matrices}

\subsection{Introduction}

Pour représenter une matrice, on peut utiliser une liste de listes.

\begin{exemple}
On souhaite représenter la matrice:
\[
A = \begin{pmatrix}
1 & -1 & 2\\
0 & 1 & 3\\
-1 & 1 & -2
\end{pmatrix}
\]
On peut le faire ainsi:
\begin{console}
>>> A = [ [1, -1, 2], [0, 1, 3], [-1, 1, -2] ]
\end{console}
\end{exemple}

\subsection{Matrice vide}

Si on souhaite définir une matrice à 5 lignes et 5 colonnes ne comportant que des \og 0 \fg, on pourra le faire ainsi :

\begin{console}
>>> A = [ [0]*5 for k in range(5) ]
\end{console}


Si on souhaite insérer le nombre \og 1 \fg{} dans \texttt{A[1][2]}, on écrira :
\begin{console}
>>> A[1][2] = 1
>>> A 
[[0, 0, 0, 0, 0], [0, 0, 1, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]
\end{console}

\begin{rem}
Dans \texttt{A[i][j]}, \texttt{i} désigne la ligne et \texttt{j}, la colonne.
\end{rem}

%\begin{attention}
%On serait peut-être tentés de définir une matrice vide par la méthode suivante :
%\begin{console}
%>>> B = [ [0]*5 ]*5
%\end{console}
%mais ceci est une erreur. En effet, si l'on écrit:
%\begin{console}
%>>> B[1][2] = 1
%>>> B
%[[0, 0, 1, 0, 0], [0, 0, 1, 0, 0], [0, 0, 1, 0, 0], [0, 0, 1, 0, 0], [0, 0, 1, 0, 0]]
%\end{console}
%on remarque que le résultat n'est pas celui espéré.
%\end{attention}


