Python Language
Moduł matematyczny

Zaokrąglenie: okrągłe, podłogowe, sufitowe, ścięte

Oprócz wbudowanego w round funkcji, math moduł dostarcza floor , ceil i trunc funkcje.

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

round(1.3)  # 1.0

round(0.5)  # 1.0
round(1.5)  # 2.0

round(1.3)      # 1
round(1.33, 1)  # 1.3

round(0.5)  # 0
round(1.5)  # 2

Ostrzeżenie!

Jak w przypadku każdej reprezentacji zmiennoprzecinkowej, niektórych ułamków nie można dokładnie przedstawić . Może to prowadzić do nieoczekiwanego zaokrąglania.

round(2.675, 2)  # 2.67, not 2.68!

Ostrzeżenie o dolnym, obciętym i całkowitym podziale liczb ujemnych

Python (oraz C ++ i Java) zaokrąglają od zera dla liczb ujemnych. Rozważać:

>>> math.floor(-1.7)
-2.0
>>> -5 // 2
-3

Logarytmy

math.log(x) daje logarytm naturalny (podstawowy e ) z x .

math.log(math.e)  # 1.0
math.log(1)       # 0.0
math.log(100)     # 4.605170185988092

math.log może stracić precyzję przy liczbach zbliżonych do 1, z powodu ograniczeń liczb zmiennoprzecinkowych. Aby dokładnie obliczyć logi bliskie 1, użyj math.log1p , który ocenia logarytm naturalny z 1 plus argument:

math.log(1 + 1e-20)  # 0.0
math.log1p(1e-20)    # 1e-20

math.log10 może być używany do dzienników bazy 10:

math.log10(10)  # 1.0

math.log(100, 10) # 2.0
math.log(27, 3)   # 3.0
math.log(1, 10)   # 0.0

Kopiowanie znaków

W Pythonie 2.6 i nowszych math.copysign(x, y) zwraca x ze znakiem y . Zwracana wartość jest zawsze 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

Trygonometria

Obliczanie długości przeciwprostokątnej

math.hypot(2, 4) # Just a shorthand for SquareRoot(2**2 + 4**2)
# Out: 4.47213595499958

Przeliczanie stopni na / z radianów

Wszystkie funkcje math oczekują radianów, więc musisz przeliczyć stopnie na radiany:

math.radians(45)              # Convert 45 degrees to radians
# Out: 0.7853981633974483

Wszystkie wyniki odwrotnych funkcji trygonometrycznych zwracają wynik w radianach, więc może być konieczne przekształcenie go z powrotem na stopnie:

math.degrees(math.asin(1))    # Convert the result of asin to degrees
# Out: 90.0

Funkcje sinus, cosinus, styczna i odwrotne

# 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"

Oprócz math.atan istnieje również math.atan2 funkcja math.atan2 , która oblicza prawidłowy kwadrant i pozwala uniknąć pułapek dzielenia przez zero:

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 hiperboliczny, cosinus i styczna

# 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

Stałe

Moduły math obejmują dwie powszechnie używane stałe matematyczne.

• math.pi - Stała matematyczna pi
• math.e - The stała e (podstawa logarytmu naturalnego)

>>> from math import pi, e
>>> pi
3.141592653589793
>>> e
2.718281828459045
>>>

Python 3.5 i wyższe mają stałe nieskończoności i NaN („nie liczba”). Starsza składnia przekazywania ciągu do float() nadal działa.

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

Wyimaginowane liczby

Liczby urojone w Pythonie są reprezentowane przez „j” lub „J” na końcu numeru docelowego.

1j         # Equivalent to the square root of -1.
1j * 1j    # = (-1+0j)

Nieskończoność i NaN („nie liczba”)

We wszystkich wersjach Pythona możemy przedstawiać nieskończoność i NaN („nie liczbę”) w następujący sposób:

pos_inf = float('inf')     # positive infinity
neg_inf = float('-inf')    # negative infinity
not_a_num = float('nan')   # NaN ("not a number")

W Pythonie 3.5 i wyższe, możemy również użyć zdefiniowane stałe math.inf i math.nan :

pos_inf = math.inf
neg_inf = -math.inf
not_a_num = math.nan

Reprezentacje ciągów są wyświetlane jako inf i -inf oraz nan :

pos_inf, neg_inf, not_a_num
# Out: (inf, -inf, nan)

Możemy przetestować nieskończoność dodatnią lub ujemną za pomocą metody isinf :

math.isinf(pos_inf)
# Out: True

math.isinf(neg_inf)
# Out: True

Możemy bezpośrednio przetestować pod kątem nieskończoności dodatniej lub nieskończoności poprzez bezpośrednie porównanie:

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 i nowsze wersje umożliwiają także sprawdzenie skończoności:

math.isfinite(pos_inf)
# Out: False

math.isfinite(0.0)
# Out: True

Operatory porównania działają zgodnie z oczekiwaniami dla nieskończoności dodatniej i ujemnej:

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

Ale jeśli wyrażenie arytmetyczne wytworzy wartość większą niż maksimum, które można przedstawić jako liczbę float , stanie się nieskończonością:

pos_inf == sys.float_info.max * 1.0000001
# Out: True

neg_inf == -sys.float_info.max * 1.0000001
# Out: True

Jednak dzielenie przez zero nie daje wyniku nieskończoności (lub ujemnej nieskończoności tam, gdzie to właściwe), a raczej podnosi wyjątek ZeroDivisionError .

