Cours python

Avant-propos
Sommaire

Notes de cours Python
2007–2008 - v 1.3

Bob Cordeau
robert.cordeau@onera.fr

Mesures Physiques
IUT d’Orsay
www.iut-orsay.fr/dptmphy/Pedagogie/Welcome.html

12 juillet 2007

Bob Cordeau robert.cordeau@onera.fr Notes de cours Python 2007–2008 - v 1.3

Avant-propos
Sommaire

Avant-propos

Ces notes reposent sur deux partis pris :
le choix du langage Python ;
le choix de logiciels libres :
Python (www.python.org)
PyScripter (mmm-experts.com/)
gnuplot (sourceforge.net/projects/gnuplot)
...


Avant-propos
Sommaire

Avant-propos

Ces notes reposent sur deux partis pris :
le choix du langage Python ;
le choix de logiciels libres :
Python (www.python.org)
PyScripter (mmm-experts.com/)
gnuplot (sourceforge.net/projects/gnuplot)
...

Remerciements :
Cette version a b´n´ﬁci´ des lectures attentives de Laurent
e e e
Pointal (LIMSI) et Georges Vincents (IUT d’Orsay).


Chapitre 1
Chapitre 2
Chapitre 3
Avant-propos
Chapitre 4
Sommaire
Chapitre 5
Chapitre 6
Chapitre 7

Sommaire du chapitre 1

1 Introduction ` l’informatique
a
Environnement mat´riel
e
Environnement logiciel
Langages
Production des programmes
M´thodologie
e
Algorithme et programme
Importance des commentaires


Chapitre 1
Chapitre 2
Chapitre 3
Avant-propos
Chapitre 4
Sommaire
Chapitre 5
Chapitre 6
Chapitre 7


2 La « calculatrice » Python
Les types simples
Donnés, variables et affectation
e
Les entrés-sorties
e
Les s´quences
e
Retour sur les r´f´rences
ee
Les dictionnaires
Les ensembles


Chapitre 1
Chapitre 2
Chapitre 3
Avant-propos
Chapitre 4
Sommaire
Chapitre 5
Chapitre 6
Chapitre 7


3 Le contrˆle du ﬂux d’instructions
o
Les instructions compos´es
e
Choisir
Boucler
Parcourir
Listes en compr´hension
e
Ruptures de s´quences
e


Chapitre 1
Chapitre 2
Chapitre 3
Avant-propos
Chapitre 4
Sommaire
Chapitre 5
Chapitre 6
Chapitre 7


4 Fonctions–Espaces de noms–Modules
D´ﬁnition et exemple
e
Passage des arguments
Espaces de noms
Modules


Chapitre 1
Chapitre 2
Chapitre 3
Avant-propos
Chapitre 4
Sommaire
Chapitre 5
Chapitre 6
Chapitre 7


5 Les ﬁchiers
Ouverture – Fermeture
M´thodes d’´criture
e e
M´thodes de lecture
e
Le module « pickle »


Chapitre 1
Chapitre 2
Chapitre 3
Avant-propos
Chapitre 4
Sommaire
Chapitre 5
Chapitre 6
Chapitre 7


6 La programmation « OO »
Classes et instanciation d’objets
M´thodes
e
M´thodes sp´ciales
e e
H´ritage et polymorphisme
e


Chapitre 1
Chapitre 2
Chapitre 3
Avant-propos
Chapitre 4
Sommaire
Chapitre 5
Chapitre 6
Chapitre 7


7 La programmation « OO » graphique
Programmes pilot´s par des ´v´nements
e e e
Les biblioth`ques graphiques
e
Les classes de widgets de Tkinter
Le positionnement des widgets
Un exemple


e
Langages
Introduction ` l’informatique
a Production des programmes
M´thodologie
e

L’ordinateur
D´ﬁnition
e
Automate d´terministe ` composants ´lectroniques.
e a e


e
Langages
M´thodologie
e

L’ordinateur
D´ﬁnition
e
e a e

L’ordinateur comprend entre autres :
un microprocesseur avec une UC (Unit´ de Contrˆle), une
e o
UAL (Unit´ Arithm´tique et Logique), une horloge, une
e e
m´moire cache rapide ;
e


e
Langages
M´thodologie
e

L’ordinateur
D´finition
e
e a e

e o
e e
e
de la m´moire vive (RAM), contenant les instructions et les
e
donnés. La RAM est formé de cellules binaires (bits)
e e
organisés en mots de 8 bits (octets) ;
e


e
Langages
M´thodologie
e

L’ordinateur
D´finition
e
e a e

e o
e e
e
de la m´moire vive (RAM), contenant les instructions et les
e
donnés. La RAM est formé de cellules binaires (bits)
e e
organisés en mots de 8 bits (octets) ;
e
des p´riph´riques : entrés/sorties, m´moires mortes (disque
e e e e
dur, CD-ROM. . . ), r´seau. . .
e

e
Langages
M´thodologie
e

Deux sortes de programmes

Le syst`me d’exploitation : ensemble des programmes qui
e
g`rent les ressources mat´rielles et logicielles ; il propose une
e e
aide au dialogue entre l’utilisateur et l’ordinateur : l’interface
textuelle (interpr`te de commande) ou graphique (gestionnaire
e
de fenˆtres). Il est souvent multitˆche et parfois
e a
multiutilisateur ;


e
Langages
M´thodologie
e

Deux sortes de programmes

Le syst`me d’exploitation : ensemble des programmes qui
e
g`rent les ressources mat´rielles et logicielles ; il propose une
e e
aide au dialogue entre l’utilisateur et l’ordinateur : l’interface
textuelle (interpr`te de commande) ou graphique (gestionnaire
e
de fenˆtres). Il est souvent multitˆche et parfois
e a
multiutilisateur ;
les programmes applicatifs d´di´s ` des tˆches particuli`res. Ils
e e a a e
sont form´s d’une s´rie de commandes contenues dans un
e e
programme source ´crit dans un langage « compris » par
e
l’ordinateur.


e
Langages
M´thodologie
e

Des langages de diﬀ´rents niveaux
e

Chaque processeur poss`de un langage propre, directement
e
ex´cutable : le langage machine. Il est form´ de 0 et de 1 et
e e
n’est pas portable, mais c’est le seul que l’ordinateur
« comprend » ;


e
Langages
M´thodologie
e

e

e
e e
« comprend » ;
le langage d’assemblage est un codage alphanum´rique du
e
langage machine. Il est plus lisible que le langage machine,
mais n’est toujours pas portable. On le traduit en langage
machine par un assembleur ;


e
Langages
M´thodologie
e

e

e
e e
« comprend » ;
le langage d’assemblage est un codage alphanum´rique du
e
langage machine. Il est plus lisible que le langage machine,
mais n’est toujours pas portable. On le traduit en langage
machine par un assembleur ;
les langages de haut niveau. Souvent normalis´s, ils
e
permettent le portage d’une machine ` l’autre. Ils sont
a
traduits en langage machine par un compilateur ou un
interpr´teur.
e

e
Langages
M´thodologie
e

Bref historique des langages

Ann´es 50 (approches exp´rimentales) : FORTRAN, LISP,
e e
COBOL. . .

Des centaines de langages ont ´t´ cr´´s, mais l’industrie n’en
e e ee
utilise qu’une minorit´.
e


e
Langages
M´thodologie
e


e e
COBOL. . .
Ann´es 60 (langages universels) : ALGOL, PL/1, PASCAL. . .
e

e e ee
e


e
Langages
M´thodologie
e


e e
COBOL. . .
e
Ann´es 70 (g´nie logiciel) : C, MODULA-2, ADA. . .
e e

e e ee
e


e
Langages
M´thodologie
e


e e
COBOL. . .
e
e e
Ann´es 80–90 (programmation objet) : C++, LabView, Eiﬀel,
e
Matlab. . .

e e ee
e


e
Langages
M´thodologie
e


e e
COBOL. . .
e
e e
Annés 80–90 (programmation objet) : C++, LabView, Eiffel,
e
Matlab. . .
Annés 90–2000 (langages interpr´t´s objet) : Java, Perl,
e ee
tcl/Tk, Ruby, Python. . .

e e ee
e


e
Langages
M´thodologie
e

Deux techniques de production des programmes
La compilation est la traduction du source en langage objet.
Elle comprend au moins quatre phases (trois phases d’analyse
— lexicale, syntaxique et s´mantique — et une phase de
e
production de code objet). Pour gń´rer le langage machine il
e e
faut encore une phase particuli`re : l’´dition de liens. La
e e
compilation est contraignante mais offre une grande vitesse
d’exćution ;
e


e
Langages
M´thodologie
e

Deux techniques de production des programmes
La compilation est la traduction du source en langage objet.
Elle comprend au moins quatre phases (trois phases d’analyse
— lexicale, syntaxique et s´mantique — et une phase de
e
production de code objet). Pour gń´rer le langage machine il
e e
faut encore une phase particuli`re : l’´dition de liens. La
e e
compilation est contraignante mais offre une grande vitesse
d’exćution ;
e
dans la technique de l’interpr´tation chaque ligne du source
e
analys´ est traduite au fur et ` mesure en instructions
e a
directement exćutés. Aucun programme objet n’est gń´r´.
e e e ee
Cette technique est tr`s souple mais les codes gń´r´s sont
e e ee
peu performants : l’interpr´teur doit ˆtre utilis´ ` chaque
e e ea
exćution. . .
e

e
Langages
M´thodologie
e

Techniques de production de Python

Technique mixte : l’interpr´tation du bytecode compil´. Bon
e e
compromis entre la facilit´ de d´veloppement et la rapidit´
e e e
d’ex´cution ;
e


e
Langages
M´thodologie
e

Techniques de production de Python

Technique mixte : l’interpr´tation du bytecode compil´. Bon
e e
compromis entre la facilit´ de d´veloppement et la rapidit´
e e e
d’ex´cution ;
e
le bytecode (forme interm´diaire) est portable sur tout
e
ordinateur muni de la machine virtuelle Python.


e
Langages
M´thodologie
e

La construction des programmes : le gńie logiciel
e
Plusieurs mod`les sont envisageables, par exemple :
e

