Passo 1 de 8
Uma classe, vários objetos
Entenda a diferença entre uma classe e os objetos concretos criados a partir dela, identificando estado e comportamento.
Trilha de aprendizado · Nível 7 · Tutorial 1
Definir uma classe simples, inicializar seus objetos e implementar métodos que consultam ou alteram o estado de cada instância.
Uma classe, vários objetos
Entenda a diferença entre uma classe e os objetos concretos criados a partir dela, identificando estado e comportamento. 2 min
Definir a classe e inicializar um objeto
Reconheça a estrutura de uma classe simples, inicialize seus atributos com __init__ e crie uma instância pela chamada da classe. 4 min
Separar atributos de variáveis locais
Identifique quais valores permanecem associados a uma instância e diferencie atributos de parâmetros e variáveis locais. 3 min
Consultar o estado com métodos de instância
Defina um método que consulta a pontuação de uma instância e entenda como self identifica o objeto que recebeu a chamada. 3 min
Alterar o estado por uma operação
Implemente um método que recebe uma quantidade, atualiza a pontuação da instância e diferencie o efeito da operação de seu valor de retorno. 3 min
Acompanhar duas instâncias
Preveja e confira como chamadas intercaladas alteram separadamente o estado de dois objetos. 3 min
Reconhecer um atributo inexistente
Leia um AttributeError, identifique o atributo ausente e corrija a inconsistência que provocou a falha. 2 min
Aplicação final: dois contadores em ação
Implemente a classe ContadorPontos, execute uma sequência com duas instâncias e explique como cada objeto mantém sua própria pontuação. 4 min
Passo 1 de 8
Entenda a diferença entre uma classe e os objetos concretos criados a partir dela, identificando estado e comportamento.
Uma classe define um tipo de objeto ao reunir:
Uma instância é um objeto concreto criado a partir dessa definição. A mesma classe pode originar várias instâncias, cada uma com seu próprio estado.
Classes não substituem todas as funções: elas são úteis quando queremos representar elementos que combinam dados próprios e operações relacionadas a esses dados.
Observe que uma única definição serve de origem para dois contadores distintos.
A classe define o que os contadores têm e fazem; Ana e Bruno são objetos distintos, com identificação e pontuação próprias.
Nos próximos passos, usaremos a classe conceitual ContadorPontos.
Cada contador representa um participante. Seu estado é formado pelo nome e pela quantidade atual de pontos. Seus comportamentos permitem consultar a pontuação e adicionar novos pontos.
Se dois participantes tiverem contadores, uma alteração no contador de um deles deve afetar somente esse objeto.
Exemplo
Considere dois objetos criados a partir de ContadorPontos:
Adicionar 5 pontos ao contador de Ana muda seu estado para 15 pontos. O contador de Bruno continua com 25 pontos.
A definição é compartilhada como modelo, mas cada instância representa um contador concreto.
Dica
Ao avaliar um problema, pergunte: “Existem vários objetos do mesmo tipo, cada um com dados próprios e operações relacionadas?” Se sim, uma classe pode ser uma escolha adequada de modelagem.
Associe cada conceito ao elemento correspondente do exemplo ContadorPontos.
Toque em um item e depois no par correspondente.
Passo 2 de 8
Reconheça a estrutura de uma classe simples, inicialize seus atributos com init e crie uma instância pela chamada da classe.
Uma classe é definida com class, seguida do nome e de dois-pontos. Por convenção, nomes de classes usam CapWords, como ContadorPontos.
Dentro do bloco indentado, __init__ define como cada nova instância começa. Ele é chamado automaticamente quando a classe é usada para criar um objeto. Nesse método, self identifica a instância que está sendo inicializada.
O inicializador recebe um nome e configura a pontuação inicial como zero.
class ContadorPontos:
def __init__(self, nome):
self.nome = nome
self.pontos = 0Dica
As linhas de __init__ ficam dentro da classe, e as atribuições ficam dentro do método. A indentação mostra essa estrutura.
Para criar um objeto, chamamos a classe como se ela fosse uma função. O argumento "Lia" corresponde ao parâmetro nome. A referência ao objeto produzido pela chamada fica armazenada em jogador.
Durante esse processo, Python chama __init__ automaticamente. Ao final, a instância identificada por self tem nome "Lia" e pontuação 0.
Esta linha cria e inicializa uma instância.
jogador = ContadorPontos("Lia")A chamada da classe inicia o fluxo; __init__ configura o estado; a expressão fornece o objeto inicializado, cuja referência é guardada na variável.
A chamada da classe fornece o objeto; o papel de init é inicializar seu estado.
Atenção
__init__ apenas inicializa a instância e termina com retorno implícito None. Não escreva return self nem retorne outro valor. É a chamada da classe — como ContadorPontos("Lia") — que fornece o objeto.
Coloque os acontecimentos na ordem em que ocorrem em jogador = ContadorPontos("Lia").
Qual trecho define o inicializador planejado e cria uma instância chamada placar com o nome "Bia" e zero pontos?
Passo 3 de 8
Identifique quais valores permanecem associados a uma instância e diferencie atributos de parâmetros e variáveis locais.
Os valores atribuídos com self.nome e self.pontos passam a fazer parte do estado do objeto. Depois que a inicialização termina, você pode acessá-los escrevendo a variável que referencia o objeto, um ponto e o nome do atributo: jogador.nome e jogador.pontos.
A variável jogador referencia a instância criada. A notação de ponto permite consultar os valores que ficaram associados a ela.
class ContadorPontos:
def __init__(self, nome):
self.nome = nome
self.pontos = 0
jogador = ContadorPontos("Lia")
print(jogador.nome)
print(jogador.pontos)
# Saída:
# Lia
# 0Durante a execução de __init__, nome é um parâmetro local que recebeu o argumento da chamada. Já self.nome é um atributo associado à instância representada por self.
A instrução self.nome = nome lê o valor local que está à direita e o associa ao objeto no atributo que está à esquerda. Quando __init__ termina, o parâmetro local deixa de fazer parte daquela chamada, mas o atributo continua disponível no objeto.
Uma variável local existe somente durante a chamada. Usar self. é o que associa o valor à instância.
class ContadorPontos:
def __init__(self, nome):
apelido_temporario = nome # variável local
self.nome = nome # atributo da instância
self.pontos = 0 # atributo da instânciaO espaço local existe enquanto __init__ está em execução. Os atributos continuam associados à instância depois que essa execução termina.
nome fornece o valor durante a chamada; self.nome mantém esse valor associado ao objeto.
Complete a lacuna para que o nome recebido fique associado ao objeto e possa ser consultado depois com jogador.nome:
class ContadorPontos:
def __init__(self, nome):
self._____ = nome
self.pontos = 0
Passo 4 de 8
Defina um método que consulta a pontuação de uma instância e entenda como self identifica o objeto que recebeu a chamada.
Uma função definida no corpo de uma classe é um método. O método consultar_pontos opera sobre uma instância de ContadorPontos e devolve a pontuação armazenada nela.
Por convenção, o primeiro parâmetro de um método de instância se chama self. Esse nome não é uma palavra reservada do Python, mas seguir a convenção torna o código reconhecível.
O método retorna o atributo pontos da instância recebida em self. Ele apenas consulta o estado: nenhum atributo é alterado.
class ContadorPontos:
def __init__(self, nome):
self.nome = nome
self.pontos = 0
def consultar_pontos(self):
return self.pontosNa chamada jogo.consultar_pontos(), você não escreve um argumento para self. O Python associa automaticamente a instância jogo ao parâmetro self.
Dentro dessa chamada, self.pontos consulta o atributo pontos de jogo. Se a chamada fosse feita por outro objeto, self representaria esse outro objeto.
O objeto antes do ponto é a instância representada por self durante a chamada.
A chamada produz um resultado que pode ser guardado e depois exibido.
jogo = ContadorPontos("Equipe Azul")
resultado = jogo.consultar_pontos()
print(resultado) # 0Dica
return self.pontos entrega o valor ao código que chamou o método. O print fica fora da classe e decide exibir esse resultado. Assim, o método pode ser usado mesmo quando você não deseja mostrar nada na tela.
Qual trecho define e chama corretamente um método que devolve a pontuação de jogo?
Passo 5 de 8
Implemente um método que recebe uma quantidade, atualiza a pontuação da instância e diferencie o efeito da operação de seu valor de retorno.
O método adicionar_pontos recebe dois parâmetros: self, que identifica a instância, e quantidade, que informa quantos pontos serão adicionados.
A atualização usa a pontuação atual do próprio objeto:
self.pontos = self.pontos + quantidade
Na chamada jogador.adicionar_pontos(7), o objeto jogador é passado automaticamente como self. Portanto, o argumento 7 corresponde a quantidade.
Execute este exemplo com Python 3 para observar a alteração da pontuação.
class ContadorPontos:
def __init__(self, nome):
self.nome = nome
self.pontos = 0
def consultar_pontos(self):
return self.pontos
def adicionar_pontos(self, quantidade):
self.pontos = self.pontos + quantidade
jogador = ContadorPontos("Ana")
jogador.adicionar_pontos(7)
print(jogador.consultar_pontos()) # 7Considere um contador que já possui 10 pontos. Ao receber a chamada jogador.adicionar_pontos(7), o método consulta o valor atual por self.pontos, soma a quantidade e associa o resultado novamente ao mesmo atributo. Depois da chamada, esse objeto passa a ter 17 pontos.
A chamada altera o atributo pontos do objeto que aparece antes do ponto.
Neste exemplo, adicionar_pontos modifica o estado e não possui return explícito. Por isso, o valor produzido pela chamada é None. Isso não significa que a operação falhou: a nova pontuação ficou armazenada no objeto.
Já consultar_pontos usa return para fornecer a pontuação ao código que fez a chamada. Essa é uma escolha adequada para estes dois métodos, mas não uma regra obrigatória para todos os métodos.
A variável resultado recebe o retorno da operação, não a pontuação atualizada.
jogador = ContadorPontos("Ana")
resultado = jogador.adicionar_pontos(5)
print(resultado) # None
print(jogador.consultar_pontos()) # 5Complete apenas o lado direito da atribuição:
self.pontos = ______
Um contador começa com zero pontos e recebe estas chamadas:
jogador.adicionar_pontos(4)
resultado = jogador.adicionar_pontos(6)O que fica armazenado em resultado? Qual valor será devolvido depois por jogador.consultar_pontos()? Explique a diferença.
Escreva pelo menos 10 caracteres (0/10).
Passo 6 de 8
Preveja e confira como chamadas intercaladas alteram separadamente o estado de dois objetos.
Cada chamada de ContadorPontos(...) cria uma nova instância. Neste exemplo, cada objeto mantém seu próprio nome e sua própria pontuação.
Em uma chamada de método, observe o objeto antes do ponto: contador_ana.adicionar_pontos(10) atua sobre contador_ana, não sobre contador_beto.
As duas instâncias partem da mesma classe, mas cada seta alcança somente o objeto que recebe a chamada.
O objeto antes do ponto determina qual estado será consultado ou alterado.
Leia as instruções na ordem e atualize mentalmente apenas o contador que aparece antes do ponto.
contador_ana = ContadorPontos("Ana")
contador_beto = ContadorPontos("Beto")
contador_ana.adicionar_pontos(10)
contador_beto.adicionar_pontos(7)
contador_ana.adicionar_pontos(5)
contador_beto.adicionar_pontos(3)Acompanhe os estados após cada linha:
| Momento | Ana | Beto |
|---|---:|---:|
| Após criar os objetos | 0 | 0 |
| Ana recebe 10 | 10 | 0 |
| Beto recebe 7 | 10 | 7 |
| Ana recebe 5 | 15 | 7 |
| Beto recebe 3 | ? | ? |
Digite as pontuações finais no formato Ana,Beto, sem espaços.
Copie o script completo para um arquivo Python e execute-o com Python 3. Compare a saída com a previsão feita na tela anterior.
O código inclui a classe, as duas instâncias, as chamadas intercaladas e a consulta dos estados finais.
class ContadorPontos:
def __init__(self, nome):
self.nome = nome
self.pontos = 0
def consultar_pontos(self):
return self.pontos
def adicionar_pontos(self, quantidade):
self.pontos += quantidade
contador_ana = ContadorPontos("Ana")
contador_beto = ContadorPontos("Beto")
contador_ana.adicionar_pontos(10)
contador_beto.adicionar_pontos(7)
contador_ana.adicionar_pontos(5)
contador_beto.adicionar_pontos(3)
print(f"{contador_ana.nome}: {contador_ana.consultar_pontos()}")
print(f"{contador_beto.nome}: {contador_beto.consultar_pontos()}")Exemplo
Ana: 15
Beto: 10
A execução confirmou sua previsão? Registre as duas pontuações finais e explique por que uma chamada de adicionar_pontos alterou somente o contador escolhido.
Escreva pelo menos 60 caracteres (0/60).
Passo 7 de 8
Leia um AttributeError, identifique o atributo ausente e corrija a inconsistência que provocou a falha.
Neste exemplo, AttributeError indica que o programa tentou acessar um atributo inexistente no objeto. A parte final da mensagem informa duas pistas importantes: o tipo do objeto e o nome do atributo procurado.
A instância possui pontos, mas o método tenta acessar pontuacao.
class ContadorPontos:
def __init__(self, nome):
self.nome = nome
self.pontos = 0
def consultar_pontos(self):
return self.pontuacao
contador = ContadorPontos("Equipe Azul")
print(contador.consultar_pontos())
# AttributeError: 'ContadorPontos' object has no attribute 'pontuacao'
O objeto é do tipo ContadorPontos; o acesso falha especificamente porque pontuacao não foi definido nele.
Primeiro, compare a grafia usada na inicialização com a grafia usada no acesso. Se os nomes deveriam ser iguais, corrija o acesso. Depois, confirme se o valor foi atribuído com self.atributo: uma variável local desaparece ao fim do método e não passa a fazer parte do objeto.
Cada correção resolve uma inconsistência diferente.
# Causa 1: diferença de grafia no acesso
class ContadorPontos:
def __init__(self, nome):
self.nome = nome
self.pontos = 0
def consultar_pontos(self):
return self.pontos # corrigido: era self.pontuacao
# Causa 2: variável local no lugar de atributo
class OutroContador:
def __init__(self, nome):
self.nome = nome
self.pontos = 0 # corrigido: era apenas pontos = 0
def consultar_pontos(self):
return self.pontosAtenção
Não use try e except apenas para ocultar esse erro. Se o atributo deveria existir, alinhe seu nome ou inicialize-o com self.atributo.
Observe onde a pontuação inicial é definida e onde ela é acessada.
class ContadorPontos:
def __init__(self, nome):
self.nome = nome
pontos = 0
def adicionar_pontos(self, quantidade):
self.pontos += quantidade
jogador = ContadorPontos("Lia")
jogador.adicionar_pontos(10)Qual é a causa do erro quando jogador.adicionar_pontos(10) é executado? Indique também a linha que deve substituir pontos = 0.
Escreva pelo menos 30 caracteres (0/30).
Passo 8 de 8
Implemente a classe ContadorPontos, execute uma sequência com duas instâncias e explique como cada objeto mantém sua própria pontuação.
No seu computador, crie um arquivo Python e implemente ContadorPontos antes do código de uso abaixo.
A classe deve:
nome em __init__;self.nome;self.pontos com 0;consultar_pontos(), que retorna a pontuação;adicionar_pontos(quantidade), que soma a quantidade ao estado atual sem retorno explícito.Depois, execute o arquivo com Python 3 e compare o resultado com a referência da próxima tela.
Escreva a definição da classe acima deste trecho. Não altere a sequência de chamadas durante a primeira execução.
alice = ContadorPontos("Alice")
bruno = ContadorPontos("Bruno")
print("Pontuações iniciais")
print(f"{alice.nome}: {alice.consultar_pontos()}")
print(f"{bruno.nome}: {bruno.consultar_pontos()}")
alice.adicionar_pontos(10)
bruno.adicionar_pontos(7)
alice.adicionar_pontos(5)
print("Pontuações finais")
print(f"{alice.nome}: {alice.consultar_pontos()}")
print(f"{bruno.nome}: {bruno.consultar_pontos()}")Atenção
Antes de revelar a solução, tente escrever a classe e executar o programa. Se ocorrer um AttributeError, confira a grafia dos atributos e verifique se eles foram definidos com self.
As duas instâncias começam com zero. Somente Alice recebe a segunda adição de pontos.
Pontuações iniciais
Alice: 0
Bruno: 0
Pontuações finais
Alice: 15
Bruno: 7Compare esta solução com a sua. Observe que o método de consulta retorna um valor, enquanto o método de alteração apenas atualiza o atributo.
class ContadorPontos:
def __init__(self, nome):
self.nome = nome
self.pontos = 0
def consultar_pontos(self):
return self.pontos
def adicionar_pontos(self, quantidade):
self.pontos = self.pontos + quantidade
alice = ContadorPontos("Alice")
bruno = ContadorPontos("Bruno")
print("Pontuações iniciais")
print(f"{alice.nome}: {alice.consultar_pontos()}")
print(f"{bruno.nome}: {bruno.consultar_pontos()}")
alice.adicionar_pontos(10)
bruno.adicionar_pontos(7)
alice.adicionar_pontos(5)
print("Pontuações finais")
print(f"{alice.nome}: {alice.consultar_pontos()}")
print(f"{bruno.nome}: {bruno.consultar_pontos()}")Quais foram as pontuações finais de Alice e Bruno? Explique como self fez cada chamada atuar sobre o objeto correto.
Escreva pelo menos 80 caracteres (0/80).
A definição da classe reúne a inicialização e os métodos. Cada chamada de ContadorPontos(...) cria um objeto distinto, e as chamadas posteriores consultam ou alteram o estado do objeto que está antes do ponto.
Uma classe orienta a criação; cada instância conserva seu próprio nome e sua própria pontuação.
Resumo
Você integrou inicialização, atributos e métodos em uma classe simples e acompanhou duas instâncias durante operações intercaladas.
__init__ associa nome e pontos a cada nova instância por meio de self.consultar_pontos retorna o estado sem alterá-lo.adicionar_pontos usa o estado atual e atualiza a instância que recebeu a chamada.Parabéns! Você concluiu: Criar objetos com classes e métodos de instância
Parabéns! Você concluiu o tutorial Criar objetos com classes e métodos de instância.
100 XP
Milhares de cursos online em vídeo, ebooks e áudiobooks.
Para testar seus conhecimentos no decorrer dos cursos online
Gerado diretamente na galeria de fotos do seu celular e enviado ao seu e-mail
Baixe nosso aplicativo pelo QR Code ou pelos links abaixo:.
Leve o conhecimento no seu bolso.
Baixe o aplicativo Cursa.
São centenas de Cursos gratuitos a disposição, com Certificado de conclusão gratuito que é salvo em sua galeria de imagens do celular.
Baixe o app para ter acesso ao Certificado de conclusão de Curso Gratuitamente.
+ de 10 milhões
de alunos
Certificado grátis e
válido em todo o Brasil
60 mil exercícios
gratuitos
4,8/5 classificação
nas lojas de apps
Cursos gratuitos em
vídeo, ebooks e audiobooks
