====== Premiers pas en Python pour la physique ======
{{Premiers pas en Python pour la physique.odt|Version originale}}
**Les premiers pas en Python pour les sciences physiques**
Ce document permet d’avoir une première approche de Python, de manière à pouvoir faire un programme simple comme nous le demanderons à nos élèves.
Nos élèves font aussi de la programmation en mathématiques, les algorithmes sont écrits en langage naturel ou en langage Python. Les notions de variable, d’instruction conditionnelle et de boucle sont vues en seconde. Les listes sont abordées en classe de première.
Suivre un MOOC dédié à la programmation Python, ou un livre, permettra d’avoir d’avantage de recul. Les chaines de caractères sont assez peu traitées dans ce document. Les objets, les fonctions, les tableaux et beaucoup d’autres choses ne sont pas traitées ici. Juste quelques bases ciblées sur les besoins en physique chimie au lycée.
====== Présentation de l’interface Edupython (script, console) ======
Au démarrage d’EduPython, la fenêtre suivante s’ouvre :
{{?33}}{{?33}}{{?33}}{{?26}}{{python_pour_la_physique_Image_0.png?604}}
Cette fenêtre comporte plusieurs zones :
- {{?33}}**Les barres d’outils :**
{{python_pour_la_physique_Image_1.png?604}}
Création d’un nouveau fichier de programme, ouverture d’un fichier existant, sauvegarder …
Exécuter votre programme{{python_pour_la_physique_Image_2.png?24}}
Forcer l’arrêt : {{python_pour_la_physique_Image_3.png?19}} (le bouton apparait quand le programme s’éxecute)
{{?33}}
- **L’éditeur de programme, appelé script :**
{{python_pour_la_physique_Image_4.png?447}}
Code
Nom du programme en coursAccès aux autres programmes ouverts
| {{?33}}\\ - **L’explorateur de code** met en évidence les fonctions appelées par votre programme et les variables utilisées.Deux autres onglets permettent d’avoir un explorateur de fichiers et un explorateur de projets.\\ | {{python_pour_la_physique_Image_5.png?157}}|
{{?33}}
- **Console Python :**
{{python_pour_la_physique_Image_6.png?604}}
Nous pouvons y saisir directement des instructions pour tester des commandes, elle est aussi utilisée pour afficher des résultats du programme avec la fonction **print()**.
Un onglet variables permet de voir les fonctions appelées par le programme, ainsi que les variables utilisées avec leur valeur.
{{python_pour_la_physique_Image_7.png?604}}
====== Faire un calcul, afficher un résultat et demander une valeur ======
===== Affectation (=) et commentaires =====
Le signe** =** permet d’affecter une valeur à une variable.
Le signe **#** (appelé dièse ou croisillon) permet d’ajouter un commentaire en fin de ligne. \\ Trois guillemets en début et en fin de commentaires permettent d’utiliser plusieurs lignes.
__Extrait de programme :__
{{python_pour_la_physique_Image_8.png?506}}
===== Faire un calcul (+ , - , * , / , **) =====
Les opérations de base sont les suivantes :
+ addition
- soustraction
* multiplication
/ division
** puissance
__Extrait de programme :__
{{python_pour_la_physique_Image_8.png?506}}
===== Afficher un résultat : print() =====
La fonction **print() **permet d’afficher un résultat ou/et une chaine de caractères.
**print(**variable**)** affiche la valeur de la variable dans la console.
__Exemple de script : Affichage d’une valeur numérique dans la console Python__
| Code python| Aperçu console|
| # Initialisation\\ g=9.81 # g=9.81 m/s²\\ m=10 # masse en kg\\ v=5 # vitesse en m/s\\ z=20 # altitude en m\\ # Exemple de calcul\\ Ec=0.5*m*v**2 # Energie cinétique en J\\ # Exemple d'affichage\\ print(Ec)| Le résultat s’affiche dans la console :\\ {{python_pour_la_physique_Image_10.png?129}}|
**print**("TEXTE**") **affiche TEXTE dans la console.
__Exemple :__
On remplace la dernière ligne du code ci-dessus par :
print("L'énergie cinétique vaut :")
Le résultat s’affiche dans la console :
{{python_pour_la_physique_Image_11.png?242}}
**print**("TEXTE**",**variable**) **affiche TEXTE variable dans la console.
__Exemple :__
On remplace la dernière ligne du code ci-dessus par :
print("L'énergie cinétique vaut",Ec,"Joules")
Le résultat s’affiche dans la console :
{{python_pour_la_physique_Image_12.png?336}}{{python_pour_la_physique_Image_13.png?338}}
===== Demander une valeur : input() et type d’une variable =====
La fonction **input() **permet de demander une valeur (une entrée) à l’utilisateur.
__Exemple de script :__
| Code python| Remarque :|
| z=input("Quelle est l'altitude en mètres ?")| Le contenu de la saisie est affecté à la variable z|
Avec EduPython, une fenêtre s’ouvre :
{{python_pour_la_physique_Image_14.png?560}}
La fonction **input()** renvoie une variable de type chaine de caractère, string en anglais, notée **str**.
Pour connaitre le type d’une variable, utilisez la fonction **type()** dans la console :
{{python_pour_la_physique_Image_15.png?146}}
La réponse signifie que **z** est du type ‘**str**’, c'est-à-dire une chaine de caractère.
Pour pouvoir faire un calcul avec une variable, il faut la convertir :
- en entier (en anglais integer, notée **int**),
- en réel (appelé nombre à virgule flottante en informatique, float en anglais, notée **float**).
| Pour convertir une variable en entier ou en réel, il faut lui affecter sa valeur convertie :\\ variable = **int(**variable**) **\\ variable=** float(**variable**)**\\ |
Dans notre cas, dans la console :
{{python_pour_la_physique_Image_16.png?122}}
Ou directement dans le script :
z=input("Quelle est l'altitude en mètres ?")
z=int(z)
Ou
z=int(input("Quelle est l'altitude en mètres ?"))
===== Exemple : Calcul et affichage d’une force =====
Le programme suivant demande une masse en kg à l’utilisateur, calcule le poids et affiche un message « Le poids vaut ‘valeur du poids’ N ».
{{python_pour_la_physique_Image_17.png?412}}
====== Faire un calcul en boucle – nombre d’itérations connu (for) ======
Une boucle pour ( **for** ) permet de réaliser des instructions un nombre de fois connu à l’avance en parcourant une liste d’itérations (avec la fonction **range()**), ou une liste de valeurs (voir paragraphe sur le type **list**).
===== Syntaxe d’une boucle POUR (for) utilisant la fonction range() : =====
| Algorithmique| Python|
| **Pour** i **allant de** 0 **à** n\\ Instructions\\ Fin Pour\\ | **for** i **in****range(**n+1**) :**# penser aux deux points à la fin\\ {{./ObjectReplacements/Object 2?116}}# penser à l’indentation\\ |
Remarques :
- La fonction **range(**n+1**)** permet de parcourir (n+1) itérations de 0 à n.
- La tabulation, appelée **indentation**, permet d’indiquer les instructions qui sont dans la boucle. La première ligne sans tabulation qui suit ne fait pas partie de la boucle.
- Les deux points « **:** » introduisent le bloc d’instructions de la boucle.
__Exemple de script, programmation d’un compteur :__
| Code python| Aperçu console|
| """\\ Compteur de 0 à 9 secondes\\ """\\ import time # module de gestion du temps\\ # Boucle de comptage\\ for i in range(10): # 10 car 10 valeurs de 0 à 9\\ print(i,"s")\\ time.sleep(1) # attente de 1 seconde\\ print("Fin")# en dehors de la boucle| {{python_pour_la_physique_Image_18.png?67}}|
===== =====
===== Application : Distance parcourue par un mobile =====
Calcul de la distance parcourue par un mobile sur coussin d’air :
Faites un programme qui ;
- demande une vitesse en cm/s,
- affiche toutes les secondes la distance parcourue à cette vitesse.
- s’arrête au bout de dix secondes.
__Solution :__
{{python_pour_la_physique_Image_19.png?604}}
===== Fonction range() =====
La fonction **range()** permet de parcourir des itérations.
Nous pouvons aussi choisir la valeur initiale, la valeur finale (**non atteinte**) et le pas (entier) en renseignant davantage de paramètres.
La syntaxe est alors la suivante :
**range(**valeur initiale, valeur finale, pas**)**
__Exemples :__
| Fonction python| Incréments parcourus|
| **range(**1,5,1**)**| 1 ; 2 ; 3 ;4|
| **range(**5,1,-1**)**| 5 ; 4 ; 3 ; 2|
__Application directe :__
Faites une boucle dont l’itération varie de 10 à 20 par pas de 2 et afficher la valeur de l’itération à chaque itération.
| Code python| Aperçu console|
| """\\ Test de la fonction range()\\ """\\ # Affichage de l’itération allant de 10 à 20 par pas de2\\ for i in range(10,21,2):\\ print(i)| {{python_pour_la_physique_Image_20.png?52}}|
__Exercice : compte à rebours__
Modifiez le programme du compteur (III.A) pour faire un compte à rebours de 5 à 0 en utilisant les trois paramètres de la fonction **range()**.
| Code python| Aperçu console|
| """\\ Compte à rebours de 5 à 0\\ """\\ import time # module de gestion du temps\\ # Boucle de décompte\\ for i in range(5,-1,-1): \\ print(i,"s")\\ time.sleep(1) # attente de 1 seconde\\ print("Fin")\\ | {{python_pour_la_physique_Image_21.png?36}}|
====== ======
====== Faire un calcul en boucle – nombre d’itérations inconnu (while) ======
===== Opérateurs de comparaison =====
Pour faire des comparaisons ou des tests, les opérateurs suivants sont utilisables :
== égalité
> plus grand que
< plus petit que
>= supérieur ou égal
<= inférieur ou égal
!= différent
Le résultat du test est du type booléen et peut donc prendre deux valeurs :
- vrai (True)
- faux (False).
__Remarque : __
Le langage Python est sensible à la casse, True et False s’écrivent avec une majuscule pour être interprété correctement.
__Exemples à la console :__ on affecte 2 à la variable a et on essaie différents tests
| {{python_pour_la_physique_Image_22.png?80}}| {{python_pour_la_physique_Image_23.png?78}}|
===== Boucle TANT QUE (while) =====
Lorsqu’un calcul doit être fait mais que le nombre d’itération n’est pas connu, on peut suivre des instructions en boucle, tant qu’une condition n’est pas vérifiée.
| Algorithmique| Python|
| **Tant que** condition \\ Instructions\\ Fin Tant que\\ | **while** condition **:**# pensez aux 2 points à la fin\\ {{./ObjectReplacements/Object 4?116}}# pensez à l’indentation\\ |
Comme pour la boucle for, la première ligne non indentée qui suit ne fait pas partie de la boucle.
__Exemple :__
La pression, P[hPa], en fonction de l’altitude, h[m], vaut
P(h) = P(0) {{./ObjectReplacements/Object 6?124}}
P(0) est la pression au niveau de la mer, on prend P(0) = 1013 hPa
Trouver l’altitude, à un mètre près (incrément à utiliser), pour laquelle la pression est divisée par deux.
**__Algorithmique :__**
|DEBUT\\ Affecter 1013 à P0 \\ Affecter 0 à h\\ Affecter P0 à P\\ **Tant que** P > P0/2 \\ Affecter h+1 à h\\ Calculer P\\ Fin Tant que\\ Afficher « La pression est divisée par deux à l’altitude de (valeur de h) m »\\ FIN|
**__Solution :__**
{{python_pour_la_physique_Image_24.png?604}}
====== Utiliser une liste de valeurs, méthodes associées ======
Pour tracer l’évolution d’une température, d’une pression, de la concentration d’un réactif… il faut conserver toutes les itérations de nos calculs. Pour stocker toutes ces valeurs, nous allons utiliser un objet de type liste (**list**).
===== Créer une liste =====
==== En tapant tous les éléments ====
|Les éléments d’une liste sont notés entre crochets et séparés par des virgules :\\ **Liste=[élément 0, élément 1, élément 2, élément 3]**\\ On peut faire une liste d’entiers, de flottants, de chaine de caractères, de booléens, ou avoir des éléments de différents types dans la liste.\\ Pour **lire le premier élément de la liste**, qui est à l’indice 0, taper** Liste[0]**\\ Pour **lire le deuxième élément de la liste**, qui est à l’indice 1, taper** Liste[1]**\\ …\\ Nous pouvons aussi lire la liste en partant de la fin : \\ Pour **lire le dernier élément de la liste**, qui est à l’indice -1, taper** Liste[-1]**\\ Pour **lire l’avant dernier élément de la liste**, qui est à l’indice -2, taper** Liste[-2]**\\ …|
**Exemple**, on va faire une liste d’altitudes :
Tapez les instructions suivantes dans la console :
{{python_pour_la_physique_Image_25.png?314}}
{{python_pour_la_physique_Image_26.png?150}}
{{python_pour_la_physique_Image_27.png?156}}
__Remarque :__
Attention, si vous déclarez votre suite d’éléments entre parenthèses, (), il s’agira d’une structure différente appelée un tuple. Un tuple est une liste non modifiable.
==== En utilisant une boucle ====
|Il faut créer une liste vide : **Liste=[]**\\ Puis ajouter des éléments avec l’instruction **append** à chaque itération, syntaxe : \\ **Liste.append(**élément_à_ajouter_à_la_fin_de_la_liste**)**\\ |
Remarque :
To append signifie ajouter en anglais
**Exemple**, ajout de la valeur 10000 à la fin de la liste altitudes :
{{python_pour_la_physique_Image_28.png?242}}
**Exemple**, création d’une liste d’altitudes de 0 à 10000 m par pas de 1000 m
| Code python|H=[] # liste vide des altitudes\\ **for** h **in****range(**0,10001,1000**):** # itération des altitudes\\ H.append(h) # Ajout altitude dans la liste H\\ |
| Aperçu console\\ Liste H complète\\ Premier et dernier éléments | {{python_pour_la_physique_Image_29.png?458}}|
===== Taille d’une liste =====
En physique, le type liste nous permet d’obtenir des séries de valeurs dans le but de faire un graphique par exemple.
La fonction **len()** permet d’obtenir le nombre d’éléments d’une liste
**Exemple :**
{{python_pour_la_physique_Image_30.png?240}}
Il existe de nombreuses instructions sur les listes non présentées ici : effacer un élément, insérer un élément, ordonner, extraire une partie de la liste … Taper **help(**list**)** dans la console pour les découvrir.
===== Parcourir les éléments d’une liste =====
Pour parcourir les éléments d’une liste, nous pouvons utiliser une boucle **for**. La liste remplace la suite d’itérations (fonction **range()**). La syntaxe est la suivante :
| Algorithmique| Python|
| **Pour** i **de la liste** Liste\\ Faire\\ Instructions\\ Fin Pour\\ | **for** i **in**Liste** : **# pensez aux 2 points\\ {{./ObjectReplacements/Object 8?116}} # pensez à l’indentation\\ |
Exemple création d’une liste de pressions, notée LP, aux altitudes de la liste altitudes :
{{python_pour_la_physique_Image_31.png?419}}
Résultat à la console :
{{python_pour_la_physique_Image_32.png?598}}
**__Attention :__**
Pour travailler sur chaque élément de la liste, nous sommes obligés d’utiliser une boucle. Les opérateurs + et * n’ont pas le même résultat sur le type **list** que sur un entier ou un flottant.
L’opération + directement sur des variables du type **list** permet de concaténer des listes
Exemple :
{{python_pour_la_physique_Image_33.png?329}}
L2 est la concaténation des deux listes
L’opération * permet de concaténer plusieurs fois la liste avec elle même
Exemple :
{{python_pour_la_physique_Image_34.png?270}}
L2 est la concaténation de L1 à 3 reprises
====== Structure condition ======
===== Instructions conditionnelles =====
Il existe plusieurs structures pouvant exécuter des instructions si des conditions sont remplies :
| Algorithmique| Python|
| **Si** Condition \\ Alors\\ Instructions\\ Fin Si\\ | **if**condition** :**\\ {{./ObjectReplacements/Object 10?116}}\\ |
| Algorithmique| Python|
| **Si** Condition\\ Alors\\ Instructions\\ **Sinon**\\ Instructions\\ Fin Si\\ | **if**condition** :**\\ {{./ObjectReplacements/Object 12?116}}\\ **else :**\\ {{./ObjectReplacements/Object 14?116}}\\ |
===== Exemple : déterminer si il y a une réflexion totale =====
Nous souhaitons faire un programme qui indique si la réflexion est totale, ou pas, dans une fibre optique.
|# déterminer si la réflexion est totale dans une fibre optique\\ # Importation de la fonction arcsinus et de la constante pi depuis le module math\\ **from **math** import** pi # importation de pi depuis le module math\\ **from **math** import **asin** as** arcsin # importation de la fonction asin, que l’on renomme arcsin\\ # Constantes\\ n1 = 1.456 # indice de réfraction de la silice (coeur de la fibre)\\ n2 = 1.410 # indice de réfraction du silicone (gaine de la fibre)\\ # angle limite pour la réfraction totale\\ i1lim= arcsin(n2/n1)\\ # Demande un angle incident i1deg, en °, dans la fibre\\ i1deg=**float**(**input**("Quel est l'angle incident exprimé en degré ?"))\\ i1=i1deg*2*pi/360 # conversion de l'angle en radian\\ if i1 > i1lim :\\ **print**("il y a une réflexion totale")\\ else :\\ **print**("il y a un angle réfracté")|
====== Importation de fonctions ou de modules ======
Un module est un fichier python qui comporte des fonctions. Il y a notamment les modules math et time auxquels nous avons plusieurs fois fait appel.
__Importation des fonctions utiles depuis un module :__
**from** math **import** pi, sin # importation de pi et de la fonction sinus depuis le module math
On accède uniquement aux fonctions importées avec le même nom que dans le module : pi, sin
__Importation de la fonction souhaitée avec un nom différent :__
**from** math **import** asin **as **arcsin
On accède uniquement aux fonctions importées avec les nouveaux noms. Dans l’exemple ci-dessus, on importe la fonction asin du module math, que l’on renomme arcsin pour l’utiliser dans notre programme.
__Importation de toutes les fonctions d’un module :__
**from** math **import*******#importation de toutes les fonctions du module math
On accède à toutes les fonctions du module importé avec le même nom que dans le module : pi, sin, cos …
__Importation d’un module : __
**import** math
Ainsi, on accédera aux fonctions **pi** et **asin** en tapant **math.pi** et **math.asin**.
Dans Python, où tout est objet, cela signifie que la fonction pi ou asin appartient à l’objet math.
__Remarque :__
Cette méthode a été utilisée précédemment pour l’exemple du compteur :
**import **time # module de gestion du temps
Et dans le script on retrouve l’écriture :
time.sleep(1) # la fonction sleep appartient à l’objet time
====== Tracer un graphique scientifique ======
Le module matplotlib.pyplot comporte un ensemble de fonctions qui permettent de tracer des graphiques.
Plus rigoureusement matplotlib est le module et pyplot est un objet de ce module qui possède les fonctions que l’on va utiliser.
===== Premières fonctions utiles =====
Les fonctions de bases pour tracer un graphique sont les suivantes :
| Fonctions de l’objet matplotlib.pyplot| |
| **plot(**X**, **Y**)**\\ | Fonction qui permet de tracer le graphique de la **liste des ordonnées Y en fonction de la liste des abscisses X**|
| **title(**"titre"**)**| Affiche un titre sur le graphique|
| **xlabel(**"Nom de l’abscisse"**)**| Affiche le nom à coté de l’axe des abscisses|
| **ylabel(**"Nom de l’ordonnée"**)**| Affiche un nom à coté de l’axe des ordonnées|
| **grid()**| Affiche une grille sur le graphique|
| **show()**| **Important ! affiche le graphique**|
| **Choisir ses échelles en abscisse et en ordonnée:**\\ **axis([**xmin**,** xmax**,** ymin**,** ymax**])**| Echelle en abscisse : [xmin, xmax] \\ Echelle en ordonnée : [ymin, ymax]|
Exemple de programme python :
{{python_pour_la_physique_Image_35.png?604}}
Exécutez le programme et la fenêtre suivante s’ouvre :
{{python_pour_la_physique_Image_36.png?372}}
Quelques outils en bas à gauche de la fenêtre nous permettent de faire des recadrages et d’exporter le graphique comme une image :
{{python_pour_la_physique_Image_37.png?293}}
| Revenir au réglage initial| Annuler ou refaire la dernière modification| Permet de bouger la courbe ou de changer les axes (clic gauche ou droit sur la courbe puis mouvement) | Faire un zoom sur une partie de la courbe|Paramètres de la fenêtre du graphique| Exporter le graphique (png, jpg, etc.)|
**Il faut fermer la fenêtre du graphique pour pouvoir relancer le programme python !**
Si il y a plusieurs courbes, nous pouvons les différencier avec des paramètres supplémentaires dans la fonction plot :
| Fonctions de l’objet matplotlib.pyplot| |
| **plot(**X**, **Y**, arguments)**\\ | Plusieurs arguments permettent de singulariser la courbe|
| **Changer la couleur : **"r"\\ **plot(**X**, **Y**, **"r"**)**\\ | L’argument ** **"r" permet d’afficher la courbe en rouge (red)\\ Les couleurs possibles sont :\\ b g r c m y k w |
| **Changer la nature du tracer : **"--"\\ **plot(**X**, **Y**, **"--"**)**\\ | L’argument ** **"--" permet d’afficher la courbe en pointillées\\ Les formes de courbes possibles sont :\\ - -- -. : |
| **Ajouter une légende :**\\ **plot(**X**, **Y**, label=**"courbe1"**)**\\ **plot(**X**, **Y2**, label=**"courbe2"**)**\\ **legend()**| Ne pas oublier la fonction **legend()** qui permet d’afficher la légende.|
| **Ajouter des marqueurs aux valeurs de la liste :**\\ **plot(**X**, **Y**, marker=**"*"**)**| Autres marqueurs possibles :\\ o + . x * ^|
Exemple :
Modification dans le code ci-dessus :
plot(X,Y,"r-.",marker="o",label="courbe1") # on indique la couleur et la forme ensemble
{{python_pour_la_physique_Image_38.png?381}}
Nous pouvons aussi ajouter un texte sur un point, une flèche, faire un histogramme, un diagramme circulaire … voir plus de détails sur :
[[http://apprendre-python.com/page-creer-graphiques-scientifiques-python-apprendre|http://apprendre-python.com/page-creer-graphiques-scientifiques-python-apprendre]]
===== Pression en fonction de l’altitude =====
Faites un programme qui affiche la pression en fonction de l’altitude de 0 à 10000 m avec les axes annotés et un titre.
**Code Python :**
"""
Tracé de la pression en fonction de l'altitude
"""
from matplotlib.pyplot import plot, show, ylabel, xlabel, title, axis, grid, legend
P0=1013 # initialisation, pression au niveau de la mer en hPa
H=[] # liste des altitudes
P=[] # liste des pression correspondantes aux altitudes de la liste H
for h in range(0,10001,1000): # itération des altitudes
P.append(P0*(1-(0.0065*h/288.15))**5.225) # Ajout pression dans la liste P
H.append(h) # Ajout altitude dans la liste H
plot(H,P,"r-.",marker="o",label="pression")
title("Evolution de la pression dans l'atmosphère entre 0 et 10 km d'altitude")
xlabel("Altitude [m]")
ylabel("Pression [hPa]")
legend()
grid()
show()
**Résultat :**
{{python_pour_la_physique_Image_39.png?397}}
**Après exportation en jpg :**
{{python_pour_la_physique_Image_40.jpg?604}}