Extrait - La programmation en sciences de la nature by Les Éditions CEC

programmation en sciences de la nature Une introduction aux sciences numériques

Fichiers Python et Jupyter fournis Inclut un outil de développement intégré

Sébastien Huneault _ Olivier Rousseau _ Charles Varin

_ _table des matieres / _ _mot des auteurs / ............................................................................................................................................................................. X

_ _Chapitre. 1 / Introduction.générale ........................................................................................................... 1 1.1 1 .2 1 .3 1 .4

Une introduction à l’analyse numérique ............................................................................................................................ 1 L’informatique et la programmation ....................................................................................................................................... 3 Un premier programme informatique .................................................................................................................................. 5 L’environnement de travail intégré ........................................................................................................................................... 7 1.4.1 1.4.2 1.4.3 1.4.4

PARTIE. 1

La console .............................................................................................................................................................................................. 7 L’éditeur de programme .............................................................................................................................................................. 8 Les messages d’erreur ................................................................................................................................................................ 10 Le mode de débogage .............................................................................................................................................................. 11

ne.introduction.à.la.programmation U informatique

_ _Chapitre.2 / Les.principes.de.base .................................................................................................... 14 2. 1

Concevoir et rédiger un programme informatique .............................................................................................. 14 Les éléments constitutifs d’un programme informatique ............................................................................... 14 L’organisation d’un programme informatique ......................................................................................................... 16 Les conventions de style et de nomenclature ......................................................................................................... 18 Le développement d’un programme informatique ............................................................................................. 19 Les opérations arithmétiques ...................................................................................................................................................... 20 2.2.1 Les opérations arithmétiques de base ........................................................................................................................... 20 2.2.2 La nomenclature ............................................................................................................................................................................ 22 2.2.3 La représentation informatique des nombres ......................................................................................................... 22 2.2.4 Les erreurs d’arrondi .................................................................................................................................................................... 26 Les.exercices ..................................................................................................................................................................................... 28 Les variables ................................................................................................................................................................................................... 29 2.3.1 Utiliser des variables ................................................................................................................................................................... 29 2.3.2 Nommer une variable ................................................................................................................................................................ 31 2.3.3 Les types de variables ................................................................................................................................................................ 33 2.3.4 La conversion de type ................................................................................................................................................................ 35 2.3.5 Les constantes ................................................................................................................................................................................. 36 2.3.6 Réutiliser et supprimer une variable ............................................................................................................................... 38 2.3.7 Échanger deux variables .......................................................................................................................................................... 40 Les.exercices ..................................................................................................................................................................................... 41 Le traitement des chaînes de caractères .......................................................................................................................... 44 2.4. 1 La fonction input()............................................................................................................................................................ 44 2.4.2 Les chaînes de caractères ........................................................................................................................................................ 44 2.4.3 La fonction print()............................................................................................................................................................ 46 Les.exercices ..................................................................................................................................................................................... 47 Les fonctions personnalisées ....................................................................................................................................................... 48 2.5.1 Définir et utiliser une fonction ............................................................................................................................................. 49 2.5.2 Tester une fonction .......................................................................................................................................................................52 2.5.3 Définir différentes modalités de fonctions ................................................................................................................. 54 2.5.4 Utiliser les fonctions de base en Python ...................................................................................................................... 56 2.5.5 Utiliser les fonctions mathématiques ............................................................................................................................. 57 2.5.6 Les fonctions récursives Les.exercices ..................................................................................................................................................................................... 60 2.1.1 2.1.2 2.1.3 2.1.4

2.2

2.3

2.4

2.5

Table des matières

_ _Chapitre.3 / Les.décisions.et.l’automatisation ................................................ 63 3. 1

3.2

Le traitement conditionnel ............................................................................................................................................................. 63

3. 1 . 1 Le mot clé if .................................................................................................................................................................................. 63 3. 1 .2 Les opérateurs de comparaison et les mots clés and, or et not ....................................................... 64 3. 1 .3 Les mots clés else et elif .......................................................................................................................................... 70 Les.exercices ..................................................................................................................................................................................... 71 Les boucles et le traitement répétitif ................................................................................................................................... 74 3.2. 1 La boucle for ............................................................................................................................................................................... 74 3.2.2 La boucle while ....................................................................................................................................................................... 80 3.2.3 Utiliser le mot clé break pour terminer l’exécution d’une boucle ...................................................... 85 3.2.4 Les boucles multiples ................................................................................................................................................................. 87 Les.exercices ..................................................................................................................................................................................... 89

_ _Chapitre.4 / L’organisation.des.données .................................................................................. x 4. 1

Les collections de données ............................................................................................................................................................... x Les listes .................................................................................................................................................................................................. x Les dictionnaires ............................................................................................................................................................................... x Les tuples ................................................................................................................................................................................................ x Les tableaux imbriqués ................................................................................................................................................................ x Les tableaux comme arguments de fonction .............................................................................................................. x Les.exercices ........................................................................................................................................................................................ x Les tableaux et les boucles ................................................................................................................................................................ x 4.2.1 Automatiser les opérations sur un tableau avec une boucle for ............................................................. x 4.2.2 Écrire et lire des données dans un fichier ....................................................................................................................... x Les.exercices ........................................................................................................................................................................................ x Une introduction aux tableaux numpy .............................................................................................................................. x 4.3.1 Définir un tableau numpy ...................................................................................................................................................... x 4.3.2 Les opérations ..................................................................................................................................................................................... x 4.3.3 Les fonctionnalités courantes .................................................................................................................................................. x 4.3.4 Les copies et les tableaux vides ............................................................................................................................................. x 4.3.5 Remplir un tableau de nombres ............................................................................................................................................ x 4.3.6 Le traitement conditionnel ........................................................................................................................................................ x 4.3.7 Les tableaux multidimensionnels ......................................................................................................................................... x 4.3.8 Écrire et lire dans un fichier avec savetxt()et loadtxt()......................................................... x Les.exercices ........................................................................................................................................................................................ x 4.1.1 4.1.2 4.1.3 4.1.4 4.1.5

4.2

4.3

_ _Chapitre.5 / Les.modules.et.les.bibliothèques ........................................................ x 5. 1

Utiliser des modules et des bibliothèques déjà installés .................................................................................. x Importer les fonctionnalités d’un module ou d’une bibliothèque .............................................................. x Les modules courants ................................................................................................................................................................... x Trouver et installer des bibliothèques .................................................................................................................................. x 5.2.1 Une introduction à PyPI ............................................................................................................................................................... x 5.2.2 Gérer les bibliothèques logicielles dans Thonny ....................................................................................................... x 5.1.1 5.1.2

5.2

PARTIE.2 Les.graphiques.et.le.traitement.de.données

_ _Chapitre.6 / Les.graphiques.de.fonctions.mathématiques avec.matplotlib ................................................................................................................................... x 6. 1 6.2

Tracer un graphique .................................................................................................................................................................................. x Utiliser les fonctions numpy.linspace()et numpy.arange()............................................ x

La fonction numpy.linspace()......................................................................................................................... x La fonction numpy.arange().................................................................................................................................. x Embellir un graphique et changer sa mise en forme ............................................................................................ x 6.3.1 Nommer les axes et ajouter un titre ................................................................................................................................... x 6.3.2 Ajouter plusieurs courbes et une légende ..................................................................................................................... x 6.2.1 6.2.2

6.3

La programmation en sciences de la nature

Ajuster les limites de l’axe des abscisses et de l’axe des ordonnées ........................................................... x Changer le style des courbes ................................................................................................................................................... x Exporter une figure pour l’inclure dans un document ........................................................................................ x 6.4.1 Exporter manuellement ............................................................................................................................................................... x 6.4.2 Exporter automatiquement avec savefig()........................................................................................................ x Les graphiques multiples .................................................................................................................................................................... x 6.5.1 Afficher plusieurs courbes sur un même graphique .............................................................................................. x 6.5.2 Afficher plusieurs graphiques sur une même figure .............................................................................................. x 6.5.3 Créer plusieurs figures .................................................................................................................................................................. x Les.exercices ........................................................................................................................................................................................ x 6.3.3 6.3.4

6.4

6.5

_ _Chapitre.7 / La.gestion.et.l’analyse.de.données de.laboratoire ....................................................................................................................................... x 7. 1

Introduire des données expérimentales dans un programme ................................................................... x Créer un tableau de valeurs expérimentales ............................................................................................................... x Importer des données d’un fichier ...................................................................................................................................... x Analyser numériquement des données de laboratoire ...................................................................................... x 7.2.1 Calculer la moyenne, l’écart-type et la médiane ........................................................................................................ x 7.2.2 Calculer l’incertitude et le pourcentage d’écart ......................................................................................................... x Représenter des données expérimentales sur un graphique ...................................................................... x 7.3.1 Tracer un nuage de points ......................................................................................................................................................... x 7.3.2 Tracer une courbe de tendance ............................................................................................................................................. x Les.exercices ........................................................................................................................................................................................ x 7.1.1 7.1.2

7.2

7.3

PARTIE.3 Les.applications.en.mathématiques

_ _Chapitre.8 / Les.probabilités.et.la.statistique ............................................... x 8. 1

Les tableaux et les graphiques ...................................................................................................................................................... x Lire des données ............................................................................................................................................................................... x Les variables qualitatives ............................................................................................................................................................ x Les distributions conjointes ...................................................................................................................................................... x Les variables quantitatives ........................................................................................................................................................ x La distribution conjointe de deux variables quantitatives ................................................................................. x Les séries chronologiques .......................................................................................................................................................... x Les.exercices ........................................................................................................................................................................................ x Les mesures statistiques ....................................................................................................................................................................... x 8.2.1 Les mesures de tendance centrale et de dispersion ............................................................................................... x 8.2.2 Les mesures de position .............................................................................................................................................................. x 8.2.3 La régression linéaire ..................................................................................................................................................................... x Les.exercices ........................................................................................................................................................................................ x Les probabilités .............................................................................................................................................................................................. x 8.3.1 Les probabilités théoriques ....................................................................................................................................................... x 8.3.2 Les probabilités empiriques ..................................................................................................................................................... x Les.exercices ........................................................................................................................................................................................ x Les variables aléatoires .......................................................................................................................................................................... x Les.exercices ........................................................................................................................................................................................ x L’inférence statistique ............................................................................................................................................................................. x 8.5.1 L’échantillonnage .............................................................................................................................................................................. x 8.5.2 Les intervalles de confiance ...................................................................................................................................................... x 8.5.3 Les tests d’hypothèse .................................................................................................................................................................... x Les.exercices ........................................................................................................................................................................................ x 8.1.1 8.1.2 8.1.3 8.1.4 8.1.5 8.1.6

