Corrigé du TD1

Il fallait vraiment tester les instructions proposées une à une dans l'interpréteur, et surtout pas écrire un programme dans un IDE.

Le notebook jupyter permet à la fois d'utiliser l'interpréteur, d'exécuter des programmes, et de rentrer du texte formaté en markdown. Il est donc idéal pour présenter des comptes rendus de TP.

In [1]:
# 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
print "ceci\test une tabulation, mais pas cela\\t." # le caractére d'échappement est \
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"
alphabet.upper() # les chaînes ont des méthodes commodes
print (2**8)%100 # 2 puissance 8, le tout modulo 100 (ça fait 56)
print 1, # notez la virgule à la fin du print : elle permet de ne pas aller à la ligne
print 1,; print 2 # ... cette ligne affichera donc « 1 2 »
4
dromadaire
ananas
mignonne allons voir si la rose
etc.
ceci	est une tabulation, mais pas cela\t.
abcdefghijklmnopqrstuvwxyz
26
56
1 1 2
In [2]:
# Exercice 1:
# Les premiers exemples du TD rappellent l'existence de + et * pour les chaînes
msg = 'coin coin'
s = '* '+msg+' *'
t = '*'*len(s)+'\n'
print t+s+'\n'+t
*************
* coin coin *
*************

In [3]:
# Exercice 2: dir("") permet de découvrir la méthode "center" ...
print '*'*79+'\n*'+msg.center(77)+'*\n'+'*'*79
*******************************************************************************
*                                  coin coin                                  *
*******************************************************************************
In [4]:
daltons=["joe","jack","william","averell"]
print daltons[0] # les listes, ça commence à zéro
print daltons[1:3] # sous-liste de l'élément 1 inclus jusqu'au 3 exclus
print daltons[-1] # -N = Nème élément en partant de la fin
print daltons[2:] # sous-liste de l'élément 2 jusqu'à la fin
daltons.sort() # tri alphabétique en place
print daltons # affiche la liste triée
petit=daltons[0] # c'est "averell" vu qu'on a trié dans l'ordre alphabétique
print petit[0] # surprise : une chaîne, c'est une liste de caractères...
print daltons[-2][3:] # on peut faire ça ( remarque importante pour la suite !)
joe
['jack', 'william']
averell
['william', 'averell']
['averell', 'jack', 'joe', 'william']
a

In [5]:
print daltons[-2]
daltons[-2][3] # Comme on voit, 'joe'[3] renvoie une erreur
joe
---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
<ipython-input-5-048d5c40c70e> in <module>()
      1 print daltons[-2]
----> 2 daltons[-2][3] # Comme on voit, 'joe'[3] renvoie une erreur

IndexError: string index out of range
In [6]:
# Mais 'joe'[3:] est la chaine vide
daltons[-2][3:]
Out[6]:
''
In [7]:
# Exercice 3: ... et aussi la méthode "strip"
message="*"*13+"\n* coin coin *\n"+"*"*13
print message
print message.strip('* \n')
*************
* coin coin *
*************
coin coin
In [8]:
# Exercice 4: On s'autorise une instruction pour déterminer
# la longueur m de la plus courte ...
s1="abcdef"
s2="0123456789"
m=min(len(s1),len(s2))
# ... puis on combine "list comprehension" et tableaux (m:, :m etc)
print ''.join([s1[i]+s2[i] for i in range(m)])+s1[m:]+s2[m:]
# ou encore:
print "".join([x[0]+x[1] for x in zip(s1,s2)])+s1[m:]+s2[m:]
# Il fallait observer que s[m:] renvoie '' si s[m] n'existe pas
a0b1c2d3e4f56789
a0b1c2d3e4f56789
In [9]:
# Exercice 5:
# Ensuite, on peut récuperer les caractères d'indices pairs ou impairs
s='a0b1c2d3e4f56789'
print s[::2]
print s[1::2]
abcdef68
01234579
In [10]:
# Exercice 6:
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"}]
# les fonctions de comparaison doivent retourner (<0), 0 ou (>0)
def compare_taille(x,y):
    return x['taille'] - y['taille']

# la liste est triée en place
daltons.sort(compare_taille)
print daltons
# On pourrait coder celle-ci, mais en fouinant un peu, on trouve "cmp"
def compare_nom(x,y):
    return cmp(x['nom'], y['nom'])

daltons.sort(compare_nom)
print daltons
[{'nom': 'joe', 'caractere': 'teigneux', 'taille': 140}, {'nom': 'jack', 'caractere': 'idiot', 'taille': 155}, {'nom': 'william', 'caractere': 'stupide', 'taille': 170}, {'nom': 'averell', 'caractere': 'abruti', 'taille': 185}]
[{'nom': 'averell', 'caractere': 'abruti', 'taille': 185}, {'nom': 'jack', 'caractere': 'idiot', 'taille': 155}, {'nom': 'joe', 'caractere': 'teigneux', 'taille': 140}, {'nom': 'william', 'caractere': 'stupide', 'taille': 170}]
In [11]:
# Exercice 7:
ll=open('liste.de.mots.francais.frgut.txt','r').readlines()
print ll[:20] # pour voir à quoi ça ressemble

def dico(w):
   ll=open('liste.de.mots.francais.frgut.txt','r').readlines()
   if w+'\n' in ll: print "%s est dans le dictionnaire" % w
   else: print "%s n'est pas dans le dictionnaire" % w

dico('zythum')
['a\n', '\xe0\n', 'abaissa\n', 'abaissable\n', 'abaissables\n', 'abaissai\n', 'abaissaient\n', 'abaissais\n', 'abaissait\n', 'abaiss\xe2mes\n', 'abaissant\n', 'abaissante\n', 'abaissantes\n', 'abaissants\n', 'abaissas\n', 'abaissasse\n', 'abaissassent\n', 'abaissasses\n', 'abaissassiez\n', 'abaissassions\n']
zythum est dans le dictionnaire
In [12]:
# Avec les lettres accentuées, ça ne marche pas forcément
dico('déjà')
déjà n'est pas dans le dictionnaire
In [13]:
# Dans ce cas il faut connaitre les encodages du système et du dictionnaire et les décoder:
# dir("") propose une méthode "decode": help("".decode) puis voir la doc en ligne
def dico2(w):
   ll=[x.decode('latin1') for x in open('liste.de.mots.francais.frgut.txt','r').readlines()]
   if w.decode('utf8')+'\n' in ll: print "%s est dans le dictionnaire" % w
   else: print "%s n'est pas dans le dictionnaire" % w

dico2('déjà')
déjà est dans le dictionnaire
# Un script complet
############### dic.py #################"
#! /usr/bin/python

import sys


def dico(w,d='utf8', e='latin1'):
    ll= open('liste.de.mots.francais.frgut.txt').readlines()
    if w.decode(d).encode(e)+'\n' in ll: print "%s est dans le dictionnaire" % w
    else: print "%s n'est pas dans le dictionnaire" % w



if __name__ == '__main__':
    d = sys.getfilesystemencoding()
    if len(sys.argv) < 2:
        print "dic prend au moins un argument"
        sys.exit(1)
    elif sys.argv[1] in ['-e', '--encoding']:
        e = sys.argv[2]
        for w in sys.argv[3:]: dico(w,d,e)
    else:
        for w in sys.argv[1:]: dico(w,d)
In [ ]: