Bạn có thể xác định một chức năng bên ngoài một lớp và sau đó thêm nó. Tuy nhiên, có một sự khác biệt tinh tế trong việc gán hàm cho lớp hoặc cho đối tượng thể hiện. Đây là một ví dụ:
class MyClass1[object]:
def __init__[self, bar]:
self.foo = 'up'
MyClass1.foobar = bar
class MyClass2[object]:
def __init__[self, bar]:
self.foo = 'up'
self.foobar = bar
def bar[self]:
return "What's " + self.foo
Trước tiên hãy nhìn vào những gì đang xảy ra trong
In [2]: x = MyClass1[bar]
In [3]: x.foobar
Out[3]:
In [4]: x.foobar[]
Out[4]: "What's up"
In [2]: x = MyClass1[bar]
In [3]: x.foobar
Out[3]:
In [4]: x.foobar[]
Out[4]: "What's up"
In [2]: x = MyClass1[bar]
In [3]: x.foobar
Out[3]:
In [4]: x.foobar[]
Out[4]: "What's up"
Làm thế nào điều này khác với
In [2]: x = MyClass1[bar]
In [3]: x.foobar
Out[3]:
In [4]: x.foobar[]
Out[4]: "What's up"
In [2]: x = MyClass1[bar]
In [3]: x.foobar
Out[3]:
In [4]: x.foobar[]
Out[4]: "What's up"
In [2]: x = MyClass1[bar]
In [3]: x.foobar
Out[3]:
In [4]: x.foobar[]
Out[4]: "What's up"
In [5]: y = MyClass2[bar]
In [6]: y.foobar
Out[6]:
In [7]: y.foobar[]
---------------------------------------------------------------------------
TypeError Traceback [most recent call last]
in []
----> 1 y.foobar[]
TypeError: bar[] takes exactly 1 argument [0 given]
In [8]: y.foobar[y]
Out[8]: "What's up"
Mặc dù tôi không chắc đây có phải là thực hành tốt để làm theo cách này không ...
[toc]
Tuyên bố vấn đề: Làm thế nào để xác định một phương pháp bên ngoài định nghĩa lớp trong Python? How to define a method outside of class definition in Python?
Example:
# Given Class
class Demo:
# Given Method
def foo[self]:
x = 10
return xChúng ta có thể tạo
In [2]: x = MyClass1[bar]
In [3]: x.foobar
Out[3]:
In [4]: x.foobar[]
Out[4]: "What's up"
Giới thiệu
Chúng ta đều biết Python là ngôn ngữ lập trình hướng đối tượng và trong Python, mọi thứ đều là một đối tượng bao gồm các thuộc tính và phương thức. Trong Python, lớp giống như một hàm tạo đối tượng để tạo các đối tượng. Do đó, các biến có thể được xác định bên trong lớp, bên ngoài lớp và bên trong các phương thức trong Python. Các biến được xác định bên ngoài lớp có thể được truy cập bằng bất kỳ phương thức hoặc lớp nào chỉ bằng cách viết tên biến. Vì vậy, trong bài viết này, chúng ta sẽ học cách xác định một phương pháp bên ngoài định nghĩa lớp.
Phương pháp trong Python là gì?
Vì Python là ngôn ngữ lập trình hướng đối tượng, nó có các đối tượng bao gồm các thuộc tính. Các thuộc tính xác định các thuộc tính của các đối tượng này và hành vi được xác định bằng các phương thức. Các phương thức là các đoạn mã có thể tái sử dụng được gọi tại bất kỳ điểm nào trong chương trình và được xác định bên trong lớp. Mọi phương pháp đều được liên kết với lớp và có thể được gọi trên các trường hợp của lớp đó.
Ví dụ: chúng ta có thể xem xét một lớp có tên ‘
In [2]: x = MyClass1[bar]
In [3]: x.foobar
Out[3]:
In [4]: x.foobar[]
Out[4]: "What's up"
In [2]: x = MyClass1[bar]
In [3]: x.foobar
Out[3]:
In [4]: x.foobar[]
Out[4]: "What's up"
In [5]: y = MyClass2[bar]
In [6]: y.foobar
Out[6]:
In [7]: y.foobar[]
---------------------------------------------------------------------------
TypeError Traceback [most recent call last]
in []
----> 1 y.foobar[]
TypeError: bar[] takes exactly 1 argument [0 given]
In [8]: y.foobar[y]
Out[8]: "What's up"
In [5]: y = MyClass2[bar]
In [6]: y.foobar
Out[6]:
In [7]: y.foobar[]
---------------------------------------------------------------------------
TypeError Traceback [most recent call last]
in []
----> 1 y.foobar[]
TypeError: bar[] takes exactly 1 argument [0 given]
In [8]: y.foobar[y]
Out[8]: "What's up"
In [5]: y = MyClass2[bar]
In [6]: y.foobar
Out[6]:
In [7]: y.foobar[]
---------------------------------------------------------------------------
TypeError Traceback [most recent call last]
in []
----> 1 y.foobar[]
TypeError: bar[] takes exactly 1 argument [0 given]
In [8]: y.foobar[y]
Out[8]: "What's up"
In [5]: y = MyClass2[bar]
In [6]: y.foobar
Out[6]:
In [7]: y.foobar[]
---------------------------------------------------------------------------
TypeError Traceback [most recent call last]
in []
----> 1 y.foobar[]
TypeError: bar[] takes exactly 1 argument [0 given]
In [8]: y.foobar[y]
Out[8]: "What's up"
In [5]: y = MyClass2[bar]
In [6]: y.foobar
Out[6]:
In [7]: y.foobar[]
---------------------------------------------------------------------------
TypeError Traceback [most recent call last]
in []
----> 1 y.foobar[]
TypeError: bar[] takes exactly 1 argument [0 given]
In [8]: y.foobar[y]
Out[8]: "What's up"
In [5]: y = MyClass2[bar]
In [6]: y.foobar
Out[6]:
In [7]: y.foobar[]
---------------------------------------------------------------------------
TypeError Traceback [most recent call last]
in []
----> 1 y.foobar[]
TypeError: bar[] takes exactly 1 argument [0 given]
In [8]: y.foobar[y]
Out[8]: "What's up"
Name- Finxter
Id – 1020
Rank- 1
Ở đây, cách thức bạn có thể gán các giá trị:
class Student:
def __init__[self, name, id, rank]:
self.name = name
self.id = id
self.rank = rank
def run[self]:
print[f'{self.name} is a cross country champion!']
def jump[self]:
print[f'{self.name} with the following ID: {self.id} is a high jumper!']
def swim[self]:
print[f'{self.name} secured rank {self.rank} in swimming.']
stud1 = Student['Finxter', 1020, 1]
stud1.run[]
stud1.jump[]
stud1.swim[]Output:
Finxter is a cross country champion!
Finxter with the following ID: 1020 is a high jumper!
Finxter secured rank 1 in swimming.Ví dụ trên đã chứng minh cách thêm chức năng [phương pháp] truyền thống vào lớp Python. Ở đây, các phương pháp được xác định bên trong cơ thể lớp. Bây giờ, hãy để nói rằng bạn muốn xác định một phương pháp bên ngoài cơ thể lớp. Bạn sẽ làm như vậy như thế nào? Hãy cùng đi sâu vào các cách tiếp cận khác nhau để khai quật câu trả lời cho câu hỏi này.
Xác định phương pháp bên ngoài và sử dụng bên trong cơ thể lớp
Ý tưởng ở đây là xác định phương pháp bên ngoài lớp và sau đó sử dụng nó bên trong thân lớp, như được hiển thị bên dưới.
Ví dụ 1:
# Defining the method outside the class
def foo[self]:
print["Method foo executed"]
x = 10
print["Value of x = ", x]
# Using the method inside the class body
class Demo:
my_method = fooBạn cũng có thể xác định một lớp trước và sau đó thêm một phương thức hoặc chức năng cho nó từ bên ngoài cơ thể của nó, như được hiển thị bên dưới.
Ví dụ 2:
# Define the class
class Demo:
pass
# Define the method outside the class
def foo[self]:
print["Method foo executed "]
# Pass the method to the class
Demo.method1 = fooTHẬN TRỌNG: Chúng tôi thậm chí có thể xác định các hàm, phương thức và lớp trong các mô -đun khác nhau nếu chúng tôi muốn. Tuy nhiên, nên sử dụng ví dụ 1 thay vì ví dụ 2 [xác định lớp trong một mô -đun, sau đó nhập nó vào một mô -đun khác và thêm các phương thức vào nó một cách linh hoạt] vì các đối tượng lớp có thể hoạt động khác nhau tùy thuộc vào việc có được nhập mô -đun hay không.We can even define the functions, methods, and classes in different modules if we want to. However, it is advisable to use example 1 rather than example 2 [defining the class in one module, then importing it into another module and further adding methods to it dynamically] because the class objects may behave differently depending on whether the module has been imported or not.
Có một cách khác để xác định chức năng bên ngoài một lớp và sau đó thêm nó. Nhưng có một sự khác biệt trong việc gán hàm cho đối tượng thể hiện hoặc lớp. Nhìn vào ví dụ sau để hiểu sự khác biệt tinh tế:
class Demo1[object]:
def __init__[self, bar]:
self.func = 'Finxter'
Demo1.funcbar = bar
class Demo2[object]:
def __init__[self, bar]:
self.func = 'Finxter'
self.funcbar = bar
def bar[self]:
return 'Welcome' + self.funcGiải thích: Hãy để hiểu về những gì xảy ra ở đây.Let’s understand what’s happening here.
- Trong trường hợp lớp
6,In [5]: y = MyClass2[bar] In [6]: y.foobar Out[6]: In [7]: y.foobar[] --------------------------------------------------------------------------- TypeError Traceback [most recent call last] in [] ----> 1 y.foobar[] TypeError: bar[] takes exactly 1 argument [0 given] In [8]: y.foobar[y] Out[8]: "What's up"
7 cũng giống như bất kỳ phương pháp thông thường nào khác được liên kết với thể hiện của lớp. Hãy để một cái nhìn về điều này trông như thế nào -bound to the instance of the class. Let’s have a look at what this looks like –In [5]: y = MyClass2[bar] In [6]: y.foobar Out[6]: In [7]: y.foobar[] --------------------------------------------------------------------------- TypeError Traceback [most recent call last] in [] ----> 1 y.foobar[] TypeError: bar[] takes exactly 1 argument [0 given] In [8]: y.foobar[y] Out[8]: "What's up"
- Trong trường hợp lớp
8,In [5]: y = MyClass2[bar] In [6]: y.foobar Out[6]: In [7]: y.foobar[] --------------------------------------------------------------------------- TypeError Traceback [most recent call last] in [] ----> 1 y.foobar[] TypeError: bar[] takes exactly 1 argument [0 given] In [8]: y.foobar[y] Out[8]: "What's up"
7 chỉ đơn giản là một tham chiếu đến hàm thanh, tức là, nó không phải là chức năng rất nhiều. Vì vậy, chúng ta phải vượt qua thể hiện cho chức năng này để nó hoạt động đúng.not a bound function. Thus, we must pass the instance for this function for it to work properly.In [5]: y = MyClass2[bar] In [6]: y.foobar Out[6]: In [7]: y.foobar[] --------------------------------------------------------------------------- TypeError Traceback [most recent call last] in [] ----> 1 y.foobar[] TypeError: bar[] takes exactly 1 argument [0 given] In [8]: y.foobar[y] Out[8]: "What's up"
Sử dụng thừa kế
Bạn thậm chí có thể sử dụng các phương thức của một lớp trong một lớp khác. Trong ví dụ sau, chúng tôi có một lớp
# Given Class
class Demo:
# Given Method
def foo[self]:
x = 10
return x0 với một số phương thức được xác định trong nó. Tất cả các phương pháp của lớp # Given Class
class Demo:
# Given Method
def foo[self]:
x = 10
return x0 có thể được kế thừa bởi lớp # Given Class
class Demo:
# Given Method
def foo[self]:
x = 10
return x2AS được hiển thị bên dưới.In [2]: x = MyClass1[bar]
In [3]: x.foobar
Out[3]:
In [4]: x.foobar[]
Out[4]: "What's up"
Output:
In [2]: x = MyClass1[bar]
In [3]: x.foobar
Out[3]:
In [4]: x.foobar[]
Out[4]: "What's up"
Đọc liên quan: thừa kế trong Python
Sự kết luận
Để tổng hợp mọi thứ, hoàn toàn có thể có các chức năng bên ngoài các lớp trong Python. Nếu bạn muốn thu thập một nhóm các chức năng trong một hộp thì bạn chỉ cần đặt chúng lại với nhau trong cùng một mô -đun. Hơn nữa, bạn có thể làm tổ các mô -đun trong các gói. Bạn nên sử dụng các lớp khi bạn phải tạo một kiểu dữ liệu mới và không chỉ sử dụng nó để nhóm các chức năng cùng nhau.
Đó là nó cho cuộc thảo luận này và tôi hy vọng nó sẽ giúp bạn. Vui lòng theo dõi và đăng ký cho các bài viết và thảo luận thú vị hơn trong tương lai. Học hỏi!
Bài báo của Shubham Sayon và Rashi AgarwalShubham Sayon and Rashi Agarwal
Tôi là một blogger Python chuyên nghiệp và người tạo nội dung. Tôi đã xuất bản nhiều bài báo và tạo ra các khóa học trong một khoảng thời gian. Hiện tại tôi đang làm việc như một freelancer toàn thời gian và tôi có kinh nghiệm trong các lĩnh vực như Python, AWS, DevOps và Mạng.
Bạn có thể liên lạc với tôi @:
Upwork LinkedIn
LinkedIn