8.2

8.3

8.4

8.5

_ _Chapitre.9 / Le.calcul.différentiel .................................................................................................... x 9. 1

Les fonctions et les graphiques .................................................................................................................................................... x Les fonctions ........................................................................................................................................................................................ x Les graphiques ................................................................................................................................................................................... x Les.exercices ........................................................................................................................................................................................ x 9.1.1 9.1.2

Table des matières

VII

9.2

Les limites et les taux de variation ............................................................................................................................................ x Les limites ............................................................................................................................................................................................... x Les taux de variation ...................................................................................................................................................................... x Les.exercices ........................................................................................................................................................................................ x Le calcul symbolique en Python .................................................................................................................................................. x 9.3.1 Définir une fonction et calculer une dérivée ................................................................................................................ x 9.3.2 Calculer une limite avec sympy ........................................................................................................................................ x 9.3.3 Calculer une dérivée implicite ................................................................................................................................................ x Les.exercices ........................................................................................................................................................................................ x La méthode de Newton ......................................................................................................................................................................... x L’optimisation : descente de gradient ..................................................................................................................................... x 9.2.1 9.2.2

9.3

9.4 9.5

_ _Chapitre. 1 0 / Le.calcul.intégral ................................................................................................................... x Calculer une somme ................................................................................................................................................................................. x Les.exercices ........................................................................................................................................................................................ x 1 0.2 Approximer une intégrale définie .............................................................................................................................................. x Les.exercices ........................................................................................................................................................................................ x 1 0.3 Résoudre une équation différentielle numériquement ...................................................................................... x Les.exercices ........................................................................................................................................................................................ x 1 0.4 Calculer une intégrale symboliquement ............................................................................................................................ x 1 0. 1

10.4.1 Le calcul d’une intégrale indéfinie ....................................................................................................................................... x 10.4.2 Le calcul d’une intégrale définie ........................................................................................................................................... x 10.4.3 Le calcul d’une intégrale impropre ...................................................................................................................................... x Les.exercices ........................................................................................................................................................................................ x 1 0.5 Les séries de Taylor et de MacLaurin ....................................................................................................................................... x Les.exercices ........................................................................................................................................................................................ x

_ _Chapitre. 1 1 / L’algèbre.linéaire ...................................................................................................................... x 11.1

1 1 .2

Les matrices ....................................................................................................................................................................................................... x 11.1.1 La création de matrices et les opérations de base ................................................................................................... x 11.1.2 Accéder à des éléments, lignes ou colonnes ............................................................................................................... x 11.1.3 Les déterminants et les inverses ............................................................................................................................................ x Les.exercices ........................................................................................................................................................................................ x Les vecteurs ........................................................................................................................................................................................................ x 11.2.1 La création de vecteurs et les opérations de base ................................................................................................... x 11.2.2 Le produit scalaire et le produit vectoriel ....................................................................................................................... x 11.2.3 L’indépendance de vecteurs ..................................................................................................................................................... x 11.2.4 Les vecteurs aléatoires .................................................................................................................................................................. x 11.2.5 Tracer des vecteurs dans un plan ......................................................................................................................................... x Les.exercices ........................................................................................................................................................................................ x

_ _Chapitre. 1 2 / Le.calcul.avancé : les.fonctions à.plusieurs.variables ...................................................................................................... x Le tracé de graphiques ........................................................................................................................................................................... x Les.exercices ........................................................................................................................................................................................ x 1 2.2 Les dérivées ........................................................................................................................................................................................................ x 1 2. 1

12.2.1 Le calcul symbolique ..................................................................................................................................................................... x 12.2.2 Le calcul numérique ....................................................................................................................................................................... x Les.exercices ........................................................................................................................................................................................ x 1 2.3 Les intégrales .................................................................................................................................................................................................... x 12.3.1 L’intégration symbolique ............................................................................................................................................................ x 12.3.2 Le calcul numérique ....................................................................................................................................................................... x Les.exercices ........................................................................................................................................................................................ x 1 2.4 L’optimisation ................................................................................................................................................................................................... x 12.4.1 L’optimisation symbolique ......................................................................................................................................................... x 12.4.2 L’optimisation numérique : descente de gradient .................................................................................................... x Les.exercices ........................................................................................................................................................................................ x

VIII

La programmation en sciences de la nature

PARTIE.4 La.résolution.de.problèmes.en.physique

_ _Chapitre. 1 3 / L’analyse.numérique.et.la.représentation graphique.du.mouvement ................................................................................................. x 1 3. 1

Les variables du mouvement en une dimension ....................................................................................................... x

13.1.1 La position ............................................................................................................................................................................................. x 13.1.2 La vitesse ................................................................................................................................................................................................ x 13.1.3 L’accélération ....................................................................................................................................................................................... x 13.1.4 Partir de l’accélération pour obtenir la vitesse et la position ........................................................................... x 1 3.2 La représentation graphique du mouvement ............................................................................................................... x 13.2.1 Le mouvement rectiligne uniformément accéléré .................................................................................................. x 13.2.2 Le mouvement avec accélération variable .................................................................................................................... x 13.2.3 Le mouvement en deux dimensions .................................................................................................................................. x Les.exercices ........................................................................................................................................................................................ x

_ _Chapitre. 1 4 / La.résolution.numérique.des.équations de.la.dynamique ................................................................................................................................ x 1 4. 1

Une introduction aux différentes méthodes de résolution ............................................................................ x

14.1.1 Les méthodes algébriques ......................................................................................................................................................... x 14.1.2 Les méthodes numériques ........................................................................................................................................................ x 1 4.2 Des exemples d’applications de la deuxième loi de Newton ....................................................................... x 14.2.1 Un bloc suspendu à une corde ............................................................................................................................................... x 14.2.2 Un bloc qui glisse sur un plan incliné sans frottement ........................................................................................ x 14.2.3 Un bloc qui glisse sur un plan incliné avec frottement ........................................................................................ x 14.2.4 Un bloc suspendu à deux cordes .......................................................................................................................................... x 1 4.3 L'intégration numérique des équations du mouvement ................................................................................... x 14.3.1 La méthode d’Euler-Cromer ..................................................................................................................................................... x 14.3.2 Des problèmes résolus ................................................................................................................................................................. x Les.exercices ........................................................................................................................................................................................ x

_ _Chapitre. 1 5 / Des.méthodes.avancées.en.physique ................................................. x 1 5. 1

La modélisation 3D .................................................................................................................................................................................... x

15.1.1 La visualisation dans un espace tri-dimensionnel ................................................................................................... x 15.1.2 Un problème résolu : le mouvement d’une charge dans un champ électrique et magnétique .................................................................................................................................................................................... x 1 5.2 L’espace des phases ................................................................................................................................................................................... x 15.2.1 La représentation du mouvement harmonique simple ....................................................................................... x 15.2.2 La représentation du mouvement harmonique amorti et forcé ................................................................... x 15.2.3 La dynamique du pendule : du mouvement harmonique simple au chaos ......................................... x 1 5.3 La transformation de Fourier rapide ....................................................................................................................................... x 15.3.1 Une introduction à la transformation de Fourier ...................................................................................................... x 15.3.2 Un problème résolu : la diffraction de la lumière par une petite ouverture .......................................... x 1 5.4 Une introduction aux simulations Monte-Carlo ......................................................................................................... x 15.4.1 Estimer la valeur de pi à l’aide de nombres aléatoires .......................................................................................... x 15.4.2 Modéliser la désintégration nucléaire ............................................................................................................................... x Les.exercices ........................................................................................................................................................................................ x

_ _index / ........................................................................................................................................................................................................................ x _ _annexes / ............................................................................................................................................................................................................ x Annexe 1 Les messages d’erreur les plus courants ................................................................................................................. x Annexe 2 Une feuille de triche (Cheatsheet) ................................................................................................................................ x Annexe 3 Les formats f-strings ............................................................................................................................................................... x

Table des matières

___Partie. 1 / //////////////////////////// ////Une.introduction//////// /à.la.programmation///////// //////////informatique////// ////////////////////////_ _ _

Chapitre 2 Chapitre 3 Chapitre 4 Chapitre 5

Les principes de base ____________ 14 Les décisions et l’automatisation____ 63 L’organisation des données________ 94 Les modules et les bibliothèques___ 156

1 3

__Chapitre.2 / ///Les.principes/////////// /////////////de.base/////// Au chapitre 1, nous avons fait un survol rapide de ce qu’est l’analyse numérique et souligné son importance en sciences. Nous avons alors introduit des concepts généraux, comme ceux d’algorithme et de programme informatique. Dans ce chapitre, notre objectif est de vous initier à la programmation informatique en langage Python. Nous ne couvrirons pas tout ce qui peut être fait avec ce dernier, mais nous proposerons un condensé des concepts de base de la programmation qui vous permettra d’aborder une vaste gamme de problèmes scientifiques. 2. 1

Concevoir et rédiger un programme informatique

Pour qu’un programme soit efficace et facile à lire, il faut en présenter les différentes composantes de manière organisée et suivre des règles de construction. La clarté d’un programme est importante non seulement pour vous-même, mais également pour les personnes qui l’utiliseront et le modifieront. Voici trois éléments qui résument l’approche que nous adopterons dans ce manuel : 1 .

Les noms de variables doivent être représentatifs du contexte. En informatique, utiliser des noms de variables constitués d’une seule lettre (x, y, a, b, etc.) est considéré comme une mauvaise pratique, mais dans plusieurs applications scientifiques, c’est tout à fait acceptable. Par exemple, y = ax + b se traduit naturellement en programmation par y = a*x + b.

Les algorithmes ainsi que les programmes doivent être simples afin d’en faciliter la lecture et la compréhension.

Il est possible que certains concepts soient utilisés avant d’être présentés. Le contexte vous permettra toutefois de les comprendre et ils seront abordés dans les chapitres subséquents.

2. 1 . 1

Les éléments constitutifs d’un programme informatique

