teorico2

Prévia do material em texto

Linguagem de 
Programação Aplicada 
Material Teórico
Responsável pelo Conteúdo:
Prof. Dr. Alcides Teixeira Barboza Junior
Revisão Textual:
Prof. Esp. Claudio Pereira do Nascimento
Orientação a Objetos
• Introdução;
• Conceitos Gerais de POO;
• Classes e Objetos;
• Métodos;
• Herança;
• Encapsulamento de Dados.
• Conhecer os conceitos da programação orientada a objetos;
• Aprender como criar e manipular classes e objetos em Python;
• Fazer uso de métodos dos objetos criados;
• Apresentar os conceitos de herança em Python.
OBJETIVOS DE APRENDIZADO
Orientação a Objetos
Orientações de estudo
Para que o conteúdo desta Disciplina seja bem 
aproveitado e haja maior aplicabilidade na sua 
formação acadêmica e atuação profissional, siga 
algumas recomendações básicas:
Assim:
Organize seus estudos de maneira que passem a fazer parte 
da sua rotina. Por exemplo, você poderá determinar um dia e 
horário fixos como seu “momento do estudo”;
Procure se alimentar e se hidratar quando for estudar; lembre-se de que uma 
alimentação saudável pode proporcionar melhor aproveitamento do estudo;
No material de cada Unidade, há leituras indicadas e, entre elas, artigos científicos, livros, vídeos 
e sites para aprofundar os conhecimentos adquiridos ao longo da Unidade. Além disso, você tam-
bém encontrará sugestões de conteúdo extra no item Material Complementar, que ampliarão sua 
interpretação e auxiliarão no pleno entendimento dos temas abordados;
Após o contato com o conteúdo proposto, participe dos debates mediados em fóruns de discus-
são, pois irão auxiliar a verificar o quanto você absorveu de conhecimento, além de propiciar o 
contato com seus colegas e tutores, o que se apresenta como rico espaço de troca de ideias e 
de aprendizagem.
Organize seus estudos de maneira que passem a fazer parte 
Mantenha o foco! 
Evite se distrair com 
as redes sociais.
Mantenha o foco! 
Evite se distrair com 
as redes sociais.
Determine um 
horário fixo 
para estudar.
Aproveite as 
indicações 
de Material 
Complementar.
Procure se alimentar e se hidratar quando for estudar; lembre-se de que uma 
Não se esqueça 
de se alimentar 
e de se manter 
hidratado.
Aproveite as 
Conserve seu 
material e local de 
estudos sempre 
organizados.
Procure manter 
contato com seus 
colegas e tutores 
para trocar ideias! 
Isso amplia a 
aprendizagem.
Seja original! 
Nunca plagie 
trabalhos.
UNIDADE Orientação a Objetos
Introdução
Na programação de computadores, existem diferentes paradigmas que 
influenciam a estrutura e forma que programamos na linguagem. Agora que você já 
estudou os conceitos da linguagem Python, nos quais estudamos e fizemos códigos 
seguindo um paradigma estruturado (também conhecido como imperativo), chegou 
a hora de verificar os conceitos do paradigma orientado a objetos.
A programação orientada a objetos (POO) está presente em diversas linguagens 
poderosas no mercado como, por exemplo, Java, C#, PHP, entre outras, assim, 
não seria diferente com o Python, ou seja, Python também nos permite trabalhar 
com esse paradigma, na verdade, tudo em Python são objetos.
Nesta unidade, iremos aprender os conceitos de POO aplicados no Python, isso 
dará auxílio no entendimento das demais unidades.
Conceitos Gerais de POO
Antes de verificarmos a aplicação da POO no Python, você se pergunta: o que 
é a programação orientada a objetos? Esta seção visa responder essa pergunta 
para você, então vamos começar!
A POO é um paradigma que interpreta um problema como uma coleção de 
objetos que interagem entre si por meio de troca de mensagens. Na programação 
estruturada, o programador pensa nas ações que precisam ser feitas e como dividi-
las em módulos. Já na POO, o programador pensa nos objetos necessário para 
resolver um problema e como eles interagem.
O canal Código Fonte TV tem um vídeo bem legal explicando a POO.
Disponível em: https://youtu.be/QY0Kdg83orY
Veja o vídeo no canal CCSL do IME/USP sobre POO (Python). 
Disponível em: https://youtu.be/frtaUi3B6Sc
Ex
pl
or
Podemos dizer que a POO possui os conceitos chaves:
• Herança;
• Encapsulamento;
• Polimorfismo.
Também temos os conceitos de classes e objetos. Sabendo entender esses princípios, 
você conseguirá desenvolver seus programas com orientação a objetos. Outro ponto 
que vale a pena destacarmos é que temos como forma de “desenhar” as classes do 
sistema chamado diagrama UML (Unified Modeling Language ou Linguagem de 
Modelagem Unificada).
Existem diferentes diagramas na UML, aqui vamos destacar o diagrama de classe, 
mas é interessante você pesquisar os demais para conhecimento. 
8
9
A figura 1 apresenta um diagrama de classe UML.
 
