[Projeto] Código Comentado (Me ajuda a entender um pouco melhor)

class Contador:
    '''
    Classe que representa um contador.
    A instância mantém um contador específico, enquanto um contador global é compartilhado por todas as instâncias.
    '''

    contador_global = 0

#  Função do __init__

# Executado automaticamente ao criar uma instância

# Inicializa o estado individual do objeto

    def __init__(self):
        self.valor = 0

# self.valor

# É um atributo de instância

# Cada objeto possui seu próprio valor

# Alterar um não afeta os outros

    def __str__(self):
        return f'Contador: {self.valor}'
    
    # Define como o objeto será representado em texto.

    def incrementar(self):
        self.valor += 1

# Atua somente no objeto

# Modifica o estado interno (self.valor)

# Não interfere em outros contadores

    @classmethod
    def zerar_contador_global(cls):
        cls.contador_global = 0
        return 'Contador global foi zerado.'
    
# O método não opera sobre um objeto específico

# Ele atua sobre a classe como um todo

# O parâmetro cls representa a própria classe

# Reseta o valor compartilhado

# Afeta todas as instâncias, presentes e futuras

#1️⃣ A ideia central (guarde isso)

# Classe é o molde.
# Instância é o objeto criado a partir do molde.
# Objeto e instância, na prática, são a mesma coisa.

# O que muda é o ponto de vista:

# instância → termo técnico (algo foi instanciado)

# objeto → o que você usa no código

# 2️⃣ Analogia simples (forma física)
# Classe = planta da casa

# Ela define:

# quantos cômodos existem

# como eles funcionam

# o que cada parte pode fazer

# Mas não é uma casa de verdade.

# Planta da casa (classe)

# Instância / Objeto = casa construída

# Quando você constrói uma casa com a planta:

# casa1 = PlantaCasa()
# casa2 = PlantaCasa()


# Você tem:

# duas casas diferentes

# com a mesma estrutura

# mas estados independentes

# Casa 1 ≠ Casa 2

# 3️⃣ Trazendo isso para o código Contador
# A classe (o molde)
# class Contador:


# Aqui você não tem um contador real ainda.
# Você só descreveu:

# quais dados existirão

# quais comportamentos existirão

# Criando uma instância (o objeto real)
# c1 = Contador()


# Nesse momento:

# o Python cria um objeto na memória

# executa o __init__

# self passa a representar esse objeto

# Agora existe um contador de verdade.

# 4️⃣ self explicado sem mistério

# Quando você escreve:

# def incrementar(self):
    #self.valor += 1


# Leia mentalmente como:

# “Quando esse objeto específico chamar incrementar, aumente o valor dele.”

# Exemplo:

# c1.incrementar()


# Internamente o Python faz:

# Contador.incrementar(c1)


# Ou seja:

# self → c1

# 5️⃣ Por que dois objetos não se misturam?
# c1 = Contador()
# c2 = Contador()

# c1.incrementar()


# Situação na memória:

# Objeto	valor
# c1	1
# c2	0

# Cada objeto:

# tem sua própria cópia de valor

# não “enxerga” o estado do outro

# 6️⃣ Onde entra o atributo de classe?
# class Contador:
   #contador_global = 0


#Isso não pertence a nenhum objeto específico.

# É como:

# um quadro na parede da sala

# Todos veem o mesmo número

# Contador.contador_global


# Se mudar:

# Contador.contador_global = 10


# Todos os objetos “veem” esse novo valor.

# 7️⃣ Diferença prática (tabela mental)
# Conceito	O que é	Exemplo
# Classe	Molde	class Contador:
# Instância	Objeto criado	c1 = Contador()
# Objeto	Instância em uso	c1.incrementar()
# Atributo de instância	Dado individual	self.valor
# Atributo de classe	Dado compartilhado	contador_global
# self	Objeto atual	c1, c2
# cls	Classe	Contador
# 8️⃣ Um erro comum (e por que confunde)

# Pensar que:

# self = Contador


# ❌ Errado.

# O correto é:

# self = o objeto específico criado
# cls = a classe

# 9️⃣ Exercício mental rápido (muito importante)

# Leia essa linha:

# c1.incrementar()


# E pense assim:

# “O objeto c1 está pedindo para executar o comportamento incrementar definido no molde Contador.”

# Esse pensamento resolve 90% da confusão em POO.

# 10️⃣ Conclusão clara e direta

# Classe não faz nada sozinha

# Objeto é quem vive, muda, executa

# self sempre aponta para quem chamou

# cls aponta para o molde

# Se quiser, no próximo passo posso:

# desenhar isso como se fosse memória

# simular chamadas linha por linha

# comparar POO com código procedural

# mostrar erros comuns e como evitá-los

# Você está entendendo — só está organizando as peças.