la m´thodologie proc´durale. On emploie l’analyse
e e
descendante et remontante qui proc`de par raffinements
e
successifs : on s’efforce de dćomposer un probl`me complexe
e e
en sous-programmes plus simples. Ce mod`le structure
e
d’abord les actions ;


e
Langages
M´thodologie
e

e
e

e e
e
e e
e
la m´thodologie objet. On con¸oit des fabriques (classes) qui
e c
servent ` produire des composants (objets) qui contiennent
a
des donn´es (attributs) et des actions (m´thodes). Les classes
e e
d´rivent (h´ritage et polymorphisme) de classes de base dans
e e
une construction hi´rarchique.
e


e
Langages
M´thodologie
e

e
e

e e
e
e e
e
la m´thodologie objet. On con¸oit des fabriques (classes) qui
e c
servent ` produire des composants (objets) qui contiennent
a
des donn´es (attributs) et des actions (m´thodes). Les classes
e e
d´rivent (h´ritage et polymorphisme) de classes de base dans
e e
une construction hi´rarchique.
e

Python oﬀre les deux techniques.

e
Langages
M´thodologie
e

Programme et algorithme

Algorithme
Moyen d’atteindre un but en r´p´tant un nombre ﬁni de fois un
e e
nombre ﬁni d’instructions.


e
Langages
M´thodologie
e


Algorithme
e e
Donc, un algorithme se termine en un temps ﬁni.


e
Langages
M´thodologie
e


Algorithme
e e

Programme
Un programme est la traduction d’un algorithme en un langage
compilable ou interpr´table par un ordinateur.
e


e
Langages
M´thodologie
e


Algorithme
e e

Programme
Un programme est la traduction d’un algorithme en un langage
compilable ou interpr´table par un ordinateur.
e
Il est souvent ´crit en plusieurs parties, dont une qui pilote les
e
autres, le programme principal.


e
Langages
M´thodologie
e

La pr´sentation des programmes
e

Un programme source est destin´ ` l’ˆtre humain. Pour en faciliter
ea e
la lecture, il doit ˆtre judicieusement comment´.
e e


e
Langages
M´thodologie
e

La pr´sentation des programmes
e

Un programme source est destin´ ` l’ˆtre humain. Pour en faciliter
ea e
la lecture, il doit ˆtre judicieusement comment´.
e e

La signification de parties non triviales doit ˆtre expliqué par un
e e
commentaire.
Un commentaire commence par le caract`re # et s’´tend jusqu’`
e e a
la fin de la ligne :

#---------------------
# Voici un commentaire
#---------------------

9 + 2 # En voici un autre


Les types simples
e
e
La « calculatrice » Python Les s´quences
e
ee
Les dictionnaires
Les ensembles

Les expressions bool´ennes
e

Deux valeurs possibles : False, True.


Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles

e

Op´rateurs de comparaison : ==, !=, >, >=, <, <=
e
2 > 8 # False
2 <= 8 < 15 # True


Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles

e

e
2 > 8 # False
2 <= 8 < 15 # True

Op´rateurs logiques (concept de shortcut) : not, or, and
e
(3 == 3) or (9 > 24) # True (d`s le premier membre)
e
(9 > 24) and (3 == 3) # False (d`s le premier membre)
e


Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles

e

e
2 > 8 # False
2 <= 8 < 15 # True

Op´rateurs logiques (concept de shortcut) : not, or, and
e
(3 == 3) or (9 > 24) # True (d`s le premier membre)
e
(9 > 24) and (3 == 3) # False (d`s le premier membre)
e

Les op´rateurs logiques et de comparaisons sont ` valeurs
e a
dans False, True


Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles

Le type entier (1/2)

Op´rations arithm´tiques
e e
20 + 3 # 23
20 - 3 # 17
20 * 3 # 60
20 ** 3 # 8000
20 / 3 # 6 (division enti`re)
e
20 % 3 # 2 (modulo)


Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles


Les entiers longs (seulement limit´s par la RAM)
e
2 ** 40 # 1099511627776L
3 * 72L # 216L


Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles


Les entiers longs (seulement limit´s par la RAM)
e
2 ** 40 # 1099511627776L
3 * 72L # 216L

Op´rations sur les bases
e
07 + 01 # 8
oct(7+1) # ’010’ (octal)
0x9 + 0x2 # 11
hex(9+2) # ’0xb’ (hexad´cimal)
e
int(’10110’, 2) # 22


Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles

Le type flottant
Les flottants sont not´s avec un « point dćimal » ou en
e e
notation exponentielle :
2.718
3e8
6.023e23


Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles

Le type ﬂottant
e e
2.718
3e8
6.023e23

Ils supportent les mˆmes op´rations que les entiers, sauf :
e e
20.0 / 3 # 6.666666666666667
20.0 // 3 # 6 (division enti`re forc´e)
e e


Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles

Le type ﬂottant
e e
2.718
3e8
6.023e23

Ils supportent les mˆmes op´rations que les entiers, sauf :
e e
20.0 / 3 # 6.666666666666667
20.0 // 3 # 6 (division enti`re forc´e)
e e

L’import du module « math » autorise toutes les op´rations
e
math´matiques usuelles :
e
from math import sin, pi
print sin(pi/4) # 0.70710678118654746


Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles

Le type complexe

Les complexes sont ćrits en notation cart´sienne, formé de
e e e
deux flottants.


Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles

Le type complexe

