Hướng dẫn e 06 in python - từ 06 bằng Python

Hàm exp(x) trong Python trả về ex.exp(x) trong Python trả về ex.

Nội dung chính Show

Các hàm Số học
Hàm Lượng giác
Hàm Hypebôn
Hàm Luỹ thừa và Logarit
Số phức

Cú pháp

Cú pháp của exp() trong Python:exp() trong Python:

Ghi chú: Hàm này không có thể truy cập trực tiếp, vì thế chúng ta cần import math module và sau đó chúng ta cần gọi hàm này bởi sử dụng đối tượng math. Hàm này không có thể truy cập trực tiếp, vì thế chúng ta cần import math module và sau đó chúng ta cần gọi hàm này bởi sử dụng đối tượng math.

Các tham số:

x: Đây là một biểu thức số.: Đây là một biểu thức số.

Ví dụ sau minh họa cách sử dụng của hàm exp() trong Python.

import math
print ("math.exp(-45) : ", math.exp(-45))
print ("math.exp(10.15) : ", math.exp(10.15))
print ("math.exp(100) : ", math.exp(100))
print ("math.exp(math.pi) : ", math.exp(math.pi))

Chạy chương trình Python trên sẽ cho kết quả:

math.exp(-45) :  2.8625185805493937e-20
math.exp(10.15) :  25591.102206689702
math.exp(100) :  2.6881171418161356e+43
math.exp(math.pi) :  23.140692632779267

Vietnamese (Tiếng Việt) translation by Dai Phong (you can also view the original English article) Dai Phong (you can also view the original English article)

Khi viết các chương trình trong cuộc sống hằng ngày, chúng ta thường gặp những tình huống nơi mà chúng ta cần phải sử dụng một chút kiến thức về môn toán để hoàn thành công việc. Cũng như những ngôn ngữ lập trình khác, Python cũng cung cấp các toán tử khác nhau để thực hiện các phép tính cơ bản như

math.exp(-45) :  2.8625185805493937e-20
math.exp(10.15) :  25591.102206689702
math.exp(100) :  2.6881171418161356e+43
math.exp(math.pi) :  23.140692632779267

0 cho phép nhân,

math.exp(-45) :  2.8625185805493937e-20
math.exp(10.15) :  25591.102206689702
math.exp(100) :  2.6881171418161356e+43
math.exp(math.pi) :  23.140692632779267

1 cho phép lấy dư, và

math.exp(-45) :  2.8625185805493937e-20
math.exp(10.15) :  25591.102206689702
math.exp(100) :  2.6881171418161356e+43
math.exp(math.pi) :  23.140692632779267

2 cho phép chia

Nếu bạn đang viết một chương trình để thực hiện các nhiệm vụ cụ thể như nghiên cứu chu kỳ chuyển động hoặc mô phỏng các mạch điện, bạn sẽ cần phải làm việc với các hàm lượng giác cũng như số phức. Mặc dù bạn không thể sử dụng trực tiếp các hàm này, nhưng bạn có thể truy cập chúng bằng cách bao gồm hai mô-đun toán học đầu tiên. Các mô-đun này là math và cmath.

Mô-đun đầu tiên cho phép bạn truy cập vào các hàm hypebôn, lượng giác và lôgarit cho các số thực, trong khi mô-đun thứ hai cho phép bạn làm việc với các số phức. Trong hướng dẫn này, tôi sẽ khái quát tất cả các hàm quan trọng được cung cấp bởi các mô-đun này. Trừ khi được đề cập một cách rõ ràng, thì tất cả các giá trị trả về đều là float.

Các hàm Số học

Các hàm này thực hiện các phép tính số học khác nhau như tính cận dưới, cận trên, hoặc giá trị tuyệt đối của một số bằng các hàm

math.exp(-45) :  2.8625185805493937e-20
math.exp(10.15) :  25591.102206689702
math.exp(100) :  2.6881171418161356e+43
math.exp(math.pi) :  23.140692632779267

math.exp(-45) :  2.8625185805493937e-20
math.exp(10.15) :  25591.102206689702
math.exp(100) :  2.6881171418161356e+43
math.exp(math.pi) :  23.140692632779267

