Olá,

seja bem-vindo/a!
Disciplina: Linguagem de Programação
Prof: Alyson Trindade Fernandes

www.ifnmg.edu.br/diamantina
 CLASSES E OBJETOS

● Classe: Um modelo que define os atributos e comportamentos de

objetos. É como um projeto para criar objetos.
● Objeto: Uma instância específica de uma classe que possui seus
próprios valores para os atributos e pode executar os métodos definidos
na classe.
 SINTAXE BÁSICA DE CLASSES

class Conta:
def __init__(self, numero, titular, saldo, limite):
self.numer = numero
self.titular = titular
self.saldo = saldo
self.limite = limite
 __init__() - CONSTRUTOR

É o método __init__() que vai inicializar os atributos de um objeto. Seu

primeiro parâmetro, assim como todo método de instância, é a própria
instância. Por convenção, chamamos este argumento de self.
 INSTÂNCIAS

São construções de objetos a partir de uma classe. Para definir um novo

objeto conta a partir da classe Conta siga esta sintaxe:

from conta import Conta

conta1 = Conta('123-4', 'João', 120.0, 1000.0)
 MÉTODOS
Além dos atributos, nossa conta deve possuir funcionalidades.

Para criar o método deposita() na classe Conta, assim como o método

__init__() , deposita() deve receber a instância do objeto (self) além do
valor a ser depositado:

class Conta:
# método __init__() omitido
def deposita(self, valor):
self.saldo += valor
 MÉTODOS

Para utilizar o método de uma classe deve-se chamá-lo a partir da

referência de um objeto:

conta1.deposita(20.0)
 MÉTODOS COM RETORNO

Um método pode retornar um valor para a sua chamada:

def saca(self, valor):

if (self.saldo < valor):
return False
else:
self.saldo -= valor
return True
 MÉTODOS COM RETORNO

Exemplo de uso:

minha_conta.saldo = 1000
consegui = minha_conta.saca(2000)
if(consegui):
print(“consegui sacar”)
else:
print(“não consegui sacar”)
 OBJETOS SÃO ACESSADOS POR
REFERÊNCIA
Quando criamos uma variável para associar a um objeto, na verdade,
essa variável não guarda o objeto, e sim uma maneira de acessá-lo,
chamada de referência (o self). Podemos definir a referência de um objeto
como sendo o endereço inicial da memória ram onde este objeto está
armazenado.

c1 = Conta()

c1 guarda o endereço da nova instância da classe conta.

OBJETOS SÃO ACESSADOS POR
REFERÊNCIA
 COMUNICAÇÃO ENTRE OBJETOS
O método transfere, lista abaixo, mostra a comunicação entre objetos
inserindo a referência de um objeto como parâmetro do método de outro
objeto. Assim os atributos do objeto passado como referência podem ser
acessados pelo objeto chamador do método.

class Conta:
# código omitido
def transfere(self, destino, valor):
retirou = self.saca(valor)
if (retirou == False):
return False
else:
destino.deposita(valor)
return True
 ATRIBUTOS COM VALOR PADRÃO
No exemplo abaixo, o atributo limite possui valor padrão definido no
construtor. Portanto ele não necessita obrigatoriamente ser definido na
instanciação de um novo objeto.

class Conta:
def __init__(self, numero, titular, saldo,
limite=1000.0):
self.numero = numero
self.titular = titular
self.saldo = saldo
self.limite = limite
 ATRIBUTOS COM VALOR PADRÃO

Veja que agora não somos obrigados a passar o valor do limite já que ele
possui um valor padrão
de 1000.0

conta = Conta('123-4', 'joão', 120.0)

 TUDO É OBJETO
Python é uma linguagem totalmente orientada a objetos. Tudo em Python
é um objeto!

print(type(conta.numero))
#<class 'str'>
print(type(conta.saldo))
#<class 'float'>
print(type(conta.titular))
#<class '__conta__.Cliente'>
 MÉTODOS MÁGICOS
Caso você queira saber quais são todos os métodos implementados pela
classe Conta , você pode usar a função embutida dir(), que irá listar todos
métodos e atributos que a classe possui.

