programming python

Tôi có thể sử dụng các ký hiệu trong python không?

Để bắt đầu, chúng ta nên làm rõ vài điều về SymPy. SymPy không gì khác hơn là một thư viện Python, như

>>> x = symbols['x']
>>> x + 1
x + 1

>>> x = symbols['x']
>>> x + 1
x + 1

4, hoặc thậm chí là các mô-đun trong thư viện chuẩn Python

>>> x = symbols['x']
>>> x + 1
x + 1

5 hoặc

>>> x = symbols['x']
>>> x + 1
x + 1

6. Điều này có nghĩa là SymPy không thêm bất cứ thứ gì vào ngôn ngữ Python. Những hạn chế cố hữu trong ngôn ngữ Python cũng là cố hữu trong SymPy. Điều đó cũng có nghĩa là SymPy cố gắng sử dụng các thành ngữ Python bất cứ khi nào có thể, giúp việc lập trình với SymPy trở nên dễ dàng đối với những người đã quen với việc lập trình với Python. Ví dụ đơn giản, SymPy sử dụng cú pháp Python để xây dựng các biểu thức. Phép nhân ẩn [như

>>> x = symbols['x']
>>> x + 1
x + 1

7 hoặc

>>> x = symbols['x']
>>> x + 1
x + 1

8] không được phép trong Python và do đó không được phép trong SymPy. Để nhân

>>> x = symbols['x']
>>> x + 1
x + 1

9 và

>>> x, y, z = symbols['x y z']

0, bạn phải gõ

>>> x, y, z = symbols['x y z']

1 với

>>> x, y, z = symbols['x y z']

Biểu tượng #

Một hệ quả của thực tế này là SymPy có thể được sử dụng trong bất kỳ môi trường nào có sẵn Python. Chúng tôi chỉ cần nhập nó, giống như bất kỳ thư viện nào khác

>>> x = symbols['x']
>>> x + 1
x + 1

Điều này nhập tất cả các hàm và lớp từ SymPy vào phiên Python tương tác của chúng tôi. Bây giờ, giả sử chúng ta bắt đầu tính toán

>>> x = symbols['x']
>>> x + 1
x + 1

Ối. Điều gì đã xảy ra ở đây? . Trong Python, các biến không có ý nghĩa gì cho đến khi chúng được định nghĩa. SymPy cũng không khác gì. Không giống như nhiều hệ thống thao tác tượng trưng mà bạn có thể đã sử dụng, trong SymPy, các biến không được xác định tự động. Để xác định các biến, chúng ta phải sử dụng

>>> x, y, z = symbols['x y z']

>>> x = symbols['x']
>>> x + 1
x + 1

>>> x, y, z = symbols['x y z']

5 lấy một chuỗi tên biến được phân tách bằng dấu cách hoặc dấu phẩy và tạo Biểu tượng từ chúng. Sau đó chúng ta có thể gán chúng cho các tên biến. Sau đó, chúng tôi sẽ điều tra một số cách thuận tiện mà chúng tôi có thể giải quyết vấn đề này. Bây giờ, chúng ta hãy định nghĩa các tên biến phổ biến nhất,

>>> x, y, z = symbols['x y z']

>>> x, y, z = symbols['x y z']

8 và

>>> x, y, z = symbols['x y z']

9, để sử dụng trong phần còn lại của phần này

>>> x, y, z = symbols['x y z']

Lưu ý cuối cùng, chúng tôi lưu ý rằng tên của Biểu tượng và tên của biến mà nó được gán không nhất thiết phải liên quan gì đến nhau

>>> x = symbols['x']
>>> x + 1
x + 1

Ở đây chúng ta đã làm một việc rất khó hiểu là gán một Ký hiệu có tên

>>> x = symbols['x']
>>> x + 1
x + 1

10 cho biến

>>> x = symbols['x']
>>> x + 1
x + 1

11 và một Ký hiệu có tên

>>> x = symbols['x']
>>> x + 1
x + 1

11 cho biến

>>> x = symbols['x']
>>> x + 1
x + 1

10. Bây giờ, biến Python có tên là

>>> x = symbols['x']
>>> x + 1
x + 1

10 trỏ đến Biểu tượng SymPy có tên là

>>> x = symbols['x']
>>> x + 1
x + 1

11 và ngược lại. Thật khó hiểu. Chúng tôi cũng có thể đã làm một cái gì đó như

>>> x = symbols['x']
>>> x + 1
x + 1

Điều này cũng cho thấy rằng các Biểu tượng có thể có tên dài hơn một ký tự nếu chúng ta muốn

Thông thường, cách tốt nhất là gán Biểu tượng cho các biến Python cùng tên, mặc dù có những trường hợp ngoại lệ. Tên biểu tượng có thể chứa các ký tự không được phép trong tên biến Python hoặc có thể chỉ muốn tránh nhập tên dài bằng cách gán Biểu tượng có tên dài cho biến Python một chữ cái

