Hướng dẫn calling class method from static method python - gọi phương thức lớp từ phương thức tĩnh python

Ví dụ, lớp và phương thức tĩnh - tổng quan

Hãy bắt đầu bằng cách viết một lớp (Python 3) chứa các ví dụ đơn giản cho cả ba loại phương thức:

class MyClass:
    def method(self):
        return 'instance method called', self

    @classmethod
    def classmethod(cls):
        return 'class method called', cls

    @staticmethod
    def staticmethod():
        return 'static method called'

Lưu ý: Đối với người dùng Python 2: Các nhà trang trí

>>> MyClass.normal_method(instance, "Success!")
Normal method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data Success!

0 và

>>> MyClass.normal_method(instance, "Success!")
Normal method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data Success!

1 có sẵn như Python 2.4 và ví dụ này sẽ hoạt động như hiện tại. Thay vì sử dụng tuyên bố đơn giản

>>> MyClass.normal_method(instance, "Success!")
Normal method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data Success!

2, bạn có thể chọn khai báo một lớp mới kế thừa từ

>>> MyClass.normal_method(instance, "Success!")
Normal method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data Success!

3 với cú pháp

>>> MyClass.normal_method(instance, "Success!")
Normal method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data Success!

4. Ngoài ra, bạn rất tốt để đi. For Python 2 users: The

>>> MyClass.normal_method(instance, "Success!")
Normal method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data Success!

0 and

>>> MyClass.normal_method(instance, "Success!")
Normal method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data Success!

1 decorators are available as of Python 2.4 and this example will work as is. Instead of using a plain

>>> MyClass.normal_method(instance, "Success!")
Normal method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data Success!

2 declaration you might choose to declare a new-style class inheriting from

>>> MyClass.normal_method(instance, "Success!")
Normal method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data Success!

3 with the

>>> MyClass.normal_method(instance, "Success!")
Normal method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data Success!

4 syntax. Other than that you’re good to go.

>>> MyClass.normal_method(instance, "Success!")
Normal method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data Success!

>>> MyClass.normal_method(instance, "Success!")
Normal method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data Success!

>>> MyClass.normal_method(instance, "Success!")
Normal method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data Success!

>>> MyClass.normal_method(instance, "Success!")
Normal method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data Success!

>>> MyClass.normal_method(instance, "Success!")
Normal method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data Success!

    @staticmethod
    def a_cool_static_method(instance, data):
        print "Cool method called with instance %s and data %s" % (instance, data)
        MyClass.normal_method(instance, data)
        MyClass.class_method(data)
        MyClass.static_method(data)

>>> instance.a_cool_static_method(instance, "So Cool!")
Cool method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data So Cool!
Normal method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data So Cool!
Class method called with class __main__.MyClass and data So Cool!
Static method called with data So Cool!

    @staticmethod
    def a_cool_static_method(instance, data):
        print "Cool method called with instance %s and data %s" % (instance, data)
        MyClass.normal_method(instance, data)
        MyClass.class_method(data)
        MyClass.static_method(data)

>>> instance.a_cool_static_method(instance, "So Cool!")
Cool method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data So Cool!
Normal method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data So Cool!
Class method called with class __main__.MyClass and data So Cool!
Static method called with data So Cool!

>>> MyClass.normal_method(instance, "Success!")
Normal method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data Success!

>>> MyClass.normal_method(instance, "Success!")
Normal method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data Success!

    @staticmethod
    def a_cool_static_method(instance, data):
        print "Cool method called with instance %s and data %s" % (instance, data)
        MyClass.normal_method(instance, data)
        MyClass.class_method(data)
        MyClass.static_method(data)

>>> instance.a_cool_static_method(instance, "So Cool!")
Cool method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data So Cool!
Normal method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data So Cool!
Class method called with class __main__.MyClass and data So Cool!
Static method called with data So Cool!

    @staticmethod
    def a_cool_static_method(instance, data):
        print "Cool method called with instance %s and data %s" % (instance, data)
        MyClass.normal_method(instance, data)
        MyClass.class_method(data)
        MyClass.static_method(data)

>>> instance.a_cool_static_method(instance, "So Cool!")
Cool method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data So Cool!
Normal method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data So Cool!
Class method called with class __main__.MyClass and data So Cool!
Static method called with data So Cool!

