informatique - S1 algorithmique élémentaire en Python 3.

0 : aide-mémoire département Mesures Physiques - IUT1 - Grenoble

1 Installation et démarrage 2 Variables et opérations élémentaires

Logiciel : nous utiliserons durant ces séances de programmation l’éditeur de 2.1 Nombres
code Pyzo, interfacé avec Miniconda qui est un interpréteur du langage
Python dans sa version 3. a =3 # variable entière
Ces deux logiciels sont des logiciels libres. Vous pouvez les installer sur b =6.0 # variable réelle
tout ordinateur tournant sous Linux, Windows, ou OS X. 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
Les logiciels et un tutoriel d’installation en 3 étapes sont disponibles ici : u , v = 3 , 4.12 # deux v a r i a b l e s , deux v a l e u r s
http://www.pyzo.org/start.html
s = a+b # somme
Premier test : tapez dans la fenêtre de gauche le code
m = a−b # différence
p r i n t ( " Bonjour à t o u s ! " ) p = a∗b # produit
c a r r e = a ∗∗2 # carré
et exécutez-le avec Ctrl+E ... le message de bienvenue s’affiche dans la d = a/b # division
fenêtre supérieure droite. q = a //b # division entière
r = a%b # r e s t e de l a d i v i s i o n
Sauvegarde de vos programmes : créez puis utilisez un répertoire
Programmation et enregistrez-y les programmes avec Ctrl+S, en leur
u,v = v,u # échange des v a l e u r s
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- Les règles de priorité usuelles s’appliquent dans les calculs :
gnants dans : p r i n t ( a / ( b+v ∗∗2) −d )
EchangeEnsEtu/Informatique/Programmation/Groupes/A calcule d’abord le carré de v, puis la somme avec b, puis le quotient de a
(ou B, C, D, E selon votre groupe). par ce résultat, puis soustrait d, et affiche le résultat.
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
2.2 Chaînes de caractères
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 /
Définir une chaîne de caractères :
c h a i n e = " i c i du t e x t e " # a v e c g u i l l e m e t s
chaine2 = ’ i c i aussi ’ # ou b i e n a v e c 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 ’ # a v e c un s a u t de l i g n e
p ri n t ( chaine3 ) # affichage

1
 a =1 2 3 4 5 . 6 7 8 9 1 0 1 1
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 \ b = 9 . 9 8 7 e−5
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 "
# a f f i c h a g e avec 2 d éci m al es :
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 a n s une c h a î n e " p r i n t (" a = { : . 2 f } " . format ( a ) )
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 a n s une c h a î n e ’
# a f f i c h a g e a v e c 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 = {:15.3 f } " . format ( a ) )
Accès à une partie de chaîne, caractère par caractère.
Les caractères sont numérotés à partir de 0 : # 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 :
print ( chaine [2] ) # affiche l e 3ème c a r a c t è r e p r i n t (" a = {: e }". format ( a ) )
print ( chaine [1:6] ) # affiche du 2ème au 5ème
print ( chaine [ 3 : ] ) # affiche à p a r t i r du 4ème # n o t a t i o n s c i e n t i f i q u e avec 2 d éci m al es :
print ( chaine [ : 4 ] ) # affiche les 4 premiers p r i n t (" b = { : . 2 e} " . format ( b ) )

# mixer 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 éci m al es :
Convertir des données d’un type à l’autre : p r i n t (" a = { : . 2 e} et b = {:3 f } " . format ( a , b ) )
a = ’1 2 4 ’ # c h a î n e de c a r a c t è r e
# . . . e t a u s s i p l a c e r symboles e t t e x t e s :
pr int ( type ( a )) # affiche in t ( e n ti e r ) ,
p r i n t ( ’15 espaces i c i {} , \
# f l o a t ( réel ) , s t r i n g ( chaîne ) , . . .
e t 20 s i g n e s "−" l à : {} ’ . f o r m a t ( " " ∗ 1 5 , " −" ∗ 2 0 ))
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

4 Saisie au clavier :
3 Affichage
input("message") affiche la chaîne de caractères passée en paramètre,
La fonction print permet des affichages simples : et renvoie la chaîne tapée au clavier par l’utilisateur.
print (a) # a f f i c h e l a v a l e u r de a Pour la saisie d’un nombre, on convertit ensuite explicitement la chaîne en
print (a ,b) # a f f i c h e deux v a l e u r s entier ou en réel :
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 a= i n p u t ( " d o n n ez une v a l e u r " )
ou des affichages formatés, mais la syntaxe se complique ! 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
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) On peut résumer ces deux étapes en une seule ligne :
et on y indique son format d’affichage souhaité, et on indique à la fin dans les a= i n t ( i n p u t ( " d o n n ez une v a l e u r " ) ) # s a i s i t un e n t i e r
paramètres de l’instruction .format avec quoi remplir ces emplacements. a= f l o a t ( i n p u t ( " d o n n ez une v a l e u r " ) ) # s a i s i t un r é e l

