Hướng dẫn when to use class method in python - khi nào sử dụng phương thức lớp trong python

Các phương thức lớp là khi bạn cần có các phương thức không cụ thể cho bất kỳ trường hợp cụ thể nào, nhưng vẫn liên quan đến lớp theo một cách nào đó. Điều thú vị nhất về chúng là chúng có thể bị ghi đè bởi các lớp con, một điều đơn giản là không thể trong các phương thức tĩnh của Java hoặc các chức năng cấp độ mô-đun của Python.

Nếu bạn có lớp

Logger.error( "Wow, something really awful happened." )

Logger.error( "Wow, something really awful happened." )

Đã trả lời ngày 1 tháng 9 năm 2008 lúc 18:45Sep 1, 2008 at 18:45

John Millikinjohn MillikinJohn Millikin

Phim thương hiệu vàng 194K3939 gold badges211 silver badges222 bronze badges

3

Phương pháp nhà máy (các hàm tạo thay thế) thực sự là một ví dụ kinh điển về các phương pháp lớp.

Về cơ bản, các phương thức lớp phù hợp bất cứ lúc nào bạn muốn có một phương thức phù hợp với không gian tên của lớp, nhưng không liên quan đến một trường hợp cụ thể của lớp.

Ví dụ, trong mô -đun Unipath xuất sắc:

Thư mục hiện tại

• Logger.error( "Wow, something really awful happened." )
  

  9
  • Trả lại thư mục hiện tại thực tế; ví dụ:

    Logger._level = Logger.ERROR
    

    0. Đây là một phương pháp lớp.

• Logger._level = Logger.ERROR
  

  1
  • Tự làm thư mục hiện tại.

Vì thư mục hiện tại là quá trình, phương thức

Logger._level = Logger.ERROR

Logger._level = Logger.ERROR

Logger._level = Logger.ERROR

Hmmm ... Vì

Logger.error( "Wow, something really awful happened." )

Logger._level = Logger.ERROR

Đã trả lời ngày 1 tháng 9 năm 2008 lúc 19:08Sep 1, 2008 at 19:08

2

Hãy suy nghĩ về nó theo cách này: Các phương thức thông thường rất hữu ích để ẩn các chi tiết của công văn: Bạn có thể nhập

Logger._level = Logger.ERROR

Logger._level = Logger.ERROR

Logger._level = Logger.ERROR

class Logger :
    ''' Handles logging of debugging and error messages. '''

    DEBUG = 5
    INFO  = 4
    WARN  = 3
    ERROR = 2
    FATAL = 1
    _level = DEBUG

    def __init__( self ) :
        Logger._level = Logger.DEBUG

    @classmethod
    def isLevel( cls, level ) :
        return cls._level >= level

    @classmethod
    def debug( cls, message ) :
        if cls.isLevel( Logger.DEBUG ) :
            print "DEBUG:  " + message

    @classmethod
    def info( cls, message ) :
        if cls.isLevel( Logger.INFO ) :
            print "INFO :  " + message

    @classmethod
    def warn( cls, message ) :
        if cls.isLevel( Logger.WARN ) :
            print "WARN :  " + message

    @classmethod
    def error( cls, message ) :
        if cls.isLevel( Logger.ERROR ) :
            print "ERROR:  " + message

    @classmethod
    def fatal( cls, message ) :
        if cls.isLevel( Logger.FATAL ) :
            print "FATAL:  " + message

Logger._level = Logger.ERROR

Logger.error( "Wow, something really awful happened." )

Các phương thức lớp rất cần thiết khi bạn đang thực hiện thiết lập hoặc tính toán trước khi tạo một thể hiện thực tế, bởi vì cho đến khi thể hiện tồn tại, bạn rõ ràng không thể sử dụng phiên bản làm điểm gửi cho các cuộc gọi phương thức của bạn. Một ví dụ tốt có thể được xem trong mã nguồn sqlalchemy; Hãy xem phương thức lớp

class Logger :
    ''' Handles logging of debugging and error messages. '''

    DEBUG = 5
    INFO  = 4
    WARN  = 3
    ERROR = 2
    FATAL = 1
    _level = DEBUG

    def __init__( self ) :
        Logger._level = Logger.DEBUG

    @classmethod
    def isLevel( cls, level ) :
        return cls._level >= level

    @classmethod
    def debug( cls, message ) :
        if cls.isLevel( Logger.DEBUG ) :
            print "DEBUG:  " + message

    @classmethod
    def info( cls, message ) :
        if cls.isLevel( Logger.INFO ) :
            print "INFO :  " + message

    @classmethod
    def warn( cls, message ) :
        if cls.isLevel( Logger.WARN ) :
            print "WARN :  " + message

    @classmethod
    def error( cls, message ) :
        if cls.isLevel( Logger.ERROR ) :
            print "ERROR:  " + message

    @classmethod
    def fatal( cls, message ) :
        if cls.isLevel( Logger.FATAL ) :
            print "FATAL:  " + message

https://github.com/zzzeek/sqlalchemy/blob/ab6946769742602e40fb9ed9dde5f642885d1906/lib/sqlalchemy/dialects/mssql/pymssql.py#L47

Bạn có thể thấy rằng phương thức