0 ..*
0 ..*
0 ..*
1
1
0 ..*
0 ..* 0 ..*
Produto
- marca: String
- valor: �oat
Produto (m: String, v:�oat)
//métodos de acesso
cadastro(): void
consulta(): String
- data: Data
- cliente: Cliente
- totalpedido: �oat
- produtos: ArrayList
- qtdefolhas: int
- tamanho: String
- tipo: String
- capadura: boolean
Caderno()
Caderno(q: int, t: String, t: String, 
c: boolean, m: String, v: �oat)
//métodos de acesso
cadastro(): void
- nome: String
- cpf: Spring
- telefone: String
- dia: int
- mes: int
- ano: int
Data(dia: int, mes: int, ano: int)
//métodos de acesso
- quantidade: int
- colorido: boolean
- graduacao: String
CaixaLapis()
CaixaLapis( q:int, c:boolean, g: 
String, m: String, v: �oat)
//métodos de acesso
cadastro(): void
consulta(): String
- cor: String
- tipo: String
- largura: �oat
- altura: �oat
- gramatura: int
- pautado: boolean
Papel()
Papel(c: String, t: String, I: �oat, a:�oat, 
g:int, p: boolean, m: String, v: �oat)
//métodos de acesso
cadastro(): void
consulta(): String
Cliente(n: String, c: String, t: 
String)
//método de acesso
Pedido()
//métodos de acesso
cadastro(): void
consulta(): String
calculaTotalPedido(): void
Papel CaixaLapis Caderno
Data
Cliente
Pedido
<< Manipulação >>
Figura 1 – Exemplo de diagrama de classe
No diagrama apresentado na figura 1, temos 8 caixas, 7 delas são classes 
e as demais simbologias que ligam essas caixas possuem relação com herança 
e associação. Note que cada caixa possui um título e duas regiões, a figura 2 
demonstra essa estrutura para uma classe.
Pessoa
nome: String
idade: int
renda: double
Pessoa()
Pessoa(n: String, i: int, r: double)
Figura 2 – Diagrama de classe, classe Pessoas
Como mencionamos, temos o nome da classe seguido pelos atributos da classe 
e por fim os métodos da classe. Os atributos são as características gerais que 
determinam os estados de um objeto; os métodos são as ações que o objeto pode 
fazer. Podemos dizer que a classe representa a abstração das características comuns 
mais relevantes (atributos e métodos) de um conjunto de objetos. A classe passa a 
ser um molde para se criar objetos do mesmo tipo.
Os atributos possuem valores e estes são definidos como estados do objeto. 
Imagine uma classe Pessoa que possua o atributo estado civil, podemos para uma 
pessoa inserir o valor de casada e para outra o valor de solteira, ou seja, estamos 
configurando o estado do atributo conforme o objeto criado.
9
UNIDADE Orientação a Objetos
Já os métodos são as funções ou ações que o objeto pode desempenhar, por 
exemplo, se tivermos uma classe Banco, esta pode ter o método sacar, esse método 
é responsável por realizar a ação de saque da conta do cliente.
Como falado, a classe é nosso molde e o objeto é criado a partir desse molde. 
Quando criamos o objeto, falamos que ele é uma instância, ou seja, estamos 
instanciando um objeto a partir de uma classe. Assim, em nosso código, iremos 
manipular o objeto e não a classe diretamente.
Os métodos são basicamente funções dentro de classes, você verá que para criar 
um método é só criar uma função com a palavra def.
Outro ponto importante em POO é a herança, pelo próprio nome fica claro 
seu significado, ou seja, alguém herdará algo. Neste conceito, existem dois papéis 
fundamentais, existe uma classe mais geral, chamada geralmentede superclasse ou 
classe pai e uma classe mais específica, chamada de subclasse ou classe filha.
A figura 3 demonstra um diagrama de classe com o conceito de herança.
 
