Initiationpython
Transféré par
aa GInitiationpython
Transféré par
aa GLA PROGRAMMATION PYTHON
EN PHYSIQUE
Lycée Saint-Exupéry de Mantes-la-Jolie
2019
La programmation python
En surfant sur le net, à la recherche d'informations sur le
nouveau programme de seconde en physique et plus parti-
culièrement le tracé de vecteurs en langage de programma-
tion Python, je suis tombé sur un document d'une journée
de formation écrit en LATEX que j'ai trouvé très réussi vi-
suellement. Pour ceux qui ne connaissent pas LATEX, c'est
une alternative à tous les WYSIWYG (What You See Is
What You Get) que vous connaissez, les plus connus étant
LibreO ce Writer et Microsoft Word. C'est beaucoup plus
austère mais tellement plus adapté quand on enseigne les
mathématiques ou la physique ! Bref, j'ai voulu essayer de
reproduire la mise en page du document.
Ensuite, je ne trouvais pas mon bonheur sur la probléma-
tique des tracés de vecteurs, seulement quelques réponses
assez succinctes dans des forums spécialisés. J'ai donc com-
biné mon envie de réécrire en LATEX avec mon besoin de
maîtriser le tracé de vecteurs vitesse et accélération. Et si,
au nal, cela peut aider certains d'entre vous qui vont se
mettre à pythonner, contraints et forcés, alors ce travail
n'aura pas été vain.
[Link] 1 Lycée Saint-Exupéry de Mantes-la-Jolie
7.7 Suite de Conway . . . . . . . . . . . . 10
7.8 Codage . . . . . . . . . . . . . . . . . 10
7.9 Fraude à la sécurité sociale . . . . . . 11
7.10 Résolution de problème . . . . . . . . 11
III. Modules et fonctions 12
Table des matières 1
2
Les modules . . . . . . . . . . . .
La fonction . . . . . . . . . . . .
2.1 Utilité . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
12
12
12
2.2 Structure . . . . . . . . . . . . . . . . 13
2.3 Return . . . . . . . . . . . . . . . . . . 13
2.4 Règles usuelles . . . . . . . . . . . . . 13
I. Et Python fut 3 3 Variable locale et variable globale . . . . . . . 14
1 La génèse . . . . . . . . . . . . . . . . . . . . 3 4 Ordre d'évaluation . . . . . . . . . . . . . . . 15
2 Faites votre choix . . . . . . . . . . . . . . . . 3 5 Récursivité . . . . . . . . . . . . . . . . . . . 15
II. Notions de base 4 IV. Fichier : lecture, écriture 16
1 Les variables . . . . . . . . . . . . . . . . . . 4 1 Ouverture et fermeture . . . . . . . . . . . . . 16
2 Principaux types de données . . . . . . . . . . 4 2 Lecture et écriture . . . . . . . . . . . . . . . 16
2.1 Les données numériques . . . . . . . . 4 3 Traitement . . . . . . . . . . . . . . . . . . . 17
2.1.1 Le type integer . . . . . . . . 4 4 [Link] . . . . . . . . . . . . . . . . . . 18
2.1.2 Le type oat . . . . . . . . . 4
2.2 Les données alphanumériques . . . . . 5 V. Lesgraphiques 19
2.2.1 Le type string . . . . . . . . 5 1 Les bases . . . . . . . . . . . . . . . . . . . . 19
2.2.2 Accès à un caractère . . . . . 5 2 Les options de plot . . . . . . . . . . . . . . . 19
2.2.3 Opérations élémentaires . . . 5 3 Les méthodes . . . . . . . . . . . . . . . . . . 20
[Link] La concaténation . . 5 4 Plusieurs courbes sur un graphe . . . . . . . . 21
[Link] Extraction, trans- 5 Multiplot . . . . . . . . . . . . . . . . . . . . 21
formation . . . . . . 5 5.1 Deux fenêtres contenant une gure . . 21
[Link] Rechercher, remplacer 6 5.2 Une fenêtre contenant deux gures . . 22
[Link] La fonction len() . . 6 5.2.1 subplot . . . . . . . . . . . . 22
[Link] La conversion . . . . 6 5.2.2 subplots . . . . . . . . . . . . 22
2.2.4 Formatage . . . . . . . . . . 6 6 Le plot logarithmique . . . . . . . . . . . . . 22
[Link] La plus simple . . . 6 7 Marée dieppoise . . . . . . . . . . . . . . . . . 22
[Link] Avec % . . . . . . . 6 8 Applications . . . . . . . . . . . . . . . . . . . 24
8.1 Reproduire . . . . . . . . . . . . . . . 24
[Link] Avec format . . . . 6
8.2 De la physique . . . . . . . . . . . . . 24
[Link] Avec f-strings . . . . 6
8.3 La fractale du vieux chien . . . . . . . 24
2.3 Booléen . . . . . . . . . . . . . . . . . 6
8.4 Cinétique chimique de réactions suc-
2.3.1 La négation . . . . . . . . . . 6
cessives . . . . . . . . . . . . . . . . . 25
2.3.2 La conjonction . . . . . . . . 7
8.5 Parabole de sûreté . . . . . . . . . . . 25
2.3.3 La disjonction . . . . . . . . 7
9 Les vecteurs . . . . . . . . . . . . . . . . . . . 26
2.3.4 Table de vérité . . . . . . . . 7 10 Encore des applications . . . . . . . . . . . . 27
2.4 Les listes . . . . . . . . . . . . . . . . 7 10.1 Analyse d'un pointage . . . . . . . . . 27
2.4.1 Généralités . . . . . . . . . . 7 10.2 Triche . . . . . . . . . . . . . . . . . . 27
2.4.2 Des méthodes associées. . . . 7 10.3 Rétrogradation de Mars . . . . . . . . 27
2.4.3 Slicing . . . . . . . . . . . . . 7 10.4 Dosage du vinaigre . . . . . . . . . . . 28
2.4.4 Liste de nombres . . . . . . . 7 10.5 Imitation . . . . . . . . . . . . . . . . 28
2.4.5 La copie de liste . . . . . . . 8 11 Modélisation . . . . . . . . . . . . . . . . . . 28
2.4.6 Avec des chaînes de caractères 8 11.1 linregress . . . . . . . . . . . . . . . . 29
3 Les opérateurs spéci ques . . . . . . . . . . . 8 11.2 poly t . . . . . . . . . . . . . . . . . . 29
4 La structure conditionnelle . . . . . . . . . . 8 11.3 curve_ t . . . . . . . . . . . . . . . . 29
5 La boucle . . . . . . . . . . . . . . . . . . . . 9 12 Barres d'erreur . . . . . . . . . . . . . . . . . 29
5.1 While . . . . . . . . . . . . . . . . . . 9
5.2 For ... in ... . . . . . . . . . . . . . . . 9
6 Fonction input() . . . . . . . . . . . . . . . . 9
7 Applications . . . . . . . . . . . . . . . . . . . 9
7.1 Échauement . . . . . . . . . . . . . . 10
7.2 Piste d'un CD . . . . . . . . . . . . . 10
7.3 Suite de Syracuse . . . . . . . . . . . . 10
7.4 Fibonacci . . . . . . . . . . . . . . . . 10
7.5 Spécial Prof . . . . . . . . . . . . . . . 10
7.6 Enigme . . . . . . . . . . . . . . . . . 10
2
La programmation python
rappelle en quelque sorte celui d'une calculatrice améliorée.
On rentre les instructions dans la console, celles-ci sont exé-
cutées par l'interpréteur et le résultat s'a che sur la ligne
suivante. Utilisons-la pour votre baptême de programmeur.
Classiquement, on doit écrire Hello World ! . Les trois che-
Chapitre I vrons indiquent que la console attend nos instructions.
Avant de
1 >>> print("Hello World !")
programmer On exécute l'instruction avec la touche Entrée . Voici
ce que vous devez obtenir :
1 >>> print("Hello World !")
2 Hello World !
3 >>>
L'interpréteur interactif est pratique mais d'un intérêt li-
1 La génèse mité car on ne peut pas sauvegarder ce que l'on écrit d'où
l'utilité de l'éditeur de texte. Ouvrez un nouveau chier Py-
En 1989, un programmeur, Guido Van Rossum, tra- thon.
vaille à l'Institut national de recherches mathématiques et
informatiques des Pays-Bas (CWI), sur un projet de dévelop-
pement d'un système d'exploitation. A n d'utiliser au mieux
ce nouveau système, il perfectionne le langage ABC qui était
alors utilisé. Il rend également ce nouveau langage portable,
c'est-à-dire utilisable sur plusieurs système d'exploitation. Il
appellera sa création Python, en l'honneur des Monty Python
dont il appréciait l'humour. Une des particularités de ce lan-
gage est la syntaxe par indentation. Ce langage est abordable
par des élèves lycéens car il reste intuitif et moins austère que
d'autres langages.
Lorsque l'on clique sur nouveau chier , on peut choisir
2 Faites votre choix entre 3 sortes de programmes diérents, il y a :
Lycée : si on veut utiliser le module lycee .
Si vous êtes adepte de l'OS de Microsoft, Windows, il Python 3.4 : pour programmer en python 3.4 jusqu'à
existe de nombreuses distributions. La plus simple dans son une prochaine évolution .
installation et dans son utilisation reste, pour moi, Edu- Tortue : pour utiliser le module tortue .
python, initiée par Vincent Maille et l'académie d'Amiens. Le module Tortue est un module de dessin. Il est intéressant
Cette distribution contient toutes les bibliothèques néces- et amusant pour des élèves de seconde en première approche
saires pour être utilisé dans l'éducation nationale. Son inter- de la programmation pour faire des fractales par exemple.
face est en français et il y a aussi un module lycee spéci que. Pour l'instant, on ouvrira seulement un nouveau chier Py-
De plus, cette distribution est portable, elle peut se mettre thon. Voici un exemple de programme que vous serez bientôt
sur une clé USB pour l'avoir toujours sur soi. Faisons une capable de faire.
présentation rapide d'Edupython.
Quand on préfère Linux, comme moi, je conseillerais la
Voici à quoi ressemble Edupython. Vous remarquerez qu'il suite Anaconda qui intègre Spyder. L'installation se fait faci-
existe trois zones. Une qui permet de retrouver facilement vos lement. Elle existe aussi pour Windows. Cela reste, au nal,
programmes, l'explorateur Windows, une autre qui per- une question de goût et de besoin.
met de rédiger vos programmes, l'éditeur de texte et une
dernière, la console, qui est un interpréteur interactif.
C'est-à-dire que cela permet d'avoir une interaction immé-
diate entre l'utilisateur et l'interpréteur. Son fonctionnement
[Link] 3 Lycée Saint-Exupéry de Mantes-la-Jolie
La programmation python
1 mon_age+=3
Notez qu'il existe une méthode simple pour permuter
deux variables sans passer par une troisième.
Chapitre II 1
a,b=5,9 # affectation parallèle
Les notions de base 2
3
4
c=d=2 # affectation multiple
print(a,b,c,d)
a,b=b,a
5 print(a,b,c,d)
Les variables que nous venons de voir sont des entiers
mais ce n'est pas toujours le cas, cela peut tout aussi bien
1 Les variables être une chaîne de caractères :
1 phrase="Le langage Python mérite d'être connu!"
Les variables sont l'un des concepts qui se retrouvent dans 2 print(phrase)
la totalité des langages de programmation. Une variable est
une donnée de votre programme stockée dans la mémoire de Dans le langage C++, nous devons dé nir le type de
l'ordinateur a n de pouvoir l'utiliser à plusieurs reprises et variable avant de l'utiliser (entier, chaîne de caractères...)
faire des calculs. En Python, pour aecter une valeur à une or, avec Python, cela se fait automatiquement. La fonction
variable, il su t d'écrire quelque chose comme : type() qui retourne le type de données de l'objet indiqué
nom_de_variable = valeur entre les parenthèses est une autre fonction prédé nie. Es-
sayez :
Une variable doit respecter quelques règles de syntaxe : 1 a=3
1. Le nom de la variable ne peut être composé que de 2 print(type(a))
lettres majuscules, minuscules, de chires et du sym- 3 # ou
bole underscore. 4 b="Hello"
5 print(type(b))
2. Le nom de la variable ne peut pas commencer par un
chire. Voyons plus en détail les principaux types de données.
3. Le langage Python est sensible à la casse, AGE est
diérent de age ou aGe.
2 Principaux types de données
4
! Il existe des noms interdits pour les variables car
2.1 Les données numériques
ils sont utilisés dans le langage Python :
and, as, assert, break, class, continue, def, del, 2.1.1 Le type integer
elif, else, except, False, nally, for, from, if,
import, in, is, global, lambda, None, nonlo- Le type int ou integer concerne les nombres entiers. Le
cal, not, or, pass, return, rise, True, try, while, langage Python est capable de traiter des nombres entiers de
with, yield. taille illimitée. Il faut quand même apporter une petite pré-
cision. Le c÷ur d'un ordinateur est constitué d'un processeur
qui ne peut que traiter des nombres binaires de taille limitée
On peut aecter à d'autres variables des valeurs obtenues (32 ou 64 bits sur les ordinateurs récents). Sur un ordinateur
en eectuant des calculs sur la première.
n bits, les nombres relatifs qu'il est possible d'encoder sont
1 mon_age=20 compris entre -2n-1 et 2n-1 −1. On représente un entier relatif
2 Mon_age=25 x positif ou nul comme l'entier naturel x et un entier relatif
3 somme=mon_age+Mon_age x strictement négatif comme l'entier naturel x + 2n . Ainsi,
4 print(mon_age,Mon_age,somme) les entiers naturels de 0 à 2n-1 − 1 servent à représenter les
entiers relatifs positifs et les entiers naturels de 2n-1 à 2n − 1
Le langage Python a des fonctions prédé nies dont la servent à représenter les entiers relatifs strictement négatifs.
fonction print() qui permet d'a cher une ou plusieurs don- Les opérations sur des nombres compris entre ces deux li-
nées. mites sont donc rapides. Mais lorsque les nombres sont hors
La fonction print permet, ici, d'a cher les valeurs des de ces limites, les interpréteurs et compilateurs doivent ef-
trois variables utilisées. fectuer un travail de codage/décodage a n de ne présenter
On est souvent amené à incrémenter des variables. L'in- au processeur que des nombres de n bits au maximum. Le
crémentation désigne l'augmentation de la valeur d'un cer- temps de traitement sera alors plus long.
tain nombre.
Il y a deux moyens pour le faire : 2.1.2 Le type oat
1 mon_age=mon_age+3 C'est ce qu'on appelle le type nombre à virgule ot-
tante . Pour qu'une donnée numérique soit du type oat,
ou plus subtil il su t qu'elle contienne un point décimal ou une puissance
[Link] 4 Lycée Saint-Exupéry de Mantes-la-Jolie
La programmation python
de 10. Ce type de variable permet de manipuler de grands
nombres positifs ou négatifs. La précision sera au maximum 1 mot5="""On la surnommait "casque d'or"."""
2 mot4='''L'appel de la forêt'''
de 12 chires signi catifs avec les puissances de 10.
1 a=3.14
2 # ou
3 b=8e4
4 print(type(b)) 2.2.2 Accès à un caractère
Un nombre ottant est représenté, pour l'interpréteur Py- Une chaîne de caractères est considérée comme une sé-
thon, sous la forme s.m.2n où s est le signe du nombre, n son quence. Chaque caractère peut être désigné par sa place dans
exposant et m sa mantisse. Le signe est + ou -, l'exposant la chaîne à l'aide d'un index. Pour cela, on utilise le nom de
est un entier relatif et la mantisse est un nombre à virgule en la variable qui contient la chaîne de caractères et on ajoute
base 2, compris entre 1 inclus et 2 exclu. Par exemple, quand l'index de la position du caractère qui nous intéresse dans la
on utilise 64 bits pour représenter un nombre à virgule, on chaîne, entre crochets.
utilise 1 bit pour le signe, 11 bits pour l'exposant et 52 bits
pour la mantisse. J'ai choisi de parler de la représentation 4
! À savoir
des ottants, non pas pour vous donner un mal de tête mais
pour mettre l'accent sur un détail qui peut être source de On commence à compter à partir de 0.
problème.
4
! À savoir
1 TS="abc"
2 print(TS[1],TS[0],TS[2])
À cause de la base binaire utilisée, il est impossible
de représenter exactement la plupart des nombres dé-
cimaux, plus précisément tous ceux qui ne s'écrivent
pas sous la forme 2kn . Des nombres qui habituelle- 2.2.3 Opérations élémentaires
ment ne posent pas de problème dans les calculs en
mathématique deviennent ainsi une source d'erreurs [Link] La concaténation :
multiples. On peut assembler plusieurs chaînes de caractères pour
en former de plus grandes. C'est la concaténation. Pour se
Pour vous en rendre compte, exécutez dans l'interpréteur faire, on utilise l'opérateur mathématique +.
interactif ce qui suit (** sert à l'exponentiation) :
1 >>>5+2**(-76)-5 1 TS="Je passe"
2 TL="mon bac."
puis 3 Terminal=TS+TL
4 print(Terminal)
1 >>>5-5+2**(-76)
2.2 Les données alphanumériques [Link] Extraction, transformation :
2.2.1 Le type string Voici quelques possibilités à tester.
Dans la plupart des langages de programmation, pour 1 mot="Ha"
traiter des caractères alphabétiques comme des mots, des 2 mots=mot*10
phrases, il existe une structure de données particulière que 3 Mot="Saperlipopette"
l'on appelle chaîne de caractères (type string ou str). 4 part=Mot[2:9] # début inclus fin exclue (slicing)
Pour la dé nir, on utilise les apostrophes ou les guillemets. 5 print(mot,mots,Mot,part)
1 mot1='Hello'
2 #ou On peut également transformer la chaîne de caractères en
3 mot2="World" majuscule ou en minuscule. Mais pour cela, il faudra mettre
4 print(mot1,mot2) en place une syntaxe un peu particulière car on doit consi-
dérer la chaîne de caractères comme un objet et utiliser une
On peut avoir besoin d'une chaîne de caractères qui méthode disponible pour cet objet. Une méthode est une
contient apostrophe et guillemets, on utilise alors l'antislash fonction qui est attachée à un objet précis.
\ .
1 mot="ForMidaBle"
2 # Méthodes lower() et upper() appliquées sur l'
1 mot3="On la surnommait \"casque d'or\"."
objet mot
2 mot4='L\'appel de la forêt'
3 min=[Link]()
4 maj=[Link]()
Une autre façon pour utiliser des apostrophes et des 5 print(mot, min, maj)
guillemets dans la chaîne de caractères est de mettre des
triples quotes (trois guillemets ou trois apostrophes).
[Link] 5 Lycée Saint-Exupéry de Mantes-la-Jolie
La programmation python
[Link] Rechercher, remplacer :
1 nombre=128
Voici d'autres possibilités qui pourront s'avérer utiles se-
2 aliments="carottes"
lon les circonstances. 3 print("J'ai planté",nombre,aliments,'dans mon
1 phrase="Cette phrase va me servir d'exercice." jardin.')
2 nb=[Link]("e")
3 nb2=[Link]("se")
4 ToF="se" in phrase [Link] Avec % :
5 ou=[Link]("va") Voici la première vraie méthode de formatage :
6 phrase2=[Link]("se","za")
7 print(phrase, "\n",nb,"\n",nb2,"\n",ToF,"\n",ou,"\n 1 nombre=128
",phrase2) 2 aliments="carottes"
3 print("J'ai planté %d %s dans mon jardin." %(nombre
,aliments))
[Link] La fonction len() : %s indique que la variable est de type str, %d int, %f
Cette fonction est très utile et très utilisée dans ce docu- oat. Pour les oat, la syntaxe peut être diérente si besoin
ment, notamment dans les boucles for que nous aborderons puisque l'on peut tronquer la valeur comme ci-dessous :
un peu plus loin. Elle permet de déterminer la longueur de 1 nombre=128
l'élément entre parenthèses. 2 aliments="carottes"
3 autres="choux"
1 variable="Einstein" 4 print("J'ai planté %f %s et %.2f %s dans mon jardin
2 longueur=len(variable) ." %(nombre,aliments,nombre,autres))
3 print(longueur)
On doit rappeler les variables à chaque fois que l'on en a
besoin et respecter l'ordre.
[Link] La conversion :
[Link] Avec format :
Si la chaîne de caractères représente un nombre, on peut
Cette méthode est à privilégier si vous n'avez pas encore
convertir cette chaîne en entier ou en ottant. Essayez :
une version supérieure à Python 3.6.
1 variable="128" 1 nombre=128
2 somme=variable+12 2 aliments="carottes"
3 autres="choux"
On ne peut pas additionner une chaîne de caractères qui 4 print("J'ai planté {0} {1} et {0} {2} dans mon
ressemble à un entier avec un entier. Mais on peut faire : jardin.".format(nombre,aliments,autres))
1 variable="128" On peut aussi tronquer les ottants avec :
2 entier=int(variable)
1 pi=3.14159
3 somme=entier+12
2 print("Pi vaut {0:2f} ou {0:3f} ou mieux {0}.".
4 print(somme)
format(pi))
ou avec un nombre de type oat :
1 variable="128.68" [Link] Avec f-strings :
2 flottant=float(variable) Depuis Python 3.6. Cela ressemble à format en plus
3 somme=flottant+12 simple et cela permet d'utiliser en plus des fonctions à l'in-
4 print(somme) térieur. Notez le f au début de la chaîne.
1 prix=12.56
Les fonctions int() et oat() transforment une chaîne 2 fruit="pommes"
de caractères en entier ou ottant. On peut aussi faire la 3 print(f"Les {[Link]()} sont à {prix:.1f} e le
conversion inverse avec la fonction str(). kilo.")
1 entier=128
ch=str(entier) # conversion inverse
2
2.3 Booléen
Les booléens sont un type un peu particulier dont les
valeurs sont particulièrement simples car il n'y en a que
2.2.4 Formatage
deux : True ou False. C'est le résultat d'expressions ma-
Nous allons voir, ici, plusieurs façons d'a cher diérents thématiques logiques.
types de variables.
2.3.1 La négation
[Link] La plus simple : C'est le NON logique qui s'écrit en Python avec le mot-
C'est celle que l'on voit beaucoup dans le code des pro- clé not. Ainsi l'expression not B a la valeur True si B a la
grammeurs débutants. valeur False.
[Link] 6 Lycée Saint-Exupéry de Mantes-la-Jolie
La programmation python
2.3.2 La conjonction Pour supprimer l'élément qui se trouve à un certain rang
d'une liste, on utilise la méthode pop. La méthode reverse
C'est le ET logique qui s'écrit en Python avec le mot-clé permet d'inverser l'ordre d'une liste. Quel sera le résultat du
and. L'expression B1 and B2 renvoie la valeur True si et programme suivant ?
seulement si B1 et B2 ont pour valeur True.
1 L=["a",0,1,2,"banane"]
2 [Link](2,"pomme") # L'index en premier argument
2.3.3 La disjonction 3 [Link](1,4)
C'est le OU logique qui s'écrit en Python avec le mot- 4 [Link](2) # L'élément en argument
clé or. L'expression B1 or B2 renvoie la valeur False si et 5 [Link](3) # L'index en argument
seulement si B1 et B2 ont pour valeur False. 6 [Link]() #
7 print(L)
2.3.4 Table de vérité Sans oublier, la méthode sort qui permet de trier une
liste.
B1 B2 not B1 B1 and B2 B1 or B2
True True False True True 1 L=[18,12,9,7,130,15,9]
True False False False True 2 [Link]()
False True True False True 3 print(L)
False False True False False
2.4.3 Slicing
2.4 Les listes
Le slicing ou, si vous préférez, la découpe en tranche ,
2.4.1 Généralités permet de modi er une liste en travaillant par tranche. Elle
consiste à indiquer entre crochets les indices correspondant
Une liste est une collection d'éléments séparés par des
au début et à la n de la tranche qui nous intéresse. On
virgules et encadrés par des crochets. Les éléments qui com-
retrouve les mêmes eets que les méthodes del et append.
posent une liste peuvent être de types diérents. Comme pour
les chaînes de caractères, on peut accéder à un élément précis 1 L=["autruche","girafe","lion","ours"]
de la liste en connaissant son index. En eet, l'ordre dans une 2 L[2:2]=["panda"]
liste est xe. La fonction len() est également applicable aux 3 L[3:3]=["rat","chien"]
listes. On ajoutera que l'on peut enlever un élément d'une 4 print(L)
liste avec la fonction del(). Il faut noter que les listes sont 5 L[1:3]=[]
6 print(L)
des séquences modi ables. On peut remplacer un élément par
7 L[3:]=["radis","banane"] # signifie de 3 jusqu'à
un autre. la fin
Devinez ce que donne le programme suivant : 8 print(L)
1 ma_liste=["bonjour",38,"Hello",12.5)
2 longueur=len(ma_liste)
3 print(longueur,ma_liste[0]) 2.4.4 Liste de nombres
4 ma_liste[2]="Great"
5 print(ma_liste) En utilisant la fonction range(n) qui génère par défaut
6 del(ma_liste[1]) une séquence de nombres entiers successifs de 0 à n-1 de
7 longueur=len(ma_liste) type range et la fonction list() qui convertit une séquence
8 print(longueur,ma_liste[2]) en liste, une liste est vite créée. Attardons-nous un peu sur
ce nouveau type d'objet car nous le retrouverons plus tard.
1 variable=range(10)
2.4.2 Des méthodes associées. 2 print(type(variable))
3 print(variable)
On peut également ajouter un élément à une liste. Mais 4 print(variable[2])
pour cela, il faudra utiliser une méthode disponible pour les 5 print(6 in variable)
objets de type list. Ici, contrairement aux méthodes sur les 6 print(15 in variable)
chaînes de caractères, on applique la méthode sur l'objet sans
la stocker dans une variable. Un exemple sera plus parlant : Range est bien un type de variable à part entière. On
peut mettre entre parenthèses, un, deux ou trois arguments,
1 """méthode append() appliquée sur l'objet semaine range(start,stop,pas ). L'avantage du type range est que
avec comme argument "dimanche".""" l'on crée un objet qui occupera toujours une petite quantité
2 semaine=["lundi","mardi","mercredi","jeudi"," de mémoire quelle que soit sa taille. Seuls les paramètres sont
vendredi","samedi"]
3 [Link]("dimanche") # pas de var =
mémorisés.
print(semaine) La fonction list() transforme cet objet en liste.
4
1 L1=list(range(10,18,2))
La méthode append ajoute l'argument en n de liste. 2 L2=list(range(10,-10,-2))
Si on préfère un rang précis, il faudra utiliser la méthode 3 print(L1)
insert. Si on veut supprimer la première occurrence d'un 4 print(L2)
élément dans une liste, il faut utiliser la méthode remove.
[Link] 7 Lycée Saint-Exupéry de Mantes-la-Jolie
La programmation python
2.4.5 La copie de liste 3 f=c-b
4 g=a*b
On peut vouloir copier une liste pour ensuite faire des 5 h=c/a
opérations dessus sans toucher à l'original. Intuitivement, on 6 i=d/b
ferait : 7 j=b**a
8 k=d//b
1 L1=[0,1,2,3,4,5] 9 l=d%b
2 L2=L1 10 print(e,f,g,h,i,j,k,l)
3 print(L1,L2)
On pourrait croire jusqu'ici que tout va bien mais .... Il existe également des opérateurs de comparaison, utiles
pour écrire des conditions.
1 L1=[0,1,2,3,4,5]
2 L2=L1 1 x==y # x est égal à y, différent de l'affectation
3 print(L1,L2) 2 x!=y # x est différent de y
4 [Link](6) 3 x>y # x supérieur à y
5 print(L1,L2) 4 x<y # x inférieur à y
5 x>=y # x supérieur ou égal à y
L1 et L2 renvoie à la même adresse mémoire, toute modi- 6 x<=y # x inférieur ou égal à y
cation sur L1 se répercute sur L2 et réciproquement. Pour
créer une nouvelle liste L2 indépendante, on peut faire comme
cela :
1
L1=[0,1,2,3,4,5]
4 La structure conditionnelle
2 L2=list(L1)
3 print(L1,L2) Cette structure très usitée possèdent des mots-clés parti-
4 [Link](6) culiers qui permettent de l'identi er immédiatement : if, elif,
5 print(L1,L2) else. Cela se traduit respectivement par si, sinon si, sinon .
Elle se présente sous la forme d'un bloc dans lequel on
remarque une indentation des instructions.
2.4.6 Avec des chaînes de caractères 1 instruction 1
Deux méthodes associées aux chaînes de caractères vont 2 if condition A: # Remarquez les :
être très utiles lorsque l'on manipule les chiers par exemple. 3 instruction 2 # indentation
J'en parle ici parce que cela fait aussi intervenir la notion de 4 instruction 3 # indentation
5 else: # pas de condition mais :
liste. En eet, il faut en argument un objet qui doit être ité-
6 instruction 4 # indentation
rable, comme une liste ou un tuple (une liste non modi able) 7 instruction 5
et qui ne doit contenir que des chaînes de caractères. La pre-
mière méthode est join qui renvoie une chaîne de caractères.
La deuxième méthode, split, est l'inverse en quelque sorte. Après avoir exécuter l'instruction 1, si la condition A est
Un exemple est toujours plus parlant, notamment pour vraie, l'instruction 2 puis l'instruction 3 sont exécutées et en-
la syntaxe. Regardez le résultat de ceci : n on passe à l'instruction 5. Par contre, si la condition A est
fausse, on exécute l'instruction 4 puis on passe à l'instruction
1 L=["un","deux","trois"] 5. Les instructions 2, 3, 4 contenues dans if et dans else ne
2 var="et".join(L) peuvent être exécutées successivement. La partie else est fa-
3 print(var) cultative. On peut aussi écrire if not à la place de if dans le
4 autre="ou".join(L) programme ci-dessus. Les instructions 2 et 3 seront alors exé-
5 print(autre) cutées quand la condition A est fausse. On pourra aussi avoir
6 Liste=[Link]("e")
7 # e est notre séparateur d'éléments pour créer la
besoin de l'instruction elif, que l'on peut traduire par sinon
liste si, pour introduire une nouvelle condition. On peut ajouter
8 print(Liste) autant de elif que l'on souhaite mais l'instruction else ne
pourra gurer qu'une fois, clôturant le bloc de la condition.
Voici un exemple complet de la structure possible :
3 Les opérateurs spéci ques 1
2
instruction 1
if condition 1: # Remarquez les :
Il faut savoir que les opérateurs Python ne sont pas 3 instruction 2 # indentation
seulement les quatre opérateurs mathématiques de base. On 4 instruction 3 # indentation
5 elif condition 2:
ajoute l'existence de l'opérateur de division entière // , 6 instruction 4
celle de l'opérateur ** pour l'exponentiation ou celle de 7 elif condition 3:
l'opérateur modulo % qui donne le reste de la division 8 instruction 5
entière. Un exemple permettra de bien comprendre les dié- 9 else: # pas de condition mais :
rents opérateurs. 10 instruction 6 # indentation
11 instruction 7
1 a,b,c,d=3,8,27,84
2 e=a+b
[Link] 8 Lycée Saint-Exupéry de Mantes-la-Jolie
La programmation python
5 La boucle Exemple 2 : Le parcours d'une liste
liste=["arrosoir","seau","pelle","plantoir"]
5.1 While 1
2 for element in liste:
Il est souvent nécessaire de répéter plusieurs fois une 3 print("le nombre de lettres de : ",element," est
de :",len(element))
même séquence d'instructions jusqu'à ce qu'une certaine
condition soit satisfaite. Pour se faire, on utilise une boucle.
Le mot-clé while permet de réaliser cela. Exemple 3 : La table de 9
Vous trouverez, ci-dessous, un exemple complet de la
structure d'une boucle. 1 for i in range(11):
2 print (i," *9= ",9*i)
1 instruction 1
2 while condition A: # se termine par :
3 instruction 2 # indentation
Exemple 4 : carré des 100 premiers nombres impairs
4 instruction 3 # indentation
1 for i in range(1,100,2):
5 instruction 4
2 print (i," * ",i," = ",i*i)
Dans le programme ci-dessus, l'instruction 1 est exécutée
puis les instructions 2 et 3 sont répétées tant que la condition Exemple 5 : L'intérêt de enumerate
A est vraie. Quand la condition A devient fausse, on passe à
l'instruction 4. Si la condition A est fausse dès le départ, les 1 Liste=["Bonjour",9,9.5,True,range(10),[1,False],(1,
"x")]
instructions 2 et 3 ne sont jamais exécutées. La ligne du bloc
2 for index,element in enumerate(Liste):
qui commence par while se termine par : et les lignes 3 print ("L'élément {0} est du type {1}".format(
suivantes sont indentées. index,type(element))
Si on veut exécuter les instructions 2 et 3 quand la condi-
tion est fausse, on doit ajouter not après while dans l'algo-
rithme ci-dessus et si la condition est vraie alors c'est l'ins-
truction 4 qui sera seulement exécutée.
Il se peut, parfois, que l'on veuille une boucle in nie, on 6 Fonction input()
utilise alors while True :. Une telle boucle est notamment
utilisée quand on veut créer des fenêtres graphiques avec le La fonction input() fait partie des fonctions prédé nies
module Tkinter par exemple. Attention, une boucle in nie comme la fonction print(). De façon courante, un programme
est considérée comme un bug si aucune condition de sortie peut nécessiter l'intervention de l'utilisateur pour entrer un
n'est prévue puisque l'on doit, alors, forcer l'arrêt du pro- paramètre par exemple. La fonction input() permet cela en
gramme. provoquant une interruption dans l'exécution du programme
1 instruction 1
pour que l'utilisateur puisse rentrer une valeur au clavier qui
2 while True : # se termine par : pourra être aectée à une variable. Une fois la valeur ren-
3 instruction 2 # indentation trée et après avoir validé avec la touche Enter, l'exécution du
4 instruction 3 # indentation programme se poursuit.
5 instruction 4
1 prenom=input("Quel est votre prénom ?")
2 print("Bonjour, ",prenom,". Je suis ravi de vous
Dans ce cas, l'instruction 4 ne sera jamais exécutée si les
rencontrer!")
instructions 2 et 3 ne permettent pas de sortir de la boucle. 3 print("Bonjour, {0}. Je suis ravi de vous
rencontrer".format(prenom)) #formatage des str
5.2 For ... in ... 4 print("Bonjour, %s. Je suis ravi aussi"%prenom) #
ancien formatage
Une autre façon de faire une boucle est d'utiliser les mots-
clés for et in quand on doit parcourir une séquence (chaîne
de caractères ou liste). Cette structure de boucle évite de de-
voir dé nir et incrémenter un compteur. Voici des exemples
4
! À savoir
pour mieux comprendre la syntaxe. Les possibilités sont nom- La fonction input() renvoie toujours une chaîne de ca-
breuses. Prenez un peu de temps pour vous attarder sur end, ractères. Si un entier est attendu en réponse ou autre
sep et enumerate : chose, il faut alors faire une conversion de typage.
Exemple 1 : Le parcours d'une chaîne de caractères
1 nom="Merlin"
2 print(nom)
for car in nom:
7 Applications
3
4 print(car +"-",end="*") # * remplace un saut de
ligne
5 print() #Pour changer de ligne Les exercices qui suivent font appel à toutes les notions
6 for car in nom: vues auparavant. Il n'existe pas qu'une seule solution. c'est
7 print(car ,"*",sep="-") # séparateur particulier
ce qui fait le charme de la programmation.
[Link] 9 Lycée Saint-Exupéry de Mantes-la-Jolie
La programmation python
7.1 Échauement
7.1.1. A cher les 20 premiers termes de la multiplica- Quel que soit le nombre de départ a, la suite se termine à
tions par 21. 1. On appelle vol d'un nombre a le nombre de termes utilisés
avant de retourner 1 et hauteur de vol la valeur maximale
7.1.2. A cher une suite de 20 termes qui débute par atteinte. Stockez dans des listes les longueurs et hauteurs de
le nombre que vous entrez avec la fonction input et où le vol pour chaque valeur de a entier 6 1000 et a chez les va-
nombre suivant est le triple du précédent. leurs pour lesquels soit la hauteur de vol est la plus grande
soit le vol le plus long.
7.1.3. Un jour, un roi fut sauvé des eaux par un vieux
sage. Pour le récompenser, il prit la décision d'exaucer le
v÷u du vieil homme s'il trouvait sa demande raisonnable. Le 7.4 Fibonacci
sage prit un grain de riz et le posa sur la première case d'un
échiquier. Il souhaita que son seigneur double ce nombre à Un homme a un couple de lapins enfermés dans un enclos
chaque nouvelle case (2 grains sur la deuxième case, 4 sur et il voudrait suivre l'évolution du nombre de couples de sa
la troisième ... ) et il précise qu'il se contentera de tous les colonie de lapins, mois par mois, pendant 5 ans.
grains de riz que cela représentera. Le roi accepte. A cher le
nombre de grains de riz sur chaque case, ainsi que le nombre
total de grains de riz en mole.
7.1.4. Écrire un programme qui demande à l'utilisateur
de rentrer une année en entrée et en sortie le programme
dit si cette année est bissextile ou non. Une année bis-
sextile comporte 366 jours au lieu de 365 jours. Une année
quelconque est bissextile si elle est divisible par 4 mais pas
par 100 sauf si elle est divisible par 400. Par exemple, 1800
n'est pas bissextile alors que 2000 l'était. À vous de jouer !
7.1.5. Écrire un programme qui calcule les 1000 premiers
nombres premiers. Un nombre premier est un nombre plus
grand que 1 qui a pour uniques diviseurs, 1 et lui-même.
Ce programme devra, par ailleurs, ressortir les nombres pre-
miers jumeaux. Deux nombres premiers sont jumeaux si leur
diérence est égal à 2 (5 et 7 sont deux nombres premiers 7.5 Spécial Prof
jumeaux).
Écrire un programme qui demande à l'utilisateur de saisir
au clavier des notes d'élèves au clavier jusqu'à ce que l'utili-
7.2 Piste d'un CD sateur tape n . Avec les notes saisies, construire une liste,
Le Compact Disc est un objet numérique. L'information y a cher le nombre de notes entrées, la note la plus basse, la
est stockée sous forme de séquences de bits qui valent 0 ou 1. plus élevée ainsi que la moyenne. Pour une liste L, Python
À la surface d'un CD, il y a un sillon sur lequel se succèdent comprend min(L), max(L), sum(L) mais essayez de vous
des plats (lands ) et des creux (pits ). On cherche à calculer en passer.
la longueur totale de la piste en faisant l'approximation qu'il
s'agit d'une succession de cercles. Dans la console, il s'a -
chera une phrase du genre : Pour être lu complètement un 7.6 Enigme
CD doit tourner .....fois, la piste mesure environ ..... mètres.
Trouver un nombre de 4 chires qui soit le carré d'un
La Program Area est la zone contenant des données. nombre entier et tel que, en ajoutant un à chaque chire
Elle commence à partir d'un rayon de 25 mm et (ex : 1258 ,→ 2369), on obtienne le carré d'un autre entier.
s'étend jusqu'à 58 mm. La largeur d'un pit ou d'un
land est de 0.6 µm, le pas de la spirale est de 1,59 µm.
7.7 Suite de Conway
Programmer les 20 premiers termes de la suite de Conway
7.3 Suite de Syracuse (voir sur Wikipédia).
Écrire un programme qui calcule les termes de la suite de
Syracuse :
7.8 Codage
u0 = a où a est un entier quelconque et :
Écrire un programme qui intercale un mot dans une
phrase. Si on intercale python dans Hello World ! cela
1
u
n+1 = un si un est pair donne Hpeyltlhoo nwpoyrtlhdo !n . On a che ensuite la
2
u
n+1 = 3 un + 1 si un est impair chaîne de caractères en l'inversant.
[Link] 10 Lycée Saint-Exupéry de Mantes-la-Jolie
La programmation python
7.9 Fraude à la sécurité sociale dans une poubelle. Il y a donc BU poubelle et GA shadok à
côté .
Faire un programme qui teste une liste de numéros de sé-
curité sociale a n de voir si ceux-ci sont valides ou non.
Pour cela, il faut savoir que le nom o ciel est Numéro d'Ins-
cription au Répertoire des Personnes Physiques (NIRPP ou
NIR). Il est construit à partir de l'état civil transmis par les
mairies (sexe (1 chire : 1 ou 2), année (2 chires) et mois de
naissance (2 chires), département (2 chires) et commune
de naissance (3 chires), numéro d'ordre du registre d'état
civil (3 chires)). C'est un numéro signi ant , composé de
13 chires, suivi d'une clé de contrôle de 2 chires (complé-
ment à 97 du nombre formé par les 13 premiers chires du
NIR modulo 97).Voici les numéros à mettre dans votre liste :
255081416802512
176066454329550
56324363975780
177097645103210
282127511412314
7.10 Résolution de problème
Compter jusqu'à 100 en langue Shadok. Pour vous aider,
voici l'explication du professeur Shadoko :
Je me souviens qu'il avait dit : Quand on a MEU shadoks,
et qu'on en ajoute BU, il n'y a plus de place. On les met alors
[Link] 11 Lycée Saint-Exupéry de Mantes-la-Jolie
La programmation python
Il est à noter que les angles doivent être donnés en ra-
dians. Il existe des descriptifs de toutes les fonctions dispo-
nibles pour un module donné sur internet. Il faut cependant
s'armer de courage pour les lire car ceux-ci peuvent être com-
posés d'un millier de pages.
Chapitre III
Modules/fonctions module math
[Link](n) n!
mathématiques
[Link](x) |x|
[Link](x) ex
[Link](x) ln(x)
math.log10(x) log(x)
[Link](x,y) xy
1 Les modules [Link](x)
√
x
[Link](x) sin(x)
Python ore de très nombreuses bibliothèques de fonc- [Link](x) cos(x)
tions prédé nies pour réaliser des tâches courantes. On a [Link](x) tan(x)
déjà vu les fonctions input et print. D'autres fonctions sont [Link](x) arcsin(x)
regroupées dans ce qui s'appelle des modules. Contrairement [Link](x) arccos(x)
aux fonctions print et input qui sont accessibles directement,
[Link](x) arctan(x)
pour pouvoir utiliser une fonction d'un module, il est néces-
[Link] π
saire d'importer la fonction explicitement. Par exemple, pour
utiliser la fonction cos (cosinus) du module math : math.e e
math. oor(x) premier entier 6 x
1 from math import cos [Link](x) premier entier > x
2 print(cos(2.0))
Une autre bibliothèque fréquemment utilisée est la biblio-
La ligne from math import cos indique que la fonction thèque random. Elle permet de générer des nombres aléa-
cos est importée du module math. Si on souhaite importer toires avec notamment la fonction random() pour avoir un
toutes les fonctions du module math, on peut écrire : nombre ottant compris ente 0 et 1, la fonction randrange(n)
pour avoir un nombre entier aléatoire compris entre 0 et n,
la fonction randint(a,b) pour avoir un entier au hasard entre
1 from math import *
a et b.
Cette façon d'importer toutes les fonctions est pratique Application directe
quand on utilise l'interpréteur interactif, mais peu recom-
mandée dans les programmes, car elle nuit aux performances Créer une liste de 100 nombres aléatoires, compris
et à la lisibilité. La méthode recommandée est la suivante : entre 0 et 100. En sortie, on a chera cette liste sans
aucun doublon.
1 import math
import math importe le module math, mais les fonc- 2 La fonction
tions du module ne sont pas accessibles directement. Il faut
alors utiliser le pré xe math. pour désigner la fonction. 2.1 Utilité
Cette méthode permet d'avoir des modules diérents qui
contiennent chacun une fonction du même nom. Par exemple Lorsque l'on écrit des programmes, nous sommes souvent
les modules scienti ques numpy et math contiennent tous amenés à répéter plusieurs fois une même séquence d'instruc-
deux une fonction racine carrée sqrt mais celle du module tions. C'est fastidieux, surtout que des erreurs ne manquent
math est un peu moins puissante. Essayez : pas de se produire. Pour nous faciliter la vie, le langage dis-
pose d'une syntaxe qui permet de regrouper une séquence et
1 import math de la désigner par un mot unique, une fonction. Quand le
2 print([Link]([4,9,16])) programme commence à avoir de nombreuses lignes de code,
il devient aussi plus di cile pour un tiers de le comprendre.
et Mettre des fonctions qui exécutent des tâches particulières
1 import numpy as np #je renomme en plus numpy en tête du programme permet de le rendre plus compréhen-
2 print([Link]([4,9,16])) sible. Une fonction est dé nie par un nom, par ses arguments
qui porteront les valeurs communiquées par le programme
C'est pourquoi, pour les équations de fonctions dans les principal à la fonction au moment de son appel, et éventuel-
graphiques (dans une partie que nous verrons plus tard) le lement une valeur de retour communiquée au programme par
module numpy (ou le module scipy ) est recommandé. Mais la fonction en n d'exécution. L'ajout d'un commentaire est
le module math contient les principales fonctions mathéma- toujours un plus pour la clarté des choses.
tiques utiles pour les cas généraux. Un aperçu est donné ci- Admettons que je veuille récapituler une journée de cham-
contre. pionnat de Quidditch avec une feuille de score de la forme :
[Link] 12 Lycée Saint-Exupéry de Mantes-la-Jolie
La programmation python
2.3 Return
L'équipe de Appleby bat l'équipe de Ballycastle. On vient de voir une fonction qui ne retournait aucune
valeur, elle se contentait d'écrire. On peut cependant avoir
L'équipe de Caerphilly bat l'équipe de Chudley. besoin d'une fonction qui eectue un calcul et qui nous ren-
voie le résultat de ce calcul (une fonction qui a deux para-
L'équipe de Falmounth bat l'équipe de Holyhead. mètres u et v , abscisse et ordonnée d'un vecteur V~ et qui
nous renvoie la norme de ce vecteur). On utilisera alors le
L'équipe de Kenmare bat l'équipe de Montrose. mot-clé return.
1 import numpy as np
L'équipe de Puddlemere bat l'équipe de Tutshill. 2
3 def norme(u,v):
4 """Cette fonction renvoie la norme d'un vecteur
d'abscisse u et d'ordonnée v"""
La solution la plus primaire serait de faire une mé-
5 norme=[Link](u**2+v**2)
thode lourde, écrire 10 lignes commençant par print. On 6 return norme
peut également utiliser une boucle for qui parcourt une liste 7
avec des paires de noms d'équipe. 8 abs=3
9 ord=4
1 print("L'équipe de Appleby.....") 10 norme=norme(abs,ord)
2 print("--------------------------") 11 print("La valeur de la norme du vecteur({0},{1})
3 print( etc etc etc .... est {2}".format(abs,ord,norme))
4 #ou
5 for (i,j) in ([("Appleby","Ballycastle"),("
Caerphilly","Chudley")]): 4
! À savoir
6 print("L'équipe {} bat l'équipe {}.".format(i,j))
7 print("-----------------------------------") Il faut savoir que le mot-clé return peut se trouver au
milieu d'une fonction et non pas à la n. Cela pour ef-
La façon la plus élégante de procéder, dans un cas géné- fet d'interrompre la fonction dès qu'il est exécuté. Et
ral, reste de créer une fonction que l'on pourra appeler score pour être précis, une fonction avec un return est une
par exemple. Voyons comment faire. vraie fonction. Quand il n'y en a pas, cela s'appelle
une procédure.
2.2 Structure Exemple :
Une fonction est introduite par le mot-clé def, suivi du 1 def cube(w):
nom de la fonction, de ses paramètres entre parenthèses, 2 return w*w*w
de deux points, puis d'un bloc d'instructions. Ce bloc d'ins- 3 print("ceci ne sera jamais écrit")
tructions s'appelle le corps de la fonction. Il doit être indenté 4
et la n de ce bloc marque la n de la dé nition de fonction. 5 x=cube(9)
6 print(x)
1 def score(equipe1,equipe2):
2 """Cette fonction donne l'équipe gagnante d'une
3
rencontre de Quidditch"""
print("L'équipe de {} bat l'équipe de {}.".
2.4 Règles usuelles
format(equipe1,equipe2)) Quand on conçoit une fonction, il est préférable de lui
4 tiret=50*'-' donner un nom explicite, car elle est susceptible d'apparaître
5 print(tiret) à de nombreux endroits dans le programme. (On n'imagine
6
pas que les fonctions de la bibliothèque Python s'appellent
7
f1 , f2 , etc...). En revanche, les noms des arguments formels
8 #début du programme
peuvent être courts, car leur portée, et donc leur signi cation,
9 score("Appleby","Ballycastle")
est limitée au corps de la fonction.
Il convient par ailleurs de documenter convenablement
L'instruction de la ligne 9, score (...), qui est dans le corps les fonctions, en spéci ant les hypothèses faites sur les argu-
du programme appelle la fonction score. Organiser un pro- ments formels, leurs relations avec le résultat renvoyé, mais
gramme à l'aide de fonctions permet d'éviter les répétitions aussi les eets de la fonction (a chage, etc.) le cas échéant.
de lignes de code. Cela rend les programmes plus clairs et Python propose un mécanisme pour associer une documenta-
plus faciles à lire : pour comprendre le programme, il n'est tion à toute fonction, sous la forme d'une chaîne de caractères
pas nécessaire de savoir comment la fonction score est pro- entre triple quote, placée au début du corps de la fonction.
grammée, il su t de savoir ce qu'elle fait. En n, cela permet
d'organiser l'écriture du programme. On peut décider d'écrire 4 ! À savoir
la fonction score un jour et le programme principal le lende-
main. On peut aussi organiser une équipe de manière à ce La documentation d'une fonction f peut être a chée
qu'un programmeur écrive la fonction score et un autre le en écrivant help(f).
programme principal.
[Link] 13 Lycée Saint-Exupéry de Mantes-la-Jolie
La programmation python
6 inutile()
1 def cube(w): 7 print(x)
2 """Renvoie la valeur de w élevée au cube"""
3 return w*w*w
4 Quand on crée une variable dans une fonction, on n'a
5 help(cube) pas à se préoccuper de savoir si ce nom a été utilisé dans le
programme principal. Par contre, il se peut que nous ayons
Application directe besoin que notre fonction modi e la variable x du programme
principal.
Écrire une fonction qui prend en arguments deux en- Premier essai :
tiers n > 0 et d > 0 et qui renvoie un couple formé du
quotient et du reste de la division euclidienne de n par 1 def inutile(a):
d. Le quotient et le reste seront calculés par soustrac- 2 x=a+3
tions successives. Une documentation sera comprise 3 print(x)
4
dans la fonction. 5 x=5
6 inutile(x)
7 print(x)
3 Variable locale et variable globale
La variable globale x est bien envoyée en argument dans
Lorsque nous initialisons des variables au début d'un pro- la fonction inutile(). J'obtiens juste que la variable locale x
gramme, celles-ci sont dites des variables globales, elles sont prend la valeur 8. Mais la variable globale x reste à 5. C'est
donc accessibles à l'intérieur d'une fonction. un échec.
1 def inutile(): Deuxième essai : utilisation de return
2 print(x)
3 1 def inutile(a):
4 x=5 2 x=a+3
5 inutile() 3 print(x)
4 return x
Ici, dans la fonction, la variable x est inconnue, l'inter- 5
6 x=5
préteur va donc voir dans le programme si la variable existe.
7 x=inutile(x)
Par contre, quand une variable est dé nie à l'intérieur d'une 8 print(x)
fonction celle-ci n'existe que pour cette fonction.
1 def inutile(): On a bien modi é la variable globale x avec une fonction.
2 x=1
Cette méthode est à privilégier mais il existe une solution
3 print(x)
4
plus simple qui peut aussi être source d'erreurs di cilement
5 x=5 identi ables.
6 inutile() Troisième essai : global
La variable x est une variable locale puisqu'elle est dé - 1 def inutile(a):
nie dans la fonction, c'est elle qui sert dans le print(). Il y a 2 global x
une variable locale x et une variable globale x. Aucun con it. 3 x=x+a
Deux entités x coexistent. 4 print(x)
5
Maintenant si on fait :
6 x=5
1 def inutile(): 7 inutile(x)
2 print(x) 8 print(x)
3 x=1
4
5 x=5
6 inutile() 4
! À savoir
On voit qu'il y a un problème, la variable locale x est De façon générale, une bonne pratique consiste à
dé nie mais après son appel dans la fonction print(). La va- utiliser les variables globales pour représenter les
riable locale est prioritaire par rapport à la variable globale constantes du problème. En pratique, on ne devrait
du même nom. Pour illustrer cette notion d'indépendance, pas recourir souvent à la construction global de Py-
essayez : thon. Comme pour les fonctions, il est préférable de
donner aux variables globales des noms longs et expli-
1 def inutile(): cites, ce qui les distinguera de fait des variables locales
2 x=1 qui portent habituellement des noms courts (comme
3
les paramètres formels).
4 x=5
5 print(x)
[Link] 14 Lycée Saint-Exupéry de Mantes-la-Jolie
La programmation python
Application directe Application directe
Que donne en sortie le programme suivant : Écrire un programme qui donne les termes de la suite
1 def fct1():
de Fibonaccien utilisant la récursivité :
2 global x u0 = 1
3 x=x+8 u1 = 1
un = un-1 + un-2 si n > 2
4 x=12
5 def fct2():
6 x=3 Que se passe-t-il si on augmente n, par exemple
7 n = 50 ? Comparez avec une méthode non-récursive.
8 x=5
9 fct1() La performance doit toujours être votre priorité. Par
10 fct2() conséquent, la récursivité n'est pas toujours la meilleure ma-
11 print(x) nière de faire. Par contre, c'est une notion essentielle quand
on veut dessiner des fractales en utilisant le module de dessin
Turtle de Python.
La plus connue des fractales est le ocon de Koch. On
part d'un triangle, donc trois côtés. Chaque côté est divisé
4 Ordre d'évaluation en trois segments et on remplace le segment du milieu par
deux autres segments qui forment un triangle équilatéral et
L'ordre dans lequel les arguments d'une fonction sont éva- ainsi de suite....
lués a une in uence sur le résultat. Véri ez que Python éva- Je donne une version Python du ocon de Koch avec les
lue les arguments d'une fonction de la gauche vers la chiers joints pour ceux qui veulent essayer.
droite.
1 n = 1
2 def fct1(x):
3 global n
4 n = n+5
5 return x + n
6 def somme(x, y):
7 return x + y
8 x=somme(fct1(1),n)
9 print(x)
Montrer qu'une évaluation de la droite par la gauche des
arguments aurait donné un résultat diérent.
5 Récursivité
En programmation, rien n'interdit d'appeler une fonction
f à l'intérieur de la fonction f elle-même. La fonction f est
dite alors récursive.
√Considérons la suite (un ) qui calcule une approximation
de 3 :
u0 = 2
1 3
u1 = un-1 +
2 un-1
Cette suite peut être calculée à l'aide d'une fonction qui
suit directement la dé nition ci-dessus :
1 import numpy as np
2 def racine(n):
3 if n == 0:
4 return 2.
5 else:
6 return 0.5 * (racine(n-1) + 3 / racine(n-1))
7
8 print(racine(4))
9 print([Link](3))
[Link] 15 Lycée Saint-Exupéry de Mantes-la-Jolie
La programmation python
Quand on va voir ce que contient notre chier avec un
éditeur de texte, on remarque que le mot Lampe est bien
écrit. Si on veut s'éviter la peine d'écrire cette dernière ligne
avec le close, on peut adopter une autre syntaxe :
Chapitre IV 1 with open('[Link]','a') as objet:
Les chiers 2
[Link]('Table')
Et là, avec l'éditeur de texte, on voit que le nouveau mot
est bien ajouté mais qu'il est collé au premier. On va ajouter
avec l'éditeur une deuxième ligne dans le chier [Link]
qui contient un seul mot : Chaise. On enregistre et on re-
On va commencer ici à aborder des notions essentielles ferme le chier. On passe à la lecture.
pour le professeur de physique. Par exemple, dans les nou-
veaux programmes de seconde, on demande explicitement
dans le B.O que l'élève maîtrise des capacités numériques
spéci ques telles que la représentation des positions succes- 2 Lecture et écriture
sives d'un système modélisé par un point lors d'une évolution
unidimensionnelle ou bidimensionnelle à l'aide d'un langage On ouvre et on lit le chier avec Python très facilement :
de programmation et la représentation des vecteurs vitesse
d'un système modélisé par un point lors d'un mouvement à 1 with open('[Link]','r') as text: # 'r' pour
l'aide d'un langage de programmation. lecture
2 print([Link]())
Ce que l'on va faire ici marchera dans tous les
cas, mais nous verrons une méthode beaucoup La méthode readlines appliquée à l'objet que j'ai nommé
beaucoup plus simple ensuite si les données ont text cette fois, permet de lire tout le chier. Dans la console,
été exporté d'une façon facilement exploitable. on peut lire quelque chose comme :
1 ['LampeTable\n', 'Chaise']
1 Ouverture et fermeture On obtient une liste dont chaque élément est une chaîne
L'ouverture d'un chier se fait avec cette ligne : de caractères. On remarque dans l'élément zéro, un \n. C'est
un caractère invisible pour un éditeur de texte qui représente
1 variable=open("chemin_complet","mode en ouverture") un saut de ligne. Donc en Python, si on veut écrire une nou-
velle ligne dans un chier, nous devons taper :
Dès que l'on ouvre un chier ainsi, il faut écrire sa ferme-
ture, cela évitera un oubli possible. 1 with open('[Link]','a') as objet:
2 [Link]('\nArmoire')
1 [Link]()
Il existe également une autre méthode de lecture qui s'ap-
mode eet pelle readline. C'est une méthode pas à pas, une seule ligne
'r' mode lecture seule est lue à chaque fois.
'w' mode écriture, chier crée sinon écrasé
chier crée sinon données ajoutées en n 1 with open('[Link]','r') as text: # 'r' pour
'a' lecture
de chier
2 print([Link]())
La première chose que l'on va faire sera de créer un -
chier qui n'existe pas encore, comme cela il sera placé dans Si on veut lire les trois lignes :
le même dossier que notre programme Python.
1 objet=open('[Link]','w') 1 with open('[Link]','r') as text: # 'r' pour
2 [Link]() lecture
2 for i in range(3):
Quand vous exécutez ces deux lignes, un chier texte ap- 3 print('Sur la ligne {} on peut lire {}'.format(i
,[Link]()))
paraît. Si on l'ouvre avec un éditeur de texte, on constate
qu'il est vide. Maintenant on va le remplir en l'ouvrant en
mode a , on veut ajouter des données et non écraser ce On remarque que chaque ligne est considérée comme une
qui existe même si il n'y a rien pour l'instant. chaîne de caractère, le \n n'est plus a ché mais il est exé-
cuté car dans la console il y a un espace d'une ligne entre
1 objet=open('[Link]','a')
2 [Link]('Lampe')
chaque ligne.
3 [Link]()
[Link] 16 Lycée Saint-Exupéry de Mantes-la-Jolie
La programmation python
Application directe 14 #on parcourt la liste erreur à l'envers pour que
les index ne changent pas
Écrire un programme qui écrit dans un chier le ré- 15 for k in erreur[::-1]:
sultat de 10 000 lancers de 3 dés ainsi que la somme, 16 [Link](k)
du style : 17 for i in range(len(texte)):
18 texte[i]=texte[i].split(';')
Lancer ;dé 1 ;dé 2,dé 3 ;somme 19 for i in range(len(texte)) :
1 ;5 ;3 ;3 ;11 20 for j in range(len(texte[i])):
2 ;2 ;6 ;1 ;9 21 texte[i][j]=eval(texte[i][j])
3 ;1 ;1 ;1 ;3 22
23 #on transforme la liste en tableau numpy plus
pratique
24 tableau=[Link](texte)
3 Traitement 25
26
print(type(tableau))
#on extrait la premiere colonne avec :
27 temps=tableau[::1,0]
Dans le chapitre suivant, on abordera les graphiques. Pour
28 X=tableau[::1,1]
tracer un graphique, il nous faut, au minimum, deux listes de 29 Y=tableau[::1,3]
points, une pour les abscisses, une autre pour les ordonnées.
Nous allons partir d'un exemple réel avec un chier .txt qui Si on introduit des fonctions (dont deux pour sauvegarder
rassemble les données obtenues lors d'un pointage vidéo avec notre chier sans erreur de deux manières diérentes), cela
Latis-Pro. Cet exemple est formateur car il y a une image devient :
manquante sur la vidéo pointée donc une erreur dans une
ligne corrompue dans le chier .txt. 1 import numpy as np
2
3 def ouverture():
4 """On ouvre le fichier qui nous intéresse"""
5 with open('fichier_pointvirgule.txt',"r") as
fich:
6 texte=[Link]()#on utilise le
parcours de l'objet fich
7 return texte
8
9 def erreur(texte):
10 erreur=[]
11 liste=["0","1","2","3","4","5","6","7","8","9","
.",";","-"]
12 for i in range(len(texte)) :
13 texte[i]=texte[i].replace("\n","")
14
15 for j in range(len(texte[i])):
16 if not texte[i][j] in liste:
17
18 if not i in erreur:
19 [Link](i)
20 return erreur
21
22 def elimination(texte,erreur):
23 """fonction qui élimine les lignes erronnées,on
parcourt la liste erreur à l'envers pour
que les index ne changent pas"""
Voici une façon de faire : 24 for k in erreur[::-1]:
25 [Link](k)
1 import numpy as np 26 return texte
2 liste=["0","1","2","3","4","5","6","7","8","9",".", 27
";","-"] 28 def creation_liste(texte):
3 erreur=[] 29 for i in range(len(texte)):
4 30 texte[i]=texte[i].split(';')
5 with open('fichier_pointvirgule.txt',"r") as fich: 31 for i in range(len(texte)) :
6 texte=[Link]()#on utilise le parcours de 32 for j in range(len(texte[i])):
l'objet fich 33 texte[i][j]=eval(texte[i][j])
7 for i in range(len(texte)) : 34 return texte
8 texte[i]=texte[i].replace("\n","") 35
9 for j in range(len(texte[i])): 36 def creation_tableau(texte):
10 if not texte[i][j] in liste: 37 """on transforme la liste en tableau numpy plus
11 if not i in erreur: pratique"""
12 [Link](i) 38 tab=[Link](texte)
13 39 return tab
[Link] 17 Lycée Saint-Exupéry de Mantes-la-Jolie
La programmation python
40 nombres de lignes d'en-tête. Il existe aussi dtype qui peut être
41 utile pour préciser le type de variable de chaque colonne car
42 def sauvegarde(texte): c'est le type oat qui est par défaut. Vous pourrez revenir
43 """Sauvegarde à partir de la liste créee""" à cette partie quand j'utiliserai dtype pour convertir une co-
44 with open('[Link]','w') as fich: lonne où le temps sera à convertir sur l'exemple de la marée
45 [Link]('Temps;Mouvement X;Temps;Mouvement
dieppoise.
Y\n')
46 for i in range (len(texte)):
47 [Link](str(texte[i])+'\n') Application directe
48
49 Le traitement du chier [Link] donnera
50 def sauvegarde2(texte): une représentation correcte des vecteurs vitesse mais
51 """"On sauvegarde notre fichier expurgé des pas des vecteurs accélération. Aussi votre mission,
erreurs à partir de la liste de liste""" si vous l'acceptez, sera de créer un chier de don-
52 with open('[Link]',"w") as fich: nées d'une chute libre à partir des équations horaires.
53 for i in range (len(texte)): Sauvegardez-le sous le nom de mon_ [Link] ,
54 for j in range(len(texte[i])):
nous l'utiliserons pour étudier la relation approchée
55 [Link](str(texte[i][j])+';')
56 [Link]('\n')
entre la variation du vecteur vitesse d'un système mo-
57 ##########début du programme############ délisé par un point matériel entre deux instants voi-
58 premier_traitement=ouverture() sins et la somme des forces appliquées sur celui-ci
59 lignes_erronnees=erreur(premier_traitement) (programme première spécialité).
60 deuxieme_traitement=elimination(premier_traitement,
lignes_erronnees)
61 sauvegarde(deuxieme_traitement)
62 liste=creation_liste(deuxieme_traitement)
63
64 sauvegarde2(liste)
65 tableau=creation_tableau(liste)
66
67 #on extrait la premiere colonne avec :
68 temps=tableau[::1,0]
69 X=tableau[::1,1]
70 Y=tableau[::1,3]
Ici, on pourrait enlever la ligne avec un éditeur de texte
car il y a peu de lignes de donnée cependant plus tard nous
représenterons la hauteur d'eau au marégraphe de Dieppe. La
hauteur est mesurée toutes les dix minutes du 01 septembre
2018 au 31 décembre 2018 soit plus de 17 000 points donc si
une erreur existe, il sera di cile de l'identi er. Cependant,
partir du principe que nos chiers ne sont pas corrompus est
source de simpli cation. En outre, dans la littérature py-
thonnesque , on ne fait pas grand cas d'une autre façon de
faire. Or, comme c'est ma préférée, je vais l'évoquer.
4 [Link]
Les données que nous utilisons sont disposées de façon
régulière. Une colonne pour le temps, une pour des abscisses
des points, une pour des ordonnées des points, le tout séparé
par ; , , ou une tabulation. Ouvrons le chier de don-
nées du pointage vidéo expurgé [Link] pour extraire
les valeurs.
1 import numpy as np # le module numpy est renommé np
2 Temps,X,Y=[Link]('[Link]',delimiter=';',
unpack=True,usecols=(0,1,3),skiprows=1)
Temps,X et Y sont directement extraits du chier et ex-
ploitables, ce ne sont pas des listes mais des tableaux d'une
seule dimension. delimiter permet d'indiquer comment les co-
lonnes sont séparées, unpack=True indique que l'on veut les
séparer, usecols permet de choisir la séquence de colonnes que
l'on souhaite utiliser, skiprows permet d'éliminer un certains
[Link] 18 Lycée Saint-Exupéry de Mantes-la-Jolie
La programmation python
[Link](start,stop,num) qui génère un tableau
de num valeurs qui commence à start et qui nit à stop.
1 import [Link] as plt
import numpy as np
Chapitre V 2
3
Les graphiques
4 x=[Link](1,11,1) # 10 valeurs de 1 à 10
5 y=[Link](1,100,10)
6 print(x,y)
7 [Link](x,y)
8 [Link]()
1 Les bases
Il est possible avec Python de créer un graphique. Le mo-
2 Les options de plot
dule matplotlib a tous les outils graphiques utiles pour les
tracés de fonctions. Le module numpy possède quant à lui Entre les parenthèses du mot-clé plot nous avons seule-
tout un arsenal de fonctions prédé nies très utiles. On veut, ment indiqué les deux paramètres essentiels, x et y. Or, on
par exemple, tracer la fonction f dé nie par f (x) = x. peut ajouter de nombreuses options au plot. Vous allez voir
que tout est paramétrable.
1 import [Link] as plt # le module pyplot
L'écriture est la suivante :
est renommé plt
2 import numpy as np # le module numpy est renommé np
[Link]( abscisse, ordonnée, "couleur stylepoint styletrait ",
3 x=[Link](10) #crée un tableau de 10 valeurs é
paramètres ).
quiréparties commençant à 0. couleur : première lettre anglaise de la cou-
4 y=x leur(b,g,y,c,r,m,w ou k pour le noir).
5 print(x) #facultatif stylepoint : liste ci-dessous.
6 print(y) #facultatif styletrait : ' :' pointillé, '-' ligne continue, '-.'point tiret, '- -'
7 [Link](x,y) # Trace la fonction mais ne montre
ligne de tirets, ',' pixel, 'v' triangle.
pas le graphique.
paramètres : cela peut être l'épaisseur du trait (line-
8 # on peut écrire également [Link](x,x)
9 [Link]() # Affiche le graphe.
width= ottant) et/ou une légende (label="ce qui doit être
écrit"). Il existe aussi markersize ou ms, markeredge-
Cela peut paraître curieux d'avoir une fonction qui trace color ou mec, markerfacecolor ou mfc... Tout est listé
la fonction et une autre qui a che le graphe mais c'est utile sur https ://[Link]. Il faut essayer, échouer, ré-
quand on a plusieurs courbes lourdes. On les charge toutes essayer, chercher mais au nal il y a toujours une solution
tranquillement en mémoire puis on les a che toutes avec pour ce que vous voulez entreprendre.
[Link](). Regardez ce que signi e markeredgecolor ou markerface-
Si tout se passe correctement, vous devriez voir votre color :
graphe avec un axe horizontal, un axe vertical et la courbe
en bleu. S'il y a plusieurs courbes, chacune aura une couleur 1 import [Link] as plt
2 import numpy as np
diérente.
À noter qu'il existe une autre façon de faire, qui est plus 3
4 x=[Link](1,100,30)
simple mais que j'utilise peu, non par préférence mais par 5 [Link](x,[Link](x),"b+:",markeredgecolor='r')
habitude. Spyder aime moins aussi, même si tout se passe 6 [Link]()
bien à l'exécution, il y a beaucoup de signaux 4! qui appa-
raissent. Je vous la livre quand même, vous ferez votre choix
vous-même.
1 import [Link] as plt
1 from pylab import * 2 import numpy as np
2 3
3 x=arange(10) #crée un tableau de 10 valeurs équiré 4 x=[Link](1,100,30)
parties commençant à 0. 5 [Link](x,[Link](x),"bo:",mec='g',ms=15,mfc='c',
4 y=x mew=5)
5 plot(x,y) # Trace la fonction mais ne montre pas le 6 [Link]()
graphique.
6 show() # Affiche le graphe.
Attardons-nous sur [Link](start,stop,step). 4
! À savoir
Cela permet de générer un tableau de valeurs qui in-
En promenant la souris sur le graphique, les coordon-
clut la valeur en start mais qui exclut la valeur en stop.
nées du pointeur sont inscrites en bas de la fenêtre.
L'écart entre deux valeurs étant xé par step. Cela fonc-
tionne très bien avec un step entier. Sinon on préférera
[Link] 19 Lycée Saint-Exupéry de Mantes-la-Jolie
La programmation python
paramètre marqueur Application directe
x une croix
X une croix pleine Mo er le programme pour a cher un graphe comme
+ un plus celui ci-dessous.
P un plus plein 1 import [Link] as ... # Le module
. un pixel pyplot est renommé plt
o un rond 2 import numpy as ... # Le module numpy est
1 tri_ bas renommé np
2 tri_ haut 3 x=[Link](.....) # Crée un tableau de
3 tri_ gauche valeurs de x=0 à 50 avec deltax=0.50.
4 tri_ droite 4 y=..... # On trace sinus x
5 [Link](x,y) # Trace la fonction comme le
triangle pointe en haut montre l'image ci-dessous
v triangle pointe en bas 6 ..... # Affiche le graphe.
> triangle pointe droite
< triangle pointe gauche
p pentagone
h hexagone
H autre hexagone
* étoile
d carreau
D carreau plus gros
| barre verticale
_ barre horizontale
4 ! Si vous utilisez une légende avec label, rien ne sera
a ché sans écrire une ligne qui appelle la légende. Si on ap-
pelle le module pyplot avec le raccourci plt, il faudra ajouter
[Link]() :
1 import [Link] as plt
2 import numpy as np
3
4 x=[Link](1,100,30)
5
6
[Link](x,[Link](x),"b+:",label=r'$y=log(x)$')
[Link]() 3 Les méthodes
7 [Link]()
Nous allons ici voir comment faire de beaux graphiques en
utilisant quelques lignes de code particulières. Il n'y a pas de
On verra, un peu plus loin, comment faire autrement meilleures façons d'apprendre qu'en essayant par vous-même.
mais dans un premier temps, faisons simple. Entre les paren- On veut, par exemple, tracer la fonction f (x) telle que :
thèses de legend, on peut aussi mettre des paramètres. Voici
quelques paramètres possibles , la liste est non-exhaustive et x ∈ [−5; 5]
(
consultable toujours sur internet sur le site cité plus haut : 1
f (x) = x3 + 3x2 + 1
2
paramètre marqueur 1 import [Link] as plt # On renomme le
au mieux, haut droite tout "plt".
0,1...10 import numpy as np # Le module numpy est renommé np
...centre 2
fontsize= taille .
3 x=[Link](-5,5,100) # la courbe est tracée à
fancybox=True or
boîte arrondie ou pas partir de 100 points sur [-5;5].
False 4 [Link](x,x**3/2-3*x**2+1,label='f(x)')
Shadow=True or [Link]()
ombre sous la boîte 5
False 6 [Link]()
facecolor= couleur du fond de la boîte
edgecolor= couleur du contour
title= titre de la boîte Application directe
title_fontsize= taille du titre
nombre de colonne occu- Ci-contre, le résultat le plus basique, à vous de l'en-
ncol=
pée richir avec les possibilités listées dans le tableau qui
suit.
[Link] 20 Lycée Saint-Exupéry de Mantes-la-Jolie
La programmation python
2 import numpy as np # le module numpy est renommé np
3
4 x=[Link](10) # on crée un tableau de 10 valeurs
équirépartie commençant à 0.
5 [Link](x,x,'r',label='y=x') # Je crée une courbe
d'équation y=x.
6 [Link](x,x*x,'k',label='x2 ') #y=x*x
7 [Link]('axe des abscisses')
8 [Link]('axe des ordonnées')
9 [Link]('Graphique de ouf')
10 [Link]()
11 [Link]() # Affiche le graphe.
Il est intéressant d'avoir une légende des diérents tra-
cés. C'est possible avec la fonction [Link]() qui s'utilise
ainsi :
[Link](loc= 'position de la légende'(,autres
options possibles)
Instructions Signi cations
Crée une matrice ligne de N va- On peut mettre comme position : 'best'(ou 0), 'upper
[Link](a,b,N) right'(ou 1),'lower left'(ou 4) etc. . .
leurs régulièrement espacées.
Trace la fonction f de variable Il se peut que l'on veuille mettre la légende hors du cadre,
[Link](x,f(x)) on ajoute alors des options à legend.
x.
[Link]() A che le graphique. 1 from matplotlib import pyplot as plt # le module
[Link]() Eace la fenêtre graphique. pyplot est renommé plt
[Link]([xmin,xmax, Spéci e la fenêtre de représen- 2 import numpy as np # le module numpy est renommé np
ymin,ymax]) tation. 3 x=[Link](10) # on crée un tableau de 10 valeurs
Sauvegarde le graphique en for- équirépartie commençant à 0.
[Link] g() [Link]("Légende hors du graphe") # On crée un
mat png par défaut. 4
Ajoute le titre texte au gra- graphe 1
[Link](texte ) 5 [Link](x,x,'r',label='y=x')
phique. 6 [Link]('axe des x')
A che texte sur l'axe des abs- [Link]('axe des y')
[Link](texte ) 7
cisses. 8 [Link](loc=2,bbox_to_anchor=(1.01,1),
A che texte sur l'axe des or- borderaxespad=0.)
[Link](texte )
données. 9 plt.tight_layout() #utile pour que la légende ne
A che texte à la position soit pas coupée
[Link](x,y,texte ) [Link]()
(x, y). 10
Permet d'avoir une grille ou
[Link](True/False)
pas.
[Link]() Permet d'a cher la légende.
5 Multiplot
Vous noterez qu'en ajoutant un r devant la chaîne Il est souvent utile de pouvoir a cher plusieurs graphes
de caractères, on peut a cher des formules mathé- pour les comparer. Il y a deux possibilités, soit on fait une
matiques pour peu que l'on connaisse un minimum fenêtre avec deux graphes ou plus, soit deux fenêtres ou plus
la syntaxe LATEX. On est plus dans le domaine de avec un graphe soit un mixte des deux.
l'esthétisme qu'autre chose ! Voici un exemple de ce
que l'on peut ajouter :
5.1 Deux fenêtres contenant une gure
[Link](0,-80,r'$y=\frac{1}{2}x^3-3x^2+1$')
[Link]='abscisse' 1 from matplotlib import pyplot as plt # le module
[Link]='ordonnée' pyplot est renommé plt
2 import numpy as np # le module numpy est renommé np
3 x=[Link](10) # on crée un tableau de 10 valeurs
équirépartie commençant à 0.
4 Plusieurs courbes sur un graphe 4 [Link]('Exemple 1') # On crée une première fenê
tre appelée exemple 1
5 [Link](x,x,'r')
Voici comment créer une gure qui accueillera le graphe, 6 [Link]("Exemple 2") # une deuxième
les courbes, les axes et un titre. 7 [Link](x,x*x,'g+--')
8 [Link]()
1 from matplotlib import pyplot as plt # le module
pyplot est renommé plt
[Link] 21 Lycée Saint-Exupéry de Mantes-la-Jolie
La programmation python
5.2 Une fenêtre contenant deux gures Application directe
Cette partie est importante car elle est également valable
À partir du chier [Link], représenter la phase
quand on ne fait qu'un seul graphe sur une fenêtre graphique.
et le gain en fonction de la fréquence. C'est un vrai -
C'est la façon la plus rigoureuse de procéder et celle que je
chier issu de mesures. Par contre, l'exportation très
vais adopter le plus souvent. Il y a deux possibilités, soit
capricieuse rend l'exploitation un peu plus compli-
on utilise subplot soit subplots. Un s en plus et tout
quée, je n'ai malheureusement pas pu faire mieux. Je
change.
ne vais pas trop m'en plaindre non plus, c'est plutôt
formateur. Il faut commencer par retravailler ce chier
5.2.1 subplot pour qu'il soit exploitable. Un programme d'une quin-
zaine de lignes su ra pour tout remettre dans l'ordre.
1 from matplotlib import pyplot as plt # le module Ensuite, faire le programme qui traitera les données.
pyplot est renommé plt
2 import numpy as np # le module numpy est renommé np
3
4 x=[Link](10) # on crée un tableau de 10 valeurs
équirépartie commençant à 0.
5 fig=[Link]("découpage de fenêtre",figsize
=(12,6),facecolor='w')#taille en pouce et
couleur du fond
6 graphe1=fig.add_subplot(121) #graphe 1
7 [Link](x,x,'r')
8 graphe2=fig.add_subplot(122) #graphe 2
9 [Link](x,x*x,'g')
10 [Link]()
La méthode .add_subplot(xyz) subdivise la fenêtre en x
ligne(s) et y colonne(s) soit (x × y) cases. Chaque case est
numérotée, z est le numéro de la case où je veux mettre un
graphique. La numérotation se fait de gauche à droite puis
de haut en bas, en commençant par 1.
5.2.2 subplots
1 from matplotlib import pyplot as plt # le module
pyplot est renommé plt
2 import numpy as np # le module numpy est renommé np
3
4 x=[Link](10) # on crée un tableau de 10 valeurs
équirépartie commençant à 0.
5 fenetre,(graphe1,graphe2)=[Link](2,1,figsize
=(12,6))
6 [Link](x,x,'r')
7 [Link](x,x*x,'g')
8 [Link]()
C'est un exemple simple. Vous en verrez de nombreux
autres ensuite puisque j'utiliserai les deux méthodes (subplots
et subplot ).
6 Le plot logarithmique
Ceci est le diagramme de Bode quand la ligne est ouverte
En classe préparatoire, on trace des fonctions de transfert
en sortie, à vide. On pourrait refaire la même étude avec une
et, pour cela, on doit utiliser du papier semi-logarithmique.
ligne fermée, cela revient à mettre une résistance de 600 Ω
Avec Python, si on veut faire un graphe logarithmique ou
en sortie.
semi-logarithmique, trois fonctions de plot logarithmique
sont à notre disposition :
• semilogx : axe des ordonnées linéaire et axe des abs- 7 Marée dieppoise
cisses logarithmique.
• semilogy : axe des abscisses linéaire et axe des ordon- Le traitement des données en lui-même est court. Le plus
nées logarithmique. long est le côté esthétique. On peut enlever l'appel à la fonc-
• loglog : axes des ordonnées et des abscisses logarith- tion embellissement pour le constater. Je vous laisse le copier,
miques. l'exécuter, l'analyser :
[Link] 22 Lycée Saint-Exupéry de Mantes-la-Jolie
La programmation python
43 fenetre,(graphe,graphe2)=[Link](2,1,figsize
1 import numpy as np =(12,6))
2 import [Link] as plt 44 [Link].set_window_title("La marée dieppoise
3 import [Link] as mdates ")
4 from datetime import datetime 45 graphe.plot_date(temps,hauteur,'g.-',markersize=1,
5 from [Link] import MultipleLocator markerfacecolor='blue') #axe qui contient des
6 dates
7 def embellissement(): 46 graphe2.plot_date(temps,hauteur,'g.',markersize=1,
8 #juste de la déco à partir d'ici markerfacecolor='blue') #axe qui contient des
9 graphe.tick_params(axis='x',labelsize=8, dates
labelrotation=45,colors='r',pad=1,length=4, 47
width=1) 48 embellissement()
10 graphe.tick_params(axis='y',labelsize=8, 49
labelrotation=45,colors='b',grid_color='b', 50 fenetre.tight_layout(pad=1,w_pad=5,rect
grid_alpha=0.5) =[0.05,0.05,0.95,0.95])
11 graphe.set_title('Hauteur d\'eau au marégraphe 51 [Link]()
de Dieppe en mètre',{'fontsize':12}) 52 [Link]('[Link]',dpi=1000)
12 graphe.set_xlabel('Année 2018',{'fontsize':8,'
color':'m'}) Voici ce que vous obtenez en exécutant le programme :
13 graphe.set_ylabel('Hauteur en mètre',{'fontsize'
:8,'color':'m'})
14 [Link].set_major_locator(mdates.
AutoDateLocator(minticks=3))
15 [Link].set_major_locator([Link]
(5))
16 [Link].set_minor_locator(MultipleLocator
(1))
17 [Link].set_major_formatter(mdates.
DateFormatter("%d/%m"))
18 [Link](True, which='major') #minor or
both
19 [Link](True)
20
21 graphe2.tick_params(axis='x',labelsize=8,
labelrotation=45,colors='r',pad=1,length=4,
width=1)
22 graphe2.tick_params(axis='y',labelsize=8,
labelrotation=45,colors='b',grid_color='b',
grid_alpha=1)
23 graphe2.set_title('Hauteur d\'eau au marégraphe
de Dieppe en mètre',{'fontsize':12})
24 graphe2.set_xlabel('Année 2018',{'fontsize':8,'
color':'m'})
25 graphe2.set_ylabel('Hauteur en mètre',{'fontsize
':8,'color':'m'})
26 graphe2.set_xlim(temps[300],temps[2500])
27 [Link].set_major_locator(mdates.
AutoDateLocator(minticks=3))
28 [Link].set_major_locator([Link]
(5))
29 [Link].set_major_formatter(mdates.
DateFormatter("%d/%m"))
30
31
32 temps=[]
33 dt=[Link]('U19,f')
34
Application directe
35
36 date,hauteur=[Link]('[Link]', Quand vous ouvrez le chier de données, vous re-
dtype=dt,delimiter=";",skiprows=14,usecols
marquez que la dernière colonne montre que les
=[0,1],unpack=True)
37
données proviennent de deux sources diérentes. À
38 for i in range (len(date)): vous d'adapter le programme pour ne visualiser que
39 item=date[i] les hauteurs issues de la source 4. Vous obtien-
40 [Link]([Link](item,"%d/%m/%Y %H drez quelque chose de signi cativement diérent pour
:%M:%S")) le deuxième graphe. La fréquence d'échantillonnage
41 commence a être limite.
42
[Link] 23 Lycée Saint-Exupéry de Mantes-la-Jolie
La programmation python
• À vous d'obtenir un graphique de ce genre.
• Tracer à présent l'étude énergétique par unité de masse
(énergie, potentielle, cinétique et mécanique) sur une même
fenêtre divisée en deux. Sur la partie du haut, l'étude d'un
corps sur Terre et sur la partie du bas, l'étude d'un corps sur
8 Applications la Lune.
8.1 Reproduire
Tracer dans une fenêtre graphique la courbe représenta-
tive C de la fonction f dé nie telle que :
∀x ∈ [−4; 8]
f (x) = x2 − 3x − 10
On a chera une grille sur le graphe, un titre, une légende.
La courbe est bleue, en pointillé et les points sont des +
rouges comme ci-après :
8.2 De la physique
Un corps, matérialisé par un point M de masse m, est
lâché sans vitesse initiale d'une hauteur h > 0. On étudie le
mouvement de M dans le référentiel R(0, x, y, z, t), supposé
galiléen. L'axe (0y) est dé nit verticalement par rapport au
sol et dans le sens ascendant. Le point M n'est soumis qu'à
la force de pesanteur. On note g la norme de l'accélération 8.3 La fractale du vieux chien
de pesanteur et on suppose ~g constant.
La deuxième loi de Newton s'écrit : Voici l'énoncé :
X
F~ext = m.~aG/R
[Link] 24 Lycée Saint-Exupéry de Mantes-la-Jolie
La programmation python
On veut représenter les diérentes concentrations au
Trois prisonniers, enchaînés en des points éloignés de cours du temps. On xe les concentrations initiales telles que
la cour d'un pénitencier, préparent un plan pour s'éva- [A]0 = 1, [B]0 = 0, [C]0 = 0 et (k1 , k2 ) = (1, 1) pour com-
der. À mi-chemin des deux premiers se trouve un chien mencer.
de garde, tenant dans sa gueule le trousseau de clés. Une possibilité :
Chacun des prisonniers agite alors un bel os pour at-
tirer le chien, qui choisit au hasard de se diriger lente-
ment vers l'un d'entre eux. Mais, arrivé à mi-chemin,
fatigué, le vieux chien s'arrête, creuse un trou et se
couche. Les prisonniers agitent alors de plus belle leurs
appâts : le chien se lève et avance à nouveau vers l'un
des prisonniers au hasard. Arrivé à la moitié du che-
min, il s'arrête, fait un nouveau trou et se couche...
L'opération se répète un très grand nombre de fois.
Si chaque trou est représenté par un point, essayez
de construire le graphe qui simule cette situation. Les
trois prisonniers peuvent être aux coordonnées suivantes :
A(0; 0), B(0.5; 1) et C(1; 0) et le chien au milieu du segment
[AB]
Avec 100 000 itérations, on obtient :
Ensuite sur un autre graphe, représenter la même chose
mais pour (k1 , k2 ) = (1, 10) et (k1 , k2 ) = (10, 1)
8.4 Cinétique chimique de réactions succes-
sives
On entend par réactions successives des réactions dont les
produits de la première sont les réactifs de la seconde. Une
telle suite de réactions met donc en jeu des molécules appe-
lées intermédiaires réactionnels, dont une caractéristique est,
le plus souvent, de ne pas pouvoir être isolés, du moins fa-
cilement. L'adjectif successives ne doit évidemment pas
être pris dans le sens où les réactions auraient lieu l'une après
l'autre.
L'exemple le plus simple est constitué de deux réactions
élémentaires monomoléculaires successives :
A B k1
B C k2
Ces réactions sont d'ordre 1 : leurs vitesses sont propor-
tionnelles à la concentration du réactif ou des réactifs. Les 8.5 Parabole de sûreté
équations cinétiques s'écrivent donc : On jette un projectile M à partir du point O(0 ;0) avec
une vitesse v0 constante, mais faisant un angle variable avec
d [A]
= −k1 . [A]
l'horizontale. Si le projectile est soumis seulement à la gra-
dt
vitation, la trajectoire est connue : ce sera une parabole. On
d [B]
= k1 . [A] − k2 . [B] démontre même de façon classique que l'ensemble des tra-
dt
jectoires est enveloppée par une parabole, dite de sûreté.
d [C] = k2 . [B]
Cet exercice a pour objet la visualisation de cette parabole.
dt
[Link] 25 Lycée Saint-Exupéry de Mantes-la-Jolie
La programmation python
Représenter une vingtaine de trajectoires
h avec des angles 4
! À savoir
πi
qui varient régulièrement sur un intervalle 0; et ajouter
2
la parabole de sûreté. J'ai passé sous silence angles et units car ces deux
options sont obligatoirement à mettre avec la valeur
'xy' pour avoir une représentation correcte des vec-
teurs vitesse et accélération.
Si on joue avec scale et la longueur du vecteur référence,
on obtient des représentations diérentes mais cohérentes.
9 Les vecteurs
Pour tracer les vecteurs, nous utiliserons la méthode qui-
ver() et pour la légende quiverkey(). Voici comment s'en
servir
avec un exemple simple, on trace le vecteur vitesse V~ :
1 import [Link] as plt
Pour l'obtenir, j'ai utilisé ce code :
2 x=1
3 y=1 1 import [Link] as plt
4 VecX=1 # vitesse selon x de 1 m/s 2 x=1
5 VecY=1.5 # vitesse selon y de 1.5 m/s 3 y=1
6 longvecref=1 4 VecX=0.5 # vitesse selon x de 1 m/s
7 fig=[Link]("Tracé d'un vecteur vitesse") 5 VecY=0.75 # vitesse selon y de 1.5 m/s
8 graphe=[Link](111) 6 longvecref=1
9 [Link]('equal') # repère orthonormé 7 fig=[Link]("Tracé d'un vecteur vitesse")
10 graphe.set_xlim(0,3) # valeurs limites pour axe des 8 graphe=[Link](221)
x 9 [Link]('equal') # repère orthonormé
11 graphe.set_ylim(0,3) # valeurs limites pour axe des 10 graphe.set_title('graphe 1: scale=1;longvecref=1')
y 11 graphe.set_xlim(0,3) # valeurs limites pour axe des
12 [Link](x,y,('b+')) # point aux coordonnées x x
et y 12 graphe.set_ylim(0,3) # valeurs limites pour axe des
13 vecteur=[Link](x,y,VecX,VecY,angles='xy', y
scale=1,units='xy',color='r') 13 [Link](x,y,('b+')) # point aux coordonnées x
14 [Link](vecteur,0.8,2.1,longvecref,label=r et y
'$échelle \ = 1 \ m.s^{-1}$',coordinates='data' 14 vecteur=[Link](x,y,VecX,VecY,angles='xy',
) scale=1,units='xy',color='r')
15 [Link]() 15 [Link](vecteur,2,0.7,longvecref,label=r'$
échelle \ = 1 \ m.s^{-1}$',coordinates='data')
On remarque les deux mots utiles pour tracer des vec- 16
teurs. Tout d'abord quiver qui permet de tracer le vecteur. 17 graphe2=[Link](222)
Il demande plusieurs arguments. En premier lieu, j'ai mis les 18 [Link]('equal') # repère orthonormé
coordonnées de départ du vecteur, x et y, ensuite les coor- 19 graphe2.set_title('graphe 4: scale=2;longvecref=1')
données du vecteur, éventuellement la couleur et l'échelle que 20 graphe2.set_xlim(0,3) # valeurs limites pour axe
j'ai choisie, 1 pour l'instant. On pourrait se contenter de qui- des x
ver cependant la longueur du vecteur permet de connaître 21 graphe2.set_ylim(0,3) # valeurs limites pour axe
la valeur de la vitesse, il nous faut donc ajouter une réfé- des y
22 [Link](x,y,('b+')) # point aux coordonnées x
rence. Pour cela, on utilise quiverkey qui a pour arguments
et y
l'instance créer par l'appel à quiver (j'ai choisi de la nom- 23 vecteur2=[Link](x,y,VecX,VecY,angles='xy',
mer vecteur ), ensuite les coordonnées où on souhaite a cher scale=2,units='xy',color='b')
notre échelle (fonction des axes x et y en précisant coordi- 24 [Link](vecteur2,2,2,longvecref,label=r'$
nates='data' ) et la longueur du vecteur référence (valeur ou échelle \ = 1 \ m.s^{-1}$',coordinates='data')
variable comme ici). En n, on ajoute un petit texte qui ac- 25
compagne ce vecteur référence. 26 graphe3=[Link](223)
[Link] 26 Lycée Saint-Exupéry de Mantes-la-Jolie
La programmation python
27
28
[Link]('equal') # repère orthonormé
graphe3.set_title('graphe 3: scale=0.5;longvecref=1
10 Encore des applications
')
29 graphe3.set_xlim(0,3) # valeurs limites pour axe 10.1 Analyse d'un pointage
des x
30 graphe3.set_ylim(0,3) # valeurs limites pour axe À partir du chier [Link], représenter les vecteurs
des y vitesse et vecteurs accélération. Sauvegarder votre graphe.
31 [Link](x,y,('b+')) # point aux coordonnées x
et y
32 vecteur3=[Link](x,y,VecX,VecY,angles='xy',
10.2 Triche
scale=0.5,units='xy',color='g')
À partir du chier d'une chute libre que vous avez créé
33 [Link](vecteur3,1.8,0.5,longvecref,label
=r'$échelle \ = 1 \ m.s^{-1}$',coordinates=' (mon_ [Link], représenter la variation du vecteur vitesse
data') d'un système modélisé par un point matériel entre deux ins-
34 tants voisins ainsi que la somme des forces appliquées sur
35 graphe4=[Link](224) celui-ci .
36 [Link]('equal') # repère orthonormé
graphe4.set_title('graphe 4: scale=2;longvecref=2')
37
38 graphe4.set_xlim(0,3) # valeurs limites pour axe 10.3 Rétrogradation de Mars
des x
39 graphe4.set_ylim(0,3) # valeurs limites pour axe À partir de l'image bitmap représentant les positions de
des y Mars et de la Terre à des intervalles de temps réguliers, re-
40 [Link](x,y,('b+')) # point aux coordonnées x présenter la rétrogradation de Mars.
et y
41 vecteur4=[Link](x,y,VecX,VecY,angles='xy',
scale=2,units='xy',color='c')
42 [Link](vecteur4,2,2,2*longvecref,label=r
'$échelle \ = 2 \ m.s^{-1}$',coordinates='data'
)
43 fig.tight_layout() # utile pour organiser aux mieux
les espaces entre graphes
44 [Link]('[Link]')
45 [Link]()
Application directe
Pendant 2 secondes, un point matériel de masse m
est en chute libre, dans un repère terrestre dans le-
quel l'accélération de pesanteur est dé nie par :
π
gx = g × cos
~g 4
π
gy = g × sin
4
Représenter les vecteurs vitesse d'une dizaine de
points.
[Link] 27 Lycée Saint-Exupéry de Mantes-la-Jolie
La programmation python
10.4 Dosage du vinaigre 10.5 Imitation
Reproduire graphiquement un document trouvé sur in-
À partir du chier [Link], représenter les ternet que je trouve particulièrement moche. Il s'agit d'un
courbes pH = f (V olume) et
d pH
= f (V olume) extrait du bac S de 2016 en Amérique du Sud.
dV
11 Modélisation
Dans le programme de seconde, il y a une partie où il
faut représenter un nuage de points associé à la caractéris-
tique d'un dipôle et modéliser la caractéristique de ce dipôle
à l'aide d'un langage de programmation. Pour se faire, j'uti-
lise le chier [Link] dans lequel l'intensité qui traverse un
conducteur ohmique est relevée pour diérentes tensions à
ses bornes. On peut employer .scatter plutôt que .plot puis-
qu'on ne veut pas relier tous les points mais modéliser par
une droite moyenne. Je vous présente, ici, trois façons dié-
rentes pour se faire :
[Link] 28 Lycée Saint-Exupéry de Mantes-la-Jolie
La programmation python
11.1 linregress 1
import [Link] as plt
2 import numpy as np
1 from [Link] import linregress 3 from [Link] import curve_fit
2 import [Link] as plt 4
3 import numpy as np 5 def func(x,a,b):
4
6 """ Fonction qui donne l'équation de la modé
5 U,I=[Link]('[Link]',skiprows=4,delimiter=';', lisation"""
unpack=True,usecols=(0,1)) 7 return a*x+b
6 fenetre,graphe=[Link](1,1,figsize=(8,10)) 8
7 [Link].set_window_title("Loi d'Ohm") 9
8 i=I/1000 #pour avoir des ampères 10 U,I=[Link]('[Link]',skiprows=4,delimiter=';',
9 [Link](i,U,marker='+',alpha=0.5) unpack=True,usecols=(0,1)) # on crée un tableau
10
de 10 valeurs équirépartie commençant à 0.
11 (a,b,rho,_,_)=linregress(i,U) 11 fenetre,graphe=[Link](1,1,figsize=(8,10))
12 [Link](i,a*i+b,'g-',label=r'$modélisation \ : 12 [Link].set_window_title("Loi d'Ohm")
\ U=%.1f*I+%.3f$'%(a,b)) 13 i=I/1000 #pour avoir des ampères
13 graphe.set_xlabel('Intensité dans la résistance en 14 [Link](i,U,marker='+',alpha=0.5)
Ampère') 15 popt,pcov=curve_fit(func,i,U)
14 graphe.set_ylabel('Tension aux bornes de la ré 16 [Link](i,func(i,*popt),'b--',label='fit a=%.3f
sistance') , b=%.3f'%tuple(popt)) #insister sur l'étoile
15 graphe.set_title('Loi d\'Ohm') 17 graphe.set_xlabel('Intensité dans la résistance en
16 [Link](0,8,"corrélation=%.3f"%rho,style=' Ampère')
italic') 18 graphe.set_ylabel('Tension aux bornes de la ré
17 [Link]() sistance')
18 [Link]() 19 graphe.set_title('Loi d\'Ohm')
20 [Link]()
La fonction linregress retourne 5 variables mais seules les 3 21 [Link]()
premières sont intéressantes (pente, ordonnée à l'origine et
c÷ cient de corrélation rho) d'ou (a,b,rho,_,_). On uti- Mais dans celui-ci, c'est nécessaire :
lise ensuite a etb pour tracer la droite.
1 import [Link] as plt
2 import numpy as np
11.2 poly t 3 from [Link] import curve_fit
4 def func(x,a,b):
Méthode adaptée pour modéliser par une fonction poly- 5 return [Link](a*x+b)
nomiale. Avec un degré 1, on arrive à une fonction a ne. 6
1 import [Link] as plt 7 xData=[Link](0,20,50)
2 import numpy as np 8 [Link](5468) #on plante la graine pour
3
avoir toujours les memes valeurs dans yBruit
4 U,I=[Link]('[Link]',skiprows=4,delimiter=';', 9 yBruit=[Link](size=[Link])*0.08 #crée
unpack=True,usecols=(0,1)) # on crée un tableau des petites fluctuations
de 10 valeurs équirépartie commençant à 0. 10 yData=func(xData,0.5,1)+yBruit
11
5 fenetre,graphe=[Link](1,1,figsize=(8,10))
6 [Link].set_window_title("Loi d'Ohm") 12 [Link](xData,yData,'g+')
7 i=I/1000 #pour avoir des ampères 13 popt,pcov=curve_fit(func,xData,yData,p0=[0.7,30]) #
8 [Link](i,U,marker='+',alpha=0.5) p0= On aide curve_fit
14
9
10 a,b=[Link](i,U,1) #1 précise le degré 15 [Link](xData,func(xData,*popt),'b--',label='fit a
11 [Link](i,a*i+b,'g-',label=r'$modélisation \ : =%.3f, b=%.3f'%tuple(popt)) #insister sur l'é
\ U=%.1f*I+%.3f$'%(a,b)) toile
12 graphe.set_xlabel('Intensité dans la résistance en 16 [Link]()
Ampère') 17 [Link]()
13 graphe.set_ylabel('Tension aux bornes de la ré
sistance') Dans cet exemple, on crée arti ciellement des valeurs expé-
14 graphe.set_title('Loi d\'Ohm') rimentales avec le module random de numpy.
15
16 [Link]()
17 [Link]()
12 Barres d'erreur
1 import [Link] as plt
11.3 curve_ t 2 import numpy as np
3 from [Link] import curve_fit
Permet de modéliser en théorie n'importe quelle fonction. 4
Par contre, il faut aider la modélisation en lui donnant des 5 def func(x,a,b):
valeurs approchées pour chaque constante si cela ne marche 6 return a*x+b
pas. Dans notre cas, ce n'est pas la peine. 7
[Link] 29 Lycée Saint-Exupéry de Mantes-la-Jolie
La programmation python
8 U,I=[Link]('[Link]',skiprows=4,delimiter=';',
unpack=True,usecols=(0,1)) # on crée un tableau
de 10 valeurs équirépartie commençant à 0.
9 fenetre,graphe=[Link](1,1,figsize=(8,10))
10 [Link].set_window_title("Loi d'Ohm")
11 i=I/1000 #pour avoir des ampères
12 [Link](i,U,marker='+',alpha=0.5)
13 popt,pcov=curve_fit(func,i,U)
14 [Link](i, U, yerr = 0.005*U+0.05,xerr
=0.005*i+0.0005,fmt = 'none', capsize = 2,
ecolor = 'b', elinewidth = 0.2, capthick = 0.2)
15 [Link](i,func(i,*popt),'b--',label='fit a=%.3f
, b=%.3f'%tuple(popt)) # insister sur l'étoile
16 graphe.set_xlabel('Intensité dans la résistance en
Ampère')
17 graphe.set_ylabel('Tension aux bornes de la ré
sistance')
18 graphe.set_title('Loi d\'Ohm')
19 [Link]()
20 [Link]()
Tout ce qui concerne les barres d'erreur se trouve à la
ligne 14. fmt ='None' est nécessaire pour que les points ne
soient pas reliés un à un. Le reste concerne les paramètres
des marqueurs.
Application directe
Modéliser la courbe obtenue grâce au chier poin-
[Link] avec les deux dernières méthodes.
[Link] 30 Lycée Saint-Exupéry de Mantes-la-Jolie
Vous aimerez peut-être aussi
- Sommaire: 1 Tutorield'Initiationàpython-1 Partie 1Pas encore d'évaluationSommaire: 1 Tutorield'Initiationàpython-1 Partie 16 pages
- LYCEE JANSON de SAILLY-POLY Cours-Informatique Pour Tous Cours Et Exercices PDFPas encore d'évaluationLYCEE JANSON de SAILLY-POLY Cours-Informatique Pour Tous Cours Et Exercices PDF101 pages
- Guide complet de la programmation PythonPas encore d'évaluationGuide complet de la programmation Python8 pages
- Apprendre À Programmer Avec Python FacilementPas encore d'évaluationApprendre À Programmer Avec Python Facilement90 pages
- 3 - Python 2021 - Pour Les SciencesPas encore d'évaluation3 - Python 2021 - Pour Les Sciences131 pages
- Formation Python pour Enseignants LycéePas encore d'évaluationFormation Python pour Enseignants Lycée39 pages
- Python pour Physique-Chimie LycéensPas encore d'évaluationPython pour Physique-Chimie Lycéens70 pages
- Python pour Débutants en ProgrammationPas encore d'évaluationPython pour Débutants en Programmation247 pages
- Poly1python para Matematica - ImportantePas encore d'évaluationPoly1python para Matematica - Importante37 pages
- Guide Python pour Prépa InformatiquePas encore d'évaluationGuide Python pour Prépa Informatique15 pages
- Introduction au Python pour DébutantsPas encore d'évaluationIntroduction au Python pour Débutants91 pages
- Informatique Python Readthedocs Io FR m2Pas encore d'évaluationInformatique Python Readthedocs Io FR m2243 pages
- Découverte de La Programmation Avec PythonPas encore d'évaluationDécouverte de La Programmation Avec Python452 pages
- Emploi Du Temps Cour Du Jour Semaine 15-09-2025Pas encore d'évaluationEmploi Du Temps Cour Du Jour Semaine 15-09-2025305 pages
- Bootstrap 5.3.3 : Guide d'installation et d'utilisationPas encore d'évaluationBootstrap 5.3.3 : Guide d'installation et d'utilisation9 pages
- Classes Internes et Anonymes en JavaPas encore d'évaluationClasses Internes et Anonymes en Java37 pages
- Introduction au Framework Grails 2015-2016100% (1)Introduction au Framework Grails 2015-2016105 pages
- TP4 - Spark: Outils Pour Le Big DataPas encore d'évaluationTP4 - Spark: Outils Pour Le Big Data6 pages
- Guide complet sur PL/SQL et ses blocsPas encore d'évaluationGuide complet sur PL/SQL et ses blocs10 pages
- Manuel D'utilisation de L'applicationPas encore d'évaluationManuel D'utilisation de L'application2 pages
- Hiérarchie et Gestion de la MémoirePas encore d'évaluationHiérarchie et Gestion de la Mémoire66 pages
- Introduction aux bases de données et SQLPas encore d'évaluationIntroduction aux bases de données et SQL58 pages
- Systèmes d'Exploitation : SémaphoresPas encore d'évaluationSystèmes d'Exploitation : Sémaphores6 pages
- Projet Data Science : Accidents RoutiersPas encore d'évaluationProjet Data Science : Accidents Routiers3 pages
- Cours Chapitre 1 Simplex Programmation LineairePas encore d'évaluationCours Chapitre 1 Simplex Programmation Lineaire38 pages
- Terminaison et correction des algosPas encore d'évaluationTerminaison et correction des algos31 pages
- Polytech Angers - Plaquette Specialite SagiPas encore d'évaluationPolytech Angers - Plaquette Specialite Sagi2 pages