class Logger :
    ''' Handles logging of debugging and error messages. '''

    DEBUG = 5
    INFO  = 4
    WARN  = 3
    ERROR = 2
    FATAL = 1
    _level = DEBUG

    def __init__( self ) :
        Logger._level = Logger.DEBUG

    @classmethod
    def isLevel( cls, level ) :
        return cls._level >= level

    @classmethod
    def debug( cls, message ) :
        if cls.isLevel( Logger.DEBUG ) :
            print "DEBUG:  " + message

    @classmethod
    def info( cls, message ) :
        if cls.isLevel( Logger.INFO ) :
            print "INFO :  " + message

    @classmethod
    def warn( cls, message ) :
        if cls.isLevel( Logger.WARN ) :
            print "WARN :  " + message

    @classmethod
    def error( cls, message ) :
        if cls.isLevel( Logger.ERROR ) :
            print "ERROR:  " + message

    @classmethod
    def fatal( cls, message ) :
        if cls.isLevel( Logger.FATAL ) :
            print "FATAL:  " + message

Đã trả lời ngày 19 tháng 8 năm 2010 lúc 12:51Aug 19, 2010 at 12:51

Brandon Rhodesbrandon RhodesBrandon Rhodes

79.3K16 Huy hiệu vàng105 Huy hiệu bạc142 Huy hiệu đồng16 gold badges105 silver badges142 bronze badges

1

Gần đây tôi muốn có một lớp ghi nhật ký rất nhẹ có lượng đầu ra khác nhau tùy thuộc vào mức ghi nhật ký có thể được lập trình. Nhưng tôi không muốn khởi tạo lớp mỗi khi tôi muốn xuất thông báo gỡ lỗi hoặc lỗi hoặc cảnh báo. Nhưng tôi cũng muốn gói gọn chức năng của cơ sở ghi nhật ký này và làm cho nó có thể tái sử dụng mà không cần tuyên bố của bất kỳ thế giới nào.

Vì vậy, tôi đã sử dụng các biến lớp và bộ trang trí

class Logger :
    ''' Handles logging of debugging and error messages. '''

    DEBUG = 5
    INFO  = 4
    WARN  = 3
    ERROR = 2
    FATAL = 1
    _level = DEBUG

    def __init__( self ) :
        Logger._level = Logger.DEBUG

    @classmethod
    def isLevel( cls, level ) :
        return cls._level >= level

    @classmethod
    def debug( cls, message ) :
        if cls.isLevel( Logger.DEBUG ) :
            print "DEBUG:  " + message

    @classmethod
    def info( cls, message ) :
        if cls.isLevel( Logger.INFO ) :
            print "INFO :  " + message

    @classmethod
    def warn( cls, message ) :
        if cls.isLevel( Logger.WARN ) :
            print "WARN :  " + message

    @classmethod
    def error( cls, message ) :
        if cls.isLevel( Logger.ERROR ) :
            print "ERROR:  " + message

    @classmethod
    def fatal( cls, message ) :
        if cls.isLevel( Logger.FATAL ) :
            print "FATAL:  " + message

Với lớp đăng nhập đơn giản của tôi, tôi có thể làm như sau:

Logger._level = Logger.DEBUG

Sau đó, trong mã của tôi, nếu tôi muốn tạo ra một loạt thông tin gỡ lỗi, tôi chỉ cần mã

Logger.debug( "this is some annoying message I only want to see while debugging" )

Lỗi có thể được đưa ra với

Logger.error( "Wow, something really awful happened." )

Trong môi trường "sản xuất", tôi có thể chỉ định

Logger._level = Logger.ERROR

Và bây giờ, chỉ có thông báo lỗi sẽ là đầu ra. Thông báo gỡ lỗi sẽ không được in.

Đây là lớp học của tôi:

class Logger :
    ''' Handles logging of debugging and error messages. '''

    DEBUG = 5
    INFO  = 4
    WARN  = 3
    ERROR = 2
    FATAL = 1
    _level = DEBUG

    def __init__( self ) :
        Logger._level = Logger.DEBUG

    @classmethod
    def isLevel( cls, level ) :
        return cls._level >= level

    @classmethod
    def debug( cls, message ) :
        if cls.isLevel( Logger.DEBUG ) :
            print "DEBUG:  " + message

    @classmethod
    def info( cls, message ) :
        if cls.isLevel( Logger.INFO ) :
            print "INFO :  " + message

    @classmethod
    def warn( cls, message ) :
        if cls.isLevel( Logger.WARN ) :
            print "WARN :  " + message

    @classmethod
    def error( cls, message ) :
        if cls.isLevel( Logger.ERROR ) :
            print "ERROR:  " + message

    @classmethod
    def fatal( cls, message ) :
        if cls.isLevel( Logger.FATAL ) :
            print "FATAL:  " + message

Và một số mã kiểm tra nó chỉ một chút:

def logAll() :
    Logger.debug( "This is a Debug message." )
    Logger.info ( "This is a Info  message." )
    Logger.warn ( "This is a Warn  message." )
    Logger.error( "This is a Error message." )
    Logger.fatal( "This is a Fatal message." )

if __name__ == '__main__' :

    print "Should see all DEBUG and higher"
    Logger._level = Logger.DEBUG
    logAll()

    print "Should see all ERROR and higher"
    Logger._level = Logger.ERROR
    logAll()