dir(Conta)
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__',
'__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__',
'__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__',
'__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__',
'__str__', '__subclasshook__', '__weakref__', 'extrato', 'deposita', 'limite' ,
'numero', 'saca', 'saldo', 'transfere_para', 'titular']
 MÉTODOS MÁGICOS
Um outro atributo bastante útil é o __dict__ , que retorna um
dicionário com os atributos da classe.

cliente = Cliente('João', 'Oliveira', '111111111-11')

conta = Conta('123-4', cliente, 1000.0)
print(conta.__dict__)
#{'saldo': 1000.0, 'numero': '123-4', 'titular':
#<__main__.Cliente object at 0x7
#f0b6d028f28>, 'limite': 1000.0}
 MODIFICADORES DE ACESSO E
MÉTODOS DE CLASSE
Em linguagens orientadas a objetos devemos esconder os atributos e
métodos que não devem ser acessados por outros sistemas.
Chamamos esta ação de “modificador de acesso”.
Outras linguagens possuem o termo private.
Em python temos algumas alternativas.
A primeira delas é adicionar dois underscores __ antes do nome do
atributo que deve ser privado. Desta forma o atributo fica escondido do
acesso direto

class Pessoa:
def __init__(self, idade):
self.__idade = idade
 MODIFICADORES DE ACESSO E
MÉTODOS DE CLASSE
Os atributos com __ no nome ainda podem ser acessados por:

p._Pessoa__idade

Ao colocar o prefixo __ no atributo da classe, o Python apenas renomeia

'__nome_do_atributo' para '_nomeda_Classe_nome_do_atributo', como
fez em __idade para _Pessoa__idade.
Muitos programadores Python não gostam dessa sintaxe e preferem usar
apenas um underscore '_' para indicar quando um atributo deve ser
protegido.
 MODIFICADORES DE ACESSO E
MÉTODOS DE CLASSE

As mesmas regras de acesso aos atributos valem para os métodos.

É muito comum, e faz todo sentido, que seus atributos sejam privados e
quase todos seus métodos sejam públicos.
 ENCAPSULAMENTO

Encapsular é fundamental para que seu sistema seja suscetível a

mudanças: não precisamos mudar uma regra de negócio em vários
lugares, mas sim em apenas um único lugar, já que essa regra está
encapsulada.

O conjunto de métodos públicos de uma classe é também chamado de

interface da classe, pois esta é a única maneira a qual você se comunica
com objetos dessa classe.
 ENCAPSULAMENTO

Outra forma de encapsular os atributos de uma classe é através da

construção de 2 métodos (get e set) para cada atributo.

Getters e setters são usados em muitas linguagens de programação

orientada a objetos para garantir o princípio do encapsulamento de dados.
O encapsulamento de dados é visto como o agrupamento de dados com
os métodos que operam nesses dados.
 ENCAPSULAMENTO
class Conta:
def __init__(self, titular, saldo):
self._titular = titular
self._saldo = saldo
def get_saldo(self):
return self._saldo
def set_saldo(self, saldo):
self._saldo = saldo
def get_titular(self):
return self._titular
def set_titular(self, titular):
self._titular = titular
 ENCAPSULAMENTO

A forma pythônica de encapsulamento de atributos é diferente:

 ENCAPSULAMENTO
class Conta:
def __init__(self, saldo=0.0):
self.saldo = saldo
@property
def saldo(self):
return self.saldo
@saldo.setter
def saldo(self, saldo):
if(saldo < 0):
print("saldo não pode ser negativo")
else:
self.saldo = saldo
 ENCAPSULAMENTO

Um método que é usado para obter um valor (o getter) é decorado com

@property , isto é, colocamos essa linha diretamente acima da declaração
do método que recebe o nome do próprio atributo.

O método que tem que funcionar como setter é decorado com

@saldo.setter . Se a função tivesse sido chamada de "func", teríamos que
anotá-la com @func.setter .
 ENCAPSULAMENTO

Desta maneira, podemos chamar esses métodos sem os parênteses,

