Tutoriel Python - sommaire

Mathématiques avec Python

Dans ce chapitre je vais évoquer des module fractions & maht puis aborder la bibliothèque Numpy.
La bibliothèque Matplotlib, très utile pour représenter des fonctions, est évoquée dans le chapitre suivant car elle permet aussi de réprésenter des séries statistiques.
Avant de traiter les modules fractions & math je reviens sur quelques fonctions "built in" utiles en mathématiques.

Fonctions génériques à vocation mathématique

Commandes à saisir dans la console.

>>> notes = [7,10,13,11,9]
>>> sum(notes)
50
>>> len(notes)
5
>>> sum(notes)/len(notes)
10.0
>>> max(notes)
13
>>> min(notes)
7
>>> sorted(notes)
>>> notes
[7, 9, 10, 11, 13]
>>> pi = 3.14116
>>> round(pi,2)
3.14

J'ai pu calculer la moyenne simple de la série : 50/5 = 10 en combinant les fonctions sum() & len().
Je peux dire grâce à la liste triée, que la médiane est 10 (médiane : élément du milieu dans la série ordonnée).
J'ai aussi utilisé la fonction générique round(nombre, décimales) qui arrondi à l'affichage.

Le module fractions

Vous pouvez manipuler des fractions sous Python grâce au module fractions.
Le module fractions de Python permet de manipuler des nombres rationnels de manière précise, évitant ainsi les erreurs d'arrondi liées à l'arithmétique en virgule flottante.

Commandes dans la console

>>> from fractions import *
>>> unTiers = Fraction(1,3)
>>> unTiers
Fraction(1, 3)
>>>type(unTiers)
class 'fractions.Fraction'>
>>> unDemi = Fraction("1/2")
>>> unQuart = Fraction("1/4")
>>> unTiers + unTiers
Fraction(2, 3)
>>> unTiers + unDemi
Fraction(5, 6)
>>> float(unTiers+unQuart)
0.5833333333333334
>>> unDemi - unTiers
Fraction(1, 6)
>>> unQuart * unTiers
Fraction(1, 12)
>>> unTiers/unQuart
Fraction(4, 3)
>>> Fraction(6/12)
Fraction(1, 2)
>>>

Commentons ces commandes :
• importation du module
• la fonction Fraction est argumentée par deux entiers (numérateur, dénominateur) ou par une chaîne ("numérateur/dénominateur")
• on peut additionner, soustraire, multiplier, diviser plusieurs fractions ; Python réduit au même dnominateur si nécessaire :
  • addition : 1/3 + 1/2 = 5/6 ou dans le jargon Python : Fraction(5,6)
  • soustraction : 1/2 - 1/3 = 1/6 ou en Python : Fraction(1,6)
  • mu1tiplication : 1/4 * 1/3 = 1/12 ou en Python : Fraction(1,12)
  • division : 1/3 / 1/4 = 4/3 ou en Python : Fraction(4,3). Donc il a bien effectué 1/3 * 4/1
• float(unTiers+unQuart) : on peut convertir une fraction en flottant avec la fonction float() ; 1/3 + 1/4 = 7/12 soit environ 0.5833333 ...
• Fraction(6/12) retourne Fraction(1,2) : donc la fraction est simplifiée

Utiliser une fraction plutôt qu'un flottant

Il y avait dans le passé un taux de TVA dit majoré qui était égal à 1/3 du hors taxes. Il s'appliquait entre autres au matériel HIFI et aux voitures neuves.
Voyons comment il fallait alors calculer la TVA par rapport au prix hors taxes de l'article.

>>> taux_tva = Fraction(1/3)
>>> hors_taxe = 1000
>>> TVA = round(float(hors_taxe * taux_tva),2)
>>> TVA
333.33

La TVA sur l'article qui vaut 1000 HT est calculée en appliquant le taux sous forme d'une fraction.
Dans la même commande le résultat est arrondi à deux décimales. J'ai donc imbriqué les fonctions round & float.

Module math

Dans un chapitre précédent ce module a simplement été survolé. Il faut désormais approfondir.

Une liste impressionnante de fonctions

>>> import math
>>> dir(math)
... 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'comb', 
'copysign', 'cos', 'cosh',
 'degrees', 'dist', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial',
 'floor', 'fmod', 'frexp', 'fsum',
 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'isqrt',
 'lcm', 'ldexp', 'lgamma', 'log',
 'log10', 'log1p', 'log2', 'modf', 'nan', 'nextafter', 'perm', 'pi', 'pow', 'prod',
 'radians', 'remainder', 'sin', 
 'sinh', 'sqrt', 'tan', 'tanh', 'tau', 'trunc', 'ulp'.
>>>

Tests

