Calculs avec Python

Opérateurs usuels

On considère ici les types int, float et complex.

Les valeurs de ces types partagent un certain nombre d’opérations arithmétiques communes (addition, produit, etc.).

Quand on évalue une expression arithmétique contenant des valeurs numériques, on peut considérer le type int comme inclus dans le type float, lui-même inclus dans le type complex.

Lors de l’évaluation d’une telle expression, le calcul s’effectue dans la classe la plus étroite qui soit compatible avec tous les arguments, et c’est dans cette classe qu’est renvoyé le résultat (c’est pour cette raison, par exemple, que la somme de l’entier 2 et du flottant 3.0 est le flottant 5.0).

Voici les principales opérations sur les types numériques:

{x\!+\!y,\ x\!-\!y,\ x\!*\!y,\ x\!/\!y}somme, différence, produit, quotient flottant
{\text{pow}(x, y)\quad x ** y}
{x} à la puissance {y}. Par défaut {0^0=1}
{x // y\quad x \% y}
quotient et reste dans une division euclidienne entre entiers
{\text{divmod}(x, y)}
renvoie le couple {(x//y, x\%y)}
{\text{abs}(x)}
valeur absolue d’un réel, module d’un complexe
{\text{int}(x)\quad\text{float}(x)}
conversion vers le type int, ou vers le type float
{\text{round}(x)\quad\text{round}(x,n)}
arrondit à l’entier le plus proche, ou valeur approchée à {10^{-n}} près
{z.\text{real},\ z.\text{imag},\ z.\text{conjugate()}}partie réelle, partie imaginaire, conjugué
{\text{complex}(x, y)\quad x + y * 1j}
renvoie le nombre complexe {x + iy}

NB : en Python, une source d’erreur classique concerne les divisions par / ou // :

  • L’expression x // y renvoie le quotient entier de l’entier x par l’entier y dans la division euclidienne.
  • L’expression x / y renvoie le quotient flottant de x par y.

Opérateurs avec assignation

Il est courant d’avoir à incrémenter une variable. L’instruction i = i+1 sera avantageusement remplacée par i += 1. On dit que += est un opérateur avec assignation.

Voici la liste des opérateurs avec assignation de Python. Leur portée va bien au delà des types numériques : ils s’appliquent à tous les types sur lesquels l’opération (addition, produit, etc.) a un sens.

{\text{x+=y}} équivautà {\text{x=x+y}}{\text{x-=y}} équivautà {\text{x=x-y}}
{\text{x*=y}} équivautà {\text{x=x*y}}{\text{x/=y}} équivautà {\text{x=x/y}}
{\text{x\%=y}} équivautà {\text{x=x\%y}}{\text{x**=y}} équivautà {\text{x=x**y}}
{\text{x//=y}} équivautà {\text{x=x//y}}

Ces opérations avec assignation ne sont donc pas réservées aux types numériques. Voici trois exemples d’utilisation de += sur des valeurs de différents types. On voit ici qu’il est possible d’écrire plusieurs instructions consécutives sur une même ligne, à condition des les séparer par un point-virgule. Seul le résultat de la dernière instruction de la ligne est affiché.

Fonctions mathématiques usuelles

Quand on lance Python, le nombre de fonctions chargées dans le “noyau” est assez réduit. En particulier, la plupart des fonc- tions mathématiques usuelles (racine carrée, sinus, logarithme, etc.) ne sont pas chargées au démarrage : elles appartiennent à un module nommé math qu’il faut donc importer. Il y a plusieurs possibilités (l’instruction choisie doit bien sûr précéder l’utilisation des fonctions intégrées au module) :

  • import math charge la totalité du module math: les fonctions mathématiques sont alors accessibles sous la forme math.nom_de_la_fonction.
  • from math import * charge la totalité du module math: on accède aux fonctions du module sans utiliser le préfixe “math.”
  • from math import sqrt, log, exp (par exemple) charge seulement certaines fonctions du module: on accède aux fonctions chargées sans le préfixe “math.”

Le module math contient les deux constantes e et pi (e ≈ 2.718281828459045 et π ≈ 3.141592653589793).
Voici l’essentiel des fonctions du module math, évaluées en un argument x quelconque.

exp log log2 log10exponentielle, log népérien, de base 2, de base 10
sqrt cos sin tanracine carrée, fonctions trigo directes (x en radians)
degrees radiansconversion radians → degrés, ou degrés → radians
floor ceil truncpartie entière [x], entier plafond, tronque (direction 0)
factorialfactorielle x! (x dans N)

Quelques fonctions de conversion

Il est souvent utile de pouvoir convertir une valeur d’un type (ou d’une forme) à un(e) autre. Voici quelques possibilités, illustrées par des exemples:

bin (conversion en une chaîne binaire)
bin(1096) ⇒ ‘0b10001001000’ ; bin(2**10-1) ⇒ ‘0b1111111111’
hex (conversion en une chaîne héxadécimale)
hex(123456789) ⇒ ‘0x75bcd15’ ; hex(2**15-1) ⇒ ‘0x7fff’
bool (conversion en un booléen)
bool(1) ⇒ True ; bool(-3) ⇒ True ; bool(0) ⇒ False
chr (convertit un code en le caractère correspondant)
chr(35) ⇒ ‘#’ ; chr(65) ⇒ ‘A’ ; chr(97) ⇒ ‘a’
ord (convertit un caractère en le code correspondant)
ord(‘#’) ⇒ 35 ; ord(‘A’) ⇒ 65 ; ord(‘a’) ⇒ 97
int (conversion en un entier, base de numération optionnelle)
int(3.7) ⇒ 3 ; int(-3.7) ⇒ -3
int(“100”,2) ⇒ 4 ; int(“100”,5) ⇒ 25 ; int(“100”,10) ⇒ 100
float (conversion en un flottant)
float(123) ⇒ 123.0 ; float(2**100) ⇒ 1.2676506002282294e+30
complex (conversion en un nombre complexe)
complex(1) ⇒ (1+0j) ; complex(3,4) ⇒ (3+4j)
print (affiche à l’écran)
print(2+3) ⇒ (affiche 5) ; print(‘2+3’) ⇒ (affiche ‘2+3’)
str (conversion en une chaîne de caractères)
str(123.45) ⇒ ‘123.45’

Fonctions de comparaison

Toutes les valeurs numériques ont une traduction booléenne : 0 représente le “faux”, et toute valeur non nulle représente le “vrai”. Plus généralement, tout objet non vide (chaîne de caractères, liste, etc.) est considéré comme “vrai”, les objets vides représentant donc la valeur “faux”.

Voici les opérateurs qui permettent de comparer des valeurs en Python. Ces opérateurs posent des questions dont la réponse est l’une deux valeurs True ou False du type bool :

< (strictement inférieur à ?)> (strictement supérieur à ?)
<= (inférieur ou égal à ?)>= (supérieur ou égal à ?)
== (égalà?)!= (différent de ?)

On notera bien sûr la différence entre le test d’égalité == et l’instruction d’affectation =.

Voici maintenant les opérateurs qui permettent de combiner des valeurs booléennes entre elles :

or (ou logique)and (et logique)not (négation logique)
  • Quand deux valeurs numériques de types différents (entier, flottant, nombre complexe) sont comparées, elles sont converties dans le type qui les contient toutes les deux. Ainsi Python considère comme égaux l’entier 4 et le flottant 4.0, ou encore le flottant 0. et le nombre complexe 0j.
  • On peut enchaîner les comparaisons. Par exemple l’expression x < y < z signifie (x < y et y < z).
  • Les chaînes de caractères sont comparées selon l’ordre lexicographique (mais les caractères eux-mêmes sont évalués en fonction de leur code numérique : les majuscules viennent donc avant les minuscules).
    On a par exemple les inégalités : A’ < ‘Z’ < ‘a’ < ‘z’
    De même, on a les inégalités : ‘ABC’ < ‘ABc’ < ‘AbC’ < ‘Abc’ < ‘aBC’ < ‘aBc’ < ‘abC’ < ‘abc’
  • Dans une répétition b1 or b2 or · · · or bn de “ou” logiques, les valeurs booléennes b1, . . . , bn sont évaluées de gauche à droite, et l’évaluation s’arrête si l’une d’elles vaut True (car alors toute l’expression vaut True).
    Il en est de même dans une répétition b1 and b2 and · · · and bn de “et” logiques : l’évaluation s’arrête dès que l’une des valeurs bk vaut False : c’est ce qu’on appelle l’évaluation paresseuse des booléens.
  • Remarque : les opérateurs <, <=, >, >=, !=, == ont le même degré de priorité, plus faible que celui des opérateurs arithmétiques. Mais ils sont prioritaires devant not, lui-même prioritaire devant and, lui-même prioritaire devant or.Par exemple x + y < z se lit (x + y) < z, et non pas x + (y < z) :