>>> MyClass.normal_method(instance, "Success!")
Normal method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data Success!

    @staticmethod
    def a_cool_static_method(instance, data):
        print "Cool method called with instance %s and data %s" % (instance, data)
        MyClass.normal_method(instance, data)
        MyClass.class_method(data)
        MyClass.static_method(data)

>>> instance.a_cool_static_method(instance, "So Cool!")
Cool method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data So Cool!
Normal method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data So Cool!
Class method called with class __main__.MyClass and data So Cool!
Static method called with data So Cool!

>>> MyClass.normal_method(instance, "Success!")
Normal method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data Success!

>>> MyClass.normal_method(instance, "Success!")
Normal method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data Success!

    @staticmethod
    def a_cool_static_method(instance, data):
        print "Cool method called with instance %s and data %s" % (instance, data)
        MyClass.normal_method(instance, data)
        MyClass.class_method(data)
        MyClass.static_method(data)

>>> instance.a_cool_static_method(instance, "So Cool!")
Cool method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data So Cool!
Normal method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data So Cool!
Class method called with class __main__.MyClass and data So Cool!
Static method called with data So Cool!

Hãy cùng xem họ trong hành động!

Tôi biết cuộc thảo luận này đã được lý thuyết khá cho đến thời điểm này. Và tôi tin rằng điều quan trọng là bạn phát triển sự hiểu biết trực quan về cách các loại phương pháp này khác nhau trong thực tế. Bây giờ chúng tôi sẽ đi qua một số ví dụ cụ thể.

Hãy cùng xem cách các phương pháp này hoạt động như thế nào khi chúng ta gọi chúng. Chúng tôi sẽ bắt đầu bằng cách tạo một thể hiện của lớp và sau đó gọi ba phương thức khác nhau trên đó.

>>> MyClass.normal_method(instance, "Success!")
Normal method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data Success!

Ở đây, những gì xảy ra khi chúng ta gọi một phương thức thể hiện:instance method:

>>>

>>> obj = MyClass()
>>> obj.method()
('instance method called', <MyClass instance at 0x10205d190>)

Điều này xác nhận rằng

>>> MyClass.normal_method(instance, "Success!")
Normal method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data Success!

class MyClass:
    def method(self):
        return 'instance method called', self

    @classmethod
    def classmethod(cls):
        return 'class method called', cls

    @staticmethod
    def staticmethod():
        return 'static method called'

>>> MyClass.normal_method(instance, "Success!")
Normal method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data Success!

Khi phương thức được gọi, Python thay thế đối số

>>> MyClass.normal_method(instance, "Success!")
Normal method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data Success!

class MyClass:
    def method(self):
        return 'instance method called', self

    @classmethod
    def classmethod(cls):
        return 'class method called', cls

    @staticmethod
    def staticmethod():
        return 'static method called'

class MyClass:
    def method(self):
        return 'instance method called', self

    @classmethod
    def classmethod(cls):
        return 'class method called', cls

    @staticmethod
    def staticmethod():
        return 'static method called'

>>>

>>> MyClass.method(obj)
('instance method called', <MyClass instance at 0x10205d190>)

Điều này xác nhận rằng

>>> MyClass.normal_method(instance, "Success!")
Normal method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data Success!

class MyClass:
    def method(self):
        return 'instance method called', self

    @classmethod
    def classmethod(cls):
        return 'class method called', cls

    @staticmethod
    def staticmethod():
        return 'static method called'

>>> MyClass.normal_method(instance, "Success!")
Normal method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data Success!

Khi phương thức được gọi, Python thay thế đối số

>>> MyClass.normal_method(instance, "Success!")
Normal method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data Success!

class MyClass:
    def method(self):
        return 'instance method called', self

    @classmethod
    def classmethod(cls):
        return 'class method called', cls

    @staticmethod
    def staticmethod():
        return 'static method called'

class MyClass:
    def method(self):
        return 'instance method called', self

    @classmethod
    def classmethod(cls):
        return 'class method called', cls

    @staticmethod
    def staticmethod():
        return 'static method called'

Bạn có thể đoán điều gì sẽ xảy ra nếu bạn cố gắng gọi phương thức mà không tạo ra một thể hiện trước không?class method next:

>>>

>>> obj.classmethod()
('class method called', <class MyClass at 0x101a2f4c8>)

