[python] 파이썬의 정적 메소드?

나는 Steven이 실제로 옳다고 생각한다 . 원래 질문에 대답하려면 클래스 메소드를 설정하려면 첫 번째 인수가 호출 인스턴스가 아니라고 가정하고 클래스에서 메소드 만 호출해야합니다.

(이 답변은 Python 3.x를 나타냅니다. Python 2.x에서는 TypeError클래스 자체에서 메서드를 호출 할 수 있습니다.)

예를 들면 다음과 같습니다.

class Dog:
    count = 0 # this is a class variable
    dogs = [] # this is a class variable

    def __init__(self, name):
        self.name = name #self.name is an instance variable
        Dog.count += 1
        Dog.dogs.append(name)

    def bark(self, n): # this is an instance method
        print("{} says: {}".format(self.name, "woof! " * n))

    def rollCall(n): #this is implicitly a class method (see comments below)
        print("There are {} dogs.".format(Dog.count))
        if n >= len(Dog.dogs) or n < 0:
            print("They are:")
            for dog in Dog.dogs:
                print("  {}".format(dog))
        else:
            print("The dog indexed at {} is {}.".format(n, Dog.dogs[n]))

fido = Dog("Fido")
fido.bark(3)
Dog.rollCall(-1)
rex = Dog("Rex")
Dog.rollCall(0)

이 코드에서 “rollCall”메소드는 첫 번째 인수가 인스턴스가 아니라고 가정합니다 (클래스 대신 인스턴스가 호출 한 것처럼). “rollCall”이 인스턴스가 아닌 클래스에서 호출되는 한 코드는 정상적으로 작동합니다. 인스턴스에서 “rollCall”을 호출하려고하면 다음과 같이됩니다.

rex.rollCall(-1)

그러나 자체와 -1이라는 두 개의 인수를 보내므로 “rollCall”은 하나의 인수 만 허용하도록 정의되므로 예외가 발생합니다.

또한, rex.rollCall ()은 정확한 개수의 인수를 보내지 만, 함수가 n을 숫자로 기대할 때 n이 Dog 인스턴스 (즉, rex)를 나타내므로 예외가 발생합니다.

여기가 데코레이션이 온 곳입니다. “rollCall”메소드 앞에

@staticmethod

그런 다음 메소드가 정적임을 명시 적으로 명시하여 인스턴스에서 메소드를 호출 할 수도 있습니다. 지금,

rex.rollCall(-1)

작동 할 것이다. 메소드 정의 앞에 @staticmethod를 삽입하면 인스턴스가 인수로 전송되지 않습니다.

@staticmethod 줄을 주석 처리하지 않고 다음 코드를 시도하여이를 확인할 수 있습니다.

class Dog:
    count = 0 # this is a class variable
    dogs = [] # this is a class variable

    def __init__(self, name):
        self.name = name #self.name is an instance variable
        Dog.count += 1
        Dog.dogs.append(name)

    def bark(self, n): # this is an instance method
        print("{} says: {}".format(self.name, "woof! " * n))

    @staticmethod
    def rollCall(n):
        print("There are {} dogs.".format(Dog.count))
        if n >= len(Dog.dogs) or n < 0:
            print("They are:")
            for dog in Dog.dogs:
                print("  {}".format(dog))
        else:
            print("The dog indexed at {} is {}.".format(n, Dog.dogs[n]))


fido = Dog("Fido")
fido.bark(3)
Dog.rollCall(-1)
rex = Dog("Rex")
Dog.rollCall(0)
rex.rollCall(-1)

답변

>>> class C:
...     @staticmethod
...     def hello():
...             print "Hello World"
...
>>> C.hello()
Hello World

class ClassName(object):

    @staticmethod
    def static_method(kwarg1=None):
        '''return a value that is a function of kwarg1'''

class ClassName(object):

    def static_method(kwarg1=None):
        '''return a value that is a function of kwarg1'''

    static_method = staticmethod(static_method)

ClassName.static_method()

class ClassName(object):

    @classmethod
    def class_method(cls, kwarg1=None):
        '''return a value that is a function of the class and kwarg1'''

new_instance = ClassName.class_method()

new_dict = dict.fromkeys(['key1', 'key2'])

# garden.py
def trim(a):
    pass

def strip(a):
    pass

def bunch(a, b):
    pass

def _foo(foo):
    pass

class powertools(object):
    """
    Provides much regarded gardening power tools.
    """
    @staticmethod
    def answer_to_the_ultimate_question_of_life_the_universe_and_everything():
        return 42

    @staticmethod
    def random():
        return 13

    @staticmethod
    def promise():
        return True

def _bar(baz, quux):
    pass

class _Dice(object):
    pass

class _6d(_Dice):
    pass

class _12d(_Dice):
    pass

class _Smarter:
    pass

class _MagicalPonies:
    pass

class _Samurai:
    pass

class Foo(_6d, _Samurai):
    pass

class Bar(_12d, _Smarter, _MagicalPonies):
    pass

# tests.py
import unittest
import garden

class GardenTests(unittest.TestCase):
    pass

class PowertoolsTests(unittest.TestCase):
    pass

class FooTests(unittest.TestCase):
    pass

class BarTests(unittest.TestCase):
    pass

# interactive.py
from garden import trim, bunch, Foo

f = trim(Foo())
bunch(f, Foo())

# my_garden.py
import garden
from garden import powertools

class _Cowboy(garden._Samurai):
    def hit():
        return powertools.promise() and powertools.random() or 0

class Foo(_Cowboy, garden.Foo):
    pass

# utils.py
class socket(object):
    @staticmethod
    def check_if_port_available(port):
        pass

    @staticmethod
    def get_free_port(port)
        pass

class image(object):
    @staticmethod
    def to_rgb(image):
        pass

    @staticmethod
    def to_cmyk(image):
        pass

class Dog(object):
    def __init__(self, name):
        self.name = name

    def bark(self):
        if self.name == "Doggy":
            return barking_sound()
        else:
            return "yip yip"

def barking_sound():
    return "woof woof"