Introduction à Python - 1 - Université Paris-Est Marne-la

Introduction à Python - 1
Traitement Automatique des Langues
Master 2 Informatique
Université Paris-Est Marne-la-Vallée
Matthieu Constant
Introduction à Python
●
Python = langage de programmation
●
créateur: Guido Van Rossum
●
date: début des années 90
●
url: www.python.org
Caractéristiques - 1
●
syntaxe simple
●
langage interprété
●
multi-paradigme (programmation impérative structurée,
orientée objet et fonctionnelle)
Caractéristiques - 2
●
typage dynamique “fort”
●
gestion automatique de la mémoire
●
gestion d'exceptions
●
utilisation possible de librairies C et C++ sans appel
système
Syntaxe - 1
●
●
●
conçu pour être un langage lisible (visuellement épuré)
moins de constructions syntaxiques que d'autres langages
(ex. C, Perl)
les blocs sont identifiés par l'indentation (au lieu de
l'accolade pour le C par ex.)
Syntaxe - 2
●
ex1: fonction factorielle en C
int factorielle(int x) {
if (x == 0)
return 1;
else
return x * factorielle(x-1);
}
●
ex2: fonction factorielle en Python
def factorielle(x):
if x == 0:
return 1
else:
return x * factorielle(x-1)
Références
●
tutoriels :
http://www.python.org/doc/current/tut/tut.html
http://www.ebgm.jussieu.fr/~fuchs/python/index.html
http://quentel.pierre.free.fr/python-trad/lib.html
●
Wikipedia :
http://fr.wikipedia.org/wiki/Python_(langage)
Plan
●
démarrer et premiers pas
●
structures de contrôle
●
fonctions et modules
●
structures de données
●
quelques techniques
Démarrer
Démarrer
●
mode interactif
●
scripts
Mode interactif - 1
●
lancement de l'interpréteur : commande python
mat@ceressou:~$ python
Python 2.4.4 (#2, Jul 21 2007, 11:00:24)
[GCC 4.1.3 20070718 (prerelease) (Debian 4.1.2-14)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>>
●
>>> : invite de commande
●
autre interpréteur: ipython (avec complétion)
Mode interatif - 2
●
chaque ligne de code est lue, interprétée et exécutée
●
exemple d'une commande :
>>> print "Hello World!"
Hello World!
>>>
●
quitter l'interpréteur: Ctrl-D
Script - 1
●
possibilité d'utiliser un script
●
soit un fichier test.py
print "Hello World!"
print "Hello Sun!"
●
lancement du script:
mat@ceressou:~/courses/m2/tal/data$ python test.py
Hello World!
Hello Sun!
Script - 2
●
rendre le fichier script directement exécutable:
–
indiquer la localisation de l'interpréteur Python
#!/usr/bin/python
print "Hello World!"
print "Hello Sun!"
–
●
modifier les droits du fichier (chmod u+x test.py)
lancer le script:
mat@ceressou:~/courses/m2/tal/data$ ./test.py
Hello World!
Hello Sun!
Script - 3
●
une alternative :
#!/usr/bin/env python
print "Hello World!"
print "Hello Sun!"
Commentaires
●
un commentaire est précédé du symbole #
●
exemple:
#!/usr/bin/python
# ceci est un commentaire
print "Hello World!"
print "Hello Sun!" # ceci est un autre commentaire
Encodage d'un script
●
●
possibilité de spécifier l'encodage du fichier source:
–
juste après la ligne #! spécifiant le chemin de l'interpréteur
–
écrire: # -*- coding: <encoding> -*-, où <encoding> est
l'encodage
exemple:
#!/usr/bin/python
# -*- coding: utf-8 -*# ceci est un commentaire très concis
print “L'unicode n'est pas un problème”
Premiers pas
Premiers pas
●
variables
●
types et opérations de base
●
listes
●
string
●
premier programme “évolué”
Variables
●
Déclaration et initialisation d'une variable en même
temps:
>>> x = 2
>>> x
2
●
●
Le signe = permet d'assigner une valeur (ex. 2) à une
variable (ex. x)
On n'indique pas le type de la variable : il se déduit
automatiquement de l'initialisation !
Types de base
●
●
●
nombres
–
entiers : x = 2
–
réels : x = 3.5
–
complexes : x = 1+3j
chaîne de caractères (ou string):
–
chaîne standard : x = ”string” ou x = 'string'
–
chaîne unicode : x = u'chaîne'
listes
–
liste : x = [3,1,7]
Opérations de base - 1
●
●
Nombres
–
opération “+” : addition
–
opération “-” : soustraction
–
opération “*” : multiplication
–
opération “/” : division
Exemple:
>>> x = 5.0
>>> y = 2.0
>>> (x+y)/y
3.5
Opérations de base - 2
●
●
cas particulier des entiers
–
opérateur “/” : division entière
–
opérateur “%” : modulo
exemple :
>>>
>>>
>>>
2
>>>
1
y=2
x=5
x/y
x%y
Opérations de base - 3
●
●
chaînes de caractères (ou string)
–
opérateur “+” : concaténation
–
opérateur “*” : répétition
exemple :
>>> x = "voici"
>>> y = "voila"
>>> x + y
'voicivoila'
>>> x * 4
'voicivoicivoicivoici'
Opérations de base - 4
●
attention : ne pas mélanger les types !
●
exemple
>>> 'yes' + 5
Traceback (most recent call last):
File "<stdin>", line 1, in ?
TypeError: cannot concatenate 'str' and 'int' objects
●
MAIS:
>>> x = 5 # !! type entier
>>> y = 2.0
>>> (x+y)/y
3.5
Opérations de base - 5
●
Remarque :
contrairement au C, les incrémentations x++ et x-- sont
interdites.
au lieu de cela:
x += 1
x -= 1
Conversion de types - 1
●
entier => string
>>> str(3)
'3'
●
string => entier
>>> int('3')
3
●
attention
>>> int('3.0')
Traceback (most recent call last):
File "<stdin>", line 1, in ?
ValueError: invalid literal for int(): 3.0
Conversion de types - 2
●
entier => réel
>>> float(2)
2.0
●
string => réel
>>> float('2')
2.0
>>> float('2.0')
2.0
Listes - 1
●
déclaration et initialisation d'une liste
>>> a = ['idiot', 'bête', 'stupide']
>>> b = [1, 7, 8, 12]
>>> c = [1.0, 27.1, 8.9, 1.7]
●
liste mixte
>>> mixte = ['idiot', 0.7, 1,'ok']
●
liste vide
>>> vide = []
Listes - 2
●
liste imbriquée
>>> b = [1, 7, 8, 12]
>>> d = ['ah',b,1]
>>> d
['ah', [1, 7, 8, 12], 1]
Listes - 3
●
●
les indices commencent à 0 et se terminent à n-1, avec n
taille de la liste
accéder aux éléments des listes :
>>> b = [1, 7, 8, 12]
>>> b[1]
7
●
attention au dépassement de taille :
>>> b[4]
Traceback (most recent call last):
File "<stdin>", line 1, in ?
IndexError: list index out of range
Listes - 3
●
indiçage négatif
liste :
['a',
indices positifs: 0
indices négatifs: -4
●
exemple
>>> b = [1, 7, 8, 12]
>>> b[-1]
12
'b',
1
-3
'c',
2
-2
'd']
3
-1
Listes - 4
●
Récupération d'une tranche de liste
>>> b = [1, 7, 8, 12]
>>> b[1:3]
[7, 8]
>>> b[:3]
[1, 7, 8]
>>> b[1:]
[7, 8, 12]
>>> b[:]
[1, 7, 8, 12]
Listes - 5
●
concaténation avec l'opérateur '+'
>>> b = [1, 7, 8, 12]
>>> b[0:3] + [1,6]
[1, 7, 8, 1, 6]
●
modification des valeurs d'une liste
>>> b[1] = 6
>>> b
[1, 6, 8, 12]
>>> b[2:] = []
>>> b
[1, 6]
Listes - 6
●
insertion dans une liste
>>> b = [1, 7, 8, 12]
>>> b[2:2] = [20,21]
>>> b
[1, 7, 20, 21, 8, 12]
●
ajout d'une valeur en fin de liste
>>> b = [1, 7, 8, 12]
>>> b.append(22)
>>> b
[1, 7, 8, 12, 22]
Listes - 7
●
taille d'une liste : fonction len
>>> b = [1, 7, 8, 12]
>>> len(b)
4
●
créer des listes d'entiers : fonction range
>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> range(2,8)
[2, 3, 4, 5, 6, 7]
>>> range(2,8,2)
[2, 4, 6]
String - 1
●
les chaînes de caractères peuvent être considérées
comme des listes
>>> s = "ceci est une chaine."
>>> s[2]
'c'
>>> s[5:10]
'est u'
>>> s[:10]
'ceci est u'
String - 2
●
mais ... ne sont pas modifiables !
>>> s = "ceci est une chaine."
>>> s[2] = 'a'
Traceback (most recent call last):
File "<stdin>", line 1, in ?
TypeError: object does not support item assignment
●
pour en modifier une, besoin d'en créer une autre !
>>> s = "ceci est une chaine."
>>> s = s[:2]+'la'+s[4:]
>>> s
'cela est une chaine.'
String - 3
●
●
caractères spéciaux
–
\n : retour à la ligne
–
\t : tabulation
–
\' : guillemet simple si string = '..... '
–
\” : guillemet si string = “.....”
–
...
exemples
>>> s = "Luc dit: \"J'aime les chiens\".\n"
>>> s = 'Luc dit: "J\'aime les chiens".\n'
String à plusieurs lignes
●
les instructions suivantes sont équivalentes :
s = “xxxxx\nyyyyyy\nzzzzzzz\n”
s = 'xxxxx\nyyyyyy\nzzzzzzz\n'
s = r”xxxxx
yyyyyy
zzzzzzz”
s = '''xxxxx
yyyyyy
zzzzzzz''' # trois quotes
Premier programme évolué - 1
●
source python-1-3.py :
#!/usr/bin/python
# -*- coding: iso-8859-1 -*# La série de Fibonacci
a, b = 0, 1
while b < 10:
print b,
a,b = b,a+b
●
Résultat:
mat@ceressou:~/courses/m2/tal/data$ ./python-1-3.py
112358
Premier programme évolué - 2
●
●
●
●
assignation multiple : a, b = 0, 1 (a = 0 et b = 1)
la boucle while s'exécute tant que la condition (b < 10)
est vraie
le corps de la boucle while est indenté ! Chaque ligne
d'un même bloc doit être indenté de la même quantité
print b,
la virgule empêche le retour à la ligne après la sortie
Structures de contrôles
Structures de contrôle
●
comparaisons
●
tests if ... elif ... else ...
●
boucles for
●
boucles while
Comparaisons - 1
●
Opérateurs de comparaison:
–
x == y
# x est égal à y
–
x != y
# x est différent de y
–
x<y
# x est inférieur à y
–
x <= y
# x est inférieur ou égal à y
–
x>y
# x est supérieur à y
–
x >= y
# x est supérieur ou égal à y
Comparaisons - 2
●
exemple sur les entiers
>>> x,y = 2,3
>>> x == y
False
>>> x < y
True
●
exemple sur les string
>>> x,y,z = "aab","aab","aaa"
>>> x != y
False
>>> x > z
True
Opérateurs booléens - 1
●
OU logique : or
>>> x,y,z = "aaa",2,3
>>> x == "bbb" or z != y
True
>>> x == "bbb" or z == y
False
●
ET logique : and
>>> x == "bbb" and z != y
False
>>> x == "aaa" and z != y
True
Opérateurs booléens - 2
●
NON logique : not
>>> x = 5
>>> not x == 5
False
>>> not x != 5
True
Opérateurs booléens - 3
●
priorité des opérateurs booléens : not > and > or
>>> True or True and False
True
>>> (True or True) and False
False
>>> not True or True
True
>>> not (True or True)
False
Instructions conditionnelles - 1
●
instruction if
x=2
if x == 2:
print 'cool!'
●
instruction if ... else...
x=1
if x == 2:
print 'cool!'
else:
print 'oups!'
Instructions conditionnelles - 2
●
instruction if ... elif ... else ...
if x < 2:
print 'cool!'
elif x==2:
print 'oups!'
else:
print 'Hein?'
Boucles for - 1
●
●
itération sur les éléments d'une liste dans l'ordre qu'ils
apparaissent
exemple
pos = ['nom','verbe','adjectif','adverbe']
for p in pos:
print p
mat@ceressou:~/courses/m2/tal/data$ ./python-1-5.py
nom
verbe
adjectif
adverbe
Boucle for - 2
●
●
attention: il n'est pas sûr de modifier une liste sur
laquelle on est en train d'itérer !
par exemple, il peut être intéressant de faire une copie :
pos = ['nom','verbe','adjectif','adverbe']
for p in pos[:]:
if len(p) > 5:
pos.insert(0,p)
print pos
mat@ceressou:~/courses/m2/tal/data$ ./python-1-5.py
['adverbe', 'adjectif', 'nom', 'verbe', 'adjectif', 'adverbe']
Boucle for - 3
●
itération sur une séquence de nombres : utiliser la
fonction range
pos = ['nom','verbe','adjectif','adverbe']
for i in range(0,len(pos)):
print i,pos[i]
mat@ceressou:~/courses/m2/tal/data$ ./python-1-6.py
0 nom
1 verbe
2 adjectif
3 adverbe
boucle while
●
exemple :
i=0
while i < len(pos):
print i,pos[i]
i+=1
mat@ceressou:~/courses/m2/tal/data$ ./python-1-6.py
0 nom
1 verbe
2 adjectif
3 adverbe
Fonctions et modules
Fonctions et modules
●
définir une fonction
●
arguments par défaut
●
arguments mots-clés
●
formes lambda
●
modules
Fonctions - 1
●
définition d'une fonction
def cube(x):
return x**3
●
explications:
–
def : définition d'une fonction
–
x (non typé) paramètre de la fonction
–
return : retourne une valeur
–
x**3 <=> x au cube
Fonctions - 2
def exemple(n):
print (n + n * 2)
x = exemple(100)
print x
●
résultat:
300
None
●
Par défaut, une fonction retourne la valeur None
Documentation des fonctions
●
la première ligne du corps de la fonction peut être une
documentation, si elle est sous la forme d'une string
●
on l'appelle docstring
●
exemple
def exemple(n):
"""Affiche un exemple de fonction avec pour parametre 'n'."""
print (n + n * 2)
print exemple.__doc_
Passage des arguments d'une fonction
●
pas besoin de préciser le typage des arguments de la
fonction : typage dynamique
def fois(x,y):
return x*y
print fois(3,7)
print fois('tata',3)
●
résultat :
21
tatatatatata
Renvoi de plusieurs valeurs - 1
●
●
une fonction peut renvoyer plusieurs valeurs (comme en
perl)
c'est impossible en C!!!
>>> def plusieurs(n):
... return (n,n/2,n/3)
...
>>> plusieurs(7)
(7, 3, 2)
●
ici, elle renvoie un tuple
Renvoi de plusieurs valeurs - 2
●
la fonction pourrait aussi renvoyer une liste
>>> def plusieurs(n):
... return [n,n/2,n/3]
...
>>> plusieurs(7)
[7, 3, 2]
Portée des variables - 1
●
●
variable locale :
–
visible uniquement dans un environnement local (ex.
fonction)
–
non visible de l'extérieur
variable globale :
–
déclarée à la racine du script, i.e. “fonction principale”
–
visible dans tout le programme
Portée des variables - 2
>>> x = 15 #variable globale
>>> def exemple():
... x,y=2,7 # variables locales
... print 'x est egal a',x
...
>>> exemple()
x est egal a 2
>>> x
15
>>> y
Traceback (most recent call last):
File "<stdin>", line 1, in ?
NameError: name 'y' is not defined
Arguments par défaut - 1
●
possibilité de spécifier une valeur par défaut pour un ou
plusieurs arguments :
>>> def f(x=5):
... return x + 1
...
>>> f()
6
>>> f(2)
3
Arguments par défaut - 2
●
attention : une valeur par
défaut n'est évaluée
qu'une seule fois !
>>> def add(a,l=[]):
... l.append(a)
... return l
...
>>> add(2)
[2]
>>> add(3)
[2, 3]
>>> add(4)
[2, 3, 4]
●
Solution:
>>>
...
...
...
...
...
>>>
[2]
>>>
[3]
def add(a,l=None):
if l == None:
l = []
l.append(a)
return l
add(2)
add(3)
Arguments mots-clés - 1
●
il est possible d'utiliser des arguments de la forme “motclé=valeur” :
>>> def exemple(x,y=2,z=3,text='resultat'):
... print text+':',(x+y+z)
...
>>> exemple(2,z=5)
resultat: 9
>>> exemple(2)
resultat: 7
>>> exemple(2,z=5,y=3) #inversion de l'ordre
resultat: 10
Arguments mots-clés - 2
●
●
attention: les arguments classiques doivent toujours être
avant les arguments mots-clés!
quelques exemples qui échouent:
>>> exemple(y=3)
Traceback (most recent call last):
File "<stdin>", line 1, in ?
TypeError: exemple() takes at least 1 non-keyword argument (0
given)
>>> exemple(y=3,7)
SyntaxError: non-keyword arg after keyword arg
Formes lambda - 1
●
programmation fonctionnelle avec mot-clé lambda pour
construire de nouveaux objets de fonctions retournées à
l'exécution
>>>
...
...
>>>
>>>
8
>>>
14
def fabrique_incrementeur(n):
return lambda x: x+n
f=fabrique_incrementeur(5)
f(3)
f(9)
Formes lambda - 2
>>> def fabrique_repetiteur(n):
... return lambda s: s*n
...
>>> deuxFois=fabrique_repetiteur(2)
>>> deuxFois('toto')
'totototo'
>>> deuxFois(5)
10
Modules - 1
●
●
module = programme python contenant des fonctions que
l'on est amené à réutiliser souvent.
importation de modules
>>> import random
>>> random.randint(0,100)
89
●
la fonction randint du module random tire un entier au
hasard entre deux bornes (ici: 0 et 100)
Modules - 2
●
importation d'une ou plusieurs fonctions d'un module
>>> from random import random,randint
>>> randint(10,55)
37
>>> random()
0.22770046531696164
●
importation de toutes les fonctions d'un module
>>> from random import *
Types de données
Structures de données
●
listes
●
tuples
●
ensembles
●
dictionnaires
Quelques méthodes des listes - 1
●
●
●
●
append(x): ajoute x à la fin de la liste
extend(L): ajoute tous les éléments de la liste L à la fin
de la liste
insert(i,x): insert l'élément x à l'indice i de la liste
remove(x): supprime le premier élément de la liste dont
la valeur est égale à x
Quelques méthodes des listes - 2
●
●
pop([i]): supprime l'élément à l'indice i et le retourne;
par défaut, supprime le dernier élément de la liste et le
retourne.
index(x): retourne le premier élément de la liste dont la
valeur est x
●
count(x): retourne le nombre de x dans la liste
●
sort(): trie les éléments de la liste
●
reverse(): inverse l'ordre des éléments de la liste
Quelques méthodes des listes - 3
>>> a = [5, 2,9,2,1,2]
>>> a.extend([3,2])
>>> a
[5, 2, 9, 2, 1, 2, 3, 2]
>>> a.count(2),a.count(5),a.count(0)
(4, 1, 0)
>>> a.pop()
2
>>> a
[5, 2, 9, 2, 1, 2, 3]
>>> a.sort()
>>> a
[1, 2, 2, 2, 3, 5, 9]
Utiliser les listes comme des piles
>>> pile = [1,4,9]
>>> pile.append(6) # push
>>> pile.append(8)
>>> pile
[1, 4, 9, 6, 8]
>>> pile.pop()
8
>>> pile
[1, 4, 9, 6]
Création simple de listes
>>> v = [2,7,8]
>>> [x**2 for x in v] # utilisation d'un for
[4, 49, 64]
>>> [x**2 for x in v if x > 2] # utilisation de for et if
[49, 64]
>>> w = [3,-1]
>>> [x*y for x in v for y in w] # utilisation de deux for
[6, -2, 21, -7, 24, -8]
Tuple - 1
●
tuple = un type de séquence (comme liste et string)
●
tuple = une séquence de valeurs séparées par des virgules
●
exemple:
>>> x = (1,5,'exemple',[8,8])
>>> x[1]
5
>>> x
(1, 5, 'exemple', [8, 8])
Tuple - 2
●
●
quelques propriétés:
–
non modifiables
–
mais peuvent contenir des objets modifiables (ex. listes)
utilisation: coordonnées de points, enregistrement dans
base de données, ...
Ensemble - 1
●
ensemble = collection non ordonnée sans doublon
>>> a = ['chien','chat','vache','chat','souris','vache']
>>> animaux = set(a)
>>> animaux
set(['souris', 'chien', 'vache', 'chat'])
●
Tests efficaces d'appartenance
>> 'vache' in animaux
True
>>> 'cache' in animaux
False
Ensemble - 2
●
opérations sur les ensembles : intersection, union,
différence, différence symétrique
>>> e1 = set('abcd')
>>> e2 = set('cde')
>>> e1 | e2 # lettres dans e1 ou dans e2
set(['a', 'c', 'b', 'e', 'd'])
>>> e1 & e2 # lettres dans e1 et dans e2
set(['c', 'd'])
>>> e1 - e2
set(['a', 'b'])
>>> e1 - e2 # lettres dans e1 mais pas dans e2
set(['a', 'b'])
>>> e1 ^ e2 # lettres dans e1 ou e2 mais pas dans les deux
set(['a', 'b', 'e'])
Dictionnaires
●
●
●
●
un type de Python
ensemble non ordonné de paires clé-valeur, avec des clés
uniques dans le dictionnaire
indexé par clés de n'importe quel type non mutable
(nombre, string, tuple)
opérations de base: initialisation, assignation, obtenir
une valeur, suppression
Initialisation des dictionnaires
●
dictionnaire vide
>>> d = {}
●
initialisation simple
>>> id={'Paul': 32, 'Jean': 55}
●
initialisation par un constructeur
>>> id = dict([('Paul',32),('Jean',55)])
>>> id = dict(Paul=32,Jean=55) # si les clés sont des string
Opérations de base sur les dictionnaires - 1
●
obtenir la valeur associée à une clé :
>>> id['Jean']
55
●
assigner une valeur à une clé :
>>> id['Jean'] = 79
>>> id['Luc'] = 13
>>> id
{'Jean': 79, 'Luc': 13, 'Paul': 32}
Opérations de base sur les dictionnaires - 2
●
détruire un couple clé-valeur
>>> del id['Jean']
>>> id
{'Luc': 13, 'Paul': 32}
Méthodes des dictionnaires
●
obtenir la liste des clés : keys()
>>> id.keys()
['Luc', 'Paul']
●
tester l'existence d'une clé : has_key()
>>> id['Jean']
Traceback (most recent call last):
File "<stdin>", line 1, in ?
KeyError: 'Jean'
>>> id.has_key('Jean')
False
Méthodes des dictionnaires - 2
●
obtenir la valeur associée à une clé, en retournant une
valeur par défaut si la clé n'existe pas
>>
>>
>>
>>
id.get('Marise',0)
0
id.get('Paul',0)
32
Quelques astuces
Quelques astuces
●
techniques de parcours
●
techniques de tri
Parcours de dictionnaires
●
●
la clé et la valeur correspondante peuvent être extraites
en même temps en utilisant la méthode iteritems()
exemple :
>>> for k,v in id.iteritems():
... print k,v
...
Luc 13
Paul 32
Parcours de séquences - 1
●
●
extraire l'indice de position et la valeur correspondante
en même temps : utiliser la fonction enumerate()
exemple :
>>> for i,v in enumerate(['tt','yy','aa']):
... print i,v
...
0 tt
1 yy
2 aa
Parcours de séquences - 2
●
●
itération sur plusieurs séquences en même temps : la
fonction zip
exemple :
>>> questions = ['sport','film','dessert']
>>> reponses = ['le tennis','Alien','une pomme']
>>> for q,a in zip(questions,reponses):
... print 'Quel est ton %s favori ? C\'est %s.'% (q,a)
...
Quel est ton sport favori ? C'est le tennis.
Quel est ton film favori ? C'est Alien.
Quel est ton dessert favori ? C'est une pomme.
Parcours de séquences - 3
●
parcours d'une séquence à l'envers: la fonction reversed()
●
exemple :
>>> reponses = ['tennis','Alien','pomme']
>>> for i in reversed(reponses):
... print i
...
pomme
Alien
tennis
Parcours de séquences - 4
●
●
parcours d'une séquence dans un ordre trié : la fonction
sorted()
exemple :
>>> reponses = ['tennis','Alien','pomme']
>>> for i in sorted(reponses):
... print i
...
Alien
pomme
tennis
Trier
●
trier une séquence en ordre croissant par défaut : la
méthode sort()
>>> a = [12,4,3,8,0]
>>> a.sort()
>>> a
[0, 3, 4, 8, 12]
●
trier une séquence en ordre décroissant : le paramètre
booleén reverse
>>> a = [12,4,3,8,0]
>>> a.sort(reverse=True)
>>> a
[12, 8, 4, 3, 0]
Trier avec sa propre fonction de comparaison - 1
●
●
on peut ajouter sa propre fonction de comparaison
comme paramètre de la méthode sort() :
exemple :
>>> def compare(x,y):
... return x - y
...
>>> a = [12,4,3,8,0]
>>> a.sort(compare)
>>> a
[0, 3, 4, 8, 12]
>>> a.sort(compare,reverse=True)
>>> a
[12, 8, 4, 3, 0]
Trier avec sa propre fonction de comparaison - 2
●
●
rendre sa fonction de comparaison anonyme: les formes
lambda
exemple:
>>> a = [12,4,3,8,0]
>>> a.sort(lambda x,y:x-y)
>>> a
[0, 3, 4, 8, 12]
cmp
●
cmp : fonction de comparaison par défaut de sort()
●
exemples :
–
entiers
>>> cmp(2,9)
-1
–
string
>>> cmp('aba','aaa')
1
Trier par clés
●
●
le paramètre key de la méthode sort() permet de :
–
associer une clé à chaque élément de la séquence
–
trier la séquence par rapport à cette clé
exemple : tri insensible à la casse
>>> s = ['avion','Paul','pierre','la','Pierre']
>>> s.sort()
>>> s
['Paul', 'Pierre', 'avion', 'la', 'pierre']
>>> s.sort(key=str.lower)
>>> s
['avion', 'la', 'Paul', 'Pierre', 'pierre']