1. math數學函式
1.1 特殊常量
很多數學運算依賴于一些特殊的常量，math包含有π(pi)、e、nan(不是一個數)和infinity(無窮大)的值，
import math print(' π: {:.30f}'.format(math.pi)) print(' e: {:.30f}'.format(math.e)) print('nan: {:.30f}'.format(math.nan)) print('inf: {:.30f}'.format(math.inf))
π和e的精度僅受平臺的浮點數C庫限制，
1.2 測驗例外值
浮點數計算可能導致兩種型別的例外值，第一種是inf(無窮大)，當用double存盤一個浮點數，而該值會從一個具體很大絕對值的值上溢位時，就會出現這個例外值，
import math print('{:^3} {:6} {:6} {:6}'.format( 'e', 'x', 'x**2', 'isinf')) print('{:-^3} {:-^6} {:-^6} {:-^6}'.format( '', '', '', '')) for e in range(0, 201, 20): x = 10.0 ** e y = x * x print('{:3d} {:<6g} {:<6g} {!s:6}'.format( e, x, y, math.isinf(y), ))
當這個例子中的指數變得足夠大時，x的平方無法再存放一個double中，這個值就會被記錄為無窮大，
不過，并不是所有浮點數溢位都會導致inf值，具體地，用浮點值計算一個指數時，會產生OverflowError而不是保留inf結果，
x = 10.0 ** 200 print('x =', x) print('x*x =', x * x) print('x**2 =', end=' ') try: print(x ** 2) except OverflowError as err: print(err)
這種差異是由C和Python所用庫中的實作差異造成的，
使用無窮大值的除法運算未定義，將一個數除以無窮大值的結果是nan(不是一個數)，
import math x = (10.0 ** 200) * (10.0 ** 200) y = x / x print('x =', x) print('isnan(x) =', math.isnan(x)) print('y = x / x =', x / x) print('y == nan =', y == float('nan')) print('isnan(y) =', math.isnan(y))
nan不等于任何值，甚至不等于其自身，所以要想檢查nan，需要使用isnan()，
可以使用isfinite()檢查其是普通的數還是特殊值inf或nan，
import math for f in [0.0, 1.0, math.pi, math.e, math.inf, math.nan]: print('{:5.2f} {!s}'.format(f, math.isfinite(f)))
如果是特殊值inf或nan，則isfinite()回傳false，否則回傳true，
1.3 比較
涉及浮點值的比較容易出錯，每一步計算都可能由于數值表示而引入誤差，isclose()函式使用一種穩定的演算法來盡可能減少這些誤差，同時完成相對和絕對比較，所用的公式等價于：
abs(a-b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol)
默認地，isclose()會完成相對比較，容差被設定為le-09，這表示兩個值之差必須小于或等于le乘以a和b中較大的絕對值，向isclose()傳入關鍵字引數rel_tol可以改變這個容差，在這個例子中，值之間的差距必須在10%以內，
import math INPUTS = [ (1000, 900, 0.1), (100, 90, 0.1), (10, 9, 0.1), (1, 0.9, 0.1), (0.1, 0.09, 0.1), ] print('{:^8} {:^8} {:^8} {:^8} {:^8} {:^8}'.format( 'a', 'b', 'rel_tol', 'abs(a-b)', 'tolerance', 'close') ) print('{:-^8} {:-^8} {:-^8} {:-^8} {:-^8} {:-^8}'.format( '-', '-', '-', '-', '-', '-'), ) fmt = '{:8.2f} {:8.2f} {:8.2f} {:8.2f} {:8.2f} {!s:>8}' for a, b, rel_tol in INPUTS: close = math.isclose(a, b, rel_tol=rel_tol) tolerance = rel_tol * max(abs(a), abs(b)) abs_diff = abs(a - b) print(fmt.format(a, b, rel_tol, abs_diff, tolerance, close))
0.1和0.09之間的比較失敗，因為誤差表示0.1，
要使用一個固定或“絕對”容差，可以傳入abs_tol而不是rel_tol，
import math INPUTS = [ (1.0, 1.0 + 1e-07, 1e-08), (1.0, 1.0 + 1e-08, 1e-08), (1.0, 1.0 + 1e-09, 1e-08), ] print('{:^8} {:^11} {:^8} {:^10} {:^8}'.format( 'a', 'b', 'abs_tol', 'abs(a-b)', 'close') ) print('{:-^8} {:-^11} {:-^8} {:-^10} {:-^8}'.format( '-', '-', '-', '-', '-'), ) for a, b, abs_tol in INPUTS: close = math.isclose(a, b, abs_tol=abs_tol) abs_diff = abs(a - b) print('{:8.2f} {:11} {:8} {:0.9f} {!s:>8}'.format( a, b, abs_tol, abs_diff, close))
對于絕對容差，輸入值之差必須小于給定的容差，
nan和inf是特殊情況，
import math print('nan, nan:', math.isclose(math.nan, math.nan)) print('nan, 1.0:', math.isclose(math.nan, 1.0)) print('inf, inf:', math.isclose(math.inf, math.inf)) print('inf, 1.0:', math.isclose(math.inf, 1.0))
nan不接近任何值，包括它自身，inf只接近它自身，
1.4 將浮點值轉換為整數
math模塊中有3個函式用于將浮點值轉換為整數，這3個函式分別采用不同的方法，并適用于不同的場合，
最簡單的是trunc()，其會截斷小數點后的數字，只留下構成這個值整數部分的有效數字，floor()將其輸入轉換為不大于它的最大整數，ceil()(上限)會生成按順序排在這個輸入值之后的最小整數，
import math HEADINGS = ('i', 'int', 'trunk', 'floor', 'ceil') print('{:^5} {:^5} {:^5} {:^5} {:^5}'.format(*HEADINGS)) print('{:-^5} {:-^5} {:-^5} {:-^5} {:-^5}'.format( '', '', '', '', '', )) fmt = '{:5.1f} {:5.1f} {:5.1f} {:5.1f} {:5.1f}' TEST_VALUES = [ -1.5, -0.8, -0.5, -0.2, 0, 0.2, 0.5, 0.8, 1, ] for i in TEST_VALUES: print(fmt.format( i, int(i), math.trunc(i), math.floor(i), math.ceil(i), ))
trunc()等價于直接轉換為int，
1.5 浮點值的其他表示
modf()取一個浮點數，并回傳一個元組，其中包含這個輸入值的小數和整數部分，
import math for i in range(6): print('{}/2 = {}'.format(i, math.modf(i / 2.0)))
回傳值中的兩個數字均為浮點數，
frexp()回傳一個浮點數的尾數和指數，可以用這個函式創建值的一種更可移植的表示，
import math print('{:^7} {:^7} {:^7}'.format('x', 'm', 'e')) print('{:-^7} {:-^7} {:-^7}'.format('', '', '')) for x in [0.1, 0.5, 4.0]: m, e = math.frexp(x) print('{:7.2f} {:7.2f} {:7d}'.format(x, m, e))
frexp()使用公式x = m * 2**e，并回傳值m和e，
ldexp()與frexp()正好相反，
import math print('{:^7} {:^7} {:^7}'.format('m', 'e', 'x')) print('{:-^7} {:-^7} {:-^7}'.format('', '', '')) INPUTS = [ (0.8, -3), (0.5, 0), (0.5, 3), ] for m, e in INPUTS: x = math.ldexp(m, e) print('{:7.2f} {:7d} {:7.2f}'.format(m, e, x))
ldexp()使用與frexp()相同的公式，取尾數和指數值作為引數，并回傳一個浮點數，
1.6 正號和負號
一個數的絕對值就是不帶正負號的本值，使用fabs()可以計算一個浮點數的絕對值，
import math print(math.fabs(-1.1)) print(math.fabs(-0.0)) print(math.fabs(0.0)) print(math.fabs(1.1))
在實際中，float的絕對值表示為一個正值，
要確定一個值的符號，以便為一組值指定相同的符號或者比較兩個值，可以使用copysign()來設定正確值的符號，
import math HEADINGS = ('f', 's', '< 0', '> 0', '= 0') print('{:^5} {:^5} {:^5} {:^5} {:^5}'.format(*HEADINGS)) print('{:-^5} {:-^5} {:-^5} {:-^5} {:-^5}'.format( '', '', '', '', '', )) VALUES = [ -1.0, 0.0, 1.0, float('-inf'), float('inf'), float('-nan'), float('nan'), ] for f in VALUES: s = int(math.copysign(1, f)) print('{:5.1f} {:5d} {!s:5} {!s:5} {!s:5}'.format( f, s, f < 0, f > 0, f == 0, ))
還需要另一個類似copysign()的函式，因為不能將nan和-nan與其他值直接比較，
1.7 常用計算
在二進制浮點數記憶體中表示精確度很有難度，有些值無法準確地表示，而且如果通過反復計算來處理一個值，那么計算越頻繁就越容易引人表示誤差，math包含一個函式來計算一系列浮點數的和，它使用一種高效的演算法來盡量減少這種誤差，
import math values = [0.1] * 10 print('Input values:', values) print('sum() : {:.20f}'.format(sum(values))) s = 0.0 for i in values: s += i print('for-loop : {:.20f}'.format(s)) print('math.fsum() : {:.20f}'.format(math.fsum(values)))
給定一個包含10個值的序列，每個值都等于0.1，這個序列總和的期望值為1.0，不過，由于0.1不能精確地表示為一個浮點數，所以會在總和中引入誤差，除非用fsum()來計算，
factorial()常用于計算一系列物件的排列和組合數，一個正整數n的階乘(表示為n!)被遞回的定義為(n-1)!*n，并在0!==1停止遞回，
import math for i in [0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.1]: try: print('{:2.0f} {:6.0f}'.format(i, math.factorial(i))) except ValueError as err: print('Error computing factorial({}): {}'.format(i, err))
factorial()只能處理整數，不過它確實也接受float引數，只要這個引數可以轉換為一個整數而不丟值，
gamma()類似于factorial()，不過它可以處理實數，而且值會下移一個數(gamma等于(n - 1)!)，
import math for i in [0, 1.1, 2.2, 3.3, 4.4, 5.5, 6.6]: try: print('{:2.1f} {:6.2f}'.format(i, math.gamma(i))) except ValueError as err: print('Error computing gamma({}): {}'.format(i, err))
由于0會導致開始值為負，所以這是不允許的，
lgamma()會回傳對輸入值求gamma所得結果的絕對值的自然對數，
import math for i in [0, 1.1, 2.2, 3.3, 4.4, 5.5, 6.6]: try: print('{:2.1f} {:.20f} {:.20f}'.format( i, math.lgamma(i), math.log(math.gamma(i)), )) except ValueError as err: print('Error computing lgamma({}): {}'.format(i, err))
使用lgamma()會比使用gamma()結果單獨計算對數更精確，
求模運算子(%)會計算一個除法運算式的余數(例如，5 % 2 = 1)，Python語言內置的這個運算子可以很好地處理整數，但是與很多其他浮點數運算類似，中間計算可能帶來表示問題，從而進一步造成資料丟失，fmod()可以為浮點值提供一個更精確的實作，
import math print('{:^4} {:^4} {:^5} {:^5}'.format( 'x', 'y', '%', 'fmod')) print('{:-^4} {:-^4} {:-^5} {:-^5}'.format( '-', '-', '-', '-')) INPUTS = [ (5, 2), (5, -2), (-5, 2), ] for x, y in INPUTS: print('{:4.1f} {:4.1f} {:5.2f} {:5.2f}'.format( x, y, x % y, math.fmod(x, y), ))
還有一點可能經常產生混淆，即fmod()計算模所使用的演算法與%使用的演算法也有所不同，所以結果的符號不同，
可以使用gcd()找出兩個整數公約數中最大的整數——也就是最大公約數，
import math print(math.gcd(10, 8)) print(math.gcd(10, 0)) print(math.gcd(50, 225)) print(math.gcd(11, 9)) print(math.gcd(0, 0))
如果兩個值都為0，則結果為0，
1.8 指數和對數
指數生長曲線在經濟學、物理學和其他科學中經常出現，Python有一個內置的冪運算子(“**”)，不過，如果需要將一個可呼叫函式作為另一個函式的引數，那么可能需要用到pow()，
import math INPUTS = [ # Typical uses (2, 3), (2.1, 3.2), # Always 1 (1.0, 5), (2.0, 0), # Not-a-number (2, float('nan')), # Roots (9.0, 0.5), (27.0, 1.0 / 3), ] for x, y in INPUTS: print('{:5.1f} ** {:5.3f} = {:6.3f}'.format( x, y, math.pow(x, y)))
1的任何次冪總回傳1.0，同樣，任何值的指數為0.0時也總是回傳1.0.對于nan值(不是一個數)，大多數運算都回傳nan，如果指數小于1，pow()會計算一個根，
由于平方根(指數為1/2)被使用的非常頻繁，所以有一個單獨的函式來計算平方根，
import math print(math.sqrt(9.0)) print(math.sqrt(3)) try: print(math.sqrt(-1)) except ValueError as err: print('Cannot compute sqrt(-1):', err)
計算負數的平方根需要用到復數，這不在math的處理范圍內，試圖計算一個負值的平方根時，會導致一個ValueError，
對數函式查找滿足條件x=b**y的y，默認log()計算自然對數(底數為e)，如果提供了第二個引數，則使用這個引數值作為底數，
import math print(math.log(8)) print(math.log(8, 2)) print(math.log(0.5, 2))
x小于1時，求對數會產生負數結果，
log()有三個變形，在給定浮點數表示和取整誤差的情況下，由log(x,b)生成的計算值只有有限的精度(特別是對于某些底數)，log10()完成log(x,10)計算，但是會使用一種比log()更精確的演算法，
import math print('{:2} {:^12} {:^10} {:^20} {:8}'.format( 'i', 'x', 'accurate', 'inaccurate', 'mismatch', )) print('{:-^2} {:-^12} {:-^10} {:-^20} {:-^8}'.format( '', '', '', '', '', )) for i in range(0, 10): x = math.pow(10, i) accurate = math.log10(x) inaccurate = math.log(x, 10) match = '' if int(inaccurate) == i else '*' print('{:2d} {:12.1f} {:10.8f} {:20.18f} {:^5}'.format( i, x, accurate, inaccurate, match, ))
輸出中末尾有*的行突出強調了不精確的值，
類似于log10()，log2()會完成等價于math.log(x,2)的計算，
import math print('{:>2} {:^5} {:^5}'.format( 'i', 'x', 'log2', )) print('{:-^2} {:-^5} {:-^5}'.format( '', '', '', )) for i in range(0, 10): x = math.pow(2, i) result = math.log2(x) print('{:2d} {:5.1f} {:5.1f}'.format( i, x, result, ))
取決于底層平臺，這個內置的特殊用途函式能提供更好的性能和精度，因為它利用了針對底數2的特殊用途演算法，而在更一般用途的函式中沒有使用這些演算法，
log1p()會計算Newton-Mercator序列(1+x的自然對數)，
import math x = 0.0000000000000000000000001 print('x :', x) print('1 + x :', 1 + x) print('log(1+x):', math.log(1 + x)) print('log1p(x):', math.log1p(x))
對于非常接近于0的x，log1p()會更為精確，因為它使用的演算法可以補償由初識加法帶來的取整誤差，
exp()會計算指數函式(e**x)，
import math x = 2 fmt = '{:.20f}' print(fmt.format(math.e ** 2)) print(fmt.format(math.pow(math.e, 2))) print(fmt.format(math.exp(2)))
類似于其他特殊函式，與等價的通用函式math.pow(math.e,x)相比，exp()使用的演算法可以生成更精確的結果，
expm1()是log1p()的逆運算，會計算e**x-1，
import math x = 0.0000000000000000000000001 print(x) print(math.exp(x) - 1) print(math.expm1(x))
類似于log1p()，x值很小時，如果單獨完成減法，則可能會損失精度，
1.9 角
盡管我們每天討論角時更常用的是度，但弧度才是科學和數學領域中度量角度的標準單位，弧度是在圓心相交的兩條線所構成的角，其終點落在圓的圓周上，終點之間相距一個弧度，
圓周長計算為2πr，所以弧度與π(這是三角函式計算中經常出現的一個值)之間存在一個關系，這個關系使得三角學和微積分中都使用了弧度，因為利用弧度可以得到更緊湊的公式，
要把度轉換為弧度，可以使用redians()，
import math print('{:^7} {:^7} {:^7}'.format( 'Degrees', 'Radians', 'Expected')) print('{:-^7} {:-^7} {:-^7}'.format( '', '', '')) INPUTS = [ (0, 0), (30, math.pi / 6), (45, math.pi / 4), (60, math.pi / 3), (90, math.pi / 2), (180, math.pi), (270, 3 / 2.0 * math.pi), (360, 2 * math.pi), ] for deg, expected in INPUTS: print('{:7d} {:7.2f} {:7.2f}'.format( deg, math.radians(deg), expected, ))
轉換公式為rad = deg * π / 180，
要從弧度轉換為度，可以使用degrees()，
import math INPUTS = [ (0, 0), (math.pi / 6, 30), (math.pi / 4, 45), (math.pi / 3, 60), (math.pi / 2, 90), (math.pi, 180), (3 * math.pi / 2, 270), (2 * math.pi, 360), ] print('{:^8} {:^8} {:^8}'.format( 'Radians', 'Degrees', 'Expected')) print('{:-^8} {:-^8} {:-^8}'.format('', '', '')) for rad, expected in INPUTS: print('{:8.2f} {:8.2f} {:8.2f}'.format( rad, math.degrees(rad), expected, ))
具體轉換公式為deg = rad * 180 / π，
1.10 三角函式
三角函式將三角形中的角與其邊長相關聯，在有周期性質的公式中經常出現三角函式，如諧波或圓周運動；在處理角時也會經常用到三角函式，標準庫中所有三角函式的角引數都被表示為弧度，
給定一個直角三角形中的角，其正弦是對邊長度與斜邊長度之比(sin A = 對邊/斜邊)，余弦是鄰邊長度與斜邊長度之比(cos A = 鄰邊/斜邊)，正切是對邊與鄰邊之比(tan A = 對邊/鄰邊)，
import math print('{:^7} {:^7} {:^7} {:^7} {:^7}'.format( 'Degrees', 'Radians', 'Sine', 'Cosine', 'Tangent')) print('{:-^7} {:-^7} {:-^7} {:-^7} {:-^7}'.format( '-', '-', '-', '-', '-')) fmt = '{:7.2f} {:7.2f} {:7.2f} {:7.2f} {:7.2f}' for deg in range(0, 361, 30): rad = math.radians(deg) if deg in (90, 270): t = float('inf') else: t = math.tan(rad) print(fmt.format(deg, rad, math.sin(rad), math.cos(rad), t))
正切也可以被定義為角的正弦值與其余弦值之比，因為弧度π/2和3π/2的余弦是0，所以相應的正切值為無窮大，
給定一個點(x,y)，點[(0,0),(x,0),(x,y)]構成的三角形中斜邊長度為(x**2+y**2)**1/2，可以用hypot()來計算，
import math print('{:^7} {:^7} {:^10}'.format('X', 'Y', 'Hypotenuse')) print('{:-^7} {:-^7} {:-^10}'.format('', '', '')) POINTS = [ # simple points (1, 1), (-1, -1), (math.sqrt(2), math.sqrt(2)), (3, 4), # 3-4-5 triangle # on the circle (math.sqrt(2) / 2, math.sqrt(2) / 2), # pi/4 rads (0.5, math.sqrt(3) / 2), # pi/3 rads ] for x, y in POINTS: h = math.hypot(x, y) print('{:7.2f} {:7.2f} {:7.2f}'.format(x, y, h))
對于圓上的點，其斜邊總是等于1，
還可以用這個函式查看兩個點之間的距離，
import math print('{:^8} {:^8} {:^8} {:^8} {:^8}'.format( 'X1', 'Y1', 'X2', 'Y2', 'Distance', )) print('{:-^8} {:-^8} {:-^8} {:-^8} {:-^8}'.format( '', '', '', '', '', )) POINTS = [ ((5, 5), (6, 6)), ((-6, -6), (-5, -5)), ((0, 0), (3, 4)), # 3-4-5 triangle ((-1, -1), (2, 3)), # 3-4-5 triangle ] for (x1, y1), (x2, y2) in POINTS: x = x1 - x2 y = y1 - y2 h = math.hypot(x, y) print('{:8.2f} {:8.2f} {:8.2f} {:8.2f} {:8.2f}'.format( x1, y1, x2, y2, h, ))
使用x值之差和y值之差將一個端點移至原點，然后將結果傳入hypot()，
math還定義了反三角函式，
import math for r in [0, 0.5, 1]: print('arcsine({:.1f}) = {:5.2f}'.format(r, math.asin(r))) print('arccosine({:.1f}) = {:5.2f}'.format(r, math.acos(r))) print('arctangent({:.1f}) = {:5.2f}'.format(r, math.atan(r))) print()
1.57大約對于π/2，或90度，這個角的正弦為1，余弦為0，
1.11 雙曲函式
雙曲函式經常出現在線性微分方程中，處理電磁場、流體力學、狹義相對論和其他高級物理和數學問題時常會用到，
import math print('{:^6} {:^6} {:^6} {:^6}'.format( 'X', 'sinh', 'cosh', 'tanh', )) print('{:-^6} {:-^6} {:-^6} {:-^6}'.format('', '', '', '')) fmt = '{:6.4f} {:6.4f} {:6.4f} {:6.4f}' for i in range(0, 11, 2): x = i / 10.0 print(fmt.format( x, math.sinh(x), math.cosh(x), math.tanh(x), ))
余弦函式和正弦函式構成一個圓，而雙曲余弦函式和雙曲正弦函式構成半個雙曲線，
另外還提供了反雙曲函式acosh()、asinh()和atanh()，
1.12 特殊函式
統計學中經常用到高斯誤差函式(Gauss error function)，
import math print('{:^5} {:7}'.format('x', 'erf(x)')) print('{:-^5} {:-^7}'.format('', '')) for x in [-3, -2, -1, -0.5, -0.25, 0, 0.25, 0.5, 1, 2, 3]: print('{:5.2f} {:7.4f}'.format(x, math.erf(x)))
對于誤差函式，erf(-x) == -erf(x)，
補余誤差函式erfc()生成等價于1 - erf(x)的值，
import math print('{:^5} {:7}'.format('x', 'erfc(x)')) print('{:-^5} {:-^7}'.format('', '')) for x in [-3, -2, -1, -0.5, -0.25, 0, 0.25, 0.5, 1, 2, 3]: print('{:5.2f} {:7.4f}'.format(x, math.erfc(x)))
如果x值很小，那么在從1做減法時erfc()實作便可以避免可能的精度誤差，
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/181255.html
標籤：Python