2
5 Tests 6 Fonctions mathématiques prédéfinies

On dispose d’opérateurs de comparaison : On place en début de programme

a==b # teste l ’ égalité from math i m p o r t ∗
a != b # ou l a non− é g a l i t é
a >b
pour importer les fonctions mathématiques (le * indique de les importer tout,
a <b
on peut utiliser une liste explicite des fonctions que l’on utilisera).
a >=b # s u p é r i e u r ou é g a l
a <=b
Quelques exemples :

que l’on peut utiliser avec l’instruction conditionnelle if accompagnée print ( pi , e ) # pi et e sont pr édéfinis
éventuellement de elif et/ou else : print ( sqrt (3)) # racine carrée
print ( sin ( pi / 6 ) ) # s i n u s ( d ’ un a n g l e en r a d i a n )
i f a >0 : print ( log ( e / 2 ) ) # logarithme népérien ln
print (" a est strictement p o s i t i f ") print ( fabs (2. 1)) # valeur absolue
e l i f a ==0 : print ( atan (1)) # arctangente
p r i n t (" a es t nul ")
else :
print (" a est strictement négatif ")

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 ( " d o n n ez 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 ?
print (" i l est pair ")
else :
p r i n t (" i l est impair ")

3
7 Boucles p r i n t nombre

7.1 while f o r nombre i n r a n g e ( 1 2 , 1 , − 1 ) : # de 12 à 2

p r i n t nombre
Une boucle while répète une série d’instructions tant qu’une condition est
vérifiée.
f o r nombre i n r a n g e ( 2 , 2 4 , 3 ) : # p a r p a s de 3
# 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 : p r i n t nombre
a=−1
while 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 ( " v o u s a v e z s a i s i l e nombre " , a )
p r i n t ( " v o u s a v e z 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-
tructions print)

On peut utiliser while et une variable pour faire varier un nombre entre
deux entiers :
# c o m p t e r j u s q u ’ à 10 :
a =0
while a <10: Afficher 200 valeurs régulièrement réparties entre pi/6 et pi/4 :
a=a +1
print (a)

i m p o r t math # i m p o r t e l e module
7.2 for # cont enant l e s f o n c t i o n s mathématiques
Dans ce dernier cas, la boucle for couplée à la fonction range fournissent for i in range (200):
une solution moins universelle mais plus élégante que la boucle while : p r i n t ( pi /6 + ( pi /4 − pi / 6 )∗ i /199 )
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

4
8 Fonctions def sinc ( x ) : # fonction sinus cardinal
i f x != 0 :
8.1 Fonction sans paramètre ni valeur renvoyée y= s i n ( x ) / x
else :
def mapremierefonction ( ) : # pour l a d é f i n i r y =1
p r i n t ( " a f f i c h e un t e x t e " ) return y

mapremierefonction () # pour l ’ u t i l i s e r y=3

8.2 Avec paramètre mais sans valeur renvoyée 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 obtenu !

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 )
9 Listes
affichecarre (5)
Définir une liste :
8.3 Avec paramètre et renvoi de valeur
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
Il est souvent préférable de dissocier calcul et affichage ainsi : uneliste = [] # l i s t e vide
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 uPour
r , ajouter une valeur en fin de liste :
r e t u r n nombre ∗∗2 # m ai s s a n s a f f i c h a g e
u n e l i s t e . ap p en d ( 1 2 )
p r i n t ( " l e c a r r é de 5 e s t " , c a r r e ( 5 ) ) Afficher et manipuler une liste :
# a f f i c h e l e r é s u l t a t renvoyé
print ( uneliste ) # affiche la l i s t e
print ( uneliste [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
8.4 Avec plusieurs paramètres uneliste . reverse () # 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
# 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 ,
pas présente, le premier rang si la valeur apparaît plusieurs fois) :
# e t q u i r e n v o i e l e module du co m p l ex e x + i y
u n e l i s t e . index (17)
d e f module ( x , y ) :
r e t u r n s q r t ( x ∗∗2 + y ∗ ∗ 2 ) 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 )
8.5 Avec des variables locales Déterminer le nombre d’éléments d’une liste :
On peut utiliser dans la fonction une variable, qui n’existe pas en dehors de len ( u n e l i s t e )
la fonction, et qui sert à faire des calcul ou stocker des résultats intermédiaires :