4 và

math.exp(-45) :  2.8625185805493937e-20
math.exp(10.15) :  25591.102206689702
math.exp(100) :  2.6881171418161356e+43
math.exp(math.pi) :  23.140692632779267

5 tương ứng. Hàm

math.exp(-45) :  2.8625185805493937e-20
math.exp(10.15) :  25591.102206689702
math.exp(100) :  2.6881171418161356e+43
math.exp(math.pi) :  23.140692632779267

4 sẽ trả về số nguyên nhỏ nhất lớn hơn hoặc bằng x. Tương tự,

math.exp(-45) :  2.8625185805493937e-20
math.exp(10.15) :  25591.102206689702
math.exp(100) :  2.6881171418161356e+43
math.exp(math.pi) :  23.140692632779267

3 trả về số nguyên lớn nhất nhỏ hơn hoặc bằng x. Hàm

math.exp(-45) :  2.8625185805493937e-20
math.exp(10.15) :  25591.102206689702
math.exp(100) :  2.6881171418161356e+43
math.exp(math.pi) :  23.140692632779267

5 trả về giá trị tuyệt đối của x.

Bạn cũng có thể thực hiện các phép toán không bình thường như tính giai thừa của một số bằng cách sử dụng hàm

math.exp(-45) :  2.8625185805493937e-20
math.exp(10.15) :  25591.102206689702
math.exp(100) :  2.6881171418161356e+43
math.exp(math.pi) :  23.140692632779267

9. Một giai thừa là tích số của một số nguyên và tất cả các số nguyên dương nhỏ hơn nó. Nó được sử dụng rộng rãi khi tính toán liên quan đến tổ hợp và hoán vị. Nó cũng có thể được sử dụng để tính toán giá trị của các hàm sin và cosin.

import math

def getsin(x):

    multiplier = 1
    result = 0
    
  for i in range(1,20,2):
		result += multiplier*pow(x,i)/math.factorial(i)
		multiplier *= -1
		
	return result
    

getsin(math.pi/2) # returns 1.0
getsin(math.pi/4) # returns 0.7071067811865475

Một hàm hữu ích khác trong mô-đun math là

import math

def getsin(x):

    multiplier = 1
    result = 0
    
  for i in range(1,20,2):
		result += multiplier*pow(x,i)/math.factorial(i)
		multiplier *= -1
		
	return result
    

getsin(math.pi/2) # returns 1.0
getsin(math.pi/4) # returns 0.7071067811865475

0, giúp bạn tính ước số chung lớn nhất (GCD) của hai số x và y. Khi x và y không bằng 0, hàm này trả về số nguyên dương lớn nhất chia hết cho cả x và y. Bạn có thể sử dụng nó gián tiếp để tính bội số chung nhỏ nhất của hai số bằng công thức sau:

gcd(a, b) x lcm(a, b) = a x b

Ở đây là một số hàm số học mà Python cung cấp:

import math

math.ceil(1.001)    # returns 2
math.floor(1.001)   # returns 1
math.factorial(10)  # returns 3628800
math.gcd(10,125)    # returns 5

math.trunc(1.001)   # returns 1
math.trunc(1.999)   # returns 1

Hàm Lượng giác

Các hàm này liên quan đến các góc của một tam giác với các cạnh của nó. Chúng có rất nhiều ứng dụng, bao gồm nghiên cứu các hình tam giác và mô hình hoá các hiện tượng theo chu kỳ như sóng âm và ánh sáng. Lưu ý rằng góc bạn cung cấp là bằng radian.

Bạn có thể tính

import math

def getsin(x):

    multiplier = 1
    result = 0
    
  for i in range(1,20,2):
		result += multiplier*pow(x,i)/math.factorial(i)
		multiplier *= -1
		
	return result
    

getsin(math.pi/2) # returns 1.0
getsin(math.pi/4) # returns 0.7071067811865475

import math

def getsin(x):

    multiplier = 1
    result = 0
    
  for i in range(1,20,2):
		result += multiplier*pow(x,i)/math.factorial(i)
		multiplier *= -1
		
	return result
    