Un programme informatique est constitué d’instructions et de commentaires. Les instructions définissent les actions et les opérations d’un programme informatique. Il est commun d’utiliser le terme code pour désigner l’ensemble des instructions. Dans ce manuel, nous utiliserons plutôt le terme programme. Les deux termes sont synonymes. Dans un programme, les instructions sont formées à l’aide de caractères communs et de mots clés qui expriment symboliquement des opérations informatiques plus ou moins complexes. Un logiciel se charge de les traduire dans un format qui pourra être exécuté par l’ordinateur. Les langages de programmation sont divisés en deux grandes catégories : les langages interprétés et les langages compilés. Il est possible d’exécuter les instructions d’un programme en langage interprété en une seule étape. Pour les langages compilés, il faut préalablement

La programmation en sciences de la nature

soumettre les instructions à un logiciel spécial (le compilateur) pour créer un programme exécutable qui devra être démarré par la suite. En règle générale, les langages compilés sont privilégiés pour leur rapidité d’exécution. Les langages interprétés sont plutôt appréciés pour leur simplicité d’utilisation. Python est un langage interprété. Pour leur part, les commentaires permettent d’ajouter, à l’intention du lecteur ou de la lectrice, des informations en complément du programme informatique. Il est d’usage, par exemple, d’inclure au début d’un programme une section qui explique brièvement ce qu’il fait et d’en nommer le, la ou les auteurs. D’autres commentaires accompagnent les instructions pour clarifier certains détails techniques, citer des sources d’information, énumérer des étapes à suivre ou des éléments à corriger, etc. Lorsqu’un programme est exécuté, l’interpréteur traduit les instructions qu’il contient en procédant ligne par ligne, de haut en bas. Les commentaires, écrits en langage courant et non en langage informatique, seront ignorés par l’interpréteur. En Python, les commentaires sont introduits à l’aide du dièse #, aussi connu sous le nom de hashtag en anglais. Considérons, par exemple, ce qui suit : >>> # Un commentaire! Si vous entrez cela dans la console et que vous appuyez sur la touche Entrée, vous verrez uniquement de nouveaux symboles >>> apparaître sur une nouvelle ligne, indiquant que l’interpréteur est prêt à recevoir de nouvelles instructions. Rien n’a été exécuté. En revanche, si vous introduisez une instruction devant le commentaire, elle s’exécutera normalement. Par exemple, inscrivez print("Salut!")devant le symbole # et appuyez sur Entrée. Vous devriez alors obtenir ceci : >>> print("Salut!") # Un commentaire! Salut! Cependant, il est préférable d’écrire un commentaire sur sa propre ligne. Un bon commentaire cible l’intention, plutôt que la description. Par exemple, ce commentaire cible l’intention puisqu’il communique des informations sur les opérations qui sont faites à la ligne qui le suit et les place dans un contexte plus général. Vous verrez à la section 2.2.1 (p. 20) que le symbole ** est associé à l'exposant. # Calculer l'hypoténuse du triangle rectangle h = (3**2 + 4**2) ** 0.5 Celui-ci propose plutôt une simple description qui n’apporte rien de plus. # Calculer la racine carrée de la somme de deux autres carrés h = (3**2 + 4**2) ** 0.5 ! ! ! remarque

Si le symbole # se trouve entre guillemets, il est traité comme du texte normal. Par exemple, l’instruction >>> print("Laisse-moi ton # et je t'appelle.") permet d’imprimer à la console la phrase suivante : Laisse-moi ton # et je t'appelle. Chapitre 2 - Les principes de base

2. 1 .2

L’organisation d’un programme informatique

S’il n’est pas bien organisé, un programme informatique peut rapidement devenir un enchevêtrement indéchiffrable d’instructions et de commentaires. C’est pourquoi la simplicité doit l’emporter sur la complexité. Un bon programme poursuit deux objectifs : 1 .

Être fonctionnel, car il doit être en mesure d’effectuer de manière efficace les tâches qui lui sont demandées ;

Être facile à lire, de sorte qu’un lecteur ou une lectrice soit en mesure d’en comprendre le fonctionnement.

Pour atteindre ces deux objectifs, il est d’usage d’organiser la rédaction d’un programme informatique en sections. Nous vous en proposons cinq qui sont appropriées pour les petits programmes que nous voyons dans ce manuel (les plus gros programmes suivent d’autres approches). Elles ne seront pas nécessairement présentes dans tous les programmes, mais il est bon de savoir les identifier et d’organiser l’ensemble des instructions en suivant cette logique. Les voici, dans leur ordre d’apparition, du début à la fin d’un programme.

L’en-tête L’en-tête, bien qu’un élément facultatif, est une bonne pratique qui consiste à insérer tout en haut d’un programme un commentaire ou une série de commentaires qui le décrivent sommairement. Il arrive qu’on y trouve aussi le nom des auteurs et leur adresse courriel, ainsi qu’une clause de déclaration de droits d’auteurs. Dans le cas de programmes distribués à une communauté élargie, on y trouve parfois le résumé d’une licence de distribution à code source libre (open-source), la licence complète se trouvant souvent dans un fichier séparé. Dans un contexte scientifique, l’en-tête peut aussi faire référence à des méthodes ou à des techniques mathématiques et numériques utilisées dans le programme et dont les détails se trouvent dans un livre ou des articles scientifiques. Nous vous rappelons que vous devez toujours citer vos sources, même en programmation. Dans le contexte du manuel, l’en-tête sera souvent omis.

Les appels de fonctionnalités externes Il arrive que certains outils et fonctionnalités se trouvent dans d’autres programmes, appelés modules. C’est le cas notamment des fonctions mathématiques, répertoriées dans le module math. Pour utiliser les fonctionnalités d’un module, il faut l’appeler préalablement en écrivant import, suivi du nom du module (p. ex. import math). Il est d’usage de faire tous les appels de fonctionnalités externes immédiatement après l’entête, afin que les utilisateurs du programme repèrent rapidement les dépendances logicielles nécessaires à son exécution.

La déclaration des fonctions Si des fonctions doivent être déclarées, elles le sont généralement après l’importation des modules et avant le début du programme. Comme les modules, elles doivent être déclarées avant d’être utilisées. L’avantage de rassembler ces blocs de codes réutilisables est de mieux structurer le programme.

La déclaration des constantes et des variables Les calculs et les opérations exécutés dans un programme informatique se font généralement par l’intermédiaire de variables. Une variable est un espace, auquel on donne un nom, réservé

La programmation en sciences de la nature

dans la mémoire de l’ordinateur afin de pouvoir y écrire et y lire de l’information. Les variables peuvent aussi être définies au moment opportun à n’importe quel endroit dans le programme. Une constante est essentiellement une variable dont la valeur ne change pas lors de l’exécution du programme (p. ex. PI = 3.1416).

Les calculs et le traitement de l’information Une fois les fonctionnalités externes chargées et les variables et constantes définies, nous entrons dans le cœur du programme, où les calculs et le traitement de l’information sont faits. Cette section est souvent la plus longue et la plus complexe du programme. Les commentaires peuvent être utiles, comme aide-mémoire ou pour fournir des explications techniques. Cette section implique généralement l’affectation de résultats dans des variables afin de garder certaines informations en mémoire, en prévision de la dernière phase du programme.

La présentation des résultats L’étape finale d’un programme consiste à présenter les résultats. Les façons les plus communes de le faire sont l’affichage à la console, la sauvegarde des données dans un fichier et la représentation des données sur un graphique. Voici l’exemple d’un programme organisé selon la logique que nous venons d’exposer. Il utilise les fonctions math.sqrt()pour évaluer la racine carrée et print()pour afficher le résultat final à la console. Programme 2.1-1

# Programme qui montre comment # utiliser le module math pour # calculer le rayon d'un cercle # à partir de son aire.

En-tête du programme

import math

Appel de fonctionnalités externes Déclaration des fonctions

def calculer_rayon(aire): return math.sqrt(aire / math.pi) # Rappel: A = pi * r**2 aire = 28.3 rayon = calculer_rayon(aire) print(rayon)

éclaration des constantes D et variables Calcul et traitement de l’information Présentation des résultats

En l’absence de commentaires et de structure, il est difficile de savoir ce qu’un programme calcule vraiment. Bien que le programme suivant effectue les mêmes opérations et donne la même réponse que le programme 2.1-1, il est moins explicite. import math print(math.sqrt(28.3/3.1416)) En revanche, trop de commentaires n’est pas nécessairement mieux, car une abondance de détails non pertinents nuit à la compréhension du programme.

À partir du menu Programmes de Thonny, accédez au programme 2.1-1 (extra), qui est un exemple à éviter.

Chapitre 2 - Les principes de base

2. 1 .3

Les conventions de style et de nomenclature

Ultimement, vos programmes seront lus et utilisés par d’autres. Il convient donc d’établir des balises de rédaction communes afin que tout le monde s’y retrouve plus aisément. Le développement du langage Python lui-même est encadré par une charte, connue sous le nom de Python Enhancement Proposals, ou PEP. Le huitième article de cette charte, le PEP 81, concerne les règles de style propres à la rédaction de programmes Python. Elles sont là pour favoriser l’interprétation visuelle. Au fil du manuel, nous nous inspirerons du PEP 8 pour définir des conventions de style et de nomenclature. Ces conventions seront introduites au fur et à mesure que nous verrons les concepts de programmation auxquels elles se rattachent. Pour commencer, voici quelques règles générales. Les instructions commencent au début de la ligne. L’interpréteur Python est strict : les lignes d’instructions doivent débuter à l’extrême gauche de la page. Si des espaces sont introduits, l’exécution du programme engendrera une erreur du type IndentationError : unexpected indent. Nous verrons plus tard que certaines structures de programmation s’écrivent sur plusieurs lignes. C’est le cas notamment des fonctions personnalisées (section 2.5, p. XXX), des structures conditionnelles (section 3.1, p. XXX) et des boucles (section 3.2, p. XXX). Dans ces cas, la première ligne de la séquence commencera complètement à gauche (pas d’espaces avant), alors que les lignes suivantes seront en retrait, décalées vers la droite d’une tabulation (ou de quatre espaces). Une ligne d’instruction ne doit pas excéder 79 caractères. Il convient d’éviter les lignes d’instructions et de commentaires trop longues. Cela produit des programmes plus faciles à lire, dont les lignes ne dépassent pas à droite de l’écran. Une ligne vide doit séparer les sections du programme. À la section 2.1.2, nous avons présenté les six sections qu’on trouve typiquement dans un programme informatique. Il convient de séparer ces différentes sections par une ligne vide. La ligne vide peut être suivie au besoin d’un commentaire afin d’indiquer le changement de section. Idéalement, ce commentaire expliquera sommairement ce qui est fait dans la section ou dans le bloc d’instructions immédiatement en dessous, comme dans l’exemple suivant. Programme 2.1-2

