Python Language
Module Math
Recherche…
Arrondi: rond, sol, plafond, tronc
Outre la fonction round intégrée, le module math fournit les fonctions floor , ceil et trunc .
x = 1.55
y = -1.55
# round to the nearest integer
round(x) # 2
round(y) # -2
# the second argument gives how many decimal places to round to (defaults to 0)
round(x, 1) # 1.6
round(y, 1) # -1.6
# math is a module so import it first, then use it.
import math
# get the largest integer less than x
math.floor(x) # 1
math.floor(y) # -2
# get the smallest integer greater than x
math.ceil(x) # 2
math.ceil(y) # -1
# drop fractional part of x
math.trunc(x) # 1, equivalent to math.floor for positive numbers
math.trunc(y) # -1, equivalent to math.ceil for negative numbers
floor , ceil , trunc et round retournent toujours un float .
round(1.3) # 1.0
round casse toujours les liens à partir de zéro.
round(0.5) # 1.0
round(1.5) # 2.0
floor , ceil et trunc renvoient toujours une valeur Integral , alors que round renvoie une valeur Integral si elle est appelée avec un argument.
round(1.3) # 1
round(1.33, 1) # 1.3
round casse les liens vers le nombre pair le plus proche. Cela corrige le biais vers de plus grands nombres lors de l'exécution d'un grand nombre de calculs.
round(0.5) # 0
round(1.5) # 2
Attention!
Comme pour toute représentation en virgule flottante, certaines fractions ne peuvent pas être représentées exactement . Cela peut entraîner un comportement d'arrondi inattendu.
round(2.675, 2) # 2.67, not 2.68!
Avertissement concernant la division floor, trunc et entier des nombres négatifs
Python (et C ++ et Java) arrondit à zéro pour les nombres négatifs. Considérer:
>>> math.floor(-1.7)
-2.0
>>> -5 // 2
-3
Logarithmes
math.log(x) donne le logarithme naturel (base e ) de x .
math.log(math.e) # 1.0
math.log(1) # 0.0
math.log(100) # 4.605170185988092
math.log peut perdre de la précision avec des nombres proches de 1, en raison des limitations des nombres à virgule flottante. Pour calculer avec précision les journaux proches de 1, utilisez math.log1p , qui évalue le logarithme naturel de 1 plus l'argument:
math.log(1 + 1e-20) # 0.0
math.log1p(1e-20) # 1e-20
math.log10 peut être utilisé pour la base de journaux 10:
math.log10(10) # 1.0
Lorsqu'il est utilisé avec deux arguments, math.log(x, base) donne le logarithme de x dans la base donnée (c'est-à-dire log(x) / log(base) .
math.log(100, 10) # 2.0
math.log(27, 3) # 3.0
math.log(1, 10) # 0.0
Signes de copie
Dans Python 2.6 et math.copysign(x, y) ultérieures, math.copysign(x, y) renvoie x avec le signe de y . La valeur renvoyée est toujours un float .
math.copysign(-2, 3) # 2.0
math.copysign(3, -3) # -3.0
math.copysign(4, 14.2) # 4.0
math.copysign(1, -0.0) # -1.0, on a platform which supports signed zero
Trigonométrie
Calcul de la longueur de l'hypoténuse
math.hypot(2, 4) # Just a shorthand for SquareRoot(2**2 + 4**2)
# Out: 4.47213595499958
Conversion de degrés en radians
Toutes math fonctions math attendent des radians , vous devez donc convertir les degrés en radians:
math.radians(45) # Convert 45 degrees to radians
# Out: 0.7853981633974483
Tous les résultats des fonctions trigonométriques inverses renvoient le résultat en radians, vous devrez donc le convertir en degrés:
math.degrees(math.asin(1)) # Convert the result of asin to degrees
# Out: 90.0
Fonctions sinus, cosinus, tangente et inverse
# Sine and arc sine
math.sin(math.pi / 2)
# Out: 1.0
math.sin(math.radians(90)) # Sine of 90 degrees
# Out: 1.0
math.asin(1)
# Out: 1.5707963267948966 # "= pi / 2"
math.asin(1) / math.pi
# Out: 0.5
# Cosine and arc cosine:
math.cos(math.pi / 2)
# Out: 6.123233995736766e-17
# Almost zero but not exactly because "pi" is a float with limited precision!
math.acos(1)
# Out: 0.0
# Tangent and arc tangent:
math.tan(math.pi/2)
# Out: 1.633123935319537e+16
# Very large but not exactly "Inf" because "pi" is a float with limited precision
math.atan(math.inf)
# Out: 1.5707963267948966 # This is just "pi / 2"
math.atan(float('inf'))
# Out: 1.5707963267948966 # This is just "pi / 2"
En dehors du math.atan il y a aussi une fonction math.atan2 deux arguments, qui calcule le quadrant correct et évite les pièges de la division par zéro:
math.atan2(1, 2) # Equivalent to "math.atan(1/2)"
# Out: 0.4636476090008061 # ≈ 26.57 degrees, 1st quadrant
math.atan2(-1, -2) # Not equal to "math.atan(-1/-2)" == "math.atan(1/2)"
# Out: -2.677945044588987 # ≈ -153.43 degrees (or 206.57 degrees), 3rd quadrant
math.atan2(1, 0) # math.atan(1/0) would raise ZeroDivisionError
# Out: 1.5707963267948966 # This is just "pi / 2"
Sinus hyperbolique, cosinus et tangente
# Hyperbolic sine function
math.sinh(math.pi) # = 11.548739357257746
math.asinh(1) # = 0.8813735870195429
# Hyperbolic cosine function
math.cosh(math.pi) # = 11.591953275521519
math.acosh(1) # = 0.0
# Hyperbolic tangent function
math.tanh(math.pi) # = 0.99627207622075
math.atanh(0.5) # = 0.5493061443340549
Les constantes
modules math comprend deux constantes mathématiques couramment utilisées.
-
math.pi- La constante mathématique pi -
math.e- La constante mathématique e (base du logarithme naturel)
>>> from math import pi, e
>>> pi
3.141592653589793
>>> e
2.718281828459045
>>>
Python 3.5 et supérieur ont des constantes pour l'infini et NaN ("pas un nombre"). L'ancienne syntaxe du passage d'une chaîne à float() fonctionne toujours.
math.inf == float('inf')
# Out: True
-math.inf == float('-inf')
# Out: True
# NaN never compares equal to anything, even itself
math.nan == float('nan')
# Out: False
Nombres Imaginaires
Les nombres imaginaires en Python sont représentés par un "j" ou un "J" suivant le numéro cible.
1j # Equivalent to the square root of -1.
1j * 1j # = (-1+0j)
Infinity et NaN ("pas un nombre")
Dans toutes les versions de Python, nous pouvons représenter l'infini et NaN ("pas un nombre") comme suit:
pos_inf = float('inf') # positive infinity
neg_inf = float('-inf') # negative infinity
not_a_num = float('nan') # NaN ("not a number")
En Python 3.5 et math.nan ultérieures, nous pouvons également utiliser les constantes définies math.inf et math.nan :
pos_inf = math.inf
neg_inf = -math.inf
not_a_num = math.nan
Les représentations de chaîne s'affichent sous la forme inf et -inf et nan :
pos_inf, neg_inf, not_a_num
# Out: (inf, -inf, nan)
Nous pouvons tester l'infini positif ou négatif avec la méthode isinf :
math.isinf(pos_inf)
# Out: True
math.isinf(neg_inf)
# Out: True
Nous pouvons tester spécifiquement l'infini positif ou l'infini négatif par comparaison directe:
pos_inf == float('inf') # or == math.inf in Python 3.5+
# Out: True
neg_inf == float('-inf') # or == -math.inf in Python 3.5+
# Out: True
neg_inf == pos_inf
# Out: False
Python 3.2 et les versions ultérieures permettent également de vérifier la finitude:
math.isfinite(pos_inf)
# Out: False
math.isfinite(0.0)
# Out: True
Les opérateurs de comparaison travaillent comme prévu pour l'infini positif et négatif:
import sys
sys.float_info.max
# Out: 1.7976931348623157e+308 (this is system-dependent)
pos_inf > sys.float_info.max
# Out: True
neg_inf < -sys.float_info.max
# Out: True
Mais si une expression arithmétique produit une valeur supérieure au maximum pouvant être représenté par un float , elle deviendra infinie:
pos_inf == sys.float_info.max * 1.0000001
# Out: True
neg_inf == -sys.float_info.max * 1.0000001
# Out: True
Cependant, la division par zéro ne donne pas un résultat d'infini (ou d'infini négatif le cas échéant), mais plutôt une exception ZeroDivisionError .
try:
x = 1.0 / 0.0
print(x)
except ZeroDivisionError:
print("Division by zero")
# Out: Division by zero
Les opérations arithmétiques sur l'infini donnent simplement des résultats infinis, ou parfois NaN:
-5.0 * pos_inf == neg_inf
# Out: True
-5.0 * neg_inf == pos_inf
# Out: True
pos_inf * neg_inf == neg_inf
# Out: True
0.0 * pos_inf
# Out: nan
0.0 * neg_inf
# Out: nan
pos_inf / pos_inf
# Out: nan
NaN n'est jamais égal à rien, pas même à lui-même. Nous pouvons tester car c'est avec la méthode isnan :
not_a_num == not_a_num
# Out: False
math.isnan(not_a_num)
Out: True
NaN se compare toujours comme "non égal", mais jamais inférieur ou supérieur à:
not_a_num != 5.0 # or any random value
# Out: True
not_a_num > 5.0 or not_a_num < 5.0 or not_a_num == 5.0
# Out: False
Les opérations arithmétiques sur NaN donnent toujours NaN. Ceci inclut la multiplication par -1: il n'y a pas de "NaN négatif".
5.0 * not_a_num
# Out: nan
float('-nan')
# Out: nan
-math.nan
# Out: nan
Il existe une différence subtile entre les anciennes versions float de NaN et infinity et les constantes de la bibliothèque math Python 3.5+:
math.inf is math.inf, math.nan is math.nan
# Out: (True, True)
float('inf') is float('inf'), float('nan') is float('nan')
# Out: (False, False)
Pow pour une exponentiation plus rapide
En utilisant le module timeit depuis la ligne de commande:
> python -m timeit 'for x in xrange(50000): b = x**3'
10 loops, best of 3: 51.2 msec per loop
> python -m timeit 'from math import pow' 'for x in xrange(50000): b = pow(x,3)'
100 loops, best of 3: 9.15 msec per loop
L'opérateur ** intégré est souvent utile, mais si les performances sont essentielles, utilisez math.pow. Veillez toutefois à noter que pow renvoie des flottants, même si les arguments sont des entiers:
> from math import pow
> pow(5,5)
3125.0
Les nombres complexes et le module cmath
Le module cmath est similaire au module math , mais définit les fonctions de manière appropriée pour le plan complexe.
Tout d'abord, les nombres complexes sont un type numérique qui fait partie du langage Python lui-même plutôt que d'être fourni par une classe de bibliothèque. Il n'est donc pas nécessaire d' import cmath pour les expressions arithmétiques ordinaires.
Notez que nous utilisons j (ou J ) et non i .
z = 1 + 3j
Nous devons utiliser 1j car j serait le nom d'une variable plutôt qu'un littéral numérique.
1j * 1j
Out: (-1+0j)
1j ** 1j
# Out: (0.20787957635076193+0j) # "i to the i" == math.e ** -(math.pi/2)
Nous avons la partie real et la partie imag (imaginaire), ainsi que le conjugate complexe:
# real part and imaginary part are both float type
z.real, z.imag
# Out: (1.0, 3.0)
z.conjugate()
# Out: (1-3j) # z.conjugate() == z.real - z.imag * 1j
Les fonctions intégrées abs et complex font également partie du langage lui-même et ne nécessitent aucune importation:
abs(1 + 1j)
# Out: 1.4142135623730951 # square root of 2
complex(1)
# Out: (1+0j)
complex(imag=1)
# Out: (1j)
complex(1, 1)
# Out: (1+1j)
La fonction complex peut prendre une chaîne, mais elle ne peut pas avoir d'espaces:
complex('1+1j')
# Out: (1+1j)
complex('1 + 1j')
# Exception: ValueError: complex() arg is a malformed string
Mais pour la plupart des fonctions, nous avons besoin du module, par exemple sqrt :
import cmath
cmath.sqrt(-1)
# Out: 1j
Naturellement, le comportement de sqrt est différent pour les nombres complexes et les nombres réels. Dans les math non complexes, la racine carrée d'un nombre négatif déclenche une exception:
import math
math.sqrt(-1)
# Exception: ValueError: math domain error
Les fonctions sont fournies pour convertir vers et à partir des coordonnées polaires:
cmath.polar(1 + 1j)
# Out: (1.4142135623730951, 0.7853981633974483) # == (sqrt(1 + 1), atan2(1, 1))
abs(1 + 1j), cmath.phase(1 + 1j)
# Out: (1.4142135623730951, 0.7853981633974483) # same as previous calculation
cmath.rect(math.sqrt(2), math.atan(1))
# Out: (1.0000000000000002+1.0000000000000002j)
Le champ mathématique de l'analyse complexe dépasse le cadre de cet exemple, mais de nombreuses fonctions dans le plan complexe ont une "coupure de branche", généralement le long de l'axe réel ou de l'axe imaginaire. La plupart des plates-formes modernes prennent en charge le «zéro signé» tel que spécifié dans la norme IEEE 754, qui assure la continuité de ces fonctions des deux côtés de la découpe. L'exemple suivant provient de la documentation Python:
cmath.phase(complex(-1.0, 0.0))
# Out: 3.141592653589793
cmath.phase(complex(-1.0, -0.0))
# Out: -3.141592653589793
Le module cmath fournit également de nombreuses fonctions avec des contreparties directes du module math .
En plus de sqrt , il existe des versions complexes de exp , log , log10 , les fonctions trigonométriques et leurs inverses ( sin , cos , tan , asin , acos , atan ), et les fonctions hyperboliques et leurs inverses ( sinh , cosh , tanh , asinh , acosh , atanh ). Notez cependant qu'il n'y a pas d'homologue complexe de math.atan2 , la forme à deux arguments de l'arctangent.
cmath.log(1+1j)
# Out: (0.34657359027997264+0.7853981633974483j)
cmath.exp(1j * cmath.pi)
# Out: (-1+1.2246467991473532e-16j) # e to the i pi == -1, within rounding error
Les constantes pi et e sont fournies. Notez que ceux-ci sont float et non complex .
type(cmath.pi)
# Out: <class 'float'>
Le module cmath fournit également des versions complexes de isinf , et (pour Python 3.2+) isfinite . Voir " Infinity et NaN ". Un nombre complexe est considéré comme infini si sa partie réelle ou sa partie imaginaire est infinie.
cmath.isinf(complex(float('inf'), 0.0))
# Out: True
De même, le module cmath fournit une version complexe de isnan . Voir " Infinity et NaN ". Un nombre complexe est considéré "pas un nombre" si sa partie réelle ou sa partie imaginaire est "pas un nombre".
cmath.isnan(0.0, float('nan'))
# Out: True
Notez qu'il n'y a pas cmath contrepartie des math.inf et math.nan constantes (de Python 3.5 et versions ultérieures)
cmath.isinf(complex(0.0, math.inf))
# Out: True
cmath.isnan(complex(math.nan, 0.0))
# Out: True
cmath.inf
# Exception: AttributeError: module 'cmath' has no attribute 'inf'
Dans Python 3.5 et isclose ultérieures, il existe une méthode isclose dans les modules cmath et math .
z = cmath.rect(*cmath.polar(1+1j))
z
# Out: (1.0000000000000002+1.0000000000000002j)
cmath.isclose(z, 1+1j)
# True