== Utiliser le contenu d’une liste ==


Écrivez une fonction :
{{{#!highlight python
def somme_liste(l):
	...
}}}
qui renvoie la somme des valeurs d’une liste de nombres,
puis une fonction :
{{{#!highlight python
def moyenne_liste(l):
	...
}}}
qui renvoie la moyenne des valeurs (en supposant la liste non vide).


{{{{#!wiki comment/dotted
Pour la somme:
{{{#!highlight python
def somme_liste(L):
    somme = 0
    for valeur in L:
        somme += valeur
    return somme
}}}
et la moyenne:
{{{#!highlight python
def moyenne_liste(L):
    return somme_liste(L)/len(L)
}}}

Notez que pour la somme, Python fournit déjà une fonction `sum()` !
}}}}


== Construire une liste ==

Écrivez une fonction :
{{{#!highlight python
def liste_carres(n):
	...
}}}
qui renvoie la liste des carrés des entiers de `0` à `n-1`.

Proposez une expression de liste en compréhension qui fait le même travail.

Écrivez une fonction :
{{{#!highlight python
def suite_recurrente(f,a,N):
	...
}}}
qui renvoie la liste des valeurs successives de la suite `u(n)` définie par `u(0)=a` et `u(n+1)=f(u(n))`, pour `n` variant de `0` à `N`.


== Transformer une liste ==


Écrivez une fonction :
{{{#!highlight python
def ajoute_un(l):
	...
}}}
qui renvoie la liste obtenue en ajoutant `1` à toutes les valeurs de `l`.

Proposez une expression de liste en compréhension qui fait le même travail.

Écrivez une fonction :
{{{#!highlight python
def pairs(l):
	...
}}}
qui renvoie la liste des valeurs de `l` en position paire (par exemple `pairs(['a','b','c','d','e']) == ['a','c','e']`).

Proposez une expression de liste en compréhension qui fait le même travail.


== Tester l’appartenance ==

Écrivez une fonction :
{{{#!highlight python
def trouve(l,x):
	...
}}}
qui renvoie `True` si `x` est un élément de la liste `l` et `False` sinon.

Testez :
{{{#!highlight python
l=[1,6,6,4]
trouve(l,0)
trouve(l,1)
trouve(l,6)
trouve(l,4)
trouve('Bonjour','B')
trouve('Bonjour','b')
}}}

Transformez légèrement la fonction pour qu’elle renvoie l’indice de 
`x` dans `l` (le numéro de la première « case » où `x` apparaît) au lieu de `True`.
Testez :
{{{#!highlight python
trouve(l,6)
trouve(l,6) == False
trouve(l,1)
trouve(l,1) == False
}}}
Argh ! Que s’est-il passé ? Le test d’égalité prend en fait en compte 
des conversions possibles entre les types, et permet de considérer 
que `False == 0` et `True == 1`. Donc `False` n’est pas un bon choix de valeur
d’erreur. On pourrait prendre `-1` par convention, mais seulement parce qu’on
sait qu’on attend un résultat positif. La manière « propre » de gérer ce cas, 
c’est d’utiliser la constante `None`, de type `NoneType`, qui a la propriété 
de n’être égale qu’à elle-même. Modifiez donc encore la fonction pour renvoyer
`None` plutôt que `False` dans le cas où on ne trouve pas l’élément.

{{{{#!wiki note

Maintenant que vous avez programmé ces fonctions, on peut révéler que c’était inutile (sauf comme indispensable exercice d’algorithmique).

On peut tester l’appartenance à un tableau avec le mot-clé `in`:
{{{#!highlight python
6 in [1,2,3]
6 in [4,5,6]
'j' in 'bonjour'
}}}
et on peut trouver le rang d’un élément avec la ''méthode'' `index` de n’importe quel type indexé:
{{{#!highlight python
[3,1,4,1,5,9].index(4)
[3,1,4,1,5,9].index(1)
'bonjour'.index('o')
}}}
Pour les chaînes ça fonctionne de manière plus générale avec les sous-chaînes:
{{{#!highlight python
'jour' in 'bonjour'
'nuit' in 'bonjour'
'bonjour'.index('jour')
}}}
Attention, la méthode `index` lève une exception quand l’élément recherché ne se trouve pas dans le tableau:
{{{#!highlight python
'bonjour'.index('nuit')
}}}
}}}}

== Ordre lexicographique ==

Lorsqu’on a une relation d’ordre total sur les éléments des listes (autrement dit, on peut
les comparer deux-à-deux), on peut définir l’ordre lexicographique sur les listes,
qui comme son nom l’indique est l’ordre du dictionnaire. Voir [[https://fr.wikipedia.org/wiki/Ordre_lexicographique|la page Wikipédia]] sur le sujet.

Écrivez une fonction
{{{#!highlight python
def compare_2(a,b):
	...
}}}
telle que, en supposant que `a` et `b` sont des couples (des séquences de longueur 2)
renvoie `-1` si `a` est avant `b` dans l’ordre lexicographique, `1` si `b` est avant `a`
et `0` sinon (dans ce cas, `a == b`). On ne s’intéresse pas au comportement de la fonction 
si `a` et `b` n’ont pas les bonnes longueurs.

Testez la fonction dans un peu tous les cas.

Écrivez maintenant une fonction
{{{#!highlight python
def compare_meme(a,b):
	...
}}}
qui a le même comportement, en supposant cette fois seulement que `a` et `b` sont de même longueur
(mais cette longueur n’est pas fixée).

Testez. Attention au cas des séquences vides !

Terminez avec une fonction
{{{#!highlight python
def compare(a,b):
	...
}}}
similaire aux précédentes, mais cette fois avec `a` et `b` de longueurs quelconques.
Testez.

== Renverser une chaîne ==

Écrivez une fonction :
{{{#!highlight python
def renverse(entree):
	...
}}}
qui prend en argument une chaîne `entree` et renvoie la chaîne 
renversée, c’est-à-dire que `renverse('abcde')` doit renvoyer (et pas afficher) `'edcba'`.

Rappelez-vous qu’il n’y a pas de manière naturelle en Python de dire quelque chose comme :
« on part avec un tableau vide de n cases », et surtout que les chaînes ne sont pas mutables.
Il faut donc ''construire'' le résultat.

Trouvez une manière de modifier la fonction `renverse` pour obtenir une fonction `renverse_listes`
qui fonctionne de la même manière sur les listes.


== Renverser une liste (en place) ==


Écrivez une ''procédure'' :
{{{#!highlight python
def retourne(entree):
	...
}}}
qui prend en argument une liste `entree` et transforme cette liste pour que
l’ordre des éléments soit renversé. Autrement dit, il faut qu’après :
{{{#!highlight python
l = [1,2,3]
retourne(l)
}}}
`l` contienne `[3,2,1]`.

La réponse au tout premier exercice sera utile.

Vérifiez que la fonction `retourne` ''ne peut pas'' être utilisée de 
la même manière sur les n-uplets et les chaînes.