Loading presentation...

Present Remotely

Send the link below via email or IM

Copy

Present to your audience

Start remote presentation

  • Invited audience members will follow you as you navigate and present
  • People invited to a presentation do not need a Prezi account
  • This link expires 10 minutes after you close the presentation
  • A maximum of 30 users can follow your presentation
  • Learn more about this feature in our knowledge base article

Do you really want to delete this prezi?

Neither you, nor the coeditors you shared it with will be able to recover it again.

DeleteCancel

Make your likes visible on Facebook?

Connect your Facebook account to Prezi and let your likes appear on your timeline.
You can change this under Settings & Account at any time.

No, thanks

Orientação a Objetos - CompII

No description
by

Thiago Sabatucci

on 2 September 2013

Comments (0)

Please log in to add your comment.

Report abuse

Transcript of Orientação a Objetos - CompII

Python
Programação
Orientada a
Objetos
Como assim?
Tudo é um objeto!
Um objeto tem:
Propriedades
Comportamento
Variáveis, tuplas, dicionários, listas,etc
Funções, métodos...
Fabricante: "Ferrari"
Modelo: "Enzo"
Potência: 651cv
Motorização: 6.0L
Cor: "amarelo"
Cilindros: 12
TipoCilindro: V
Preço: 1milhão
virar(ângulo)
acelerar(forçaPedaldeAceleração)
freiar(forçaPedalFreio)
...
As funções agem de acordo com as especificações do carro
Objeto:
Carro
Objeto:
Trabalhador
Propriedades:
Nome
Salário
Horas de trabalho
Regime de trabalho
Nascimento
Faltas
Funções:
CalculaSalário()
registraPonto()
aumentaSalario()
reduzSalario()
bloquearFacebook()
Propriedades:
Funções:
Objetos podem se relacionar!
Trabalhador pode dirigir um carro...
dirigir(Carro,Percurso)
Conceitos de OO
Herança
Pai
14-bis (conceito de avião)
Filho
Voar()
VoarRapido()
class Aviao:
velocidade=5 #km/h
altitude=5 #metros
alcance=0.1 #km
altura=1 #m
comprimento=2 #m
envergadura=1 #m
passageiros=1
def Voar():

class Embraer195(Aviao):
motorizacao=GE CF34-10E
def VoarRapido():
Essa é uma propriedade que o pai não tem
Estas propriedades (ou variáveis)
serão acessíveis pelo filho
Avião
Embraer 195
Propriedades em comum:
alcance, altitude,etc.
Propriedades diferentes:
Motorização
Esse método também é acessível pelo filho
Abstração
Voltando ao carro
Fabricante: "Ferrari"
Modelo: "Enzo"
Potência: 651cv
Motorização: 6.0L
Cor: "amarelo"
Cilindros: 12
TipoCilindro: V
Preço: 1milhão
Podemos fazer uma classe carro com
todos estes atributos, mas...
Dentro do carro também temos outros objetos:
Carro
Motor
Roda
Cor
Fabricante
Modelo
Potência: 651cv
Motorização: 6.0L
Cilindros: 12
TipoCilindro: V
Aro
Perfil
Furação
class Carro:
cor=None
fabricante=None
modelo=None

class Motor(Carro):
potencia= None
motorizacao= None
cilindros=None
tipoCilindro= None
Carro
Roda
Motor
Potência: 651cv
Motorização: 6.0L
Cilindros: 12
TipoCilindro: V
Aro
Perfil
Furação
Cor
Fabricante
Modelo
class Roda(Carro)
aro=None
perfil=None
furacao=None
(Super-classe)
(Sub-classe)
(Sub-classe)
Isso é chamado
especialização
Polimorfismo
Se escrevemos um algoritmo para ser aplicado um objeto X, então também pode ser aplicado a um objeto Y desde que Y seja suficientemente polimórfico a X
Habilidade de um objeto ser usado de forma semelhante a outro
Veículo
Carro
Caminhão
Motor
Roda
Motor
Roda
Acelerar()
Freiar()
Virar()
Se criarmos uma instância de Carro e outra de Veículo
ambos terão as funções para acelerar, freiar e virar (via herança).
Podemos dizer que estas funções são polimórficas.
Múltipla
Veículo
Carro
Caminhão
Roda
Motor de carro
Motor
de caminhão
Roda
Motor
Voltando para o veículo.
Ambos veículos têm motor, mas com propriedades distintas.
Podemos criar um 'pai' Motor que terá propriedades em comum, e cujos filhos terão propriedades específicas
Nota: Ambos os motores tem mais de um pai
Utilização
Entenda as classes (de python) como 'fabricas' de objetos.
Eles apenas ditam como seria um objeto quando ele for criado.
class Carro:
cor='amarelo'
fabricante='ferrari'
modelo='enzo'
def acelera(forçaPedal):
#faça acelerar
Exemplo:
ao declarar isso abaixo em python
Você apenas
definiu
como é o seu objeto
Você não
criou
um objeto
(instanciou)
Para criar (fabricar) um objeto do tipo 'Carro' é só chamar o nome da classe como uma função:
Carro()