Điều này xác nhận rằng

>>> MyClass.normal_method(instance, "Success!")
Normal method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data Success!

class MyClass:
    def method(self):
        return 'instance method called', self

    @classmethod
    def classmethod(cls):
        return 'class method called', cls

    @staticmethod
    def staticmethod():
        return 'static method called'

>>> MyClass.normal_method(instance, "Success!")
Normal method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data Success!

Khi phương thức được gọi, Python thay thế đối số

>>> MyClass.normal_method(instance, "Success!")
Normal method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data Success!

class MyClass:
    def method(self):
        return 'instance method called', self

    @classmethod
    def classmethod(cls):
        return 'class method called', cls

    @staticmethod
    def staticmethod():
        return 'static method called'

class MyClass:
    def method(self):
        return 'instance method called', self

    @classmethod
    def classmethod(cls):
        return 'class method called', cls

    @staticmethod
    def staticmethod():
        return 'static method called'

Bạn có thể đoán điều gì sẽ xảy ra nếu bạn cố gắng gọi phương thức mà không tạo ra một thể hiện trước không?

Nhân tiện, các phương thức thể hiện cũng có thể truy cập vào bản thân lớp thông qua thuộc tính

    @staticmethod
    def a_cool_static_method(instance, data):
        print "Cool method called with instance %s and data %s" % (instance, data)
        MyClass.normal_method(instance, data)
        MyClass.class_method(data)
        MyClass.static_method(data)

>>> instance.a_cool_static_method(instance, "So Cool!")
Cool method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data So Cool!
Normal method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data So Cool!
Class method called with class __main__.MyClass and data So Cool!
Static method called with data So Cool!

>>>

>>> obj.staticmethod()
'static method called'

Điều này xác nhận rằng

>>> MyClass.normal_method(instance, "Success!")
Normal method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data Success!

class MyClass:
    def method(self):
        return 'instance method called', self

    @classmethod
    def classmethod(cls):
        return 'class method called', cls

    @staticmethod
    def staticmethod():
        return 'static method called'

>>> MyClass.normal_method(instance, "Success!")
Normal method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data Success!

Khi phương thức được gọi, Python thay thế đối số

>>> MyClass.normal_method(instance, "Success!")
Normal method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data Success!

class MyClass:
    def method(self):
        return 'instance method called', self

    @classmethod
    def classmethod(cls):
        return 'class method called', cls

    @staticmethod
    def staticmethod():
        return 'static method called'

class MyClass:
    def method(self):
        return 'instance method called', self

    @classmethod
    def classmethod(cls):
        return 'class method called', cls

    @staticmethod
    def staticmethod():
        return 'static method called'

Bạn có thể đoán điều gì sẽ xảy ra nếu bạn cố gắng gọi phương thức mà không tạo ra một thể hiện trước không?

Nhân tiện, các phương thức thể hiện cũng có thể truy cập vào bản thân lớp thông qua thuộc tính

    @staticmethod
    def a_cool_static_method(instance, data):
        print "Cool method called with instance %s and data %s" % (instance, data)
        MyClass.normal_method(instance, data)
        MyClass.class_method(data)
        MyClass.static_method(data)

>>> instance.a_cool_static_method(instance, "So Cool!")
Cool method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data So Cool!
Normal method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data So Cool!
Class method called with class __main__.MyClass and data So Cool!
Static method called with data So Cool!

>>>

>>> MyClass.classmethod()
('class method called', <class MyClass at 0x101a2f4c8>)

>>> MyClass.staticmethod()
'static method called'

>>> MyClass.method()
TypeError: unbound method method() must
    be called with MyClass instance as first
    argument (got nothing instead)

Điều này xác nhận rằng

>>> MyClass.normal_method(instance, "Success!")
Normal method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data Success!

class MyClass:
    def method(self):
        return 'instance method called', self

    @classmethod
    def classmethod(cls):
        return 'class method called', cls

    @staticmethod
    def staticmethod():
        return 'static method called'

>>> MyClass.normal_method(instance, "Success!")
Normal method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data Success!

Khi phương thức được gọi, Python thay thế đối số

>>> MyClass.normal_method(instance, "Success!")
Normal method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data Success!