getsin(math.pi/2) # returns 1.0
getsin(math.pi/4) # returns 0.7071067811865475

2, và

import math

def getsin(x):

    multiplier = 1
    result = 0
    
  for i in range(1,20,2):
		result += multiplier*pow(x,i)/math.factorial(i)
		multiplier *= -1
		
	return result
    

getsin(math.pi/2) # returns 1.0
getsin(math.pi/4) # returns 0.7071067811865475

3 trực tiếp bằng mô-đun này. Tuy nhiên, không có công thức trực tiếp để tính

import math

def getsin(x):

    multiplier = 1
    result = 0
    
  for i in range(1,20,2):
		result += multiplier*pow(x,i)/math.factorial(i)
		multiplier *= -1
		
	return result
    

getsin(math.pi/2) # returns 1.0
getsin(math.pi/4) # returns 0.7071067811865475

import math

def getsin(x):

    multiplier = 1
    result = 0
    
  for i in range(1,20,2):
		result += multiplier*pow(x,i)/math.factorial(i)
		multiplier *= -1
		
	return result
    

getsin(math.pi/2) # returns 1.0
getsin(math.pi/4) # returns 0.7071067811865475

5 và

import math

def getsin(x):

    multiplier = 1
    result = 0
    
  for i in range(1,20,2):
		result += multiplier*pow(x,i)/math.factorial(i)
		multiplier *= -1
		
	return result
    

getsin(math.pi/2) # returns 1.0
getsin(math.pi/4) # returns 0.7071067811865475

6, nhưng giá trị của chúng bằng với nghịch đảo giá trị trả về của

import math

def getsin(x):

    multiplier = 1
    result = 0
    
  for i in range(1,20,2):
		result += multiplier*pow(x,i)/math.factorial(i)
		multiplier *= -1
		
	return result
    

getsin(math.pi/2) # returns 1.0
getsin(math.pi/4) # returns 0.7071067811865475

import math

def getsin(x):

    multiplier = 1
    result = 0
    
  for i in range(1,20,2):
		result += multiplier*pow(x,i)/math.factorial(i)
		multiplier *= -1
		
	return result
    

getsin(math.pi/2) # returns 1.0
getsin(math.pi/4) # returns 0.7071067811865475

2 và

import math

def getsin(x):

    multiplier = 1
    result = 0
    
  for i in range(1,20,2):
		result += multiplier*pow(x,i)/math.factorial(i)
		multiplier *= -1
		
	return result
    

getsin(math.pi/2) # returns 1.0
getsin(math.pi/4) # returns 0.7071067811865475

3 tương ứng.

Thay vì tính giá trị của các hàm lượng giác ở một góc nào đó, bạn cũng có thể làm ngược lại và tính góc tại nơi mà chúng có một giá trị nhất định bằng cách sử dụng

gcd(a, b) x lcm(a, b) = a x b

gcd(a, b) x lcm(a, b) = a x b

1 và

gcd(a, b) x lcm(a, b) = a x b

Bạn có rành về định lý Pitago không? Nó phát biểu rằng bình phương của cạnh huyền (cạnh đối diện với góc phải) bằng với tổng bình phương của hai cạnh bên. Cạnh huyền cũng là cạnh lớn nhất của một tam giác vuông góc bên phải. Mô-đun math cung cấp hàm

gcd(a, b) x lcm(a, b) = a x b

3 để tính toán chiều dài của cạnh huyền.

import math

math.sin(math.pi/4)    # returns 0.7071067811865476
math.cos(math.pi)      # returns -1.0
math.tan(math.pi/6)    # returns 0.5773502691896257
math.hypot(12,5)       # returns 13.0

math.atan(0.5773502691896257) # returns 0.5235987755982988
math.asin(0.7071067811865476) # returns 0.7853981633974484

Hàm Hypebôn

Các hàm hypebôn là tương tự các hàm lượng giác dựa trên một hipebôn thay vì một vòng tròn. Trong phép đo lượng giác, các điểm (cos b, sin b) đại diện cho các điểm của một vòng tròn đơn vị. Trong trường hợp các hàm hipebôn, các điểm (cosh b, sinh b) đại diện cho các điểm hình thành nửa bên phải của một hypebôn vuông góc.

