Python Academy · Aula

@classmethod e @staticmethod

Defina métodos de classe e métodos estáticos com os decoradores apropriados.

@classmethod e @staticmethod é uma aula grátis de Python Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Python Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Python Academy inclui 4 aulas no total.

Introdução

@classmethod recebe a classe como primeiro argumento. @staticmethod não recebe nada de especial. Ambos são definidos na classe.

Instância vs classe vs estático

Métodos regulares recebem self. Métodos de classe recebem cls. Métodos estáticos não recebem nenhum dos dois. Escolha com base nos dados de que você precisa.

class Demo:
    def instance(self): return 'instance'
    @classmethod
    def class_m(cls): return f'class: {cls.__name__}'
    @staticmethod
    def static_m(): return 'static'
d = Demo()
print(d.instance())
print(Demo.class_m())
print(Demo.static_m())

@classmethod como fábrica

O uso mais comum são construtores alternativos. Date.from_string('2024-01-15') em vez de fazer a análise em __init__.

class Date:
    def __init__(self, y,m,d): self.y,self.m,self.d=y,m,d
    @classmethod
    def today(cls):
        from datetime import date
        d = date.today()
        return cls(d.year, d.month, d.day)
    def __repr__(self): return f'{self.y}-{self.m}-{self.d}'
print(Date.today())

@classmethod com herança

cls em um método de classe se refere à subclasse real, não à classe-base. Isso faz com que os métodos-fábrica funcionem corretamente com subclasses.

class Animal:
    @classmethod
    def create(cls, name):
        return cls(name)
    def __init__(self, name): self.name = name
class Dog(Animal): pass
d = Dog.create('Rex')
print(type(d).__name__, d.name)

@staticmethod para utilitários

Métodos estáticos são funções regulares agrupadas logicamente com uma classe. Eles não podem acessar dados da classe nem da instância.

class MathHelper:
    @staticmethod
    def clamp(value, lo, hi):
        return max(lo, min(hi, value))
print(MathHelper.clamp(15, 0, 10))
print(MathHelper.clamp(-5, 0, 10))

@staticmethod vs função de módulo

Se uma função não precisa da classe, ela poderia ser uma função no nível do módulo. Use @staticmethod apenas quando ela pertencer logicamente à classe.

class Validator:
    @staticmethod
    def is_email(s): return '@' in s and '.' in s
print(Validator.is_email('user@example.com'))
print(Validator.is_email('not-an-email'))

Chamando a partir de uma instância

Você pode chamar @classmethod e @staticmethod em instâncias, mas o comportamento de cls e da ausência do primeiro argumento não muda.

class C:
    @classmethod
    def who(cls): return cls.__name__
    @staticmethod
    def pi(): return 3.14
c = C()
print(c.who())
print(c.pi())

Método de classe para singletons

Métodos de classe podem impor padrões singleton verificando se uma instância já existe.

class Singleton:
    _instance = None
    @classmethod
    def get(cls):
        if cls._instance is None:
            cls._instance = cls()
        return cls._instance
a = Singleton.get()
b = Singleton.get()
print(a is b)

Substituindo métodos de classe

Uma subclasse pode substituir um método de classe. cls será então a subclasse, mantendo o polimorfismo.

class Base:
    @classmethod
    def info(cls): return f'{cls.__name__} info'
class Child(Base): pass
print(Base.info())
print(Child.info())

Verificação de tipo com cls

Dentro de um método de classe, cls é a classe real. Use cls() para criar instâncias — não codifique diretamente o nome da classe.

class Shape:
    @classmethod
    def make(cls):
        return cls()  # NOT Shape()
class Square(Shape): pass
print(type(Square.make()).__name__)

Combinando com @property

Um valor armazenado em cache no nível da classe pode combinar @classmethod e um atributo de classe para o armazenamento em cache compartilhado pela classe.

class Config:
    _data = None
    @classmethod
    def load(cls):
        if cls._data is None:
            cls._data = {'debug': True}
        return cls._data
print(Config.load())

Verificação rápida

O que é cls em um @classmethod?

Recapitulação

@classmethod recebe cls: use-o para fábricas, construtores alternativos e singletons. @staticmethod não recebe nada: use-o para utilitários. cls é a classe real (ou subclasse).

Continue

Excelente progresso! Continue para dominar o próximo conceito.

Perguntas Frequentes

A aula “@classmethod e @staticmethod” é grátis?

Sim — o texto completo de “@classmethod e @staticmethod” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Python Academy, atualize para CoddyKit PRO. O curso de Python Academy inclui 4 aulas no total.

O que vou aprender em “@classmethod e @staticmethod”?

Defina métodos de classe e métodos estáticos com os decoradores apropriados. Você pratica Python Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Python Academy?

Nenhuma experiência prévia é necessária. Python Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “@classmethod e @staticmethod”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Python Academy?

Sim. Cada aula de Python Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Python Academy