Home / Questions / 4626
Accepted
Andrés Muñoz
Asked: 2020-02-24 01:36:13 +0800 CST 2020-02-24 01:36:13 +0800 CST

What is @classmethod for in python?

  • 772

I have the following class and I would like to know what the @classmethodabove of each method of the class is for.

class User(db.Model):
    name = db.StringProperty(required = True)
    pw_hash = db.StringProperty(required = True)
    email = db.StringProperty()

    @classmethod
    def by_id(cls, uid):
        return User.get_by_id(uid, parent = users_key())

    @classmethod
    def by_name(cls, name):
        u = User.all().filter('name =', name).get()
        return u

    @classmethod
    def register(cls, name, pw, email = None):
        pw_hash = make_pw_hash(name, pw)
        return User(parent = users_key(),
                    name = name,
                    pw_hash = pw_hash,
                    email = email)

    @classmethod
    def login(cls, name, pw):
        u = cls.by_name(name)
        if u and valid_pw(name, pw, u.pw_hash):
            return u

This class is used to create an entity for the App Engine datastore.

python

2 Answers

  1. Best Answer

    @classmethod, it will receive the class as the first argument, in case it needs to be used for something. It is usually called clsby convention. In this example all methods have it def by_name(cls, name):. For this purpose, C++ has overloading as a function, but Python doesn't, so this is where it applies classmethod. In short: When this method is called, it is passed to the class as the first argument instead of the instance of that class (as we normally do with methods). This means that you can use the class and its properties inside that method without having to instantiate the class. Example:

     class Clase
    @classmethod
    def metodo2(cls, arg):
        pass

Clase.metodo2("argumento")

    A practical example:

    from enum import Enum


class Tamano(Enum):  # Una enumeracion es simplemente ponerle nombre a numeros
    normal = 1
    familiar = 2
    xl = 3


class Pizza:
    def __init__(self, precio, tamano, ingredientes):
        self.precio = precio
        self.tamano = tamano
        self.ingredientes = ingredientes

    @classmethod
    def napolitana(cls, tamano):
        precio_napolitana = 8990 * tamano
        ingredientes = ['Queso', 'Oregano', 'Tomate']
        # Instanciamos 'cls' que es la clase Pizza
        return cls(precio_napolitana, tamano, ingredientes)


if __name__ == '__main__':
    # Puedo crear pizzas 'a mano':
    hawaiana = Pizza(9990, Tamano.normal, ['Tomate', 'Jamon', 'Pina'])

    # Creamos una pizza con nuestro metodo de clase
    napolitana = Pizza.napolitana(Tamano.familiar)
    • 8

  2. To complete @eduardo-munizaga 's answer , what you see in this Entity creation is a kind of implementation of the well-known Singleton pattern . Instead of creating instances, you are directly using the class, with its attributes and methods.

    But it's still a class, so subclasses can be derived that overload attributes and methods. Specifically, it Userderives from db.Model, where it will look for its missing attributes and methods. For example, when the method registerreturns an instance User:

    @classmethod
def register(cls, name, pw, email = None):
    pw_hash = make_pw_hash(name, pw)
    return User(parent = users_key(),
                name = name,
                pw_hash = pw_hash,
                email = email)

    This is known as an instance factory . If you parse it right, your class Userdoesn't have any method __init__to create this instance, so it would be using the one inherited from db.Modelwhich is where the magic is done.

    • 6