Cũng giống như các hàm lượng giác, bạn có thể tính trực tiếp giá trị

gcd(a, b) x lcm(a, b) = a x b

gcd(a, b) x lcm(a, b) = a x b

5, và

gcd(a, b) x lcm(a, b) = a x b

6. Phần còn lại của các giá trị có thể được tính bằng các mối quan hệ khác nhau giữa ba giá trị này. Ngoài ra còn có các hàm khác như

gcd(a, b) x lcm(a, b) = a x b

gcd(a, b) x lcm(a, b) = a x b

8, và

gcd(a, b) x lcm(a, b) = a x b

9, chúng có thể được sử dụng để tính toán nghịch đảo của các giá trị hypebôn tương ứng.

import math

math.sinh(math.pi)    # returns 11.548739357257746
math.cosh(math.pi)    # returns 11.591953275521519
math.cosh(math.pi)    # returns 0.99627207622075

math.asinh(11.548739357257746)   # returns 3.141592653589793
math.acosh(11.591953275521519)   # returns 3.141592653589793
math.atanh(0.99627207622075)     # returns 3.141592653589798

Vì

import math

math.ceil(1.001)    # returns 2
math.floor(1.001)   # returns 1
math.factorial(10)  # returns 3628800
math.gcd(10,125)    # returns 5

math.trunc(1.001)   # returns 1
math.trunc(1.999)   # returns 1

0 tương đương khoảng 3.141592653589793, nên khi chúng ta sử dụng

import math

math.ceil(1.001)    # returns 2
math.floor(1.001)   # returns 1
math.factorial(10)  # returns 3628800
math.gcd(10,125)    # returns 5

math.trunc(1.001)   # returns 1
math.trunc(1.999)   # returns 1

1 với giá trị trả về bởi

import math

math.ceil(1.001)    # returns 2
math.floor(1.001)   # returns 1
math.factorial(10)  # returns 3628800
math.gcd(10,125)    # returns 5

math.trunc(1.001)   # returns 1
math.trunc(1.999)   # returns 1

2, chúng ta lấy lại π của chúng ta.

Hàm Luỹ thừa và Logarit

Có lẽ bạn sẽ phải làm việc với luỹ thừa và logarit thường xuyên hơn so với các hàm hypebôn hay lượng giác. May mắn thay, mô-đun math cung cấp rất nhiều hàm để giúp chúng ta tính logarit.

Bạn có thể sử dụng

import math

math.ceil(1.001)    # returns 2
math.floor(1.001)   # returns 1
math.factorial(10)  # returns 3628800
math.gcd(10,125)    # returns 5

math.trunc(1.001)   # returns 1
math.trunc(1.999)   # returns 1

3 để tính log của một số x cho trước với cơ số nhất định. Nếu bạn bỏ ra đối số cơ số, thì log của x được tính theo cơ số e. Ở đây, e là một hằng số toán học có giá trị là 2.71828182.... và nó có thể được truy xuất bằng cách sử dụng

import math

math.ceil(1.001)    # returns 2
math.floor(1.001)   # returns 1
math.factorial(10)  # returns 3628800
math.gcd(10,125)    # returns 5

math.trunc(1.001)   # returns 1
math.trunc(1.999)   # returns 1

4. Nhân tiện, Python cũng cho phép bạn truy cập vào hằng số π bằng cách sử dụng

import math

math.ceil(1.001)    # returns 2
math.floor(1.001)   # returns 1
math.factorial(10)  # returns 3628800
math.gcd(10,125)    # returns 5

math.trunc(1.001)   # returns 1
math.trunc(1.999)   # returns 1

Nếu bạn muốn tính các giá trị logarit cơ số 2 hoặc 10, hãy sử dụng

import math

math.ceil(1.001)    # returns 2
math.floor(1.001)   # returns 1
math.factorial(10)  # returns 3628800
math.gcd(10,125)    # returns 5

math.trunc(1.001)   # returns 1
math.trunc(1.999)   # returns 1

6 và

import math