Đã trả lời ngày 11 tháng 5 năm 2010 lúc 1:48May 11, 2010 at 1:48

MarvomarvoMarvo

17.7K8 Huy hiệu vàng49 Huy hiệu bạc73 Huy hiệu đồng8 gold badges49 silver badges73 bronze badges

4

Các nhà xây dựng thay thế là ví dụ cổ điển.

Đã trả lời ngày 1 tháng 9 năm 2008 lúc 18:27Sep 1, 2008 at 18:27

Aaron Maenpaaaaron MaenpaaAaron Maenpaa

Huy hiệu vàng 116K1194 Huy hiệu bạc108 Huy hiệu đồng11 gold badges94 silver badges108 bronze badges

Khi người dùng đăng nhập vào trang web của tôi, đối tượng người dùng () được khởi tạo từ tên người dùng và mật khẩu.

Nếu tôi cần đối tượng người dùng mà không có người dùng ở đó để đăng nhập (ví dụ: người dùng quản trị có thể muốn xóa tài khoản người dùng khác, vì vậy tôi cần khởi tạo người dùng đó và gọi phương thức xóa của nó):

Tôi có các phương thức lớp để lấy đối tượng người dùng.

class User():
    #lots of code
    #...
    # more code

    @classmethod
    def get_by_username(cls, username):
        return cls.query(cls.username == username).get()

    @classmethod
    def get_by_auth_id(cls, auth_id):
        return cls.query(cls.auth_id == auth_id).get()

Đã trả lời ngày 26 tháng 3 năm 2012 lúc 6:36Mar 26, 2012 at 6:36

Rusty Robrusty RobRusty Rob

15.8k8 Huy hiệu vàng94 Huy hiệu bạc112 Huy hiệu đồng8 gold badges94 silver badges112 bronze badges

Tôi nghĩ rằng câu trả lời rõ ràng nhất là một câu trả lời của Amankow. Nó tập trung vào cách bạn muốn tổ chức mã của bạn. Bạn có thể viết mọi thứ như các hàm cấp mô -đun được bọc trong không gian tên của mô -đun, tức làAmanKow's one. It boils down to how u want to organize your code. You can write everything as module level functions which are wrapped in the namespace of the module i.e

module.py (file 1)
---------
def f1() : pass
def f2() : pass
def f3() : pass


usage.py (file 2)
--------
from module import *
f1()
f2()
f3()
def f4():pass 
def f5():pass

usage1.py (file 3)
-------------------
from usage import f4,f5
f4()
f5()

Mã thủ tục trên không được tổ chức tốt, như bạn có thể thấy chỉ sau 3 mô -đun nó gây nhầm lẫn, mỗi phương pháp làm gì? Bạn có thể sử dụng tên mô tả dài cho các chức năng (như trong Java) nhưng mã của bạn vẫn không thể quản lý được rất nhanh.

Cách định hướng đối tượng là chia mã của bạn thành các khối có thể quản lý, tức là các lớp & đối tượng và chức năng có thể được liên kết với các trường hợp đối tượng hoặc với các lớp.

Với các chức năng của lớp, bạn đạt được một cấp độ phân chia khác trong mã của mình so với các chức năng cấp độ mô -đun. Vì vậy, bạn có thể nhóm các chức năng liên quan trong một lớp để làm cho chúng cụ thể hơn cho một nhiệm vụ mà bạn đã giao cho lớp đó. Ví dụ: bạn có thể tạo một lớp tiện ích tệp:

class FileUtil ():
  def copy(source,dest):pass
  def move(source,dest):pass
  def copyDir(source,dest):pass
  def moveDir(source,dest):pass

//usage
FileUtil.copy("1.txt","2.txt")
FileUtil.moveDir("dir1","dir2")

Cách này linh hoạt hơn và dễ bảo trì hơn, bạn nhóm các chức năng với nhau và rõ ràng hơn với những gì mỗi chức năng làm. Ngoài ra, bạn ngăn chặn xung đột tên, ví dụ: bản sao chức năng có thể tồn tại trong một mô -đun được nhập khác (ví dụ: bản sao mạng) mà bạn sử dụng trong mã của mình, vì vậy khi bạn sử dụng tên đầy đủ fileUtil.copy () bạn xóa vấn đề và cả hai hàm sao chép có thể được sử dụng cạnh nhau.

Đã trả lời ngày 14 tháng 5 năm 2011 lúc 10:24May 14, 2011 at 10:24

Firephilfirephilfirephil

83110 Huy hiệu bạc18 Huy hiệu đồng10 silver badges18 bronze badges

3

Nó cho phép bạn viết các phương thức lớp chung mà bạn có thể sử dụng với bất kỳ lớp tương thích nào.

Ví dụ:

@classmethod
def get_name(cls):
    print cls.name

class C:
    name = "tester"

C.get_name = get_name

#call it:
C.get_name()

Nếu bạn không sử dụng