como se fossem atributos públicos. É uma forma mais elegante de
encapsular nossos atributos. Vamos testar criar uma conta e depois
atribuir um valor negativo ao saldo:

conta = Conta(1000.0)
conta.saldo = -300.0
"saldo não pode ser negativo"
 ENCAPSULAMENTO

A forma pythônica é bem mais amigável ao usar o encapsulamento. Veja a

diferença dos da chamada dos dois métodos:

Java:
conta3.set_saldo(conta1.get_saldo() + conta2.get_saldo())

Python:
conta3.saldo = conta1.saldo + conta2.saldo
 ATRIBUTOS DE CLASSE
● Variável própria da classe, sendo única e compartilhada por todos os
objetos da mesma. Dessa maneira, quando a mesma fosse mudada
através de um objeto, o outro enxergaria o mesmo valor

>>>
class Conta:
_total_contas = 0
def__init__(self, saldo):
self._saldo = saldo
Conta._total_contas += 1
 ATRIBUTOS DE CLASSE

c1 = Conta(100.0)
print(c1._total_contas)
#1

c2 = Conta(200.0)
print(c2._total_contas)
#2
 ATRIBUTOS DE CLASSE

Também é possível acessar este atributo direto da classe:

>>> Conta._total_contas
 MÉTODOS ESTÁTICOS
Métodos estáticos não precisam de uma referência, não
recebem um primeiro argumento especial (self). É como uma
função simples que, por acaso, reside no corpo de uma classe em
vez de ser definida no nível do módulo.

>>>
@staticmethod
def get_total_contas():
return Conta._total_contas
 MÉTODOS DE CLASSE
Métodos de classe servem para definir um método que opera na
classe, e não em instâncias. Já os métodosestáticos utilizamos
quando não precisamos receber a referência de um objeto especial
(seja da classe ou de uma instância) e funciona como uma função
comum, sem relação.

Um método de classe pode mudar a implementação, ou seja, pode

ser reescrito pela classe filha. Já os métodos estáticos não
podem ser reescritos pelas filhas, já que são imutáveis e não dependem
de um referência especial.
 MÉTODOS DE CLASSE

class Conta:
_total_contas = 0
def __init__(self):
Conta._total_contas += 1

@classmethod
def get_total_contas(cls):
return cls._total_contas
 PROTEÇÃO DE CLASSES COM SLOTS

Como Python é uma linguagem dinâmica, nada impede que usuários

de nossa classe Conta criem atributos em tempo de execução,
fazendo, por exemplo:

>>> conta.nome = "minhaconta"

 PROTEÇÃO DE CLASSES COM SLOTS

Podemos utilizar uma variável embutida no Python chamada

__slots__ , que pode guardar uma lista de atributos definidos por
nós e garantir que novos atributos não sejam adicionados às instâncias
desta classe.
 PROTEÇÃO DE CLASSES COM SLOTS

class Conta:
__slots__ = ['_numero', '_titular', '_saldo', '_limite']
def__init__(self, numero, titular, saldo,
limite=1000.0):
# inicialização dosatributos

>>> conta.nome = "minha_conta" #gera erro

 EXERCÍCIO DE FIXAÇÃO
1) Crie uma classe Tempo com três atributos: horas, minutos e segundos.
Crie os seguintes métodos:
a) Construtor para inicializar os atributos com valores passados como
argumentos ou com valores padrão para a hora “00:00:00”;
b) Funcionar como getter e setter;
c) Imprimir os atributos no formato hh:mm:ss;
d) Crie uma classe de teste que cria um objeto Tempo e o inicializa com
a hora do dia;
e) Avançar ou atrasar o tempo de acordo com a hora de outro objeto
Tempo recebida como parâmetro;
f) Um método estático que verifica se um objeto de Tempo possui hora
válida;
g) Um método de classe que retorna a diferença de tempo entre 2
objetos Tempos recebidos como parâmetro;
h) Teste todos os métodos.
 EXERCÍCIO DE FIXAÇÃO