Conta
ContaCorrente
- nome: String
- numero: String
#saldo: �oat
+ construtores
+ sets e gets
+ depositar(valor: �oat): void
+ print(): void
- limite: �oat
-construtores
+sets e gets
+ sacar(valor: �oat): void
+limiteUtilizado(): �oat
+print(): void
Figura 3 – Diagrama de classe com 
representação de herança
Perceba que a classe Conta é mais geral e a classe ContaCorrente é mais 
específica. Poderíamos ter, por exemplo, a classe ContaPoupança que assim como 
a outra classe corrente também é uma conta no banco.
Usamos a ideia de herança para reaproveitar código, então tudo que a classe pai 
tem, a classe filha também terá, isso aumenta o reuso em nossa aplicação dos códigos.
Até este ponto você viu o que é uma classe (uma especificação, molde); um 
objeto (instância de uma classe); uma classe é composta por atributos e métodos e 
sempre que quisermos aproveitar o código de uma classe, podemos usar o conceito 
de herança. Outro ponto chave da POO é a ideia de encapsulamento.
10
11
O encapsulamento nada mais é do que ocultamento de informações. Os usuários 
dos objetos não conhecem sua constituição e os utilizam através dos métodos públicos.
O encapsulamento elimina dependências diretas na implementação, possibili-
tando a mudanças sem afetar outros sistemas que utilizem o objeto, desde que as 
assinaturas dos métodos não sejam alteradas. Assim, pensando em um exemplo 
simples, podemos criar uma classe com um atributo x, esse atributo não pode ser 
acessado pelas classes filhas e nem diretamente pelo objeto, ou seja, ele deve ser 
encapsulado. Mas você se pergunta, como vamos acessar esse atributo?
A resposta é simples, por meio de métodos (funções) de acesso, os famosos getters 
e setters, um método get retorna o valor de um atributo e o método set atribui um valor 
para um atributo.
Os conceitos descritos até aqui de POO são gerais, contudo, dependendo da 
linguagem escolhida, podem ser mais diretos ou não. Nas próximas subunidades 
estudaremos como fazer tudo isso com a linguagem Python. 
Ressaltamos que estes são os conceitos mais elementares da POO, existem outros 
que não serão tratados aqui, mas vale a pena você pesquisar para conhecimento. 
Estes conceitos elementares darão a base para entendermos o uso de objetos e 
chamada de métodos das próximas subunidades.
Introdução à Programação Orientada a Objetos (POO), curso da fundação Bradesco. 
Disponível em: http://bit.ly/2QjYcVXE
xp
lo
r
Classes e Objetos
Daremos início ao desenvolvimento de POO no Python. Como falamos, tudo no 
Python é objeto, mas nesta subunidade iremos aprender a criar os nossos objetos a 
partir das classes que iremos definir.
A definição padrão de classe em Python é:
class ClassName:
 #declarações de:
 #atributos de atributos da classe 
 #inicializador da classe
 def __init__(self, <args>):
 //instruções 
 #declaração dos métodos
Por convenção, os nomes das classes são criados sempre com a primeira letra 
das palavras em maiúscula. O nome do arquivo .py deverá ter o mesmo nome dado 
à classe. 
11
UNIDADE Orientação a Objetos
No Python, temos a definição de variáveis de instância que são para dados 
exclusivos de cada instância (objeto) e as variáveis de classe que são atributos com-
partilhados por todas as instâncias da classe, ou seja, compartilhado por todos 
os objetos. As variáveis de instância são definidas no construtor e as variáveis de 
classe, na classe.
Os atributos de classe podem ser acessados sem a necessidade de se criar ou 
instanciar um objeto, eles são estáticos. Para acessar um atributo de classe, basta 
você colocar usar o nome_da_classe.nome_do_atributo.
Geralmente criamos as variáveis de classe para representar valores constantes, 
visto que estes valores serão compartilhados entre todos os objetos de uma classe.
No Python, temos uma diferença em relação a outras linguagens como Java, o 
construtor no Python é declarado com __new__ (método chamado quando criamos 
uma instância, objeto) e o método que podemos inicializar o objeto com atributos 
e valores é o __init__.
Exemplo 1: Imagine que precisamos fazer um sistema que guardará informa-
ções de carros, para isso, precisamos criar uma classe carro com atributos perti-
nentes a diferentes carros do segmento.
class Carro():
 def __init__(self, initMarca, initModelo, initCor):
 self.marca = initMarca
 self.modelo = initModelo
 self.cor = initCor
