Introdução à linguagem Python
Thiago Martins
Orientação a objetos
●
Idéia central: Representar a computação como um conjunto de entidades
(“agentes” ou “objetos”) que interagem entre si para realizar tarefas
(objetos).
●
Objetos podem representar entidades concretas ou abstratas.
●
O funcionamento de objetos (o seu estado e como ele evolui) é
encapsulado.
●
Cada objeto expõe interfaces. As interfaces governam a interação entre
objetos.
●
A interface é de certa forma um “contrato”, um objeto que expõe uma
dada interface está comprometido com um certo comportamento.
2
Orientação a objetos
●
1950-1960: Foco em algoritmos e no fluxo de controle, voltados a
resolução de problemas de cálculo e manipulação simples de dados
(Fortran, Algol).
●
1970-1980: Foco no fluxo de dados e programaçãoestruturada (Cobol,
Pascal, C).
●
1990-2000: Orientação a objetos: sistemas decompostos em estrutura
formada por classes e objetos (C++, Java).
●
Hoje?
3
Orientação a objetos
●
1950-1960: Foco em algoritmos e no fluxo de controle, voltados a
resolução de problemas de cálculo e manipulação simples de dados
(Fortran, Algol).
●
1970-1980: Foco no fluxo de dados e programaçãoestruturada (Cobol,
Pascal, C).
●
1990-2000: Orientação a objetos: sistemas decompostos em estrutura
formada por classes e objetos (C++, Java).
●
Hoje?
4
Orientação a objetos em Python
●
Python é uma linguagem orientada à objetos?
●
SIM:
●
Todos os dados primitivos são objetos!
●
Permite a criação de novas classes de objetos (embora seja possível
criar objetos sem classes)
●
NÃO:
●
A sintaxe linguagem é na prática independente de conceitos de OO.
●
Python não dispõe de mecanismos de controle de encapsulamento.
5
Orientação a objetos em Python
●
Todos os dados podem ser tratados como objetos (e de fato o são?).
a = 1
dir(a)
●
As interfaces são implementadas em Python por métodos.
●
Um método se assemelha a uma função aplicada a um objeto.
a = [5,4,3,2,1]
a.sort()
●
Métodos também podem receber parâmetros e retornar valores
a = [1,2,2,1,3]
a.count(1)
6
Orientação a objetos em Python
●
Classes em Python
●
No mundo de OO, uma Classe serve para declarar uma categoria de
objetos, com comportamento uniforme.
class Valor():
def __init__(self, x=0):
self._x = x
def incrementa(self):
self._x += 1
def __str__(self):
return(str(self._x))
7
Orientação a objetos em Python
●
MAS comportamento de objetos
pode ser modificado após a
criação!
class ObjetoVazio(): print(a.um_valor)
pass print(a.outro_valor)
a = ObjetoVazio() a.cumprimento()
a.um_valor = 1 b = a
a.outro_valor = “dois” b.cumprimento()
def ola():
print(“olá”)
“Monkey-Patching”
a.cumprimento = ola
8
Orientação a objetos em Python
●
O método __init__ é invocado para criar uma instância ou seja, um objeto
da classe declarada.
a = Valor(1)
print(a)
a.incrementa()
O mesmo que Valor.incrementa(a)
print(a)
print(a._x)
●
Em geral, métodos e campos com nomes iniciados por _ não devem ser
acessados por fora da classe. – Mais sobre isso adiante –
●
Métodos iniciados e terminados por __ são especiais e têm um significado
especial na linguagem. __str__ por exemplo é invocado para se obter a
representação em string do objeto.
9
Classes em Python
Construtor
class Valor():
def __init__(self, x=0):
self._x = x
def incrementa(self): Métodos
self._x += 1
def __str__(self):
return(str(self._x))
Atributo de
objeto
Corpo da classe
10
Uma classe também é um objeto
class Classe(): a = Classe()
mensagem = “olá!” a.mostra_mensagem()
def muda_mensagem(nova): Classe.muda_mensagem(“adeus”)
Classe.mensagem = nova a.mostra_mensagem()
def mostra_mensagem(self):
print(Classe.mensagem)
11
Orientação a objetos em Python
●
Herança: É possível criar classes que extendem uma classe preexistente.
class ValorSomavel(Valor):
def __init__(self, x=0):
super().__init__(x)
def __add__(self, outro):
return ValorSomavel(self._x + outro._x)
12
Orientação a objetos em Python
●
Herança: Métodos podem ser sobrepostos
class Pessoa():
def __init__(self, telefone):
self._telefone = telefone
def mostra_contato(self):
print(“Telefone: “ + str(self._telefone))
class Funcionario(Pessoa):
def __init__(self, telefone, ramal):
self._ramal = ramal
super().__init__(telefone)
def mostra_contato(self):
print(“Telefone: “ + str(self._telefone))
print(“Ramal: “ + str(self._ramal))
13
Orientação a objetos em Python
●
Herança: Métodos podem ser sobrepostos. Super também funciona aqui
class Pessoa():
def __init__(self, telefone):
self._telefone = telefone
def mostra_dados(self):
print(“Telefone: “ + str(self._telefone))
class Funcionario(Pessoa):
def __init__(self, telefone, ramal):
self._ramal = ramal
super().__init__(telefone)
def mostra_contato(self):
super().mostra_dados()
print(“Ramal: “ + str(self._ramal))
14
Orientação a objetos em Python
●
Herança múltipla...
class Pessoa(): class Aluno(Pessoa):
def __init__(self, **args): def __init__(self, **args):
self._nome = args['nome'] self._curso = args['curso']
super().__init__(**args)
def mostra_dados(self):
print(f"Nome: {self._nome}") def mostra_dados(self):
super().mostra_dados()
class Funcionario(Pessoa): print(f'Curso: {self._curso}')
def __init__(self, **args):
self._cargo = args['cargo'] class Monitor(Aluno, Funcionario):
super().__init__(**args) def __init__(self, **args):
super().__init__(**args)
def mostra_dados(self):
super().mostra_dados() def mostra_dados(self):
print(f'Cargo: {self._cargo}') super().mostra_dados()
15
Orientação a objetos em Python
●
Herança múltipla…
A ordem de chamada de métodos NÃO é trivial!
class O(): class C(D, F):
def msg(self): def msg(self):
print("O") print("C")
super().msg()
class F(O):
def msg(self): class B(D, E):
print("F") def msg(self):
super().msg() print("B")
super().msg()
class E(O):
def msg(self): class A(B, C):
print("E") def msg(self):
super().msg() print("A")
super().msg()
class D(O):
def msg(self):
print("D")
super().msg()
16