Les complexes sont ćrits en notation cart´sienne, formé de
e e e
deux flottants.
La partie imaginaire est suffixé par j :
e
1j # 1j
(2+3j) + (4-7j) # (6-4j)
(9+5j).real # 9.0
(9+5j).imag # 5.0
(abs(3+4j) # 5.0 : module


Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles

Les donn´es et les variables
e

Variable
C’est un nom donn´ ` une valeur.
ea


Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles

e

Variable
ea
Informatiquement, c’est une r´f´rence ` une adresse m´moire.
ee a e


Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles

e

Variable
ea
ee a e

Les noms des variables sont conventionnellement ´crits en
e
minuscule. Ils commencent par une lettre ou le caract`ree
soulign´ ( ), puis ´ventuellement, des lettres, des chiﬀres ou le
e e
caract`re soulign´.
e e


Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles

e

Variable
ea
ee a e

Les noms des variables sont conventionnellement ćrits en
e
minuscule. Ils commencent par une lettre ou le caract`ree
soulign´ ( ), puis ´ventuellement, des lettres, des chiffres ou le
e e
caract`re soulign´.
e e
Ils doivent ˆtre diff´rents des mots r´serv´s de Python.
e e e e


Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles

Les mots r´serv´s de Python 2.5
e e

and def finally in print yield
as del for is raise
assert elif from lambda return
break else global not try
class except if or while
continue exec import pass with


Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles

Les mots r´serv´s de Python 2.5
e e

and def finally in print yield
as del for is raise
assert elif from lambda return
break else global not try
class except if or while
continue exec import pass with

Remarques :
Ne pas red´ﬁnir les constantes None, True et False.
e


Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles

L’affectation

Affectation
On affecte une variable par une valeur en utilisant le signe = (qui
n’a rien ` voir avec l’´galit´ en math !).
a e e


Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles

L’affectation

Affectation
a e e
Dans une affectation, le membre de gauche re¸oit le membre de
c
droite (ce qui nćessite deux temps d’horloge diff´rents).
e e

a = 2 # a "re¸oit" 2
c


Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles

L’affectation

Affectation
a e e
Dans une affectation, le membre de gauche re¸oit le membre de
c
droite (ce qui nćessite deux temps d’horloge diff´rents).
e e

a = 2 # a "re¸oit" 2
c

La valeur d’une variable peut ´voluer au cours du temps (la valeur
e
ant´rieure est perdue) :
e
a = a + 1 # 3 (incr´mentation)
e
a = a - 1 # 2 (dćr´mentation)
e e


Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles

Formes des instructions d’affectation

Outre l’affectation simple, on peut aussi utiliser les formes
suivantes :

a = 4 # forme de base
a += 2 # idem ` : a = a + 2 si a est d´j` r´f´renc´
a e a e e e
c = d = 8 # cibles multiples (affectation de droite ` gauche)
a
e, f = 2.7, 5.1 # affectation de tuple (par position)
e, f = f, e # ćhange les valeurs de e et f
e
g, h = [’G’, ’H’] # affectation de liste (par position)


Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles

Les entrés
e

L’instruction input() permet se saisir une entré au clavier.
e
Elle effectue un typage dynamique. Elle permet ´galement
e
d’afficher une invite :
n = input("Entrez un entier : ")


Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles

Les entrés
e

L’instruction input() permet se saisir une entré au clavier.
e
Elle effectue un typage dynamique. Elle permet ´galement
e
d’afficher une invite :
n = input("Entrez un entier : ")

L’instruction raw input() force une saisie en mode texte que
l’on peut ensuite transtyper :
f1 = raw_input("Entrez un flottant : ")
f1 = float(f1) # transtypage en flottant

f2 = float(raw_input("Entrez un autre flottant : "))


Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles

Les sorties

L’instruction print permet d’aﬃcher des sorties ` l’´cran :
a e
a = 2
b = 5
print a # 2
print "Somme :", a + b # 7
print "Diff´rence :", a - b, # -3
e
print "produit :", a * b # 10


Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles

Les sorties

L’instruction print permet d’aﬃcher des sorties ` l’´cran :
a e
a = 2
b = 5
print a # 2
print "Somme :", a + b # 7
print "Diff´rence :", a - b, # -3
e
print "produit :", a * b # 10

Le s´parateur virgule (,) permet d’empˆcher le retour ` la
e e a
ligne.


Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles

Qu’est-ce qu’une s´quence ?
e

D´ﬁnition
e
Une s´quence est un conteneur ordonn´ d’´l´ments, indic´s par des
e e ee e
entiers positifs ou nuls.


Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles

Qu’est-ce qu’une s´quence ?
e

D´ﬁnition
e
Une s´quence est un conteneur ordonn´ d’´l´ments, indic´s par des
e e ee e
entiers positifs ou nuls.

Python dispose de trois types pr´d´ﬁnis de s´quences :
e e e
les chaˆ
ınes (normales, brutes et en Unicode) ;
les listes ;
les tuples.


Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles

Les chaˆ
ınes de caract`res : notations
e
Trois notations disponibles :
Les guillemets permettent d’inclure des apostrophes :
c1 = "L’eau vive"


Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles

Les chaˆ
e
c1 = "L’eau vive"

Les apostrophes permettent d’inclure des guillemets :
c2 = ’ est "froide" !’


Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles

Les chaˆ
e
c1 = "L’eau vive"

Les apostrophes permettent d’inclure des guillemets :
c2 = ’ est "froide" !’

Les triples guillemets ou triples apostrophes conservent la
mise en page (lignes multiples) :
c3 = """Usage :
-h : help
-q : quit"""


Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles

Les chaˆ
ınes de caract`res : op´rations
e e

Longueur :
s = "abcde"
len(s) # 5


Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles

Les chaˆ
e e

Longueur :
s = "abcde"
len(s) # 5

Concat´nation :
e
s1 = "abc"
s2 = "defg"
s3 = s1 + s2 # ’abcdefg’


Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles

Les chaˆ
e e

Longueur :
s = "abcde"
len(s) # 5

Concat´nation :
e
s1 = "abc"
s2 = "defg"
s3 = s1 + s2 # ’abcdefg’

R´p´tition :
e e
s4 = "Fi! "
s5 = s4 * 3 # ’Fi! Fi! Fi! ’


Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles

Les chaˆ
ınes de caract`res : m´thodes (1/3)
e e

split() : scinde une chaˆ en une liste de mots :
ıne
’ab*cd’.split(’*’) # [’ab’, ’cd’] (on indique le s´parateur)
e


Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles

Les chaˆ
e e

ıne
e

join() : concat`ne une liste de chaˆ
e ınes en une chaˆ :
ıne
’-’.join([’ci’, ’joint’]) # ’ci-joint’


Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles

Les chaˆ
e e

ıne
e

ıne

find() : donne la position d’une sous-chaˆ dans la chaˆ :
ıne ıne
’abracadabra’.find(’bra’) # 1 (le premier indice vaut 0)


Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles

Les chaˆ
e e

ıne
e

ıne

find() : donne la position d’une sous-chaˆ dans la chaˆ :
ıne ıne
’abracadabra’.find(’bra’) # 1 (le premier indice vaut 0)

count() : donne le nombre de sous-chaˆ
ınes dans la chaˆ :
ıne
’abracadabra’.count(’bra’) # 2


Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles

Les chaˆ
e e

lower() : convertit en minuscules :
’PETIT’.lower() # ’petit’


Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles

Les chaˆ
e e


upper() : convertit en majuscules :
’grand’.upper() # ’GRAND’


Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles

Les chaˆ
e e



capitalize() : convertit la premi`re lettre en majuscule :
e
’michelle’.capitalize() # ’Michelle’


Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles

Les chaˆ
e e



capitalize() : convertit la premi`re lettre en majuscule :
e
’michelle’.capitalize() # ’Michelle’

title() : la premi`re lettre de tous les mots en majuscule :
e
’un beau titre !’.title() # ’Un Beau Titre !’


Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles

Les chaˆ
e e

swapcase() : intervertit les casses :
’bOB’.swapcase() # ’Bob’


Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles

Les chaˆ
e e


strip() : supprime les blancs en d´but et ﬁn de chaˆ :
e ıne
’ Trop de blancs ’.strip() # ’Trop de blancs’


Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles

Les chaˆ
e e


strip() : supprime les blancs en d´but et ﬁn de chaˆ :
e ıne
’ Trop de blancs ’.strip() # ’Trop de blancs’

replace() : remplace une sous-chaˆ par une autre :
ıne
’abracadabra’.replace(’a’, ’o’) # ’obrocodobro’


Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles

Les chaˆ
ınes de caract`res : indi¸age
e c

On indique, entre crochets, la position d’un caract`re par un
e
indice qui commence ` 0 :
a
s = "abcdefg"
s[0] # a
s[2] # c
s[-1] # g (n´gatif : on commence par la fin)
e


Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles

Les chaˆ
e c

e
a
s = "abcdefg"
s[0] # a
s[2] # c
e

On peut extraire une sous-chaˆ par d´coupage :
ıne e
s[1:3] # ’bc’
s[3:] # ’defg’
s[:3] # ’abc’


Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles

Les chaˆ
e c

e
a
s = "abcdefg"
s[0] # a
s[2] # c
e

On peut extraire une sous-chaˆ par d´coupage :
ıne e
s[1:3] # ’bc’
s[3:] # ’defg’
s[:3] # ’abc’

Les chaˆ
ınes de caract`res ne sont pas modiﬁables !
e

Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles

Les chaˆ
ınes de caract`res : formatage
e

Les formats permettent de contrˆler finement l’affichage :
o
n = 100
"%d en base 10 : %d" % (n, n) # ’100 en base 10 : 100’
"%d en base 8 : %o" % (n, n) # ’100 en base 8 : 144’
"%d en base 16 : %x" % (n, n) # ’100 en base 16 : 64’

pi = 3.1415926535897931
print "%4.2f" %(pi) # 3.14
print "%.4e" %(pi) # 3.1415e+000
print "%g" %(pi) # 3.14159

msg = "R´sultat sur %d ćhantillons : %4.2f" % (n, pi)
e e
print msg # ’R´sultat sur 100 ćhantillons : 3.14’
e e


Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles

Les principaux formats

%d : entier sign´
e
%u : entier non-sign´
e
%o : un octal non-sign´
e
%x : un hexadćimal non-sign´
e e
%s : une chaˆ de caract`res
ıne e
%f : un flottant
%e : un flottant (format exponentiel)
%g : un flottant (format « optimal » suivant sa longueur)


Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles

Les principaux formats

%d : entier sign´
e
%u : entier non-sign´
e
%o : un octal non-sign´
e
%x : un hexadćimal non-sign´
e e
%s : une chaˆ de caract`res
ıne e
%f : un flottant
%e : un flottant (format exponentiel)
%g : un flottant (format « optimal » suivant sa longueur)
On peut aussi contrˆler le champ d’affichage : "%7.2f" permet
o
d’ćrire un flottant sur 7 caract`res dont 2 apr`s le point dćimal.
e e e e

Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles

Les chaˆ
ınes brutes et en Unicode

Python dispose de variantes tr`s utiles pour coder le type chaˆ :
e ıne
Les chaˆınes brutes sont prć´dés d’un r ou d’un R.
e e e
Elles n’interpr`tent pas les s´quences d’ćhappement comme
e e e
ou n.
Les chaˆ
ınes en Unicode sont prć´dés d’un u ou d’un U.
e e e
Les litt´raux chaˆ
e ınes Unicode bruts commencent par ur, et
non par ru.


Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles

Les listes : d´finition et exemples
e
D´finition
e
Collection h´t´rog`ne, ordonné et modifiable d’´l´ments s´par´s
ee e e ee e e
par des virgules, et entouré de crochets.
e


Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles

Les listes : d´finition et exemples
e
D´finition
e
Collection h´t´rog`ne, ordonné et modifiable d’´l´ments s´par´s
ee e e ee e e
par des virgules, et entouré de crochets.
e

couleurs = [’tr`fle’, ’carreau’, ’coeur’, ’pique’]
e
print couleurs # [’tr`fle’, ’carreau’, ’coeur’, ’pique’]
e
print couleurs[1] # carreau
couleurs[1] = 14
print couleurs # [’tr`fle’, 14, ’coeur’, ’pique’]
e

list1 = [’a’, ’b’]
list2 = [4, 2.718]
list3 = [list1, list2] # liste de listes
print list3 # [[’a’, ’b’], [4, 2.718]]


Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles

Les listes : m´thodes et indi¸age
e c
Mˆmes notations que pour les chaˆ
e ınes de caract`res :
e

nombres = [17, 38, 10, 25, 72]

nombres.sort() # [10, 17, 25, 38, 72]
nombres.append(12) # [10, 17, 25, 38, 72, 12]
nombres.reverse() # [12, 72, 38, 25, 17, 10]
nombres.index(17) # 4
nombres.remove(38) # [12, 72, 25, 17, 10]

nombres[1:3] # [72, 25]
nombres[:2] # [12, 72]
nombres[:] # [12, 72, 25, 17, 10]
nombres[-1] # 10


Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles

Les listes : initialisations

Utilisation de la r´p´tition et de l’instruction range() :
e e

truc = [] # liste vide
machin = [0.0] * 3 # [0.0, 0.0, 0.0]

range(4) # cr´´ la liste [0, 1, 2, 3]
ee
range(4, 8) # cr´´ la liste [4, 5, 6, 7]
ee
range(2, 9, 2) # cr´´ la liste [2, 4, 6, 8]
ee

chose = range(6) # [0, 1, 2, 3, 4, 5]

print 3 in chose # True (teste l’appartenance)


Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles

Les listes : technique de « slicing » avancé (1/2)
e

Insertion d’´l´ments
ee
Dans le membre de gauche d’une affectation, il faut
obligatoirement indiquer une « tranche » pour effectuer une
insertion ou une suppression.


Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles

e

ee
Le membre de droite doit lui-mˆme ˆtre une liste.
e e


Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles

e

ee
Le membre de droite doit lui-mˆme ˆtre une liste.
e e

mots = [’jambon’, ’sel’, ’confiture’]
mots[2:2] = [’miel’] # insertion en 3` position
e
mots[4:4] = [’beurre’] # insertion en 5` position
e
print mots # [’jambon’, ’sel’, ’miel’, ’confiture’, ’beurre’]


Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles

e

Suppression/remplacement d’´l´ments
ee
Mˆmes remarques : une « tranche » dans le membre de gauche,
e
une liste dans le membre de droite.


Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles

e

Suppression/remplacement d’´l´ments
ee
Mˆmes remarques : une « tranche » dans le membre de gauche,
e
une liste dans le membre de droite.