1) Crie uma classe Calculadora com quatro atributos: operando_1,
operação, operando_2 e resultado. Crie os seguintes métodos:
a) Construtor para inicializar os atributos com valores passados como
argumentos ou com valores padrão para a operação: 0+0==0;
b) Funcionar como getter e setter;
c) Imprimir os atributos no formato “00+00=00”;
d) Método Estático validar_operacao() que recebe uma string como
parâmetro e verifica se é uma operação válida (+, -, *, /);
e) Método de classe que recebe uma operação no formato “00+00=00” e
extrai os dados da operação e alimenta os atributos da classe;
f) Realizar o cálculo com base nos atributos do objeto;
g) Retornar se a operação setada em um objeto irá gerar divisão por
zero;
h) Teste todos os métodos.
 HERANÇA E POLIMORFISMO

…
 HERANÇA E POLIMORFISMO

…
 HERANÇA E POLIMORFISMO

…
HERANÇA E POLIMORFISMO (REESCRITA DE
MÉTODOS)
HERANÇA E POLIMORFISMO (REESCRITA DE
MÉTODOS)
HERANÇA E POLIMORFISMO (REESCRITA DE
MÉTODOS)
 HERANÇA E POLIMORFISMO

Polimorfismo é a capacidade de um objeto poder ser

referenciado de várias formas (cuidado, polimorfismo não
quer dizer que o objeto fica se transformando, muito pelo
contrário, um objeto nasce de um tipo e morre daquele tipo, o
que pode mudar é a maneira como nos referimos a ele).
HERANÇA E POLIMORFISMO
 HERANÇA E POLIMORFISMO

…
 HERANÇA E POLIMORFISMO

● No dia em que criarmos uma classe Secretaria , por exemplo, que é filha
de Funcionario, precisaremos mudar a classe ControleDeBonificacoes ?

● O quê acontece se tentarmos registrar um cliente na classe

ControleDeBonificacoes ? Faça o teste.
 HERANÇA E POLIMORFISMO

…
 HERANÇA E POLIMORFISMO

…
 HERANÇA E POLIMORFISMO

Você deve escrever o código esperando somente uma interface do objeto,

não um tipo de objeto.

No caso da nossa classe ControleDeBonificacoes , o método registra()

espera um objeto que possua o método get_bonificacao() e não apenas
um funcionário.
 HERANÇA E POLIMORFISMO

O Duck Typing é um estilo de programação que não

procura o tipo do objeto para determinar se ele tem a
interface correta. Ao invés disso, o método ou atributo é
simplesmente chamado ou usado ('se parece como um
pato e grasna como um pato, então deve ser um pato').
 HERANÇA E POLIMORFISMO

O que é importante é que a maneira pythônica de se fazer é assumir a

existência do atributo e capturar (tratar) um exceção quando o atributo não
pertencer ao objeto e seguir o fluxo do programa.
 CLASSES ABSTRATAS

Neste sistema, não faz sentido instanciar um objeto da classe

Funcionario.
Logo, a classe Funcionario é uma classe abstrata. Ela serve de molde
(rascunho) para a construção de outras classes.
Uma classe abstrata não pode ser instanciada e deve conter pelo menos
um método abstrato.
 CLASSES ABSTRATAS

…
 CLASSES ABSTRATAS

Uma classe abstrata não pode ter um método instanciado;

É possível instanciar um objeto de uma classe filha da classe abstrata;
Não é possível herdar de uma classe abstrata sem instanciar todos os
seus métodos abstratos;
Métodos abstratos não possuem implementação na classe base e devem
ser implementados nas classe subclasses;
 CLASSES ABSTRATAS

…
 CLASSES ABSTRATAS

…
 CLASSES ABSTRATAS

…
 CLASSES ABSTRATAS

…
 CLASSES ABSTRATAS

…
 CLASSES ABSTRATAS

…
 CLASSES ABSTRATAS

…
 CLASSES ABSTRATAS

…
 CLASSES ABSTRATAS

…
 CLASSES ABSTRATAS

…
 CLASSES ABSTRATAS

…
OBRIGADO!
Esperamos que você consiga
desenvolver todo seu potencial
conosco.