class Logger :
    ''' Handles logging of debugging and error messages. '''

    DEBUG = 5
    INFO  = 4
    WARN  = 3
    ERROR = 2
    FATAL = 1
    _level = DEBUG

    def __init__( self ) :
        Logger._level = Logger.DEBUG

    @classmethod
    def isLevel( cls, level ) :
        return cls._level >= level

    @classmethod
    def debug( cls, message ) :
        if cls.isLevel( Logger.DEBUG ) :
            print "DEBUG:  " + message

    @classmethod
    def info( cls, message ) :
        if cls.isLevel( Logger.INFO ) :
            print "INFO :  " + message

    @classmethod
    def warn( cls, message ) :
        if cls.isLevel( Logger.WARN ) :
            print "WARN :  " + message

    @classmethod
    def error( cls, message ) :
        if cls.isLevel( Logger.ERROR ) :
            print "ERROR:  " + message

    @classmethod
    def fatal( cls, message ) :
        if cls.isLevel( Logger.FATAL ) :
            print "FATAL:  " + message

Logger.debug( "this is some annoying message I only want to see while debugging" )

Paul

4.0903 Huy hiệu vàng27 Huy hiệu bạc52 Huy hiệu Đồng3 gold badges27 silver badges52 bronze badges

Đã trả lời ngày 26 tháng 12 năm 2012 lúc 15:11Dec 26, 2012 at 15:11

Yetyetyet

74311 Huy hiệu bạc18 Huy hiệu đồng11 silver badges18 bronze badges

Trung thực? Tôi chưa bao giờ tìm thấy việc sử dụng cho staticmethod hoặc classmethod. Tôi chưa thấy một hoạt động không thể thực hiện bằng cách sử dụng hàm toàn cầu hoặc phương thức thể hiện.

Sẽ khác nếu Python sử dụng các thành viên riêng tư và được bảo vệ giống như Java. Trong Java, tôi cần một phương pháp tĩnh để có thể truy cập vào các thành viên riêng của một trường hợp để làm công cụ. Trong Python, điều đó hiếm khi cần thiết.

Thông thường, tôi thấy mọi người sử dụng staticmethod và classmethods khi tất cả những gì họ thực sự cần làm là sử dụng không gian tên cấp độ mô-đun của Python tốt hơn.

Đã trả lời ngày 1 tháng 9 năm 2008 lúc 18:54Sep 1, 2008 at 18:54

Jason Bakerjason BakerJason Baker

186K132 Huy hiệu vàng368 Huy hiệu bạc510 Huy hiệu Đồng132 gold badges368 silver badges510 bronze badges

2

Tôi đã từng làm việc với PHP và gần đây tôi đã tự hỏi mình, chuyện gì đang xảy ra với lớp học này? Hướng dẫn Python rất kỹ thuật và rất ngắn trong các từ nên nó sẽ không giúp hiểu được tính năng đó. Tôi đã googling và googling và tôi đã tìm thấy câu trả lời -> http://code.anjanesh.net/2007/12/python-lassmethods.html.

Nếu bạn lười nhấp vào nó. Giải thích của tôi ngắn hơn và bên dưới. :)

Trong PHP (có thể không phải tất cả các bạn đều biết PHP, nhưng ngôn ngữ này rất thẳng về phía mọi người nên hiểu những gì tôi đang nói) chúng tôi có các biến tĩnh như thế này:

Logger.debug( "this is some annoying message I only want to see while debugging" )

Đầu ra sẽ trong cả hai trường hợp 20.

Tuy nhiên, trong Python, chúng ta có thể thêm công cụ trang trí @ClassMethod và do đó có thể có đầu ra 10 và 20 tương ứng. Thí dụ:

Logger.debug( "this is some annoying message I only want to see while debugging" )

Thông minh, không?

Đã trả lời ngày 22 tháng 2 năm 2010 lúc 13:27Feb 22, 2010 at 13:27

1

Phương pháp lớp cung cấp "đường ngữ nghĩa" (không biết thuật ngữ này được sử dụng rộng rãi) - hoặc "sự tiện lợi ngữ nghĩa".

Ví dụ: Bạn có một tập hợp các lớp đại diện cho các đối tượng. Bạn có thể muốn có phương thức lớp

class Logger :
    ''' Handles logging of debugging and error messages. '''

    DEBUG = 5
    INFO  = 4
    WARN  = 3
    ERROR = 2
    FATAL = 1
    _level = DEBUG

    def __init__( self ) :
        Logger._level = Logger.DEBUG

    @classmethod
    def isLevel( cls, level ) :
        return cls._level >= level

    @classmethod
    def debug( cls, message ) :
        if cls.isLevel( Logger.DEBUG ) :
            print "DEBUG:  " + message

    @classmethod
    def info( cls, message ) :
        if cls.isLevel( Logger.INFO ) :
            print "INFO :  " + message

    @classmethod
    def warn( cls, message ) :
        if cls.isLevel( Logger.WARN ) :
            print "WARN :  " + message

    @classmethod
    def error( cls, message ) :
        if cls.isLevel( Logger.ERROR ) :
            print "ERROR:  " + message

    @classmethod
    def fatal( cls, message ) :
        if cls.isLevel( Logger.FATAL ) :
            print "FATAL:  " + message