mots = [’jambon’, ’sel’, ’miel’, ’confiture’, ’beurre’]

mots[2:4] = [] # effacement par affectation d’une liste vide
print mots # [’jambon’, ’sel’, ’beurre’]
mots[1:3] = [’salade’]
print mots # [’jambon’, ’salade’]
mots[1:] = [’mayonnaise’, ’poulet’, ’tomate’]
print mots # [’jambon’, ’mayonnaise’, ’poulet’, ’tomate’]


Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles

Les tuples

D´finition
e
Collection h´t´rog`ne, ordonné et immuable d’´l´ments s´par´s
ee e e ee e e
par des virgules, et entouré de parenth`ses.
e e


Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles

Les tuples

D´ﬁnition
e
ee e e ee e e
e e

monTuple = (’a’, 2, [1, 3])


Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles

Les tuples

D´ﬁnition
e
ee e e ee e e
e e

monTuple = (’a’, 2, [1, 3])

Les tuples s’utilisent comme les listes mais leur parcours est
plus rapide ;

Comme les chaˆ
ınes de caract`res, les tuples ne sont pas
e
modiﬁables !

Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles

Les tuples

D´finition
e
ee e e ee e e
e e

monTuple = (’a’, 2, [1, 3])

Les tuples s’utilisent comme les listes mais leur parcours est
plus rapide ;
Ils sont utiles pour d´finir des constantes.
e

Comme les chaˆ
ınes de caract`res, les tuples ne sont pas
e
modifiables !

Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles

Le probl`me des r´f´rences (1/3)
e ee
L’op´ration d’affectation, apparemment innocente, est une rélle
e e
difficult´ de Python.
e
i = 1
msg = "Quoi de neuf ?"
e = 2.718


Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles

e ee
e e
e
i = 1
e = 2.718

Dans l’exemple ci-dessus, l’affectation rálise plusieurs op´rations :
e e
cré et m´morise un nom de variable dans l’espace de noms
e e
courant (c’est en fait une adresse) ;


Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles

e ee
e e
e
i = 1
e = 2.718

e e
e e
lui attribue dynamiquement un type bien d´termin´ ;
e e


Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles

e ee
e e
e
i = 1
e = 2.718

e e
e e
e e
cr´e et m´morise une valeur (membre de droite) ;
e e


Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles

e ee
e e
e
i = 1
e = 2.718

e e
e e
e e
cr´e et m´morise une valeur (membre de droite) ;
e e
´tablit un lien entre le nom de la variable et l’adresse de la
e
valeur correspondante.

Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles

e ee
Une cons´quence de ce mćanisme est que, si un objet modifiable
e e
est affect´, tout changement sur un objet modifiera l’autre :
e
fable = [’Je’, ’plie’, ’mais’, ’ne’, ’romps’, ’point’]
phrase = fable
fable[4] = ’casse’


Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles

e ee
Si l’on d´sire r´aliser une vraie copie d’un objet, on utilise le
e e
module copy :


Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles

e ee
e e
module copy :

import copy
a = [1, 2, 3]
b = a # une r´f´rence
e e
b.append(4)
print a # [1, 2, 3, 4]
c = copy.copy(a) # une copie de "surface"
c.append(5)
print a # [1, 2, 3, 5]


Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles

e ee
e e
module copy :

import copy
a = [1, 2, 3]
b = a # une r´f´rence
e e
b.append(4)
print a # [1, 2, 3, 4]
c = copy.copy(a) # une copie de "surface"
c.append(5)
print a # [1, 2, 3, 5]

Dans les rares occasions o` l’on veut aussi que chaque ´l´ment et
u ee
attribut de l’objet soit copi´ s´par´ment et de fa¸on r´cursive, on
e e e c e
emploie deepcopy().

Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles

Les dictionnaires : d´finition et exemples
e

D´finition
e
Collection de couples cl´ : valeur entouré d’accolades.
e e


Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles

Les dictionnaires : d´finition et exemples
e

D´finition
e
Collection de couples cl´ : valeur entouré d’accolades.
e e

dico = {} # dictionnaire vide

dico[’I’] = ’je’
dico[’she’] = ’elle’
dico[’you’] = ’vous’
print dico # {’I’:’je’, ’she’:’vous’, ’you’:’vous’}
print dico[’I’] # ’je’
del dico[’I’]
print dico # {’she’:’vous’, ’you’:’vous’}
dico[’we’] = ’nous’


Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles

Les dictionnaires : m´thodes
e

Les m´thodes suivantes sont sp´ciﬁques aux dictionnaires :
e e

dico.keys() # [’we’, ’she’, ’you’]
dico.values() # [’nous’, ’elle’, ’vous’]
dico.items() # [(’we’,’nous’), (’she’,’elle’), (’you’,’
vous’)]
dico.has_key(’I’) # False
dico.has_key(’we’) # True


Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles

Les dictionnaires : m´thodes
e

Les m´thodes suivantes sont sp´ciﬁques aux dictionnaires :
e e

dico.keys() # [’we’, ’she’, ’you’]
dico.values() # [’nous’, ’elle’, ’vous’]
dico.items() # [(’we’,’nous’), (’she’,’elle’), (’you’,’
vous’)]
dico.has_key(’I’) # False
dico.has_key(’we’) # True

Les dictionnaires ne sont pas ordonn´s.
e
On ne peut donc pas les indicer.


Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles

Les dictionnaires : it´rateurs
e
D´finition
e
Les it´rateurs sont des objets spćifiques permettant de parcourir
e e
un dictionnaire.


Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles

Les dictionnaires : it´rateurs
e
D´finition
e
Les it´rateurs sont des objets spćifiques permettant de parcourir
e e
un dictionnaire.

On dispose d’it´rateurs sur les cl´s, les valeurs et les items :
e e
d = {’a’:1, ’b’:2, ’c’:3, ’d’:4} # un dictionnaire

for it1 in d.iterkeys():
print it1, # a c b d

for it2 in d.itervalues():
print it2, # 1 3 2 4

for it3 in d.iteritems():
print it3, # (’a’, 1) (’c’, 3) (’b’, 2) (’d’, 4)

Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles

Les ensembles

Ils sont g´n´r´s par la fonction set() :
e ee
x = set(’abcd’)
y = set(’bdx’)


Les types simples
e
e
e
ee
Les dictionnaires
Les ensembles

Les ensembles

Ils sont g´n´r´s par la fonction set() :
e ee
x = set(’abcd’)
y = set(’bdx’)

Op´rations sur les ensembles :
e
’c’ in x # True : appartenance
x - y # set([’a’, ’c’]) : diff´rence
e
x | y # set([’a’, ’c’, ’b’, ’d’, ’x’]) : union
x & y # set([’b’, ’d’]) : intersection


e
Choisir
Boucler
Le contrˆle du ﬂux d’instructions
o
Parcourir
e
e

e

Syntaxe
Elles se composent :
d’une ligne d’en-tˆte termin´e par deux-points ;
e e


e
Choisir
Boucler
o
Parcourir
e
e

e

Syntaxe
e e
d’un bloc d’instructions indent´ au mˆme niveau.
e e


e
Choisir
Boucler
o
Parcourir
e
e

e

Syntaxe
e e
d’un bloc d’instructions indent´ au mˆme niveau.
e e

On peut imbriquer des instructions composés pour ráliser des
e e
structures de dćision complexes.
e


e
Choisir
Boucler
o
Parcourir
e
e

if -- [elif] -- [else]

Contrˆler une alternative :
o


e
Choisir
Boucler
o
Parcourir
e
e

if -- [elif] -- [else]

Contrˆler une alternative :
o

if x < 0:
print "x est n´gatif"
e
elif x % 2:
print "x est positif et impair"
else:
print "x n’est pas n´gatif et est pair"
e

# Test d’une valeur bool´enne :
e
if x: # mieux que (if x is True:) ou que (if x == True:)


e
Choisir
Boucler
o
Parcourir
e
e

while -- [else]

R´p´ter une portion de code :
e e


e
Choisir
Boucler
o
Parcourir
e
e

while -- [else]

R´p´ter une portion de code :
e e

cpt = 0
while x > 0:
x = x // 2 # division avec troncature
cpt += 1 # incr´mentation
e
print "L’approximation de log2 de x est", cpt

# Exemple de saisie filtr´e
e
n = input(’Entrez un entier [1 .. 10] : ’)
while (n < 1) or (n > 10):
n = input(’Entrez un entier [1 .. 10], S.V.P. : ’)


e
Choisir
Boucler
o
Parcourir
e
e

for -- [else]

Parcourir une s´quence :
e


e
Choisir
Boucler
o
Parcourir
e
e

for -- [else]

Parcourir une s´quence :
e

for lettre in "ciao":
print lettre, # c i a o

for x in [2, ’a’, 3.14]:
print x, # 2 a 3.14

for i in range(5):
print i, # 0 1 2 3 4


e
Choisir
Boucler
o
Parcourir
e
e

Les listes en compr´hension (1/3)
e
D´ﬁnition
e
Une liste en compr´hension est une expression qui permet de
e
g´n´rer une liste de mani`re tr`s compacte.
e e e e


e
Choisir
Boucler
o
Parcourir
e
e

e
D´ﬁnition
e
e
e e e e
Elle est ´quivalente ` une boucle for qui construirait la mˆme liste
e a e
en utilisant la m´thode append().
e


e
Choisir
Boucler
o
Parcourir
e
e

e
D´ﬁnition
e
e
e e e e
Elle est ´quivalente ` une boucle for qui construirait la mˆme liste
e a e
en utilisant la m´thode append().
e

Les listes en compr´hension sont utilisables sous trois formes.
e
Premi`re forme :
e
result1 = [x+1 for x in une_seq]
# a le m^me effet que :
e
result2 = []
for x in une_seq:
result2.append(x+1)


e
Choisir
Boucler
o
Parcourir
e
e

e
Deuxi`me forme :
e
result3 = [x+1 for x in une_seq if x > 23]
e
result4 = []
for x in une_seq:
if x > 23:
result4.append(x+1)


e
Choisir
Boucler
o
Parcourir
e
e

