MANIPULER LES NOMBRES AVEC PYTHON

IPT_TP_manipulation_nombres_PCSI
- page 1 -
MANIPULER LES NOMBRES AVEC PYTHON
Le but de ce TP est d'utiliser Python pour effectuer des calculs sur les nombres entiers et flottants.
On a besoin pour cela de charger des modules.
Modules
Un module est un regroupement de fonctions portant sur un même thème.
Par exemple,
• le module math regroupe des fonctions mathématiques
• le module random regroupe des fonctions permettant de générer des données aléatoires
• le module matplotlib regroupe des commandes pour les tracés de courbes
• le module numpy regroupe des commandes pour créer et manipuler des vecteurs
• le module scipy regroupe des fonctions dédiées au calcul scientifique (résolution d'équations, calcul
matriciel, ... )
• le module sympy regroupe des commandes pour faire du calcul symbolique
• le module fractions permet de manipuler des fractions de façon exacte.
• ...
Certains modules sont déjà préchargés dans la console Python de Spyder. C'est le cas de numpy, scipy, matplotlib.
Importation d'un module
On insère au début du script Python une commande du type "import nom_module" avec différentes syntaxes
d'importation possibles :
>>> import math
Les commandes du module math sont toutes chargées mais doivent être préfixées par "math" .
exemple : math.cos(math.pi/4)
>>> from math import *
Les commandes sont également toutes chargées mais n'ont pas besoin d'être préfixées pour être comprises par
l'interpréteur.
exemple : cos(pi/4).
Par contre, si un autre module possède une fonction nommée cos (numpy par exemple), il peut y avoir des
conflits. C'est la fonction du dernier module chargé qui prévaut.
>>> from math import floor
On n'importe que la fonction dont on a besoin, en l'occurrence ici « floor » (partie entière). On utilise cette
possibilité pour certains modules très volumineux (comme scipy). On importe seulement ce dont on a besoin.
print(dir(math)) : affiche toutes les fonctions du module math
(la même syntaxe prévaut pour d'autre type d'objets) dir(int), dir(str), etc ... )
Aide sur une fonction : help(math.ceil)

