TP0 : le Python en 2 heures

Dans chaque paragraphe, il y a un gros pâté de lignes de code ; vous
devez copier ces lignes dans l’interpréteur Python une à une pour
observer leur effet. Ces petits exemples vont vous permettre de vous
familiariser très, très vite avec ce nouveau langage. Après chaque
paragraphe, il y a des petits exercices liés aux concepts présentés.
Foncez ! :-)



Tour d’horizon rapide du langage




On lance l’interpréteur en tapant “python”. On obtient un prompt >>>. On tape les instructions directement, il n’y a pas besoin de mettre un point virgule à la fin des lignes.



Des chiffres et des lettres




# ceci est un commentaire 
print 2+2 # on affiche avec "print"
print "dro"+'madaire' # les chaînes peuvent être avec des " ou des ' et on peut les concaténer
print "a"+2*"na"+"s" # on peut aussi multiplier les chaînes
print "mignonne allons voir si la rose\netc." # on peut mettre des \quelquechose
alphabet="abcdefghijklmnopqrstuvwxyz" # on définit une variable
print alphabet # ça affiche l'alphabet, pas de surprise
print len(alphabet) # "len" c'est pour "length", c'est-à-dire "longueur"
print (2**8)%100 # 2 puissance 8, le tout modulo 100 (ça fait 56)



Exercice 1 : soit une variable appelée “message” et contenant un
message de moins de 75 caractères. Écrire un bout de programme qui
affiche ce message en l’encadrant avec des *.

Par exemple, si on tape dans l’interpréteur :
message="coin coin"
...votre programe...

Alors il doit s’afficher :
*************
* coin coin *
*************



Exercice 2 : on garde la variable “message” ; mais cette fois-ci on
veut que le cadre fasse 79 caractères de large et que le message soit
centré, par exemple (j’ai mis des points pour la mise en page, mais ils
ne doivent pas apparaître, bien sûr) :

*******************************************************************************
* . . . . . . . . . . . . . . . . .coin coin. . . . . . . . . . . . . . . . . *
*******************************************************************************



Des listes (ou des tableaux, c’est pareil)


simpsons=["homer","marge","bart","lisa","maggie"]
print simpsons[0] # les listes, ça commence à zéro
print simpsons[1:3] # sous-liste de l'élément 1 inclus jusqu'au 3 exclus
print simpsons[-1] # -N = Nème élément en partant de la fin
print simpsons[2:] # sous-liste de l'élément 2 jusqu'à la fin
simpsons.sort() # tri alphabétique
print simpsons # affiche la liste triée
fils=simpsons[0] # c'est "bart" vu qu'on a trié dans l'ordre alphabétique
print fils[0] # surprise : une chaîne, c'est une liste de caractères...
print simpsons[-2][3:] # oui oui, on peut faire ça



Exercice 3 : on va faire l’inverse de l’exercice 1 … À savoir : on
suppose qu’il existe une variable “message”, contenant un message
encadré d’étoiles. Écrire un bout de programme permettant de retrouver
le message original.
Si, par exemple :

message="*"*13+"\n* coin coin *\n"+"*"*13

Alors le programme doit afficher “coin coin”. Bien sûr, il faut que cela
marche quelle que soit la taille du message (pas seulement avec des
messages de 9 caractères!). On suppose que le message original est bien
construit (c’est-à-dire qu’il n’y a pas d’étoiles en plus ou en moins
que ce qu’il faut).



Du has©h




Écouter attentivement l’explication !



moi={"nom":"jerome", "date_de_naissance":[4,7,1980],
     "poissons_rouges":2, 123:"un deux trois"}
moi["ville"]="plessis" # ajoute une clé
moi["ville"]="paris" # modifie la valeur
del moi[123] # supprime une valeur
print moi # affiche la table résultante



Les structures de contrôle