import math # Longueur des côtés d'un triangle rectangle x = 10 y = 5 # Calcul de l'hypothénuse r = math.sqrt(x*x + y*y) print(r) Il faut limiter l’utilisation des caractères accentués et des caractères spéciaux. Python reconnaît les caractères accentués, les caractères spéciaux, les lettres grecques, les kanji, etc. Cependant, il est recommandé de limiter leur usage aux commentaires ou à l’affichage d’information à la console à l’aide de la fonction print()(section 2.4.3). Leur utilisation dans d’autres contextes (noms de variables, noms de fonctions, etc.) pourrait compliquer le développement et la collaboration.

Le guide de style complet se trouve à l’adresse suivante : https://www.python.org/dev/peps/pep-0008/

La programmation en sciences de la nature

2. 1 .4

Le développement d’un programme informatique

Le développement d’un programme informatique comporte plusieurs étapes qui doivent être adaptées en fonction des objectifs à atteindre, par exemple une commercialisation, une distribution à code source libre (open-source) ou un usage par un bassin restreint d’utilisateurs. Voici les grandes étapes du développement d’un programme destiné à la résolution de problèmes scientifiques qui sera revu et réutilisé par d’autres scientifiques.

Définir le problème à résoudre Avant de commencer la rédaction d’un programme informatique, il faut connaître en détail le problème à résoudre. Le chemin de résolution peut impliquer l’élaboration de schémas, d’un modèle mathématique et d’une démarche claire permettant d’obtenir les réponses désirées.

Identifier les paramètres du programme Une fois que le problème à résoudre est connu, il faut en identifier les différents paramètres comme les valeurs initiales, les constantes, les fonctions utilisées, etc. On doit aussi identifier le format dans lequel les données d’entrée seront fournies (via la console, la lecture d’un fichier externe, etc.) ainsi que la façon dont les réponses seront présentées (affichage à la console, graphique, etc.).

Traduire et écrire le problème en langage informatique Une fois le problème cerné et les paramètres identifiés, il faut traduire le tout dans le langage de programmation choisi. Pour faciliter la rédaction du programme, il peut être utile de faire un schéma d’exécution ou d’écrire un pseudo-code, c’est-à-dire d’écrire en français les étapes requises pour résoudre le problème. Par exemple, 1.

Obtenir le rayon de l’utilisateur.

Calculer l’aire du cercle.

Afficher la réponse.

Déboguer et valider scientifiquement Il est fréquent qu’un programme ne fonctionne pas du premier coup ou qu’il donne des résultats inattendus. Dans un premier temps, il faut gérer les messages associés aux erreurs de syntaxe ou de retraits à la ligne, afin de permettre au programme de s’exécuter. Ensuite, on doit effectuer des tests à l’aide de cas exemples ou de cas limites, pour lesquels la réponse est connue ou peut être calculée avec une calculatrice. Les outils de débogage peuvent aussi aider à trouver et à comprendre l’origine des problèmes.

Nettoyer et documenter Une fois le programme fonctionnel et validé, il convient d’enlever les morceaux de programme et les commentaires qui ne sont plus utiles. Il est important de réviser l’ensemble des commentaires pour qu’ils reflètent adéquatement le fonctionnement du programme dans son état final.

Produire, diffuser et assurer la maintenance Finalement, le programme est utilisé pour résoudre des problèmes et partagé avec d’autres personnes. Ces dernières l’utiliseront à leur tour et s’en inspireront pour développer leurs propres programmes. Des mises à jour peuvent également être effectuées pour corriger des problèmes ou améliorer la performance du programme avant de le distribuer à nouveau.

Chapitre 2 - Les principes de base

2.2

Les opérations arithmétiques

Nous commençons maintenant plus sérieusement l’étude de la programmation informatique. Pour débuter, nous utiliserons Python comme s’il s’agissait d’une grosse calculatrice. 2.2. 1

Les opérations arithmétiques de base

Le tableau 2.1 présente l’ensemble des opérateurs arithmétiques de base en Python. Vous pouvez les utiliser directement dans la console ou l’éditeur. Il faut néanmoins faire attention à la priorité des opérations. En Python, elle est la même qu’en mathématiques, communément mémorisée grâce à l’acronyme PEDMAS : Parenthèses – Exposants – Division – Multiplication – Addition – Soustraction Ainsi, la directive -2**3 calculera −(23 ), puisque l’exposant 3 est prioritaire. Le signe négatif devant signifie que 23 est multiplié par −1. Pour calculer (−2)3, il faut ajouter des parenthèses et écrire plutôt(-2)**3. La minutie est très importante à cette étape, car l’interpréteur vérifie uniquement les erreurs de syntaxe : il exécutera ce que vous écrivez en respectant la priorité des opérations à la lettre. _Tableau 2 . 1 /

Symboles de programmation en Python associés aux opérations arithmétiques

Symbole

Description

Représentation mathématique

Exemple

Résultat de l’opération

Addition

x+y

4 + 5

−

Soustraction

x−y

10 – 2

Multiplication

x×y

5 * 3

Division

x÷y

15 / 2

7,5

Exposant

2 ** 3

Division entière

xy ⌊x ÷ y⌋

15 // 2

Modulo (reste de la division)

x mod y

15 % 2

3 + (−2)3 Par exemple, pour calculer , il faut écrire ceci : 5+2 >>> (3 + (-2)**3)/(5+2) -0.7142857142857143 ! ! ! remarque

Les parenthèses viennent toujours par paire : une ouverte et une fermée. S’il en manque une, vous verrez à l’exécution du programme l’un des deux messages d’erreur suivants :

SyntaxError: '(' was never closed ou

SyntaxError: unmatched ')' Pour corriger ce type d’erreur, il suffit d’ajouter la parenthèse manquante. Quelques remarques avant de clore cette section : / En Python, comme dans la plupart des langages de programmation, les nombres décimaux

doivent être écrits avec un point, et non une virgule. La programmation en sciences de la nature

• Pour exprimer de grands ou de petits nombres, il est avisé d’utiliser la notation scientifique. L’expression mathématique x × 10n peut s’écrire xen ou xEn. Par exemple, 0, 0001234 = 1, 234 × 10−4 s’écrira 1.234e-4 ou 1.234E-4. • En chimie ou en physique, l’utilisation de la notation scientifique est essentielle. Le nombre d’Avogadro deviendra alors 6.0221e23 atomes par mole et la constante gravitationnelle 6.6742e-11 Nm2/kg2. ! ! ! remarque

Pour calculer des racines, on peut utiliser l’identité suivante : √ m

xn = x m

La racine carrée peut donc s’exprimer sous la forme d’un exposant. Prenons par exemple : √

5 = 52

Voici deux façons de l’écrire en Python : 1 >>> 5**(1/2) 2.23606797749979 2 >>> 5**0.5 2.23606797749979 Les parenthèses de la première façon sont importantes. Voyez-vous pourquoi ? Essayez sans elles pour voir…

2.2.2

La nomenclature

PEP 8 suggère quelques règles de nomenclature pour les formules mathématiques. Bien que non contraignantes et n’ayant aucun impact sur l’exécution du programme, elles contribuent à la compréhension de celui-ci et évitent des erreurs. Parmi ces règles, il est suggéré : • d’insérer un espace avant et après les opérateurs ; • de mettre un espace de part et d’autre de l’opérateur ayant la plus faible priorité seulement, dans les cas où il y a plusieurs opérateurs ayant des priorités différentes (p. ex. + et *). Les exemples suivants respectent cette convention : age = age + 1 pcent = note / 60 * 100 total = a*5 + b*4 res = (1+2) * (3+4)

Opérateurs = et + entourés d’un espace Les opérateurs / et * ont la même priorité Multiplications regroupées pour la lecture Faible priorité avec un espace

Ces autres exemples sont à éviter : age=age+1 pcent=note/60*100 total = a*5+b*4 res = (1 + 2) * (3 + 4) 2.2.3

Difficile à lire Difficile à lire La priorité d’opération n’est pas apparente Trop espacé

La représentation informatique des nombres

En informatique, l’unité de base de stockage et de traitement de l’information s’appelle bit. La forme dite binaire, que l’ordinateur peut traiter, est construite en combinant les valeurs de plusieurs bits, comptés généralement en blocs de huit appelés octets (ou bytes en anglais). Les détails techniques peuvent varier d’une architecture à l’autre, mais la logique derrière la représentation informatique des nombres que nous vous présentons reste la même. Chapitre 2 - Les principes de base

La représentation binaire des nombres entiers Un bit peut valoir 0 ou 1. Pour représenter des nombres autres que ces deux valeurs, il faut plus de bits. Par exemple, un nombre entier naturel N représenté par deux bits, b1 et b0, s’écrira sous la forme suivante :

N = b 1 2 1 + b0 2 0 Par convention, les bits sont généralement placés en ordre décroissant de puissance. Ainsi, le nombre N écrit sous sa forme binaire équivaudra à la juxtaposition des valeurs des différents bits :

Nbinaire = b1 b0 Comme chacun des bits peut prendre deux valeurs (0 ou 1), il y a quatre possibilités : 00, 01, 10 et 11. Les valeurs numérales correspondantes sont énumérées dans le tableau suivant.

Nbinaire = b1b0

b121 + b020

00 01 10 11

0×2+0×1 0×2+1×1 1×2+0×1 1×2+1×1

0 1 2 3

Donc, avec deux bits, il est possible de constituer 22 = 4 nombres entiers naturels dont les valeurs sont entre 0 et 22 − 1, inclusivement. Pour représenter les nombres négatifs, un bit est ajouté pour encoder le signe : 0 pour positif et 1 pour négatif. Ainsi, un nombre entier représenté par trois bits, bs, b1 et b0, s’écrira :

Z = (−1)bs (b1 21 + b0 20 ) Pour un nombre écrit sous sa forme binaire, le bit de signe bs sera placé au début :

