Phương thức tĩnh có thể được gọi mà không cần tạo đối tượng hoặc thể hiện. Chỉ cần tạo phương thức và gọi trực tiếp. Đây là một ý nghĩa trực giao với lập trình hướng đối tượng. chúng tôi gọi một phương thức mà không tạo đối tượng
Điều này chạy trực tiếp với khái niệm lập trình hướng đối tượng và có thể không được tán thành, nhưng đôi khi có thể hữu ích khi có một phương thức tĩnh
khóa học liên quan. Hoàn thành khóa học & bài tập lập trình Python
Ví dụ
phương pháp tĩnh
Thông thường, bạn muốn có các lệnh gọi hàm hoặc tạo một đối tượng mà bạn gọi các phương thức của nó. tuy nhiên bạn có thể làm một cái gì đó khác. gọi một phương thức trong một lớp mà không tạo một đối tượng
Trình diễn phương thức tĩnh bên dưới. Định nghĩa một lớp với một phương thức. Thêm từ khóa @staticmethod phía trên để làm cho nó tĩnh
1
2
3
4
5
6
class Music:
@staticmethod
def play[]:
print["*playing music*"]
Music.play[]
Các phương thức tĩnh bên trong một lớp
Một lớp có thể chứa cả phương thức tĩnh và không tĩnh. Nếu bạn muốn gọi các phương thức không tĩnh, bạn sẽ phải tạo một đối tượng. Mã bên dưới không hoạt động vì một đối tượng không được tạo
1
2
3
4
5
6
7
8
9
10
class Music:
@staticmethod
def play[]:
print["*playing music*"]
def stop[self]:
print["stop playing"]
Music.play[]
Music.stop[]
Gọi các phương thức tĩnh
Các phương thức lớp thông thường và các phương thức tĩnh có thể được trộn lẫn [tại sao không?].
Điều này có thể rất khó hiểu. chúng tôi sử dụng cả khái niệm hướng đối tượng và lập trình chức năng trộn lẫn trong một lớp.
Nếu bạn tạo một đối tượng, chúng ta có thể gọi các phương thức không tĩnh. Nhưng bạn cũng có thể gọi phương thức tĩnh mà không cần tạo đối tượng
1
2
3
4
5
6
7
8
9
10
11
12
class Music:
@staticmethod
def play[]:
print["*playing music*"]
def stop[self]:
print["stop playing"]
Music.play[]
obj = Music[]
obj.stop[]
Nhìn chung, các phương thức tĩnh là một khái niệm thú vị cần biết, nhưng trong thực tế, bạn hiếm khi sử dụng chúng. Đôi khi sử dụng các phương thức tĩnh có thể là dấu hiệu của việc có một thiết kế tồi
Chương này được trích từ cuốn sách A Primer on Scientific Programming with Python của H. P. Langtangen, tái bản lần thứ 5, Springer, 2016
Các lớp có thể được sử dụng cho nhiều thứ trong tính toán khoa học, nhưng một trong những nhiệm vụ lập trình thường xuyên nhất là biểu diễn các hàm toán học có một tập tham số ngoài một hoặc nhiều biến độc lập. Phần này giải thích tại sao các hàm toán học như vậy gây khó khăn cho người lập trình và phần này cho thấy ý tưởng lớp gặp những khó khăn này như thế nào. Các phần trình bày một ví dụ khác trong đó một lớp đại diện cho một hàm toán học. Tài liệu nâng cao hơn về các lớp học, mà đối với một số độc giả có thể làm rõ các ý tưởng, nhưng cũng có thể bỏ qua trong lần đọc đầu tiên, xuất hiện trong các phần và phần
Thách đấu. chức năng với các tham số
Để tạo động lực cho khái niệm lớp, chúng ta sẽ xem xét các hàm có tham số. Một ví dụ là \[ y[t]=v_0t-\frac{1}{2}gt^2 \]. Về mặt khái niệm, trong vật lý, đại lượng \[ y \] được xem như một hàm của \[ t \], nhưng \[ y \] còn phụ thuộc vào hai tham số khác là \[ v_0 \] và \[ g \], mặc dù . Chúng ta có thể viết \[ y[t;v_0,g] \] để chỉ ra rằng \[ t \] là biến độc lập, trong khi \[ v_0 \] và \[ g \] là các tham số. Nói một cách chính xác, \[ g \] là một tham số cố định [miễn là chúng ta ở trên bề mặt trái đất và có thể xem \[ g \] là hằng số], vì vậy chỉ có \[ v_0 \] và \[ t \] mới có thể . Sau đó, sẽ tốt hơn nếu viết \[ y[t;v_0] \]
Trong trường hợp chung, chúng ta có thể có một hàm \[ x \] có \[ n \] tham số \[ p_1,\ldots,p_n \]. \[ f[x; p_1,\ldots,p_n] \]. Một ví dụ có thể là $$ \begin{equation*} g[x; A, a] = Ae^{-ax} \thinspace. \end{phương trình*} $$
Làm thế nào chúng ta nên thực hiện các chức năng như vậy?
def y[t, v0]:
g = 9.81
return v0*t - 0.5*g*t**2
def g[x, a, A]:
return A*exp[-a*x]
Vấn đề
Có một vấn đề lớn với giải pháp này. Nhiều công cụ phần mềm mà chúng ta có thể sử dụng cho các phép toán trên các hàm giả định rằng một hàm của một biến chỉ có một đối số trong biểu diễn hàm của máy tính. Ví dụ: chúng ta có thể có một công cụ để lấy đạo hàm của một hàm \[ f[x] \] tại một điểm \[ x \], sử dụng phép tính gần đúng $$ \begin{equation} f'[x]\approx {f[x
def diff[f, x, h=1E-5]:
return [f[x+h] - f[x]]/h
Hàm
v0 = 3 dy = diff[y, 1] A = 1; a = 0.1 dg = diff[g, 1.5]1 hoạt động với bất kỳ hàm
v0 = 3 dy = diff[y, 1] A = 1; a = 0.1 dg = diff[g, 1.5]2 nào nhận một đối số
class Music:0
@staticmethod
def play[]:
print["*playing music*"]
Music.play[]
Thật không may,
v0 = 3 dy = diff[y, 1] A = 1; a = 0.1 dg = diff[g, 1.5]1 sẽ không hoạt động với chức năng
v0 = 3 dy = diff[y, 1] A = 1; a = 0.1 dg = diff[g, 1.5]4 của chúng tôi. Gọi
v0 = 3 dy = diff[y, 1] A = 1; a = 0.1 dg = diff[g, 1.5]5 dẫn đến lỗi bên trong hàm
v0 = 3 dy = diff[y, 1] A = 1; a = 0.1 dg = diff[g, 1.5]1, vì nó cố gọi hàm
v0 = 3 dy = diff[y, 1] A = 1; a = 0.1 dg = diff[g, 1.5]7 của chúng ta chỉ với một đối số trong khi hàm
v0 = 3 dy = diff[y, 1] A = 1; a = 0.1 dg = diff[g, 1.5]7 yêu cầu hai đối số
Viết một hàm
v0 = 3 dy = diff[y, 1] A = 1; a = 0.1 dg = diff[g, 1.5]1 thay thế cho các hàm
v0 = 3 dy = diff[y, 1] A = 1; a = 0.1 dg = diff[g, 1.5]2 có hai đối số là một biện pháp khắc phục tồi vì nó hạn chế tập hợp các hàm
v0 = 3 dy = diff[y, 1] A = 1; a = 0.1 dg = diff[g, 1.5]2 được chấp nhận trong trường hợp rất đặc biệt của hàm có một biến độc lập và một tham số. Một nguyên tắc cơ bản trong lập trình máy tính là cố gắng tạo ra phần mềm càng phổ biến và có thể áp dụng rộng rãi càng tốt. Trong trường hợp hiện tại, điều đó có nghĩa là hàm
v0 = 3 dy = diff[y, 1] A = 1; a = 0.1 dg = diff[g, 1.5]1 nên được áp dụng cho tất cả các hàm
v0 = 3 dy = diff[y, 1] A = 1; a = 0.1 dg = diff[g, 1.5]2 của một biến và để
v0 = 3 dy = diff[y, 1] A = 1; a = 0.1 dg = diff[g, 1.5]2 nhận một đối số sau đó là quyết định tự nhiên để đưa ra
Sự không phù hợp của các đối số hàm, như đã nêu ở trên, là một vấn đề lớn vì có rất nhiều thư viện phần mềm dành cho các phép toán trên các hàm toán học của một biến. tích phân, vi phân, giải \[ f[x]=0 \], tìm cực trị, v.v. Tất cả các thư viện này sẽ cố gắng gọi hàm toán học mà chúng tôi cung cấp chỉ với một đối số. Khi chức năng của chúng tôi có nhiều đối số hơn, mã bên trong thư viện sẽ hủy bỏ lệnh gọi đến chức năng của chúng tôi và các lỗi như vậy có thể không phải lúc nào cũng dễ dàng theo dõi
Một giải pháp tồi. biến toàn cầu
Do đó, yêu cầu là xác định các triển khai Python của các hàm toán học của một biến với một đối số, biến độc lập. Hai ví dụ trên sau đó phải được thực hiện như
13
2
3
4
5
6
7
8
9
10
Các hàm này chỉ hoạt động nếu
145,
2
3
4
5
6
7
8
9
10
146 và
2
3
4
5
6
7
8
9
10
147 là các biến toàn cục, được khởi tạo trước khi một người cố gắng gọi hàm. Dưới đây là hai cuộc gọi mẫu trong đó
2
3
4
5
6
7
8
9
10
v0 = 3 dy = diff[y, 1] A = 1; a = 0.1 dg = diff[g, 1.5]1 phân biệt giữa
v0 = 3 dy = diff[y, 1] A = 1; a = 0.1 dg = diff[g, 1.5]7 và
190
2
3
4
5
6
7
8
9
10
________số 8
Việc sử dụng các biến toàn cục nói chung được coi là lập trình tồi. Tại sao các biến toàn cục lại có vấn đề trong trường hợp hiện tại có thể được minh họa khi cần phải làm việc với một số phiên bản của hàm. Giả sử chúng ta muốn làm việc với hai phiên bản của \[ y[t;v_0] \], một với \[ v_0=1 \] và một với \[ v_0=5 \]. Mỗi lần chúng ta gọi
v0 = 3 dy = diff[y, 1] A = 1; a = 0.1 dg = diff[g, 1.5]7, chúng ta phải nhớ phiên bản nào của chức năng mà chúng ta làm việc và đặt
145 tương ứng trước khi gọi
2
3
4
5
6
7
8
9
10
14
2
3
4
5
6
7
8
9
10
Một vấn đề khác là các biến có tên đơn giản như
145,
2
3
4
5
6
7
8
9
10
147 và
2
3
4
5
6
7
8
9
10
146 có thể dễ dàng được sử dụng làm biến toàn cục trong các phần khác của chương trình. Những phần này có thể thay đổi
2
3
4
5
6
7
8
9
10
145 của chúng tôi trong ngữ cảnh khác với hàm
2
3
4
5
6
7
8
9
10
v0 = 3 dy = diff[y, 1] A = 1; a = 0.1 dg = diff[g, 1.5]7, nhưng sự thay đổi đó ảnh hưởng đến tính chính xác của hàm
v0 = 3 dy = diff[y, 1] A = 1; a = 0.1 dg = diff[g, 1.5]7. Trong trường hợp như vậy, chúng tôi nói rằng việc thay đổi
145 có tác dụng phụ, tôi. e. , sự thay đổi ảnh hưởng đến các phần khác của chương trình một cách không chủ ý. Đây là một lý do tại sao một quy tắc vàng trong lập trình yêu cầu chúng ta hạn chế sử dụng các biến toàn cục càng nhiều càng tốt
2
3
4
5
6
7
8
9
10
Một giải pháp khác cho vấn đề cần hai tham số \[ v_0 \] có thể là giới thiệu hai hàm
v0 = 3 dy = diff[y, 1] A = 1; a = 0.1 dg = diff[g, 1.5]7, mỗi hàm có một tham số \[ v_0 \] riêng biệt
19
2
3
4
5
6
7
8
9
10
Bây giờ chúng ta cần khởi tạo
131 và
2
3
4
5
6
7
8
9
10
11
12
132 một lần, sau đó chúng ta có thể làm việc với
2
3
4
5
6
7
8
9
10
11
12
133 và
2
3
4
5
6
7
8
9
10
11
12
134. Tuy nhiên, nếu chúng ta cần 100 tham số \[ v_0 \] thì chúng ta cần 100 hàm. Điều này gây tẻ nhạt cho mã, dễ xảy ra lỗi, khó quản trị và đơn giản là một giải pháp thực sự tồi tệ cho một vấn đề lập trình
2
3
4
5
6
7
8
9
10
11
12
Vì vậy, có một biện pháp khắc phục tốt? . khái niệm lớp giải quyết tất cả các vấn đề được mô tả ở trên
Biểu diễn một hàm dưới dạng một lớp
Một lớp chứa một tập hợp các biến [dữ liệu] và một tập hợp các hàm, được tổ chức cùng nhau dưới dạng một đơn vị. Các biến có thể nhìn thấy trong tất cả các chức năng trong lớp. Tức là chúng ta có thể xem các biến là "toàn cục" trong các hàm này. Các đặc điểm này cũng áp dụng cho các mô-đun và các mô-đun có thể được sử dụng để đạt được nhiều lợi thế giống như các lớp mang lại [xem nhận xét trong phần ]. Tuy nhiên, các lớp về mặt kỹ thuật rất khác so với các mô-đun. Bạn cũng có thể tạo nhiều bản sao của một lớp, trong khi chỉ có thể có một bản sao của một mô-đun. Khi bạn thành thạo cả module và class, bạn sẽ thấy rõ sự giống và khác nhau. Bây giờ chúng ta tiếp tục với một ví dụ cụ thể về một lớp
Xét hàm \[ y[t; v_0]=v_0t - \frac{1}{2}gt^2 \]. Chúng ta có thể nói rằng \[ v_0 \] và \[ g \], được đại diện bởi các biến
145 và
2
3
4
5
6
7
8
9
10
190, cấu thành dữ liệu. Cần có một hàm Python, chẳng hạn như
2
3
4
5
6
7
8
9
10
137, để tính giá trị của \[ y[t;v_0] \] và hàm này phải có quyền truy cập vào dữ liệu
2
3
4
5
6
7
8
9
10
11
12
145 và
2
3
4
5
6
7
8
9
10
190, trong khi
2
3
4
5
6
7
8
9
10
class Music:20 là một đối số
@staticmethod
def play[]:
print["*playing music*"]
def stop[self]:
print["stop playing"]
Music.play[]
obj = Music[]
obj.stop[]
Sau đó, một lập trình viên có kinh nghiệm với các lớp sẽ đề xuất thu thập dữ liệu
145 và
2
3
4
5
6
7
8
9
10
190, và hàm
2
3
4
5
6
7
8
9
10
137, cùng nhau dưới dạng một lớp. Ngoài ra, một lớp thường có một chức năng khác, được gọi là hàm khởi tạo để khởi tạo dữ liệu. Hàm tạo luôn có tên là
2
3
4
5
6
7
8
9
10
11
12
class Music:24. Mỗi lớp phải có một tên, thường bắt đầu bằng chữ hoa, vì vậy chúng tôi chọn
@staticmethod
def play[]:
print["*playing music*"]
def stop[self]:
print["stop playing"]
Music.play[]
obj = Music[]
obj.stop[]
class Music:25 làm tên vì lớp đại diện cho một hàm toán học có tên \[ y \]. Hình vẽ phác thảo nội dung của lớp
@staticmethod
def play[]:
print["*playing music*"]
def stop[self]:
print["stop playing"]
Music.play[]
obj = Music[]
obj.stop[]
class Music:25 dưới dạng cái gọi là sơ đồ UML, ở đây được tạo ra với sự trợ giúp của chương trình class_Y_v1_UML. py. Sơ đồ UML có hai "hộp", một nơi liệt kê các chức năng và một nơi liệt kê các biến. Bước tiếp theo của chúng tôi là triển khai lớp này bằng Python
@staticmethod
def play[]:
print["*playing music*"]
def stop[self]:
print["stop playing"]
Music.play[]
obj = Music[]
obj.stop[]
Hình 1. Sơ đồ UML với chức năng và dữ liệu trong lớp đơn giản
class Music:25 để biểu diễn một hàm toán học \[ y[t;v_0] \]
@staticmethod
def play[]:
print["*playing music*"]
def stop[self]:
print["stop playing"]
Music.play[]
obj = Music[]
obj.stop[]
Thực hiện
Mã hoàn chỉnh cho lớp
class Music:25 của chúng tôi trông như sau trong Python
@staticmethod
def play[]:
print["*playing music*"]
def stop[self]:
print["stop playing"]
Music.play[]
obj = Music[]
obj.stop[]
13
2
3
4
5
6
7
8
9
10
11
12
Một điều khó hiểu đối với những người mới tham gia các lớp Python là tham số
class Music:29, có thể mất một số nỗ lực và thời gian để hiểu đầy đủ
@staticmethod
def play[]:
print["*playing music*"]
def stop[self]:
print["stop playing"]
Music.play[]
obj = Music[]
obj.stop[]
Sử dụng và mổ xẻ
Trước khi tìm hiểu ý nghĩa của từng dòng trong phần triển khai lớp, chúng ta bắt đầu bằng cách chỉ ra cách lớp có thể được sử dụng để tính toán các giá trị của hàm toán học \[ y[t;v_0] \]
Một lớp tạo một kiểu dữ liệu mới, ở đây có tên là
class Music:25, vì vậy khi chúng ta sử dụng lớp để tạo các đối tượng thì các đối tượng đó thuộc kiểu
@staticmethod
def play[]:
print["*playing music*"]
def stop[self]:
print["stop playing"]
Music.play[]
obj = Music[]
obj.stop[]
class Music:25. [Trên thực tế, tất cả các đối tượng Python tiêu chuẩn, chẳng hạn như danh sách, bộ dữ liệu, chuỗi, số dấu phẩy động, số nguyên, v.v. , là các lớp Python tích hợp, với các tên
@staticmethod
def play[]:
print["*playing music*"]
def stop[self]:
print["stop playing"]
Music.play[]
obj = Music[]
obj.stop[]
def y[t, v0]:
g = 9.81
return v0*t - 0.5*g*t**2
def g[x, a, A]:
return A*exp[-a*x]
52, def y[t, v0]:
g = 9.81
return v0*t - 0.5*g*t**2
def g[x, a, A]:
return A*exp[-a*x]
53, def y[t, v0]:
g = 9.81
return v0*t - 0.5*g*t**2
def g[x, a, A]:
return A*exp[-a*x]
54, def y[t, v0]:
g = 9.81
return v0*t - 0.5*g*t**2
def g[x, a, A]:
return A*exp[-a*x]
55, def y[t, v0]:
g = 9.81
return v0*t - 0.5*g*t**2
def g[x, a, A]:
return A*exp[-a*x]
56, v.v. ] Một đối tượng của lớp do người dùng định nghĩa [như class Music:25] thường được gọi là một thể hiện. Chúng ta cần một thể hiện như vậy để sử dụng dữ liệu trong lớp và gọi hàm
@staticmethod
def play[]:
print["*playing music*"]
def stop[self]:
print["stop playing"]
Music.play[]
obj = Music[]
obj.stop[]
def y[t, v0]:
g = 9.81
return v0*t - 0.5*g*t**2
def g[x, a, A]:
return A*exp[-a*x]
58. Câu lệnh sau xây dựng một thể hiện được liên kết với tên biến v0 = 3 dy = diff[y, 1] A = 1; a = 0.1 dg = diff[g, 1.5]7
Dường như, chúng ta gọi lớp
class Music:25 như thể nó là một hàm. Trên thực tế,
@staticmethod
def play[]:
print["*playing music*"]
def stop[self]:
print["stop playing"]
Music.play[]
obj = Music[]
obj.stop[]
def diff[f, x, h=1E-5]:
return [f[x+h] - f[x]]/h
01 được Python dịch tự động thành lệnh gọi hàm tạo class Music:24 trong lớp
@staticmethod
def play[]:
print["*playing music*"]
def stop[self]:
print["stop playing"]
Music.play[]
obj = Music[]
obj.stop[]
class Music:25. Các đối số trong cuộc gọi, ở đây chỉ có số
@staticmethod
def play[]:
print["*playing music*"]
def stop[self]:
print["stop playing"]
Music.play[]
obj = Music[]
obj.stop[]
def diff[f, x, h=1E-5]:
return [f[x+h] - f[x]]/h
04, luôn được chuyển thành đối số cho class Music:24 sau đối số
@staticmethod
def play[]:
print["*playing music*"]
def stop[self]:
print["stop playing"]
Music.play[]
obj = Music[]
obj.stop[]
class Music:29. Nghĩa là,
@staticmethod
def play[]:
print["*playing music*"]
def stop[self]:
print["stop playing"]
Music.play[]
obj = Music[]
obj.stop[]
145 nhận giá trị
2
3
4
5
6
7
8
9
10
def diff[f, x, h=1E-5]:
return [f[x+h] - f[x]]/h
04 và class Music:29 vừa bị loại bỏ trong cuộc gọi. Điều này có thể gây nhầm lẫn, nhưng có một quy tắc là đối số
@staticmethod
def play[]:
print["*playing music*"]
def stop[self]:
print["stop playing"]
Music.play[]
obj = Music[]
obj.stop[]
class Music:29 không bao giờ được sử dụng trong các lệnh gọi hàm trong lớp
@staticmethod
def play[]:
print["*playing music*"]
def stop[self]:
print["stop playing"]
Music.play[]
obj = Music[]
obj.stop[]
Với ví dụ
v0 = 3 dy = diff[y, 1] A = 1; a = 0.1 dg = diff[g, 1.5]7, chúng ta có thể tính giá trị \[ y[t=0. 1;v_0=3] \] bởi câu lệnh
Ở đây cũng vậy, đối số
class Music:29 bị loại bỏ trong lệnh gọi tới
@staticmethod
def play[]:
print["*playing music*"]
def stop[self]:
print["stop playing"]
Music.play[]
obj = Music[]
obj.stop[]
def y[t, v0]:
g = 9.81
return v0*t - 0.5*g*t**2
def g[x, a, A]:
return A*exp[-a*x]
58. Để truy cập các hàm và biến trong một lớp, chúng ta phải thêm tiền tố vào tên hàm và biến bằng tên của thể hiện và dấu chấm. hàm def y[t, v0]:
g = 9.81
return v0*t - 0.5*g*t**2
def g[x, a, A]:
return A*exp[-a*x]
58 đạt được là def diff[f, x, h=1E-5]:
return [f[x+h] - f[x]]/h
15 và các biến được đạt được là def diff[f, x, h=1E-5]:
return [f[x+h] - f[x]]/h
16 và def diff[f, x, h=1E-5]:
return [f[x+h] - f[x]]/h
17. Ví dụ, chúng ta có thể in ra giá trị của 145 trong ví dụ
2
3
4
5
6
7
8
9
10
v0 = 3 dy = diff[y, 1] A = 1; a = 0.1 dg = diff[g, 1.5]7 bằng cách viết
Đầu ra trong trường hợp này sẽ là
def diff[f, x, h=1E-5]:
return [f[x+h] - f[x]]/h
04Chúng tôi đã giới thiệu thuật ngữ "thể hiện" cho đối tượng của một lớp. Các hàm trong các lớp thường được gọi là các phương thức và các biến [dữ liệu] trong các lớp được gọi là các thuộc tính dữ liệu. Các phương thức còn được gọi là các thuộc tính của phương thức. Từ bây giờ chúng ta sẽ sử dụng thuật ngữ này. Trong lớp mẫu
class Music:25 của chúng ta, chúng ta có hai phương thức hoặc thuộc tính phương thức,
@staticmethod
def play[]:
print["*playing music*"]
def stop[self]:
print["stop playing"]
Music.play[]
obj = Music[]
obj.stop[]
class Music:24 và
@staticmethod
def play[]:
print["*playing music*"]
def stop[self]:
print["stop playing"]
Music.play[]
obj = Music[]
obj.stop[]
def y[t, v0]:
g = 9.81
return v0*t - 0.5*g*t**2
def g[x, a, A]:
return A*exp[-a*x]
58, hai thuộc tính dữ liệu, 145 và
2
3
4
5
6
7
8
9
10
190, và tổng cộng bốn thuộc tính [
2
3
4
5
6
7
8
9
10
class Music:24,
@staticmethod
def play[]:
print["*playing music*"]
def stop[self]:
print["stop playing"]
Music.play[]
obj = Music[]
obj.stop[]
def y[t, v0]:
g = 9.81
return v0*t - 0.5*g*t**2
def g[x, a, A]:
return A*exp[-a*x]
58, 145 và
2
3
4
5
6
7
8
9
10
190]. Tên của các thuộc tính có thể được chọn tự do, giống như tên của các hàm và biến Python thông thường. Tuy nhiên constructor phải có tên là
2
3
4
5
6
7
8
9
10
class Music:24, nếu không nó sẽ không tự động được gọi khi chúng ta tạo instance mới
@staticmethod
def play[]:
print["*playing music*"]
def stop[self]:
print["stop playing"]
Music.play[]
obj = Music[]
obj.stop[]
Bạn có thể làm bất cứ điều gì bạn muốn trong bất kỳ phương thức nào, nhưng quy ước chung là sử dụng hàm tạo để khởi tạo các biến trong lớp
Gia hạn lớp học
Chúng ta có thể có bao nhiêu thuộc tính tùy thích trong một lớp, vì vậy hãy thêm một phương thức mới vào lớp
class Music:25. Phương thức này được gọi là
@staticmethod
def play[]:
print["*playing music*"]
def stop[self]:
print["stop playing"]
Music.play[]
obj = Music[]
obj.stop[]
def diff[f, x, h=1E-5]:
return [f[x+h] - f[x]]/h
32 và in ra một chuỗi chứa công thức của hàm toán học \[ y \]. Sau công thức này, chúng tôi cung cấp giá trị của \[ v_0 \]. Chuỗi sau đó có thể được xây dựng nhưclass Music:2
@staticmethod
def play[]:
print["*playing music*"]
def stop[self]:
print["stop playing"]
Music.play[]
obj = Music[]
obj.stop[]
trong đó
class Music:29 là một thể hiện của lớp
@staticmethod
def play[]:
print["*playing music*"]
def stop[self]:
print["stop playing"]
Music.play[]
obj = Music[]
obj.stop[]
class Music:25. Cuộc gọi của
@staticmethod
def play[]:
print["*playing music*"]
def stop[self]:
print["stop playing"]
Music.play[]
obj = Music[]
obj.stop[]
def diff[f, x, h=1E-5]:
return [f[x+h] - f[x]]/h
32 không cần bất kỳ đối số nàophải đủ để tạo, trả về và in chuỗi. Tuy nhiên, ngay cả khi phương thức
def diff[f, x, h=1E-5]:
return [f[x+h] - f[x]]/h
32 không cần bất kỳ đối số nào, thì nó phải có đối số class Music:29, đối số này bị bỏ qua trong lệnh gọi nhưng cần thiết bên trong phương thức để truy cập các thuộc tính. Do đó, việc thực hiện phương pháp
@staticmethod
def play[]:
print["*playing music*"]
def stop[self]:
print["stop playing"]
Music.play[]
obj = Music[]
obj.stop[]
def y[t, v0]:
g = 9.81
return v0*t - 0.5*g*t**2
def g[x, a, A]:
return A*exp[-a*x]
5Cho đầy đủ, bây giờ cả lớp đọc
def diff[f, x, h=1E-5]:
return [f[x+h] - f[x]]/h
0Ví dụ về sử dụng có thể là
def diff[f, x, h=1E-5]:
return [f[x+h] - f[x]]/h
1với đầu ra
def diff[f, x, h=1E-5]:
return [f[x+h] - f[x]]/h
2Hãy cẩn thận với thụt đầu dòng trong lập trình lớp. Một sai lầm phổ biến của những người mới bắt đầu xây dựng lớp là đặt mã áp dụng lớp ở cùng một khoảng thụt đầu dòng như các phương thức của lớp. điều này là bất hợp pháp. Chỉ các định nghĩa và gán phương thức cho cái gọi là thuộc tính dữ liệu tĩnh [phần ] mới có thể xuất hiện trong khối thụt vào bên dưới tiêu đề
def diff[f, x, h=1E-5]:
return [f[x+h] - f[x]]/h
38. Việc gán thuộc tính dữ liệu thông thường phải được thực hiện bên trong các phương thức. Chương trình chính sử dụng lớp phải xuất hiện với cùng thụt lề như dòng tiêu đề def diff[f, x, h=1E-5]:
return [f[x+h] - f[x]]/h
38Sử dụng các phương thức như các hàm thông thường
Chúng tôi có thể tạo một số hàm \[ y \] với các giá trị khác nhau của \[ v_0 \]
def diff[f, x, h=1E-5]:
return [f[x+h] - f[x]]/h
3Chúng ta có thể coi
def diff[f, x, h=1E-5]:
return [f[x+h] - f[x]]/h
40, def diff[f, x, h=1E-5]:
return [f[x+h] - f[x]]/h
41 và def diff[f, x, h=1E-5]:
return [f[x+h] - f[x]]/h
42 là các hàm Python thông thường của class Music:20, sau đó chuyển chúng cho bất kỳ hàm Python nào mong đợi hàm một biến. Đặc biệt, chúng ta có thể gửi các hàm tới hàm
@staticmethod
def play[]:
print["*playing music*"]
def stop[self]:
print["stop playing"]
Music.play[]
obj = Music[]
obj.stop[]
def diff[f, x, h=1E-5]:
return [f[x+h] - f[x]]/h
44 từ phầndef diff[f, x, h=1E-5]:
return [f[x+h] - f[x]]/h
4Bên trong hàm
def diff[f, x, h=1E-5]:
return [f[x+h] - f[x]]/h
44, đối số v0 = 3 dy = diff[y, 1] A = 1; a = 0.1 dg = diff[g, 1.5]2 hiện hoạt động như một hàm của một biến tự động mang theo hai biến
145 và
2
3
4
5
6
7
8
9
10
190. Khi
2
3
4
5
6
7
8
9
10
v0 = 3 dy = diff[y, 1] A = 1; a = 0.1 dg = diff[g, 1.5]2 đề cập đến [e. g. ]
def diff[f, x, h=1E-5]:
return [f[x+h] - f[x]]/h
42, Python thực sự biết rằng def diff[f, x, h=1E-5]:
return [f[x+h] - f[x]]/h
51 có nghĩa là def diff[f, x, h=1E-5]:
return [f[x+h] - f[x]]/h
52, và bên trong phương thức def diff[f, x, h=1E-5]:
return [f[x+h] - f[x]]/h
42, class Music:29 là
@staticmethod
def play[]:
print["*playing music*"]
def stop[self]:
print["stop playing"]
Music.play[]
obj = Music[]
obj.stop[]
def diff[f, x, h=1E-5]:
return [f[x+h] - f[x]]/h
55, và chúng ta có quyền truy cập vào def diff[f, x, h=1E-5]:
return [f[x+h] - f[x]]/h
56 và def diff[f, x, h=1E-5]:
return [f[x+h] - f[x]]/h
57Lớp học kiểu mới so với lớp học cổ điển
Khi sử dụng Python phiên bản 2 và viết một lớp như
chúng tôi nhận được những gì được gọi là một lớp kiểu cũ hoặc cổ điển. Việc triển khai sửa đổi các lớp trong Python đã có trong phiên bản 2. 2 với các lớp học kiểu mới. Đặc điểm kỹ thuật của một lớp kiểu mới yêu cầu
def diff[f, x, h=1E-5]:
return [f[x+h] - f[x]]/h
58 sau tên lớpCác lớp kiểu mới có nhiều chức năng hơn và nói chung nên làm việc với các lớp kiểu mới. Do đó, từ bây giờ chúng ta sẽ viết
def diff[f, x, h=1E-5]:
return [f[x+h] - f[x]]/h
59 thay vì chỉ viết def diff[f, x, h=1E-5]:
return [f[x+h] - f[x]]/h
60. Trong Python 3, tất cả các lớp đều là kiểu mới cho dù chúng ta viết def diff[f, x, h=1E-5]:
return [f[x+h] - f[x]]/h
60 hay def diff[f, x, h=1E-5]:
return [f[x+h] - f[x]]/h
59chuỗi tài liệu
Một hàm có thể có một chuỗi tài liệu ngay sau định nghĩa hàm, xem phần ref{sec. căn bản. chuỗi tài liệu}. Mục đích của chuỗi tài liệu là để giải thích mục đích của hàm và, ví dụ, đối số và giá trị trả về là gì. Một lớp cũng có thể có một chuỗi tài liệu, nó chỉ là chuỗi đầu tiên xuất hiện ngay sau dòng tiêu đề
def diff[f, x, h=1E-5]:
return [f[x+h] - f[x]]/h
38. Quy ước là đặt chuỗi tài liệu trong ba dấu ngoặc kép def diff[f, x, h=1E-5]:
return [f[x+h] - f[x]]/h
64def diff[f, x, h=1E-5]:
return [f[x+h] - f[x]]/h
5Thông tin toàn diện hơn có thể bao gồm các phương pháp và cách lớp được sử dụng trong phiên tương tác
def diff[f, x, h=1E-5]:
return [f[x+h] - f[x]]/h
6biến tự
Bây giờ chúng ta sẽ giải thích thêm về tham số
class Music:29 và cách hoạt động của các phương thức lớp. Bên trong hàm tạo
@staticmethod
def play[]:
print["*playing music*"]
def stop[self]:
print["stop playing"]
Music.play[]
obj = Music[]
obj.stop[]
class Music:24, đối số
@staticmethod
def play[]:
print["*playing music*"]
def stop[self]:
print["stop playing"]
Music.play[]
obj = Music[]
obj.stop[]
class Music:29 là một biến chứa thể hiện mới sẽ được tạo. Khi chúng ta viết
@staticmethod
def play[]:
print["*playing music*"]
def stop[self]:
print["stop playing"]
Music.play[]
obj = Music[]
obj.stop[]
chúng tôi xác định hai thuộc tính dữ liệu mới trong trường hợp này. Tham số
class Music:29 được vô hình trả về mã gọi. Chúng ta có thể tưởng tượng rằng Python dịch cú pháp
@staticmethod
def play[]:
print["*playing music*"]
def stop[self]:
print["stop playing"]
Music.play[]
obj = Music[]
obj.stop[]
def diff[f, x, h=1E-5]:
return [f[x+h] - f[x]]/h
69 thành một cuộc gọi được viết làBây giờ,
class Music:29 trở thành thể hiện mới của
@staticmethod
def play[]:
print["*playing music*"]
def stop[self]:
print["stop playing"]
Music.play[]
obj = Music[]
obj.stop[]
v0 = 3 dy = diff[y, 1] A = 1; a = 0.1 dg = diff[g, 1.5]7 mà chúng tôi muốn tạo, vì vậy khi chúng tôi thực hiện
def diff[f, x, h=1E-5]:
return [f[x+h] - f[x]]/h
72 trong hàm tạo, chúng tôi thực sự gán 145 cho
2
3
4
5
6
7
8
9
10
def diff[f, x, h=1E-5]:
return [f[x+h] - f[x]]/h
16. Tiền tố với def diff[f, x, h=1E-5]:
return [f[x+h] - f[x]]/h
75 minh họa cách tiếp cận một phương thức lớp với cú pháp tương tự như cách tiếp cận một hàm trong mô-đun [giống như def diff[f, x, h=1E-5]:
return [f[x+h] - f[x]]/h
76]. Nếu chúng ta đặt tiền tố bằng def diff[f, x, h=1E-5]:
return [f[x+h] - f[x]]/h
75, thì chúng ta cần cung cấp rõ ràng một thực thể cho đối số class Music:29, chẳng hạn như
@staticmethod
def play[]:
print["*playing music*"]
def stop[self]:
print["stop playing"]
Music.play[]
obj = Music[]
obj.stop[]
v0 = 3 dy = diff[y, 1] A = 1; a = 0.1 dg = diff[g, 1.5]7 trong dòng mã ở trên, nhưng nếu chúng ta thêm tiền tố bằng
def diff[f, x, h=1E-5]:
return [f[x+h] - f[x]]/h
80 [tên thực thể] thì đối số class Music:29 sẽ bị loại bỏ trong cú pháp và Python sẽ . Đây là "tiền tố tên đối tượng" mà chúng ta sẽ sử dụng khi tính toán với các lớp. [
@staticmethod
def play[]:
print["*playing music*"]
def stop[self]:
print["stop playing"]
Music.play[]
obj = Music[]
obj.stop[]
def diff[f, x, h=1E-5]:
return [f[x+h] - f[x]]/h
84 sẽ không hoạt động vì v0 = 3 dy = diff[y, 1] A = 1; a = 0.1 dg = diff[g, 1.5]7 không được xác định và được coi là một đối tượng
class Music:25. Tuy nhiên, nếu trước tiên chúng tôi tạo
@staticmethod
def play[]:
print["*playing music*"]
def stop[self]:
print["stop playing"]
Music.play[]
obj = Music[]
obj.stop[]
def diff[f, x, h=1E-5]:
return [f[x+h] - f[x]]/h
87 và sau đó gọi def diff[f, x, h=1E-5]:
return [f[x+h] - f[x]]/h
84, cú pháp sẽ hoạt động và def diff[f, x, h=1E-5]:
return [f[x+h] - f[x]]/h
16 là def diff[f, x, h=1E-5]:
return [f[x+h] - f[x]]/h
04 sau cuộc gọi. ]Chúng ta hãy xem một cuộc gọi đến phương thức
def y[t, v0]:
g = 9.81
return v0*t - 0.5*g*t**2
def g[x, a, A]:
return A*exp[-a*x]
58 để xem cách sử dụng tương tự đối số class Music:29. Khi chúng ta viết
@staticmethod
def play[]:
print["*playing music*"]
def stop[self]:
print["stop playing"]
Music.play[]
obj = Music[]
obj.stop[]
Python dịch điều này thành một cuộc gọi
sao cho đối số
class Music:29 trong phương thức
@staticmethod
def play[]:
print["*playing music*"]
def stop[self]:
print["stop playing"]
Music.play[]
obj = Music[]
obj.stop[]
def y[t, v0]:
g = 9.81
return v0*t - 0.5*g*t**2
def g[x, a, A]:
return A*exp[-a*x]
58 trở thành đối tượng v0 = 3 dy = diff[y, 1] A = 1; a = 0.1 dg = diff[g, 1.5]7. Trong biểu thức bên trong phương thức
def y[t, v0]:
g = 9.81
return v0*t - 0.5*g*t**2
def g[x, a, A]:
return A*exp[-a*x]
58,def diff[f, x, h=1E-5]:
return [f[x+h] - f[x]]/h
7class Music:29 là
@staticmethod
def play[]:
print["*playing music*"]
def stop[self]:
print["stop playing"]
Music.play[]
obj = Music[]
obj.stop[]
v0 = 3 dy = diff[y, 1] A = 1; a = 0.1 dg = diff[g, 1.5]7 vì vậy điều này giống như
Việc sử dụng
class Music:29 có thể trở nên rõ ràng hơn khi chúng ta có nhiều thể hiện lớp. Chúng ta có thể tạo một lớp chỉ có một tham số để chúng ta có thể dễ dàng xác định một thể hiện của lớp bằng cách in giá trị của tham số này. Ngoài ra, mọi đối tượng Python
@staticmethod
def play[]:
print["*playing music*"]
def stop[self]:
print["stop playing"]
Music.play[]
obj = Music[]
obj.stop[]
class Music:000 đều có một mã định danh duy nhất do
@staticmethod
def play[]:
print["*playing music*"]
Music.play[]
class Music:001 thu được mà chúng ta cũng có thể in ra để theo dõi xem
@staticmethod
def play[]:
print["*playing music*"]
Music.play[]
class Music:29 là gì
@staticmethod
def play[]:
print["*playing music*"]
def stop[self]:
print["stop playing"]
Music.play[]
obj = Music[]
obj.stop[]
def diff[f, x, h=1E-5]:
return [f[x+h] - f[x]]/h
8Đây là một phiên tương tác với lớp học này
def diff[f, x, h=1E-5]:
return [f[x+h] - f[x]]/h
9Chúng ta thấy rõ rằng
class Music:29 bên trong hàm tạo là cùng một đối tượng như
@staticmethod
def play[]:
print["*playing music*"]
def stop[self]:
print["stop playing"]
Music.play[]
obj = Music[]
obj.stop[]
class Music:004 mà chúng ta muốn tạo bằng cách gọi hàm tạo
@staticmethod
def play[]:
print["*playing music*"]
Music.play[]
Một đối tượng thứ hai được thực hiện bởi
class Music:00
@staticmethod
def play[]:
print["*playing music*"]
Music.play[]
Bây giờ chúng ta có thể gọi phương thức
def y[t, v0]:
g = 9.81
return v0*t - 0.5*g*t**2
def g[x, a, A]:
return A*exp[-a*x]
58 bằng cú pháp tiêu chuẩn class Music:006 và cú pháp "mô phạm hơn"
@staticmethod
def play[]:
print["*playing music*"]
Music.play[]
class Music:007. Sử dụng cả
@staticmethod
def play[]:
print["*playing music*"]
Music.play[]
class Music:004 và
@staticmethod
def play[]:
print["*playing music*"]
Music.play[]
class Music:009 minh họa cách
@staticmethod
def play[]:
print["*playing music*"]
Music.play[]
class Music:29 nhận các giá trị khác nhau, trong khi chúng ta có thể xem phương thức
@staticmethod
def play[]:
print["*playing music*"]
def stop[self]:
print["stop playing"]
Music.play[]
obj = Music[]
obj.stop[]
class Music:011 như một hàm duy nhất chỉ hoạt động trên các đối tượng
@staticmethod
def play[]:
print["*playing music*"]
Music.play[]
class Music:29 và
@staticmethod
def play[]:
print["*playing music*"]
def stop[self]:
print["stop playing"]
Music.play[]
obj = Music[]
obj.stop[]
class Music:013 khác nhau
@staticmethod
def play[]:
print["*playing music*"]
Music.play[]
class Music:01
@staticmethod
def play[]:
print["*playing music*"]
Music.play[]
Hy vọng rằng những minh họa này giúp giải thích rằng
class Music:29 chỉ là trường hợp được sử dụng trong tiền tố gọi phương thức, ở đây là
@staticmethod
def play[]:
print["*playing music*"]
def stop[self]:
print["stop playing"]
Music.play[]
obj = Music[]
obj.stop[]
class Music:004 hoặc
@staticmethod
def play[]:
print["*playing music*"]
Music.play[]
class Music:009. Nếu không, kiên nhẫn làm việc với lập trình lớp trong Python theo thời gian sẽ tiết lộ sự hiểu biết về
@staticmethod
def play[]:
print["*playing music*"]
Music.play[]
class Music:29 thực sự là gì
@staticmethod
def play[]:
print["*playing music*"]
def stop[self]:
print["stop playing"]
Music.play[]
obj = Music[]
obj.stop[]
Các quy tắc liên quan đến
class Music:29
@staticmethod
def play[]:
print["*playing music*"]
def stop[self]:
print["stop playing"]
Music.play[]
obj = Music[]
obj.stop[]
- Bất kỳ phương thức lớp nào cũng phải có
class Music:
29 làm đối số đầu tiên. [Tên có thể là bất kỳ tên biến hợp lệ nào, nhưng tên
@staticmethod
def play[]:
print["*playing music*"]
def stop[self]:
print["stop playing"]
Music.play[]
obj = Music[]
obj.stop[]class Music:
29 là một quy ước được thiết lập rộng rãi trong Python. ]
@staticmethod
def play[]:
print["*playing music*"]
def stop[self]:
print["stop playing"]
Music.play[]
obj = Music[]
obj.stop[] class Music:
29 đại diện cho một thể hiện [tùy ý] của lớp
@staticmethod
def play[]:
print["*playing music*"]
def stop[self]:
print["stop playing"]
Music.play[]
obj = Music[]
obj.stop[]- Để truy cập bất kỳ thuộc tính lớp nào bên trong các phương thức lớp, chúng ta phải đặt tiền tố bằng
class Music:
29, như trong
@staticmethod
def play[]:
print["*playing music*"]
def stop[self]:
print["stop playing"]
Music.play[]
obj = Music[]
obj.stop[]class Music:
023, trong đó
@staticmethod
def play[]:
print["*playing music*"]
Music.play[]class Music:
024 là tên của thuộc tính
@staticmethod
def play[]:
print["*playing music*"]
Music.play[] class Music:
29 bị loại bỏ dưới dạng đối số trong các cuộc gọi đến các phương thức lớp
@staticmethod
def play[]:
print["*playing music*"]
def stop[self]:
print["stop playing"]
Music.play[]
obj = Music[]
obj.stop[]
Một ví dụ lớp chức năng khác
Chúng ta hãy áp dụng ý tưởng từ lớp
class Music:25 cho hàm $$ \begin{equation*} v[r] = \left[{\beta\over 2\mu_0}\right]^{{1/ n}} {n . Chúng ta có thể viết hàm này là \[ v[r; \beta,\mu_0,n,R] \] để biểu thị rõ ràng rằng có một biến độc lập chính [\[ r \]] và bốn tham số vật lý \[ \beta \ . Lớp này thường giữ các tham số vật lý dưới dạng biến và cung cấp phương thức
@staticmethod
def play[]:
print["*playing music*"]
def stop[self]:
print["stop playing"]
Music.play[]
obj = Music[]
obj.stop[]
class Music:027 để tính toán hàm \[ v \]
@staticmethod
def play[]:
print["*playing music*"]
Music.play[]
class Music:02
@staticmethod
def play[]:
print["*playing music*"]
Music.play[]
Dường như có một điều mới ở đây là chúng ta khởi tạo một số biến trên cùng một dòng
class Music:03
@staticmethod
def play[]:
print["*playing music*"]
Music.play[]
Danh sách các biến được phân tách bằng dấu phẩy ở phía bên tay phải tạo thành một bộ vì vậy phép gán này chỉ là một cấu trúc hợp lệ trong đó một tập hợp các biến ở phía bên trái được đặt bằng một danh sách hoặc bộ ở phía bên tay phải . Một mã nhiều dòng tương đương là
class Music:04
@staticmethod
def play[]:
print["*playing music*"]
Music.play[]
Trong phương pháp
def y[t, v0]:
g = 9.81
return v0*t - 0.5*g*t**2
def g[x, a, A]:
return A*exp[-a*x]
58, thuận tiện là tránh tiền tố class Music:029 trong các công thức toán học và thay vào đó giới thiệu các tên viết tắt địa phương
@staticmethod
def play[]:
print["*playing music*"]
Music.play[]
class Music:030,
@staticmethod
def play[]:
print["*playing music*"]
Music.play[]
class Music:031,
@staticmethod
def play[]:
print["*playing music*"]
Music.play[]
class Music:032 và
@staticmethod
def play[]:
print["*playing music*"]
Music.play[]
class Music:033. Nói chung, đây là một ý tưởng hay, vì nó giúp dễ dàng đọc cách thực hiện công thức và kiểm tra tính đúng đắn của nó
@staticmethod
def play[]:
print["*playing music*"]
Music.play[]
Nhận xét
Một giải pháp khác cho vấn đề gửi các hàm có tham số đến một hàm thư viện chung, chẳng hạn như
v0 = 3 dy = diff[y, 1] A = 1; a = 0.1 dg = diff[g, 1.5]1, được cung cấp trong tài liệu Số biến đối số của hàm trong Python. Biện pháp khắc phục là chuyển các tham số dưới dạng đối số "thông qua" hàm
v0 = 3 dy = diff[y, 1] A = 1; a = 0.1 dg = diff[g, 1.5]1. Điều này có thể được thực hiện một cách tổng quát như được giải thích trong phụ lục đó
Triển khai lớp chức năng thay thế
Để minh họa thêm về lập trình lớp, bây giờ chúng ta sẽ nhận ra lớp
class Music:25 từ phần này theo một cách khác. Bạn có thể coi phần này là phần nâng cao và bỏ qua nó, nhưng đối với một số độc giả, tài liệu này có thể cải thiện sự hiểu biết về lớp
@staticmethod
def play[]:
print["*playing music*"]
def stop[self]:
print["stop playing"]
Music.play[]
obj = Music[]
obj.stop[]
class Music:25 và cung cấp một số hiểu biết sâu sắc về lập trình lớp nói chung
@staticmethod
def play[]:
print["*playing music*"]
def stop[self]:
print["stop playing"]
Music.play[]
obj = Music[]
obj.stop[]
Một thói quen tốt là luôn có một hàm tạo trong một lớp và khởi tạo các thuộc tính dữ liệu trong lớp ở đây, nhưng đây không phải là một yêu cầu. Hãy để chúng tôi loại bỏ hàm tạo và biến
145 thành một đối số tùy chọn cho phương thức
2
3
4
5
6
7
8
9
10
def y[t, v0]:
g = 9.81
return v0*t - 0.5*g*t**2
def g[x, a, A]:
return A*exp[-a*x]
58. Nếu người dùng không cung cấp 145 trong cuộc gọi tới
2
3
4
5
6
7
8
9
10
def y[t, v0]:
g = 9.81
return v0*t - 0.5*g*t**2
def g[x, a, A]:
return A*exp[-a*x]
58, chúng tôi sẽ sử dụng giá trị 145 phải được cung cấp trong cuộc gọi trước đó và được lưu trữ dưới dạng thuộc tính dữ liệu
2
3
4
5
6
7
8
9
10
class Music:043. Chúng tôi có thể nhận biết liệu người dùng có cung cấp đối số
@staticmethod
def play[]:
print["*playing music*"]
Music.play[]
145 hay không bằng cách sử dụng
2
3
4
5
6
7
8
9
10
class Music:045 làm giá trị mặc định cho đối số từ khóa và sau đó kiểm tra xem có phải
@staticmethod
def play[]:
print["*playing music*"]
Music.play[]
class Music:046 không
@staticmethod
def play[]:
print["*playing music*"]
Music.play[]
Triển khai thay thế của chúng tôi về lớp
class Music:25, có tên là
@staticmethod
def play[]:
print["*playing music*"]
def stop[self]:
print["stop playing"]
Music.play[]
obj = Music[]
obj.stop[]
class Music:048, hiện đã đọc
@staticmethod
def play[]:
print["*playing music*"]
Music.play[]
class Music:05
@staticmethod
def play[]:
print["*playing music*"]
Music.play[]
Lần này, lớp chỉ có một phương thức và một thuộc tính dữ liệu vì chúng ta đã bỏ qua hàm tạo và để
190 là một biến cục bộ trong phương thức
2
3
4
5
6
7
8
9
10
def y[t, v0]:
g = 9.81
return v0*t - 0.5*g*t**2
def g[x, a, A]:
return A*exp[-a*x]
58Nhưng nếu không có hàm tạo, thì một thể hiện được tạo như thế nào? . Điều này cho phép chúng tôi viết
để làm một ví dụ
v0 = 3 dy = diff[y, 1] A = 1; a = 0.1 dg = diff[g, 1.5]7. Vì không có gì xảy ra trong hàm tạo trống được tạo tự động, nên
v0 = 3 dy = diff[y, 1] A = 1; a = 0.1 dg = diff[g, 1.5]7 không có thuộc tính dữ liệu nào ở giai đoạn này. Viết
do đó dẫn đến ngoại lệ
class Music:06
@staticmethod
def play[]:
print["*playing music*"]
Music.play[]
Bằng cách gọi
chúng tôi tạo một thuộc tính
class Music:043 bên trong phương thức
@staticmethod
def play[]:
print["*playing music*"]
Music.play[]
def y[t, v0]:
g = 9.81
return v0*t - 0.5*g*t**2
def g[x, a, A]:
return A*exp[-a*x]
58. Nói chung, chúng ta có thể tạo bất kỳ thuộc tính class Music:024 nào trong bất kỳ phương thức nào bằng cách chỉ gán một giá trị cho
@staticmethod
def play[]:
print["*playing music*"]
Music.play[]
class Music:023. Bây giờ đang thử một
@staticmethod
def play[]:
print["*playing music*"]
Music.play[]
sẽ in
class Music:057. Trong một cuộc gọi mới,
@staticmethod
def play[]:
print["*playing music*"]
Music.play[]
giá trị
145 trước đó [
2
3
4
5
6
7
8
9
10
class Music:057] được sử dụng bên trong
@staticmethod
def play[]:
print["*playing music*"]
Music.play[]
def y[t, v0]:
g = 9.81
return v0*t - 0.5*g*t**2
def g[x, a, A]:
return A*exp[-a*x]
58 là class Music:043 trừ khi đối số
@staticmethod
def play[]:
print["*playing music*"]
Music.play[]
145 được chỉ định trong cuộc gọi
2
3
4
5
6
7
8
9
10
Việc triển khai trước đó không thể đánh lừa được nếu chúng tôi không khởi tạo được
145. Ví dụ, mã
2
3
4
5
6
7
8
9
10
sẽ chấm dứt trong phương pháp
def y[t, v0]:
g = 9.81
return v0*t - 0.5*g*t**2
def g[x, a, A]:
return A*exp[-a*x]
58 với ngoại lệclass Music:06
@staticmethod
def play[]:
print["*playing music*"]
Music.play[]
Như thường lệ, tốt hơn là thông báo cho người dùng bằng một thông báo nhiều thông tin hơn. Để kiểm tra xem chúng ta có thuộc tính
145 hay không, chúng ta có thể sử dụng hàm Python
2
3
4
5
6
7
8
9
10
class Music:066. Gọi
@staticmethod
def play[]:
print["*playing music*"]
Music.play[]
class Music:067 chỉ trả về
@staticmethod
def play[]:
print["*playing music*"]
Music.play[]
class Music:068 nếu thể hiện
@staticmethod
def play[]:
print["*playing music*"]
Music.play[]
class Music:29 có một thuộc tính có tên
@staticmethod
def play[]:
print["*playing music*"]
def stop[self]:
print["stop playing"]
Music.play[]
obj = Music[]
obj.stop[]
class Music:070. Một phương pháp
@staticmethod
def play[]:
print["*playing music*"]
Music.play[]
def y[t, v0]:
g = 9.81
return v0*t - 0.5*g*t**2
def g[x, a, A]:
return A*exp[-a*x]
58 được cải tiến hiện đọcclass Music:08
@staticmethod
def play[]:
print["*playing music*"]
Music.play[]
Ngoài ra, chúng ta có thể thử truy cập
class Music:043 trong một khối
@staticmethod
def play[]:
print["*playing music*"]
Music.play[]
class Music:073 và có thể đưa ra một ngoại lệ
@staticmethod
def play[]:
print["*playing music*"]
Music.play[]
class Music:074 [đây là điều mà Python đưa ra nếu không có đủ đối số cho một hàm hoặc phương thức]
@staticmethod
def play[]:
print["*playing music*"]
Music.play[]
class Music:09
@staticmethod
def play[]:
print["*playing music*"]
Music.play[]
Lưu ý rằng Python phát hiện một
class Music:075, nhưng theo quan điểm của người dùng, không có đủ tham số được cung cấp trong cuộc gọi nên một
@staticmethod
def play[]:
print["*playing music*"]
Music.play[]
class Music:074 sẽ phù hợp hơn để liên lạc lại với mã cuộc gọi
@staticmethod
def play[]:
print["*playing music*"]
Music.play[]
Chúng tôi nghĩ lớp
class Music:25 triển khai tốt hơn lớp
@staticmethod
def play[]:
print["*playing music*"]
def stop[self]:
print["stop playing"]
Music.play[]
obj = Music[]
obj.stop[]
class Music:048, vì lớp trước đơn giản hơn. Như đã đề cập, thói quen tốt là bao gồm một hàm tạo và đặt dữ liệu ở đây thay vì "ghi dữ liệu một cách nhanh chóng" như chúng ta cố gắng thực hiện trong lớp
@staticmethod
def play[]:
print["*playing music*"]
Music.play[]
class Music:048. Toàn bộ mục đích của lớp
@staticmethod
def play[]:
print["*playing music*"]
Music.play[]
class Music:048 chỉ là để chỉ ra rằng Python cung cấp tính linh hoạt cao đối với việc xác định các thuộc tính và không có yêu cầu nào đối với những gì một lớp phải chứa
@staticmethod
def play[]:
print["*playing music*"]
Music.play[]
Tạo các lớp không có cấu trúc lớp
Những người mới làm quen với khái niệm lớp học thường gặp khó khăn để hiểu khái niệm này là gì. Phần hiện tại cố gắng giải thích chi tiết hơn về cách chúng ta có thể giới thiệu các lớp mà không cần cấu trúc lớp bằng ngôn ngữ máy tính. Thông tin này có thể hoặc không thể làm tăng sự hiểu biết của bạn về các lớp học. Nếu không, lập trình với các lớp chắc chắn sẽ nâng cao hiểu biết của bạn theo thời gian, vì vậy không có lý do gì phải lo lắng. Trên thực tế, bạn có thể chuyển sang phần này một cách an toàn vì không có khái niệm quan trọng nào trong phần này mà các phần sau sẽ dựa vào
Một lớp chứa tập hợp các biến [dữ liệu] và tập hợp các phương thức [hàm]. Tập hợp các biến là duy nhất cho mỗi thể hiện của lớp. Nghĩa là, nếu chúng ta tạo 10 trường hợp, thì mỗi trường hợp có một tập biến riêng. Các biến này có thể được coi như một từ điển với các khóa bằng tên biến. Sau đó, mỗi phiên bản có từ điển riêng và chúng ta có thể xem đại khái phiên bản đó là từ điển này. [Thể hiện cũng có thể chứa các thuộc tính dữ liệu tĩnh [phần ], nhưng những thuộc tính này được xem là biến toàn cục trong bối cảnh hiện tại. ]
Mặt khác, các phương thức được chia sẻ giữa các thể hiện. Chúng ta có thể coi một phương thức trong một lớp là một hàm toàn cục tiêu chuẩn lấy một thể hiện ở dạng từ điển làm đối số đầu tiên. Sau đó, phương thức này có quyền truy cập vào các biến trong thể hiện [từ điển] được cung cấp trong cuộc gọi. Đối với lớp
class Music:25 từ phần và một thể hiện
@staticmethod
def play[]:
print["*playing music*"]
def stop[self]:
print["stop playing"]
Music.play[]
obj = Music[]
obj.stop[]
v0 = 3 dy = diff[y, 1] A = 1; a = 0.1 dg = diff[g, 1.5]7, các phương thức là các hàm thông thường với các tên và đối số sau
130
2
3
4
5
6
7
8
9
10
Lớp hoạt động như một không gian tên, nghĩa là tất cả các chức năng phải được đặt trước bởi tên không gian tên, ở đây
class Music:25. Hai lớp khác nhau, chẳng hạn như
@staticmethod
def play[]:
print["*playing music*"]
def stop[self]:
print["stop playing"]
Music.play[]
obj = Music[]
obj.stop[]
class Music:084 và
@staticmethod
def play[]:
print["*playing music*"]
Music.play[]
class Music:085, có thể có các hàm có cùng tên, chẳng hạn như
@staticmethod
def play[]:
print["*playing music*"]
Music.play[]
def y[t, v0]:
g = 9.81
return v0*t - 0.5*g*t**2
def g[x, a, A]:
return A*exp[-a*x]
58, nhưng khi các hàm def y[t, v0]:
g = 9.81
return v0*t - 0.5*g*t**2
def g[x, a, A]:
return A*exp[-a*x]
58 thuộc về các không gian tên khác nhau, tên của chúng class Music:088 và
@staticmethod
def play[]:
print["*playing music*"]
Music.play[]
class Music:089 trở nên khác biệt. Các mô-đun cũng là không gian tên cho các hàm và biến trong đó [nghĩ về
@staticmethod
def play[]:
print["*playing music*"]
Music.play[]
class Music:090,
@staticmethod
def play[]:
print["*playing music*"]
Music.play[]
class Music:091,
@staticmethod
def play[]:
print["*playing music*"]
Music.play[]
class Music:092]
@staticmethod
def play[]:
print["*playing music*"]
Music.play[]
Điều đặc biệt duy nhất với cấu trúc lớp trong Python là nó cho phép chúng ta sử dụng một cú pháp thay thế cho các lệnh gọi phương thức
Cú pháp này trùng với cú pháp truyền thống gọi các phương thức lớp và cung cấp đối số, như được tìm thấy trong các ngôn ngữ máy tính khác, chẳng hạn như Java, C#, C++, Simula và Smalltalk. Ký hiệu dấu chấm cũng được sử dụng để truy cập các biến trong một thể hiện sao cho chúng ta bên trong một phương thức có thể viết
class Music:043 thay vì
@staticmethod
def play[]:
print["*playing music*"]
Music.play[]
class Music:094 [
@staticmethod
def play[]:
print["*playing music*"]
Music.play[]
class Music:29 đề cập đến
@staticmethod
def play[]:
print["*playing music*"]
def stop[self]:
print["stop playing"]
Music.play[]
obj = Music[]
obj.stop[]
v0 = 3 dy = diff[y, 1] A = 1; a = 0.1 dg = diff[g, 1.5]7 thông qua lệnh gọi hàm]
Chúng ta có thể dễ dàng triển khai một phiên bản đơn giản của khái niệm lớp mà không cần xây dựng lớp bằng ngôn ngữ. Tất cả những gì chúng ta cần là một loại từ điển và các chức năng thông thường. Từ điển đóng vai trò là thể hiện và các phương thức là các hàm lấy từ điển này làm đối số đầu tiên sao cho hàm có quyền truy cập vào tất cả các biến trong thể hiện. Lớp
class Music:25 của chúng tôi bây giờ có thể được thực hiện như
@staticmethod
def play[]:
print["*playing music*"]
def stop[self]:
print["stop playing"]
Music.play[]
obj = Music[]
obj.stop[]
131
2
3
4
5
6
7
8
9
10
Hai chức năng được đặt trong một mô-đun có tên là
class Music:25. Việc sử dụng diễn ra như sau
@staticmethod
def play[]:
print["*playing music*"]
def stop[self]:
print["stop playing"]
Music.play[]
obj = Music[]
obj.stop[]
132
2
3
4
5
6
7
8
9
10
Chúng tôi không có hàm tạo vì việc khởi tạo các biến được thực hiện khi khai báo từ điển
v0 = 3 dy = diff[y, 1] A = 1; a = 0.1 dg = diff[g, 1.5]7, nhưng chúng tôi cũng có thể đưa một số hàm khởi tạo vào mô-đun
class Music:25
@staticmethod
def play[]:
print["*playing music*"]
def stop[self]:
print["stop playing"]
Music.play[]
obj = Music[]
obj.stop[]
133
2
3
4
5
6
7
8
9
10
Cách sử dụng bây giờ hơi khác một chút
134
2
3
4
5
6
7
8
9
10
Cách triển khai lớp này với sự trợ giúp của từ điển và một tập hợp các hàm thông thường thực sự tạo cơ sở cho việc triển khai lớp trong nhiều ngôn ngữ. Python và Perl thậm chí còn có cú pháp thể hiện kiểu triển khai này. Trên thực tế, mọi thể hiện của lớp trong Python đều có một thuộc tính từ điển
1301, chứa tất cả các biến trong thể hiện. Đây là bản demo chứng minh sự tồn tại của từ điển này trong lớp
2
3
4
5
6
7
8
9
10
class Music:25
@staticmethod
def play[]:
print["*playing music*"]
def stop[self]:
print["stop playing"]
Music.play[]
obj = Music[]
obj.stop[]
135
2
3
4
5
6
7
8
9
10
Để tóm tắt. Một lớp Python có thể được coi là một số biến được thu thập trong từ điển và một tập hợp các hàm trong đó từ điển này được cung cấp tự động làm đối số đầu tiên sao cho các hàm luôn có quyền truy cập đầy đủ vào các biến của lớp
nhận xét đầu tiên
Trong phần này, chúng tôi đã cung cấp chế độ xem các lớp từ quan điểm kỹ thuật. Những người khác có thể xem một lớp như một cách mô hình hóa thế giới về mặt dữ liệu và hoạt động trên dữ liệu. Tuy nhiên, trong các ngành khoa học sử dụng ngôn ngữ toán học, việc mô hình hóa thế giới thường được thực hiện bằng toán học và các cấu trúc toán học cung cấp sự hiểu biết về vấn đề và cấu trúc của các chương trình. Khi thích hợp, cấu trúc toán học có thể được ánh xạ thuận tiện vào các lớp trong chương trình để làm cho phần mềm đơn giản và linh hoạt hơn
nhận xét thứ hai
Khung nhìn của các lớp trong phần này bỏ qua các chủ đề rất quan trọng như kế thừa và liên kết động [được giải thích trong tài liệu Lập trình hướng đối tượng]. Để phần hiện tại đầy đủ hơn, do đó, chúng tôi mô tả ngắn gọn cách kết hợp từ điển và các hàm toàn cục của chúng tôi có thể xử lý tính kế thừa và liên kết động [nhưng điều này sẽ không có ý nghĩa trừ khi bạn biết tính kế thừa là gì]
Kế thừa dữ liệu có thể thu được bằng cách cho phép từ điển lớp con thực hiện cuộc gọi
1303 với từ điển lớp cha làm đối số. Theo cách này, tất cả dữ liệu trong lớp cha cũng có sẵn trong từ điển lớp con. Liên kết động của các phương thức phức tạp hơn, nhưng người ta có thể nghĩ đến việc kiểm tra xem phương thức đó có nằm trong mô-đun lớp con hay không [sử dụng
2
3
4
5
6
7
8
9
10
class Music:066] và nếu không, người ta tiếp tục kiểm tra các mô-đun siêu hạng cho đến khi tìm thấy phiên bản của phương thức
@staticmethod
def play[]:
print["*playing music*"]
Music.play[]
đóng cửa
Phần này tiếp nối cuộc thảo luận trong phần này và trình bày một cấu trúc nâng cao hơn có thể đóng vai trò thay thế cho cấu trúc lớp trong một số trường hợp
Ví dụ thúc đẩy của chúng tôi là chúng tôi muốn Python triển khai hàm toán học \[ y[t;v_0]=v_0t - \frac{1}{2}gt^2 \] có \[ t \] làm đối số duy nhất, . Hãy xem xét hàm sau, trả về một hàm
136
2
3
4
5
6
7
8
9
10
Thuộc tính đáng chú ý của hàm
v0 = 3 dy = diff[y, 1] A = 1; a = 0.1 dg = diff[g, 1.5]7 là nó ghi nhớ giá trị của
145 và
2
3
4
5
6
7
8
9
10
190, mặc dù các biến này không cục bộ đối với hàm mẹ
2
3
4
5
6
7
8
9
10
1308 và không cục bộ trong
2
3
4
5
6
7
8
9
10
v0 = 3 dy = diff[y, 1] A = 1; a = 0.1 dg = diff[g, 1.5]7. Cụ thể, chúng ta có thể chỉ định
145 làm đối số cho
2
3
4
5
6
7
8
9
10
1308
2
3
4
5
6
7
8
9
10
137
2
3
4
5
6
7
8
9
10
Ở đây,
1312 có quyền truy cập vào
2
3
4
5
6
7
8
9
10
1313 trong khi
2
3
4
5
6
7
8
9
10
1314 có quyền truy cập vào
2
3
4
5
6
7
8
9
10
1315
2
3
4
5
6
7
8
9
10
Hàm
1316 chúng ta xây dựng và trả về từ
2
3
4
5
6
7
8
9
10
1308 được gọi là một bao đóng và nó ghi nhớ giá trị của các biến cục bộ xung quanh trong hàm cha [tại thời điểm chúng ta tạo hàm
2
3
4
5
6
7
8
9
10
v0 = 3 dy = diff[y, 1] A = 1; a = 0.1 dg = diff[g, 1.5]7]. Bao đóng rất thuận tiện cho nhiều mục đích trong tính toán toán học. Các ví dụ xuất hiện trong phần. Bao đóng cũng là trung tâm trong phong cách lập trình được gọi là lập trình chức năng
Tạo nhiều bao đóng trong một chức năng. Ngay khi bạn có ý tưởng về một bao đóng, có thể bạn sẽ sử dụng nó rất nhiều vì đây là một cách thuận tiện để đóng gói một chức năng với dữ liệu bổ sung. Tuy nhiên, có một số cạm bẫy. Lớn nhất được minh họa bên dưới, nhưng đây được coi là tài liệu nâng cao
Hãy để chúng tôi tạo một loạt các hàm
1319 cho các giá trị khác nhau của tham số
2
3
4
5
6
7
8
9
10
145. Mỗi hàm chỉ trả về một bộ
2
3
4
5
6
7
8
9
10
1321 để chúng ta có thể dễ dàng thấy đối số và tham số là gì. Chúng tôi sử dụng
2
3
4
5
6
7
8
9
10
1322 để nhanh chóng xác định từng chức năng và chúng tôi đặt các chức năng trong danh sách
2
3
4
5
6
7
8
9
10
138
2
3
4
5
6
7
8
9
10
Bây giờ,
1323 là danh sách các hàm có một đối số. Gọi từng hàm và in các giá trị trả về
2
3
4
5
6
7
8
9
10
145 và
2
3
4
5
6
7
8
9
10
class Music:20 sẽ cho
@staticmethod
def play[]:
print["*playing music*"]
def stop[self]:
print["stop playing"]
Music.play[]
obj = Music[]
obj.stop[]
139
2
3
4
5
6
7
8
9
10
Như chúng ta thấy, tất cả các chức năng có
1326, i. e. , họ đã lưu trữ giá trị gần đây nhất của
2
3
4
5
6
7
8
9
10
145 trước khi trả về. Đây không phải là những gì chúng tôi muốn
2
3
4
5
6
7
8
9
10
Mẹo nhỏ là để
145 làm đối số từ khóa trong mỗi hàm, vì giá trị của đối số từ khóa bị cố định tại thời điểm hàm được xác định
2
3
4
5
6
7
8
9
10