class Logger :
    ''' Handles logging of debugging and error messages. '''

    DEBUG = 5
    INFO  = 4
    WARN  = 3
    ERROR = 2
    FATAL = 1
    _level = DEBUG

    def __init__( self ) :
        Logger._level = Logger.DEBUG

    @classmethod
    def isLevel( cls, level ) :
        return cls._level >= level

    @classmethod
    def debug( cls, message ) :
        if cls.isLevel( Logger.DEBUG ) :
            print "DEBUG:  " + message

    @classmethod
    def info( cls, message ) :
        if cls.isLevel( Logger.INFO ) :
            print "INFO :  " + message

    @classmethod
    def warn( cls, message ) :
        if cls.isLevel( Logger.WARN ) :
            print "WARN :  " + message

    @classmethod
    def error( cls, message ) :
        if cls.isLevel( Logger.ERROR ) :
            print "ERROR:  " + message

    @classmethod
    def fatal( cls, message ) :
        if cls.isLevel( Logger.FATAL ) :
            print "FATAL:  " + message

class Logger :
    ''' Handles logging of debugging and error messages. '''

    DEBUG = 5
    INFO  = 4
    WARN  = 3
    ERROR = 2
    FATAL = 1
    _level = DEBUG

    def __init__( self ) :
        Logger._level = Logger.DEBUG

    @classmethod
    def isLevel( cls, level ) :
        return cls._level >= level

    @classmethod
    def debug( cls, message ) :
        if cls.isLevel( Logger.DEBUG ) :
            print "DEBUG:  " + message

    @classmethod
    def info( cls, message ) :
        if cls.isLevel( Logger.INFO ) :
            print "INFO :  " + message

    @classmethod
    def warn( cls, message ) :
        if cls.isLevel( Logger.WARN ) :
            print "WARN :  " + message

    @classmethod
    def error( cls, message ) :
        if cls.isLevel( Logger.ERROR ) :
            print "ERROR:  " + message

    @classmethod
    def fatal( cls, message ) :
        if cls.isLevel( Logger.FATAL ) :
            print "FATAL:  " + message

def logAll() :
    Logger.debug( "This is a Debug message." )
    Logger.info ( "This is a Info  message." )
    Logger.warn ( "This is a Warn  message." )
    Logger.error( "This is a Error message." )
    Logger.fatal( "This is a Fatal message." )

if __name__ == '__main__' :

    print "Should see all DEBUG and higher"
    Logger._level = Logger.DEBUG
    logAll()

    print "Should see all ERROR and higher"
    Logger._level = Logger.ERROR
    logAll()

Đã trả lời ngày 17 tháng 8 năm 2010 lúc 15:53Aug 17, 2010 at 15:53

PierrepierrePierre

1192 Huy hiệu bạc3 Huy hiệu đồng2 silver badges3 bronze badges

2

Nếu bạn không phải là "lập trình viên bằng cách đào tạo", điều này sẽ giúp:

Tôi nghĩ rằng tôi đã hiểu những lời giải thích kỹ thuật ở trên và các nơi khác trên mạng, nhưng tôi luôn bị bỏ lại với một câu hỏi "tốt đẹp, nhưng tại sao tôi cần nó? Trường hợp sử dụng thực tế là gì?". Và bây giờ cuộc sống đã cho tôi một ví dụ điển hình đã làm rõ tất cả:

Tôi đang sử dụng nó để kiểm soát biến chia sẻ toàn cầu được chia sẻ giữa các trường hợp của một lớp được khởi tạo bởi mô-đun đa luồng. Trong ngôn ngữ nhân đạo, tôi đang chạy nhiều tác nhân tạo ra các ví dụ cho việc học sâu song song. (Hãy tưởng tượng nhiều người chơi chơi trò chơi Atari cùng một lúc và mỗi người lưu kết quả của trò chơi của họ vào một kho lưu trữ chung (biến chia sẻ)))

Tôi khởi tạo người chơi/đại lý với mã sau (trong mã chính/thực thi):

Logger.debug( "this is some annoying message I only want to see while debugging" )

• Nó tạo ra nhiều người chơi như có các lõi của bộ xử lý trên comp a3c_worker của tôi - là một lớp xác định tác nhân A3C_Workers - là danh sách các trường hợp của lớp đó (tức là mỗi trường hợp là một người chơi/tác nhân)

Bây giờ tôi muốn biết có bao nhiêu trò chơi đã được chơi trên tất cả các người chơi/tác nhân do đó trong định nghĩa A3C_Worker, tôi xác định biến sẽ được chia sẻ trên tất cả các trường hợp:

Logger.debug( "this is some annoying message I only want to see while debugging" )

Bây giờ khi các công nhân kết thúc các trò chơi của họ, họ tăng số lượng 1 mỗi cho mỗi trò chơi kết thúc

Vào cuối thế hệ ví dụ của tôi, tôi đã đóng các trường hợp nhưng biến được chia sẻ đã chỉ định tổng số trò chơi được chơi. Vì vậy, khi tôi quay lại, tổng số tập ban đầu của tôi là tổng số trước đó. Nhưng tôi cần số lượng đó để thể hiện giá trị đó cho mỗi lần chạy riêng lẻ

Để sửa chữa mà tôi đã chỉ định:

Logger.debug( "this is some annoying message I only want to see while debugging" )

Hơn trong mã thực thi, tôi chỉ gọi:

Logger.debug( "this is some annoying message I only want to see while debugging" )

Lưu ý rằng đó là một cuộc gọi đến lớp tổng thể không phải là bất kỳ trường hợp nào của nó. Do đó, nó sẽ đặt bộ đếm của tôi thành 0 cho mọi tác nhân mới mà tôi bắt đầu từ bây giờ.

Sử dụng định nghĩa phương thức thông thường