Zbinaire = bs b1 b0 Les différentes possibilités et le nombre entier correspondant sont énumérés ci-dessous.

Nbinaire = bsb1b0 111 110 101 100 000 001 010 011

(−1)bs(b121 + b020)

(−1)1(1 × 2 + 1 × 1) (−1)1(1 × 2 + 0 × 1) (−1)1(0 × 2 + 1 × 1) (−1)1(0 × 2 + 0 × 1) (−1)0(0 × 2 + 0 × 1) (−1)0(1 × 2 + 1 × 1) (−1)0(1 × 2 + 1 × 1) (−1)0(1 × 2 + 1 × 1)

Z −3 −2 −1 0 0 1 2 3

Typiquement, les langages de programmation feront usage de 32 ou de 64 bits pour représenter les entiers, ce qui correspond à 4 ou 8 octets de mémoire respectivement. Python a ceci de spécial qu’il ajuste automatiquement la taille en mémoire en fonction de la valeur des nombres.

La programmation en sciences de la nature

! ! ! remarque

Avec n bits, ce sera 2n entiers naturels entre 0 et 2n − 1. Par exemple, dans une image en format JPEG, les pixels sont constitués d’un mélange de rouge, de vert et de bleu (Red, Green, Blue, ou RGB, en anglais). Chaque couleur est alors associée à un nombre binaire de huit bits (soit un octet) permettant de quantifier son intensité sur une échelle composée de 28 = 256 niveaux allant de 0 à 28 − 1 = 255, inclusivement.

La représentation binaire des nombres décimaux De manière générale, les nombres décimaux peuvent être représentés à l’aide de la notation scientifique :

R = m × 10e où m et e sont des entiers. Par exemple, la valeur de la constante mathématique π peut s’écrire ainsi : −4

3, 1416 = 31416 × 10

L’entier m est donc associé à l’ensemble des chiffres significatifs du nombre (31416), alors que l’exposant e définit la position de la virgule séparant la partie entière (3) de la partie décimale (1416). En informatique, les nombres décimaux sont souvent appelés nombres à virgule flottante. Pour un traitement efficace par l’ordinateur, ils sont exprimés en notation scientifique en utilisant une décomposition binaire (en base 2) :

R2 = M × 2 E La plupart des langages de programmation, incluant Python, utilisent 64 bits pour représenter le nombre : 53 bits pour la mantisse M et 11 bits pour l’exposant E. Le nombre fini de bits utilisés pour M et E définit la précision et les limites des nombres qu’il est possible de représenter en format numérique.

L’incertitude associée à la représentation numérique des nombres décimaux Le nombre fini de bits utilisés pour la mantisse M définit la précision des nombres décimaux qu’il est possible de représenter en format numérique. Nous avons vu qu’avec n bits, le plus grand entier possible est 2n − 1. Comme un des bits est utilisé pour le signe, la valeur maximale 53−1 − 1 = 4503599627370496 ≈ 4, 5 × 1015. Cette valeur possible pour M est donc 2 indique que la précision d’un nombre décimal sera, au maximum, de 16 chiffres significatifs. En informatique, il est d’usage de parler plutôt de l’incertitude de représentation des nombres, ici de l’ordre de 1/253−1 ≈ 2 × 1016, aussi appelée unité d’arrondi (machine epsilon en anglais). L’unité d’arrondi représente le plus petit nombre en deçà duquel, si ce nombre est ajouté à 1, le résultat sera 1. Dans l’exemple suivant, Python pourra ainsi exécuter l’opération comme attendu. >>> 1 + 2e-16 1.0000000000000002 Cependant, si le nombre additionné est inférieur à l’unité d’arrondi, la valeur affichée sera tout simplement 1.0. (Les programmeurs diront dans leur langage que l’exécution « retourne » 1.0.) >>> 1 + 1e-16 1.0 Pour la majorité des applications, une précision de cet ordre est amplement suffisante. Chapitre 2 - Les principes de base

Les limites des très grands ou très petits nombres Le nombre de bits utilisés pour représenter l’exposant E définit les limites des grands et des petits nombres qui peuvent être utilisés dans un programme. Rappelons que 11 bits sont employés pour représenter l’exposant E, dont un pour le signe. Une limite supérieure de la valeur de l’exposant sera donc 211−1 − 1 = 1023. Ainsi, le plus grand nombre possible sera de l’ordre de 21023 ≈ 10308, ce qui est un très grand nombre. Dans les faits, les architectures modernes de processeurs utilisent certains trucs pour optimiser l’utilisation des bits, et les limites réelles observées sont les suivantes :

±5 × 10−324 ≤ R2 < ±1, 8 × 10308 Au-delà de la limite supérieure (±1, 8 × 10308 ), Python arrondira le nombre à ±inf, correspondant au ±∞ mathématique. >>> 1.7e308 1.7e+308 >>> 1.8e308 inf >>> -1.8e308 -inf Pour les entiers, une telle limite supérieure n’existe pas en Python. ! ! ! remarque

Le mot clé inf n’a pas de valeur numérique et ne peut pas être utilisé pour faire des calculs. >>> 1.0/inf Traceback (most recent call last): File "<pyshell>", line 1, in <module> NameError: name 'inf' is not defined En ce qui concerne les petits nombres, il faut noter qu’aux alentours de ±5 × 10−324 , ils sont arrondis à ±5 × 10−324 ou ±1 × 10−323, mais qu’en deçà de 2.48e-324, ils sont arrondis à 0. >>> 8.0e-324 1e-323 >>> 7e-324 5e-324 >>> -3.0e-324 -5e-324 >>> 2.47e-324 0.0

Les différences entre 10, 10.0 et 1.0e1 En Python, le type d’une variable dépend de l’information qui lui est associée. À titre d’exemple, nous pouvons considérer les nombres 10 et 10.0. Dans les faits, ils représentent la même quantité, mais en Python, 10 sera associé à un type entier (int en termes informatiques), alors que 10.0 sera plutôt associé à un type décimal (float en informatique, en référence à « nombre à virgule flottante »). Les nombres 1e1 et 1.0e1 seront pour leur part équivalents à 10.0 et associés au type float.

La programmation en sciences de la nature

>>> type(10) <class 'int'> >>> type(10.0) <class 'float'> >>> type(1e1) <class 'float'> Nous rediscuterons des types de variables à la section 2.3.3. Entre-temps, nous vous suggérons d’être explicite dans vos programmes en utilisant la forme 10.0, 1e1 ou 1.0e1 lorsque vous faites des calculs avec des nombres décimaux. 2.2.4

Les erreurs d’arrondi

L’utilisation d’un nombre fini de bits implique une représentation approximative des nombres décimaux. Cette approximation introduit une erreur par rapport à la valeur mathématique attendue normalement. Cette erreur, appelée erreur d’arrondi, provient de l’arrondissement des nombres lors de leur expression sous forme binaire. Les erreurs d’arrondis sont typiquement petites, de l’ordre de l’unité d’arrondi, dont la valeur est d’environ 2 × 10−16. Mais elles peuvent mener à une erreur cumulative plus grande en s’additionnant et en se multipliant. Dans certains calculs, elles peuvent même causer des instabilités numériques : les valeurs vont alors différer largement des valeurs mathématiques. Or, en analyse numérique, il n’est pas rare de répéter des opérations des milliers, voire des millions de fois. Une bonne compréhension et un contrôle adéquat des erreurs d’arrondi sont donc essentiels pour obtenir des résultats valables.

√

Prenons par exemple l’opération mathématique ( 2)2, dont la valeur exacte est 2. Le programme suivant reproduit ce calcul. import math print(math.sqrt(2)**2) >>> 2.0000000000000004 Le résultat indique clairement que la valeur obtenue avec le programme n’est pas exactement 2.

L’erreur absolue L’erreur absolue se calcule en soustrayant la valeur mathématique exacte (valeur théorique) de la valeur obtenue en faisant le calcul avec Python (valeur numérique). erreur_absolue = numerique - theorique Dans l’exemple donné précédemment, la valeur théorique est 2 et la valeur numérique est le résultat du calcul math.sqrt(2)**2 √ 2 . Le programme qui suit affiche l’erreur absolue asso( 2) . ciée à l’évaluation numérique de import math print(math.sqrt(2)**2 - 2) >>> 4.440892098500626e-16 Chapitre 2 - Les principes de base

Il apparaît donc que l’erreur absolue est, dans ce cas précis, le double de l’unité d’arrondi, dont la valeur à trois chiffres significatifs est 2, 22 × 10−16.

L’erreur relative L’erreur relative est une estimation de l’erreur en proportion de la valeur de référence théorique. Elle s’exprime en pourcentage. erreur_relative = 100*(numerique – theorique)/theorique

√

Voici un programme qui affiche l’erreur relative associée à l’évaluation numérique de ( 2)2. import math theorique = 2 numerique = math.sqrt(2)**2 erreur_relative = 100*(numerique – theorique)/theorique print(erreur_relative, "%") >>> 2.220446049250313e-14 % Il apparaît que l’erreur relative pour ce cas particulier est très petite.

L’erreur absolue et l’erreur relative Il faut noter que l’erreur d’arrondi n’est pas toujours la même et dépend de la valeur des nombres et de la séquence d’opérations exécutée. À titre d’exemple, nous√ avons compilé dans le tableau suivant l’erreur d’arrondi associée à l’évaluation numérique de ( x)2 pour quelques valeurs de x.

( x)2

Erreur absolue

2 3 4 5 13 309 5 005 959 869

2,0000000000000004 2,9999999999999996 4,0 5,000000000000001 13 309,000000000002 5 005 959 869,000001

4,44 × 10−16 −4,44 × 10−16 0,0 8,88 × 10−16 1,82 × 10−12 9,54 × 10−7

Erreur relative (%)

2,22 × 10−14 −1,48 × 10−14 0,0 1,78 × 10−14 1,37 × 10−14 1,91 × 10−14 √ À part pour les carrés parfaits (comme le nombre 4), pour lesquels ( x)2 donne la valeur exacte, l’erreur absolue aura tendance à augmenter lorsque la valeur du nombre x augmente. Cette tendance s’explique par le fait que l’arrondi s’applique au dernier chiffre significatif à droite. Comme les grands nombres utilisent de plus en plus de chiffres significatifs pour la partie entière, l’erreur d’arrondi est alors introduite de plus en plus près de la virgule, ce qui correspond à une erreur absolue de plus en plus grande. En ce qui concerne l’erreur relative, il est observé que celle-ci fluctue, mais que sa valeur absolue reste aux alentours de 10−14 , sauf pour x = 4 et les carrés parfaits, où elle est 0,0. Cependant, l’erreur relative peut elle aussi grandir. Cela se produit typiquement avec des séquences composées de plusieurs opérations, ou lorsqu’une ou des opérations sont répétées plusieurs fois.