>>>import math
>>> math.ceil(3.5)
4
>>> math.floor(3.5)
3
>>> math.fabs(-10)
10.0
>>> math.factorial(5)
120
>>> math.remainder(10,3)
1.0
>>> maliste = [10,15,12,18]
>>> math.fsum(maliste)
55.0
>>> monset = {10,15,12,9}
>>> math.fsum(monset)
46.0
>>> montuple = (10,12,14)
>>> math.fsum(montuple)
36.0
>>> math.gcd(60,90)
30
>>> math.hypot(4,3)
5.0
>>> math.modf(17.25)
(0.25, 17.0)
>>> round(3.99)
4
>>> math.pi
3.141592653589793
>>> pow(10,5)
100000
>>> math.pow(10,5)
100000.0
>>> math.fmod(10,3)
1.0

Les fonctions du module math utilisées :
• ceil(nombre) : arrondit à l'entier supérieur
• floor(nombre) : arrondit à l'entier inférieur
• fabs(nombre) : retourne la valeur absolue
• factorial(n) : retourne la factorielle de l'entier n : 1*2 ... * n
• remainder(dividende, diviseur) : retourne le reste de la division entière ; équivaut à l'expression : dividende%diviseur
• fsum(liste) : retourne la somme des éléments d'une liste, tuple ou ensemble
• gcd(n1,n2): retourne le plus grand commun diviseur entre plusieurs entiers
• hypot(4,3): donne la valeur de l'hypothénuse à partir des côtés de l'angle droit ; équivaut à math.sqrt(4** + 3**)
• modf(flottant): décompose un nombre décimal en partie entière et partie décimale sous forme d'un tuple
• pi : pi n'est pas une fonction du module mais une constante. Donc pas de parenthèses après "pi"
• utilisation de la fonction native pow() puis de la fonction math.pow() (fonction du module math).
• fmod() : retourne le reste de la division euclidienne ; équivaut à remainder()

Trigonométrie

Le module math comprend également toutes les fonctions relatives à la trigonomètrie :

• des fonctions pour convertir radians en degrés ou vice versa
• des fonctions pour calculer sinus, cosinus, tangente à partir d'un angle en radians
• des fonctions pour calculer angles en radians à partir de sinus, cosinus ou tangente.

Rappels : unité d'angle radian

Le radian est une unité de mesure pour mesurer les angles. Un angle d'un radian est un angle qui délimite un arc de cercle d'une longueur égale au rayon du cercle.
Ci-dessous un gif animé qui explique bien la notion de radian :
Un cercle complet (360°) représente un angle de 2π radians. Donc un angle plat c'est π radian et un angle droit c'est π/2 radian.

Rappels de trigonométrie

La trigonométrie est une branche des mathématiques qui traite des relations entre distances et angles dans un triangle rectangle. Sinus, cosinus et tangente sont des rapports entre deux côtés du triangle rectangle. Mais à partir du sinus (ou cosinus ou tangente) on peut déterminer l'angle correspondant.

Quelques fonctions trigonométriques proposées dans le module math

Vérifions tout cela dans la console :

>>> import math
>>> math.pi
3.141592653589793
>>> math.radians(360)
6.283185307179586
>>> math.degrees(2 * math.pi)
360.0
>>> math.sin(radians(45))
0.7071067811865476
>>> math.sin(radians(60))
0.8660254037844386
>>> math.sin(radians(30))
0.49999999999999994

math.pi retourne 3.1416... environ.
L'équivalent de 360° en radians est 6,28 radians.
L'équivalent de 2 ∏ radians = 360°
La fonction radians(angle en degrés) convertit les degrés en radians.
La fonction degrees(angle en radians) convertit les radians en degrés.
La fonction sin(angle en radians) retourne la valeur du sinus. Donc si vous voulez partir d'un angle en degrés il faut imbriquer la fonction radians(angle en degrés) dans sin()
Il existe aussi les fonctions : cos(), tan()

Rappels sur le calcul du sinus, cosinus et tangente d'un angle

Après avoir calculé le sinus ou cosinus ou tangente d'un angle, il fallait rechercher ensuite dans les tables trigonométriques l'angle correspondant.
J'emploie le passé car désormais la recherche d'une valeur d'angle se fait avec une calculette scientifique OU avec Python.

Exercice de trigo