def logAll() :
    Logger.debug( "This is a Debug message." )
    Logger.info ( "This is a Info  message." )
    Logger.warn ( "This is a Warn  message." )
    Logger.error( "This is a Error message." )
    Logger.fatal( "This is a Fatal message." )

if __name__ == '__main__' :

    print "Should see all DEBUG and higher"
    Logger._level = Logger.DEBUG
    logAll()

    print "Should see all ERROR and higher"
    Logger._level = Logger.ERROR
    logAll()

Arudzinska

Phù hiệu vàng 3,0041 Huy hiệu bạc28 Huy hiệu đồng1 gold badge17 silver badges28 bronze badges

Đã trả lời ngày 20 tháng 10 năm 2020 lúc 12:37Oct 20, 2020 at 12:37

SEBTACSEBTACsebtac

4135 Huy hiệu bạc7 Huy hiệu Đồng5 silver badges7 bronze badges

Điều mà tôi chỉ đánh tôi, đến từ Ruby, đó là phương pháp được gọi là phương pháp lớp và phương pháp được gọi là một hàm có nghĩa là ý nghĩa ngữ nghĩa cho tham số đầu tiên của nó, được truyền lặng lẽ khi hàm được gọi là một phương pháp một đối tượng (tức là

def logAll() :
    Logger.debug( "This is a Debug message." )
    Logger.info ( "This is a Info  message." )
    Logger.warn ( "This is a Warn  message." )
    Logger.error( "This is a Error message." )
    Logger.fatal( "This is a Fatal message." )

if __name__ == '__main__' :

    print "Should see all DEBUG and higher"
    Logger._level = Logger.DEBUG
    logAll()

    print "Should see all ERROR and higher"
    Logger._level = Logger.ERROR
    logAll()

Thông thường đối tượng đó phải là một ví dụ nhưng người trang trí phương thức

class Logger :
    ''' Handles logging of debugging and error messages. '''

    DEBUG = 5
    INFO  = 4
    WARN  = 3
    ERROR = 2
    FATAL = 1
    _level = DEBUG

    def __init__( self ) :
        Logger._level = Logger.DEBUG

    @classmethod
    def isLevel( cls, level ) :
        return cls._level >= level

    @classmethod
    def debug( cls, message ) :
        if cls.isLevel( Logger.DEBUG ) :
            print "DEBUG:  " + message

    @classmethod
    def info( cls, message ) :
        if cls.isLevel( Logger.INFO ) :
            print "INFO :  " + message

    @classmethod
    def warn( cls, message ) :
        if cls.isLevel( Logger.WARN ) :
            print "WARN :  " + message

    @classmethod
    def error( cls, message ) :
        if cls.isLevel( Logger.ERROR ) :
            print "ERROR:  " + message

    @classmethod
    def fatal( cls, message ) :
        if cls.isLevel( Logger.FATAL ) :
            print "FATAL:  " + message

Bởi vì nó chỉ là một hàm, nó chỉ có thể được khai báo một lần trong bất kỳ phạm vi nào (nghĩa là định nghĩa

def logAll() :
    Logger.debug( "This is a Debug message." )
    Logger.info ( "This is a Info  message." )
    Logger.warn ( "This is a Warn  message." )
    Logger.error( "This is a Error message." )
    Logger.fatal( "This is a Fatal message." )

if __name__ == '__main__' :

    print "Should see all DEBUG and higher"
    Logger._level = Logger.DEBUG
    logAll()

    print "Should see all ERROR and higher"
    Logger._level = Logger.ERROR
    logAll()

Xem xét điều này:

Logger.debug( "this is some annoying message I only want to see while debugging" )

Bạn có thể gọi

def logAll() :
    Logger.debug( "This is a Debug message." )
    Logger.info ( "This is a Info  message." )
    Logger.warn ( "This is a Warn  message." )
    Logger.error( "This is a Error message." )
    Logger.fatal( "This is a Fatal message." )

if __name__ == '__main__' :

    print "Should see all DEBUG and higher"
    Logger._level = Logger.DEBUG
    logAll()

    print "Should see all ERROR and higher"
    Logger._level = Logger.ERROR
    logAll()

Logger.debug( "this is some annoying message I only want to see while debugging" )

Nhưng không phải trên một lớp học:

Logger.debug( "this is some annoying message I only want to see while debugging" )

Bây giờ thêm

class Logger :
    ''' Handles logging of debugging and error messages. '''

    DEBUG = 5
    INFO  = 4
    WARN  = 3
    ERROR = 2
    FATAL = 1
    _level = DEBUG

    def __init__( self ) :
        Logger._level = Logger.DEBUG

    @classmethod
    def isLevel( cls, level ) :
        return cls._level >= level

    @classmethod
    def debug( cls, message ) :
        if cls.isLevel( Logger.DEBUG ) :
            print "DEBUG:  " + message

    @classmethod
    def info( cls, message ) :
        if cls.isLevel( Logger.INFO ) :
            print "INFO :  " + message

    @classmethod
    def warn( cls, message ) :
        if cls.isLevel( Logger.WARN ) :
            print "WARN :  " + message

    @classmethod
    def error( cls, message ) :
        if cls.isLevel( Logger.ERROR ) :
            print "ERROR:  " + message

    @classmethod
    def fatal( cls, message ) :
        if cls.isLevel( Logger.FATAL ) :
            print "FATAL:  " + message

Logger.error( "Wow, something really awful happened." )

Gọi một ví dụ bây giờ vượt qua lớp học của nó:

Logger.error( "Wow, something really awful happened." )

cũng như việc kêu gọi một lớp học:

Logger.error( "Wow, something really awful happened." )

Chỉ có quy ước chỉ ra rằng chúng tôi sử dụng

def logAll() :
    Logger.debug( "This is a Debug message." )
    Logger.info ( "This is a Info  message." )
    Logger.warn ( "This is a Warn  message." )
    Logger.error( "This is a Error message." )
    Logger.fatal( "This is a Fatal message." )

if __name__ == '__main__' :

    print "Should see all DEBUG and higher"
    Logger._level = Logger.DEBUG
    logAll()

    print "Should see all ERROR and higher"
    Logger._level = Logger.ERROR
    logAll()

def logAll() :
    Logger.debug( "This is a Debug message." )
    Logger.info ( "This is a Info  message." )
    Logger.warn ( "This is a Warn  message." )
    Logger.error( "This is a Error message." )
    Logger.fatal( "This is a Fatal message." )

if __name__ == '__main__' :

    print "Should see all DEBUG and higher"
    Logger._level = Logger.DEBUG
    logAll()

    print "Should see all ERROR and higher"
    Logger._level = Logger.ERROR
    logAll()

def logAll() :
    Logger.debug( "This is a Debug message." )
    Logger.info ( "This is a Info  message." )
    Logger.warn ( "This is a Warn  message." )
    Logger.error( "This is a Error message." )
    Logger.fatal( "This is a Fatal message." )

if __name__ == '__main__' :

    print "Should see all DEBUG and higher"
    Logger._level = Logger.DEBUG
    logAll()

    print "Should see all ERROR and higher"
    Logger._level = Logger.ERROR
    logAll()

Tương phản với Ruby:

Logger.error( "Wow, something really awful happened." )

Phương pháp lớp Python chỉ là một hàm được trang trí và bạn có thể sử dụng các kỹ thuật tương tự để tạo ra các nhà trang trí của riêng bạn. Một phương pháp được trang trí kết thúc phương pháp thực (trong trường hợp

class Logger :
    ''' Handles logging of debugging and error messages. '''

    DEBUG = 5
    INFO  = 4
    WARN  = 3
    ERROR = 2
    FATAL = 1
    _level = DEBUG

    def __init__( self ) :
        Logger._level = Logger.DEBUG

    @classmethod
    def isLevel( cls, level ) :
        return cls._level >= level

    @classmethod
    def debug( cls, message ) :
        if cls.isLevel( Logger.DEBUG ) :
            print "DEBUG:  " + message

    @classmethod
    def info( cls, message ) :
        if cls.isLevel( Logger.INFO ) :
            print "INFO :  " + message

    @classmethod
    def warn( cls, message ) :
        if cls.isLevel( Logger.WARN ) :
            print "WARN :  " + message

    @classmethod
    def error( cls, message ) :
        if cls.isLevel( Logger.ERROR ) :
            print "ERROR:  " + message

    @classmethod
    def fatal( cls, message ) :
        if cls.isLevel( Logger.FATAL ) :
            print "FATAL:  " + message

Chú thích: Tôi đã viết điều này sau khi một cuộc đụng độ giữa một lớp học và phương pháp thể hiện đã khơi dậy sự tò mò của tôi. Tôi khác xa với một chuyên gia Python và muốn nhận xét nếu bất kỳ điều này là sai.

marc_s

716K172 Huy hiệu vàng1315 Huy hiệu bạc1434 Huy hiệu đồng172 gold badges1315 silver badges1434 bronze badges

Đã trả lời ngày 24 tháng 3 năm 2017 lúc 20:45Mar 24, 2017 at 20:45

STARFREMFRYstarfry

8.7856 Huy hiệu vàng61 Huy hiệu bạc93 Huy hiệu Đồng6 gold badges61 silver badges93 bronze badges

3

Đây là một chủ đề thú vị. Tôi nhận ra rằng Python ClassMethod hoạt động giống như một người độc thân chứ không phải là một nhà máy (trả về một trường hợp sản xuất của một lớp). Lý do đó là một singleton là có một đối tượng chung được tạo ra (từ điển) nhưng chỉ một lần cho lớp nhưng được chia sẻ bởi tất cả các trường hợp.

Để minh họa điều này ở đây là một ví dụ. Lưu ý rằng tất cả các trường hợp có một tham chiếu đến từ điển duy nhất. Đây không phải là mô hình nhà máy như tôi hiểu nó. Điều này có lẽ rất độc đáo đối với Python.

Logger.error( "Wow, something really awful happened." )

Đã trả lời ngày 7 tháng 9 năm 2012 lúc 5:06Sep 7, 2012 at 5:06

Peter Moorepeter MoorePeter Moore

1.44513 huy hiệu bạc28 Huy hiệu đồng13 silver badges28 bronze badges

Tôi đã tự hỏi mình cùng một câu hỏi vài lần. Và mặc dù những người ở đây đã cố gắng giải thích nó, nhưng câu trả lời tốt nhất (và đơn giản nhất) tôi đã tìm thấy là mô tả của phương pháp lớp trong tài liệu Python.

Cũng có tham chiếu đến phương pháp tĩnh. Và trong trường hợp ai đó đã biết các phương thức thể hiện (mà tôi giả sử), câu trả lời này có thể là phần cuối cùng để kết hợp tất cả lại với nhau ...

Xa hơn và sâu hơn về chủ đề này cũng có thể được tìm thấy trong tài liệu: phân cấp loại tiêu chuẩn (cuộn xuống phần Phương thức thể hiện)

Đã trả lời ngày 14 tháng 10 năm 2014 lúc 7:07Oct 14, 2014 at 7:07

Dee'KejDee'KejDee'Kej

1.1501 huy hiệu vàng9 Huy hiệu bạc1 gold badge9 silver badges8 bronze badges

class Logger :
    ''' Handles logging of debugging and error messages. '''

    DEBUG = 5
    INFO  = 4
    WARN  = 3
    ERROR = 2
    FATAL = 1
    _level = DEBUG

    def __init__( self ) :
        Logger._level = Logger.DEBUG

    @classmethod
    def isLevel( cls, level ) :
        return cls._level >= level

    @classmethod
    def debug( cls, message ) :
        if cls.isLevel( Logger.DEBUG ) :
            print "DEBUG:  " + message

    @classmethod
    def info( cls, message ) :
        if cls.isLevel( Logger.INFO ) :
            print "INFO :  " + message

    @classmethod
    def warn( cls, message ) :
        if cls.isLevel( Logger.WARN ) :
            print "WARN :  " + message

    @classmethod
    def error( cls, message ) :
        if cls.isLevel( Logger.ERROR ) :
            print "ERROR:  " + message

    @classmethod
    def fatal( cls, message ) :
        if cls.isLevel( Logger.FATAL ) :
            print "FATAL:  " + message

Logger.error( "Wow, something really awful happened." )

Sau đó trong một tập tin khác:

Logger.error( "Wow, something really awful happened." )

Truy cập Inst.x sẽ cung cấp cùng một giá trị như cài đặt ['x'].

Đã trả lời ngày 15 tháng 11 năm 2019 lúc 14:19Nov 15, 2019 at 14:19

psilocybinpsilocybinpsilocybin

1.0316 huy hiệu bạc24 Huy hiệu đồng6 silver badges24 bronze badges

Một lớp xác định một tập hợp các trường hợp, tất nhiên. Và các phương pháp của một lớp hoạt động trên các trường hợp riêng lẻ. Các phương thức lớp (và biến) là một nơi để treo thông tin khác có liên quan đến tập hợp các phiên bản trên tất cả.

Ví dụ: nếu lớp của bạn định nghĩa một tập hợp học sinh, bạn có thể muốn các biến hoặc phương thức lớp xác định những thứ như tập hợp học sinh có thể là thành viên của.

Bạn cũng có thể sử dụng các phương thức lớp để xác định các công cụ để làm việc trên toàn bộ tập hợp. Ví dụ: student.all_of_em () có thể trả về tất cả các sinh viên đã biết. Rõ ràng nếu tập hợp các trường hợp của bạn có nhiều cấu trúc hơn là một tập hợp, bạn có thể cung cấp các phương thức lớp để biết về cấu trúc đó. Học sinh.all_of_em (Lớp = 'Junenson')

Các kỹ thuật như thế này có xu hướng dẫn đến việc lưu trữ các thành viên của tập hợp các trường hợp vào các cấu trúc dữ liệu bắt nguồn từ các biến lớp. Bạn cần phải chăm sóc để tránh làm nản lòng bộ sưu tập rác sau đó.

Đã trả lời ngày 8 tháng 9 năm 2016 lúc 1:29Sep 8, 2016 at 1:29

Ben Hydeben HydeBen Hyde

1.3939 huy hiệu bạc13 huy hiệu đồng9 silver badges13 bronze badges

Các khái niệm lớp học và đối tượng rất hữu ích trong việc tổ chức mọi thứ. Đúng là tất cả các hoạt động có thể được thực hiện bằng phương thức cũng có thể được thực hiện bằng cách sử dụng hàm tĩnh.

Chỉ cần nghĩ về một kịch bản, để xây dựng một hệ thống cơ sở dữ liệu sinh viên để duy trì chi tiết của sinh viên. Bạn cần có chi tiết về học sinh, giáo viên và nhân viên. Bạn cần xây dựng các chức năng để tính phí, tiền lương, điểm, vv Phí và nhãn hiệu chỉ được áp dụng cho sinh viên, tiền lương chỉ được áp dụng cho nhân viên và giáo viên. Vì vậy, nếu bạn tạo các lớp riêng biệt cho mọi loại người, mã sẽ được tổ chức.

Dominik

1.3262 huy hiệu vàng16 Huy hiệu bạc36 Huy hiệu đồng2 gold badges16 silver badges36 bronze badges

Đã trả lời ngày 19 tháng 8 năm 2020 lúc 6:42Aug 19, 2020 at 6:42

Khi nào tôi nên sử dụng phương pháp lớp trong Python?

Khi nào bạn sẽ sử dụng một phương pháp lớp?

Tại sao bạn sẽ sử dụng một phương pháp lớp?

Lợi ích của phương pháp lớp trong Python là gì?