Les modules utiles pour les mathématiques

Le module math

Lorsqu'on utilise Python comme calculatrice, on rencontre très vite des problèmes.

Exemples : Si on teste les instructions suivantes, on obtient des messages d'erreur.

>>>sqrt(25)
>>>cos(pi/4)
>>>exp(0)
...

Pourtant en mathématiques, nous avons besoin de calculer ces nombres. Nous avons déjà vu un exemple qui permet d'éviter ces messages d'erreur. Il suffit d'importer le module math de Python en utilisant l'une des méthodes suivantes.

>>> import math
>>> math.sqrt(25)
5.0
>>> math.cos(math.pi/3)
0.5000000000000001
>>> math.floor(4.546)
4

>>> from math import *
>>> sqrt(25)
5.0
>>> cos(pi/3)
0.5000000000000001
>>> floor(4.546)
4

La solution de droite permet d'éviter d'écrire ''math.'' devant toutes les expressions mathématiques dont nous aurons besoin.

La liste des fonctions mathématiques contenues dans le module math se trouve à cette adresse :

Plus généralement, la liste des modules Python se trouve à l'adresse :

Comment connaître toutes les fonctions contenues dans un module ?

Quelque soit le module que l'on importe, on peut obtenir la documentation correspondante ou des informations sur une fonction à l'aide des instructions suivantes.

>>>Import math         #on importe le module math
>>>help(math)          #on obtient la liste des fonctions et leur description
>>>help(math.log)      #on obtient la description de la fonction log

La module random

Le module random propose des fonctions permettant de générer des nombres pseudo aléatoires.

La liste des fonctions contenues dans le module random se trouve à cette adresse :

>>> import random >>> random.random() 0.028211960331271158

>>> from random import * >>> random() 0.33274126768250034

Plus généralement, la liste des modules Python se trouve à l'adresse :

Le module fractions

Voilà un module bien pratique !

>>> from fractions import Fraction             #fractions avec un s !
>>> Fraction(1,3)+Fraction(1,6)
Fraction(1, 2)

La module turtle

Ce module va permettre de s'appuyer sur les connaissances que les élèves, sortant du collège, auront en Scratch pour découvrir Python.

Voici deux premiers exemples d'utilisation de ce module.

>>> from turtle import *
>>> color('red')
>>> down()
>>> for i in range(4):
	forward(100)
	left(90)
>>>up()

from turtle import *
color('red', 'yellow')
begin_fill()
while True:
    forward(200)
    left(170)
    if abs(pos()) < 1:
        break
end_fill()
done()

L'exemple de droite est l'exemple que l'on peut trouver sur le site python.org l'adresse :

Voici les principales fonctions du module turtle dont on peut avoir besoin pour commencer.

reset()                       #On efface tout et on recommence   
goto(x,y)                     #aller au point de coordonnées (x,y)  
forward(d) ; backward(d)      #avancer, reculer d'une distance d 
up() ; down()                 #relever, abaisser le crayon 
left(alpha) ; right(alpha)    #tourner à gauche, tourner à droite d'un angle alpha (en degrés)
color(couleur) ; width(l)     #couleur et épaisseur du tracé
fill(1)                       #remplir un contour fermé

En utilisant les fonctions du module turtle qui se trouve à l'adresse précédente, on peut, par exemple, essayer de dessiner cette étoile en changeant les couleurs, ses dimensions, en la dessinant au point de coordonnées (100,100), en en dessinant plusieurs...

le module complexe

Le module complexe est aussi à découvrir. On trovera des exemples à l'adresse :

Calcul formel : le module de calcul formel sympy

Pour commencer, toujours dans l'IDLEX, il faut importer le module sympy en tapant l'instruction :

from sympy import *

Ceci étant fait, vous pouvez, par exemple, tester les fonctions suivantes.

>>> x=symbols('x')
>>> y=symbols('y')
>>> simplify((x+y)**2-(x-y)**2)
4*x*y

>>> x=symbols('x')
>>> y=symbols('y')
>>> expand((x+y)**2)
x**2 + 2*x*y + y**2

>>> x=symbols('x')
>>> y=symbols('y')
>>> simplify((x+y)**2-(x-y)**2)
4*x*y
>>> factor(x**2-5*x+4)
(x - 4)*(x - 1)