5
10 Tracé de courbes 11 Fichiers
Pour créer une liste X contenant nombre abscisses régulièrement réparties 11.1 lecture directe
entre deux nombres min et max : on ajoute les valeurs une par une à une liste
initialement vide : Pour relire un fichier, on peut l’ouvrir, récupérer l’ensemble des lignes du
X = [] # l i s t e vide fichier dans une liste lignes, et le refermer :
f o r i i n r a n g e ( nombre ) :
X . ap p en d ( min + i ∗ ( max−min ) / ( nombre −1) ) f i c h i e r = open ( ’ e s s a i . t x t ’ , ’ r ’ )
p r i n t (X) # a f f i c h a g e ( peu l i s i b l e ) lignes = fichier . readlines ()
fichier . close ()
Pour créer une liste d’abscisse et leurs images par la fonction cos :
X = []
Y = [] Si le fichier essai.txt contient un nombre par ligne, on peut créer la liste
f o r i i n r a n g e ( nombre ) : des valeurs présentes dans le fichier ainsi :
x = min + i ∗ ( max−min ) / ( nombre −1)
X . ap p en d ( x ) f i c h i e r = open ( ’ e s s a i . t x t ’ , ’ r ’ )
Y . ap p en d ( c o s ( x ) ) X= [ ]
for x in f i c h i e r . readlines ( ) :
Si la liste X existe déjà, et que l’on veut les ordonnées correspondantes dans
X . ap p en d ( f l o a t ( x ) )
une liste Y :
fichier . close ()
Y = []
f o r x i n X:
Y . ap p en d ( c o s ( x ) ) Si les données sont rangées à raison de deux nombres par ligne séparés par
Pour tracer la courbe associée : une espace, on peut utiliser en plus split() pour remplacer chaque ligne par
une liste composée des deux nombres de la ligne :
import m a t p l o t l i b . pypl ot as p p l o t
f i c h i e r = open ( ’ c o u r b e . t x t ’ , ’ r ’ )
p p l o t . g r i d ( T ru e )
p p l o t . p l o t (X, Y) X= [ ]
p p l o t . show ( ) Y= [ ]

for ligne in f i c h i e r . readlines ( ) :

ligne = line . s p l i t ()
X . ap p en d ( f l o a t ( l i g n e [ 0 ] ) )
Y . ap p en d ( f l o a t ( l i g n e [ 1 ] ) )

fichier . close ()

6
11.2 fonctions lecture Y . ap p en d ( f l o a t ( l i g n e [ 1 ] ) )
fichier . close ()
r e t u r n (X , Y)
Écrire une fonction lecture permet de ne pas refaire à chaque fois ce tra-
vail dans le programme principal :
X, Y = l e c t u r e 2 ( ’ c o u r b e . t x t ’ )
def l e c t u r e ( chaine ) :
f i c h i e r = open ( c h a i n e , ’ r ’ )
X= [ ] 11.3 fonctions sélecteur de fichier
for ligne in f i c h i e r . re adlines ( ) :
X . ap p en d ( f l o a t ( l i g n e ) ) from t k i n t e r i m p o r t ∗
fichier . close () 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
r e t u r n (X)
nomdufichier = askopenfilename ()
renvoie dans la variable nomdufichier le chemin d’accès désigné par
X = l e c t u r e ( ’ courbe . txt ’ )
l’utilisateur.
et en version "deux valeurs par ligne" :

def l e c t u r e 2 ( chaine ) : On peut spécifier un argument optionnel initialdir pour choisir le ré-
f i c h i e r = open ( c h a i n e , ’ r ’ ) pertoire par défaut dans lequel s’ouvre le sélecteur de fichiers et limiter les fi-
X= [ ] chiers qui apparaissent aux fichiers texte :
Y= [ ] nomdufichier = askopenfilename
for ligne in f i c h i e r . re adlines ( ) : ( i n i t i a l d i r = ’X : / I n f o r m a t i q u e / P r o g r a m m a t i o n / Donnees / ’ ,
ligne = line . s p l i t () f i l et y pe s =[(" texte " , ’∗. t xt ; ∗. text ’ ) ] )
X . ap p en d ( f l o a t ( l i g n e [ 0 ] ) )
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