Trong chương trình này, bạn sẽ học cách tìm LCM của hai số và hiển thị nó.
Để hiểu ví dụ này, bạn nên có kiến thức về các chủ đề lập trình Python sau:
- Python trong khi vòng lặp
- Chức năng Python
- Đối số chức năng Python
- Các chức năng do người dùng định nghĩa
Nhiều số ít nhất [L.C.M.] của hai số là số nguyên dương nhỏ nhất hoàn toàn chia hết bởi hai số đã cho.
Ví dụ, L.C.M. của 12 và 14 là 84.
Chương trình tính toán LCM
# Python Program to find the L.C.M. of two input number
def compute_lcm[x, y]:
# choose the greater number
if x > y:
greater = x
else:
greater = y
while[True]:
if[[greater % x == 0] and [greater % y == 0]]:
lcm = greater
break
greater += 1
return lcm
num1 = 54
num2 = 24
print["The L.C.M. is", compute_lcm[num1, num2]]
Đầu ra
The L.C.M. is 216
Lưu ý: Để kiểm tra chương trình này, hãy thay đổi các giá trị của The L.C.M. is 216
2 và The L.C.M. is 216
3. To test this program, change the values of
The L.C.M. is 2162 and
The L.C.M. is 2163.
Chương trình này lưu trữ hai số trong
The L.C.M. is 2162 và
The L.C.M. is 2163 tương ứng. Những con số này được chuyển đến hàm
The L.C.M. is 2166. Hàm trả về L.C.M của hai số.
Trong hàm, trước tiên chúng tôi xác định số lượng lớn hơn của hai số kể từ L.C.M. Chỉ có thể lớn hơn hoặc bằng số lớn nhất. Sau đó, chúng tôi sử dụng một vòng lặp
The L.C.M. is 2167 vô hạn để đi từ số đó và hơn thế nữa.
Trong mỗi lần lặp, chúng tôi kiểm tra xem cả hai con số hoàn toàn chia số của chúng tôi. Nếu vậy, chúng tôi lưu trữ số dưới dạng L.C.M. và thoát khỏi vòng lặp. Mặt khác, số được tăng thêm 1 và vòng lặp tiếp tục.
Chương trình trên chậm hơn để chạy. Chúng ta có thể làm cho nó hiệu quả hơn bằng cách sử dụng thực tế là sản phẩm của hai số bằng với sản phẩm của số ước số phổ biến nhất và lớn nhất của hai số đó.
Number1 * Number2 = L.C.M. * G.C.D.
Đây là một chương trình Python để thực hiện điều này.
Chương trình tính toán LCM bằng GCD
# Python program to find the L.C.M. of two input number
# This function computes GCD
def compute_gcd[x, y]:
while[y]:
x, y = y, x % y
return x
# This function computes LCM
def compute_lcm[x, y]:
lcm = [x*y]//compute_gcd[x,y]
return lcm
num1 = 54
num2 = 24
print["The L.C.M. is", compute_lcm[num1, num2]]
Đầu ra của chương trình này giống như trước đây. Chúng tôi có hai chức năng
The L.C.M. is 2168 và
The L.C.M. is 2166. Chúng tôi yêu cầu G.C.D. của các số để tính toán L.C.M.
Vì vậy,
The L.C.M. is 2166 gọi hàm
The L.C.M. is 2168 để thực hiện điều này. G.C.D. của hai số có thể được tính toán hiệu quả bằng thuật toán Euclide.
Nhấn vào đây để tìm hiểu thêm về các phương pháp để tính toán G.C.D trong Python.
Bản dịch tiếng Việt [tiếng việt] của Dai Phong [bạn cũng có thể xem bài viết tiếng Anh gốc]Dai Phong [you can also view the original English article]
Khi bạn Cũng NH
N ếu bạn Mặc dù bạn không thể sử dụng trực tiếp các ha Các muô
Mô-ôn Trong hướng dẫn nào, tôma sẽ Khái quámt tất cả c6 Trừ khi
Các ha số học
Cac ha nÀy thực hiện cac phép tính số học Khác nhau như tính cận dưới, cận trán HÀM
Number1 * Number2 = L.C.M. * G.C.D.6 Sẽ TRả Về Số Nguyễn NH Tương tự,
Number1 * Number2 = L.C.M. * G.C.D.5 trả về số nguyn lớn nh ấ nh ỏn hoặc bằng x. HÀM
Number1 * Number2 = L.C.M. * G.C.D.7 TRả Về Giá Trị Tuyệt Đối Của x.
Bạn cũng đó là thểc hiện cau phép Toán Không bình thường NHư tính giai thừa của một Một giai thừa là tích số của một số nguynênn và tất cả cac Nó Được sử dụng rộng rãi khi Nó cũng đó là thể ôn
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 ha hữu ích khát trong mô- / Khi x và y không bằng 0, ha nÀy trả về số nguyn Bạn Có Thể Sử Dụng Nó Gián Tiếp Để Tính BộI Số Chung NHỏ NHấT
gcd[a, b] x lcm[a, b] = a x b
Ở đang
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án Với Các cạNH Của Nó. Chúng đó là rất nhiều ứng dụng, bao Lưu ý rằng góc bạn cung cấp là bằng radian.
Bạn Có Thể Tính
# Python program to find the L.C.M. of two input number
# This function computes GCD
def compute_gcd[x, y]:
while[y]:
x, y = y, x % y
return x
# This function computes LCM
def compute_lcm[x, y]:
lcm = [x*y]//compute_gcd[x,y]
return lcm
num1 = 54
num2 = 24
print["The L.C.M. is", compute_lcm[num1, num2]]
3, # Python program to find the L.C.M. of two input number
# This function computes GCD
def compute_gcd[x, y]:
while[y]:
x, y = y, x % y
return x
# This function computes LCM
def compute_lcm[x, y]:
lcm = [x*y]//compute_gcd[x,y]
return lcm
num1 = 54
num2 = 24
print["The L.C.M. is", compute_lcm[num1, num2]]
4, Và # Python program to find the L.C.M. of two input number
# This function computes GCD
def compute_gcd[x, y]:
while[y]:
x, y = y, x % y
return x
# This function computes LCM
def compute_lcm[x, y]:
lcm = [x*y]//compute_gcd[x,y]
return lcm
num1 = 54
num2 = 24
print["The L.C.M. is", compute_lcm[num1, num2]]
5 trực tiếp Bằng Mô- / Tuy NHiênn, Khôngó Công thức trực tiếp Để Tính # Python program to find the L.C.M. of two input number
# This function computes GCD
def compute_gcd[x, y]:
while[y]:
x, y = y, x % y
return x
# This function computes LCM
def compute_lcm[x, y]:
lcm = [x*y]//compute_gcd[x,y]
return lcm
num1 = 54
num2 = 24
print["The L.C.M. is", compute_lcm[num1, num2]]
6, # Python program to find the L.C.M. of two input number
# This function computes GCD
def compute_gcd[x, y]:
while[y]:
x, y = y, x % y
return x
# This function computes LCM
def compute_lcm[x, y]:
lcm = [x*y]//compute_gcd[x,y]
return lcm
num1 = 54
num2 = 24
print["The L.C.M. is", compute_lcm[num1, num2]]
7 Và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
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.70710678118654752,
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.70710678118654753 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.70710678118654754.
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
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.70710678118654755 để 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ị
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.70710678118654756,
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.70710678118654757, 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.70710678118654758. 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ư
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.70710678118654759,
gcd[a, b] x lcm[a, b] = a x b0, và
gcd[a, b] x lcm[a, b] = a x b1, 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ì
gcd[a, b] x lcm[a, b] = a x b2 tương đương khoảng 3.141592653589793, nên khi chúng ta sử dụng
gcd[a, b] x lcm[a, b] = a x b3 với giá trị trả về bởi
gcd[a, b] x lcm[a, b] = a x b4, 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
gcd[a, b] x lcm[a, b] = a x b5 để 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
gcd[a, b] x lcm[a, b] = a x b6. 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
gcd[a, b] x lcm[a, b] = a x b2.
Nếu bạn muốn tính các giá trị logarit cơ số 2 hoặc 10, hãy sử dụng
gcd[a, b] x lcm[a, b] = a x b8 và
gcd[a, b] x lcm[a, b] = a x b9 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 10 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 11. Hãy nhớ rằng không có hàm
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 12, do đó bạn sẽ phải tiếp tục 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 13 để 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.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 14.
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 15 trong
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 16 nghĩa là 1 cộng. Do đó,
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 14 tính
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 18 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.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 14.
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.78539816339744840 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.78539816339744841 có sẵn hoặc toán tử
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.78539816339744842.
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.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.78539816339744843, 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.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.78539816339744844.
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.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.78539816339744845, 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.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.78539816339744846 tích hợp, và pha của nó có thể được tính bằ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.78539816339744847 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.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.78539816339744848, nó sẽ trả về một cặp
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.78539816339744849, 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.1415926535897980 và phi là
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.78539816339744847.
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.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.1415926535897982. Số phức trả về bởi hàm này 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.1415926535897983.
The L.C.M. is 2160
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.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.1415926535897984 hoặc cosine của nó bằ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.1415926535897985.
The L.C.M. is 2161
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
# Python program to find the L.C.M. of two input number
# This function computes GCD
def compute_gcd[x, y]:
while[y]:
x, y = y, x % y
return x
# This function computes LCM
def compute_lcm[x, y]:
lcm = [x*y]//compute_gcd[x,y]
return lcm
num1 = 54
num2 = 24
print["The L.C.M. is", compute_lcm[num1, num2]]
1 để 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é.