1 Premiers pas en python. . .
1.1 Environnement de développement
1.1.1 Téléchargement d’une distribution
Le langage python est un langage simple, puissant et gratuit. Il en existe de nombreuses distributions, plus ou moins conviviales et plus ou moins « volumineuses ». Moi, j’aime bien l’environnement Spyder. Vous pouvez en trouver une version pour tout type d’ordinateure à l’adresse : http ://http ://continuum.io/downloads (il suffit de taper Anadonda python sous Google). Vous choisissez votre système d’exploitation et, surtout, vous choisissez une version 3.x
Pour celles et ceux qui ont des machines peu performantes, vous pouvez utiliser un environnement plus « léger » comme la distribution pyzo (www.pyzo.org/downloads.html) ou Edupython (http ://edupython.tuxfamily.org/).
1.1.2 A l’écran. . .
Si vous avez téléchargé Spyder, vous vous retrouvez avec l’écran suivant ; les autres distributions se présentent de façon similaire.
Que doit-on repérer en priorité ?
— Une zoneEditeurqui sert. . . à éditer le programme dont vous souhaitez l’éxécution ; ce sera votre terrain de jeu !
— Une zone Console dans laquelle sera affichés les résultats de vos calculs, les graphes, très souvent. . . les messages d’erreur ! C’est également là qu’il faudra introduire éventuellement certaines données demandées par le programme. C’est donc une zone d’interface entre le programme et l’utilisateur1. On peut, si on veut se servir de la console comme d’une calculatrice ou effectuer quelques tests simples de programmation.
1. Parfois, aucune console ne se trouve associée au programme que l’on souhaite exécuter. Le logiciel va vous demander d’ouvrir une console ; un menuConsoleest prévu à cet effet, choisir une « IPython Console »
— Le bouton Run (équivalent clavier F5) vous permet de lancer l’exécution du programme (parfois, des problèmes de connexion à la console interviennent et un message d’erreur du type « Open an Ipython console » apparait, il faut alors ouvrir une telle console à partir du menu Console).
— Parfois votre programme va se bloquer (suite à une erreur de programmation !) ; on peut arrêter son exécution à l’aide du bouton « carré rouge » dans la console.
— Une fenêtre en haut à droite avec différents onglets qui permet d’accéder, entre autre : à l’arborescence des fichiers sur votre disque dur, aux valeurs des différentes variables que vous allez utiliser, à l’aide en ligne sur certaines fonctions. . .
1.2 Une boite à outils pour commencer
1.2.1 Commentaires, entrée/sortie et affectation : #, input, print, =
Recopier le programme suivant dans la fenêtre principale :
1 p r i n t(" Bonjour l e monde ! ")
2 # On demande m a i n t e n a n t l e nom de l ’ u t i l i s a t e u r 3 nom = i n p u t(" E c r i r e v o t r e nom : ")
4 p r i n t(" Bonjour ", nom)
Exécuter le programme (flèche verte dans la barre d’icônes).
— print()permet d’afficher du texte dans la console ;
— input()permet de demander à l’utilisateur d’entrer une chaîne de caractère.
Dans l’exemple,nomest une variable. Elle stocke la chaine de caractère entrée par l’utilisateur. L’opérateur=est l’opérateur d’affectation. Il permet d’écrire des données dans une variable.
Le texte derrière le croisillon#est un commentaire. Il n’est pas pris en compte par python, mais permet de rendre plus clair un programme par le lecteur. On peut également librement sauter des lignes dans un programme.
Q1
Modifier le programme pour obtenir et afficher le nom et le prénom de l’utilisateur.1.2.2 Quelques calculs. . .
1.2.2.1 Opérations arithmétiques de base
Elles sont représentées, sans surprise, par les symboles :+,-,*,/. On peut également utiliser des parenthèses.
Ajoutons** pour une puissance (a**b revient àab) ou encore% pour un modulo.
Attention aux ordres de priorité des opérateurs. Exécuter le programme suivant et, s’il ne fait pas ce que vous souhaitez, ajoutez des parenthèses !
1 a = 2 2 b = 3
3 c = a + b/a − b 4 p r i n t(" c = ", c )
Recopier et exécuter le programme suivant :
1 n = i n p u t(" Entrer un nombre : ") 2 n = n + 2
3 p r i n t( n )
Que se passe-t-il ?
Q2
1. Écrire un programme qui élève un nombre au cube.
2. Écrire un programme qui, partant du prix hors taxe d’un article, ajoute la TVA et affiche « Le prix TTC est de. . . »
3. Écrire un programme qui demande le prénom et l’année de naissance d’une personne, puis qui renvoie une phrase comprenant le prénom et l’âge de la personne.
1.2.2.2 Utilisation de bibliothèques
On souhaite maintenant calculer la racine carrée ou le sinus d’un nombre. Le langage python ne dispose pas, de base, de la fonction racine carrée. Pour pouvoir en bénéficier, il faut utiliser une bibliothèque de fonctions (que l’on appelle aussi module). Dans notre cas, nous allons importer la bibliothèquemath. Pour cela, il faut écrire, en tête du programme, une des lignes suivantes :
— « from math import * » ; on importe alors la totalité de la bibliothèque mathématique ;
— « from math import sqrt, sin, pi » ; on importe alors uniquement les deux fonctions souhaitées ;
— « import math as m » et l’on écrira alors2m.sqrt(3) oum.sin(pi/4) Voici quelques fonctions de la bibliothèque math :
sqrt() Racine carrée d’un nombre pow(x ,y) ou x**y Calcule x à la puissance y
sin() Sinus d’un angle (en radian) cos() Cosinus d’un angle (en radian) tan() Tangente d’un angle (toujours en radian)
pi Une valeur approchée précise du nombreπ
Q3
1. Écrire un programme qui calcule la puissance 8 d’un nombre.
2. Écrire un programme qui renvoie le cosinus et le sinus d’un angle que l’utilisateur donne en degré.
3. En physique, on montre que pour une faible amplitude d’oscillation, la période d’oscillationT d’un pendule simple de longueur l est donnée par la formule : T = 2π
rl
g avec g = 9,81m.s−2. Écrire un programme qui donne la période d’oscillation en fonction de la longueur l indiquée par l’utilisateur. L’abus de chiffres significatifs peut choquer. . . taper « round » dans la zone de saisie de « l’object inspector » et rectifier le programme en conséquence.
1.2.3 Testons. . . if, else
Il s’agit de permettre l’exécution d’une série d’instruction uniquement si une condition est vérifiée. La structure générale du programme est la suivante est la suivante :
1 i n i t i a l i s a t i o n s
2 if c o n d i t i o n à vé r i f i e r :
3 . . . s u i t e d’ i n s t r u c t i o n à e f f e c t u e r
4 s u i t e du programme
ou
1 i n i t i a l i s a t i o n s
2 if c o n d i t i o n à vé r i f i e r :
3 . . . s u i t e d’ i n s t r u c t i o n à e f f e c t u e r s i l a c o n d i t i o n e s t vé r i f i é e 4 e l s e :
5 . . . s u i t e d ’i n s t r u c t i o n à e f f e c t u e r s i l a c o n d i t i o n n’ e s t vé r i f i é e
6 s u i t e du programme
ou encore
2. Cette méthode peut sembler un peu lourde de prime abord. Elle permet toutefois d’éviter des conflits si une même fonction est définie dans plusieurs bibliothèques. Elle permet également de disposer d’une aide contextuelle lors de la frappe ; il suffit de taper m.
et ensuite un menu déroulant apparait avec toutes les fonctions disponibles
1 i n i t i a l i s a t i o n s 2 if c o n d i t i o n 1 :
3 . . . s u i t e d’ i n s t r u c t i o n à e f f e c t u e r s i l a c o n d i t i o n 1 e s t vé r i f i é e 4 e l i f c o n d i t i o n 2 :
5 . . . s u i t e d ’i n s t r u c t i o n à e f f e c t u e r s i l a c o n d i t i o n 2 n’ e s t vé r i f i é e 6 e l s e :
7 . . . à e f f e c t u e r s i ni l a c o n d i t i o n 1 ni l a c o n d i t i o n 2 n ’e s t vé r i f i é e 89 s u i t e du programme
La condition mise en jeu dans l’instructionif ouelif résulte la plupart du temps du résultat :
— du test d’égalité entre deux nombres : on utilise alors l’opérateur==
! 4
ATTENTION, piège à . . . ON NE TESTE PAS L’ÉGALITÉ ENTREaet b PAR ifa=b : MAIS PARif a == b :! 4
— du test d’une différence entre deux nombres à l’aide de l’opérateur!=
— d’une comparaison de deux nombres à l’aide des opérateurs :<,<=,>,>=
Lorsque l’on tape une condition, on constate que l’éditeur introduit, de lui même des « :« et des indentations. . . affaire à suivre ! Comme ce sont vos premiers pas, vous pouvez toujours essayer de les supprimer, vous verrez bien si vous tombez !
Q4
1. Écrire un programme qui demande un nombre et affiche sa valeur absolue.
2. Écrire un programme qui demande le résultat d’une opération (simple) sur des entiers (par exemple « Que vaut 2 + 3*4 ? ») et qui affiche « vrai » ou « faux » selon la valeur entrée.
3. Écrire un programme qui demande un nombrex, calcule x2
2 six <−2 oux >2 ; 4−x2
2 sinon, puis affiche le résultat.
1.2.4 La meilleure façon de marcher, c’est de mettre un pied devant l’autre. . . et de recommencer !
C’est ce que va nous permettre de faire la boucle : while : tant qu’une condition n’est pas vérifiée, on exécute plusieurs fois la même suite d’instruction3.
La structure générale du programme sera la suivante :
1 i n i t i a l i s a t i o n s
2 w h i l e c o n d i t i o n à vé r i f i e r :
3 . . .
4 s u i t e d’ i n s t r u c t i o n à e f f e c t u e r 5 m o d i f i c a t i o n de l a c o n d i t i o n
6 s u i t e du programme
La plupart du temps, la condition à vérifier est la comparaison d’un « compteur » qui va acquérir un certain nombre de valeurs comprises entre une valeur initiale et une valeur finale. . . pour peu que l’on n’oublie pas de l’incrémenter.
1 debut = 0 2 f i n = 1
3 increment = 0 . 1 4 compteur = debut
5 w h i l e compteur <= f i n :
6 p r i n t(" Le compteur vaut : ", compteur )
7 compteur = compteur + increment
8 p r i n t(" Termin é , l e compteur vaut : ", compteur )
Taper et exécuter le programme programme précédent. Si vous voulez voir à quoi sert le carré rouge dans la console, vous n’avez qu’à mettre la ligne 7 en commentaire ou de supprimer l’incrément qui lui correspond !
A l’usage cette structure est extrêmement performante mais nécessite un « minimum » d’attention :
3. Tant qu’on n’est pas contre le mur, on avance !
— attention à bien écrire la condition après l’instruction while4! Par exemple, mettre « = » à la place de
« == », changera la suite d’instructions suivantes.
— mais la principale source d’erreur est d’oublier de modifier la condition de test ou le compteur ; on a alors une boucle infinie5.
Q5
1. Écrire un programme qui, à l’aide d’une boucle whilecalcule la somme des nombres pairs compris entre 1 et 100 (inclus) et affiche le résultat.
2. On demande d’entrer une lettre. Si cette lettre est différente deq(pour quitter !), on imprime la lettre et on demande la lettre suivante ; sinon on imprime « fin » et le programme s’arrête. Écrire le programme python correspondant.
3. Écrire un programme qui calcule la somme des entierskpositifs tels quek+k2+k3≤n,nétant un nombre introduit dans le programme. Vérifier que pourn= 1000, la somme vaut 45.
1.2.5 On peut aussi faire 10 pas dans une direction !
Si on connait, à l’avance, le nombre de fois où l’on doit répéter une série d’instruction, on utilise une boucle6for. On accède à un « compteur de bouclei» à l’aide de l’instructionfor i in range(debut, f in(exclue), pas)dans laquellei,debut, f inetpassont des nombres entierw.
! 4
ATTENTION : La valeurf inn’est pas atteinte : ATTENTION! 4
Si l’incrément (ou le pas) vaut 1, on n’est pas obligé de le spécifier.
On rencontre également une instruction du type for i in range(5). Dans ce cas, le début vaut forcément 0, on ne précise que laf in(non atteinte) et le pas vaut 1. Dans le cas présent,ivaut successivement 0, 1, 2, 3, 4.
Par exemple :
Instruction Valeurs successives de i for i in range(0, 4) 0 ; 1 ; 2 ; 3
for i in range(-10, 10, 2) -10 ; -8 ; -6 ; -4 ; -2 ; 0 ; 2 ; 4 ; 6 ; 8 for i in range(10, 5, -1) 10 ; 9 ; 8 ; 7 ; 6
Le programme suivant calcule la somme des nombres entre 0 et 100 (inclus) :
1 S = 0# on i n i t i a l i s e l a somme à 0 2 f o r i in r a n g e( 1 0 1 ) :
3 S = S + i # e t on r a j o u t e 0 p u i s 1 p u i s 2 . . . j u s q u ’ à 100 4 p r i n t("Somme des nombres e n t r e 1 et 100 ( i n c l u s ) : ", S )
! 4
ATTENTION : ON NE MODIFIE PAS, DANS UNE BOUCLE FOR, LE COMPTEUR DE BOUCLE! 4
Q6
1. Écrire à l’aide d’une bouclef orun programme qui calcule la somme de nombres pairs entre 1 et 100 (inclus) et affiche le résultat.
2. Écrire à l’aide d’une boucle f or un programme qui affiche les nombres réels compris entre 0 et 1 (inclus) espacés de 0,1.
3. Écrire à l’aide de deux boucles f or imbriquées un programme qui calcule la somme : S =Pn i=1
Pn j=1ij. Vérifier que pourn= 10, on aS= 3025.
4. Je suis contre le mur mais je continue quand même d’avancer, ou du moins, j’essaie ! 5. Vous essayez d’avancer mais vous oubliez de mettre un pied devant l’autre !
6. On peut réaliser la même chose avec une boucle while mais c’est un peu plus long à écrire.
1.3 Pour compléter la séance. . .
Vous pouvez écrire du code sur papier (sans l’avoir tapé à l’ordinateur) mais, pour commencer, ce n’est pas très facile ! Si vous venez avec votre ordinateur portable, on testera vos programmes ensemble ; sinon, venez avec un listing imprimé de votre7programme !
1.3.1 Equation du second degré
Écrire un programme qui demande les nombres a,b et c dans l’équationax2+bx+c= 0 et qui donne en retour les solutions de cette équation (ou affiche un message dans si elles n’existent pas).
1.3.2 Au dessus ou en dessous de la droite ?
On considère le début du programme suivant :
1 xA = 1 . 5 2 yA = 4 . 5 3 xB =− 3 4 yB = 7 . 5 5 xC = 1 6 yC = 2
On définit les coordonnées de trois pointsA,B etC (que l’on peut librement modifier pour tester le programme) Écrire un programme qui :
1. Calcule et affiche la distance entreAet B.
2. Calcule et affiche la penteaet l’ordonnée à l’origineb de la droiteAB.
3. Calcule et affiche l’équation de la droite AB sous la forme « print("Droite AB d’équation y = ", a, " x + ", b) » ou « print("Droite verticale d’équation x = ", c) ». L’affichage doit être valable quelque soit les coordonnées des pointsAetB en évitant un affichage du type : Droite AB d’équation y = 3.2 x + -2.8 (on veut alors y = 3.2 x - 2.8).
4. Affiche « Au dessus de la droite », « Au dessous de la droite », « Sur la droite » selon la position du point C par rapport à la droiteAB (si on modifie les coordonnées de A ouB et que la droite est verticale, au dessus signifiera à gauche, et en dessous à droite).
Conseil : il est conseiller d’exécuter le programme question après question. . .
1.3.3 En attendant la suite. . .
1. Écrire un programme qui calcule la limite de la suite Sn = Pn i=1
1
i2 sachant que l’on arrête l’exécution lorsque|Sn+1−Sn|< avecproche de zéro.
Vous vérifierez que la limite de la suite est une bonne approximation de π2
6 et en déduirez une valeur approchée deπ.
2. On introduit un entier positifn. Écrire un programme qui calcule la sommeSn des termes suivants : 1×1 + 1×2 + · · · + 1×n
+ 2×2 + · · · + 2×n
. .. ...
. .. ... + n×n Que vautS8?
7. Le votre, pas celui du voisin !
2 Fonctions personnelles. . .
2.1 Les fonctions en Python
2.1.1 Objectif
Dès qu’un programme s’étoffe un peu, il devient peu lisible s’il est écrit « linéairement ». On préfère en général le décomposer en plusieurs « sous programmes », nommés fonctions (ensemble d’instructions) appelés par le programme principal1.
Parfois certaines actions doivent être effectuées plusieurs fois. . . les écrire dans un sous programme est alors un choix judicieux.
Certaines instructions peuvent également être utilisées dans différents programmes ; les inclure dans un sous pro- gramme (puis éventuellement dans une bibliothèque) permettra de les avoir facilement à disposition.
Reprenons, par exemple, une des questions abordées dans le chapitre précéde. Il s’agissait de calculer la moyenne d’une série notes. En notantL1 la liste de notes au premier trimestre, l’algorithme ci-dessous permet de calculer cette moyenne.
1 L1 = [ 5 , 12 , 8 , 6 , 11 , 14 , 12 , 9 , 16 , 10 , 8 , 1 2 ] 23 n = l e n( L1 )
4 somme = 0
5 f o r i in r a n g e( n ) :
6 somme = somme + L1 [ i ] 78 moyenne = somme/n
9 p r i n t(" Moyenne du t a b l e a u : ", moyenne )
1011 L2 = [ 8 , 12 , 11 , 9 , 10 , 11 , 15 , 12 , 13 , 10 , 11 , 9 ]
Mais. . . que se passe-t-il si l’on veut calculer la moyenne au second semestre (liste de notesL2 ?). Il faudrait reco- pier l’ensemble des lignes 3 à 9 et changerL1 en L2. La meilleur solution est de définir une fonction qui calcule la moyenne d’une liste de valeurs quelle qu’elle soit !
Les avantage de définir des fonctions sont :
— Le programme est plus lisible, et se comprend plus facilement.
— Le code est réutilisable.
— Le programme est moins long, si on fait plusieurs fois la même chose, on définie une fonction une seule fois pour cette tâche.
— Le programme est plus facile à debugger et à améliorer.
Il ne faut pas non plus tomber dans un excès inverse et tout inclure dans des fonctions et laisser toute sa place au corps du programme principal.
1. En toute rigueur il faudrait faire la différence entre une fonction (qui doit retourner un (ou plusieurs) résultat(s)) et une procédure (exécute un bloc de code sans retourner de valeurs) ; l’implémentation en python est la même !
2.1.2 Implémentation
1 " " "
2 Dé f i n i t i o n de l a f o n c t i o n 3 " " "
4 d e f maFonction ( paramè t r e ( s ) ) :
5 . . .
6 corps de l a f o n c t i o n , on e x p l o i t e e n t r e autre l e s v a l e u r s du ( des ) paramè t r e ( s ) 7 quelque part : r e s u l t a t = . . .
8 . . .
9 r e t u r n r e s u l t a t # on r e n v o i e l e c o n t e n u de l a v a r i a b l e moyenne au programme p r i n c i p a l 1011 " " "
12 Programme p r i n c i p a l
13 " " "
1415 v a l e u r = maFonction ( 2 )#on s t o c k e l e r é s u l t a t dans une v a r i a b l e 1617 p r i n t(" Valeur de l a f o n c t i o n ", v a l e u r )#on a f f i c h e
— Les fonctions sont définis par leur nom grâce à l’instruction def maFonction(x,y):
— Le mot clef defsignal à Python que l’on va définir une fonction ;
— maFonction est le nom que l’on souhaite donner à la fonction ;
— x, y. . . sont les paramètres que l’on souhaite transmettre à la fonction. Ces paramètres, en nombre quelconques sont introduits entre parenthèses et séparés par des virgules ;
— Dans la fonction, l’instruction return renvoie au programme principale une valeur (ou une liste, ou une chaine de caractères etc.) et stoppe l’exécution de la fonction2.
— On appelle une fonction dans le corps du programme principal parmaFonction(2,3)par exemple ;
— Dans le cas d’une fonction, la(les) valeur(s) retournée(s) doivent être stockées dans des variables : «z = maFonction(2,3)» ; la variable z contient alors le résultat du calcul effectué par maFonction lorsqu’elle reçoit les valeurs 2 et 3 comme paramètres.
2.1.3 Exercices
2.1.3.1 Quelques exemples « simples »
Q7
Ecrire le programme permettant de calculer et afficher les moyennes des deux listes de notes L1 et L2 définies précédemment.Q8
Écrire les fonctions permettant le calcul des fonctions mathématiques :— valeur absolue (OK, elle existe déjà !) ;
— sinus cardinal :sincard(x) = sin(x)
x (sans oublier de gérer le cas x = 0) ;
— sin(ω, t) = sin(ω×t) (ω ett sont deux variables) Tester chacune des fonctions sur quelques valeurs.
Q9
Écrire une fonction pythagore(a,b) qui calcule la longueur de l’hypoténuse d’un triangle rectangle en fonction des longueurs des côtésaet b.Tester sur quelques valeurs.
Q10
Fahrenheit est une échelle de température thermodynamique, où le point de congélation de l’eau est à 32◦F et le point d’ébullition à 212◦F.Écrire :
— une fonctionF2C(x)qui convertit degré Fahrenheit en degré Celsius ;
— une fonctionC2F(x)qui convertit degré Celsius en degré Fahrenheit.
2. Dans le cas d’une procédure, l’instruction return est inutile. . . certains écrivent return none pour bien marquer la fin de la fonction qui ne renvoie rien !
Tester sur quelques exemples.
Q11
Ecrire une fonctionbarsu(ordre, A0, k, t) qui reçoit comme paramètre un entierordrevalant 1 ou 2 ; une concen- tration initialeA0, une constante de vitesseket retourne la concentration en A pour une valeur du tempst.
2.1.3.2 On complique un peu. . .
Q12
On rappelle la formule de conjugaison deDescartes. SoitAun point de l’axe optique etA0 son image par la lentille mince de distance fo- calef0 (f0 >0 pour une lentille convergente) : 1
OA0 − 1 OA = 1
f0. Écrire une fonction qui renvoie la position de l’image en fonction de la position de l’objet (par rapport à la lentille) et de la distance focale.
Écrire une seconde fonction qui calcule la hauteur de l’image en fonc- tion de la hauteur de l’objet, de sa position par rapport à la lentille et de la distance focale de la lentille.
Tester cette fonction sur quelques exemples.
2.1.3.3 Pour les « stars »
Q13
On complète l’exercice précédent. On considère un appareil optique constitué de deux lentilles minces de focalesf1 etf2 séparées d’une distanced. L’origine est fixée au centre de la première lentille. On considère un objet placé à la distanceOAde l’origine. Écrire une fonction qui calcule la position de l’objet.2.1.4 Pièges et difficultés
La principale difficulté, au début, est de bien comprendre la notion de paramètres à passer à une fonction ou à une procédure. Comme sur votre calculatrice, il ne suffit pas d’écrire sin, par exemple, pour que le sinus du nombre auquel on pense soit calculé !
L’erreur classique, ensuite, consiste à supposer que du moment qu’on appelle une fonction avec les bons paramètres, le résultat du calcul est stocké quelque part. . . Le calcul est bien effectué mais la valeur de retour est perdue si on ne la stocke pas dans une variable : il faut absolument, dans le cas d’une fonction, avoir une structure du type :
variable_résultat = maFonction(paramètres) .
Abordons, ici, un cas plus délicat ; celui où une fonction retourne plusieurs valeurs. On ne peut pas exécuter plusieurs «return» de suite, car cette instruction met fin à l’exécution de la fonction. Par contre, on peut écrire «return valeur1, valeur2» ; et on récupèrera les résultats sous la forme «variable1, variable2 = maFonction(paramètres)».
UN SEUL RETURN PAR FONCTION Par exemple, la fonction suivante retourne le périmètre et la surface d’un carré.
1 d e f c a r r e ( a ) :
2 p = 4∗a
3 s = a∗a
4 r e t u r n p , s
56 perimetre , s u r f a c e = c a r r e ( 3 )
7 p r i n t("Pé rim è t r e : " + s t r( p e r i m e t r e ) + " s u r f a c e : " + s t r( s u r f a c e ) )
2.2 Tracé de courbes
Une des principales applications des fonctions est quand même de pouvoir définir. . . une fonction ! et tracer sa courbe représentative.
2.2.1 matplotlib.pyplot est votre amie !
La bibliothèquematplotlib.pyplotdu langage python met à votre disposition tout ce dont vous avez besoin pour tracer des courbes (et bien plus !).
Vous n’avez rien à connaître de cette bibliothèque, mais. . . à force :
— vous importerez la bibliothèque sous l’alias plt : import matplotlib.pyplot as plt ;
— vous créerez deux tableauxX etY de même dimension ;
— vous appelerez plt.plot(X,Y) (éventuellement suivie de plt.show()) pour affichier la courbe.
Soit, par exemple, la représentation de la fonctionsin(k×x) entre 0 et 2πen calculant un point tous les π 100. La solution la plus simple,a priori, consiste, comme dans le chapitre précédent, à utiliser une boucle while comme compteur de boucle.
1 f r o m math i m p o r t sin , pi
2 i m p o r t m a t p l o t l i b . pyplot as p l t
34 d e f sinkx ( k , x ) : #on d é f i n i t l a f o n c t i o n que l ’ on v e u t é t u d i e r 5 r e t u r n s i n ( k∗x )
67 X = [ ] # l i s t e de v a l e u r s pour l e s a b s c i s s e s 8 Y = [ ] # l i s t e de v a l e u r s pour l e s ordonn é e s 9 debut = 0 # v a l e u r i n i t i a l e
10 f i n = 2∗ p i # v a l e u r f i n a l e
11 pas = p i /100 #i n c r é ment d e s v a l e u r s s u r x 1213 x = debut #v a l e u r de x en c o u r s
14 w h i l e x <= f i n :#on p a r c o u r t une b o u c l e t a n t que x e s t <= à 2 p i 15 X. append ( x ) # on compl è t e l e t a b l e a u d e s a b s c i s s e s
16 Y. append ( sinkx ( 4 , x ) ) # e t c e l u i d e s ordonn é e s
17 x = x + pas # on n ’ o u b l i e p a s d ’ i n c r é menter l a v a l e u r de x
1819 p l t . p l o t (X, Y)# on a , au minimum , b e s o i n d e s deux l i s t e s de v a l e u r s X e t Y 20 p l t . show ( )
La bibliothèque matplotlib contient d’inombrables instructions pour enrichir le graphe, tracer une animation. . . Toutes les instructions vous seront données le cas échéant.
Par exemple, on peut enrichir le graphe avec une étiquette sur chaque axe et la légende des courbes.
1 i m p o r t m a t p l o t l i b . pyplot as p l t 2 f r o m math i m p o r t s q r t
3 X = [ ] 4 Y = [ ] 5 Z = [ ] 6 x = 0
7 w h i l e x <=5 : 8 X. append ( x ) 9 Y. append ( x/(1+x ) ) 10 Z . append ( s q r t ( x ) )
11 x = x + 0 . 1
1213 p l t . p l o t (X, Y, " r ", l a b e l="Y") 14 p l t . p l o t (X, Z , " b ", l a b e l="Z") 15 p l t . x l a b e l ("X")
16 p l t . y l a b e l ("Y ou Z")
17 p l t . t i t l e (" Exemple de courbes ") 18 p l t . legend ( )
19 p l t . show ( )
2.2.2 Quelques exemples. . .
Q14
Tracer la courbesincard(x) =sin(x)x entre - 5πet 5π(un point tous les π 100).
Q15
Définir la fonctionf(x) suivante, puis tracer sa courbe représentative :— six<= -2 oux>= 2 :f(x) = x2 2
— si -2 <x< 2 :f(x) = 4−x2 2
Q16
Exploiter la fonctionbarsu(ordre, A0, k, t) afin de comparer l’évolution des concentrations en fonction du temps pour une réaction d’ordre un et d’ordre deux.Q17
Définir une fonction en coordonnées polairer(θ) de votre choix et tracer sa courbe représentative (on ne cherchera pas à utiliser une fonction de la bibliothèque permettant de tracer des courbes en polaire. Google vient de me dire qu’on pourra utiliser l’instruction plt.axis(’equal’) pour forcer un repère orthonormé.2.2.3 Pour compliquer un peu. . .
Q18
La courbe du Blanc-MangeDans cette exercice, on cherche à tracer une approximation de la courbe du Blanc-Mange (en référence à un dessert qui ressemble à cette courbe).
On définie les fonctionsBn, avecnun entier par : Bn(x) =
n
X
k=0
1 2k
2kx−E
2kx+1 2
— La fonction E est la fonction partie entière. On la trouve en python sous le nom floor, dans la bibliothèque math.
(floor(12.95) = 12)
— Les barres verticales désignent la valeur absolue.
Plusnest grand, plus la courbe deBn ressemble à la "vraie" courbe du blanc-mange.
1. Créer une fonction python B(n,x)qui renvoie la valeur deBn(x).
2. Tracer la courbe de Bn sur [0,1] pour des valeurs de plus en plus grandes den.
2.3 Quelques soucis avec les variables. . .
2.3.1 Variables globales, locales
Dans un programme, on peut très bien se trouver dans le cas de figure suivant :
— une fonction est définie par « defmaF onction(x) : » ;
— quelque part on attribue àxune certaine valeur Que se passe-t-il quand on appellemaF onction?
1 x = 2
23 d e f maFonction ( x ) :
4 r e t u r n x∗x
56 y = maFonction ( x ) 7 z = maFonction ( 3 )
8 p r i n t(" x : ", x , " y : ", y , " z : ", z )
Et bien. . . tout se passe bien car à l’intérieur de la fonctionmaF onction, xapparaît comme une variablelocale.
Cette variable a sa propre zone de stockage en mémoire, indépendamment de celle de la variableglobalexdéfinie dans le cœur du programme.
Pour éviter des conflits enter les différentes variables (on parle d’effet de bord) ; une fonction ne peut pas modifier de variable globale sauf si on spécifie explicitement que c’est une variable globale. Que va-t-on avoir comme impression en exécutant le programme suivant ?
1 a = 3#v a r i a b l e g l o b a l e 23 d e f f o n c t i o n 1 ( x ) :
4 y = a ∗ x #on u t i l i s e l a v a r i a b l e g l o b a l e 5 p r i n t(" Dans l a f o n c t i o n 1 a = ", a )
6 r e t u r n y
7 d e f f o n c t i o n 2 ( x ) :
8 a = 2 ∗ x #a e s t r e d é f i n i e comme v a r i a b l e l o c a l e , x en e s t une a u s s i 9 p r i n t(" Dans l a f o n c t i o n 2 a = ", a )
10 r e t u r n x∗x
11 d e f f o n c t i o n 3 ( x ) :
12 g l o b a l a# on p r é c i s e que l ’ on v e u t u t i l i s e r l a v a r i a b l e g l o b a l e 13 a = 10 ∗ x#c e q u i permet de l a m o d i f i e r . . . à nos r i s q u e s e t p é r i l s 14 p r i n t(" Dans l a f o n c t i o n 3 a = ", a )
15 r e t u r n x∗x
1617 p r i n t("Au dé part : a = ", a ) 18 y = f o n c t i o n 1 ( 4 )
19 p r i n t(" Aprè s f o n c t i o n 1 : a = ", a , " y = ", y ) 20 y = f o n c t i o n 2 ( 4 )
21 p r i n t(" Aprè s f o n c t i o n 2 : a = ", a , " y = ", y ) 22 y = f o n c t i o n 3 ( 4 )
23 p r i n t(" Aprè s f o n c t i o n 3 : a = ", a , " y = ", y )
La fonction f onction3 est « dangereuse » car elle modifie la valeur d’une variable globale. . . en principe, seul le programme devrait être autorisé à le faire ! ! !
2.3.2 Pour experts. . . variables mutables ou non mutables
Quesako ?
Un objet mutableest un objet que l’on peut modifier après sa création. Lorsqu’on modifie une liste, la liste est modifiée sans que sa place en mémoire change.
Un objetnon mutablene peut être modifié. Si on le modifie, on crée en fait une nouvelle instance de la variable à un nouvel emplacement mémoire. Les entiers, réels, chaînes de caractères sont non mutables.
Si on ne comprend pas tout, ce n’est pas grave mais il faut avoir, peut-être, conscience des conséquences. Exécutez, par exemple le programme suivant (L’instructionid() retourne l’adresse mémoire d’une variable donnée).
1 a = 2
2 p r i n t(" Avant : a=", a , " à l ’ a d r e s s e : ", id( a ) ) 3 a = 4
4 p r i n t(" Aprè s : a=", a , " à l ’ a d r e s s e : ", id( a ) ) 56 u = [ 4 , 3 , 2 , 1 ]
7 p r i n t(" Avant : u=",u ," à l ’ a d r e s s e : ", id( u ) )
8 u . append ( 5 )
9 p r i n t(" Aprè s : u=",u ," à l ’ a d r e s s e : ", id( u ) ) 1011 ch = " abcde "
12 p r i n t(" Avant : ch=", ch ," à l ’ a d r e s s e : ", id( ch ) ) 13 ch = ch + " f "
14 p r i n t(" Aprè s : ch=", ch ," à l ’ a d r e s s e : ", id( ch ) )
Moralité :
— lors d’une modification d’une variable de type entier, réel, chaîne de caractère : une nouvelle variable est créee à une nouvelle adresse mémoire ;
— lors d’une modification d’une variable de type liste, on conserve la même adresse mémoire.
2.3.2.1 Conséquences sur l’affectationx=y
D’où piège lors de l’exécution du programme suivant :
1 a = 2 2 b = a
3 p r i n t(" Avant : a=", a ," b=", b ) 4 b = 3
5 p r i n t(" Aprè s : a=", a ," b=", b ) 67 u = [ 4 , 3 , 2 , 1 ]
8 v = u
9 p r i n t(" Avant : u=",u ," v=", v ) 10 v [ 2 ] = 5
11 p r i n t(" Aprè s : u=", u ," v=", v ) 12 v = [ 1 , 2 , 3 , 4 ]
13 p r i n t(" Enfin : u=", u ," v=", v )
Aucun souci pour les types entier, réel, booléen, chaîne de caractère ; mais pour les listes l’instructionv =ucrée une nouvelle variablev qui pointe vers le même contenu mémoire que la variableu. Ces variables sont mutables, donc quand on modifie l’une d’elle, on n’en crée pas une nouvelle copie quelque part dans la zone mémoire mais on modifie le contenu de la zone mémoire commun aux deux variables.
Variable et zone mémoire
variable non mutable variable mutable
booléen, entier, réel, chaîne de caractères liste
Instruction : Variable(s) : Zone mémoire :
a = 2 a 2
b = a a
b
2
b = 3 a
b
2 3
Instruction : Variable(s) : Zone mémoire :
u = [4,3,2,1] u 4 3 2 1
v = u u 4 3 2 1
v
v[2] = 5 u 4 3 5 1
v C’est grave, docteur ?
On peut quand même ; pour y remédier il faut remplacer l’instructionv=u:
— soit par une copie dans le vecteurv de tous les éléments deuun par un
— soit, si on vous la donne, par l’utilisation de l’instruction copy() qui crée une nouvelle variable dans une nouvelle zone mémoire pour y stocker le contenu souhaité.
1 u = [ 4 , 3 , 2 , 1 ] 2 v = [ x f o r x in u ]
3 p r i n t(" Avant : u=",u ," v=", v ," aux a d r e s s e s ", id( u ) ," et ",id( v ) ) 4 v [ 2 ] = 5
5 p r i n t(" Aprè s : u=",u ," v=", v ," aux a d r e s s e s ", id( u ) ," et ",id( v ) ) 67 u = [ 4 , 3 , 2 , 1 ]
8 v = u . copy ( )
9 p r i n t(" Avant : u=",u ," v=", v ," aux a d r e s s e s ", id( u ) ," et ",id( v ) ) 10 v [ 2 ] = 5
11 p r i n t(" Aprè s : u=",u ," v=", v ," aux a d r e s s e s ", id( u ) ," et ",id( v ) )
A l’exécution u et v ne pointent pas vers la même zone mémoire et on peut donc modifier l’un sans modifier l’autre.
Remarque : dans le listing ci-dessus, on utilise une liste par compréhension, on pourrait tout aussi bien écrire une des solutions du code suivant :
1 v = [ u [ i ] f o r i in r a n g e(l e n( u ) ) ] 2 # ou
3 v = [ ]
4 f o r uu in u :
5 v . append ( uu ) 6 # ou
7 v = [ ]
8 f o r i in r a n g e(l e n( u ) ) : 9 v . append ( u [ i ] )
2.3.2.2 Conséquences sur les paramètres d’une fonction
Le fait d’accéder aux listes par leur adresse mémoire et non pas directement par leur valeur a également quelques conséquences (qui peuvent être bénéfiques !) lors du passage de paramètre à une fonction.
Qu’obtient-on à l’exécution du programme suivant ?
1 d e f permuteNombre ( x , y ) :
2 p r i n t("Dé but de l a f o n c t i o n : x = ", x , " y = ", y )
3 temp = x
4 x = y
5 y = temp
6 p r i n t(" Fin de l a f o n c t i o n : x = ", x , " y = ", y ) 78 d e f permuteListe (T) :
9 p r i n t("Dé but de l a f o n c t i o n : T = ", T) 10 temp = T [ 0 ]
11 T [ 0 ] = T [ 1 ] 12 T [ 1 ] = temp
13 p r i n t(" Fin de l a f o n c t i o n : T = ", T) 1415 a = 2
16 b = 3
17 p r i n t(" Avant : a = ", a , " b = ", b ) 18 permuteNombre ( a , b )
19 p r i n t(" Aprè s : a = ", a , " b = ", b ) 2021 u = [ 2 , 3 ]
22 p r i n t(" Avant : u = ", u ) 23 permuteListe ( u )
24 p r i n t(" Aprè s : u = ", u )
On constate :
— Que les valeurs des variables non mutables ne sont pas changées dans le corps du programme (même si on appelaitaetble nom des variables dans la fonctionpermuteN ombrecar ce sont des variables « muettes »).
Pour se faire, il faudrait rajouter returnx, y à la fin de la fonction permuteN ombre et faire l’appel de la fonction sous la formea, b=permuteN ombre(a, b).
— Que le tableauuest changé dans le corps du programme après l’appel de la fonctionpermuteListe. En fait, on a passé à la fonction non pas directement la liste mais l’adresse de la liste et, dans la fonction, on travaille sur l’adresse de cette liste.
Par conséquent, lorsqu’on travaille sur une liste ou un tableau :
— ce n’est pas nécessaire de faire unreturnpour récupérer le tableau modifié dans le corps du programme ;
— en contre-partie, il faut faire attention car si on modifie le tableau dans la fonction, le tableau est également modifié dans le corps du programme. . .
