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
Python 2.x 2.7

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
Python 3.x 3.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
Python 2.x 2.3.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 .

Python 2.x 2.6
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
Python 3.x 3.5
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.

Python 3.x 3.5
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 :

Python 3.x 3.5
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:

Python 3.x 3.2
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
Python 3.x 3.5
-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+:

Python 3.x 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)

Python 3.x 3.5
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 .

Python 3.x 3.5
z = cmath.rect(*cmath.polar(1+1j))

z
# Out: (1.0000000000000002+1.0000000000000002j)

cmath.isclose(z, 1+1j)
# True


Modified text is an extract of the original Stack Overflow Documentation
Sous licence CC BY-SA 3.0
Non affilié à Stack Overflow