math.ceil(1.001)    # returns 2
math.floor(1.001)   # returns 1
math.factorial(10)  # returns 3628800
math.gcd(10,125)    # returns 5

math.trunc(1.001)   # returns 1
math.trunc(1.999)   # returns 1

7 sẽ trả về kết quả chính xác hơn

import math

math.ceil(1.001)    # returns 2
math.floor(1.001)   # returns 1
math.factorial(10)  # returns 3628800
math.gcd(10,125)    # returns 5

math.trunc(1.001)   # returns 1
math.trunc(1.999)   # returns 1

8 và

import math

math.ceil(1.001)    # returns 2
math.floor(1.001)   # returns 1
math.factorial(10)  # returns 3628800
math.gcd(10,125)    # returns 5

math.trunc(1.001)   # returns 1
math.trunc(1.999)   # returns 1

9. Hãy nhớ rằng không có hàm

import math

math.sin(math.pi/4)    # returns 0.7071067811865476
math.cos(math.pi)      # returns -1.0
math.tan(math.pi/6)    # returns 0.5773502691896257
math.hypot(12,5)       # returns 13.0

math.atan(0.5773502691896257) # returns 0.5235987755982988
math.asin(0.7071067811865476) # returns 0.7853981633974484

0, do đó bạn sẽ phải tiếp tục sử dụng

import math

math.sin(math.pi/4)    # returns 0.7071067811865476
math.cos(math.pi)      # returns -1.0
math.tan(math.pi/6)    # returns 0.5773502691896257
math.hypot(12,5)       # returns 13.0

math.atan(0.5773502691896257) # returns 0.5235987755982988
math.asin(0.7071067811865476) # returns 0.7853981633974484

1 để tính các giá trị logarit cơ số 3. Tương tự với tất cả các cơ số khác.

Nếu giá trị của lôgarit mà bạn tính là rất gần với 1, bạn có thể sử dụng

import math

math.sin(math.pi/4)    # returns 0.7071067811865476
math.cos(math.pi)      # returns -1.0
math.tan(math.pi/6)    # returns 0.5773502691896257
math.hypot(12,5)       # returns 13.0

math.atan(0.5773502691896257) # returns 0.5235987755982988
math.asin(0.7071067811865476) # returns 0.7853981633974484

import math

math.sin(math.pi/4)    # returns 0.7071067811865476
math.cos(math.pi)      # returns -1.0
math.tan(math.pi/6)    # returns 0.5773502691896257
math.hypot(12,5)       # returns 13.0

math.atan(0.5773502691896257) # returns 0.5235987755982988
math.asin(0.7071067811865476) # returns 0.7853981633974484

3 trong

import math

math.sin(math.pi/4)    # returns 0.7071067811865476
math.cos(math.pi)      # returns -1.0
math.tan(math.pi/6)    # returns 0.5773502691896257
math.hypot(12,5)       # returns 13.0

math.atan(0.5773502691896257) # returns 0.5235987755982988
math.asin(0.7071067811865476) # returns 0.7853981633974484

4 nghĩa là 1 cộng. Do đó,

import math

math.sin(math.pi/4)    # returns 0.7071067811865476
math.cos(math.pi)      # returns -1.0
math.tan(math.pi/6)    # returns 0.5773502691896257
math.hypot(12,5)       # returns 13.0

math.atan(0.5773502691896257) # returns 0.5235987755982988
math.asin(0.7071067811865476) # returns 0.7853981633974484

2 tính

import math

math.sin(math.pi/4)    # returns 0.7071067811865476
math.cos(math.pi)      # returns -1.0
math.tan(math.pi/6)    # returns 0.5773502691896257
math.hypot(12,5)       # returns 13.0

math.atan(0.5773502691896257) # returns 0.5235987755982988
math.asin(0.7071067811865476) # returns 0.7853981633974484

6 trong đó x là gần bằng 0. Tuy nhiên, kết quả chính xác hơn với

import math

math.sin(math.pi/4)    # returns 0.7071067811865476
math.cos(math.pi)      # returns -1.0
math.tan(math.pi/6)    # returns 0.5773502691896257
math.hypot(12,5)       # returns 13.0