La programmation en sciences de la nature

√

Par exemple, l’opération ( 2)100 correspond à ( 2)2 multipliée par elle-même 50 fois, avec une valeur théorique attendue de 250 = 1125899906842624 . En évaluant math. sqrt(2)**100 et 2**50 avec Python, vous observerez que l’erreur relative entre elles est −12 alors 1, 11 × 10 √ . C’est toujours très petit, mais tout de même 50 fois plus grand que ce qui était observé avec ( 2)2, les erreurs relatives s’étant additionnées.

///Les.exercices/////////// Effectuez les exercices suivants directement dans la console Python. 1 _

Multipliez 26 et 13.

Calculez l’âge approximatif d’une personne née en 1985.

Calculez la circonférence d’un cercle dont le rayon est de 4 cm.

Calculez l’aire d’un cercle dont le diamètre est de 8 m.

Calculez le pourboire à laisser sur une facture de 57,35 $ selon la qualité du service reçu.

La formule pour calculer la circonférence d’un cercle : C = 2πr. La valeur de π ∼ = 3, 1416.

La formule pour calculer l’aire d’un cercle : A = πr 2.

a. Moyenne (10 %) b. Bonne (15 %) c. Excellente (20 %) 6_

Calculez les taxes et le total à payer pour l’achat d’un bien dont le prix est de 118,92 $.

Calculez à quelle hauteur se trouve une balle lancée du sommet d’un immeuble après un temps t de 4 secondes si sa position verticale est donnée par

Le taux de la TPS est 5 %, celui de la TVQ est 9,975 %, et le total à payer se calcule ainsi : total = montant avant taxes + montant TPS + montant TVQ

h(t) = −4, 9t2 + 10t + 50 8_

Calculez

a. la valeur de l’hypoténuse d’un triangle rectangle dont les côtés de l’angle droit mesurent 3 et 4 unités, respectivement ;

b. la valeur du troisième côté d’un triangle rectangle dont l’hypoténuse mesure 8 unités et un des autres côtés 5 unités. 9_

Calculez le volume d’une sphère de 3 m de rayon. La formule pour calculer le volume d’une sphère : V =

10 _

4πr3 . 3

Calculez la valeur de la fonction

f (x) =

x2 − 2 3(3x + 2)2

lorsque x = −2.

Chapitre 2 - Les principes de base

1 1 _

Convertissez les extraits de programme suivants en notation mathématique (p. ex. x**2 devient x 2).

a. 7/3**5 + 2**0.5 b. -9**(1/5)/2 + 1 c. ((3/2)**0.5)*(-3 + 2)/(-1**2 - 3*7)**2 12 _

Calculez l’erreur absolue et l’erreur relative associées à l’évaluation numérique de

13 _

Soit l’opération suivante :

√ 3

73 .

1 1 + 19

a. À l’aide des opérations sur les fractions, calculez la valeur exacte de cette opération. b. Effectuez l’évaluation numérique de l’expression avec Python. Quelle est l’erreur absolue ? Quelle est l’erreur relative ? 2.3

Les variables

Si vous devez calculer la valeur de la fonction

f (x) =

x2 − 2 3(3x + 2)2

lorsque x = −2 en tenant compte de la priorité des opérations, une solution possible est celle-ci : >>>((-2)**2 - 2)/(3*(3*(-2) + 2)**2) 0.041666666666666664 Cette approche intuitive n’est toutefois pas idéale. Pour calculer la valeur de f (x) pour des valeurs de x autres que −2, il faut remplacer ce nombre par la nouvelle valeur partout dans l’équation. Par exemple, pour évaluer f (3), il faudrait changer les −2 par des 3. Le risque d’erreur est grand et d’autant plus probable si cette opération doit être répétée plusieurs fois. Dans les sections suivantes, nous verrons comment utiliser des variables pour éviter ce genre de problème et rendre la programmation plus efficace. 2.3. 1

Utiliser des variables

Comme en mathématiques, une variable est un objet que l’on nomme et auquel il est possible d’attribuer une valeur ou le résultat d’une expression. Par exemple, x = 3 sous-entend que x est une variable qui contient un nombre dont la valeur est 3. La même notion existe en programmation. Ainsi, >>> x = 3 créera la variable x et lui assignera la valeur 3. ! ! ! remarque

La variable doit absolument être à gauche et la valeur, à droite. Ainsi, l’instruction 3 = x ne fonctionnera pas et donnera une erreur. Notez les espaces autour de l’opérateur =, comme vu dans la section 2.2.2 sur la nomenclature. Les formes x= 3, x =3 ou x=3 sont à éviter.

La programmation en sciences de la nature

Concrètement, lorsque la touche Entrée est enfoncée, Python réserve un espace dans la mémoire vive de l’ordinateur, lui donne l’étiquette x et lui associe la valeur 3. La variable et sa valeur restent alors dans la mémoire et peuvent être réutilisées. Par exemple : >>> x = 3 >>> x**2 9 De la même manière, nous pouvons utiliser la variable x pour évaluer la fonction f (x), qui serait écrite de manière générique en utilisant ce symbole. >>> x = 3 >>>(x**2 - 2)/(3*(3*x + 2)**2) 0.01928374655647383 Pour calculer une valeur de x différente, il suffit de modifier sa valeur et d’exécuter le code à nouveau. x = 3 print( (x**2 - 2)/(3*(3*x + 2)**2) ) >>> 0.01928374655647383 ! ! ! remarque

Dans la console, Python garde un historique des instructions exécutées. Vous pouvez naviguer dans cet historique en utilisant les flèches « vers le haut » ou « vers le bas » du clavier. Plutôt que de faire du copier-coller, il est donc possible de faire réapparaître une ligne d’instruction, de modifier la valeur de x et d’appuyer sur la touche Entrée pour voir le nouveau résultat. Les programmes précédents auraient aussi pu être écrits dans l’éditeur de programme. Dans ce cas, la fonction print()est utilisée pour afficher le résultat final à la console. Programme 2.3-1

x = 3 fx = (x**2 - 2)/(3*(3*x + 2)**2) print(fx) >>> 0.01928374655647383 <<< rappel

Une variable doit être définie avant d’être utilisée. Par exemple, omettre la ligne x = 3 dans le programme précédent engendrera cette erreur d’exécution : NameError: name 'x' is not defined.

Chapitre 2 - Les principes de base

2.3.2

Nommer une variable

En mathématiques, les lettres x, y, z, a, b, c… sont souvent utilisées pour nommer les variables. Mais un programme informatique complexe peut compter des dizaines de variables. Si, dans certains contextes mathématiques, x et y sont des choix naturels et appropriés, il sera habituellement préférable de choisir un nom de variable qui résume de façon concrète le rôle qu’elle joue dans le programme. Que fait le programme suivant ? a = 45.36 b = a * 0.15 c = a + b print(c) Ce n’est pas du tout évident. En utilisant des noms de variables évocateurs, il est possible de comprendre le programme sans explications supplémentaires. Programme 2.3-2

total = 45.36 taxes = total * 0.15 total_avec_taxes = total + taxes print(total_avec_taxes) Notons cependant que, lorsqu’un programme traduit une équation ou un concept mathématique précis, il convient de les reproduire le plus fidèlement possible. Par exemple, le calcul de l’hypoténuse c d’un triangle rectangle dont les côtés sont de longueurs a et b se fait à l’aide du théorème de Pythagore, donné par l’équation

√

a2 + b2

Le programme correspondant, qui accompagne l’équation, pourrait alors reprendre le nom de ces variables tel quel, ce qui constituerait une référence directe au théorème. Programme 2.3-3

a = 3 b = 4 # Calculer l'hypoténuse à l'aide du théorème de Pythagore c = (a**2 + b**2)**0.5 print(c) Des commentaires peuvent aussi être insérés dans le programme pour donner plus de détails et, le cas échéant, faire référence à l’ouvrage où se trouve l’équation, le schéma, l’énoncé du problème, etc.

Les noms de variables en Python En Python, un nom de variable peut : • être de n’importe quelle longueur, mais il sera préférablement concis ; • contenir des chiffres et des lettres ; • contenir des lettres majuscules et minuscules (Python est sensible à la casse, c’est-à-dire qu’il fait la différence entre les deux) ;

La programmation en sciences de la nature

mais : • doit obligatoirement débuter par une lettre ; • ne doit pas contenir d’espaces ; • ne doit pas contenir de caractères spéciaux, à l’exception du souligné _. Il est à noter que certains mots sont réservés par Python lui-même et qu’ils ne peuvent pas être utilisés comme noms de variables. Il y en a 35 au total. Nous les avons compilés dans le tableau 2.2. _Tableau 2 . 2/

Liste des mots clés réservés à Python

False

None

True

and

elif

assert

async

await

break

class

continue

def

del

else

except

finally

for

from

global

import

lambda

nonlocal

not

pass

raise

return

try

while

with

yield

Finalement, il faut éviter d’utiliser des noms de variables qui sont en conflit avec des constantes ou des fonctions déjà existantes. Par exemple, print = 10 est permis, mais rendra la fonction print()inutilisable ! Si cela se produit, il est possible de redémarrer l’interpréteur en appuyant sur l’icône , située dans la barre d’outils de Thonny. <<< rappel

En Python, le dièse # (hashtag) est réservé à l’annotation des programmes. Ainsi, il est possible d’insérer des commentaires, des notes ou des clarifications pour documenter un programme informatique, sans que cela affecte son exécution.

