Mathématiques avec Python

Guillaume Saupin, "70 concepts mathématiques expliqués avec Python ", Dunod , 2023

1) Abrégé de Python

1) Type

Le typage est dynamique, autrement dit, une variable peut.
changer de type en cours de route.

type(5) → <class 'int'>
type('ab') → <class 'str'>
type(1.2) → <class 'float'>
type(True) → <class 'bool'>
type([1,2,'x']) → <class 'list'>
type({1,1,2,'x'}) → <class 'set'>
type({'key1':1,'key2' : 2, key3 : 3}) → <class 'dict'>
type(type(5)) → <class 'type'>

2) Opération

s='abcd'
s+s → 'abcdabcd'
len(s) → 4
s[:3] → 'abc'

3) Boucle

s=0
for i in range(1,10):
s += i
s → 45

while i>0:
....

for i in [2,3,5,7]
....

continue # Passe une itération
break # Sort de la boucle

4) Fonction

def f(x,y):
return x*y
f(2,3) → 6

f=lambda x,y: x**y

4) Condition

if not x<5 :
    x=x//4
elif x==4 :
    x=-5
else:
    x=-3*x+1

x=5 if y==3 else 6 # x est égale à 5 ou 6 selon

5) Map

[x*x for x in range(1,5)] → [1,4,9,16]
[f(x) if x%2==0 for x in range(1,5)] → [-1,4,-9,16]
[x, for x in range(0,10) if x%2==0] → [0,2,4,8]

D={'key1':1,'key2':2,'key3':3}
D['key2'] → 2
D.items() → dict_items([('key1', 1), ('key2', 2), ('key3', 3)])
A={x:y for x,y in D.items()}
A → {'key1':1,'key2':2,'key3':3}
A={x:y for x,y in D.items() if y>1}
A → {'key2':2,'key3':3}

X=[2,3,4,5]
list( map(lambda x:x*x, X) ) → [4,9,16,25]
def g(x):
return x*x
list( map(g, X) ) → [4,9,16,25]

6) Reduce

from functools import reduce

reduce(lambda x,y: x*y, [1,2,3,4]) → 24 # Egale à ((1*2)*3)*4
reduce(f, X) → 24

X=[2,4,3,1,5] # Valeurs
P=[1,3,5,4,2] # Poids
list( zip(X,P) ) → [(2,1),(4,3),(3,5),(1,4),(5,2)]

# somme pondérée
reduce(lambda x,y: x+y, map(lambda x: x[0]*x[1], zip(X,P))) → 25

2) La surcharge des opérateurs

La surcharge les opérateurs +, -, *, //, /, %, ** ce fait en programmant les méthodes privées qui ont des nom de la forme __xxxx__, Voir : Émuler les types numériques

Opérateur	Méthode privée	Déscription
+	__add__	Addition
-	__sub__	Soustraction
*	__mul__	Multiplication
/	__floordiv__	Division
%	__mod__	Modulo
**	__pow__	Puissance

3) Quelques librairies utiles

.1) Numpy

import numpy as np

v=np.array([1,2,3])
print(v) => [1,2,3]
print(v.sum()) => 6         # Somme
print(v.men()) => 2.0       # Moyenne
print(v.std()) => 0.86       # Ecart type

M= np.matrix([[1,2,3],
                        [4,5,6],
                        [7,8,9]]),
print(M.dot(v))                  # Produit matrice par vecteur
print(np.linalg.inv(M))     # Inversion de matrice

2) Matplotlib

import matplotlib.pyplot as plt
from random import random as rd

X=[rd()-0.5 for i in range(0,20)]
Y=[rd()-0.5 for i in range(0,20)]
plt.plot(X,Y)             # Dessine des traits reliant les points (x,y) à la suite
plt.show()                # Affiche le dessin, jusqu'à ce quon appuit la touche q
plt.scatter(X,Y)       # Dessine chaque point (x,y)
plt.show()                # Affiche le dessin, jusqu'à ce quon appuit la touche q

4) Prédiction polynomiale de degré `d` d'une variable en fonction de `n` variables

On se propose de programmer en python l'algorithme d'optimisation des paramètres d'une fonction polynomial de degrès `d` de prédiction de la variable `y` en fonction des variables `vec x= x_1,x_2,x_2,...,x_n`, et que l'on nomme `f`, en utilisant la méthode de la descente de gradient

On définit l'indice k qui quitte le nombre de composante dans un monôme. `k "∈" {1,2,...,d}`

On définit les indices `j_1,j_2,j_3,...,j_k,...,j_d` qui désigne le numéro de la variable d'entrée compris entre `0` et `n`, sachant que la variable d'entrée numéro zéro est la constante `x_0=1`.

La fonction `f(vecx)` est une combinaison linéaire des monômes suivants :

`AAk "∈" {1,2,...,d}, j_k "∈" {0,1,2,...,n}`

`f(vecx) = sum_( j_1<=j_2<=...<=j_d) a_( j_1,j_2,...,j_d)(x_(j_1)x_(j_2)...x_(j_d))`

Le nombre de paramètres est égale au coefficient binomial :

`((n"+"d),(d))= ((n"+"d)!)/(n!d!)`

Pour que cette fonction de prédiction est une signification statistique, il faut un nombre d'observations beaucoup plus grand. On peut utiliser la règle empirique d'au moins 36 mesures pour mesurer empririquement une valeurs statistique. Et donc qu'il faudrait au moins 36 fois plus d'observations que de paramètres à optimiser.

5) Prédiction polynomiale de degré `d` de `n` variables en fonction de `k` pas de retards des `n` variables

Accueil

Dominique Mabboux-Stromberg
octobre 2025