Attention: il y a un petit bug dans le
copier/coller de firefox ; les espaces en début de ligne ne passent
pas. Lorsque vous copiez/collez les exemples suivants, n’oubliez pas de
les ajouter à la main ! Peu importe que vous mettiez 1, 2, 4, 42
espaces au début de chaque ligne, du moment que vous mettez le même
nombre à chaque fois.

if 5>2: print “5 est plus grand que 2”

else: print “5 est plus petit que 2”

	
for nom in simpsons: print nom+” est un simpson”


	
print “la famille simpson comprend:”

for nom in simpsons:
    nom_complet=nom+” simpson”
    print nom_complet


	
s=“abracadabrakangourou”

t=”“

while s:
    if s0==“k”: break
    t=t+s0
    s=s[1:]


	
print s

print t



On note qu’il n’y a pas d’accolade : c’est l’indentation qui détermine les blocs de code !



Exercice 4 : écrire un bout de programme qui prend deux chaînes s1 et
s2 et qui les “tricotte” ensemble, par exemple si s1=“abcdef” et
s2=“0123456789”, le résultat doit être “a0b1c2d3e4f56789” (on intercale
une lettre de la première, une lettre de la deuxième, etc.)



Exercice 5 : écrire un bout de programme qui “détricotte” une chaîne s
en deux chaînes, l’une contenant tous les caractères de rang pair et
l’autre ceux de rangs impairs. Par exemple pour le “a0b1c2d3e4f56789”
de la question précédente, cela donne “abcdef68” pour la première
chaîne et “012345679” pour la deuxième.



Définition de fonction


def addition(a,b,c):
    return a+b+c

	
def plusgrand(a,b,c):
    if a>b and a>c: return a
    if b>c: return b
    return c


	
def meteo(temperature, ciel, date=“demain”): # definition de paramètre(s) par défaut
    print date+”, le ciel sera”ciel” et il fera “str(temperature)” °”.


	
meteo(25,“bleu”)

meteo(22,“nuageux”,“mardi”)

meteo(28, date=“dimanche”,ciel=“clair”) # nommage des paramètres


Exercice 6


On suppose qu’on a la liste suivante :
daltons=[{"nom":"joe","taille":140,"caractere":"teigneux"},
         {"nom":"jack","taille":155,"caractere":"idiot"},
         {"nom":"william","taille":170,"caractere":"stupide"},
         {"nom":"averell","taille":185,"caractere":"abruti"}]

Ecrire une fonction compare_taille qui prenant en argument deux daltons (deux tables de hachage, en fait), comparant leur attribut “taille”, et renvoyant :

  • zéro s’ils sont de même taille

  • un nombre négatif si le premier est plus petit

  • un nombre positif si le premier est plus grand


Ecrire aussi une fonction compare_nom prenant en argument deux daltons, comparant leur attribut “nom”, et renvoyant :



  • zéro s’ils sont identiques

  • un nombre négatif si le premier est avant le second dans l’ordre alphabétique

  • un nombre positif si le premier est après le second dans l’ordre alphabétique


Exécuter le code suivant pour tester les fonctions :


print daltons
daltons.sort(compare_nom)
print daltons
daltons.sort(compare_taille)
print daltons

Interlude : comment faire un programme python?



Par convention, appeler le fichier quelquechose.py (ce n’est pas obligatoire, mais c’est comme appeler un source C quelquechose.c!)


Au début du source, mettre la ligne :
#!/usr/bin/python


Puis rendre le fichier exécutable (chmod +x toto.py).



On peut maintenant lancer le programme : ./toto.py arguments…


Le formatage des chaînes de caractères



Pour l’instant, nous avons utilisé des “+” pour concaténer les chaînes à afficher. Ce n’est pas la meilleure méthode.


Pour faire l’équivalent d’un printf, on fait comme ceci :
print "La somme de %d et %d, ça fait %d, qui est un nombre %s."%(2, 40, 2+40, "positif")


C’est-à-dire qu’on utilise l’opérateur modulo (%) qui va prendre à
gauche, une chaîne avec des %quelquechose, et à droite, une liste
d’arguments à remplacer.