class MyClass:
    def method(self):
        return 'instance method called', self

    @classmethod
    def classmethod(cls):
        return 'class method called', cls

    @staticmethod
    def staticmethod():
        return 'static method called'

class MyClass:
    def method(self):
        return 'instance method called', self

    @classmethod
    def classmethod(cls):
        return 'class method called', cls

    @staticmethod
    def staticmethod():
        return 'static method called'

Bạn có thể đoán điều gì sẽ xảy ra nếu bạn cố gắng gọi phương thức mà không tạo ra một thể hiện trước không?

Nhân tiện, các phương thức thể hiện cũng có thể truy cập vào bản thân lớp thông qua thuộc tính

    @staticmethod
    def a_cool_static_method(instance, data):
        print "Cool method called with instance %s and data %s" % (instance, data)
        MyClass.normal_method(instance, data)
        MyClass.class_method(data)
        MyClass.static_method(data)

>>> instance.a_cool_static_method(instance, "So Cool!")
Cool method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data So Cool!
Normal method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data So Cool!
Class method called with class __main__.MyClass and data So Cool!
Static method called with data So Cool!

>>> instance = MyClass()
>>> instance.normal_method("Success!")
Normal method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data Success!

>>> instance.class_method("Success!")
Class method called with class __main__.MyClass and data Success!

>>> instance.static_method("Success!")
Static method called with data Success!

>>>

>>> instance = MyClass()
>>> instance.normal_method("Success!")
Normal method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data Success!

>>> instance.class_method("Success!")
Class method called with class __main__.MyClass and data Success!

>>> instance.static_method("Success!")
Static method called with data Success!

Hãy cùng thử phương pháp lớp tiếp theo: This code example and the ones further along in the tutorial use Python 3.6 f-strings to construct the string returned by

>>> MyClass.method(obj)
('instance method called', <MyClass instance at 0x10205d190>)

7. On Python 2 and versions of Python 3 before 3.6 you’d use a different string formatting expression, for example:

>>> instance = MyClass()
>>> instance.normal_method("Success!")
Normal method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data Success!

>>> instance.class_method("Success!")
Class method called with class __main__.MyClass and data Success!

>>> instance.static_method("Success!")
Static method called with data Success!

2

Gọi class MyClass: def method(self): return 'instance method called', self @classmethod def classmethod(cls): return 'class method called', cls @staticmethod def staticmethod(): return 'static method called' 9 cho chúng tôi thấy rằng nó không có quyền truy cập vào đối tượng class MyClass: def method(self): return 'instance method called', self @classmethod def classmethod(cls): return 'class method called', cls @staticmethod def staticmethod(): return 'static method called' 3, nhưng chỉ với đối tượng >>> obj = MyClass() >>> obj.method() ('instance method called', <MyClass instance at 0x10205d190>) 1, đại diện cho bản thân lớp (mọi thứ trong Python là một đối tượng, thậm chí cả các lớp).

Lưu ý cách Python tự động chuyển lớp là đối số đầu tiên cho hàm khi chúng ta gọi

>>> obj = MyClass()
>>> obj.method()
('instance method called', <MyClass instance at 0x10205d190>)

>>> MyClass.normal_method(instance, "Success!")
Normal method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data Success!

>>> instance = MyClass()
>>> instance.normal_method("Success!")
Normal method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data Success!

>>> instance.class_method("Success!")
Class method called with class __main__.MyClass and data Success!

>>> instance.static_method("Success!")
Static method called with data Success!

Xin lưu ý rằng việc đặt tên cho các tham số này

>>> MyClass.normal_method(instance, "Success!")
Normal method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data Success!

    @staticmethod
    def a_cool_static_method(instance, data):
        print "Cool method called with instance %s and data %s" % (instance, data)
        MyClass.normal_method(instance, data)
        MyClass.class_method(data)
        MyClass.static_method(data)

>>> instance.a_cool_static_method(instance, "So Cool!")
Cool method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data So Cool!
Normal method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data So Cool!
Class method called with class __main__.MyClass and data So Cool!
Static method called with data So Cool!

>>> obj = MyClass()
>>> obj.method()
('instance method called', <MyClass instance at 0x10205d190>)

>>> obj = MyClass()
>>> obj.method()
('instance method called', <MyClass instance at 0x10205d190>)

Thời gian để gọi phương thức tĩnh ngay bây giờ:

>>> instance = MyClass()
>>> instance.normal_method("Success!")
Normal method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data Success!

>>> instance.class_method("Success!")
Class method called with class __main__.MyClass and data Success!

>>> instance.static_method("Success!")
Static method called with data Success!

Bạn có thấy cách chúng tôi gọi

>>> obj = MyClass()
>>> obj.method()
('instance method called', <MyClass instance at 0x10205d190>)

Đằng sau hậu trường, Python chỉ đơn giản thực thi các hạn chế truy cập bằng cách không truyền trong đối số

>>> MyClass.normal_method(instance, "Success!")
Normal method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data Success!

    @staticmethod
    def a_cool_static_method(instance, data):
        print "Cool method called with instance %s and data %s" % (instance, data)
        MyClass.normal_method(instance, data)
        MyClass.class_method(data)
        MyClass.static_method(data)

>>> instance.a_cool_static_method(instance, "So Cool!")
Cool method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data So Cool!
Normal method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data So Cool!
Class method called with class __main__.MyClass and data So Cool!
Static method called with data So Cool!

Điều này xác nhận rằng các phương thức tĩnh không thể truy cập trạng thái thể hiện đối tượng cũng như trạng thái lớp. Chúng hoạt động như các chức năng thông thường nhưng thuộc về lớp học (và mọi trường hợp) không gian tên.

>>>

>>> instance = MyClass()
>>> instance.normal_method("Success!")
Normal method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data Success!

>>> instance.class_method("Success!")
Class method called with class __main__.MyClass and data Success!

>>> instance.static_method("Success!")
Static method called with data Success!

Như bạn có thể thấy, chúng ta có thể sử dụng các chức năng của nhà máy để tạo các đối tượng

>>> MyClass.method(obj)
('instance method called', <MyClass instance at 0x10205d190>)

>>> obj.classmethod()
('class method called', <class MyClass at 0x101a2f4c8>)

Một cách khác để xem xét việc sử dụng các phương thức lớp này là chúng cho phép bạn xác định các hàm tạo thay thế cho các lớp của bạn.

Python chỉ cho phép một phương thức

>>> obj.classmethod()
('class method called', <class MyClass at 0x101a2f4c8>)

Khi nào nên sử dụng các phương thức tĩnh

Nó khó khăn hơn một chút để đưa ra một ví dụ điển hình ở đây. Nhưng hãy nói với bạn những gì, tôi sẽ tiếp tục kéo dài pizza tương tự mỏng hơn và mỏng hơn (yum!)

Ở đây, những gì tôi đã nghĩ ra:

>>> instance = MyClass()
>>> instance.normal_method("Success!")
Normal method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data Success!

>>> instance.class_method("Success!")
Class method called with class __main__.MyClass and data Success!

>>> instance.static_method("Success!")
Static method called with data Success!

Bây giờ tôi đã thay đổi gì ở đây? Đầu tiên, tôi đã sửa đổi hàm tạo và

>>> MyClass.method(obj)
('instance method called', <MyClass instance at 0x10205d190>)

>>> obj.classmethod()
('class method called', <class MyClass at 0x101a2f4c8>)

Tôi cũng đã thêm một phương thức ví dụ

>>> obj.classmethod()
('class method called', <class MyClass at 0x101a2f4c8>)

>>> obj.staticmethod()
'static method called'

Thay vì tính toán diện tích trực tiếp trong

>>> obj.classmethod()
('class method called', <class MyClass at 0x101a2f4c8>)

>>> obj.staticmethod()
'static method called'

Hãy để thử nó ra!

>>>

>>> instance = MyClass()
>>> instance.normal_method("Success!")
Normal method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data Success!

>>> instance.class_method("Success!")
Class method called with class __main__.MyClass and data Success!

>>> instance.static_method("Success!")
Static method called with data Success!

Chắc chắn, đây là một chút của một ví dụ đơn giản, nhưng nó sẽ không để giải thích một số lợi ích mà các phương pháp tĩnh mang lại.

Như chúng tôi đã học, các phương pháp tĩnh có thể truy cập vào lớp hoặc trạng thái thể hiện vì họ không có đối số

    @staticmethod
    def a_cool_static_method(instance, data):
        print "Cool method called with instance %s and data %s" % (instance, data)
        MyClass.normal_method(instance, data)
        MyClass.class_method(data)
        MyClass.static_method(data)

>>> instance.a_cool_static_method(instance, "So Cool!")
Cool method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data So Cool!
Normal method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data So Cool!
Class method called with class __main__.MyClass and data So Cool!
Static method called with data So Cool!

>>> MyClass.normal_method(instance, "Success!")
Normal method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data Success!

Trong ví dụ trên, nó rõ ràng rằng

>>> obj.staticmethod()
'static method called'

Bây giờ, tại sao điều đó lại hữu ích?

Việc gắn cờ một phương thức như một phương pháp tĩnh không chỉ là một gợi ý rằng một phương thức đã giành được sửa đổi lớp hoặc trạng thái thể hiện - hạn chế này cũng được thực thi bởi thời gian chạy Python.

Các kỹ thuật như thế cho phép bạn giao tiếp rõ ràng về các phần của kiến ​​trúc lớp của bạn để công việc phát triển mới được hướng dẫn một cách tự nhiên để xảy ra trong các ranh giới đã đặt ra này. Tất nhiên, nó sẽ đủ dễ dàng để thách thức những hạn chế này. Nhưng trong thực tế, họ thường giúp tránh các sửa đổi tình cờ đi ngược lại với thiết kế ban đầu.

Nói cách khác, sử dụng các phương thức tĩnh và phương pháp lớp là cách để truyền đạt ý định của nhà phát triển trong khi thực thi ý định đó đủ để tránh hầu hết các lỗi và lỗi của tâm trí sẽ phá vỡ thiết kế.

Áp dụng một cách tiết kiệm và khi nó có ý nghĩa, viết một số phương pháp của bạn theo cách có thể cung cấp lợi ích bảo trì và làm cho ít có khả năng các nhà phát triển khác sử dụng các lớp của bạn không chính xác.

Phương pháp tĩnh cũng có lợi ích khi viết mã kiểm tra.

Bởi vì phương pháp

>>> obj.staticmethod()
'static method called'

Chúng tôi không phải lo lắng về việc thiết lập một thể hiện lớp hoàn chỉnh trước khi chúng tôi có thể kiểm tra phương thức trong một bài kiểm tra đơn vị. Chúng ta chỉ có thể bắn đi như chúng ta sẽ thử nghiệm một chức năng thông thường. Một lần nữa, điều này làm cho việc bảo trì trong tương lai dễ dàng hơn.

Key Takeaways

• Các phương thức thể hiện cần một thể hiện lớp và có thể truy cập phiên bản thông qua

  >>> MyClass.normal_method(instance, "Success!")
  Normal method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data Success!
  

  7.
• Phương pháp lớp don don cần một thể hiện lớp. Họ có thể truy cập vào trường hợp (

  >>> MyClass.normal_method(instance, "Success!")
  Normal method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data Success!
  

  7) nhưng họ có quyền truy cập vào lớp thông qua

      @staticmethod
      def a_cool_static_method(instance, data):
          print "Cool method called with instance %s and data %s" % (instance, data)
          MyClass.normal_method(instance, data)
          MyClass.class_method(data)
          MyClass.static_method(data)
  
  >>> instance.a_cool_static_method(instance, "So Cool!")
  Cool method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data So Cool!
  Normal method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data So Cool!
  Class method called with class __main__.MyClass and data So Cool!
  Static method called with data So Cool!
  

  4.
• Các phương pháp tĩnh don lồng có quyền truy cập vào

      @staticmethod
      def a_cool_static_method(instance, data):
          print "Cool method called with instance %s and data %s" % (instance, data)
          MyClass.normal_method(instance, data)
          MyClass.class_method(data)
          MyClass.static_method(data)
  
  >>> instance.a_cool_static_method(instance, "So Cool!")
  Cool method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data So Cool!
  Normal method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data So Cool!
  Class method called with class __main__.MyClass and data So Cool!
  Static method called with data So Cool!
  

  4 hoặc

  >>> MyClass.normal_method(instance, "Success!")
  Normal method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data Success!
  

  7. Chúng hoạt động như các chức năng thông thường nhưng thuộc về không gian tên lớp.
• Phương pháp tĩnh và lớp giao tiếp và (ở một mức độ nhất định) thực thi ý định của nhà phát triển về thiết kế lớp. Điều này có thể có lợi ích bảo trì.