e
Deuxi`me forme :
e
result3 = [x+1 for x in une_seq if x > 23]
e
result4 = []
for x in une_seq:
if x > 23:
result4.append(x+1)

Troisi`me forme :
e
result5 = [x+y for x in une_seq for y in une_autre]
e
result6 = []
for x in une_seq:
for y in une_autre:
result6.append(x+y)


e
Choisir
Boucler
o
Parcourir
e
e

e

Une utilisation fr´quente tr`s « pythonique », le calcul d’une
e e
somme :

s = sum([i for i in xrange(10)])
e
s = 0
for i in xrange(10):
s = s + i


e
Choisir
Boucler
o
Parcourir
e
e

Interrompre : break

Sort imm´diatement de la boucle for ou while en cours
e
contenant l’instruction et passe outre le else ´ventuel :
e


e
Choisir
Boucler
o
Parcourir
e
e

Interrompre : break

Sort imm´diatement de la boucle for ou while en cours
e
contenant l’instruction et passe outre le else ´ventuel :
e

for x in range(1, 11):
if x == 5:
break
print x,

print "nBoucle interrompue pour x =", x
# affiche :
# 1 2 3 4
# Boucle interrompue pour x = 5


e
Choisir
Boucler
o
Parcourir
e
e

Interrompre : continue

Passe imm´diatement au d´but de la boucle for ou while en
e e
cours contenant l’instruction ; reprend ` la ligne de l’en-tˆte de la
a e
boucle :


e
Choisir
Boucler
o
Parcourir
e
e

Interrompre : continue

Passe imm´diatement au d´but de la boucle for ou while en
e e
cours contenant l’instruction ; reprend ` la ligne de l’en-tˆte de la
a e
boucle :

for x in range(1, 11):
if x == 5:
continue
print x,

print "nLa boucle a saut´ la valeur 5"
e
# affiche :
# 1 2 3 4 6 7 8 9 10
# La boucle a saut´ la valeur 5
e


e
Choisir
Boucler
o
Parcourir
e
e

Exceptions : try -- except -- [else]

D´finition
e
Op´ration effectué ` l’exćution par Python lorsqu’une erreur est
e e a e
d´tecté.
e e


e
Choisir
Boucler
o
Parcourir
e
e

Exceptions : try -- except -- [else]

D´finition
e
Op´ration effectué ` l’exćution par Python lorsqu’une erreur est
e e a e
d´tecté.
e e

from math import sin

for x in range(-3, 4):
try:
print ’%.3f’ %(sin(x)/x), # cas normal
except:
print 1.0, # g`re l’exception en 0
e


e
Choisir
Boucler
o
Parcourir
e
e

G´rer ses propres exceptions : raise
e

L’instruction raise permet de lever volontairement une
exception :


e
Choisir
Boucler
o
Parcourir
e
e

e

exception :

if not 0<=x<=1:
raise ValueError, "x n’est pas dans [0 .. 1]"


e
Choisir
Boucler
o
Parcourir
e
e

e

exception :

if not 0<=x<=1:
raise ValueError, "x n’est pas dans [0 .. 1]"

(Voir la liste des exceptions standards dans la documentation
Python)


e
Fonctions–Espaces de noms–Modules
Espaces de noms
Modules

D´ﬁnition et syntaxe
e
Fonction
Groupe d’instructions regroup´ sous un nom et s’ex´cutant ` la
e e a
demande (appel). Les fonctions sont les ´l´ments structurants de
ee
base de tout langage proc´dural.
e


e
Espaces de noms
Modules

e
Fonction
e e a
ee
e

Syntaxe
C’est une instruction compos´e :
e
def nom_fonction(param`tres):
e
<bloc_instructions>


e
Espaces de noms
Modules

e
Fonction
e e a
ee
e

