Python Language
Matematikmodul

Avrundning: rund, golv, tak, trunkel

Förutom den inbyggda round funktion, math ger modulen floor , ceil och trunc funktioner.

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

Varning!

Liksom med någon flytande punktrepresentation kan vissa bråk inte representeras exakt . Detta kan leda till något oväntat avrundningsbeteende.

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

Varning om golvet, trunken och heltalets uppdelning av negativa siffror

Python (och C ++ och Java) avrundar från noll för negativa siffror. Överväga:

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

logaritmer

math.log(x) ger den naturliga (bas e ) logaritmen av x .

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

math.log kan förlora precision med siffror nära 1 på grund av begränsningarna för flytande punktnummer. För att exakt beräkna loggar nära 1, använd math.log1p , som utvärderar den naturliga logaritmen till 1 plus argumentet:

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

math.log10 kan användas för loggar bas 10:

math.log10(10)  # 1.0

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

Kopiera skyltar

I Python 2.6 och högre math.copysign(x, y) x med tecknet på y . Det returnerade värdet är alltid en 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

Trigonometri

Beräknar längden på hypotenusen

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

Konvertera grader till / från radianer

Alla math förväntar sig radianer så du måste konvertera grader till radianer:

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

Alla resultat av de omvända trigonometiska funktionerna returnerar resultatet i radianer, så du kan behöva konvertera det tillbaka till grader:

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

Sinus-, kosinus-, tangent- och inversfunktioner

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

Förutom math.atan finns det också en två-argument math.atan2 funktion, som beräknar rätt kvadrant och undviker fallgrupper av delning med noll:

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"

Hyperbolisk sinus, kosinus och tangens

# 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

Konstanter anter~~POS=HEADCOMP

math innehåller två vanligtvis använda matematiska konstanter.

• math.pi - Den matematiska konstanten pi
• math.e - Den matematiska konstanten e (basen för naturlig logaritm)

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

Python 3.5 och högre har konstanter för oändlighet och NaN ("inte ett tal"). Den äldre syntaxen för att skicka en sträng att float() fungerar fortfarande.

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

Fantastiska siffror

Fantasiska nummer i Python representeras av ett "j" eller "J" som följer målnumret.

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

Infinity och NaN ("inte ett tal")

I alla versioner av Python kan vi representera oändlighet och NaN ("inte ett tal") enligt följande:

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

I Python 3.5 och högre kan vi också använda de definierade konstanterna math.inf och math.nan :

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

Strängrepresentationerna visas som inf och -inf och nan :

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

Vi kan testa för antingen positiv eller negativ oändlighet med isinf metoden:

math.isinf(pos_inf)
# Out: True

math.isinf(neg_inf)
# Out: True

Vi kan testa specifikt för positiv oändlighet eller negativ oändlighet genom direkt jämförelse:

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 och högre möjliggör också kontroll av finitet:

math.isfinite(pos_inf)
# Out: False

math.isfinite(0.0)
# Out: True

Jämförelseoperatörer fungerar som förväntat för positiv och negativ oändlighet:

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

Men om ett aritmetiskt uttryck producerar ett värde större än det maximala som kan representeras som en float , blir det oändligt:

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

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

Men delning med noll ger inte ett resultat av oändlighet (eller negativ oändlighet i förekommande fall) utan snarare ger ett ZeroDivisionError undantag.

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

# Out: Division by zero

Aritmetiska operationer på oändlighet ger bara oändliga resultat, eller ibland 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 är aldrig lika med någonting, inte ens sig själv. Vi kan testa för det är med isnan metoden:

not_a_num == not_a_num
# Out: False

math.isnan(not_a_num)
Out: True

NaN jämför alltid som "inte lika", men aldrig mindre än eller större än:

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

Aritmetiska operationer på NaN ger alltid NaN. Detta inkluderar multiplikation med -1: det finns ingen "negativ NaN".

5.0 * not_a_num
# Out: nan

float('-nan')
# Out: nan

-math.nan
# Out: nan

Det finns en subtil skillnad mellan de gamla float av NaN och oändlighet och Python 3.5+ math bibliotekskonstanter:

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 för snabbare exponentiering

Använda tidsmodulen från kommandoraden:

> 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

Den inbyggda ** -operatören är ofta praktiskt, men om prestanda är väsentligen, använd math.pow. Tänk dock på att pow returnerar flottörer, även om argumenten är heltal:

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

Komplexa siffror och cmath-modulen

cmath modulen liknar math , men definierar funktioner lämpligt för det komplexa planet.

Först och främst är komplexa nummer en numerisk typ som ingår i själva Python-språket snarare än att tillhandahållas av en biblioteksklass. Därför behöver vi inte import cmath för vanliga aritmetiska uttryck.

Observera att vi använder j (eller J ) och inte i .

z = 1 + 3j

Vi måste använda 1j eftersom j skulle vara namnet på en variabel snarare än en numerisk bokstav.

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

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

Vi har den real delen och den imag (imaginära) delen, såväl som det komplexa 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

De inbyggda funktionerna abs och complex är också en del av själva språket och kräver ingen import:

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)

Den complex funktionen kan ta en sträng, men den kan inte ha mellanslag:

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

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

Men för de flesta funktioner behöver vi modulen, till exempel sqrt :

import cmath

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

Naturligtvis är beteendet hos sqrt olika för komplexa siffror och verkliga siffror. I icke-komplex math kvadratroten av ett negativt antal ett undantag:

import math

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

Funktioner tillhandahålls för att konvertera till och från polära koordinater:

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)

Det matematiska området för komplex analys ligger utanför detta exempel, men många funktioner i det komplexa planet har ett "grenskur", vanligtvis längs den verkliga axeln eller den imaginära axeln. De flesta moderna plattformar stöder "signerad noll" som anges i IEEE 754, vilket ger kontinuiteten för dessa funktioner på båda sidor av grenskärningen. Följande exempel är från Python-dokumentationen:

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

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

cmath modulen tillhandahåller också många funktioner med direkta motsvarigheter från math .

Förutom sqrt finns det komplexa versioner av exp , log , log10 , de trigonometriska funktionerna och deras inverser ( sin , cos , tan , asin , acos , atan ), och de hyperboliska funktionerna och deras inverser ( sinh , cosh , tanh , asinh , acosh , atanh ). Observera dock att det inte finns någon komplex motsvarighet till math.atan2 , math.atan2 två-argumentform.

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

Konstanterna pi och e tillhandahålls. Observera att dessa är float och inte complex .

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

cmath modulen tillhandahåller också komplexa versioner av isinf , och (för Python 3.2+) är isfinite . Se " Oändlighet och NaN ". Ett komplext antal anses oändligt om antingen dess verkliga del eller dess imaginära del är oändlig.

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

På samma cmath ger cmath modulen en komplex version av isnan . Se " Oändlighet och NaN ". Ett komplext nummer betraktas som "inte ett tal" om antingen dess verkliga del eller den imaginära delen är "inte ett tal".

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

Observera att det inte finns någon cmath motsvarighet till math.inf och math.nan (från Python 3.5 och högre)

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'

I Python 3.5 och högre finns det en isclose metod i både cmath och math .

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

z
# Out: (1.0000000000000002+1.0000000000000002j)

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