Neste exemplo, criamos a classe Carro com 3 atributos de instância (marca, 
modelo e cor). Para acessarmos os atributos dentro da classe, devemos utilizar a 
palavra self.
Com a classe criada, podemos criar nossos objetos e manipular seus atributos e 
métodos, vejamos alguns exemplos com base na classe Carro criada anteriormente.
Exemplos de criação de objetos em Python:
carro1 = Carro(“Fiat”,”UNO”,”preto”)
carro2 = Carro(“Honda”,”HR-V”,”preto”)
Para manipular os atributos de um objeto usamos o “.”.
Exemplo de acesso a atributos de objetos:
carro1.marca #retorna “Fiat”
carro2.marca = “Toyota” #altera de Honda para Toyota 
carro2.marca #retorna “Toyota”
Como você pode ter percebido, é muito simples manipular classes e objetos em 
Python, agora veremos na próxima seção como criar métodos em nossas classes e 
como fazer uso deles.
12
13
Métodos
Nesta seção, veremos como criar nossos métodos. Estudamos que uma classe é 
formada por atributos e métodos e que os métodos são as ações que a classe gene-
raliza indicando que os objetos instanciados poderão fazer.
Mas, como criamos métodos em Python? Métodos nada mais são que funções 
dentro de classes, assim, sua criação segue o mesmo princípio da criação de funções, 
ou seja, usaremos a palavra reservada “def” para criarmos nossos métodos.
É muito importante criarmos métodos que acessam os atributos, os chamados 
métodos de acesso, isso permite encapsular as informações como veremos na 
subunidade 6.
Além desses métodos de acesso aos atributos, você também irá criar métodos 
gerais que manipulam os atributos para tarefas determinadas. Todos os métodos 
podem ou não retornar um valor (palavra reservada return), tudo vai depender da 
sua necessidade.
No geral, criamos classes para as atividades de análise de dados e dentro destas 
classes criamos os métodos específicos para cada tarefa, com, por exemplo, métodos 
para calcular desvio padrão, métodos para gerar gráficos de barra, de setores etc.
Como já mencionamos, a sintaxe para criar os métodos é a mesma de funções, 
então vamos direto ao ponto, veremos agora alguns exemplos com métodos de 
acesso (get e set) e métodos específicos conforme a necessidade da classe.
Exemplo 1: Vamos criar uma classe Círculo, essa classe deve ter um atributo de 
classe chamado PI; o método de inicialização __init__ para atribuir o valor de um 
raio passado pelo usuário ao atributo de instância “raio”. Precisamos ainda criar 
o método de acesso setRaio para atribuir um valor novo de raio ao atributo, caso 
necessário, e o método de acesso getRaio para retornar o valor ou estado do raio 
atual. Esses são os elementos principais, contudo, podemos ter também um méto-
do para calcular e retornar a área do círculo, seguindo a fórmula matemática πr2. 
class Circulo():
 PI = 3.14
 def __init__(self, initRaio):
 self.raio = initRaio 
 #Método de acesso para configurar um novo raio 
 def setRaio(self, newRaio):
 self.raio = newRaio
 #Método de acesso para retornar o valor atual do raio 
 def getRaio(self):
 return self.raio
 # Método para calcular a área 
 # Perceba que iremos fazer o cálculo com os atributos da classe
13
UNIDADE Orientação a Objetos
 # O atributo da classe PI pode ser acessado 
 # colocando o nome da classe antes
 def calcArea(self):
 return Circulo.PI * (self.raio * self.raio) 
