= Quelques exercices de programmation classiques =


== Échanger deux variables ==

Après :
{{{#!highlight python
a = 1
b = 'Ceci n’est pas un nombre.'
a = b
b = a
}}}
que valent `a` et `b` ?

Comment échanger les valeurs de deux variables ?

(Astuce : il en faut une troisième.)


== 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 « 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')
}}}
On verra plus tard comment gérer ça. Dans l’attente, on peut tester avec `in`.
}}}}

== 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.

Vérifiez que la fonction ``renverse`` peut aussi être utilisée de 
la même manière sur les séquences (listes, n-uplets).


== 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 ``renverse`` ''ne peut pas'' être utilisée de 
la même manière sur les n-uplets et les chaînes.