Để tránh nhầm lẫn, trong suốt hướng dẫn này, tên Ký hiệu và tên biến Python sẽ luôn trùng nhau. Hơn nữa, từ “Symbol” sẽ chỉ một SymPy Symbol và từ “variable” sẽ chỉ một biến Python

Cuối cùng, hãy chắc chắn rằng chúng ta hiểu sự khác biệt giữa Biểu tượng SymPy và biến Python. Hãy xem xét những điều sau đây

>>> x = symbols['x']
>>> x + 1
x + 1

Bạn nghĩ đầu ra của mã này sẽ là gì? . Hãy xem điều gì thực sự xảy ra

>>> x = symbols['x']
>>> x + 1
x + 1

Thay đổi

>>> x, y, z = symbols['x y z']

0 thành

>>> x = symbols['x']
>>> x + 1
x + 1

18 không ảnh hưởng đến

>>> x = symbols['x']
>>> x + 1
x + 1

19. Điều này là do

>>> x = symbols['x']
>>> x + 1
x + 1

80 thay đổi biến Python

>>> x, y, z = symbols['x y z']

0 thành

>>> x = symbols['x']
>>> x + 1
x + 1

18, nhưng không ảnh hưởng đến Biểu tượng SymPy

>>> x, y, z = symbols['x y z']

0, vốn là thứ chúng tôi đã sử dụng để tạo

>>> x = symbols['x']
>>> x + 1
x + 1

19. Khi chúng tôi tạo

>>> x = symbols['x']
>>> x + 1
x + 1

19, biến Python

>>> x, y, z = symbols['x y z']

0 là một Biểu tượng. Sau khi chúng tôi tạo, chúng tôi đã thay đổi biến Python

>>> x, y, z = symbols['x y z']

0 thành 2. Nhưng

>>> x = symbols['x']
>>> x + 1
x + 1

19 vẫn giữ nguyên. Hành vi này không phải là duy nhất đối với SymPy. Tất cả các chương trình Python đều hoạt động theo cách này. nếu một biến bị thay đổi, các biểu thức đã được tạo với biến đó sẽ không tự động thay đổi. Ví dụ

>>> x = symbols['x']
>>> x + 1
x + 1

Mẹo nhanh

Để thay đổi giá trị của Ký hiệu trong một biểu thức, hãy sử dụng

>>> x = symbols['x']
>>> x + 1
x + 1

>>> x = symbols['x']
>>> x + 1
x + 1

Trong ví dụ này, nếu chúng ta muốn biết

>>> x = symbols['x']
>>> x + 1
x + 1

19 là gì với giá trị mới của

>>> x, y, z = symbols['x y z']

0, chúng ta cần đánh giá lại mã đã tạo ra

>>> x = symbols['x']
>>> x + 1
x + 1

19, cụ thể là,

>>> x = symbols['x']
>>> x + 1
x + 1

93. Điều này có thể phức tạp nếu một số dòng được tạo

>>> x = symbols['x']
>>> x + 1
x + 1

19. Một lợi thế của việc sử dụng hệ thống tính toán tượng trưng như SymPy là chúng ta có thể xây dựng biểu diễn tượng trưng cho

>>> x = symbols['x']
>>> x + 1
x + 1

19, sau đó thay thế

>>> x, y, z = symbols['x y z']

0 bằng các giá trị. Cách chính xác để làm điều này trong SymPy là sử dụng

>>> x = symbols['x']
>>> x + 1
x + 1

89, sẽ được thảo luận chi tiết hơn sau

>>> x = symbols['x']
>>> x + 1
x + 1

dấu bằng#

Một hậu quả rất quan trọng khác của việc SymPy không mở rộng cú pháp Python là

>>> x = symbols['x']
>>> x + 1
x + 1

98 không đại diện cho sự bình đẳng trong SymPy. Thay vào đó là phép gán biến Python. Điều này được mã hóa cứng thành ngôn ngữ Python và SymPy không cố gắng thay đổi điều đó

Tuy nhiên, bạn có thể nghĩ rằng

>>> x = symbols['x']
>>> x + 1
x + 1

99, được sử dụng để kiểm tra tính bình đẳng trong Python, được sử dụng cho SymPy là bình đẳng. Điều này cũng không hẳn đúng. Hãy để chúng tôi xem điều gì sẽ xảy ra khi chúng tôi sử dụng

>>> x = symbols['x']
>>> x + 1
x + 1

>>> x = symbols['x']
>>> x + 1
x + 1

Thay vì đối xử tượng trưng với

>>> x = symbols['x']
>>> x + 1
x + 1

11, chúng tôi chỉ lấy