Com a classecriada, basta instanciar um objeto e fazer uso dos métodos que 
definimos anteriormente na classe. Veja a seguir, lembrando que isso é feito no 
bloco principal do nosso código:
circulo1 = Circulo(5) #instância 1 objeto
print(Circulo.PI) #acessa o valor da constante PI
print(circulo1.getRaio()) #imprime o valor do raio atual, igual a 5
circulo1.setRaio(10) #altera o valor do raio de 5 para 10
print(circulo1.getRaio()) #imprime o valor do raio atual, igual a 10
print(“Área = “, circulo1.calcArea()) #calcula e imprime a área do círculo 1
Procure refazer esse código no Python em sua máquina para treinar. 
Além dos métodos de acesso e métodos específicos, como o método calcArea, 
podemos criar em nossas classes métodos chamados de especiais. Você já utilizou 
um dos métodos especiais do Python, foi o __init__. Existem muitos métodos 
especiais no Python, veja alguns exemplos na figura 4 dos métodos especiais da 
nossa classe Círculo.
Figura 4 − Métodos especiais do Python
Fonte: Acervo do conteudista
14
15
Note primeiro que para listar os métodos especiais usamos o comando dir(objeto), 
ou seja, digitando dir(Circulo) listamos todos os métodos que temos em nossa classe 
juntamente com os especiais. 
Vamos usar o método especial __delattr__, esse método deleta um atributo do 
objeto, para usá-lo, você digita simplesmente del objeto.se_atributo, perceba que não 
digitamos __delattr__, digitamos somente “del”. O mais interessante é que podemos 
colocar dentro de nossas classes esses métodos especiais, vejamos um exemplo.
Exemplo: Criamos a classe Círculo anteriormente em nosso código, como apre-
sentado abaixo:
class Circulo():
 PI = 3.14
 def __init__(self, initRaio):
 self.raio = initRaio
 # Método de acesso para configurar um novo raio 
 def setRaio(self, newRaio):
 self.raio = newRaio
 # Método de acesso para retornar o valor atual do raio
 def getRaio(self):
 return self.raio
 # Método para calcular a área
 # Perceba que iremos fazer o cálculo com os atributos da classe
 # O atributo da classe PI pode ser acessado
 # Colocando o nome da classe antes
 def calcArea(self):
 return Circulo.PI * (self.raio * self.raio)
Se você tentar imprimir o objeto diretamente, print(circulo1), irá visualizar a re-
ferência dele na memória e não seus dados:
print(circulo1) #exibe <__main__.Circulo object at 0x057437D0>
Quando usamos o comando print, por exemplo, ele utiliza a função __str__ do 
Python, logo, podemos usar essa função dentro da nossa classe, assim, quando 
chamarmos o print novamente, ele irá imprimir corretamente o que queremos. 
Exemplo da classe Círculo alterada:
class Circulo():
 PI = 3.14
 def __init__(self, initRaio):
 self.raio = initRaio 
15
UNIDADE Orientação a Objetos
 #Método de acesso para configurar um novo raio 
 def setRaio(self, newRaio):
 self.raio = newRaio
 #Método de acesso para retornar o valor atual do raio 
 def getRaio(self):
 return self.raio
 #Método para calcular a área 
 #Perceba que iremos fazer o cálculo com os atributos da classe
 #O atributo da classe PI pode ser acessado 
 #colocando o nome da classe antes
 def calcArea(self):
 return Circulo.PI * (self.raio * self.raio) 
 #Método __str__
 def __str__(self):
 return (“Círculo de raio: “+ str(self.raio) + “, área: “ + 
str(self.calcArea()))
Analise o método __str__, nós praticamente criamos uma string específica, ago-
ra chame o método print com um objeto instância.
circulo2 = Circulo(10)
print(circulo2) #irá retornar “Círculo de raio: 10, área: 314.0”
Notou a diferença? Isso nos permite recriar em nossas classes diversos mé-
todos especiais do Python, dependendo do tipo da classe que queremos criar e 
suas funcionalidades. 
Vamos avançar agora e estudar como usar herança em Python na próxima 
subunidade.
Descritores em Python. Disponível em: https://ibm.co/2m7XqwD
Métodos especiais. Disponível em: http://bit.ly/2kxWgtUE
xp
lo
r
Herança
Na subunidade 2, estudamos os conceitos gerais de POO e comentamos sobre 
a herança. Herança, como vimos, é uma forma de reaproveitar código e diminuir 
a complexidade dos programas, estendendo nossas classes.
Para trabalharmos com herança em Python, iremos usar a seguinte sintaxe:
class subclasse(superclasse,...)
16
17
Vamos ver um exemplo de herança em Python.
Exemplo: Vamos criar a estrutura apresentada na figura 5, na qual temos uma 
superclasse FormaGeometrica e duas subclasses (Círculo e Quadrado).
Figura 5 − Herança de formas geométricas
Fonte: Acervo do conteudista
Vamos ao código:
#classe FormaGeometrica
class FormaGeometrica():
 def __init__(self,initX,initY):
 self.x = initX
 self.y = initY
 def getX(self):
 return self.x
 def setX(self, newX):
 self.x = newX
 def getY(self):
 return self.y
 def setY(self, newY):
 self.y = newY