math.atan(0.5773502691896257) # returns 0.5235987755982988
math.asin(0.7071067811865476) # returns 0.7853981633974484

Bạn cũng có thể tính giá trị của một số x luỹ thừa y bằng cách sử dụng

import math

math.sin(math.pi/4)    # returns 0.7071067811865476
math.cos(math.pi)      # returns -1.0
math.tan(math.pi/6)    # returns 0.5773502691896257
math.hypot(12,5)       # returns 13.0

math.atan(0.5773502691896257) # returns 0.5235987755982988
math.asin(0.7071067811865476) # returns 0.7853981633974484

8 Trước khi tính toán các luỹ thừa, hàm này sẽ chuyển đổi cả hai đối số thành kiểu float. Nếu bạn muốn kết quả cuối cùng được tính bằng các số nguyên chính xác, bạn nên sử dụng hàm

import math

math.sin(math.pi/4)    # returns 0.7071067811865476
math.cos(math.pi)      # returns -1.0
math.tan(math.pi/6)    # returns 0.5773502691896257
math.hypot(12,5)       # returns 13.0

math.atan(0.5773502691896257) # returns 0.5235987755982988
math.asin(0.7071067811865476) # returns 0.7853981633974484

9 có sẵn hoặc toán tử

import math

math.sinh(math.pi)    # returns 11.548739357257746
math.cosh(math.pi)    # returns 11.591953275521519
math.cosh(math.pi)    # returns 0.99627207622075

math.asinh(11.548739357257746)   # returns 3.141592653589793
math.acosh(11.591953275521519)   # returns 3.141592653589793
math.atanh(0.99627207622075)     # returns 3.141592653589798

Bạn cũng có thể tính căn bậc hai của bất kỳ số x cho trước bằng cách sử dụng

import math

math.sinh(math.pi)    # returns 11.548739357257746
math.cosh(math.pi)    # returns 11.591953275521519
math.cosh(math.pi)    # returns 0.99627207622075

math.asinh(11.548739357257746)   # returns 3.141592653589793
math.acosh(11.591953275521519)   # returns 3.141592653589793
math.atanh(0.99627207622075)     # returns 3.141592653589798

1, nhưng điều tương tự cũng có thể được thực hiện bằng cách sử dụng

import math

math.sinh(math.pi)    # returns 11.548739357257746
math.cosh(math.pi)    # returns 11.591953275521519
math.cosh(math.pi)    # returns 0.99627207622075

math.asinh(11.548739357257746)   # returns 3.141592653589793
math.acosh(11.591953275521519)   # returns 3.141592653589793
math.atanh(0.99627207622075)     # returns 3.141592653589798

import math

math.exp(5)                      # returns 148.4131591025766
math.e**5                        # returns 148.4131591025765

math.log(148.41315910257657)     # returns 5.0
math.log(148.41315910257657, 2)  # returns 7.213475204444817
math.log(148.41315910257657, 10) # returns 2.171472409516258

math.log(1.0000025)              # returns 2.4999968749105643e-06
math.log1p(0.0000025)            # returns 2.4999968750052084e-06

math.pow(12.5, 2.8)              # returns 1178.5500657314767
math.pow(144, 0.5)               # returns 12.0
math.sqrt(144)                   # returns 12.0

Số phức

Số phức được lưu trữ nội tại bằng tọa độ hình chữ nhật hoặc Đề các. Một số phức z sẽ được biểu diễn trong các tọa độ Đề các là

import math

math.sinh(math.pi)    # returns 11.548739357257746
math.cosh(math.pi)    # returns 11.591953275521519
math.cosh(math.pi)    # returns 0.99627207622075

math.asinh(11.548739357257746)   # returns 3.141592653589793
math.acosh(11.591953275521519)   # returns 3.141592653589793
math.atanh(0.99627207622075)     # returns 3.141592653589798

3, trong đó x đại diện cho phần thực và y đại diện cho phần ảo. Một cách khác để biểu diễn chúng là sử dụng tọa độ cực.

Trong trường hợp này, số phức z sẽ được định nghĩa là sự kết hợp của hệ số r và góc pha phi. Hệ số r là khoảng cách giữa số phức z và gốc. Góc phi là góc nghịch đảo được tính theo đơn vị radian từ trục x dương đến đoạn nối z với gốc.

