Какой пример используется для метода класса Python?

Ответ 1

Вспомогательные методы для инициализации:

class MyStream(object):

    @classmethod
    def from_file(cls, filepath, ignore_comments=False):    
        with open(filepath, 'r') as fileobj:
            for obj in cls(fileobj, ignore_comments):
                yield obj

    @classmethod
    def from_socket(cls, socket, ignore_comments=False):
        raise NotImplemented # Placeholder until implemented

    def __init__(self, iterable, ignore_comments=False):
       ...

Ответ 2

Ну __new__ - довольно важный класс. Это где примеры обычно происходят из

поэтому dict() вызывает dict.__new__, конечно, но есть еще один удобный способ иногда делать dicts, что является классом method dict.fromkeys()

например.

>>> dict.fromkeys("12345")
{'1': None, '3': None, '2': None, '5': None, '4': None}

Ответ 3

Я не знаю, что-то вроде методов конструктора named?

class UniqueIdentifier(object):

    value = 0

    def __init__(self, name):
        self.name = name

    @classmethod
    def produce(cls):
        instance = cls(cls.value)
        cls.value += 1
        return instance

class FunkyUniqueIdentifier(UniqueIdentifier):

    @classmethod
    def produce(cls):
        instance = super(FunkyUniqueIdentifier, cls).produce()
        instance.name = "Funky %s" % instance.name
        return instance

Использование:

>>> x = UniqueIdentifier.produce()
>>> y = FunkyUniqueIdentifier.produce()
>>> x.name
0
>>> y.name
Funky 1

Ответ 4

Я нахожу, что я чаще всего использую @classmethod для связывания фрагмента кода с классом, чтобы избежать создания глобальной функции, для случаев, когда мне не нужен экземпляр класса для использования кода.

Например, у меня может быть структура данных, которая учитывает только ключ, если он соответствует некоторому шаблону. Я могу использовать это изнутри и снаружи класса. Однако я не хочу создавать еще одну глобальную функцию:

def foo_key_is_valid(key):
    # code for determining validity here
    return valid

Я бы скорее сгруппировал этот код с классом, с которым он ассоциировался:

class Foo(object):

    @classmethod
    def is_valid(cls, key):
        # code for determining validity here
        return valid

    def add_key(self, key, val):
        if not Foo.is_valid(key):
            raise ValueError()
        ..

# lets me reuse that method without an instance, and signals that
# the code is closely-associated with the Foo class
Foo.is_valid('my key')

Ответ 5

Самая большая причина использования @classmethod заключается в альтернативном конструкторе, который предназначен для наследования. Это может быть очень полезно в полиморфизме. Пример:

class Shape(object):
    # this is an abstract class that is primarily used for inheritance defaults
    # here is where you would define classmethods that can be overridden by inherited classes
    @classmethod
    def from_square(cls, square):
        # return a default instance of cls
        return cls()

Обратите внимание, что Shape является абстрактным классом, который определяет classmethod from_square, так как Shape на самом деле не определен, он действительно не знает, как получить себя от Square, поэтому он просто возвращает экземпляр по умолчанию класса.

Унаследованные классы затем могут определять собственные версии этого метода:

class Square(Shape):
    def __init__(self, side=10):
        self.side = side

    @classmethod
    def from_square(cls, square):
        return cls(side=square.side)


class Rectangle(Shape):
    def __init__(self, length=10, width=10):
        self.length = length
        self.width = width

    @classmethod
    def from_square(cls, square):
        return cls(length=square.side, width=square.side)


class RightTriangle(Shape):
    def __init(self, a=10, b=10):
        self.a = a
        self.b = b
        self.c = ((a*a) + (b*b))**(.5)

    @classmethod
    def from_square(cls, square):
        return cls(a=square.length, b=square.width)


class Circle(Shape):
    def __init__(self, radius=10):
        self.radius = radius

    @classmethod
    def from_square(cls, square):
        return cls(radius=square.length/2)

Использование позволяет обрабатывать все эти неинтересные классы полиморфно

square = Square(3)
for polymorphic_class in (Square, Rectangle, RightTriangle, Circle):
    this_shape = polymorphic_class.from_square(square)

Все это прекрасно, и вы можете сказать, но почему я не могу использовать как @staticmethod для выполнения такого же полиморфного поведения:

class Circle(Shape):
    def __init__(self, radius=10):
        self.radius = radius

    @staticmethod
    def from_square(square):
        return Circle(radius=square.length/2)

Ответ заключается в том, что вы можете, но вы не получаете преимущества наследования, потому что Circle должен быть вызван явно в методе. Значение, если я вызываю его из унаследованного класса без переопределения, я все равно получаю Circle каждый раз.

Обратите внимание на то, что получается, когда я определяю другой класс формы, который на самом деле не имеет какой-либо пользовательской логики from_square:

class Hexagon(Shape):
    def __init__(self, side=10):
        self.side = side

    # note the absence of classmethod here, this will use from_square it inherits from shape

Здесь вы можете оставить @classmethod undefined, и он будет использовать логику от Shape.from_square, сохраняя при этом, кто cls и возвращает соответствующую форму.

square = Square(3)
for polymorphic_class in (Square, Rectangle, RightTriangle, Circle, Hexagon):
    this_shape = polymorphic_class.from_square(square)

Ответ 6

in class MyClass(object):
    '''
    classdocs
    '''
    obj=0
    x=classmethod
    def __init__(self):
        '''
        Constructor
        '''
        self.nom='lamaizi'
        self.prenom='anas'
        self.age=21
        self.ville='Casablanca'
if __name__:
    ob=MyClass()
    print(ob.nom)
    print(ob.prenom)
    print(ob.age)
    print(ob.ville)