IPT_TP_manipulation_nombres_PCSI
- page 2 -
Le module Math
Opération de base
• + , − , / division flottante (le résultat est un flottant en Python 3), ** puissances (ou bien pow(x,y) = x
y
)
• a//b division entière (quotient dans la division euclidienne de a par b)
a%b (reste dans la division euclidienne de a par b)
Constantes
• math.pi, math.e (ou pi, e, ... selon le mode d'importation).
Fonctions de base :
• cos, sin, tan, acos, asin, atan : fonctions trigonométriques de base et leurs réciproques
• cosh, sinh, tanh, asinh, acosh : fonctions trigonométriques hyperboliques de base et leurs réciproques
• sqrt (racine carrée)
• exp, log, log10, math.log(x, base)
Appel d’une fonction : math.cos(x) (ou simplement cos(x) selon le mode d'importation).
• math.factorial pour les factorielles
• floor (partie entière : plus grand entier ≤ x), ceil (plus petit entier ≥ x), round pour arrondir‹ attention, résultats
flottants même si x est entier !
Un résultat flottant peut-être reconverti en entier par int(x) (renvoie le plus proche entier en direction de 0). La
fonction trunc a le même effet.
• modf(x) = (partie fractionnaire, partie entière)
frexp(x) = (mantisse, exposant) : x = mantisse*2
exposant
avec mantisse dans ]− 1,1[
• radians(x) convertit de degrés en radians
• cmp(x,y) = 1 si x > y, 0 si x = y et – 1 si x < y
Rappel de cours
Un flottant en double précision est codé sur 8 octets, 1 bit pour le signe, 11 bits pour l’exposant (compris entre − 1022
et 1023) et 52 bits pour la mantisse (la mantisse est comprise entre 1 inclus et 2 exclu et les 52 bits décrivent les
décimales)
La précision en entiers longs est illimitée.
Pour faire des calculs sur les nombres flottants avec une haute précision, on peut utiliser le module décimal qui est livré
avec la distribution.

IPT_TP_manipulation_nombres_PCSI
- page 3 -
Le module decimal
Calculs en haute précision sur les flottants.
Importation : from decimal import *
getcontext() donne les paramètres en cours. En particulier,
getcontext().prec = nombre de chiffres significatifs (28 chiffres significatifs par défaut)
La commande decimal.getcontext().prec retourne 28.
Les règles d'arrondi et la précision n'interviennent toutefois que dans les calculs arithmétiques.
Decimal('0.1') renvoie Decimal('0.1') (valeur exacte) tandis que Decimal(0.1) renvoie
0.1000000000000000055511151231257827021181583404541015625
decimal.Decimal('0.1') + decimal.Decimal('0.5') retourne
Decimal('0.6')
decimal.Decimal(0.1) + decimal.Decimal(0.5) retourne (avec 28 chiffres significatifs)
Decimal('0.6000000000000000055511151231')
decimal.Decimal(0.6) retourne
Decimal('0.59999999999999997779553950749686919152736663818359375')
Ces résultats légèrement différents s'expliquent par le fait que 0.1 et 0.6 ne sont pas représentables de façon exacte en
machine (développement binaire illimité).
On peut gérer différentes formes d'arrondi, utile notamment dans les calculs monétaires.
Le module fraction
Il permet d'effectuer des calculs exacts sur les fractions.
Importation : import fractions
fractions.Fraction(2,3) représente la fraction 2/3
‹ fractions.Fraction(0.1) ne retourne pas fractions.Fraction(11,10); par contre fractions.Fraction('0.1') retourne
Fraction(1,10).
fractions.gcd(a,b) calcule le pgcd des entiers a et b
Nombres complexes :
Les nombres complexes s'écrivent sous la forme a + bj (sans * devant j).
‹ si b = 1, il faut écrire a + 1j et non pas 1 + j.
z.imag et z.real donnent les parties imaginaires et réelles du complexe z.
abs(z) donne le module.
Le module cmath fournit des fonctions de la variable complexe. Par exemple : cmath.phase(z) donne l’argument
principal, polar(z) rend le couple (module, argument principal).

IPT_TP_manipulation_nombres_PCSI
- page 4 -
Variables
Dans Python, on crée une variable et on l’affecte en même temps :
>>> ma_variable = valeur
On peut faire des affectations simultanées :
>>> var1, var2 = valeur1, valeur2
On peut réinitialiser une variable :
>>> var = None # aucune valeur (et donc aucun type) n’est affectée à la variable. Tout calcul où x
apparaît déclenchera une erreur.
>>> del var # a le même effet
On peut tester le type d’une variable ou demander quel est son type. Par exemple,
>>> isinstance(var, int) va tester si var est un entier. Réponse bouléenne.
>>> type(var) retourne le type de la variable.
>>> id(var) donne (sous forme décimale) l’adresse en mémoire où la variable est stockée.
Types courants
• int, long (entiers longs), float, complex (nombres complexes)
• str (chaînes), bool (bouléen), unicode
• tuple (suites d'objets), list (listes), dict (dictionnaires), file (fichiers)
• NoneType, function (fonctions), module, ...
Conversions
• bin(entier) (resp. hex(entier)) retourne l'écriture binaire (resp. hexadécimale) de l'entier.
• int(‘nombre binaire’,2) retourne l'écriture en base 10 du nombre binaire.
int(‘nombre hexadécimal’,16) retourne l'écriture en base 10 du nombre hexadécimal.
int('entier', base) retourne l'entier en base 10
int(flottant) donne l'entier le plus proche (en direction de 0) du nombre flottant.
int(chaîne) donne l'entier correspondant si la chaîne de caractères est interprétable comme un entier.
• float(entier) donne l'écriture flottante du nombre entier.
• float.hex(flottant) donne la représentation hexadécimale du flottant.

IPT_TP_manipulation_nombres_PCSI
- page 5 -
Entrées-Sorties
La plupart du temps, le jeu de données nécessaire à des calculs sera introduit par transmission des paramètres lors de
l'appel d'une fonction.
On peut cependant interagir avec un utilisateur directement au clavier, les calculs étant en pause tant que ce dernier n'a
pas validé la donnée demandée.
Il y a une différence dans la syntaxe selon qu'on utilise Python2 ou Python3. On privilégie désormais Python3.
Entrées
L'utilisateur rentre au clavier une donnée conforme à ce qui est demandé dans le texte qui s'affiche à l'écran.
‹ Le résultat est toujours une chaîne de caractères. Il faut convertir la donnée obtenue si on veut faire du calcul
numérique.
Exemple :
>>> x = input("entrer un entier : ") # x est une chaîne de caractères
>>> x1 = int(x) # x1 est un entier
>>> y1 = x1**2 # Si l'on fait le calcul directement sur x au lieu de le faire sur x1, cela provoque une erreur.
Remarque
En Python2, la syntaxe est variable = input(texte ) : la variable prend le type de ce qui est rentré par l‘utilisateur.
L'équivalent du input de Python3 est variable = raw_input(texte ) : la variable est forcément une chaîne de caractères.
Sorties
Pour une sortie vers l'écran, la commande est
>>> print(objets à afficher séparés par des virgules)
Les objets peuvent être de type différent. Exemple,
>>> x, y = 1.2 , 3.4
>>> print("la valeur de x est : ", x, "la valeur de y est : ", y, "la norme du vecteur ('x,y) est : ", sqrt(x**2 + y**2))
Pour insérer un saut de ligne : print('\n'); pour insérer une tabulation : print('\t').
On peut vouloir insérer des valeurs numériques (ou autres) dans une chaîne de caractères.
Syntaxe :
print("chaîne où les valeurs à insérer sont remplacées par des accolades {}").format(suite des éléments à inclure)
A l'intérieur des accolades, on précise le type de la variable à substituer (‹ ne pas oublier " : " dans la syntaxe) :
:d pour un entier relatif
:s pour une chaîne de caractères
:e pour un nombre réel au format exponentiel
:f pour un nombre réel au format décimal
:n.pf pour un formatage des flottants avec n chiffres dont p décimales
:g pour un nombre au format décimal ou exponentiel selon la taille du nombre,
Exemple