Python Language
수학 모듈

반올림 : round, floor, ceil, trunc

내장 round 기능 외에도 math 모듈은 floor , ceil 및 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

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

경고!

부동 소수점 표현과 마찬가지로 일부 분수 는 정확하게 표현할 수 없습니다 . 이로 인해 예기치 않은 반올림 동작이 발생할 수 있습니다.

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

음수의 바닥, trunc 및 정수 나누기에 대한 경고

파이썬 (및 C ++ 및 Java)은 음수에 대해 0에서 멀어집니다. 중히 여기다:

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

로그

math.log(x) 자연 (기본 제공 e 의) 로그 x .

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

math.log 는 부동 소수점 숫자의 한계로 인해 1에 가까운 숫자로 정밀도를 잃을 수 있습니다. 1에 가까운 로그를 정확하게 계산하려면 math.log1p 사용합니다.이 로그에는 1의 자연 로그와 인수를 더한 값이 있습니다.

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

로그베이스에 math.log10 사용할 수 있습니다. 10 :

math.log10(10)  # 1.0

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

간판 복사하기

Python 2.6 이상에서 math.copysign(x, y) 는 y 기호로 x 를 반환합니다. 반환 값은 항상 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

삼각법

빗변의 길이 계산

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

각도를 라디안으로 / 라디안으로 변환

모든 math 함수는 라디안 을 필요로하므로도를 라디안으로 변환해야합니다.

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

역 삼각법 함수의 모든 결과는 결과를 라디안으로 반환하므로 다시 각도로 변환해야 할 수 있습니다.

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

사인, 코사인, 접선 및 역함수

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

math.atan 외에도 올바른 인수를 계산하고 0으로 나누는 함정을 피하는 두 개의 인자 인 math.atan2 함수가 있습니다.

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"

쌍곡선 사인, 코사인 및 접선

# 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

상수

math 모듈에는 일반적으로 사용되는 두 개의 수학 상수가 포함됩니다.

• math.pi - 수학 상수 pi
• math.e - 수학 상수 e (자연 대수의 밑)

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

파이썬 3.5 이상은 무한대와 NaN ( "숫자가 아님")에 대한 상수를가집니다. 문자열을 float() 에 전달하는 이전 구문은 여전히 ​​작동합니다.

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

상상의 수

파이썬에서의 가상 숫자는 대상 번호 뒤의 "j"또는 "J"로 표시됩니다.

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

무한대와 NaN ( "숫자가 아님")

모든 Python 버전에서 다음과 같이 무한대와 NaN ( "숫자가 아님")을 나타낼 수 있습니다.

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

파이썬 3.5 이상에서는 정의 된 상수 인 math.inf 와 math.nan 사용할 수 있습니다.

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

문자열 표현은 inf 와 -inf 및 nan 으로 표시됩니다.

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

isinf 메서드를 사용하여 양수 또는 음수 무한대를 테스트 할 수 있습니다.

math.isinf(pos_inf)
# Out: True

math.isinf(neg_inf)
# Out: True

직접 비교를 통해 양의 무한대 또는 음의 무한대를 구체적으로 테스트 할 수 있습니다.

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 이상에서는 또한 유물을 검사 할 수 있습니다.

math.isfinite(pos_inf)
# Out: False

math.isfinite(0.0)
# Out: True

비교 연산자는 양수 및 음수 무한대에서 예상대로 작동합니다.

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

그러나 산술식이 float 로 표현할 수있는 최대 값보다 큰 값을 생성하면 무한대가됩니다.

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

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

그러나 0으로 나눈 값은 무한대 (또는 음수 무한대)의 결과를 제공하지 않고 ZeroDivisionError 예외를 발생시킵니다.

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

# Out: Division by zero

무한대에 대한 산술 연산은 무한한 결과를 제공하거나 때로는 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은 결코 그 자체가 아닌 어떤 것에도 동등하지 않습니다. isnan 메서드를 사용하여 테스트 할 수 있습니다.

not_a_num == not_a_num
# Out: False

math.isnan(not_a_num)
Out: True