>>> expression1=2*x+5*x**3+3*x-6*x**2+7+3*x
>>> expression1
5*x**3 - 6*x**2 + 8*x + 7
>>> expression2=2*y*x**4+3*y*x**2+5*y*x**4-4*y*x**4
>>> expression2
3*x**4*y + 3*x**2*y

>>> cancel((x**2+x)/(x**2-x))
(x + 1)/(x - 1)

>>> diff(cos(x),x)
-sin(x)
>>> diff(exp(-x),x)
-exp(-x)

>>> integrate(cos(x),x)
sin(x)
>>> integrate((1/sqrt(2*pi))*exp(-(x**2/2)),(x,-oo,oo))
1

>>> limit(sin(x)/x,x,0)
1
>>> limit(x*exp(x),x,-oo)
0
>>> limit(1/x,x,0,'+')
oo
>>> limit(1/x,x,0,'-')
-oo

Remarque : Le signe infini se code à l'aide de 2 lettre o cote à cote : oo

>>> solveset(Eq(x**2-2*x+1,0),x)
{1}
>>> solveset(Eq(x**2-2*x+1,x),x)
{-sqrt(5)/2 + 3/2, sqrt(5)/2 + 3/2}

>>> factorial(6)
720
>>> binomial(4,2)
6

Vous trouverez une liste bien plus grande à l'adresse :

Un éclaircissement sur les importations de module

Supposons que Python ait un module nommé module_fictif et supposons que dans ce module, il y ait une fonction nommé phonksion. Pour importer ce module et/ou utiliser sa fonction phonksion, dans les instructions suivantes, on a trois possibilités.

1. Méthode 1 : On saisit from module_fictif import *
   Dans ce cas toutes les fonctions de ce module peuvent être utilisées en les nommant quand on en a besoin. Ce serait le cas pour la fonction fictive phonksion.
2. Méthode 2 : on saisit import module_fictif
   Dans ce cas, pour utiliser une fonction de ce module, il faudra précéder le nom de la fonction de "module_fictif.". En particulier pour notre fonction phonksion, il faudrait saisir : module_fictif.phonksion
3. Méthode 3 : si on a besoin que de la fonction phonksion, on peut se contenter de saisir :
   from module_fictif import phoncsion

Dans le cas de la fonction cosinus du module math, voici 3 exemples qui devraient vous éclairer,

>>> from math import *
>>> cos(pi/6)
0.8660254037844387

>>> import math
>>> math.cos(pi/6)
Traceback (most recent call last):
  File "", line 1, in 
    math.cos(pi/6)
NameError: name 'pi' is not defined
>>> math.cos(math.pi/6)
0.8660254037844387

>>> from math import cos
>>> cos(pi/6)
Traceback (most recent call last):
  File "", line 1, in 
    cos(pi/6)
NameError: name 'pi' is not defined
>>> cos(0)
1.0

Dans l'exemple 1 : aucun problème !
Dans l'exemple 2 : on doit écrire « math. » devant toute fonction ou ''objet'' du module math. C'est pour cela que l'on a un message d'erreur si on saisit math.cos(pi/6) car pi n'est pas connu.
Dans l'exemple 3 : on importe la fonction cos du module math et encore une fois pi n'est pas reconnu et entraîne un message d'erreur à son utilisation. Par contre tout se passe bien si on tape cos(0).

Dernières remarques au sujet de l'importation des modules :

Prenons un exemple :

>>> import math as m
>>> m.cos(0)
1.0

Pour ne pas avoir à écrire le nom du module suivi d'un point devant chaque fonctions de ce module, il suffit de lui donner un nom plus court. Quand on écrit :

 import math as m

c'est comme si on écrivait "importer le module math alias m".

Le module MatplotLib

Ce module va permettre de dessiner des courbes. Son importation peut se faire de deux manières.

>>>from pylab import *

>>>x = array([1, 3, 4, 6])
>>>y = array([2, 3, 5, 1])
>>>plot(x, y)

>>>show() # affiche la figure a l'ecran

>>>import numpy as np
>>>import matplotlib.pyplot as plt

>>>x = np.array([1, 3, 4, 6])
>>>y = np.array([2, 3, 5, 1])
>>>plt.plot(x, y)

>>>plt.show() # affiche la figure a l'ecran

Pour plus de renseignements sur le module matplolib :