Programação
Orientada a Objetos
com Python
Prof. Alexandre de Assis Bento Lima
assis@[Link]
Objetos e Classes em Python (...)
● Em Python, todos os dados são tratados como
Objetos
● Um objeto é uma abstração que representa uma
entidade do domínio do problema
● Todo objeto possui
○ Um estado, representado pelos valores dos seus
atributos
○ Um ou mais métodos
● Uma Classe é um tipo de um objeto. Ela representa
um conjunto de objetos com os mesmos tipos de
atributos e mesmos métodos.
2
Objetos e Classes em Python (...)
● As classes são utilizadas em Python para a
implementação de novos tipos de dados
● Cada objeto é uma instância de uma classe
● Em Python, ao executarmos um comando de
atribuição (=), um objeto é criado (uma classe é
instanciada) e associado a uma variável
● Pyhton é uma linguagem totalmente orientada a
objetos. Mesmo tipos primitivos em outras
linguagens, como números inteiros e de ponto
flutuante, são classes nesta linguagem
3
Objetos e Classes em Python
● Por exemplo, ao executarmos o
temperatura
comando
temperatura = 15.5
float
um objeto da classe float é criado em 15.5
memória com o valor 15.5 e associado
à variável “temperatura”
● Ao contrário de outras linguagens, como C, C++ e Java,
Python não exige que declaremos o tipo de dados ou a classe
de uma variável ao criá-la
● Assim, uma mesma variável pode apontar para objetos de
diferentes classes durante sua existência
● Dizemos que Python é uma linguagem com tipos dinâmicos
4
Classes Predefinidas em Python
● A linguagem Python possui uma série de classes
predefinidas (built-in classes), como
○ bool, int, float, list, tuple, str, set e dict, por exemplo
● Uma classe é imutável se seu estado não puder
sofrer modificações
○ Exemplos: bool, int, float, tuple, str
● Ao contrário, uma classe é dita mutável se seu
estado puder ser modificado
○ Exemplos: list, dict
5
Criação de Classes em Python
● Python permite a definição de novas classes
● Tal característica é fundamental para a criação de novas
Estruturas de Dados a serem utilizadas em algoritmos
● Uma classe é definida em Python através da palavra
reservada class, do seu nome e de “:”.
● Por exemplo, para definirmos a classe vazia
ClasseExemplo, sem atributos nem métodos:
class ClasseExemplo:
pass # classe “vazia”
● Para criarmos um objeto da classe ClasseExemplo e o
atribuirmos a uma variável denominada v, devemos fazer:
v = ClasseExemplo()
6
Declaração de Métodos (...)
● Da mesma forma que uma função, um método é declarado
através da palavra reservada def, mas ela deve se encontrar
“dentro” da declaração da classe
● Métodos e funções são similares nos seguintes aspectos:
○ Executam comandos
○ Podem receber parâmetros
○ Podem ter variáveis locais
○ Podem retornar valores (comando return)
● Ao contrário das funções, os métodos
○ Têm acesso aos atributos do objeto
○ Precisam ser invocados sempre a partir de um objeto
■ A forma mais utilizada de invocação se dá através do
operador ponto (“.”).
7
Declaração de Métodos
● Particularidade do Python:
○ Todo método deve ter como primeiro parâmetro uma
referência para o objeto (instância) que o invoca. É uma
convenção denominar esse primeiro parâmetro self.
○ self não é palavra reservada do Python
■ O parâmetro poderia ter qualquer nome, mas isso é
evitado para melhorar a legibilidade do código
8
Exemplo: CalcV1 - uma Calculadora
sem Memória (...)
● Vamos declarar uma classe que implementa uma
calculadora simples, com as quatro operações
básicas: adição, subtração, multiplicação e adição
○ Cada operação será implementada através de um
método
○ A calculadora não terá função “memória”
CalcV1
somar(parcela1, parcela2)
subtrair(minuendo, subtraendo)
multiplicar(fator1, fator2)
dividir(dividendo, divisor)
9
Exemplo: CalcV1 - uma Calculadora
sem Memória (...)
class CalcV1:
def somar(self, parcela1, parcela2):
return parcela1 + parcela2
def subtrair(self, minuendo, subtraendo):
return minuendo - subtraendo
def multiplicar(self, fator1, fator2):
return fator1 * fator2
def dividir(self, dividendo, divisor):
return dividendo / divisor
10
Exemplo: CalcV1 - uma Calculadora
sem Memória (...)
class CalcV1:
def somar(self, parcela1, parcela2):
return parcela1 + parcela2
def subtrair(self, minuendo, subtraendo):
return minuendo - subtraendo
métodos
def multiplicar(self, fator1, fator2):
return fator1 * fator2
def dividir(self, dividendo, divisor):
return dividendo / divisor
11
Exemplo: CalcV1 - uma Calculadora
sem Memória (...)
O primeiro parâmetro de cada método é uma
class CalcV1: referência ao objeto através do qual se dá a chamada
def somar(self, parcela1, parcela2):
return parcela1 + parcela2
def subtrair(self, minuendo, subtraendo):
return minuendo - subtraendo
def multiplicar(self, fator1, fator2):
return fator1 * fator2
def dividir(self, dividendo, divisor):
return dividendo / divisor
12
Exemplo: CalcV1 - Utilização (...)
● Vamos instanciar CalcV1 no console Python e utilizá-la
>>> c = CalcV1() # a variável c referencia uma instância de CalcV1
>>> [Link](2,3) # invocação do método somar()
5
>>> [Link](9,2) # invocação do método dividir()
4.5
>>> # comportamento padrão quando pedimos que o Python escreva
>>> # na tela uma instância de uma classe que definimos: escrever
>>> # o endereço do objeto na memória
>>> print(c)
<__main__.CalcV1 object at 0x7ff77fafb700>
13
Exemplo: CalcV1 - Utilização
● Se criarmos uma nova instância, podemos
observar, pelo endereço em memória, que se trata
de um novo objeto da mesma classe
>>> c2 = CalcV1() # c2 referencia uma nova instância de CalcV1
>>> print(c2)
<__main__.CalcV1 object at 0x7ff77fafabf0>
>>> print(c) Endereços diferentes
<__main__.CalcV1 object at 0x7ff77fafb700>
14
Atributos (...)
● Os dados ou valores das propriedades de um objeto ficam
armazenados em seus atributos. Os atributos funcionam
então como “variáveis internas” dos objetos
● Assim como as variáveis comuns em Python, atributos novos
para objetos podem ser criados dinamicamente, a qualquer
momento
○ Isso pode levar à existência de objetos da mesma classe
com atributos diferentes, caso o programador não adote
boas práticas de programação!
● Para evitar este problema, a seguinte prática é adotada em
Python:
○ Todos os atributos dos objetos de uma classe devem ser
criados apenas no método construtor da mesma
15
Atributos
● Para acessarmos um atributo em um método da sua classe,
utilizamos
self.nome_do_atributo
● Para acessarmos um atributo fora da classe, utilizamos o
operador ponto (“.”), como fazemos com os métodos
○ Essa operação deve ser evitada, pois representa uma
quebra de encapsulamento (veremos este conceito mais
tarde)
16
Atributos e Método Construtor
● Em várias linguagens OO, quando um objeto é criado, um
método especial de sua classe é invocado
○ Este método é genericamente denonimado método
construtor
● Em Python, sempre que um objeto é criado, o método
__init__ é invocado. Por isso, ele é utilizado como construtor
por muitos desenvolvedores
● Para implementarmos um construtor para uma nova classe,
basta declararmos um método __init__ na mesma
● Sempre que a classe possuir atributos, vamos criá-los no
__init__
○ Se não houver valor inicial para um atributo, ele pode ser
inicializado com None, zero, string vazia ou qualquer
outro valor que se escolha
17
Exemplo: uma Calculadora com
Memória (...)
● Vamos criar a classe Calculadora a partir de CalcV1
● Objetos dessa classe vão ser calculadoras com
“memória”. Como em uma calculadora comum, será
possível:
○ Armazenar um valor para cálculos futuros.
○ Recuperar o valor armazenado
○ Somar e subtrair valores diretamente ao que está armazenado
em memória
● O valor armazenado em memória precisa ficar
armazenado no objeto enquanto ele existir e não
apenas durante a execução de um método, como em
uma variável ou parâmetro
● Sendo assim, precisamos de um atributo para
armazenar o valor em memória 18
Exemplo: uma Calculadora com
Memória (...)
Calculadora
memória
somar(parcela1, parcela2)
subtrair(minuendo, subtraendo)
multiplicar(fator1, fator2)
dividir(dividendo, divisor)
memoArmazenar(valor)
memoAdicionar(valor)
memoSubtrair(valor)
memoRecuperar()
memoLimpar()
19
Exemplo: uma Calculadora com
Memória (...)
Calculadora
memória
atributo
somar(parcela1, parcela2)
subtrair(minuendo, subtraendo)
multiplicar(fator1, fator2)
dividir(dividendo, divisor)
memoArmazenar(valor) novos métodos
memoAdicionar(valor)
memoSubtrair(valor)
memoRecuperar()
memoLimpar()
20
Exemplo: uma Calculadora com
Memória (...)
class Calculadora:
def __init__(self):
[Link] = 0.0
… # métodos já declarados
def memoArmazenar(self,valor):
[Link] = float(valor)
def memoAdicionar(self,valor):
[Link] += float(valor)
def memoSubtrair(self,valor):
[Link] -= float(valor)
def memoRecuperar(self):
return [Link]
def memoLimpar(self):
[Link] = 0.0
21
Exemplo: uma Calculadora com
Memória (...)
class Calculadora: método construtor
def __init__(self):
[Link] = 0.0
… # métodos já declarados
def memoArmazenar(self,valor):
[Link] = valor
def memoAdicionar(self,valor):
[Link] += valor
def memoSubtrair(self,valor):
[Link] -= valor
def memoRecuperar(self):
return [Link]
def memoLimpar(self):
[Link] = 0.0
22
Exemplo: uma Calculadora com
Memória (...)
class Calculadora:
def __init__(self):
[Link] = 0.0 Atribuição de valor ao atributo. Como ele
… # métodos já declarados ainda não existe, é criado.
def memoArmazenar(self,valor):
[Link] = float(valor)
def memoAdicionar(self,valor):
[Link] += float(valor)
def memoSubtrair(self,valor):
[Link] -= float(valor)
def memoRecuperar(self):
return [Link]
def memoLimpar(self):
[Link] = 0.0
23
Exemplo: uma Calculadora com
Memória (...)
class Calculadora:
def __init__(self):
[Link] = 0.0
… # métodos já declarados
def memoArmazenar(self,valor):
[Link] = float(valor) Modificação do valor do atributo. Como o
__init__ foi obrigatoriamente executado,
def memoAdicionar(self,valor):
o atributo já existe no objeto.
[Link] += float(valor)
def memoSubtrair(self,valor):
[Link] -= float(valor)
def memoRecuperar(self):
return [Link]
def memoLimpar(self):
[Link] = 0.0
24
Exemplo: uma Calculadora com
Memória (...)
● Vamos utilizar a nova calculadora
>>> calc = Calculadora()
>>> [Link] # acesso ao atributo
0.0
>>> [Link]() # melhor acessar via método
0.0
>>> [Link](15) # armazenamos o valor 15
>>> [Link]()
15.0
>>> [Link](10)
>>> [Link]()
25.0
25
Exemplo: uma Calculadora com
Memória
● Criando um novo objetos, observamos que cada um possui
seu próprio estado
>>> cal2 = Calculadora()
>>> [Link](100) # armazenamos o valor 100
>>> [Link] # estado de cal2
100.0
>>> [Link] # estado de calc
25.0 memoria 25.0
variáveis
calc
cal2 memoria 100.0
26
Exemplo - Classe Gato (...)
● Vamos criar uma classe com vários atributos. Valores
serão passados no momento da criação de cada objeto.
● A casse será denominada Gato
○ Objetos desta classe devem possuir 4 atributos: nome,
sexo, data de nascimento e raça
○ Apenas o nome e o sexo são obrigatórios durante a
criação de um objeto desta classe
■ Se a data de nascimento e/ou a raça forem
desconhecidas, devem receber o valor
“Desconhecida”.
○ Claramente, cada objeto desta classe vai possuir valores
próprios para os atributos descritos. Então, utilizar o
construtor para defini-los é a melhor alternativa
27
Exemplo - Classe Gato (...)
● A classe pode ser definida da seguinte forma:
class Gato:
def __init__(self, nome, sexo, datanasc = ‘Desconhecida’,
raca = ‘Desconhecida’):
[Link] = nome
[Link] = sexo
[Link] = datanasc
[Link] = raca
28
Exemplo - Classe Gato (...)
● A classe pode ser definida da seguinte forma:
class Gato:
def __init__(self, nome, sexo, datanasc = ‘Desconhecida’,
raca = ‘Desconhecida’):
método [Link] = nome
construtor
[Link] = sexo
[Link] = datanasc
[Link] = raca
29
Exemplo - Classe Gato (...)
● A classe pode ser definida da seguinte forma:
class Gato:
def __init__(self, nome, sexo, datanasc = ‘Desconhecida’,
raca = ‘Desconhecida’):
referência à [Link] = nome
instância
[Link] = sexo
[Link] = datanasc
[Link] = raca
30
Exemplo - Classe Gato (...)
● A classe pode ser definida da seguinte forma:
class Gato:
def __init__(self, nome, sexo, datanasc = ‘Desconhecida’,
raca = ‘Desconhecida’):
[Link] = nome Valores default para os
parâmetros datanasc e raca
[Link] = sexo
[Link] = datanasc
[Link] = raca
31
Exemplo - Classe Gato (...)
● A classe pode ser definida da seguinte forma:
class Gato:
def __init__(self, nome, sexo, datanasc = ‘Desconhecida’,
raca = ‘Desconhecida’):
[Link] = nome
[Link] = sexo
[Link] = datanasc
[Link] = raca
criação dos atributos
da instância
32
Exemplo - Classe Gato
● Podemos agora instanciar
○ um gato com valores para os 4 atributos
g1 = Gato(‘Pafúncio’, ‘M’, ‘08/01/2018’, ‘Angorá’)
○ uma gata apenas com nome, sexo e data de nascimento
g2 = Gato(‘Genoveva’,’F’, ‘29/11/2017’)
○ uma gata apenas com nome, sexo e raça
g3 = Gato(‘Eurídice’,’F’, raca = ‘Persa’)
○ um gato apenas com nome e sexo
g4 = Gato(‘Aristides’,’M’)
● Note que, em nenhum caso, foi passado valor para o
parâmetro self
○ É o interpretador Pyhton quem passa uma referência para o
próprio objeto como valor para o parâmetro
33
Atributos de Classe
● Alguns atributos possuem o mesmo valor para
todas as instâncias de uma classe
● Neste caso, não vale a pena criar novamente os
mesmos atributos para cada instância
○ Devemos criar atributos de classe
● Estes atributos são definidos fora do construtor. De
preferência, antes dele
34
Atributos de Classe: Classe Gato
● Segundo a classificação científica, todos os gatos são do
reino Animal e da classe Mamífero
● Podemos criar os atributos reino e classe como atributos
da classe Gato e atribuir-lhes um valor
class Gato:
reino = ‘Animal’
classe = ‘Mamífero’
def __init__(self, nome, sexo, datanasc = ‘Desconhecida’,
raca = ‘Desconhecida’):
[Link] = nome
[Link] = sexo
[Link] = datanasc
[Link] = raca
35
Atributos de Classe: Classe Gato
● Segundo a classificação científica, todos os gatos são do
reino Animal e da classe Mamífero
● Podemos criar os atributos reino e classe como atributos
da classe Gato e atribuir-lhes um valor
class Gato:
reino = ‘Animal’
classe = ‘Mamífero’
def __init__(self, nome, sexo, datanasc = ‘Desconhecida’,
atributos de raca = ‘Desconhecida’):
classe [Link] = nome
[Link] = sexo
[Link] = datanasc
[Link] = raca
36
Exercícios (...)
1. Implemente a classe Triângulo
a. Os comprimentos dos lados devem ser informados no
momento de criação da classe
b. Em um triângulo válido, todo lado deve ser maior que o valor
absoluto (módulo) da diferença dos outros dois lados e menor
que a soma dos outros dois lados. Verifique essas condições
no momento de instanciação do triângulo. Caso haja
inconsistência, provoque uma Exception. (A função abs(x)
retorna o valor absoluto de x)
c. Deve haver um atributo para indicar o número de lados. Ele
deve ser de instância ou de classe?
d. Crie três métodos que retornem:
i. O perímetro do tiângulo
ii. O comprimento do maior lado
iii. O comprimento do menor lado
37
Exercícios (...)
2. Implemente a classe SequenciaDNA para armazenar uma
sequência de bases de DNA.
a. Internamente, represente a sequência como uma string
b. A string deve ser informada no momento da criação de uma
instância d SequenciaDNA. Garanta que a sequência seja
válida. Se não for, provoque uma Exception no construtor.
c. Crie os métodos reversa() e complementar() para retornar,
respectivamente, objetos SequenciaDNA com a sequência
reversa e a complementar da original
38
Exercícios
3. Implemente a classe ParticulaMRU para representar partículas em
movimento retilíneo uniforme
a. Uma partícula deve ter como atributos sua posição atual e sua
velocidade
b. Ao ser instanciada, a partícula deve receber posição inicial (e
metros) e velocidade (em m/s)
c. Implemente um método passagemTempo(t) que atualiza a posição
da partícula depois de transcorridos t segundos
4. Crie um programa para simular o movimento de uma partícula em
MRU
a. Solicite os dados da partícula ao usuário
b. Pergunte ao usuário a duração da simulação (em segundos)
c. Pergunte ao usuário o intervalo de tempo entre cada observação
d. Mostre na tela a posição da partícula a cada intervalo determinado
durante o tempo solicitado
39
Igualdade Superficial entre Variáveis
que Referenciam Objetos
● Se duas variáveis referenciam o MESMO objeto, dizemos
que elas possuem igualdade superficial (shallow equality)
● A igualdade superficial é avaliada pelo operador is
○ a is b retorna True se a e b referenciam o mesmo objeto
○ a is b retorna False se a e b referenciam objetos
diferentes, mesmo que seus estados sejam idênticos
● No exemplo abaixo, as variáveis a, b e c referenciam
instâncias de list
c referencia o mesmo objeto que a
Apesar dos conteúdos idênticos, a is b retorna
False
Como c referencia o mesmo objeto que a, a is
c retorna True
40
Igualdade Profunda entre Variáveis
que Referenciam Objetos (...)
● A igualdade profunda (deep equality) ocorre quando os
estados dos objetos são iguais
● A igualdade profunda é utilizada pelos operadores
relacionais tradicionais ==, !=, <, <=, >, >=
○ Estes operadores invocam, respectivamente, os métodos
__eq__, __ne__, __lt__, __le__, __gt__ e __ge__ da
classe dos objetos comparados
● A classe list, por exemplo, implementa estes métodos e, por
isso, podemos comparar duas listas quanto aos seus
conteúdos
Teste de igualdade profunda
Teste de igualdade superficial
41
Igualdade Superficial entre Variáveis
que Referenciam Objetos
● Se duas variáveis referenciam o MESMO objeto, dizemos
que elas possuem igualdade superficial (shallow equality)
● A igualdade superficial é avaliada pelo operador is
○ a is b retorna True se a e b referenciam o mesmo objeto
○ a is b retorna False se a e b referenciam objetos
diferentes, mesmo que seus estados sejam idênticos
● No exemplo abaixo, as variáveis a, b e c referenciam
instâncias de list
c referencia o mesmo objeto que a
Apesar dos conteúdos idênticos, a is b retorna
False
Como c referencia o mesmo objeto que a, a is
c retorna True
42
Igualdade Profunda entre Variáveis
que Referenciam Objetos
● A igualdade profunda (deep equality) ocorre quando os
estados dos objetos são iguais
● A igualdade profunda é utilizada pelos operadores
relacionais tradicionais ==, !=, <, <=, >, >=
Teste de igualdade profunda
Teste de igualdade superficial
43
Encapsulamento (...)
● Um dos conceitos mais importantes da Programação
Orientada a Objetos é o encapsulamento
● O encapsulamento determina que os detalhes internos de
um objeto (seu estado) devem ser protegidos do exterior,
não podendo ser acessados diretamente, seja para
alteração ou apenas consulta. Toda interação com um objeto
deve se dar através de sua interface, ou seja, de seus
métodos
● O encapsulamento impede que o estado do objeto seja
alterado de forma inapropriada, levando-o a comportamentos
não esperados
● A linguagem Python permite a quebra de encapsulamento,
pois nela podemos acessar diretamente os atributos dos
objetos
44
Encapsulamento (...)
● No entanto, é uma boa prática de programação seguirmos os
princípios do encapsulamento, criando métodos para o acesso
e a alteração de valores de atributos
● Um método cujo único propósito é retornar o valor de um
atributo de um objeto é genericamente denominado, em inglês,
getter
● Um método cujo único propósito é alterar o valor de um atributo
de um objeto é genericamente denominado, em inglês, setter
○ Setters são uma ótima maneira de impedir que valores
inconsistentes sejam atribuídos a atributos
● Já utilizamos um um getter e um setter na classe Calculadora
○ memoArmazenar() - setter
○ memoRecuperar() - getter
45
Encapsulamento (...)
● Getters podem parecer um desperdício em Python, mas
facilitam modificações futuras em uma classe
● Suponha a seguinte classe para representar uma solução de
ácido forte ou base
● A classe possui um atributo ph, que armazena o pH
(potencial hidrogeniônico) da solução
● Como o Python não reforça o encapsulamento, o atributo
pode ser acessado livremente
46
Encapsulamento (...)
● O pH é calculado a partir da concentração de [H+]
● Se desejarmos que um objeto Solução armazene também
sua concentração de [H+] teremos o problema de manter
ambos os atributos sincronizados a fim de evitar
inconsistências
● Isso pode ser evitado se um getter para retornar o pH da
concentração for implementado e armazenarmos apenas a
concentração de [H+]
● Vamos modificar a classe para receber a concentração de
[H+] no construtor e calcular o pH quando este for solicitado
● Criaremos também um getter para a concentração de [H+]
47
Encapsulamento (...)
● O pH pode ser calculado quando necessário
48
Encapsulamento (...)
● No entanto, códigos anteriores que acessavam diretamente
o atributo ph deixam de funcionar
● Isto não ocorreria se, desde o início, um getter para
obtenção do pH tivesse sido implementado
● Vamos complementar a classe incluindo um setter para a
concentração de [H+] e outro para o pH, que deveria existir
desde o início
○ O setter do pH deve alterar a concentração de [H+]
49
Encapsulamento (...)
50
Encapsulamento (...)
51
Encapsulamento (...)
● Podemos reforçar o encapsulamento antecedendo os nomes
dos atributos com “__”
from math import log
class Solucao:
def __init__(self, concentracaoH):
self.__concentracaoH = concentracaoH
def concentracaoIonsH(self):
return self.__concentracaoH
def novaConcentracaoIonsH(self, nova):
self.__concentracaoH = nova
def ph(self):
return -log([Link](), 10)
def novoph(self, novo):
[Link](10**(-novo))
52
Encapsulamento (...)
● Podemos reforçar o encapsulamento antecedendo os nomes
dos atributos com “__”
from math import log
class Solucao:
def __init__(self, concentracaoH):
self.__concentracaoH = concentracaoH
def concentracaoIonsH(self):
return self.__concentracaoH
def novaConcentracaoIonsH(self, nova):
self.__concentracaoH = nova
def ph(self):
return -log([Link](), 10)
def novoph(self, novo):
[Link](10**(-novo))
53
Encapsulamento (...)
● O encapsulamento impede que o estado do objeto seja
alterado de forma inapropriada, levando-o a comportamentos
não esperados
● Para isso, utilizamos os setters
● Exemplo
○ Vamos modificar a classe Solução de maneira a garantir
que o pH fique entre 0 e 14
54
Encapsulamento (...)
from math import log
class Solucao:
def __init__(self, concentracaoH):
self.__concentracaoH = None
[Link](concentracaoH)
def concentracaoIonsH(self):
return self.__concentracaoH
def novaConcentracaoIonsH(self, nova):
if not self.__concentracaoValida(nova):
raise Exception('Concentração inválida')
self.__concentracaoH = nova
55
Encapsulamento (...)
…
def ph(self):
return -log([Link](), 10)
def novoph(self, novo):
[Link](10**(-novo))
def __concentracaoValida(self, valor):
if 1e-14 <= valor <= 1e0:
return True
return False
56
Encapsulamento
● Ao tentarmos atribuir um valor inválido para a concentração
de [H+] ou para o pH, ocorre uma Exceção
>>> s = Solucao(1e-7)
>>> [Link]()
7.0
>>> [Link](20)
…
Exception: Concentração inválida
57
Exercícios
5. Implemente getters e setters para a classe Gato.
6. Modifique a classe SequenciaDNA do exercício 2 implementando
getters e setters. Garanta que a sequência seja válida.
58
Bibliografia
Goodrich, M.T., Tamassia, R., Goldwasser, M.H., 2013,
Data Structures and Algorithms in Python, John Wiley &
Sons, Inc., USA.
Miller, B., Ranum, D., 2014, Problem Solving with
Algorithms and Data Structures, url:
[Link]
[Link]
59