NaN은 항상 "같지 않음"으로 비교되지만 결코 작거나 같지 않습니다.

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

NaN에 대한 산술 연산은 항상 NaN을 제공합니다. 여기에는 -1 배수가 포함됩니다. "음수 NaN"이 없습니다.

5.0 * not_a_num
# Out: nan

float('-nan')
# Out: nan

-math.nan
# Out: nan

NaN과 무한대의 오래된 float 버전과 Python 3.5+ math 라이브러리 상수 사이에는 미묘한 차이가 있습니다.

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

명령 줄에서 timeit 모듈 사용 :

> 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

내장형 ** 연산자는 종종 편리하게 사용되지만, 성능이 핵심이라면 math.pow를 사용하십시오. 그러나 인수가 정수인 경우에도 pow 반환 값은 다음과 같이 나타납니다.

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

복잡한 숫자와 cmath 모듈

cmath 모듈은 math 모듈과 유사하지만 복잡한 평면에 대해 함수를 적절하게 정의합니다.

우선, 복소수는 라이브러리 클래스에서 제공되는 것이 아니라 Python 언어 자체의 일부인 숫자 유형입니다. 따라서 우리는 일반적인 산술 표현식에 import cmath 를 import cmath 할 필요가 없습니다.

우리가 j (또는 J )를 사용하고 i 아니라는 것에 유의하십시오.

z = 1 + 3j

j 는 숫자 리터럴이 아닌 변수의 이름이므로 1j 사용해야합니다.

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

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

우리는이 real 부분과 imag (가상의) 부분뿐만 아니라 복잡한 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

기본 제공 함수 abs 및 complex 도 언어 자체의 일부이므로 가져 오기가 필요하지 않습니다.

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)

complex 함수는 문자열을 취할 수 있지만 공백을 포함 할 수는 없습니다.

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

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

그러나 대부분의 함수들에 대해 모듈을 필요로합니다. 예를 들어 sqrt :

import cmath

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

당연히 sqrt 의 동작은 복소수와 실수에 따라 다릅니다. 비 복잡한 math 에서 음수의 제곱근은 예외를 발생시킵니다.

import math

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

극좌표로 변환하거나 극좌표에서 변환하는 함수가 제공됩니다.

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)

복잡한 분석의 수학 분야는이 예제의 범위를 벗어나지 만 복잡한 평면의 많은 함수는 대개 실수 축 또는 허수 축을 따라 "분기 컷"을 갖습니다. 대부분의 최신 플랫폼은 IEEE 754에 명시된 "signed zero"를 지원합니다. IEEE 754는 분기 절단의 양면에서 해당 함수의 연속성을 제공합니다. 다음 예제는 Python 문서에서 가져온 것입니다.

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

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

cmath 모듈은 math 모듈에서 직접 제공되는 많은 함수를 제공합니다.

sqrt 외에도 exp , log , log10 , 삼각 함수와 그 역 ( sin , cos , tan , asin , acos , atan )의 복잡한 버전과 쌍곡선 함수와 그 역 ( sinh , cosh , tanh , asinh , acosh , atanh ). 그러나 arctangent의 두 인수 형식 인 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

상수 pi 및 e 가 제공된다. 이것들은 float 이며 complex 하지는 않습니다.

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

cmath 모듈은 또한 isinf 복잡한 버전과 (for Python 3.2+) isfinite 합니다. " Infinity 및 NaN "을 참조하십시오. 복소수는 실수 부 또는 허수 부 중 하나가 무한 경우 무한으로 간주됩니다.

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

마찬가지로, cmath 모듈은 isnan 의 복잡한 버전을 제공합니다. " Infinity 및 NaN "을 참조하십시오. 복소수는 실수 부분 또는 허수 부분이 "숫자가 아닌"경우 "숫자가 아닌"것으로 간주됩니다.

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

math.inf 및 math.nan 상수의 cmath 대응 물은 없습니다 (Python 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'

Python 3.5 이상에서는 cmath 및 math 모듈 모두에 isclose 메서드가 있습니다.

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

z
# Out: (1.0000000000000002+1.0000000000000002j)

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