Syntaxe
C’est une instruction compos´e :
e
def nom_fonction(param`tres):
e
<bloc_instructions>

Le bloc d’instructions est obligatoire. S’il ne fait rien, on emploie
l’instruction pass.

e
Espaces de noms
Modules

Exemples de fonction et d’appel

def double(x):
return 2*x

def table(base):
n = 1
while n < 11:
print n * base,
n += 1

print double(8) # 16 : "appel" de la fonction double
# Affiche la table de multiplication par 8 :
table(8) # "appel" de la fonction table


e
Espaces de noms
Modules

Mćanisme gń´ral
e e e

Passage par affectation
Chaque argument de la d´finition de la fonction correspond, dans
e
l’ordre, ` un param`tre de l’appel.
a e


e
Espaces de noms
Modules

e e e

e
a e
La correspondance se fait par aﬀectation.


e
Espaces de noms
Modules

e e e

e
a e
La correspondance se fait par aﬀectation.

def ma_fonction(x, y, z):
pass

# Appel de la fonction :
## le passage d’arguments se fait dans l’ordre, par affectation :
ma_fonction(7, ’k’, 2.718) # x = 7, y = ’k’, z = 2.718


e
Espaces de noms
Modules

Un ou plusieurs param`tres, pas de retour
e

def table(base, debut, fin):
n = debut
while n <= fin:
print n, ’x’, base, ’=’, n * base,
n += 1

# exemple d’appel :
table(7, 2, 11)


e
Espaces de noms
Modules

Un ou plusieurs param`tres, utilisation du retour
e

from math import pi

def cube(x):
return x**3

def volumeSphere(r):
return 4.0 * pi * cube(r) / 3.0

# Saisie du rayon et affichage du volume
rayon = float(raw_input(’Rayon : ’))
print ’Volume de la sph`re =’, volumeSphere(rayon)
e


e
Espaces de noms
Modules

Param`tres avec valeur par d´faut
e e

def initport(speed=9600, parity="paire", data=8, stops=1):
print "Initialisation `", speed, "bits/s"
a
print "parit´ :", parity
e
print dat, "bits de donnés"
e
print stops, "bits d’arr^t"
e

# Appels possibles :
initport()
initPort(parity="nulle")
initPort(2400, "paire", 7, 2)

Note : on utilise de pr´f´rence des valeurs par d´faut
ee e
non-modifiables (entiers, booléns, flottants, complexes, chaˆ
e ınes,
tuples) car la modification d’un param`tre par un premier appel est
e
visible les fois suivantes.

e
Espaces de noms
Modules

Nombre d’arguments arbitraire : passage d’un tuple (1/2)

def somme(*args):
resultat = 0
for nombre in args:
resultat += nombre
return resultat

# Exemples d’appel :
print somme(23) # 23
print somme(23, 42, 13) # 78


e
Espaces de noms
Modules

Nombre d’arguments arbitraire : passage d’un tuple (2/2)

Il est aussi possible de passer un tuple ` l’appel qui sera
a
d´compress´ en une liste de param`tres d’une fonction
e e e
« classique » :

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

# Exemple d’appel :
elements = [2, 4, 6]
print somme(*elements)


e
Espaces de noms
Modules

Nombre d’arguments arbitraire : passage d’un dictionnaire

def un_dict(**kargs):
return kargs

# Exemples d’appels
## par des param`res nomm´s :
e e
print un_dict(a=23, b=42) # affiche : {’a’: 23, ’b’: 42}
## en fournissant un dictionnaire :
mots = {’d’: 85, ’e’: 14, ’f’:9}
print un_dict(**mots) # affiche : {’e’: 14, ’d’: 85, ’f’: 9}


e
Espaces de noms
Modules

Porté des objets
e

Porté
e
Les noms des objets sont cr´´s lors de leur premi`re affectation,
ee e
mais ne sont visibles que dans certaines r´gions de la m´moire.
e e


e
Espaces de noms
Modules

Porté des objets
e

Porté
e
ee e
e e

Porté globale : celle du module main . Un dictionnaire
e
g`re les objets globaux : l’instruction globals() fournit les
e
couples variable : valeur ;


e
Espaces de noms
Modules

Porté des objets
e

Porté
e
ee e
e e

Porté globale : celle du module main . Un dictionnaire
e
g`re les objets globaux : l’instruction globals() fournit les
e
couples variable : valeur ;
Porté locale : les objets internes aux fonctions (et aux
e
classes) sont locaux. Les objets globaux ne sont pas
modifiables dans les portés locales. L’instruction locals()
e
fournit les couples variable : valeur.

e
Espaces de noms
Modules

R´solution des noms : r`gle LGI
e e

La recherche des noms est d’abord locale (L), puis globale (G),
enﬁn interne (I) :


e
Espaces de noms
Modules

Exemple de port´e (1/3)
e

# x et fonc sont affect´s dans le module : globaux
e

def fonc(y): # y et z sont affect´s dans fonc : locaux
e
# dans fonc : port´e locale
e
z = x + y
return z

x = 99
print fonc(1) # affiche : 100


e
Espaces de noms
Modules

e

e

def fonc(y): # y, x et z sont affect´s dans fonc : locaux
e
x = 3 # ce nouvel x est local et masque le x global
z = x + y
return z

x = 99


e
Espaces de noms
Modules

e

e

def fonc(y): # y et z sont affect´s dans fonc : locaux
e
global x # permet de modifier x ligne suivante
x += 2
z = x + y
return z

x = 99


e
Espaces de noms
Modules

D´ﬁnition
e

Module
Fichier ind´pendant permettant d’´laborer des biblioth`ques de
e e e
fonctions ou de classes.


e
Espaces de noms
Modules

D´ﬁnition
e

Module
e e e

Avantages des modules :
r´utilisation du code ;
e


e
Espaces de noms
Modules

D´ﬁnition
e

Module
e e e

e
la documentation et les tests peuvent ˆtre int´gr´s au module ;
e e e


e
Espaces de noms
Modules

D´finition
e

Module
e e e

e
e e e
rálisation de services ou de donnés partag´s ;
e e e


e
Espaces de noms
Modules

D´finition
e

Module
e e e

e
e e e
rálisation de services ou de donnés partag´s ;
e e e
partition de l’espace de noms du syst`me.
e


e
Espaces de noms
Modules

Import d’un modules

Deux syntaxes possibles :
la commande import <nom module> importe la totalit´ des
e
objets du module :
import Tkinter


e
Espaces de noms
Modules

Import d’un modules

Deux syntaxes possibles :
la commande import <nom module> importe la totalit´ des
e
objets du module :
import Tkinter

la commande from <nom module> import obj1,...
n’importe que les objets obj1,... du module :
from math import pi, sin, log


e
Espaces de noms
Modules

Exemple
Un module m cube.py :
def cube(y):
"""Calcule le cube du param`tre.""" # docstring
e
reurn y**3

# Auto-test ----------------------------------------------------
if __name__ == "__main__": # ignor´ lors d’un import
e
help(cube) # affiche le docstring de la fonction
print "cube de 9 :", cube(9)

Utilisation du module :
from m_cube import cube

for i in xrange(10):
print "cube de", i, "=", cube(i)

e e
Les fichiers
e

Ouverture et fermeture des fichiers

Le type fichier est un type pr´-d´fini de Python.
e e


e e
Les fichiers
e


e e

Principaux modes d’ouverture :
f1 = open("monFichier_1", "r") # en lecture
f2 = open("monFichier_2", "w") # en ćriture
e
f3 = open("monFichier_3", "a") # en ajout

Python utilise les fichiers en mode texte par d´faut (not´ t). Pour
e e
les fichiers binaires on prćise le mode b. Tant que le fichier n’est
e
pas ferm´, son contenu n’est pas garanti sur le disque.
e


e e
Les fichiers
e


e e

Principaux modes d’ouverture :
f1 = open("monFichier_1", "r") # en lecture
f2 = open("monFichier_2", "w") # en ćriture
e
f3 = open("monFichier_3", "a") # en ajout

Python utilise les fichiers en mode texte par d´faut (not´ t). Pour
e e
les fichiers binaires on prćise le mode b. Tant que le fichier n’est
e
pas ferm´, son contenu n’est pas garanti sur le disque.
e
Une seule m´thode de fermeture :
e
f1.close()


e e
Les fichiers
e

´
Ecriture s´quentielle
e

M´thodes d’ćriture :
e e

f = open("truc.txt", "w")
s = ’toto’
f.write(s) # ćrit la cha^ne s dans f
e ı
l = [’a’, ’b’, ’c’]
f.writelines(l) # ćrit les cha^nes de la liste l dans f
e ı
f.close()

# on peut aussi utiliser le "print ´tendu" :
e
f = open("truc.txt", "w")
print >> f, "abcd" # ćrit dans f en mode ajout
e
f.close()


e e
Les ﬁchiers
e

Lecture s´quentielle
e

M´thodes de lecture :
e

f = open("truc.txt", "r")
s = f.read() # lit tout le fichier --> string
s = f.read(n) # lit au plus n octets --> string
s = f.readline() # lit la ligne suivante --> string
s = f.readlines() # lit tout le fichier --> liste de strings

for ligne in f:
print ligne # bon proc´d´ de parcours d’un fichier
e e

f.close()


e e
Les ﬁchiers
e

Il permet la conservation des types :
import pickle

a, b = 5, 2.83
f = open("monFichier.txt", "w") # en ´criture
e
pickle.dump(a, f)
pickle.dump(b, f)
f.close()

f = open("monFichier.txt", "r") # en lecture
t = pickle.load(f)
print t, type(t) # 5 <type ’int’>
t = pickle.load(f)
print t, type(t) # 2.83 <type ’float’>
f.close()


M´thodes
e
La programmation « OO »
e e
e

La programmation Orient´e Objet
e

Les classes sont les ´l´ments structurants de base de tout langage
ee
orient´ objet.
e
Une classe Python poss`de plusieurs caract´ristiques :
e e
on appelle un objet classe comme s’il s’agissait d’une fonction.
L’objet cr´´ (instance) sait ` quelle classe il appartient ;
ee a


M´thodes
e
e e
e

e

ee
orient´ objet.
e
e e
ee a
Une classe poss`de deux sortes d’attributs : des donn´es et
e e
des fonctions (appel´es m´thodes) ;
e e


M´thodes
e
e e
e

e

ee
orient´ objet.
e
e e
ee a
e e
e e
Python d´ﬁnit des m´thodes sp´ciales ;
e e e


M´thodes
e
e e
e

e

ee
orient´ objet.
e
e e
ee a
e e
e e
Python d´ﬁnit des m´thodes sp´ciales ;
e e e
Une classe peut h´riter d’autres classes.
e


M´thodes
e
e e
e

L’instruction class

C’est une instruction compos´e : en-tˆte (avec docstring) + corps
e e
indent´.
e

class C(object):
"""Documentation de la classe."""
x = 23


M´thodes
e
e e
e

L’instruction class

C’est une instruction compos´e : en-tˆte (avec docstring) + corps
e e
indent´.
e

class C(object):
"""Documentation de la classe."""
x = 23

Dans cet exemple, C est le nom de la classe (qui commence
conventionnellement par une majuscule), object est un type
pr´d´ﬁni ancˆtre de tous les autres types, et x est un attribut de
e e e
classe, local ` C.
a


M´thodes
e
e e
e

L’instanciation et ses attributs

On cr´e un objet en appelant le nom de sa classe :
e

a = C() # a est un objet de la classe C
print dir(a) # affiche les attributs de l’objet a
print a.x # affiche 23. x est un attribut de classe
a.x = 12 # modifie l’attribut d’instance (attention...)
print C.x # 23, l’attribut de classe est inchang´e
e
a.y = 44 # nouvel attribut d’instance

b = C() # b est un autre objet de la classe C
print b.x # 23. b conna^t son attribut de classe, mais...
ı
print b.y # AttributeError: C instance has no attribute ’y’


M´thodes
e
e e
e

Retour sur les espaces de noms (1/2)

Les espaces de noms sont impl´ment´s par des dictionnaires pour
e e
les modules, les classes et les intances.


M´thodes
e
e e
e


e e

Noms non qualifi´s (exemple dimension) l’affectation cré
e e
ou change le nom dans la porté locale courante. Ils sont
e
cherch´s suivant la r`gle LGI.
e e


M´thodes
e
e e
e


e e

Noms non qualifi´s (exemple dimension) l’affectation cré
e e
ou change le nom dans la porté locale courante. Ils sont
e
cherch´s suivant la r`gle LGI.
e e
Noms qualifi´s (exemple dimension.hauteur) l’affectation
e
cré ou modifie l’attribut dans l’espace de noms de l’objet. Un
e
attribut est cherch´ dans l’objet, puis dans toutes les classes
e
dont l’objet d´pend (mais pas dans les modules).
e


M´thodes
e
e e
e


L’exemple suivant aﬃche le dictionnaire li´ ` la classe C puis la
ea
liste des attributs li´s ` une instance de C.
e a


M´thodes
e
e e
e


L’exemple suivant aﬃche le dictionnaire li´ ` la classe C puis la
ea
liste des attributs li´s ` une instance de C.
e a
class C(object):
x = 20

print C.__dict__ # {’__dict__’: <attribute ’__dict__’ of ’C’
objects>, ’x’: 20, ’__module__’: ’__main__’, ’__weakref__’:
<attribute ’__weakref__’ of ’C’ objects>, ’__doc__’: None}
a = C()
print dir(a) # [’__class__’, ’__delattr__’, ’__dict__’, ’
__doc__’, ’__getattribute__’, ’__hash__’, ’__init__’, ’
__module__’, ’__new__’, ’__reduce__’, ’__reduce_ex__’, ’
__repr__’, ’__setattr__’, ’__str__’, ’__weakref__’, ’x’]


M´thodes
e
e e
e

Syntaxe
M´thode
e
Une m´thode s’´crit comme une fonction du corps de la classe
e e
avec un premier param`tre self obligatoire. self repr´sente
e e
l’objet sur lequel la m´thode sera appliqu´e.
e e


M´thodes
e
e e
e

Syntaxe
M´thode
e
Une m´thode s’´crit comme une fonction du corps de la classe
e e
avec un premier param`tre self obligatoire. self repr´sente
e e
l’objet sur lequel la m´thode sera appliqu´e.
e e

class C(object):
x = 23 # x et y : attributs de classe
y = x + 5
def affiche(self): # m´thode affiche()
e
self.z = 42 # attribut d’instance
print C.y, # dans une m´thode, on qualifie un attribut
e
de classe,
print self.z # mais pas un attribut d’instance
ob = C() # instanciation de l’objet ob
ob.affiche() # 28 42 (` l’appel, ob affecte self)
a

M´thodes
e
e e
e

Les m´thodes spćiales
e e

Ces m´thodes portent des noms pr´-d´finis, prć´d´s et suivis de
e e e e e e
deux caract`res de soulignement.
e


M´thodes
e
e e
e

e e

e e e e e e
e

Elles servent :
` initialiser l’objet instanci´ ;
a e


M´thodes
e
e e
e

e e

e e e e e e
e

Elles servent :
a e
` modiﬁer son aﬃchage ;
a


M´thodes
e
e e
e

e e

e e e e e e
e

Elles servent :
a e
a
` surcharger ses op´rateurs ;
a e


M´thodes
e
e e
e

e e

e e e e e e
e

Elles servent :
a e
a
` surcharger ses op´rateurs ;
a e
...


M´thodes
e
e e
e

Le constructeur

Lors de l’instanciation d’un objet, la m´thode init est
e
automatiquement invoqué. Elle permet d’effectuer toutes les
e
initialisations nćessaires :
e


M´thodes
e
e e
e

Le constructeur

Lors de l’instanciation d’un objet, la m´thode init est
e
automatiquement invoqué. Elle permet d’effectuer toutes les
e
initialisations nćessaires :
e

class C(object):
def __init__(self, n):
self.x = n # initialisation de l’attribut d’instance x

uneInstance = C(42) # param`tre obligatoire, affect´ ` n
e e a
print uneInstance.x # 42


M´thodes
e
e e
e

Surcharge des op´rateurs (1/2)
e

La surcharge permet ` un op´rateur de poss´der un sens diﬀ´rent
a e e e
suivant le type de leurs op´randes. Par exemple, l’op´rateur +
e e
permet :