>>> x = symbols['x']
>>> x + 1
x + 1

12. Trong SymPy,

>>> x = symbols['x']
>>> x + 1
x + 1

99 đại diện cho kiểm tra bình đẳng cấu trúc chính xác. Điều này có nghĩa là

>>> x = symbols['x']
>>> x + 1
x + 1

14 nghĩa là chúng ta đang hỏi liệu \[a = b\] . Chúng tôi luôn nhận được một

>>> x = symbols['x']
>>> x + 1
x + 1

15 là kết quả của

>>> x = symbols['x']
>>> x + 1
x + 1

99. Có một đối tượng riêng biệt, được gọi là

>>> x = symbols['x']
>>> x + 1
x + 1

17, có thể được sử dụng để tạo các đẳng thức tượng trưng

>>> x = symbols['x']
>>> x + 1
x + 1

Cũng có một cảnh báo bổ sung về

>>> x = symbols['x']
>>> x + 1
x + 1

99. Giả sử chúng ta muốn biết liệu \[[x + 1]^2 = x^2 + 2x + 1\] . Chúng ta có thể thử một cái gì đó như thế này.

>>> x = symbols['x']
>>> x + 1
x + 1

Chúng ta lại có

>>> x = symbols['x']
>>> x + 1
x + 1

12. Tuy nhiên, \[[x + 1]^2\] bằng \[x^2 + 2x + . Chuyện gì đang xảy ra ở đây?. What is going on here? Did we find a bug in SymPy, or is it just not powerful enough to recognize this basic algebraic fact?

Nhớ lại từ trên rằng

>>> x = symbols['x']
>>> x + 1
x + 1

99 đại diện cho kiểm tra bình đẳng cấu trúc chính xác. “Chính xác” ở đây có nghĩa là hai biểu thức sẽ so sánh bằng với

>>> x = symbols['x']
>>> x + 1
x + 1

99 chỉ khi chúng hoàn toàn bằng nhau về mặt cấu trúc. Ở đây, \[[x + 1]^2\] và \[x^2 + 2x + 1 . Một là lũy thừa của phép cộng hai số hạng và hai là phép cộng ba số hạng. are not the same structurally. One is the power of an addition of two terms, and the other is the addition of three terms.

Hóa ra là khi sử dụng SymPy làm thư viện, việc có bài kiểm tra

>>> x = symbols['x']
>>> x + 1
x + 1

99 về đẳng thức cấu trúc chính xác sẽ hữu ích hơn nhiều so với việc nó đại diện cho đẳng thức tượng trưng hoặc để nó kiểm tra đẳng thức toán học. Tuy nhiên, là một người dùng mới, có lẽ bạn sẽ quan tâm đến hai cái sau nhiều hơn. Chúng ta đã thấy một giải pháp thay thế cho việc biểu diễn các đẳng thức một cách tượng trưng,

>>> x = symbols['x']
>>> x + 1
x + 1

17. Để kiểm tra xem hai đối tượng có bằng nhau hay không, cách tốt nhất là nhớ lại sự kiện cơ bản là nếu \[a = b\] thì \[a - b = 0\]. Thus, the best way to check if \[a = b\] là lấy \[a - b . Chúng ta sẽ biết and simplify it, and see if it goes to 0. We will learn sau hàm để thực hiện điều này được gọi là

>>> x = symbols['x']
>>> x + 1
x + 1

44. Phương pháp này không phải là không thể sai được—trên thực tế, nó có thể được chứng minh về mặt lý thuyết rằng không thể xác định xem hai biểu thức tượng trưng có giống hệt nhau nói chung hay không—nhưng đối với hầu hết các biểu thức phổ biến, nó hoạt động khá tốt.

>>> x = symbols['x']
>>> x + 1
x + 1

Ngoài ra còn có một phương pháp gọi là

>>> x = symbols['x']
>>> x + 1
x + 1

45 để kiểm tra xem hai biểu thức có bằng nhau hay không bằng cách đánh giá chúng bằng số tại các điểm ngẫu nhiên

>>> x = symbols['x']
>>> x + 1
x + 1

Hai lưu ý cuối cùng.

>>> x = symbols['x']
>>> x + 1
x + 1

46 và

>>> x = symbols['x']
>>> x + 1
x + 1

47#

Bạn có thể nhận thấy rằng chúng tôi đã sử dụng

>>> x = symbols['x']
>>> x + 1
x + 1

48 để lũy thừa thay vì tiêu chuẩn

>>> x = symbols['x']
>>> x + 1
x + 1

46. Đó là bởi vì SymPy tuân theo các quy ước của Python. Trong Python,

>>> x = symbols['x']
>>> x + 1
x + 1

46 đại diện cho loại trừ logic hoặc. SymPy tuân theo quy ước này

>>> x = symbols['x']
>>> x + 1
x + 1

Cuối cùng, một cuộc thảo luận kỹ thuật nhỏ về cách SymPy hoạt động theo thứ tự. Khi bạn gõ một cái gì đó như

>>> x = symbols['x']
>>> x + 1
x + 1

61, Biểu tượng SymPy

>>> x, y, z = symbols['x y z']

0 được thêm vào Python int

>>> x = symbols['x']
>>> x + 1
x + 1

63. Các quy tắc toán tử của Python sau đó cho phép SymPy nói với Python rằng các đối tượng SymPy biết cách được thêm vào các int của Python và do đó,

>>> x = symbols['x']
>>> x + 1
x + 1

63 sẽ tự động được chuyển đổi thành đối tượng SymPy Integer

Loại ma thuật điều hành này xảy ra tự động đằng sau hậu trường và bạn thậm chí hiếm khi cần biết rằng nó đang xảy ra. Tuy nhiên, có một ngoại lệ. Bất cứ khi nào bạn kết hợp một đối tượng SymPy và một đối tượng SymPy, hoặc một đối tượng SymPy và một đối tượng Python, bạn sẽ có một đối tượng SymPy, nhưng bất cứ khi nào bạn kết hợp hai đối tượng Python, SymPy sẽ không bao giờ hoạt động và do đó bạn sẽ có một đối tượng Python

>>> x = symbols['x']
>>> x + 1
x + 1

Đây thường không phải là vấn đề lớn. Int Python hoạt động giống như SymPy Integers, nhưng có một ngoại lệ quan trọng. phân công. Trong SymPy, phép chia hai Số nguyên cho một Số hợp lý

>>> x = symbols['x']
>>> x + 1
x + 1

Nhưng trong Python,

>>> x = symbols['x']
>>> x + 1
x + 1

47 đại diện cho phép chia số nguyên hoặc phép chia dấu phẩy động, tùy thuộc vào việc bạn đang sử dụng Python 2 hay Python 3 và tùy thuộc vào việc bạn đã chạy

>>> x = symbols['x']
>>> x + 1
x + 1

66 trong Python 2 hay chưa, phiên bản này không còn được hỗ trợ từ các phiên bản trên SymPy 1. 5. 1

>>> x = symbols['x']
>>> x + 1
x + 1

Để tránh điều này, chúng ta có thể xây dựng đối tượng hợp lý một cách rõ ràng

>>> x = symbols['x']
>>> x + 1
x + 1

Vấn đề này cũng xuất hiện bất cứ khi nào chúng ta có một biểu thức tượng trưng lớn hơn với

>>> x = symbols['x']
>>> x + 1
x + 1

67 trong đó. Ví dụ

>>> x = symbols['x']
>>> x + 1
x + 1

Điều này xảy ra bởi vì Python trước tiên đánh giá

>>> x = symbols['x']
>>> x + 1
x + 1

68 thành

>>> x = symbols['x']
>>> x + 1
x + 1

69, sau đó được chuyển thành loại SymPy khi nó được thêm vào

>>> x, y, z = symbols['x y z']

0. Một lần nữa, chúng ta có thể giải quyết vấn đề này bằng cách tạo ra một Rational một cách rõ ràng.

Chúng ta có thể sử dụng các ký hiệu đặc biệt trong Python không?

Trong các chuỗi Python, dấu gạch chéo ngược "\" là một ký tự đặc biệt, còn được gọi là ký tự "thoát" . Nó được sử dụng để đại diện cho các ký tự khoảng trắng nhất định. "\t" là một tab, "\n" là một dòng mới và "\r" là một xuống dòng. Ngược lại, đặt trước một ký tự đặc biệt với "\" sẽ biến ký tự đó thành một ký tự thông thường.

%% có nghĩa là gì trong Python?

Khi nhìn thấy biểu tượng %, bạn có thể nghĩ là "phần trăm". Nhưng trong Python, cũng như hầu hết các ngôn ngữ lập trình khác, nó có ý nghĩa khác. Ký hiệu % trong Python được gọi là Toán tử Modulo. Nó trả về phần còn lại của phép chia toán hạng bên trái cho toán hạng bên phải .

Biểu tượng #

dấu bằng#

Hai lưu ý cuối cùng. >>> x = symbols['x'] >>> x + 1 x + 1 46 và >>> x = symbols['x'] >>> x + 1 x + 1 47#

Chúng ta có thể sử dụng các ký hiệu đặc biệt trong Python không?

%% có nghĩa là gì trong Python?

Bài Viết Liên Quan

Toplist mới

Bài mới nhất

Chủ Đề

Hai lưu ý cuối cùng.
>>> x = symbols['x'] >>> x + 1 x + 1
46 và
>>> x = symbols['x'] >>> x + 1 x + 1
47#