try:
    x = 1.0 / 0.0
    print(x)
except ZeroDivisionError:
    print("Division by zero")

# Out: Division by zero

Operacje arytmetyczne na nieskończoności dają po prostu nieskończone wyniki, a czasem 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 nigdy nie jest niczym, nawet sam w sobie. Możemy to sprawdzić za pomocą metody isnan :

not_a_num == not_a_num
# Out: False

math.isnan(not_a_num)
Out: True

NaN zawsze porównuje się jako „nie równy”, ale nigdy mniejszy lub większy niż:

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

Operacje arytmetyczne na NaN zawsze dają NaN. Obejmuje to mnożenie przez -1: nie ma „ujemnego NaN”.

5.0 * not_a_num
# Out: nan

float('-nan')
# Out: nan

-math.nan
# Out: nan

Istnieje jedna subtelna różnica między starymi wersjami NaN i infinity w wersji float a stałymi bibliotekami 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 dla szybszego potęgowania

Za pomocą modułu timeit z wiersza poleceń:

> 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

Wbudowany ** operator często przydaje się, ale jeśli najważniejsza jest wydajność, użyj math.pow. Pamiętaj jednak, że pow zwraca liczby zmiennoprzecinkowe, nawet jeśli argumentami są liczby całkowite:

> from math import pow
> pow(5,5)
3125.0

Liczby zespolone i moduł cmath

Moduł cmath jest podobny do modułu math , ale definiuje funkcje odpowiednio dla płaszczyzny złożonej.

Przede wszystkim liczby zespolone są typem liczbowym, który jest częścią samego języka Python, a nie dostarczany przez klasę biblioteki. Dlatego nie musimy import cmath dla zwykłych wyrażeń arytmetycznych.

Zauważ, że używamy j (lub J ), a nie i .

z = 1 + 3j

Musimy użyć 1j ponieważ j byłoby nazwą zmiennej, a nie literałem liczbowym.

1j * 1j
Out: (-1+0j)

1j ** 1j
# Out: (0.20787957635076193+0j)     # "i to the i"  ==  math.e ** -(math.pi/2)

Mamy real część i imag (wyimaginowany) część, jak również złożoną conjugate :

# 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

Wbudowane funkcje abs i complex są również częścią samego języka i nie wymagają żadnego importu:

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)

Funkcja complex może przyjmować ciąg, ale nie może zawierać spacji:

complex('1+1j')
# Out: (1+1j)

complex('1 + 1j')
# Exception: ValueError: complex() arg is a malformed string

Ale do większości funkcji potrzebujemy modułu, na przykład sqrt :

import cmath

cmath.sqrt(-1)
# Out: 1j

Oczywiście zachowanie sqrt jest różne dla liczb zespolonych i liczb rzeczywistych. W math niezłożonej pierwiastek kwadratowy z liczby ujemnej wywołuje wyjątek:

import math

math.sqrt(-1)
# Exception: ValueError: math domain error

Dostępne są funkcje konwersji do i ze współrzędnych biegunowych:

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)

Matematyczne pole analizy złożonej wykracza poza zakres tego przykładu, ale wiele funkcji w płaszczyźnie złożonej ma „wycięcie gałęzi”, zwykle wzdłuż osi rzeczywistej lub osi urojonej. Większość nowoczesnych platform obsługuje „podpisane zero”, jak określono w IEEE 754, co zapewnia ciągłość tych funkcji po obu stronach cięcia gałęzi. Poniższy przykład pochodzi z dokumentacji języka Python:

cmath.phase(complex(-1.0, 0.0))
# Out: 3.141592653589793

cmath.phase(complex(-1.0, -0.0))
# Out: -3.141592653589793

Moduł cmath zapewnia również wiele funkcji z bezpośrednimi odpowiednikami z modułu math .

Oprócz sqrt istnieją złożone wersje exp , log , log10 , funkcje trygonometryczne i ich inwersje ( sin , cos , tan , asin , acos , atan ) oraz funkcje hiperboliczne i ich inwersje ( sinh , cosh , tanh , asinh , acosh , atanh ). Zauważ jednak, że nie ma złożonego odpowiednika math.atan2 , math.atan2 Argumentowej postaci math.atan2 .

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

Podane są stałe pi i e . Uwaga: są one float i nie są complex .

type(cmath.pi)
# Out: <class 'float'>

Moduł cmath zapewnia również złożone wersje isinf i (dla Python 3.2+) isfinite . Zobacz „ Infinity and NaN ”. Liczbę zespoloną uważa się za nieskończoną, jeśli jej rzeczywista część lub część urojona jest nieskończona.

cmath.isinf(complex(float('inf'), 0.0))
# Out: True

Podobnie moduł cmath zapewnia złożoną wersję isnan . Zobacz „ Infinity and NaN ”. Liczbę zespoloną uważa się za „nie liczbę”, jeśli jej rzeczywista część lub część urojona nie jest „liczbą”.

cmath.isnan(0.0, float('nan'))
# Out: True 

Uwaga nie ma cmath odpowiednikiem math.inf i math.nan stałych (z Pythona 3.5 i wyższe)

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'

W Pythonie 3.5 i wyższej, istnieje isclose sposób w obu cmath i math modułów.

z = cmath.rect(*cmath.polar(1+1j))

z
# Out: (1.0000000000000002+1.0000000000000002j)

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