M´thodes
e
e e
e

e

a e e e
e e
permet :

x = 7 + 9 # addition enti`re
e
s = ’ab’ + ’cd’ # concat´nation
e


M´thodes
e
e e
e

e

a e e e
e e
permet :

e
e

Python poss`de des m´thodes de surcharge pour :
e e
tous les types ( call , str , . . .) ;


M´thodes
e
e e
e

e

a e e e
e e
permet :

e
e

e e
les nombres ( add , div , . . .) ;


M´thodes
e
e e
e

e

a e e e
e e
permet :

e
e

e e
les nombres ( add , div , . . .) ;
les s´quences ( len ,
e iter , . . .).


M´thodes
e
e e
e

e

Soient deux instances, obj1 et obj2, les m´thodes sp´ciales
e e
suivantes permettent d’eﬀectuer les op´rations arithm´tiques
e e
courantes :


M´thodes
e
e e
e

e

Soient deux instances, obj1 et obj2, les m´thodes spćiales
e e
suivantes permettent d’effectuer les op´rations arithm´tiques
e e
courantes :

Nom M´thode spćiale
e e Utilisation
oppos´ e neg -obj1
addition add obj1 + obj2
soustraction sub obj1 - obj2
multiplication mul obj1 * obj2
division div obj1 / obj2


M´thodes
e
e e
e

Exemple de surcharge

class Vecteur2D(object):
def __init__(self, x, y):
self.x = x
self.y = y
def __add__(self, autre): # addition vectorielle
return Vecteur2D(self.x + autre.x, self.y + autre.y)
def __str__(self): # affichage d’un Vecteur2D
return "Vecteur(%g, %g)" % (self.x, self.y)

v1 = Vecteur2D(1.2, 2.3)
v2 = Vecteur2D(3.4, 4.5)

print v1 + v2 # affiche : Vecteur(4.6, 6.8)


M´thodes
e
e e
e

e

D´finition
e
L’h´ritage est le mćanisme qui permet de se servir d’une classe
e e
préxistante pour en crér une nouvelle qui poss´dera des
e e e
fonctionnalit´s diff´rentes ou suppl´mentaires.
e e e


M´thodes
e
e e
e

e

D´finition
e
L’h´ritage est le mćanisme qui permet de se servir d’une classe
e e
préxistante pour en crér une nouvelle qui poss´dera des
e e e
fonctionnalit´s diff´rentes ou suppl´mentaires.
e e e

D´finition
e
Le polymorphisme est la facult´ pour une m´thode portant le
e e
mˆme nom mais appartenant ` des classes distinctes h´rités
e a e e
d’effectuer un travail diff´rent. Cette propri´t´ est acquise par la
e ee
technique de la surcharge.


M´thodes
e
e e
e

Exemple d’h´ritage et de polymorphisme
e
Dans l’exemple suivant, la classe Carre h´rite de la classe
e
Rectangle, et la m´thode init est polymorphe :
e


M´thodes
e
e e
e

Exemple d’h´ritage et de polymorphisme
e
Dans l’exemple suivant, la classe Carre h´rite de la classe
e
Rectangle, et la m´thode init est polymorphe :
e

class Rectangle(object):
def __init__(self, longueur=30, largeur=15):
self.L, self.l, self.nom = longueur, largeur, "rectangle"

class Carre(Rectangle):
def __init__(self, cote=10):
Rectangle.__init__(self, cote, cote)
self.nom = "carr´"
e

r = Rectangle()
print r.nom # ’rectangle’
c = Carre()
print c.nom # ’carr´’
e

e e e
e
La programmation « OO » graphique Les classes de widgets de Tkinter
Un exemple

Deux styles de programmation

En programmation graphique objet, on remplace le d´roulement
e
s´quentiel du script par une boucle d’´v´nements :
e e e


e e e
e
Un exemple

e

Parmi les diff´rentes biblioth`ques graphiques utilisables dans
e e
Python (GTK+, wxPython, Qt. . .), la biblioth`que Tkinter,
e
issue du langage tcl/Tk est tr`s employé, car elle est
e e
installé de base dans toute les distributions Python.
e


e e e
e
Un exemple

e

Parmi les diff´rentes biblioth`ques graphiques utilisables dans
e e
Python (GTK+, wxPython, Qt. . .), la biblioth`que Tkinter,
e
issue du langage tcl/Tk est tr`s employé, car elle est
e e
installé de base dans toute les distributions Python.
e
Tkinter facilite la construction de GUI (Graphic User
Interface) simples. Apr`s l’avoir import´, il suffit de crér,
e e e
configurer et positionner les widgets utilis´s, puis d’entrer
e
dans la boucle principale de gestion des ´vńements.
e e


e e e
e
Un exemple

Tkinter : exemple simple

from Tkinter import *

base = Tk()
texte = Label(base, text="Bienvenue !", fg=’red’)
texte.pack()
bouton = Button(base, text="Quit", command=base.destroy)
bouton.pack()

base.mainloop()


e e e
e
Un exemple

Les widgets de Tkinter (1/3)

Tk fenˆtre de plus haut niveau
e
Frame contenant pour organiser d’autres widgets
Label zone de message
Button bouton avec texte ou image
Message zone d’aﬃchage multi-lignes
Entry zone de saisie
Checkbutton bouton ` deux ´tats
a e
Radiobutton bouton ` deux ´tats exclusifs
a e


e e e
e
Un exemple


Scale glissi`re ` plusieurs positions
e a
PhotoImage sert ` placer des images sur des widgets
a
BitmapImage sert ` placer des bitmaps sur des widgets
a
Menu associ´ ` un Menubutton
ea
Menubutton bouton ouvrant un menu d’options
Scrollbar ascenseur
Listbox liste de noms ` s´lectionner
a e
Text ´dition de texte multi-lignes
e


e e e
e
Un exemple


Canvas zone de dessins graphiques ou de photos
OptionMenu liste d´roulante
e
ScrolledText widget Text avec ascenseur
PanedWindow interface ` onglets
a
LabelFrame contenant avec un cadre et un titre
Spinbox un widget de s´lection multiple
e


e e e
e
Un exemple

Gestion de la g´om´trie
e e

Tkinter poss`de trois gestionnaires de positionnement :
e


e e e
e
Un exemple

e e

e

Le packer : dimensionne et place chaque widget dans un
widget conteneur selon l’espace requis par chacun d’eux.


e e e
e
Un exemple

e e

e

Le gridder : dimensionne et positionne chaque widget dans les
cellules d’un tableau d’un widget conteneur.


e e e
e
Un exemple

e e

e

Le gridder : dimensionne et positionne chaque widget dans les
cellules d’un tableau d’un widget conteneur.
Le placer : dimensionne et place chaque widget w dans un
widget conteneur exactement selon ce que demande w. C’est
un placement absolu (usage peu fr´quent).
e


e e e
e
Un exemple

« Saisie » : programmation OO (1/4)

L’en-tˆte et les imports (on utilise le module Pmw, Python Mega
e
Widgets) :
#!/bin/env python
# -*- coding: Latin-1 -*-
"""Programmation OO graphique."""
__file__ = "7_2.py"
__author__ = "Bob Cordeau"

# imports
from Tkinter import *
from tkSimpleDialog import *
import Pmw


e e e
e
Un exemple


La classe App :
# classes
class App:
def __init__(self, master):
self.result = Pmw.EntryField(master, entry_width=8,
value=’10’,
label_text=’Affichage retourn´ : ’,
e
labelpos=W, labelmargin=1)
self.result.pack(padx=15, pady=15)


e e e
e
Un exemple


Le programme principal :
# programme principal -------------------------------------
root = Tk()
display = App(root)
retVal = askinteger("Notes",
"Entrez votre note d’info :",
minvalue=0, maxvalue=50)
display.result.setentry(retVal)
root.mainloop()


e e e
e
Un exemple

Le programme ouvre deux fenˆtres. On saisit une note...
e

...qui est report´e dans la premi`re fenˆtre.
e e e


La table ASCII
Exemple de script
Exemple de module
Les fonctions logiques
Les bases
Bibliographie

Annexes et Bibliographie

La table ASCII
Un exemple complet de script
Un exemple de module
e
Les changements de base
Bibliographie


La table ASCII
Exemple de script
Exemple de module
American Standard Code for Information Interchange
Les bases
Bibliographie


La table ASCII
Exemple de script
But du programme
Exemple de module
En-tˆte
e
Programme principal
Les bases
Bibliographie

Un jeu de carte

L’exemple propos´ programme un jeu de carte dont la r`gle est la
e e
suivante :


La table ASCII
Exemple de script
But du programme
Exemple de module
En-tˆte
e
Programme principal
Les bases
Bibliographie

Un jeu de carte

e e
suivante :
On utilise un jeu de n cartes particulier : chaque carte porte
un num´ro, de 1 ` n.
e a


La table ASCII
Exemple de script
But du programme
Exemple de module
En-tˆte
e
Programme principal
Les bases
Bibliographie

Un jeu de carte

e e
suivante :
e a
Les cartes sont pr´alablement tri´es dans l’ordre croissant.
e e


La table ASCII
Exemple de script
But du programme
Exemple de module
En-tˆte
e
Programme principal
Les bases
Bibliographie

Un jeu de carte

e e
suivante :
e a
e e
Le jeu proprement dit consiste ` :
a


La table ASCII
Exemple de script
But du programme
Exemple de module
En-tˆte
e
Programme principal
Les bases
Bibliographie

Un jeu de carte

e e
suivante :
e a
e e
a
jeter la premi`re carte ;
e


La table ASCII
Exemple de script
But du programme
Exemple de module
En-tˆte
e
Programme principal
Les bases
Bibliographie

Un jeu de carte

e e
suivante :
e a
e e
a
e
mettre la seconde sous le paquet ;


La table ASCII
Exemple de script
But du programme
Exemple de module
En-tˆte
e
Programme principal
Les bases
Bibliographie

Un jeu de carte