Les règles de nomenclature Nous avons vu les règles à suivre pour nommer une variable et s’assurer que le programme s’exécute sans erreur. Cependant, le choix du nom d’une variable ne doit pas se limiter à la syntaxe. Un nom de variable doit aider à la compréhension du programme et faciliter son entretien. Choisi judicieusement, il peut éviter des erreurs, accélérer le développement et aider au débogage. À cet égard, rappelons que, pour encadrer son développement, Python possède sa propre charte. Le huitième article de cette charte, le PEP 8 (Python Enhancement Proposal number 8), propose des conventions de style dont ce manuel s’inspire. En voici quelques-unes : • Le nom d’une variable s’écrit toujours en lettres minuscules. Exemples : total, taxes, a, b, x, y • Le nom d’une constante (section 2.3.5, p. 34) s’écrit toujours en lettres majuscules. Exemples : PI, TAUX, GAUSS • Lorsque le nom d’une variable ou d’une constante est constitué de plusieurs mots, ceux-ci sont séparés par un souligné _. Exemple : total_avec_taxes, VITESSE_DE_LA_LUMIERE

Chapitre 2 - Les principes de base

2.3.3

Les types de variables

Lors de la création d’une variable, un type lui est donné en fonction de la valeur qui lui est assignée. Par exemple, lorsque l’instruction suivante >>> x = 3 est exécutée, la variable x de type nombre entier (integer en anglais) est créée et contient la valeur 3. Dans la situation suivante, >>> x = 3.0 la variable x est plutôt de type décimal (float). Le tableau suivant regroupe les principaux types de variables. _Tableau 2 .3 /

Principaux types de variables

Nom (terme en programmation)

Description

Exemple

Entier (integer ou int)

Nombre entier, positif ou négatif

Décimal (float)

Nombre à virgule

Booléen (boolean ou bool)

Vrai ou Faux

Texte (string ou str)

Une chaîne de caractères, du texte

Liste ou Tableau (list ou array)

Plusieurs valeurs dans une même variable

[4, 8, 72, 45]

Date (datetime)

Une date ou une heure incluant parfois le fuseau horaire

2022-01-19 14:28:18.158209

42 12.78 True, False "Bonjour le monde"

D’autres types de variables, tels que les dictionnaires, les tuples2, les ensembles et les instances de classes, sont également possibles en Python. Certains de ces types seront vus plus tard dans ce manuel. Il est important de noter que certaines opérations ne sont possibles qu’entre types compatibles. Par exemple, il est possible d’effectuer des opérations entre nombres entiers (int) et décimaux (float), mais pas entre des nombres (int ou float) et du texte (str). Voici un exemple classique de programme où une opération mathématique est effectuée entre types incompatibles. >>> age = "36" >>> vieux = age + 5 Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: can only concatenate str (not "int") to str Ici, la variable age est de type str (texte) parce que la valeur qui lui est donnée, 36, est placée entre guillemets. Comme il n’est pas possible d’additionner du texte et un nombre entier, l’opération age + 5 donne une erreur.

2 L’usage du terme anglais tuple, suffixe de quintuple, sextuple, etc., est courant dans les ouvrages de programmation informatique en français. La programmation en sciences de la nature

Voici un autre exemple : >>> age1 = "36" >>> age2 = "42" >>> age1 + age2 '3642' L’intention ici est d’obtenir la somme des âges (36 + 42 = 78), mais le résultat affiché est incorrect. Que s’est-il passé ? Quand nous avons attribué les âges, nous avons encadré les nombres de guillemets. Or, les guillemets signifient l’attribution du type str (texte) à la variable. Le symbole + a alors pour effet de concaténer le texte "36" au texte "42", au lieu d’additionner les nombres 36 et 42. ! ! ! remarque

Cet exemple présente un type d’erreur plus difficile à repérer. Lorsque l’application cause une erreur et cesse de fonctionner, il est évident qu’une erreur de code a été commise. Mais lorsque tout fonctionne bien sans répondre à notre intention, c’est plus complexe. D’où l’importance de toujours valider les résultats.

2.3.4

La conversion de type

Plusieurs fonctions existent pour convertir les divers types de variables. _Tableau 2 .4 /

Principales fonctions de base de conversion de types

Fonction

int() float() str() bool()

Description

Transforme en entier Transforme en nombre flottant Transforme en texte Transforme en booléen

Exemple --> résultat

int("36") --> 36 float(36) --> 36.0 str(36) --> "36" bool(36) --> True

Pour convertir le type d’une variable, il suffit d’utiliser la fonction appropriée. Ainsi, dans le cas de la variable age, de type str (texte), il sera possible de la convertir en type int (entier). >>> age = "36" >>> type(age) <class 'str'> >>> age = int(age) >>> type(age) <class 'int'> L’exemple de la section précédente, sur la somme des âges, devra donc être corrigé ainsi afin d’obtenir le bon résultat : >>> age1 = "36" >>> age2 = "42" >>> int(age1) + int(age2) 78

Chapitre 2 - Les principes de base

! ! ! remarque

La fonction type()permet de trouver le type d’une donnée ou d’une variable.

type_de_la_variable = type(variable) type_de_la_variable est le nom de la variable dans laquelle la fonction type()inscrira le résultat sous la forme d’une chaîne de caractères (type str). variable est le symbole de la variable ou d’une donnée dont on souhaite connaître le type. type_PI = type(3.1416) Comme la fonction type()retourne une chaîne de caractères, on peut aussi l’utiliser directement avec la fonction print(), pour afficher le type à la console.

print(type(3.1416)) La conversion de type est importante lors de la présentation d’informations textuelles et numériques à la console. Dans l’exemple ci-dessous, l’utilisation du symbole + entre le texte "La moyenne est " (type str) et la variable moyenne (type float) donne une erreur. >>> somme = 25 + 45 + 30 >>> moyenne = somme / 3 >>> print("La moyenne est " + moyenne) Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: can only concatenate str (not "int") to str La solution est de convertir la variable moyenne en type str afin que le symbole + puisse combiner les deux textes : >>> somme = 25 + 45 + 30 >>> moyenne = somme / 3 >>> print("La moyenne est " + str(moyenne)) La moyenne est 33.333333333333336 Nous verrons d’autres façons d’imprimer ce genre de résultat à la section 2.4. 2.3.5

Les constantes

Dans certains cas, des variables sont utilisées pour conserver des valeurs qui ne changent pas. Ces variables à valeur fixe sont appelées constantes. Leur utilisation permet d’écrire des programmes plus clairs, de limiter les risques d’erreur et d’apporter des changements globaux rapidement.

Définir une constante Une constante s’utilise exactement de la même façon qu’une variable. Par convention, son nom sera cependant écrit entièrement en lettres majuscules. >>> PI = 3.141592654 >>> r = 10 >>> circ = 2 * PI * r >>> print(circ) 62.83185308

La programmation en sciences de la nature

Il est important de noter que Python ne protège pas la valeur des constantes, comme d’autres langages de programmation le font. Il serait donc possible de remplacer la valeur de PI. L’utilisation des majuscules permet alors d’indiquer que la valeur de cette variable ne doit pas être modifiée, car cela pourrait nuire au fonctionnement du programme et entraîner des erreurs de calcul. ! ! ! remarque

Plusieurs constantes mathématiques existent déjà dans les bibliothèques Python et n’auront pas besoin d’être réécrites manuellement.

Les constantes mathématiques et physiques prédéfinies en Python Le logiciel de développement intégré qui accompagne le manuel vous permet d’importer les valeurs des constantes mathématiques et physiques à partir des bibliothèques math et scipy. Nous verrons ici comment les inclure dans vos programmes sans avoir à entrer leur valeur à la main chaque fois. Deux constantes mathématiques sont définies dans la bibliothèque math : le nombre d’Euler e et la constante π. Pour y accéder, il faut inclure import math en début de programme ou écrire cette ligne d’instruction dans la console. >>> import math >>> math.e 2.718281828459045 >>> math.pi 3.141592653589793 ! ! ! remarque

Les constantes définies dans un module sont aussi des variables et peuvent donc être modifiées. Par exemple, il serait possible d’écrire math.pi = 2.0. La constante π prendrait alors la valeur 2. Heureusement, le changement n’est pas permanent. Si vous faites cette erreur, il est possible de revenir en arrière. Il suffit de redémarrer l’interpréteur Python en appuyant sur l’icône dans Thonny et en important le module à nouveau. La bibliothèque scipy regorge de fonctionnalités très utiles, dont une table exhaustive des constantes physiques. Voici, par exemple, comment accéder à la valeur de la constante d’accélération gravitationnelle terrestre g : >>> import scipy.constants as cst >>> cst.g 9.80665

Nous avons employé ici une technique particulière d’importation du module constants de la bibliothèque scipy en lui attribuant l’étiquette cst. Nous donnerons des explications à ce sujet dans la section 5.1.1 (p. XXX). Une recherche dans Internet avec les mots clés scipy et constants vous donnera plus d’information sur l’ensemble des constantes disponibles. Nous avons compilé dans le tableau 2.5, à la page suivante, certaines des constantes les plus courantes.

Chapitre 2 - Les principes de base

_Tableau 2 .5 /

Principales constantes en physique et en chimie Symbole usuel

Bibliothèque scipy

Valeur

Nombre d’Avogadro

Avogadro

6, 02214076 × 1023 mol−1

Accélération gravitationnelle terrestre

9, 80665

Constante de gravitation

6, 6743 × 10−11 N ·

Masse du proton

m_p

1, 67262192369 × 10−27 kg

Masse du neutron

m_n

1, 67492749804 × 10−27 kg

Masse de l’électron

m_e

9, 1093837015 × 10−31 kg

Charge élémentaire

1, 602176634 × 10−19 C

Constante magnétique

µ0

mu_0

1, 25663706212 × 10−6 T ·

Constante électrique

ε0

Vitesse de la lumière dans le vide

299792458, 0

Constante de Planck

6, 62607015 × 10−34 J · s

Nom

m s2

epsilon_0 8, 8541878128 × 10−12

m2 kg2

m A

C2 (N · m2 )

m s

Vous remarquerez que la lettre « e » est utilisée à la fois pour la constante mathématique e (2,7183) et pour la charge élémentaire, dont la valeur arrondie est plutôt 1, 6022 × 10−19 C. Il faut savoir que, même si ces deux variables portent le même nom, cela ne pose pas de problème, car elles sont définies dans des bibliothèques différentes (math et scipy.constants). Il est cependant important d’utiliser la bonne bibliothèque pour s’assurer d’importer la bonne valeur ! 2.3.6

Réutiliser et supprimer une variable

En programmation, le signe = est un opérateur d’affectation, ou d’assignation. Par exemple, x = 3 signifie que nous donnons à x la valeur 3. ! ! ! remarque

Le signe « égalité » en Python doit être interprété comme ceci : [nom variable] = [valeur à mettre dans la variable].