Un triangle rectangle a des côtés de l'angle droit qui mesurent respectivement 3 et 4.
Calculez l’hypoténuse, et les deux angles (autres que l'angle droit) en degrés.
Résolvons ce problème dans la console :

>>> from math import *	
>>> a=4
>>> b=3
>>> h =sqrt(pow(a,2) + pow(b,2))	#j'aurais pu utiliser la fonction hypot
>>> h
5.0
>>> h =math.hypot(a,b)
>>> h
5.0
>>> angle1 = degrees(asin(b/h))
>>> angle
36.86989764584402
>>> angle2 = degrees(asin(a/h))
>>> angle2
53.13010235415599
>>>
>>> angle1 + angle2
90.0

Le carré de l’hypothénuse est égal à la somme des carrés des côtés de l'angle droit.
Donc l'hypothénuse est ici égale à 5
Donc le sinus du premier angle = 3/5 soit un angle de 36,87°
Et le sinus du deuxième angle = 4/5 soit un angle de 53,13°
Contrôle : la somme des deux angles est bien égale à 90°

La fonction asin(sinus) donne l'angle en radians à partir de la valeur du sinus ; il faut ensuite le convertir en degrés avec la fonction degrees()
Il existe aussi les fonctions acos(), atan() qui donnent respectivement l'angle en radians à partir du cosinus ou tangente.

La bibliothèque Numpy

NumPy est une bibliothèque Python permettant entre autres de manipuler des tableaux.
Mais cette bibliothèque a d'autres cordes à son arc ...
Dans ce chapitre je n'évoque que les "ndarray" de Numpy. Les possibilités de Numpy en matière de statistiques seront traitées dans le chapitre suivant.

Les tableaux numpy

En Python, il existe des listes qui peuvent servir de tableaux, mais leur traitement est lent.
NumPy propose un objet nommé "ndarray" qui permet des traitements beaucoup plus rapides qu'avec de simples listes.
Les "ndarray" sont multidimensionnels, homogènes (tous les éléments de même type), itérables, indexables mais immuables (ne peuvent être modifiées après leur création).
Les "ndarray" sont très fréquemment utilisés en science des données, où la vitesse de traitement est essentielle.

Entrainez vous !

En supposant que la bibliothèque "numpy" est installée sur votre PC.

>>> import numpy as np
>>> tab1 = np.array([1,2,3,4,5])
>>> len(tab1)
5
>>> type(tab1)
class 'numpy.ndarray'
>>> np.size(tab1)
5
>>> np.shape(tab1)
(5,)
>>> tab2 = np.array([[1, 2, 3], [4, 5, 6]])
>>> print(tab2)
[[1 2 3]
 [4 5 6]]
>>> np.size(tab2)
6
>>> np.shape(tab2)
(2, 3)
>>> tab1 *3
array([ 3,  6,  9, 12, 15])
>>> tab2 *5
array([[ 5, 10, 15],
       [20, 25, 30]])
>>> tab1[0]
np.int64(1)
>>> tab2[1,2]
np.int64(6)
>>>

J'ai importé la bibliothèque numpy (qui ne comporte qu'un module) avec l'alias np.

tab1 = np.array([1,2,3,4,5]) : j'ai créé un "ndarray" à une dimension nommé "tab1".
Pour créer un ndarray 1D, il suffit de passer une liste en argument de la fonction array().
Je peux obtenir la taille de cet objet de deux façons : len(nomArray) / np.size(nomArray).

tab2 = np.array([[1, 2, 3], [4, 5, 6]]) : j'ai créé un ndarray à deux dimensions nommé "tab2 (2 lignes et 3 colonnes)
Pour créer un tableau 2D, il faut transmettre à la fonction array() une liste de listes grâce à des crochets imbriqués.

La méthode shape(nomArray) indique la forme du tableau :
• nombre de termes pour un tableau 1D
• nombre de lignes puis de colonnes pour un tableau 2D

Je vous montre ensuite comment récupérer un élément de tableau
• tableau 1D : nomArray[indice]
• tableau 2D : nomArray[indice ligne,indice colonne]

Attention le premier terme, la première ligne, la première colonne ont l'indice zéro !
tab1[0] retourne 1 (premier terme)
tab2[1,2] retourne 6 (élément en 2ième ligne, 3ième colonne)

Calculs sur les ndarray

>>> tab1 = np.array([1,2,3,4,5])
>>> tab2 = np.array([[1, 2, 3], [4, 5, 6]])
>>> tab1 *3
array([ 3,  6,  9, 12, 15])

>>> tab2 *5
array([[ 5, 10, 15],
       [20, 25, 30]])
>>>tab3 = np.array([[2, 1, 3],	[3, 2, 1]])
>>> tab2 * tab3
array([[ 2,  2,  9],
       [12, 10,  6]])

tab1 *3 : Tous les termes du ndarray "tab1" multipliés par 3
tab2 *5 : tous les termes du ndarray "tab2 multipliés par 5

tab2 * tab3 : il est possible de réaliser un produit terme à terme grâce à l’opérateur *.
Il faut dans ce cas que les deux ndarray aient les mêmes dimensions ce qui est le cas entre "tab2" et "tab3" (2 lignes et 3 colonnes).

Produit matriciel

Un ndarray peut jouer le rôle d’une matrice si on lui applique une opération de calcul matriciel. Par exemple, la fonction numpy dot() permet de réaliser le produit matriciel.

>>> import numpy as np
>>> m1 = np.array([[1, 2, 3],[4, 5, 6]])
>>> m2 = np.array([[4],[2],[1]])
>>>m3 = np.dot(m1,m2)
>>> m3
array([[11],
       [32]])

La matrice "m1" a trois colonnes et 2 lignes ; la matrice "m2" à 1 colonne et trois lignes donc le produit matriciel est possible.
11 = 4*1 + 2*2 + 3*1
32 = 4*4 + 5*2 + 6*1
m3 est un matrice découlant du produit de m1 par m2.