informatique - S1
algorithmique élémentaire en Python 3.0 : aide-mémoire
département Mesures Physiques - IUT1 - Grenoble1 Installation et démarrage
Logiciel : nous utiliserons durant ces séances de programmation l’éditeur de code Pyzo, interfacé avec Miniconda qui est un interpréteur du langage Python dans sa version 3.
Ces deux logiciels sont des logiciels libres. Vous pouvez les installer sur tout ordinateur tournant sous Linux, Windows, ou OS X.
Les logiciels et un tutoriel d’installation en 3 étapes sont disponibles ici : http://www.pyzo.org/start.html
Premier test : tapez dans la fenêtre de gauche le code p r i n t ( " Bo n j o u r à t o u s ! " )
et exécutez-le avec Ctrl+E ... le message de bienvenue s’affiche dans la fenêtre supérieure droite.
Sauvegarde de vos programmes : créez puis utilisez un répertoire Programmationet enregistrez-y les programmes avec Ctrl+S, en leur donnant des noms explicites (par exemple de la forme TP3exo2.py).
Vous pouvez retrouver les corrections rédigées en séance par les ensei- gnants dans :
EchangeEnsEtu/Informatique/Programmation/Groupes/A (ouB,C,D,Eselon votre groupe).
Ressources : pour compléter (et approfondir largement) cet aide-mémoire, vous pouvez consulter en ligne ou télécharger au format pdf l’ouvrage
« Apprendre Python 3.0 » de Gérard Swinnen sur
h t t p s : / / p y t h o n . d e v e l o p p e z . com / c o u r s / a p p r e n d r e−p y t h o n 3 /
2 Variables et opérations élémentaires
2.1 Nombres
a =3 # v a r i a b l e e n t i è r e b = 6 . 0 # v a r i a b l e r é e l l e
c =1 . 2 5 e−3 # r é e l s a i s i e en n o t a t i o n s c i e n t i f i q u e x=y = 5 . 2 # deux v a r i a b l e s , une v a l e u r
u , v = 3 , 4 . 1 2 # deux v a r i a b l e s , deux v a l e u r s
s = a+b # somme
m = a−b # d i f f é r e n c e
p = a∗b # p r o d u i t
c a r r e = a∗∗2 # c a r r é d = a / b # d i v i s i o n
q = a / / b # d i v i s i o n e n t i è r e r = a%b # r e s t e de l a d i v i s i o n
u , v = v , u # é c h a n g e d e s v a l e u r s Les règles de priorité usuelles s’appliquent dans les calculs : p r i n t ( a / ( b+v∗∗2)−d )
calcule d’abord le carré de v, puis la somme avec b, puis le quotient de a par ce résultat, puis soustraitd, et affiche le résultat.
2.2 Chaînes de caractères
Définir une chaîne de caractères :
c h a i n e = " i c i du t e x t e " # av ec g u i l l e m e t s
c h a i n e 2 = ’ i c i a u s s i ’ # ou b i e n av ec a p o s t r o p h e s c h a i n e 3 = ’ en \ ndeux l i g n e s ’ # av ec un s a u t de l i g n e p r i n t ( c h a i n e 3 ) # a f f i c h a g e
c h a i n e 4 = " p o u r é c r i r e une l o n g u e c h a î n e s u r deux \ l i g n e s u t i l i s e r l e c a r a c t è r e a n t i−s l a s h "
c h a i n e 5 = " m e t t r e une a p o s t r o p h e ’ d an s une c h a î n e "
c h a i n e 6 = ’ m e t t r e d e s g u i l l e m e t s " d an s une c h a î n e ’
Accès à une partie de chaîne, caractère par caractère.
Les caractères sont numérotés à partir de 0 :
p r i n t ( c h a i n e [ 2 ] ) # a f f i c h e l e 3ème c a r a c t è r e p r i n t ( c h a i n e [ 1 : 6 ] ) # a f f i c h e du 2ème au 5ème p r i n t ( c h a i n e [ 3 : ] ) # a f f i c h e à p a r t i r du 4ème p r i n t ( c h a i n e [ : 4 ] ) # a f f i c h e l e s 4 p r e m i e r s
Convertir des données d’un type à l’autre : a = ’124 ’ # c h a î n e de c a r a c t è r e
p r i n t ( t y p e ( a ) ) # a f f i c h e i n t ( e n t i e r ) ,
# f l o a t ( r é e l ) , s t r i n g ( c h a î n e ) , . . . p r i n t ( a +1) # e r r e u r : a e t 1 s o n t de t y p e s d i f f é r e n t s a= i n t ( a ) # c o n v e r s i o n en e n t i e r
p r i n t ( a +1) # l ’ a d d i t i o n d e v i e n t p o s s i b l e
3 Affichage
La fonctionprintpermet des affichages simples : p r i n t ( a ) # a f f i c h e l a v a l e u r de a p r i n t ( a , b ) # a f f i c h e deux v a l e u r s
p r i n t ( " v a l e u r s " , a , " e t " , b ) # nombres e t c h a î n e s ou des affichages formatés, mais la syntaxe se complique !
Pour cela on indique une chaîne (entre guillemets ou apostrophes), dans la- quelle on place des{}pour réserver un emplacement pour un nombre (ou autre) et on y indique son format d’affichage souhaité, et on indique à la fin dans les paramètres de l’instruction.formatavec quoi remplir ces emplacements.
a =12345.67891011 b =9 . 9 8 7 e−5
# a f f i c h a g e av ec 2 d é c i m a l e s : p r i n t ( " a = { : . 2 f } " . f o r m a t ( a ) )
# a f f i c h a g e av ec 3 d é c i m a l e s , 15 c a r a c t è r e s en t o u t : p r i n t ( " a = { : 1 5 . 3 f } " . f o r m a t ( a ) )
# a f f i c h a g e en n o t a t i o n s c i e n t i f i q u e : p r i n t ( " a = { : e } " . f o r m a t ( a ) )
# n o t a t i o n s c i e n t i f i q u e av ec 2 d é c i m a l e s : p r i n t ( " b = { : . 2 e } " . f o r m a t ( b ) )
# m i x er l e s n o t a t i o n s s c i e n t i f i q u e s e t d é c i m a l e s : p r i n t ( " a = { : . 2 e } e t b = { : 3 f } " . f o r m a t ( a , b ) )
# . . . e t a u s s i p l a c e r s y m b o l es e t t e x t e s : p r i n t ( ’ 1 5 e s p a c e s i c i { } , \
e t 20 s i g n e s "−" l à : {} ’ . f o r m a t ( " "∗1 5 , "−"∗20))
4 Saisie au clavier :
input("message")affiche la chaîne de caractères passée en paramètre, et renvoie la chaîne tapée au clavier par l’utilisateur.
Pour la saisie d’un nombre, on convertit ensuite explicitement la chaîne en entier ou en réel :
a= i n p u t ( " donnez une v a l e u r " )
a= i n t ( a ) # c o n v e r s i o n en e n t i e r a= f l o a t ( a ) # c o n v e r s i o n en r é e l
On peut résumer ces deux étapes en une seule ligne :
a= i n t ( i n p u t ( " donnez une v a l e u r " ) ) # s a i s i t un e n t i e r a= f l o a t ( i n p u t ( " donnez une v a l e u r " ) ) # s a i s i t un r é e l
5 Tests
On dispose d’opérateurs de comparaison : a==b # t e s t e l ’ é g a l i t é
a != b # ou l a non−é g a l i t é a >b
a <b
a >=b # s u p é r i e u r ou é g a l a <=b
que l’on peut utiliser avec l’instruction conditionnelle if accompagnée éventuellement deelifet/ouelse:
i f a >0 :
p r i n t ( " a e s t s t r i c t e m e n t p o s i t i f " ) e l i f a ==0 :
p r i n t ( " a e s t n u l " ) e l s e :
p r i n t ( " a e s t s t r i c t e m e n t n é g a t i f " )
Exemple d’un test de parité : pour savoir si un nombre est pair, on regarde si le reste de la division par 2 est nul.
a= i n t ( i n p u t ( " donnez un nombre e n t i e r " ) )
i f a%2 == 0 : # l e r e s t e de l a d i v i s i o n p a r 2 e s t n u l ? p r i n t ( " i l e s t p a i r " )
e l s e :
p r i n t ( " i l e s t i m p a i r " )
6 Fonctions mathématiques prédéfinies
On place en début de programme from math i m p o r t ∗
pour importer les fonctions mathématiques (le * indique de les importer tout, on peut utiliser une liste explicite des fonctions que l’on utilisera).
Quelques exemples :
p r i n t ( p i , e ) # p i e t e s o n t p r é d é f i n i s p r i n t ( s q r t ( 3 ) ) # r a c i n e c a r r é e
p r i n t ( s i n ( p i / 6 ) ) # s i n u s ( d ’ un a n g l e en r a d i a n ) p r i n t ( l o g ( e / 2 ) ) # l o g a r i t h m e n é p é r i e n l n
p r i n t ( f a b s ( 2 . 1 ) ) # v a l e u r a b s o l u e p r i n t ( a t a n ( 1 ) ) # a r c t a n g e n t e
7 Boucles
7.1 while
Une bouclewhilerépète une série d’instructions tant qu’une condition est vérifiée.
# r é p è t e t a n t que l a v a l e u r s a i s i e e s t n é g a t i v e : a=−1
w h i l e a <0 :
a= f l o a t ( i n p u t ( " d o n n e r un nombre p o s i t i f " ) ) p r i n t ( " vous av ez s a i s i l e nombre " , a )
p r i n t ( " vous av ez b i e n s a i s i une v a l e u r p o s i t i v e , " , a ) (noter l’importance de la présence ou l’absence de tabulation devant les ins- tructionsprint)
On peut utiliser while et une variable pour faire varier un nombre entre deux entiers :
# co m p t er j u s q u ’ à 10 : a =0
w h i l e a <1 0 : a=a +1
p r i n t ( a )
7.2 for
Dans ce dernier cas, la boucleforcouplée à la fonctionrangefournissent une solution moins universelle mais plus élégante que la bouclewhile:
f o r nombre i n r a n g e ( 1 0 ) : # 10 nombres e n t i e r s , de 0 e t 9 p r i n t nombre
Variantes :
f o r nombre i n r a n g e ( 5 , 1 2 ) : # de 5 à 11
p r i n t nombre
f o r nombre i n r a n g e ( 1 2 , 1 ,−1 ) : # de 12 à 2 p r i n t nombre
f o r nombre i n r a n g e ( 2 , 2 4 , 3 ) : # p a r p a s de 3 p r i n t nombre
Afficher 200 valeurs régulièrement réparties entre pi/6 et pi/4 :
i m p o r t math # i m p o r t e l e module
# c o n t e n a n t l e s f o n c t i o n s m a t h é m a t i q u e s f o r i i n r a n g e ( 2 0 0 ) :
p r i n t ( p i / 6 + ( p i / 4 − p i / 6 )∗i / 1 9 9 )
8 Fonctions
8.1 Fonction sans paramètre ni valeur renvoyée
d e f m a p r e m i e r e f o n c t i o n ( ) : # p o u r l a d é f i n i r p r i n t ( " a f f i c h e un t e x t e " )
m a p r e m i e r e f o n c t i o n ( ) # p o u r l ’ u t i l i s e r 8.2 Avec paramètre mais sans valeur renvoyée
d e f a f f i c h e c a r r e ( nombre ) :
p r i n t ( " l e c a r r é de " , nombre , " e s t " , nombre∗ ∗2 ) a f f i c h e c a r r e ( 5 )
8.3 Avec paramètre et renvoi de valeur
Il est souvent préférable de dissocier calcul et affichage ainsi :
d e f c a r r e ( nombre ) : # c a l c u l e t r e t o u r de v a l e u r , r e t u r n nombre∗∗2 # mais s a n s a f f i c h a g e
p r i n t ( " l e c a r r é de 5 e s t " , c a r r e ( 5 ) )
# a f f i c h e l e r é s u l t a t r e n v o y é
8.4 Avec plusieurs paramètres
# f o n c t i o n à q u i on f o u r n i t deux r é e l s x e t y ,
# e t q u i r e n v o i e l e module du complexe x + i y d e f module ( x , y ) :
r e t u r n s q r t ( x∗∗2 + y∗ ∗2 ) 8.5 Avec des variables locales
On peut utiliser dans la fonction une variable, qui n’existe pas en dehors de la fonction, et qui sert à faire des calcul ou stocker des résultats intermédiaires :
d e f s i n c ( x ) : # f o n c t i o n s i n u s c a r d i n a l i f x != 0 :
y= s i n ( x ) / x e l s e :
y=1 r e t u r n y y=3
p r i n t ( s i n c ( 1 ) , y ) # e x p l i q u e r l ’ a f f i c h a g e o b t e n u !
9 Listes
Définir une liste :
u n e l i s t e = [ 1 , ’ a ’ , 3 . 2 , 5 ] # on p e u t m é l a n g e r l e s t y p e s u n e l i s t e = [ ] # l i s t e v i d e
Pour ajouter une valeur en fin de liste : u n e l i s t e . append ( 1 2 )
Afficher et manipuler une liste :
p r i n t ( u n e l i s t e ) # a f f i c h e l a l i s t e
p r i n t ( u n e l i s t e [ 1 : 3 ] ) # a f f i c h e du 2ème au 4ème é l é m e n u n e l i s t e . s o r t ( ) # t r i e une l i s t e de nombres
u n e l i s t e . r e v e r s e ( ) # r e n v e r s e l ’ o r d r e d ’ une l i s t e Détermine le rang d’une valeur présente dans la liste (erreur si la valeur n’est pas présente, le premier rang si la valeur apparaît plusieurs fois) :
u n e l i s t e . i n d e x ( 1 7 )
Enlève un élément d’une liste (ne fait rien s’il n’est pas présent) : u n e l i s t e . remove ( 3 2 )
Déterminer le nombre d’éléments d’une liste : l e n ( u n e l i s t e )
10 Tracé de courbes
Pour créer une listeXcontenantnombreabscisses régulièrement réparties entre deux nombresmin etmax: on ajoute les valeurs une par une à une liste initialement vide :
X = [ ] # l i s t e v i d e f o r i i n r a n g e ( nombre ) :
X . append ( min + i ∗( max−min ) / ( nombre−1) ) p r i n t (X) # a f f i c h a g e ( peu l i s i b l e )
Pour créer une liste d’abscisse et leurs images par la fonctioncos: X = [ ]
Y = [ ]
f o r i i n r a n g e ( nombre ) :
x = min + i∗( max−min ) / ( nombre−1) X . append ( x )
Y . append ( c o s ( x ) )
Si la listeXexiste déjà, et que l’on veut les ordonnées correspondantes dans une listeY:
Y = [ ]
f o r x i n X:
Y . append ( c o s ( x ) ) Pour tracer la courbe associée :
i m p o r t m a t p l o t l i b . p y p l o t a s p p l o t p p l o t . g r i d ( True )
p p l o t . p l o t (X, Y) p p l o t . show ( )
11 Fichiers
11.1 lecture directe
Pour relire un fichier, on peut l’ouvrir, récupérer l’ensemble des lignes du fichier dans une listelignes, et le refermer :
f i c h i e r = open ( ’ e s s a i . t x t ’ , ’ r ’ ) l i g n e s = f i c h i e r . r e a d l i n e s ( ) f i c h i e r . c l o s e ( )
Si le fichieressai.txtcontient un nombre par ligne, on peut créer la liste des valeurs présentes dans le fichier ainsi :
f i c h i e r = open ( ’ e s s a i . t x t ’ , ’ r ’ ) X= [ ]
f o r x i n f i c h i e r . r e a d l i n e s ( ) : X . append ( f l o a t ( x ) ) f i c h i e r . c l o s e ( )
Si les données sont rangées à raison de deux nombres par ligne séparés par une espace, on peut utiliser en plussplit()pour remplacer chaque ligne par une liste composée des deux nombres de la ligne :
f i c h i e r = open ( ’ c o u r b e . t x t ’ , ’ r ’ ) X= [ ]
Y= [ ]
f o r l i g n e i n f i c h i e r . r e a d l i n e s ( ) : l i g n e = l i n e . s p l i t ( )
X . append ( f l o a t ( l i g n e [ 0 ] ) ) Y . append ( f l o a t ( l i g n e [ 1 ] ) ) f i c h i e r . c l o s e ( )
11.2 fonctionslecture
Écrire une fonctionlecturepermet de ne pas refaire à chaque fois ce tra- vail dans le programme principal :
d e f l e c t u r e ( c h a i n e ) :
f i c h i e r = open ( c h a i n e , ’ r ’ ) X= [ ]
f o r l i g n e i n f i c h i e r . r e a d l i n e s ( ) : X . append ( f l o a t ( l i g n e ) )
f i c h i e r . c l o s e ( ) r e t u r n (X)
X = l e c t u r e ( ’ c o u r b e . t x t ’ ) et en version "deux valeurs par ligne" : d e f l e c t u r e 2 ( c h a i n e ) :
f i c h i e r = open ( c h a i n e , ’ r ’ ) X= [ ]
Y= [ ]
f o r l i g n e i n f i c h i e r . r e a d l i n e s ( ) : l i g n e = l i n e . s p l i t ( )
X . append ( f l o a t ( l i g n e [ 0 ] ) )
Y . append ( f l o a t ( l i g n e [ 1 ] ) ) f i c h i e r . c l o s e ( )
r e t u r n (X, Y)
X, Y = l e c t u r e 2 ( ’ c o u r b e . t x t ’ )
11.3 fonctionssélecteur de fichier from t k i n t e r i m p o r t ∗
from t k i n t e r . f i l e d i a l o g i m p o r t a s k o p e n f i l e n a m e n o m d u f i c h i e r = a s k o p e n f i l e n a m e ( )
renvoie dans la variable nomdufichier le chemin d’accès désigné par l’utilisateur.
On peut spécifier un argument optionnel initialdirpour choisir le ré- pertoire par défaut dans lequel s’ouvre le sélecteur de fichiers et limiter les fi- chiers qui apparaissent aux fichiers texte :
n o m d u f i c h i e r = a s k o p e n f i l e n a m e
( i n i t i a l d i r = ’X : / I n f o r m a t i q u e / Pro g ram m at i o n / Donnees / ’ , f i l e t y p e s = [ ( " t e x t e " , ’∗. t x t ;∗. t e x t ’ ) ] )
Guillaume Laget - version du 26-10-2017 11:29 (document mis à jour sur http ://maths.tetras.org/) - réutilisation et reproduction non commerciale de tout ou partie de ce document vivement encouragées
