Hướng dẫn python print math equation - python in phương trình toán học

Trước hết, bỏ tất cả các nhập khẩu không cần thiết và gắn bó với những gì bạn thực sự cần. Toán biểu tượng là những gì

f = x ** 2 * sympy.exp(-x)
dfdx = sympy.diff(f, x)
d2fdx2 = sympy.diff(f, x, x)
g = sympy.exp(x) / sympy.factorial(2) * d2fdx2
5 đã được thực hiện để kiểm tra tài liệu cho điều đó.

Trong sympy, bạn phải xác định

f = x ** 2 * sympy.exp(-x)
dfdx = sympy.diff(f, x)
d2fdx2 = sympy.diff(f, x, x)
g = sympy.exp(x) / sympy.factorial(2) * d2fdx2
6 đầu tiên

import sympy
x = symbols('x')

Bây giờ bạn sẽ sử dụng ký hiệu

f = x ** 2 * sympy.exp(-x)
dfdx = sympy.diff(f, x)
d2fdx2 = sympy.diff(f, x, x)
g = sympy.exp(x) / sympy.factorial(2) * d2fdx2
7 để xây dựng một biểu thức bằng cách sử dụng các toán tử và chức năng tích hợp trong mô -đun
f = x ** 2 * sympy.exp(-x)
dfdx = sympy.diff(f, x)
d2fdx2 = sympy.diff(f, x, x)
g = sympy.exp(x) / sympy.factorial(2) * d2fdx2
5. Xin lưu ý rằng
f = x ** 2 * sympy.exp(-x)
dfdx = sympy.diff(f, x)
d2fdx2 = sympy.diff(f, x, x)
g = sympy.exp(x) / sympy.factorial(2) * d2fdx2
9 là số mũ và
>>> print(g)
x**2/2 - 2*x + 1
0 là XOR logic.

f = x ** 2 * sympy.exp(-x)
dfdx = sympy.diff(f, x)
d2fdx2 = sympy.diff(f, x, x)
g = sympy.exp(x) / sympy.factorial(2) * d2fdx2

Khi bạn viết

>>> print(g)
x**2/2 - 2*x + 1
1 trong trình thông dịch tương tác, nó sẽ viết biểu thức theo cách bạn muốn. Không thể cho thấy điều đó ở đây nhưng ít nhất tôi có thể làm điều này:

>>> print(g)
x**2/2 - 2*x + 1

Bạn không thể làm những gì bạn muốn với các mô -đun

>>> print(g)
x**2/2 - 2*x + 1
2,
>>> print(g)
x**2/2 - 2*x + 1
3 và
>>> print(g)
x**2/2 - 2*x + 1
4 khi chúng tồn tại để đánh giá số - họ muốn số và cung cấp cho bạn số.

Nếu sau này bạn muốn đánh giá biểu thức của mình cho một giá trị nhất định là

f = x ** 2 * sympy.exp(-x)
dfdx = sympy.diff(f, x)
d2fdx2 = sympy.diff(f, x, x)
g = sympy.exp(x) / sympy.factorial(2) * d2fdx2
7, bạn có thể làm

val_at_point = g.evalf(subs={x: 1.5})

trong đó

>>> print(g)
x**2/2 - 2*x + 1
6 là một từ điển.

Hoặc bạn có thể biến

>>> print(g)
x**2/2 - 2*x + 1
1 thành chức năng Python Lambda:

fun_g = sympy.lambdify(x, g)
val_at_point = fun_g(1.5)

Nếu bạn đang làm điều này cho một lớp toán, bạn có thể muốn làm việc trong trình thông dịch bằng mọi cách trong trường hợp đó bạn có thể bắt đầu bằng cách viết

>>> from sympy import *

để bạn có thể bỏ qua tất cả các công cụ

>>> print(g)
x**2/2 - 2*x + 1
8 trong các mẫu mã trên. Tôi để chúng ở đó chỉ để cho thấy các biểu tượng đến từ đâu.


Bây giờ chúng ta đã biết cách làm việc với các số và chuỗi, hãy viết một chương trình thực sự có thể hữu ích! Giả sử bạn muốn tìm hiểu xem bạn nặng bao nhiêu bằng đá. Một chương trình súc tích có thể làm cho công việc ngắn của nhiệm vụ này. Vì một viên đá là 14 pounds, và có khoảng 2,2 pound trong một kg, công thức sau đây nên thực hiện thủ thuật:

Vì vậy, hãy biến công thức này thành một chương trình!