e e
suivante :
e a
e e
a
e
recommencer jusqu’` ce qu’il n’en reste qu’une.
a


La table ASCII
Exemple de script
But du programme
Exemple de module
En-tˆte
e
Programme principal
Les bases
Bibliographie

Un jeu de carte

e e
suivante :
e a
e e
a
e
recommencer jusqu’` ce qu’il n’en reste qu’une.
a
Quel est le num´ro de la carte restante ?
e


La table ASCII
Exemple de script
But du programme
Exemple de module
En-tˆte
e
Programme principal
Les bases
Bibliographie

Un en-tˆte g´n´ral
e e e
#!/bin/env python #1
# -*- coding: Latin-1 -*- #2
"""Jeu de carte.""" #3
__file__ = "jeu_de_cartes.py" #4
__author__ = "Adam et Eve" #5


La table ASCII
Exemple de script
But du programme
Exemple de module
En-tˆte
e
Programme principal
Les bases
Bibliographie

e e e
# -*- coding: Latin-1 -*- #2

Ligne 1 : Assure le fonctionnement du script sur tous les
syst`mes.
e


La table ASCII
Exemple de script
But du programme
Exemple de module
En-tˆte
e
Programme principal
Les bases
Bibliographie

e e e
# -*- coding: Latin-1 -*- #2

syst`mes.
e
Ligne 2 : d´ﬁnit l’encodage (permet l’utilisation des accents
e
usuels en fran¸ais).
c


La table ASCII
Exemple de script
But du programme
Exemple de module
En-tˆte
e
Programme principal
Les bases
Bibliographie

e e e
# -*- coding: Latin-1 -*- #2

syst`mes.
e
e
c
Ligne 3 : le docstring du script.


La table ASCII
Exemple de script
But du programme
Exemple de module
En-tˆte
e
Programme principal
Les bases
Bibliographie

e e e
# -*- coding: Latin-1 -*- #2

syst`mes.
e
e
c
Ligne 4 : nom du script.


La table ASCII
Exemple de script
But du programme
Exemple de module
En-tˆte
e
Programme principal
Les bases
Bibliographie

e e e
# -*- coding: Latin-1 -*- #2

syst`mes.
e
e
c
Ligne 4 : nom du script.
Ligne 5 : noms des auteurs.

La table ASCII
Exemple de script
But du programme
Exemple de module
En-tˆte
e
Programme principal
Les bases
Bibliographie

# programme principal -------------------------------------
taille = input("Taille du jeu de cartes : ")
while taille < 2:
taille = input("Taille du jeu (taille > 1), s.v.p. : ")

# on constitue le jeu (1, 2, 3...)
t = [i+1 for i in xrange(taille)]

# on joue
while taille > 1:
sauve = t[1] # la deuxi`me carte
e
t = t[2:] # d´calage du jeu de 2 crans ` gauche
e a
t.append(sauve) # sauve est mise sous le paquet
taille -= 1 # on r´duit la taille du jeu
e

print "nCarte restante :", sauve


La table ASCII
Exemple de script
Exemple de module Un module d’assertion (1/2)
Les fonctions logiques Un module d’assertion (2/2)
Les bases
Bibliographie

L’en-tˆte et les imports :
e
#!/bin/env python
# -*- coding: Latin-1 -*-
"""Module de v´rification."""
e
__file__ = "verif_m.py"
__author__ = "Bob Cordeau"

# imports
from sys import exit


La table ASCII
Exemple de script
Exemple de module Un module d’assertion (1/2)
Les fonctions logiques Un module d’assertion (2/2)
Les bases
Bibliographie

La fonction et son auto-test :
# fonctions
def verif(entree, reference, precision=0, comment=""):
"""V´rifie que l’entr´e est ´gale ` la r´f´rence ` la
e e e a e e a
pr´cision pr`s."""
e e
print "%s[%s, %s]" % (comment, entree, reference),
if abs(entree - reference) <= precision:
print ": ok"
else:
print "### ERREUR ! ###"
exit(1)

# auto-test -------------------------------------
if __name__==’__main__’:
def f(x):
return 7*x-5
verif(f(2), 9, comment="Teste la fonction f : ")


La table ASCII
Exemple de script
La logique de Boole
Exemple de module
Les tables de v´rit´
e e
Les op´rateurs compos´s
e e
Les bases
Bibliographie

Les variables logiques

Au 19` si`cle, le logicien et math´maticien George Boole
e e e
restructura compl`tement la logique en un syst`me formel.
e e
Aujourd’hui, l’alg`bre de Boole trouve de nombreuses applications
e
en informatique et dans la conception des circuits ´lectroniques.
e


La table ASCII
Exemple de script
La logique de Boole
Exemple de module
e e
e e
Les bases
Bibliographie


e e e
e e
e
e

C’est une logique ` deux valeurs. Soit B = {0, 1}, l’ensemble de
a
d´ﬁnition, sur lequel on d´ﬁnit les op´rateurs NON, ET et OU.
e e e


La table ASCII
Exemple de script
La logique de Boole
Exemple de module
e e
e e
Les bases
Bibliographie


e e e
e e
e
e

C’est une logique ` deux valeurs. Soit B = {0, 1}, l’ensemble de
a
d´finition, sur lequel on d´finit les op´rateurs NON, ET et OU.
e e e

Les valeurs des variables sont parfois notés False et True.
e
Les op´rateurs sont parfois notés respectivement a, a.b et a + b.
e e


La table ASCII
Exemple de script
La logique de Boole
Exemple de module
e e
e e
Les bases
Bibliographie

Les tables de v´rit´ des op´rateurs bool´ens
e e e e

Table de v´rit´ des op´rateurs bool´ens de base :
e e e e


La table ASCII
Exemple de script
La logique de Boole
Exemple de module
e e
e e
Les bases
Bibliographie

Les tables de v´rit´ des op´rateurs bool´ens
e e e e

Table de v´rit´ des op´rateurs bool´ens de base :
e e e e

Op´rateurs binaires OU et ET
e
Op´rateur unaire NON
e
a b a OU b a ET b
a NON(a) 0 0 0 0
0 1 1 0
0 1
1 0 1 0
1 0
1 1 1 1


La table ASCII
Exemple de script
La logique de Boole
Exemple de module
e e
e e
Les bases
Bibliographie

Les tables de v´rit´ des op´rateurs compos´s
e e e e

Table de v´rit´ des op´rateurs ou exclusif, ´quivalence et
e e e e
implication :


La table ASCII
Exemple de script
La logique de Boole
Exemple de module
e e
e e
Les bases
Bibliographie

Les tables de v´rit´ des op´rateurs compos´s
e e e e

Table de v´rit´ des op´rateurs ou exclusif, ´quivalence et
e e e e
implication :

Op´rateurs compos´s
e e
a b a XOR b a ⇐⇒ b a =⇒ b
0 0 0 1 1
0 1 1 0 1
1 0 1 0 0
1 1 0 1 1


La table ASCII
Exemple de script
Exemple de module D´finition
e
Les fonctions logiques Conversion
Les bases
Bibliographie

Les bases arithm´tiques
e
D´finition
e
En arithm´tique, une base d´signe la valeur dont les puissances
e e
successives interviennent dans l’ćriture des nombres, ces
e
puissances d´finissant l’ordre de grandeur de chacune des positions
e
occupés par les chiffres composant tout nombre
e


La table ASCII
Exemple de script
e
Les bases
Bibliographie

e
D´ﬁnition
e
e e
e
e
e

Certaines bases sont couramment employ´es :
e
la base 2 (syst`me binaire), en ´lectronique num´rique et
e e e
informatique ;


La table ASCII
Exemple de script
e
Les bases
Bibliographie

e
D´ﬁnition
e
e e
e
e
e

e
e e e
informatique ;
la base 8 (syst`me octal), en informatique ;
e


La table ASCII
Exemple de script
e
Les bases
Bibliographie

e
D´ﬁnition
e
e e
e
e
e

e
e e e
informatique ;
e
la base 16 (syst`me hexad´cimal), fr´quente en informatique ;
e e e


La table ASCII
Exemple de script
e
Les bases
Bibliographie

e
D´ﬁnition
e
e e
e
e
e

e
e e e
informatique ;
e
la base 16 (syst`me hexad´cimal), fr´quente en informatique ;
e e e
la base 60 (syst`me sexag´simal), dans la mesure du temps et
e e
des angles.

La table ASCII
Exemple de script
e
Les bases
Bibliographie


M´thode
e
Un nombre dans une base n donn´e s’´crit sous la forme d’addition
e e
des puissances successives de cette base.


La table ASCII
Exemple de script
e
Les bases
Bibliographie


M´thode
e
Un nombre dans une base n donn´e s’´crit sous la forme d’addition
e e
des puissances successives de cette base.

Par exemple :

5716 = (5 × 161 ) + (7 × 160 ) = 8710
578 = (5 × 81 ) + (7 × 80 ) = 4710


La table ASCII
Exemple de script
Exemple de module
Pour aller plus loin. . .
Les bases
Bibliographie

G´rard Swinnen
e
Apprendre ` programmer avec Python
a
O’Reilly, 2005.


La table ASCII
Exemple de script
Exemple de module
Les bases
Bibliographie

G´rard Swinnen
e
a
O’Reilly, 2005.
Mark Lutz
Python pr´cis et concis
e
O’Reilly, 2005.


La table ASCII
Exemple de script
Exemple de module
Les bases
Bibliographie

G´rard Swinnen
e
a
O’Reilly, 2005.
Mark Lutz
e
O’Reilly, 2005.
Alex Martelli
Python en concentr´
e
O’Reilly, 2004.


La table ASCII
Exemple de script
Exemple de module
Les bases
Bibliographie

G´rard Swinnen
e
a
O’Reilly, 2005.
Mark Lutz
e
O’Reilly, 2005.
Alex Martelli
Python en concentr´
e
O’Reilly, 2004.
Wesley J. Chun
Au cœur de Python. Version 2.5
CampusPress, 2007.


Cours python

Contenu connexe

Tendances (20)

En vedette (20)

Plus de salmazen (13)

Cours python