Aula Sobrecarga de Operadores - Python Computação II - Engenharia Mecânica UFRJ

Prévia do material em texto

Orientação a objetos no Python – 
Sobrecarga de Operadores
 
Sobrecarga de Operadores
● No Python, o comportamento dos operadores é definido 
por métodos especiais, que por convenção, têm nomes 
que começam e terminam com “__”.
Alguns:
 
Sobrecarga de Operadores
● Operadores como +, - e * podem ser aplicados a 
objetos como inteiros e strings gerando diferentes 
resultados dependendo do tipo do objeto. O sinal + 
aplicado a dois inteiros resulta na sua soma, enquanto 
sobre strings resulta na sua concatenação. 
● Podemos implementar o comportamento deste 
operador sobre duas instâncias definindo-o dentro de 
sua classe.
 
Exemplo
class Inteiro:
 def __init__(self,entrada):
 self.__valor = entrada
def getValor(self):
 return self.__valor
 def __add__(self,outro):
 return self.getValor() + outro.getValor()
>>> a = Inteiro(20)
>>> b = Inteiro(10)
>>> a + b
>>> 30
 
Exemplo
 class String(str):
 def __sub__(self, s):
 return self.replace(s,'')
>>> s1 = String(" Luis Carlos Duarte")
>>> s2 = String(" Duarte")
>>> s1 - s2
' Luis Carlos'
 
Exemplo
● Claro que não precisamos criar nem a classe Inteiro e 
nem a classe String, pois estas já existem no Python, 
mas e se quiséssemos, por exemplo, representar 
frações? Somar frações? Multiplicar frações?
● Uma fração são dois inteiros na forma a/b. a é um 
inteiro e b é um inteiro diferente de zero.
● Uma classe em Python que modela o comportamento 
das frações é dada a seguir.
 
Exemplo
 class Fracao:
def __init__(self, numerador, denominador):
 self.__numerador = numerador
 self.__denominador = denominador
def __str__(self):
 return str(self.__numerador) + '/' + 
str(self.__denominador)
>>> a = Fracao(1,2)
>>> print a
1/2
 
Exemplo
● E como seria a multiplicação de duas frações?
 
Exemplo
 def __mul__(self, outro):
 numerador = self.getNumerador()*outro.getNumerador()
denominador = self.getDenominador()*outro.getDenominador()
 return Fracao(numerador, denominador)
>>> a = Fracao(1,2)
>>> b = Fracao(3,4)
>>> c = a*b
>>> print c
3/8
 
Exemplo
● Quando definimos o método __mul__() estamos 
fazendo a sobrecarga do operador *. 
● O método __mul__ sempre vai exigir dois parâmetros, 
o self que é o próprio objeto que está à esquerda do 
operador e outro objeto que chamamos de outro, que 
vai estar à direita do operador *.
 
Sobrecarga de Operadores
● Sobrecarga de operadores é uma maneira muito 
elegante de implementar uma álgebra simples para 
suas classes.
● No exemplo da Fracao, se não usássemos sobrecarga 
de operadores, teríamos que fazer um novo método 
para a multiplicação, como por exemplo:
a = Fracao(1,2)
 b = Fracao(3,4)
 c = a.multiplica(b)
● Com sobrecarga, a semântica do operador * ficou 
encapsulada dentro da classe.
 
Sobrecarga de Operadores
● Alguns outros operadores que podem ser 
sobrecarregados:
 
Exercícios
1) Complete o exemplo da Fração. Defina métodos para 
adição, subtração e divisão de frações. Além dos 
métodos que sobrecarregam os operadores, utilize 
funções auxiliares apropriadas para frações. Com o uso 
de excecões, evite que sejam atribuídos denominadores 
com valor 0.
 
Exercícios
2) Desenvolva uma classe para trabalhar com números 
complexos, na qual estejam definidas as quatro 
operacões básicas com este conjunto numérico.
 
Exercícios
3) Desenvolva uma classe Relógio que represente um horário no 
formato HH:MM:SS. Com o auxílio de exceções, evite que sejam 
atribuídos valores inválidos para hora, minuto e segundo. 
Sobrecarregue os métodos __str__, __add__, __sub__, 
__eq__,__gt__, de forma a permitir os seguintes testes:
>>> c1 = Relogio(18,37,32)
>>> c2 = Relogio(20,0,30)
>>> print c1
18:37:32
>>> print c2
20:00:30
>>> c3 = c1 + c2
>>> print c3
14:37:02
>>> c3 = c1 - c2
>>> print c3
22:37:02
>>> c1 == c2
False
>>> c1 > c2
False
 
Exercícios
4) Considere a definição de um ponto: P = (X,Y), onde X e Y são 
as coordenadas do ponto. Implemente uma classe para definir 
pontos na qual estejam definidas as seguintes operações:
Sejam dois pontos P1 = (X1,Y1) e P2 = (X2,Y2):
– impressão do ponto P1 na tela: (X1,Y1)
– Adição: P1 + P2 : P3 = (X1 + X2, Y1 + Y2)
– Subtração: P1 - P2 : P3 = (X1 - X2, Y1 – Y2)
– multiplicação de dois pontos: P1 * P2 : X1*X2 + Y1*Y2
– multiplicação de um escalar por um ponto: n*P1 : P3 = 
(n*X1,n*Y1) (o método a ser sobrecarregado é o 
__rmul__)
Um Exemplo é dado na proxima transparência.
 
Exercícios
4) 
Exemplo:
>>> p1 = Ponto(3,4)
>>> p2 = Ponto(5,7)
>>> print p1
(3,4)
>>> p3 = p1+p2
>>> print p3
(8,11)
>>> p3 = p1-p2
>>> print p3
(-2,-3)
>>> p3 = p1*p2
>>> print p3
43
>>> d = 2*p2
>>> print d
(10,14) 
	Slide 1
	Slide 2
	Slide 3
	Slide 4
	Slide 5
	Slide 6
	Slide 7
	Slide 8
	Slide 9
	Slide 10
	Slide 11
	Slide 12
	Slide 13
	Slide 14
	Slide 15
	Slide 16
	Slide 17