Depois guardar em uma variável
meuCarro=Carro()
Após 'criar' (instanciar) o Carro, é possível
m
odificar os valores

do seu carro através do operador ponto (.)
meuCarro.motorizacao=4.3
meuCarro.potencia=230
meuCarro.porta='madeira'

Assim como chamar as funções:
meuCarro.Vire(
'esquerda'
)
Construtores
Ao criar um objeto da classe, é possível já inserir valores logo ao chamar o construtor
Exemplo:
meuCarro=Carro()
meuCarro.fabricante=ferrari
meuCarro.potencia=650
meuCarro.cor='preto'
meuCarro.modelo='enzo'
Com o contrutor, poderia ficar assim:
meuCarro=Carro('ferrari','enzo',preto',650)
Para ser possível chamar o construtor, basta definir uma função restrita, chamada __init__() dentro da classe.
class

PoligonoRegular:
lados=
None
tamanhoAresta=
None

def
__init__ (
self
,lados,tamanhoAresta)


self
.lados=lados

self
.tamanhoAresta=tamanhoAresta

def
Area (
self
):
return 0
Imagine uma classe derivada de PoligonoRegular.
Os atributos (lado e tamanhoAresta) vão ser herdados.
Entretanto não serão inicializados, e o construtor do pai
não será chamado

class TrianguloEquilatero (PoligonoRegular):
def
__init__
(self,lados,tamanhoAresta):
PoligonoRegular.
__init__
(self,lados,tamanhoAresta)
def Area(self):
return self.tamanhoAresta*math.sqrt(3)/4
O

self

indica que é um parâmetro da própria classe.
Em todo método (dentro da classe) ele deve estar incluído)
Antes vamos criar uma classe para os polígonos regulares...
Ao usar um construtor __init__() não é preciso
declarar as variáveis, se for atribuído algum valor a self.variavel
class

PoligonoRegular:

def
__init__ (
self
,lados,tamanhoAresta)


self
.lados=lados

self
.tamanhoAresta=tamanhoAresta

def
Area (
self
):
return 0
lados e tamanhoAresta serão criados
na classe PoligonoRegular, se chamado o construtor
class

PoligonoRegular:
#declarações
class TrianguloEquilatero (PoligonoRegular):
#declarações
Exceções
São comportamentos inesperados do código
Quando um programa realiza uma operação que não deveria: divisão por zero,erro de precisão,etc
Usuário entra com algo que não deveria. Esperava-se um número, digitou-se um caractere
Exemplos
Como saber de antemão?
A verdade é que nem sempre é fácil
No caso da divisão por zero:
def

media
(x):
soma=
0

for
i
in
x:
soma+=i

return
soma/
len
(x)
Nessa simples função, o que acontece se passarmos uma lista vazia?
Erros
A maior causa de erros dos programas são
por causa de entradas inexperadas
O programador, quase sempre, faz uma função ou parte de um código para funcionar num caso particular.
Como tratar?
Simples! Use:

raise

Exception
("frase do erro")
Exception
é uma classe, que é filha de
BaseException
('pai' de todos os erros)
Todos os erros criados pelo usuário derivam de
Exception
(veremos como)
Seus filhos tratam de erros específicos
def media(x):
soma=0
for i in x:
soma+=i
if len(x)==0:

raise