mass_kg = int(input("What is your mass in kilograms?" ))
mass_stone = mass_kg * 2.2 / 14
print("You weigh", mass_stone, "stone.")

Chạy chương trình này và lấy trọng lượng của bạn bằng đá! Lưu ý rằng việc áp dụng công thức cũng đơn giản như đưa vào một vài tuyên bố toán học:

mass_stone = mass_kg * 2.2 / 14

Toán tử toán học [Chỉnh sửa | Chỉnh sửa nguồn]

Dưới đây là một số toán tử toán học thường được sử dụng

Cú phápmôn ToánTên hoạt động
>>> print(g)
x**2/2 - 2*x + 1
9

Hướng dẫn python print math equation - python in phương trình toán học

phép cộng
val_at_point = g.evalf(subs={x: 1.5})
0
phép trừ
val_at_point = g.evalf(subs={x: 1.5})
1
phép nhân
val_at_point = g.evalf(subs={x: 1.5})
2
Phân chia (xem ghi chú bên dưới)
val_at_point = g.evalf(subs={x: 1.5})
3
Phân chia sàn (ví dụ: 5 // 2 = 2) - Có sẵn trong Python 2.2 trở lên
val_at_point = g.evalf(subs={x: 1.5})
4
modulo
val_at_point = g.evalf(subs={x: 1.5})
5
phủ định
val_at_point = g.evalf(subs={x: 1.5})
6
giá trị tuyệt đối
val_at_point = g.evalf(subs={x: 1.5})
7
số mũ
val_at_point = g.evalf(subs={x: 1.5})
8
căn bậc hai

Lưu ý: Để sử dụng chức năng

val_at_point = g.evalf(subs={x: 1.5})
9, bạn phải nói rõ ràng với Python rằng bạn muốn nó tải mô -đun toán học. Để làm điều đó, viết
In order to use the
val_at_point = g.evalf(subs={x: 1.5})
9 function, you must explicitly tell Python that you want it to load the math module. To do that, write

ở đầu tập tin của bạn. Đối với các chức năng khác có sẵn bởi tuyên bố này, xem ở đây.

Coi chừng rằng do những hạn chế của số học điểm nổi, các lỗi làm tròn có thể gây ra kết quả bất ngờ. Ví dụ:

 >>> print(0.6/0.2)
 3.0
 >>> print(0.6//0.2)
 2.0

Đối với sê -ri Python 2.x,

fun_g = sympy.lambdify(x, g)
val_at_point = fun_g(1.5)
0 không "phân chia sàn" cho số nguyên và độ dài (ví dụ: 5/2 = 2) nhưng "phân chia thực sự" cho phao và phức tạp (ví dụ: 5.0/2.0 = 2.5). Đối với Python 3.x,
fun_g = sympy.lambdify(x, g)
val_at_point = fun_g(1.5)
0 không "phân chia thực sự" cho tất cả các loại. [1] [2]

Điều này có thể được sửa chữa bằng cách đặt một

fun_g = sympy.lambdify(x, g)
val_at_point = fun_g(1.5)
2 xung quanh một dấu hiệu phân chia bình thường, do lỗi Python khiến vòng (0,5) làm tròn xuống.

Nhà điều hành

fun_g = sympy.lambdify(x, g)
val_at_point = fun_g(1.5)
3 luôn thực hiện phân chia Euclide (hoặc số nguyên), bao gồm một thuật ngữ thương số (thu được từ toán tử
fun_g = sympy.lambdify(x, g)
val_at_point = fun_g(1.5)
3) và một thuật ngữ còn lại (thu được từ toán tử
fun_g = sympy.lambdify(x, g)
val_at_point = fun_g(1.5)
5). Trong ví dụ trước, chúng tôi đã thấy rằng thuật ngữ thương số
fun_g = sympy.lambdify(x, g)
val_at_point = fun_g(1.5)
6 là
fun_g = sympy.lambdify(x, g)
val_at_point = fun_g(1.5)
7, có thể được xác minh bằng cách mở rộng ví dụ trên:

 >>> 0.6 == 0.2 * ( 0.6 // 0.2 ) + 0.6 % 0.2
 True
 >>> 0.6 // 0.2
 2.0
 >>> 0.6 % 0.2
 0.19999999999999996

Sự khác biệt giữa các hoạt động

fun_g = sympy.lambdify(x, g)
val_at_point = fun_g(1.5)
0 và
fun_g = sympy.lambdify(x, g)
val_at_point = fun_g(1.5)
3 khi áp dụng cho các số thập phân là do cách lưu trữ số thập phân trong python và làm tròn.

f = x ** 2 * sympy.exp(-x)
dfdx = sympy.diff(f, x)
d2fdx2 = sympy.diff(f, x, x)
g = sympy.exp(x) / sympy.factorial(2) * d2fdx2
0

Thứ tự hoạt động [Chỉnh sửa | Chỉnh sửa nguồn]

Python sử dụng thứ tự tiêu chuẩn của các hoạt động như được dạy trong các lớp đại số và hình học tại trường trung học hoặc trung học. Đó là, các biểu thức toán học được đánh giá theo thứ tự sau (ghi nhớ bởi nhiều người là PEMDAs), cũng được áp dụng cho các dấu ngoặc đơn.

.

TênCú phápmôn ToánTên hoạt động
>>> print(g)
x**2/2 - 2*x + 1
9
arentheses
phép cộng
val_at_point = g.evalf(subs={x: 1.5})
0
phép trừlease
val_at_point = g.evalf(subs={x: 1.5})
1
xponents
phép nhân
val_at_point = g.evalf(subs={x: 1.5})
2
Phân chia (xem ghi chú bên dưới)xcuse
val_at_point = g.evalf(subs={x: 1.5})
3
ultiplication and

Phân chia sàn (ví dụ: 5 // 2 = 2) - Có sẵn trong Python 2.2 trở lênivision

val_at_point = g.evalf(subs={x: 1.5})
4
modulo
val_at_point = g.evalf(subs={x: 1.5})
5
y

phủ địnhear

val_at_point = g.evalf(subs={x: 1.5})
6
ddition and

giá trị tuyệt đốiubtraction

val_at_point = g.evalf(subs={x: 1.5})
7
số mũunt

val_at_point = g.evalf(subs={x: 1.5})
8ally

căn bậc hai

Sẽ không tốt nếu chúng ta luôn làm việc với các số tròn đẹp trong khi làm toán? Thật không may, thế giới thực không quá gọn gàng và ngăn nắp như chúng ta muốn. Đôi khi, chúng ta kết thúc với những con số dài, xấu xí như sau:

f = x ** 2 * sympy.exp(-x)
dfdx = sympy.diff(f, x)
d2fdx2 = sympy.diff(f, x, x)
g = sympy.exp(x) / sympy.factorial(2) * d2fdx2
1

Theo mặc định, câu lệnh

>>> from sympy import *
4 của Python in các số tới 10 số thập phân. Nhưng nếu bạn chỉ muốn một hoặc hai thì sao? Chúng ta có thể sử dụng hàm
>>> from sympy import *
5, làm tròn một số vào số điểm thập phân bạn chọn.
>>> from sympy import *
5 có hai đối số: số bạn muốn làm tròn và số lượng vị trí thập phân để làm tròn nó. Ví dụ:

f = x ** 2 * sympy.exp(-x)
dfdx = sympy.diff(f, x)
d2fdx2 = sympy.diff(f, x, x)
g = sympy.exp(x) / sympy.factorial(2) * d2fdx2
2

Bây giờ, hãy thay đổi chương trình của chúng tôi để chỉ in kết quả thành hai vị trí thập phân.

f = x ** 2 * sympy.exp(-x)
dfdx = sympy.diff(f, x)
d2fdx2 = sympy.diff(f, x, x)
g = sympy.exp(x) / sympy.factorial(2) * d2fdx2
3

Điều này cũng chứng minh khái niệm về các chức năng làm tổ. Như bạn có thể thấy, bạn có thể đặt một hàm bên trong một chức năng khác và mọi thứ vẫn sẽ hoạt động chính xác theo cách bạn mong đợi. Nếu bạn không thích điều này, bạn luôn có thể sử dụng nhiều biến, thay vào đó:

f = x ** 2 * sympy.exp(-x)
dfdx = sympy.diff(f, x)
d2fdx2 = sympy.diff(f, x, x)
g = sympy.exp(x) / sympy.factorial(2) * d2fdx2
4

Để tìm hiểu về các tùy chọn định dạng nhiều hơn, hãy xem phần định dạng trong đầu vào và đầu ra chương.

Ghi chú [Chỉnh sửa | Chỉnh sửa nguồn]

  1. ↑ Có gì mới trong Python 2.2 What's New in Python 2.2
  2. ↑ PEP 238 - Thay đổi nhà điều hành bộ phận PEP 238 -- Changing the Division Operator