#classe Circulo
class Circulo(FormaGeometrica):
 PI = 3.14
 def __init__(self, initRaio, initX, initY):
 #precisamos chamar o __init__ da classe pai
 super().__init__(initX, initY)
 self.raio = initRaio
17
UNIDADE Orientação a Objetos
 def setRaio(self, newRaio):
 self.raio = newRaio
 def getRaio(self):
 return self.raio
 def calcArea(self):
 return Circulo.PI * (self.raio * self.raio)
 def __str__(self):
 return (“Círculo de raio: “+ str(self.raio) + “, área: “ + 
str(self.calcArea()) +”\n”+ “(X,Y)=(“+str(self.getX())+”,”+str(self.
getY())+”)”)
#classe Quadrado
class Quadrado(FormaGeometrica):
 def __init__(self, initLado, initX, initY):
 super().__init__(initX, initY)
 self.lado = initLado 
 def setLado(self, newLado):
 self.lado = newLado
 def getLado(self):
 return self.lado
 def calcArea(self):
 return (self.lado*self.lado)
 def __str__(self):
 return (“Quadrado de lados: “+ str(self.lado) + “, área: “ 
+ str(self.calcArea()) +”\n”+ “(X,Y)=(“+str(self.getX())+”,”+str(self.
getY())+”)”)
Note que nas classes filhas, podemos usar os métodos getX e getY com a pala-
vra reservada self, assim, podemos acessar os recursos da classe pai. Vamos criar 
agora objetos dessas classes filhas.
forma1 = Circulo(10, 2,3) #Circulo(raio, x , y)
forma2 = Quadrado(20, 0,0) #Quadrado(lado, x, y)
forma2.setLado(30) #altera o lado do quadrado
forma2.setX(10) #alteramos o X do Quadrado
print(forma1) 
# a linha acima retorna:
# Círculo de raio: 10, área: 314.0 
# (X,Y)=(2,3) 
print(forma2)
# a linha acima retorna:
# Quadrado de lados: 30, área: 900
# (X,Y)=(10,0)
18
19
Veja mais alguns exemplos de herança: Disponível em:
• http://bit.ly/2mfWzKf
• http://bit.ly/2myfnEM
Ex
pl
or
Encapsulamento de Dados
A linguagem Python não possui os modificadores de acesso iguais as outras 
linguagens como Java, C#, PHP etc. Contudo, ainda sim é possível definirmos 
atributos ou métodos que não podem ser acessados fora da classe “de forma fácil”, 
isso seria equivalente ao modificador private, por exemplo. 
Atenção, o Python só oculta os atributos ou métodos “privados”, ele não bloqueia 
realmente o acesso a estes, sendo assim, podemos dizer que no Python existe uma 
nomenclatura para a criação de atributos e métodos com acesso restrito, é uma 
convenção que indica ao desenvolvedor o que pode ou não ser acessado fora da 
classe, mas, novamente, o acesso ainda é possível, ele só fica mais “complicado”.
Podemos criar atributos/métodos fracamente privados com um underscore “_” 
e fortemente privados com dois underscores “__”.
Vamos ver alguns exemplos:
Exemplo 1: Atributo e método “fracamente privados”, neste caso é somente ocul-
to o atributo e o método, mas ainda podemos acessá-los como veremos na execução.
#classe conta com 2 atributos e 1 método “privados”
class Conta():
 def __init__(self,initNum,initSaldo):
 self._numero = initNum
 self._saldo = initSaldo
 def _adicionarBonus(self):
 self._saldo += 1000