Quelques fonctions utiles


Si on veut transformer un entier en chaîne (on l’a fait plus haut), on utilise la fonction str. Inversement, pour transformer une chaîne en nombre, on utilise int ; par exemple :
print int("2")+int("40") # ça fait 42

 
On a déjà vu que len renvoie la longueur de l’argument (qu’il s’agisse d’une chaîne de caractères, d’une liste…)


La bibliothèque



On va rencontrer en Python une écriture ressemblant à celle du C pour l’accès aux champs des structures et unions : le point.


 Ainsi, lorsqu’on écrit maison.chaise, on accède au champ “chaise” de la variable qui s’appelle “maison”.


 Ces champs peuvent être des fonctions ! On l’a déjà vu plus haut, quand on a fait ma_liste.sort() par exemple. On a appelé la méthode “sort” sur l’objet ma_liste.


 
D’autres exemples :


une_chaine="eviv bulgroz"
en_majuscule=une_chaine.upper() # met tout en majuscules
print en_majuscule
couleurs_html={"rouge":"#ff0000", "vert":"#00ff00", "bleu":"#0000ff", "blanc":"#ffffff", "noir":"#000000"}
print couleurs_html.keys() # affiche la liste des clés (avant les :)
print couleurs_html.values() # affiche la liste des valeurs (après les :)
print couleurs_html.items() # affiche une liste avec des couples (clé,valeur)
for cle,valeur in couleurs_html.items(): print "en html, pour avoir du "+cle+", il faut utiliser "+valeur
castors="riri&fifi&loulou"
liste_castors=castors.split("&") # crée une liste à partir d'une chaîne, en séparant avec le(s) caractère(s) indiqué(s)
print liste_castors
print ", ".join(liste_castors) # l'inverse : concatène les éléments d'une liste en les recollant avec la chaîne indiquée


Enfin, il y a un type d’objet particulier : les modules. Ce sont l’équivalent des bibliothèques en C, ou des packages en Java.


Pour utiliser un module, on fait import nom_du_module et cela permet ensuite d’appeler des fonctions dans ce module, par exemple nom_du_module.nom_de_la_fonction(parametres…)


 La documentation de tous les modules de base est disponible sur http://doc.python.org/lib/


 

Le module sys


import sys
print sys.argv # il s'agit des arguments du programme !
print "J'ai %d arguments, et le premier est %s"%(len(sys.argv),sys.argv[1])
sys.stderr.write("Ceci s'affiche sur l'erreur standard. Tapez votre nom, puis ENTREE, puis Ctrl+D: ")
nom=sys.stdin.read()
sys.stdout.write("Bonjour, %s!\n"%nom)
# NB: sys.stdout.write et print, c'est presque pareil (au \n près!)

Manipulation de fichiers


f=open("toto") # ouverture en lecture
donnees=f.read(10) # lit 10 octets
encore_des_donnees=f.read() # lit autant d'octets que possible (tout le fichier)
f.close() # referme
ff=open("titi","w+") # le 2è argument est le mode, exactement comme pour la fonction C fopen
ff.write("bonjour, monde!\n")
ff.close()

Pour finir…


 



Ecrire un programme qui prend N arguments ; le premier étant le chemin
d’un dictionnaire (par exemple /usr/share/dict/french), les suivants
étant des mots. Le programme doit charger le dictionnaire en mémoire
dans une table de hachage, puis tester pour chaque mot s’il appartient
au dictionnaire. On demande de lire tout le fichier d’un coup (dans une
grande chaîne de caractères donc), puis de séparer les mots grâce à la
fonction split, puis de tous les insérer dans une table de hachage (vide à l’origine) grâce à une boucle for. Puis pour tester l’appartenance, on utilisera la fonction has_key dont voici un exemple :


table={"coin": 123, "cuicui": "..."}
print table.has_key("coin") # affiche True
print table.has_key("couac") # affiche False

Si vous n’avez pas de dictionnaire, utilisez ce dictionnaire français.