rayon_de_la_terre = 6.37e6 La nature même de l’opérateur = permet de réutiliser une variable déjà existante et d’en changer la valeur en cours de programme. Cela peut parfois mener à des expressions ayant un autre sens qu’en mathématiques. Prenez le programme suivant :

La programmation en sciences de la nature

Programme 2.3-4

1 x = 3 2 print(x)

3 x = 3*x + 5 4 print(x) Voici comment l’interpréter, ligne par ligne : • La ligne 1 assigne à la variable x la valeur 3.

• La ligne 2 affiche la valeur de x, soit 3. • La ligne 3 assigne à la variable x une nouvelle valeur, qui est l’ancienne valeur de x multipliée par 3 et à laquelle 5 est ajouté. Cela équivaut à x = 3*3 + 5. • La ligne 4 affiche à la console la nouvelle valeur de x, soit 14.

<<< rappel

En mathématiques, 3x signifie que 3 multiplie la variable x. En programmation, 3x n’est pas une syntaxe permise. Il faut plutôt faire usage de l’opérateur de multiplication et écrire 3*x. Sinon, un programme ne pourrait savoir si xy signifie le produit de x et de y ou s’il fait référence à une variable nommée xy. Il est possible d’effacer une variable et sa valeur de la mémoire en utilisant le mot clé del. >>> x = 6.23e2 >>> print(x) 623.0 >>> del x >>> print(x) Traceback (most recent call last): File "<pyshell>", line 1, in <module> NameError: name 'x' is not defined Le message d’erreur est très clair : après avoir supprimé la variable x, celle-ci n’existe plus dans la mémoire du programme, et sa valeur non plus. Cette fonctionnalité est très utile lorsque des ensembles de données volumineux sont attachés à une variable et qu’il est souhaitable, en cours de programme, de libérer de l’espace dans la mémoire vive. Finalement, il est important de mentionner qu’il est possible de changer complètement la valeur et le type d’une variable en Python. >>> valeur = 45 >>> print(valeur + 20) 65 >>> valeur = "ok" >>> print(valeur + 20) Traceback (most recent call last): File "<string>", line 5, in <module> TypeError: can only concatenate str (not "int") to str La variable valeur, bien que définie en tant que nombre, a changé de type en cours de route. Il n’est donc plus possible de l’additionner à un autre nombre. Il faut être prudent pour éviter une telle situation, car cela peut causer des problèmes importants.

Chapitre 2 - Les principes de base

2.3.7

Échanger deux variables

Dans certains contextes, il peut être nécessaire d’échanger les valeurs de deux variables. Par exemple, supposons que la variable x ait la valeur 5 et que la variable y ait la valeur 2. L’objectif du programme qui suit est de faire en sorte qu’à la fin, x vaille 2 et y vaille 5. Cependant, le résultat obtenu ne sera pas celui désiré. Trouvez l’erreur. Programme 2.3-5

1 2 3 4

x = 5 y = 2 y = x x = y

En effet, nous pouvons remarquer qu’après la ligne 3 , les variables x et y vaudront toutes les deux 5. La ligne 4 n’apportera donc aucun changement. À partir du moment où y = x, la valeur initiale de y est en effet perdue. La façon classique de remédier à ce problème est d’enregistrer la valeur de y dans une variable temporaire, aussi appelée variable tampon. Le programme suivant fait un usage approprié de cette technique. Programme 2.3-6

x = 5 y = 2 temp = y y = x x = temp Fait intéressant, Python permet d’assigner simultanément les valeurs de plusieurs variables d’un seul coup. Si on utilise la bonne syntaxe, cela permet d’éviter l’usage de la variable temp comme cela a été fait dans le programme ci-dessus. Voici un exemple de programme compact qui aura exactement le même résultat que le programme 2.3-6. Programme 2.3-7

x, y = 5, 2 x, y = y, x ! ! ! remarque

Il est possible de définir sur une seule ligne autant de variables que désiré. Si cela permet d’écrire des programmes plus compacts, ils seront cependant difficiles à lire. Un bon programme sera un compromis entre clarté, lisibilité et efficacité.

La programmation en sciences de la nature

///Les.exercices/////////// Résolvez ces problèmes à l’aide de l’éditeur de programme. Utilisez des variables pour définir les valeurs numériques nécessaires aux calculs et la fonction print()pour afficher les résultats. 1 _

Écrivez un programme pour afficher votre nom (str), votre âge (int) et si vous êtes un adulte ou non (bool), et ensuite le contenu de ces variables. Un exemple de résultat attendu serait : Je m'appelle Sébastien J'ai 36 ans Je suis un adulte: True

Écrivez un programme pour calculer le montant total d’une facture à partir du montant avant taxes. Le montant de la facture (nombre à virgule) doit être dans une variable. Calculez la TPS (5 %), la TVQ (9,975 %) et le montant total, puis stockez le résultat dans des variables séparées avant d’afficher le tout. Le résultat attendu est celui-ci : Montant facture: 10$ Montant TPS: 0.5$ Montant TVQ: 0.9975$ -----------------------Montant Total: 11.4975$

Calculez le volume d’une sphère de 3 m de rayon en définissant au préalable des variables pour r et π . La formule pour calculer le volume d’une sphère : V =

4πr3 . 3

Écrivez un programme qui calcule la longueur de l’hypoténuse d’un triangle rectangle à partir des variables représentant les longueurs de ses deux côtés a et b.

a. Testez d’abord votre programme en utilisant a = 3 et b = 4, et comparez avec le résultat obtenu à l’aide de la calculatrice.

b. Calculez ensuite la longueur de l’hypoténuse d’un triangle rectangle avec a = 5 et b = 19.

Sachant que la constante gravitationnelle universelle est G = 6, 67408 × 10−11 Nm2 /kg2, que la masse de la Terre est M = 5, 972 × 1024 kg et que le rayon de la Terre est R = 6 371 km, écrivez un programme qui calcule le module de l’accélération gravitationnelle à la surface de la Terre. GM La formule pour calculer l’accélération gravitationnelle : g =

À une distance d de la surface de la Terre, le module de l’accélération gravitationnelle est donné par l’expression suivante :

GM (R + d)2

a. Écrivez un programme qui calcule a et vérifiez qu’il donne bien g = 9, 82 m/s2 lorsque d = 0 km.

b. Par essais et erreurs, trouvez, à quatre chiffres significatifs près, la distance d à laquelle le module de l’accélération gravitationnelle donne 1, 000 m/s2 .

Chapitre 2 - Les principes de base

La vitesse de propagation d’une maladie infectieuse, correspondant au nombre de nouveaux cas par jour, est donnée par

v = bIS où I est la proportion de la population qui est infectée, S est la proportion de la population susceptible d’attraper la maladie et b est une constante qui dépend du degré de contagion et des contacts des personnes infectées avec les autres. La valeur de b diminue lorsque des mesures sont prises pour réduire la transmission entre les personnes infectées et celles susceptibles d’attraper la maladie. L’addition du nombre de personnes infectées (I ), du nombre de personnes susceptibles de contracter la maladie (S) et du nombre de personnes remises et considérées comme immunisées (R) donne l’ensemble de la population. Dans ce cas, I + S + R = 8 485 000.

a. Écrivez un programme qui calcule le nombre v de nouveaux cas par jour si b = 0, 2 × 10−8, I = 20 000 et R = 225 245.

b. Normalement, I et S sont connus, et la valeur de v est observée quotidiennement. Les chercheurs tentent alors de trouver la valeur de b. Écrivez un programme qui donne la valeur de b pour les valeurs de I, S et v indiquées ci-dessous.

i. Calculez b, alors que I = 24 000 et R = 119 000, sachant qu’il y a 1 194 nouveaux cas par jour.

ii. Refaites le calcul, alors que I = 60 000 et R = 242 500, sachant qu’il y a 2 000 nouveaux cas par jour.

Écrivez un programme qui calcule la valeur des deux racines de l’équation quadratique :

ax2 + bx + c = 0

a. a = −2, b = 3 et c = 10 b. a = 1, b = −4 et c = −2 c. a = 1 × 10−4, b = 3 × 106 et c = −2 × 10−4 Pensez aux priorités d’opérations et aux parenthèses. La solution de l’équation quadratique est :

√ x=

−b ±

b2 − 4ac 2a

Zone.défi 9_

Étant donné le programme suivant, répondez aux questions. Programme 2.3-8

x = 3 + 4**2 y = x - 4 z = y - x x = y * z - 3 y = 3 x + y + z print(x) print(y) print(z)

La programmation en sciences de la nature

a. Sans exécuter le programme et sans l’aide du débogueur, déterminez quelle est la valeur finale de x, y et z.

b. Exécutez le programme et vérifiez vos réponses. 10 _

Étant donné le programme suivant, répondez aux questions. Programme 2.3-9

x, y, z = 3, 2, -4 x, y, z = x + 4, z, y - 2 x, y, z = x + y, 3*z, z print(x) print(y) print(z)

a. Sans exécuter le programme et sans l’aide du débogueur, déterminez quelle est

la valeur finale de x, y et z. Détaillez à chaque étape ce qu’il advient des variables x, y et z.

b. Exécutez le programme et vérifiez vos réponses. 1 1 _

La formule quadratique permet de résoudre une équation polynomiale de degré 2. Une telle formule existe aussi pour une équation polynomiale de degré 3 :

ax3 + bx2 + cx + d = 0 Vous devez réaliser, par étapes, un programme permettant de résoudre cette équation.

a. Pour commencer, utilisez a = 1, b = 2, c = 1 et d = 1 et écrivez les directives pour créer les deux variables suivantes :

A = b2 − 3ac B = 2b3 − 9abc + 27a2 d

b. Puis, écrivez la ou les directives pour calculer C=

B+

√ B 2 − 4A3 2

c. Écrivez également les directives pour calculer une des trois racines de l’équation x=−

1 3a

b+C +

A C

et l’afficher à la console.

d. Vérifiez votre programme en affichant à la console le résultat de

ax3 + bx2 + cx + d obtenu = 0 avec la valeur de x trouvée à l’étape précédente.

Le résultat devrait être une très petite valeur, de l’ordre de 1e-14 ou moins.

e. Finalement, trouvez une des solutions de 3x3 − 2x2 + 5x − 7 = 0

Chapitre 2 - Les principes de base