Khi xử lý các số phức, mô-đun cmath có thể là sự trợ giúp rất lớn. Hệ số của một số phức có thể được tính bằng hàm

import math

math.sinh(math.pi)    # returns 11.548739357257746
math.cosh(math.pi)    # returns 11.591953275521519
math.cosh(math.pi)    # returns 0.99627207622075

math.asinh(11.548739357257746)   # returns 3.141592653589793
math.acosh(11.591953275521519)   # returns 3.141592653589793
math.atanh(0.99627207622075)     # returns 3.141592653589798

4 tích hợp, và pha của nó có thể được tính bằng hàm

import math

math.sinh(math.pi)    # returns 11.548739357257746
math.cosh(math.pi)    # returns 11.591953275521519
math.cosh(math.pi)    # returns 0.99627207622075

math.asinh(11.548739357257746)   # returns 3.141592653589793
math.acosh(11.591953275521519)   # returns 3.141592653589793
math.atanh(0.99627207622075)     # returns 3.141592653589798

5 sẵn có trong mô đun cmath. Bạn có thể chuyển đổi một số phức dưới dạng hình chữ nhật thành dạng có cực sử dụng

import math

math.sinh(math.pi)    # returns 11.548739357257746
math.cosh(math.pi)    # returns 11.591953275521519
math.cosh(math.pi)    # returns 0.99627207622075

math.asinh(11.548739357257746)   # returns 3.141592653589793
math.acosh(11.591953275521519)   # returns 3.141592653589793
math.atanh(0.99627207622075)     # returns 3.141592653589798

6, nó sẽ trả về một cặp

import math

math.sinh(math.pi)    # returns 11.548739357257746
math.cosh(math.pi)    # returns 11.591953275521519
math.cosh(math.pi)    # returns 0.99627207622075

math.asinh(11.548739357257746)   # returns 3.141592653589793
math.acosh(11.591953275521519)   # returns 3.141592653589793
math.atanh(0.99627207622075)     # returns 3.141592653589798

7, trong đó r là

import math

math.sinh(math.pi)    # returns 11.548739357257746
math.cosh(math.pi)    # returns 11.591953275521519
math.cosh(math.pi)    # returns 0.99627207622075

math.asinh(11.548739357257746)   # returns 3.141592653589793
math.acosh(11.591953275521519)   # returns 3.141592653589793
math.atanh(0.99627207622075)     # returns 3.141592653589798

8 và phi là

import math

math.sinh(math.pi)    # returns 11.548739357257746
math.cosh(math.pi)    # returns 11.591953275521519
math.cosh(math.pi)    # returns 0.99627207622075

math.asinh(11.548739357257746)   # returns 3.141592653589793
math.acosh(11.591953275521519)   # returns 3.141592653589793
math.atanh(0.99627207622075)     # returns 3.141592653589798

Tương tự, bạn có thể chuyển đổi một số phức dưới dạng có cực sang dạng hình chữ nhật bằng cách sử dụng

import math

math.exp(5)                      # returns 148.4131591025766
math.e**5                        # returns 148.4131591025765

math.log(148.41315910257657)     # returns 5.0
math.log(148.41315910257657, 2)  # returns 7.213475204444817
math.log(148.41315910257657, 10) # returns 2.171472409516258

math.log(1.0000025)              # returns 2.4999968749105643e-06
math.log1p(0.0000025)            # returns 2.4999968750052084e-06

math.pow(12.5, 2.8)              # returns 1178.5500657314767
math.pow(144, 0.5)               # returns 12.0
math.sqrt(144)                   # returns 12.0

0. Số phức trả về bởi hàm này là

import math

math.exp(5)                      # returns 148.4131591025766
math.e**5                        # returns 148.4131591025765

math.log(148.41315910257657)     # returns 5.0
math.log(148.41315910257657, 2)  # returns 7.213475204444817
math.log(148.41315910257657, 10) # returns 2.171472409516258

math.log(1.0000025)              # returns 2.4999968749105643e-06
math.log1p(0.0000025)            # returns 2.4999968750052084e-06