Exception
(
"ja era"
)
return soma/len(x)
Após colocar isso, ao ser passado uma lista vazia,
o seguinte aparecerá no terminal:
Traceback (most recent call last):
File "arquivo.py", line 9, in <module>
media(x)
File "arquivo.py", line 6, in media
raise Exception("ja era")
Exception: ja era
Resultado
Ora... Isso não foi muito diferente do que iria acontecer.
O que ocorre num erro?
Se nada for feito, ao ocorrer um
erro
num programa em python, o programa
termina
e o código
pára
na
linha
que resultou o problema.
Nosso
raise
não impediu isso, pois o erro não foi
tratado
. Apenas repassamos a batata quente e colocamos um nome diferente.
Como tratar?
Usamos o
try
e o
except
.
O
try
indica um trecho que pode dar problema
O
except
tenta 'pegar' um problema específico e tratar
listaVazia=[]
try
:
media(listaVazia)
except
Exception,msgem:
print msgem
print
'cheguei aqui'
Dessa forma será impresso:
ja era
cheguei aqui
Sem a exceção isso não seria impresso
Alguns filhos de Exception:
AttributeError
IOError
IndexError
KeyError
NameError
SyntaxError
TypeError
ValueError
ZeroDivisionError
Falha no acesso ou atribuição a atributo de classe
Falha no acesso a arquivo inexistente ou outros de E/S
Índice inexistente
Chave inexistente de dicionário
Variável inexistente
Erro de sintaxe (código errado)
Operador embutido aplicado a objeto de tipo errado
Operador embutido aplicado a objeto de tipo certo mas valor inapropriado
Erro de divisão por zero
Usando uma exceção mais apropriada
def media(x):
soma=0
for i in x:
soma+=i
if len(x)==0:
raise
ZeroDivisionError
("ja era")
return soma/len(x)
x=[]
try:
media(x)
except
ZeroDivisionError
,msg:
print msg
print 'cheguei aqui'
Exceções são muito boas para lidar com usuário
try
:
x = int(raw_input("Digite um numero: "))
except

ValueError
:

print
"Voce é cego? Eu disse um NÚMERO!"
else
:

print
x*x
Se não ocorrer nenhum erro, o bloco
else
é executado
Criando seu próprio tipo de erro
class
MeuErro(
Exception
):
def __init__(self, value):
self.value = value
def __str__(self):
return repr(self.value)

try:

raise
MeuErro(2*2)
except MeuErro as e:
print 'Alguma coisa acontece, valor:', e.value
Geradores
Uma maneira de acelerar o for
Introdução
Thiago Sabatucci
thisab@ppgi.ufrj.br

OO
Outros conceitos
Atributos privados
Certas vezes, é preciso se assegurar de que as variáveis
internas da classe só sejam acessíveis por métodos
class A():
publico=0
__privado=0
Para isso, usa-se o __ antes da variável
a=A()
a.publico=5
a.__privado=3
OK
Erro de AtributeError
Atributos Privados
class A():
__privado=0
def mudaPrivado(self,x)
__privado=x
def retornaPrivado(self)
return __privado
>>>a=A()
>>>a.mudaPrivado(10)
>>>print a.retornaPrivado()
10
Sobrecarga de Operadores
Permite fazer operações com os objetos, como
soma, subtração,etc.
Exemplo: temos duas instâncias de Carro,
a
e
b
.
Se quisermos comparar se um carro é maior que o outro,
poderíamos fazer uma função dentro de Carro.
Ou então, é possível usar algo mais intuitivo:
a>b
Para isso, basta definir uma função especial dentro da classe:
__gt__
(contração para: Greater Than..)
class Carro():
largura=100
altura=110
comprimento=90
def volume(self):
return (largura*altura*comprimento)
def __gt__(self,outroCarro):
return self.volume()>outroCarro.volume()
Overload
Outras operações possíveis
+
-
*
/
<
>=
<=
==
!=
__add__
__sub__
__mul__
__div__
__lt__
__ge__
__le__
__eq__
__ne__
Além de muitas outras...
For usando range()
def firstn(n):
num, nums = 0, []
while num < n:
nums.append(num)
num += 1
return nums

sum_of_first_n = sum(firstn(1000000))
Full transcript