Se tentarmos executar diretamente os elementos fracamente privados, teremos 
um erro:
conta1 = Conta(1,1200) #cria a conta
conta1.numero #o atributo não “existe”
# AttributeError: ‘Conta’ object has no attribute ‘numero’
conta1.adicionarBonus()# AttributeError: ‘Conta’ object has no attribute ‘adicionarBonus’
19
UNIDADE Orientação a Objetos
Como falamos, os atributos/métodos ficam ocultos, logo, se colocar o “_” na 
chamada, conseguimos acesso a ambos:
conta1._numero #retorna 1
conta1._adicionarBonus() #acesso o método
conta1._saldo #retorna 2200
Você percebeu que os atributos/métodos fracamente privados podem ser 
acessados normalmente. Agora vamos dificultar um pouco mais esse acesso, vamos 
criar atributos/métodos fortemente privados.
Exemplo: Atributos e métodos “fortemente privados”:
class Conta():
 def __init__(self,initNum,initSaldo):
 self.__numero = initNum
 self.__saldo = initSaldo
 def __adicionarBonus(self):
 self.__saldo += 1000
 def getSalfo(self):
 return str(self.__saldo)
Vamos tentar agora acessar os atributos/métodos como fizemos anteriormente, 
porém, agora vamos utilizar dois underscores “__”:
conta1 = Conta(1,1200) #cria o objeto
conta1.__saldo
# AttributeError: ‘Conta’ object has no attribute ‘__saldo’
conta1.__adicionarBonus()
# AttributeError: ‘Conta’ object has no attribute ‘__adicionarBonus’
Nestes exemplos, vimos que não podemos acessar nem mesmo colocando os 
dois “__”, mas existe um recurso que nos permite acessar tais elementos “privados”. 
Vamos utilizar _NomeClasse__nomeAtributo ou _NomeClasse__nomeMétodo.
Exemplo:
conta1._Conta__saldo #retorna 1200
conta1._Conta__adicionarBonus() #chama o método
conta1._Conta__saldo #retorna 2200
Em resumo, somente podemos ocultar ou dificultar o acesso aos atributos/méto-
dos da classe, os programadores Python sabem disso quando visualizam algo com 
_ ou __, então é mais uma convenção do que uma regra rígida da linguagem.
20
21
Nesta unidade você teve contato com a orientação a objetos no Python, isso é 
importante para entender as demais unidades da disciplina. Ressaltamos que não 
necessariamente precisaremos criar classes para fazer nossas análises, mas você 
está livre para decidir. 
Nosso objeto foi apresentar os conceitos de POO e mais que isso, mostrar 
como acessar atributos e métodos de classes, isso será útil, pois nas próximas 
unidades trabalharemos com diversos pacotes que irão nos fornecer ferramentas 
para trabalharmos com nossas análises de dados em Python. Com esses pacotes, 
precisaremos criar objetos e manipular eles. 
Veja mais sobre encapsulamento em Python. Disponível em: http://bit.ly/2kVZ1Wk
Ex
pl
or
21
UNIDADE Orientação a Objetos
Material Complementar
Indicações para saber mais sobre os assuntos abordados nesta Unidade:
 Leitura
Programação Orientada a Objetos em Python
http://bit.ly/2mAFNpr
Python Tutorial
http://bit.ly/2mDFfiJ
Documentação do Python 3.7 – Classes
http://bit.ly/2l6PPOO
Referência da linguagem Python
http://bit.ly/2mDxSI4
22
23
Referências
BECKER, J. L.. Estatística básica: transformando dados em informação. Porto 
Alegre: Bookman, 2015.
CASTRO, L. N. de. Introdução à mineração de dados: conceitos básicos, 
algoritmos e aplicações. São Paulo: Saraiva, 2016.
PERKOVIC, L.; VIEIRA, D.. Introdução à computação usando Python: um foco 
no desenvolvimento de aplicações. Rio de Janeiro: LTC, 2016.
23