math.pow(12.5, 2.8)              # returns 1178.5500657314767
math.pow(144, 0.5)               # returns 12.0
math.sqrt(144)                   # returns 12.0

import cmath

cmath.polar(complex(1.0, 1.0))
# returns (1.4142135623730951, 0.7853981633974483)

cmath.phase(complex(1.0, 1.0))
# returns 0.7853981633974483

abs(complex(1.0, 1.0))
# returns 1.4142135623730951

Mô-đun cmath cũng cho phép chúng ta sử dụng các hàm toán học thông thường với số phức. Ví dụ, bạn có thể tính toán căn bậc hai của một số phức bằng hàm

import math

math.exp(5)                      # returns 148.4131591025766
math.e**5                        # returns 148.4131591025765

math.log(148.41315910257657)     # returns 5.0
math.log(148.41315910257657, 2)  # returns 7.213475204444817
math.log(148.41315910257657, 10) # returns 2.171472409516258

math.log(1.0000025)              # returns 2.4999968749105643e-06
math.log1p(0.0000025)            # returns 2.4999968750052084e-06

math.pow(12.5, 2.8)              # returns 1178.5500657314767
math.pow(144, 0.5)               # returns 12.0
math.sqrt(144)                   # returns 12.0

2 hoặc cosine của nó bằng

import math

math.exp(5)                      # returns 148.4131591025766
math.e**5                        # returns 148.4131591025765

math.log(148.41315910257657)     # returns 5.0
math.log(148.41315910257657, 2)  # returns 7.213475204444817
math.log(148.41315910257657, 10) # returns 2.171472409516258

math.log(1.0000025)              # returns 2.4999968749105643e-06
math.log1p(0.0000025)            # returns 2.4999968750052084e-06

math.pow(12.5, 2.8)              # returns 1178.5500657314767
math.pow(144, 0.5)               # returns 12.0
math.sqrt(144)                   # returns 12.0

import cmath

cmath.sqrt(complex(25.0, 25.0))
# returns (5.49342056733905+2.2754493028111367j)

cmath.cos(complex(25.0, 25.0))
# returns (35685729345.58163+4764987221.458499j)

Số phức có rất nhiều ứng dụng như mô phỏng mạch điện, động lực học và phân tích tín hiệu. Nếu bạn cần phải làm việc với những điều đó, thì mô-đun cmath sẽ không làm bạn thất vọng.

Tóm tắt

Tất cả các hàm mà chúng ta thảo luận ở trên có các ứng dụng cụ thể của chúng. Ví dụ, bạn có thể sử dụng hàm

math.exp(-45) :  2.8625185805493937e-20
math.exp(10.15) :  25591.102206689702
math.exp(100) :  2.6881171418161356e+43
math.exp(math.pi) :  23.140692632779267

9 để tính hoán vị và các vấn đề về tập hợp. Bạn có thể sử dụng các hàm lượng giác để phân giải một vector thành tọa độ Đề các. Bạn cũng có thể sử dụng các hàm lượng giác để mô phỏng các hàm tuần hoàn như sóng âm và ánh sáng.

Tương tự, đường cong của một sợi dây treo giữa hai cực có thể được xác định bằng cách sử dụng một hàm hypebôn. Vì tất cả các hàm này trực tiếp có sẵn trong mô đun math, nên nó giúp dễ dàng tạo ra các chương trình nhỏ có thể thực hiện tất cả các nhiệm vụ này.

Tôi hy vọng bạn thấy hứng thú với hướng dẫn này. Nếu bạn có bất kỳ câu hỏi nào, hãy cho tôi biết trong phần bình luận nhé.

Hướng dẫn e 06 in python - từ 06 bằng Python

Cú pháp

Các hàm Số học

Hàm Lượng giác

Hàm Hypebôn

Hàm Luỹ thừa và Logarit

Số phức

Tóm tắt

Bài Viết Liên Quan

Quảng Cáo

Có thể bạn quan tâm

Toplist được quan tâm

Quảng cáo

Xem Nhiều

Quảng cáo

Chúng tôi

Điều khoản

Trợ giúp

Mạng xã hội