E Book Python Funcoes e Poo

GRAN CURSOS ONLINE
DIRETORIA DE PRODUÇÃO EDUCACIONAL

PRODUÇÃO DE MATERIAIS DIVERSOS
FICHA TÉCNICA DO MATERIAL

GRANCURSOSONLINE.COM.BR
CÓDIGO:
1012023219
TIPO DE MATERIAL:
E-book
TÍTULO:
Python - Funções e POO
PROFESSOR:
Rogério Araújo
ÚLTIMA ATUALIZAÇÃO:
1/2023
PYTHON – FUNÇÕES E POO
Professor: Rogério Araújo
Sumário
APRESENTAÇÃO...............................................................................................................5
1. FUNÇÕES EM PYTHON.................................................................................................6
1.1. Introdução sobre modularização..........................................................................6
1.1.1 Conceituação........................................................................................................6
1.1.2. Vantagens............................................................................................................6
1.1.3. Tipos de módulos................................................................................................7
1.1.4. Escopo de variáveis............................................................................................8
1.1.5. Tipos de parâmetros...........................................................................................9
1.1.6. Tipos de passagens de parâmetros..................................................................9
1.2. Funções em Python...............................................................................................10
1.3. Variáveis globais....................................................................................................16
1.4. Funções recursivas...............................................................................................24
1.5. Funções lambda.....................................................................................................34
1.6. Recebendo um número arbitrário de parâmetros...............................................36
1.6.1. Introdução............................................................................................................36
1.6.2. Descompactando (unpacking) parâmetros......................................................37
1.6.3. Compactando (packing) parâmetros.................................................................39
1.7. Funções de primeira classe..................................................................................41
1.7.1. Introdução............................................................................................................41
1.7.2. Tipo das funções em Python.............................................................................42
1.7.3. Armazenando uma função em uma variável....................................................43
1.7.4. Passando uma função como parâmetro para outra........................................43
1.7.5. Retornando uma função por outra....................................................................44
1.7.6. Armazenando funções em coleções.................................................................45
www.grancursosonline.com.br 3
2. PROGRAMAÇÃO ORIENTADA A OBJETOS EM PYTHON.........................................46
2.1. Introdução à POO...................................................................................................46
2.2. Classes e objetos em Python...............................................................................51
2.2.1. Criando classes e objetos..................................................................................51
2.2.2. Método __new__()...............................................................................................57
2.2.3. Método __init__().................................................................................................60
2.2.4. Atributos e métodos de instância......................................................................66
2.2.5. Atributos e métodos de classe..........................................................................69
2.2.6. Método __del__().................................................................................................75
2.2.7. Tipos de objetos, classes old-style e new-style e tipo object........................79
2.2.8. Função isinstance()............................................................................................81
REFERÊNCIAS...................................................................................................................83
APRESENTAÇÃO
Fala, meu (minha) consagrado(a) concurseiro(a)? Tudo beleza com você?

Sou o professor Rogério Araújo. Sou bacharel em Ciência da Computação pela Univer-
sidade Estadual do Piauí (UESPI), especialista em Governança em TI pela Unieuro e em
Desenvolvimento de Sistemas Baseados em Software Livre pela Universidade da Amazônia
(UNAMA). Atualmente, estou cursando o MBA Data Science e Analytics pela USP/Esalq.
Possuo as certificações Certified ScrumMaster, COBIT 4.1 Foundation Certified e Sun Certi-
fied Associate for J2SE (SCJA). Sou autor de artigos no site www.rogeraoaraujo.com.br, no
blog do Gran Cursos Online (https://blog.grancursosonline.com.br/author/rogerio-araujo/) e
tenho meu canal no Youtube (www.youtube.com/rgildoaraujo). Sou professor de cursos na
área de Tecnologia da Informação para concursos.
Quanto à minha carreira como servidor público, atualmente trabalho na Secretaria do
Tesouro Nacional, vinculada ao Ministério da Economia, exercendo o cargo de Auditor Federal
de Finanças e Controle, na área de Governança de TI. Também já passei pelo Tribunal Regio-
nal Federal (TRF) 1ª Região, exercendo o cargo de Analista Judiciário, na especialidade de
Analista de Sistemas, e pelo Ministério Público Federal (MPF), como Técnico de Informática.
Como concurseiro, fui aprovado em alguns concursos, tais como, em ordem decrescente
de ano, STN 2013 (nomeado e onde estou hoje), TST 2012 (nomeado), TSE 2012 (apro-
veitado e nomeado no TRF 1ª Região), TRE-PE 2011 (classificado), TRT 19ª Região 2011
(classificado), MPU 2010 (classificado), STM 2010 (classificado), SERPRO 2008 (nomeado),
TRT 18ª Região 2008 (classificado), MPU 2006 (classificado), BACEN 2005 (classificado),
TRE-MA 2005 (classificado), TRT 16ª Região 2005 (classificado), TCE-PI 2005 (classificado)
e MPU 2004 (nomeado).
Professor Rogério Araújo – @profRogeraoAraujo
1. FUNÇÕES EM PYTHON
1.1. INTRODUÇÃO SOBRE MODULARIZAÇÃO
1.1.1 Conceituação
A modularização é a forma de dividir as tarefas em módulos, também chamados de

subprogramas ou componentes.
Figura 1.1: Características fundamentais da modularização.
Os módulos:
• Cuidam de uma parte separada de um problema;

• Realizam uma tarefa específica dentro de uma solução do problema;
• São unidades funcionais de um algoritmo;
• São grupos de comandos com uma funcionalidade ou um objetivo bem definida;
• Devem ser o mais independentes possível das outras partes do algoritmo.
1.1.2. Vantagens
Ao modularizarmos nosso código, podemos obter uma série de vantagens, tais como:
• Reduzir o tamanho do algoritmo;

• Melhorar a legibilidade do algoritmo;
• Evitar a repetição de código;
• Promover o reaproveitamento no mesmo programa ou em outros;
• Facilitar a manutenção e a divisão de trabalho;
• Possibilitar a utilização de componentes prontos.
1.1.3. Tipos de módulos
Há dois tipos de módulos:
• Procedimentos:
– São módulo que não retornam valores;
– Exemplos:
– Imprimir o maior elemento de um grupo de elementos; ou
– Ler um elemento.
• Funções:
– São módulos que retornam um valor;
– Exemplos:
– Retornar o menor (ou maior) valor de um grupo de elementos; ou
– Retornar um valor booleano caso um valor esteja dentro de um grupo de elementos.
Figura 1.2: Tipos de módulos.
ATENÇÃO
Em algumas linguagens de programação, como Pascal, há tanto procedimentos, que
não retornam valores, quanto funções, que retornam valores. Já em outras lingua-
gens, como linguagens C, C++, Java e Python, há somente funções, independente-
mente se retornam ou não valores.
DIRETO DO CONCURSO
1. (IFPA/2016/IFPA/TÉCNICO DE TECNOLOGIA DA INFORMAÇÃO) Em programação

de computadores uma sub-rotina pode ser uma função ou um procedimento. Sobre fun-
ções e procedimentos, pode-se afirmar:
a. Que as funções retornam um único valor e procedimentos não retornam valores.
b. Que funções não retornam um único valor e procedimentos retornam valores.
c. Nem função nem procedimento retornam valores.
d. Funções sempre retornam valor do mesmo tipo recebido e procedimentos não.
e. Procedimentos retornam valores do mesmo tipo recebido e função nunca retornam tipo.
Letra a.
Os procedimentos não retornam valores, e as funções retornam um valor. Portanto, letra A
é o nosso gabarito.
Lembre-se: Nas linguagens C, C++, Java e Python, há somente funções, independente-
mente se retornam ou não valores.
Comentando todas as letras:
a) Certa.
b) Errada. É o inverso.
c) Errada. As funções retornam um valor.
d) Errada. Não há essa relação entre o valor recebido e o valor retornado pelas funções.
e) Errada. Não há essa relação entre o valor recebido e o valor retornado pelas funções, e
os procedimentos não retornam valores.
1.1.4. Escopo de variáveis
Em relação ao escopo de variáveis, há as variáveis globais, que são declaradas no

programa principal e podem ser manipuladas em todo programa principal ou em qualquer
módulo. Também existem as variáveis locais, que são declaradas em um módulo especí-
fico e são manipuladas dentro desse módulo apenas.
ATENÇÃO
Uma boa prática de programação é evitar declarar variáveis globais com o mesmo
nome das variáveis dos módulos.
Na figura 1.3, a variável global A é declarada no corpo do programa principal. Ela pode
ser vista e manipulada tanto no Módulo 1 quanto no Módulo 2. Dentro do Módulo 1, temos
a variável local B, que é vista e manipulada apenas dentro desse módulo. A variável local C,
por sua vez, é declarada, vista e manipulada dentro do Módulo 2.
Figura 1.3: Escopo de variáveis.
DIRETO DO CONCURSO
2. (UNIRIO/2014/UNIRIO/ANALISTA TECNOLOGIA DA INFORMAÇÃO/DESENVOL-

VIMENTO DE SISTEMAS/ADAPTADA) Sobre o escopo de variáveis, julgue o item
seguinte como CERTO ou ERRADO.
Mesmo variáveis definidas em escopos diferentes precisam necessariamente ter no-
mes diferentes.
Errado.
As variáveis globais e locais podem ter os mesmos nomes, porém uma boa prática de pro-
gramação é evitar declarar variáveis globais com o mesmo nome das variáveis das funções.
1.1.5. Tipos de parâmetros
Figura 1.4: Tipos de parâmetros.
Os parâmetros formais são definidos no cabeçalho do módulo. Eles possuem escopo

do módulo em que estão definidos.
Já os parâmetros reais representam o valor (ou endereço) das variáveis ou constan-
tes usadas na chamada do subprograma (módulo).
Na próxima seção, identificaremos esses tipos de parâmetros nos exemplos de funções
em Python.
1.1.6. Tipos de passagens de parâmetros
Na passagem por valor, há a transmissão do valor do parâmetro real para o parâme-

tro formal correspondente, ou seja, a cópia física do valor do parâmetro real é feita durante
a ativação do módulo.
Na passagem por referência, há a transmissão do endereço (caminho de acesso) do
parâmetro real para o parâmetro formal correspondente. Esse tipo de passagem é efi-
ciente, pois é feita sem cópia ou armazenamento duplicado.
Figura 1.5: Tipos de passagens de parâmetros.
DIRETO DO CONCURSO
3. (CESPE/2011/STM/ANALISTA JUDICIÁRIO/ANÁLISE DE SISTEMAS/ESPECÍFICOS)

Com relação a algoritmos e lógica de programação, julgue o item a seguir.
Na passagem de parâmetros por referência, o valor do parâmetro real é copiado para
o parâmetro formal do módulo, preservando, assim, o valor original do parâmetro. Na
passagem de parâmetros por valor, toda alteração feita nos parâmetros formais reflete-
-se nos parâmetros reais.
Errado.
É o inverso.
Na passagem de parâmetros por valor, o valor do parâmetro real é copiado para o parâme-
tro formal do módulo, preservando, assim, o valor original do parâmetro.
Na passagem de parâmetros por referência, toda alteração feita nos parâmetros formais
reflete-se nos parâmetros reais.
1.2. FUNÇÕES EM PYTHON
As funções, como estudado, são blocos de código executados apenas quando

são chamados.
As funções podem:
• Receber dados através de parâmetros;

• Retornar dados como resultado.
Sintaxe:
def nomeFuncao([parâmetro formal 1, parâmetro formal 2,...]):

bloco de instruções
[return] valor
Para a criação de uma função em Python, usamos a palavra-chave def, seguida do

nome da função, como descrito na sintaxe acima.
Uma função não precisa de parâmetros. Se precisar, pode-se usar um ou mais parâme-
tros. Os parâmetros definidos na função, como estudamos, são chamados de parâmetros
formais. Eles representam as informações passadas para funções e são especificados após
o nome da função, entre parênteses.
Uma função pode ou não retornar algum valor. Quando for necessário retornar, usa-se a
declaração return. Essa declaração gera a saída do método atual e faz com que o controle
de fluxo retorne para onde o método foi invocado.
Veremos vários exemplos para exercitarmos a criação de funções de várias formas,
começando com o exemplo de uma função sem parâmetros formais e que não retorna
nada, apenas imprime uma string:
O segundo exemplo é de uma função com um parâmetro formal e que não retorna nada:
Para a função dobrar(), foi citado um parâmetro formal: x. Quando se chama essa função,
por exemplo dobrar(15), passamos um parâmetro real (15) e a função não retorna nada,
apenas imprime um valor, que é a multiplicação do parâmetro formal x por 2 (30).
O terceiro exemplo traz uma função com um parâmetro formal e que retorna algum valor:
Alteramos a função dobrar(), fazendo com que ela retornasse o valor do resultado da multi-
plicação, ao invés de apenas imprimir esse resultado. Para isso, foi utilizada a declaração return.
Na nova versão da função dobrar(), continuamos com o parâmetro formal x, porém ela é
atualizada com a multiplicação do valor atual de parâmetro x pelo valor 2, e seu valor atuali-
zado é retornado pela função.
Como a função agora retorna um valor, a função pode:
• Retornar o valor para uma variável;

– Como acontece na linha 7 do exemplo acima, em que a variável a recebe o valor
retornado pela função dobrar(), passando o parâmetro real 15;
– A variável a, então, recebe o valor 30.
• Ser usada com outras funções;

– Como é o caso da linha 10 do exemplo acima, em que usamos a função print() para
imprimir o valor retornado pela função dobrar(), passando o parâmetro real 30;
– Então foi impresso o valor 60.
Aproveitando o estudo sobre funções em Python, vamos estudar sobre o código que traz
a implementação da série de Fibonacci como função.
Iniciaremos com a função que gera a série, começando com o valor 0.
Exemplo:
Agora temos o código da série Fibonacci em forma de função. Dessa maneira, basta
chamá-la, passando um parâmetro real. Serão impressos os primeiros números da série
menores que o valor do parâmetro real. No caso, chamamos a função fibonacci(), informando
o valor 10, ou seja, serão impressos os primeiros números da série menores que 10, com a
série iniciando com o valor 0.
Modificaremos a função, fazendo com que a série se inicie com o valor 1. Para isso,
vamos mudar o seguinte:
• A condição da declaração while é feita com a variável b;

• O valor dessa variável é impresso.
Exemplo:
Agora, chamamos a função fibonacci(), informando o valor 10. Serão impressos os pri-
meiros números da série menores que 10, com a série iniciando com o valor 1.
Uma função não pode ter um bloco vazio de instruções:
Caso haja necessidade de ter uma função com um bloco vazio, pode-se utilizar a pala-
vra-chave pass. Dessa forma, o erro não aparecerá:
DIRETO DO CONCURSO
4. (CETAP/2010/AL-RR/ANALISTA DE SISTEMAS/ADAPTADA) Sobre a linguagem de

programação PYTHON, julgue item seguinte como CERTO ou ERRADO.
As funções são definidas em Phyton utilizando a palavra-chave def.
Certo.
Para a criação de uma função, usamos a palavra-chave def, seguida do nome da função.
5. (FCC/2014/TRT 13ª REGIÃO/TÉCNICO JUDICIÁRIO/TECNOLOGIA DA INFORMA-

ÇÃO) Considere o código abaixo digitado em Python.
...I... contar(n):
a = 1
while a < n:
print a,
a = a+1
contar(10)
Preenche, corretamente, a lacuna I:

a. function
b. def
c. procedure
d. public
e. void
Letra b.
Para a criação de uma função, usamos a palavra-chave def, seguida do nome da função:
def contar(n):
Organizando o código da questão e verificando o resultado de sua execução, temos
O código acima tem o objetivo de imprimir uma sequência de números inteiros, começando
de 1 até o menor valor antes do valor passado como parâmetro. No caso, foram impressos
números de 1 até 9.
6. (FCC/2019/TJ-MA/TÉCNICO JUDICIÁRIO/TÉCNICO EM INFORMÁTICA/SOFTWARE)

Considere o programa Python abaixo:
...I...
for x in pro:
print(x)
processos = [“0456789908”, “0875643087”, “0897645109”]
exibir_processos(processos)
Para que o programa seja executado corretamente, em condições ideais, a indicação I

deve ser substituída por:
a. private exibir_processos(pro):
b. public exibir_processos(pro):
c. function exibir_processos(pro):
d. definition exibir_processos(pro):
e. def exibir_processos(pro):
Letra e.
Para a criação de uma função, usamos a palavra-chave def, seguida do nome da função:
def nomeFuncao([parâmetro formal 1, parâmetro formal 2,...]):

bloco de instruções
[return] valor
Organizando o código da questão e verificando o resultado de sua execução, temos:
O código acima tem o objetivo de imprimir cada elemento de uma lista. No caso, a lista
passada como parâmetro foi a lista da variável processos.
1.3. VARIÁVEIS GLOBAIS
As variáveis globais são variáveis criadas fora das funções. Já as variáveis locais
possuem escopo das funções.
Exemplo:
A variável x, no exemplo anterior, é uma variável global, pois foi declarada (recebeu um
valor) fora da função dobrar().
Caso haja uma variável declarada dentro da função com o mesmo nome de uma vari-
ável global, haverá duas variáveis diferentes para o código. A variável global permanecerá
com o mesmo valor após a execução da função com uma variável local com o mesmo nome
da global.
Exemplo:
No exemplo acima, a variável x da linha 2 é uma variável global. Já a variável x da linha

6, dentro da função dobrar(), é uma variável local da função, ou seja, ela possui o escopo
da função. Na linha 11, há uma chamada da função dobrar(), que imprime o valor da variá-
vel local x depois de ter seu valor inicial dobrado. Já na linha 14, há a impressão da variável
global x, que manteve seu valor 15 inicial.
Podemos aplicar a ideia de variáveis globais e locais com os mesmos nomes. Por exenplo,
os parâmetros formais (citados na criação da função) podem ter os mesmos nomes das vari-
áveis globais. Mesmo que tenham os mesmos nomes, elas são variáveis diferentes e não
devem ser confundidas.
Exemplo:
Veja que a variável x, na linha 7 do exemplo anterior, foi inicializada com o valor 15.
Nas linhas:
• 8, há a impressão do valor da variável x;

– Ou seja, é impresso o valor 15.
• 9, há a impressão do valor do resultado retornado da função dobrar(), passando o valor

da variável x como parâmetro real;
– Ou seja, é impresso o valor 30;
• 10, há a impressão novamente do valor da variável x;

– Ou seja, é impresso novamente o valor 15;
– Isso mostra que a variável x não é a mesma que o parâmetro formal x da função dobrar().
Esse tipo de passagem de parâmetro é do tipo de passagem por valor, como já

foi estudado.
Há a possibilidade de criar uma variável dentro de uma função, mas que seja global. Para
isso, podemos usar a palavra-chave global. Assim, a variável terá o escopo global.
Exemplo:
No exemplo acima, a variável global x foi declarada dentro da função dobrar(). Ao chamar
a função, é impresso o valor da variável: 30. Também, ao chamar a função print(), a impres-
são do valor da variável é 30.
Uma variável global criada fora de uma função pode ter seu valor modificado dentro da
função também utilizando a palavra-chave global.
Exemplo:
DIRETO DO CONCURSO
7. (UNIRIO/2014/UNIRIO/ANALISTA TECNOLOGIA DA INFORMAÇÃO/DESENVOL-

VIMENTO DE SISTEMAS/ADAPTADA) Sobre o escopo de variáveis, julgue o item a
seguir como CERTO ou ERRADO.
Na linguagem Python, não é possível atribuir um valor a uma variável global de dentro
de uma função.
Errado.
Sim, é possível, utilizando a palavra-chave global.
8. (IFCE/2017/IFCE/TÉCNICO DE LABORATÓRIO/INFORMÁTICA) Considere o trecho

do programa Python abaixo.
def func():
x = 1
print(x)
x = 10
func()
print(x)
Os valores impressos, ao se executar o programa, são, respectivamente,

a. 1 e 1.
b. 10.
c. 1 e 10.
d. 10 e 1.
e. 10 e 10.
Letra c.
Quando chamamos a função func(), há uma variável local x que recebe o valor 1 e é im-
presso o valor dessa variável local.
Na linha 5, a variável global x foi inicializada com o valor 10.

Na linha 6, a função func() é chamada e imprimirá o valor 1.
Na linha 7, é impresso o valor da variável x criada na linha 5, ou seja, será impresso o valor
10, pois a variável x é totalmente diferente da variável local x da função func(). Com isso,
não houve alteração do valor da variável x.
O resultado da execução é 1 (quando chamamos a função func()) e 10 (impressão do valor
da variável x), o que faz a letra C ser o nosso gabarito.
Novamente frisando, as variáveis globais e locais podem ter os mesmos nomes, porém
uma boa prática de programação é evitar declarar variáveis globais com o mesmo nome
das variáveis das funções.
9. (IFMT/2018/IFMT/INFORMÁTICA) Considere o seguinte fragmento de código fonte

escrito na linguagem python:
def foo(a):
return a + a + a
b = 1
foo(b)
Após a execução de todos esses códigos, qual é o valor a ser mostrado mediante o
comando abaixo?
print(b)
a. 0
b. 1
c. 3
d. 6
e. 9
Letra b.
Quando chamamos a função foo(), passando um valor para o parâmetro formal, a função
retorna o valor triplicado do parâmetro.
Na linha 4, a variável b foi inicializada com o valor 1.
Nas linhas de 5 a 7, a função foo() é chamada, passando como parâmetro real a variável
b. Com isso, para cada chamada à função foo(), será retornado o valor 3.
Na linha 8, há a impressão do valor da variável b, que continua sendo valor 1. Não houve
mudança do valor da variável.
Como o código gerou o valor 1, então nosso gabarito é a letra B.
Melhorando o código para explicar melhor, temos:
Na linha 4 do código acima, a variável b foi inicializada com o valor 1.

Nas linhas de 5 a 7, usamos a função print() para imprimir o valor retornado por cada cha-
mada à função foo(), ou seja, foi impresso o valor 3 para cada linha.
Na linha 8, é impresso o valor da variável b (valor 1), o que mostra que o valor da variável
b não é alterado quando ela é usada em uma função que precisa de parâmetro.
10. (PAQTCPB/2012/UEPB/TÉCNICO EM INFORMÁTICA/PROGRAMADOR) Considere o

trecho do programa Python abaixo.
def dobra(y):
x = y + y
return x
x = 5
dobra(x)
print x
Qual o valor impresso ao executarmos o programa?

a. 25
b. 15
c. 5
d. 10
e. 20
Letra c.
Quando chamamos a função dobra(), passando um valor para o parâmetro formal, a fun-
ção retorna o valor dobrado do parâmetro.
O código desta questão é idêntico ao código da questão anterior, mas com uma diferença:
existe uma variável local x que receberá o valor duplicado do parâmetro formal y.
Na linha 5, a variável x foi inicializada com o valor 5.
Nas linhas 6 e 7, a função dobra() é chamada, passando como parâmetro real a variável x.
Com isso, para cada chamada à função dobra(), será retornado o valor 10.
Na linha 8, há a impressão do valor da variável x, que continua sendo valor 5. Não hou-
ve mudança do valor da variável, por mais que haja uma variável local na função com o
mesmo nome.
Como o código gerou o valor 5, então nosso gabarito é a letra C.
Melhorando o código para explicar melhor, temos:
Na linha 6, como forma de mostrar o valor da variável x, foi impresso o seu valor, ou seja, 5.
Nas linhas 7 e 8, usamos a função print() para imprimir o valor retornado por cada chamada
à função dobra(), ou seja, foi impresso o valor 10 para cada linha.
Na linha 9, é impresso o valor da variável x (valor 5), o que mostra que o valor da variável
x não é alterado, mesmo que haja um parâmetro formal ou variável local da função com o
mesmo nome do parâmetro real, que, no caso do código, é a variável x.
Em resumo, a letra C é nosso gabarito, pois o código da questão imprime o valor 5.
11. (COMPERVE/2019/UFRN/TÉCNICO DE TECNOLOGIA DA INFORMAÇÃO) Python

é uma linguagem de programação de alto nível, interpretada, orientada a objetos,
funcional, de tipagem dinâmica e forte. Levando isso em conta, analise o código em
Python abaixo.
def e(b):
a = b*b
return a
a = 10
e(a)
print(e(a))
Nesse caso, ao executar o programa, o valor impresso será

a. 1000.
b. 10.
c. 100.
d. 10000.
Letra c.
Mais uma questão parecida com as questões anteriores: há uma variável local a que rece-
berá o valor elevado a dois do parâmetro formal b.
Na linha 5, a variável a foi inicializada com o valor 10.
Nas linhas 6 e 7, a função e() é chamada, passando como parâmetro real a variável a. Com
isso, para cada chamada à função e(), será retornado o valor 100.
Na linha 8, há a impressão do valor retornado pela função e(), passando o valor da variável
a. Com isso, será impresso o valor 100.
Não houve mudança do valor da variável a, por mais que haja uma variável local na função
com o mesmo nome.
Como o código gerou o valor 100, então nosso gabarito é a letra C.
1.4. FUNÇÕES RECURSIVAS
A recursividade ou recursão é quando um módulo faz uma chamada ou ativa

a si mesmo.
Uma grande vantagem no seu uso é um conjunto infinito de sentenças possíveis que
pode ser definido, analisado ou produzido por um programa finito de computador.
Outra vantagem é a função recursiva, que é mais elegante e menor que a sua versão
iterativa. A versão iterativa é como estudamos até agora, uma sequência de passos para
resolver um problema.
Uma função recursiva exibe com maior clareza o processo utilizado, desde que o pro-
blema ou os dados sejam naturalmente definidos através de recorrência.
No entanto, como desvantagem, uma função recursiva exige mais espaço de memória e
é mais lenta do que a versão iterativa, na grande maioria dos casos.
Como exemplos e comparação, veremos uma função de fatorial na versão iterativa e a
mesma função, porém, na versão recursiva.
Função de fatorial na versão iterativa:
Dentro da função fatorial na versão iterativa, as variáveis aux e fat recebem, respectiva-
mente, os valores 1 e 1 inicialmente.
Enquanto o valor da variável aux for menor que ou igual a n então:
• Atualize:
– O valor da variável fat com o valor original dela mesma multiplicado pelo valor da
variável aux;
– O valor da variável aux com valor original dela mesma somado com 1.
Fazendo o teste chinês do código, passando o valor 4 como parâmetro, temos:
Iteração n aux fat

1 4 1 1
2 4 2 1
3 4 3 2
4 4 4 6
5 4 5 24
Função de fatorial na versão recursiva:
Perceba a simplificação de passos em relação à versão iterativa.

Dentro da função fatorial na versão recursiva, se o valor da variável n for menor que ou
igual a 1, então retorne 1. Se não, retorne a multiplicação da variável n pelo valor retornado
da própria função fatorial, passando, como parâmetro, a variável n menos 1.
Fazendo o teste chinês do código, passando o valor 4 como parâmetro, temos:
Iteração n Ida Retorna

1 4 4 * fatorial(3) 4*6 24
2 4 3 * fatorial(2) 3*2 6
3 4 2 * fatorial(1) 2*1 2
4 4 1 1 1
Ilustrando o teste chinês, temos a figura 1.6:
Figura 1.6: Esquema do teste chinês da função fatorial recursiva.
Como outro exemplo de função recursiva, utilizaremos a implementação da série

de Fibonacci.
Como estudado na seção 1.2, temos a seguinte versão da função iterativa que gera a
série começando com o valor 0:
A sua versão recursiva pode ser a seguinte:
No código acima, a variável x recebe o valor 1 e há uma declaração while com a condi-
ção: enquanto o valor de x for menor ou igual a 10, então:
• Imprima o valor retornado da função fibonacci(), passando o valor da variável x como

parâmetro; e
• Incremente o valor da variável x em 1.
Enquanto a função recursiva fatorial() se chama uma vez, a função recursiva fibonacci()
se chama duas vezes:
• fibonacci(n – 2);
• fibonacci(n – 1).
Quando uma função chama a si mesma uma vez apenas, temos uma pilha de chamadas,
como está na figura 1.6.
Já quando uma função chama a si mesma mais de uma vez, então se forma uma árvore
de chamadas. Como a função fibonacci() chama a si mesma duas vezes, a árvore de chama-
das é binária (quando cada nó possui até dois nós-filho). A cada chamada da função recur-
siva fibonacci() mais duas chamadas são geradas, e assim por diante.
Para entendermos o código da função recursiva, podemos aplicar a função passando
como parâmetro valores de 1 a 3.
Quando chamamos fibonacci(1), o seu retorno é 0:
• O parâmetro formal n receber o valor 1;

• Se o valor do parâmetro n, que no caso é 1, for menor que 3, então retorne n – 1:
1 – 1 = 0;
• A função retorna 0.
Quando chamamos fibonacci(2), o seu retorno é 1:

• Se o valor do parâmetro n, que no caso é 2, for menor que 3, então retorne n – 1:
2 – 1 = 1;
Quando chamamos fibonacci(3), o seu retorno será 1:

• Se o valor do parâmetro n, que no caso é 3, for menor que 3, então retorne n – 1;
• Como n é igual a 3, então a execução cairá na declaração else: retorne fibonacci(n - 2)

+ fibonacci(n - 1);
– fibonacci(1) + fibonacci(2);
– 0 + 1 = 1.
Então já temos que:
• fibonacci(1) = 0;
• fibonacci(3) = 1.
Pela lógica, caso se chame:
• fibonacci(1) = 1 - 1 = 0;
• fibonacci(2) = 2 - 1 = 1;
• fibonacci(3) = fibonacci(1) + fibonacci(2) = 0 + 1 = 1;
• fibonacci(10) = fibonacci(8) + fibonacci(9) = 13 + 21 = 34.
Agora vamos estudar como criar uma função recursiva que gera a série começando com
o valor 1. Como estudado na seção 1.2, temos a seguinte versão da função iterativa:
A sua versão recursiva pode ser a seguinte:
No código acima, a variável x recebe o valor 1 e há uma declaração while com a condi-
ção: enquanto o valor de x for menor ou igual a 10, então:
• Imprima o valor retornado da função fibonacci(), passando o valor da variável x como

parâmetro; e
• Incremente o valor da variável x em 1.
As diferenças com a versão recursiva anterior são que:
• A condição da declaração if é se n for igual a 1 ou 2;

• O retorno da declaração if é 1.
Pela nova lógica, caso se chame:
• fibonacci(10) = fibonacci(8) + fibonacci(9) = 21 + 34 = 55.
DIRETO DO CONCURSO
12. (COPEVE/UFAL/2016/UFAL/ANALISTA DE TECNOLOGIA DA INFORMAÇÃO/EDITAL

N. 30) O trecho de código Python é uma função recursiva para o cálculo do fatorial de
um número natural qualquer. Entretanto, apresenta um erro de programação.
1. def Fatorial( n ):
2. if (n == 1) or (n == 0):
3. return 1
4. else:
5. return n * (n - 1)*(n – 2)*(n – 3)*(n – 4)*(n - 5);
Em qual linha está o erro e como consertá-lo para que a função cumpra corretamente
o seu propósito?
a. o código deveria ser “if (n == 1):” na linha 2.
b. o código deveria ser “return 0” na linha 3.
c. o código deveria ser “if (n == 1) and (n == 0):” na linha 2.
d. o código deveria ser “return Fatorial(n - 1) * n;” na linha 5.
e. o código deveria ser “return Fatorial(n) * n -1;” na linha 5.
Letra d.
O erro de programação citado no enunciado é o seguinte: a função Fatorial() retornará um
valor fatorial de forma incorreta. Por exemplo, se o parâmetro n for algum valor entre 2 e 5,
então a função vai retornar 0:
Para corrigirmos o código da função do enunciado, basta usarmos a ideia de recursividade,

ou seja, podemos substituir o código da linha 5 por:
return Fatorial(n - 1) * n;
Dessa forma, podemos passar qualquer valor como parâmetro para a função Fatorial(),
que teremos o valor fatorial do parâmetro:
Portanto, o nosso gabarito é a letra D.
13. (IF SUL RIO-GRANDENSE/2019/ANALISTA DE TECNOLOGIA DA INFORMAÇÃO)

Observe a função print do código escrito em Python 2.7 a seguir:
def foo(n):
if n > 1:
return n * foo(n-1)
return n
print(foo(4))
Qual o resultado impresso por essa função?

a. 4
b. 16
c. 24
d. 20
Letra c.
Fazendo o teste chinês do código passando o valor 4 como parâmetro, temos:
Iteração n Ida Retorna

1 4 4 * foo(3) 4*6 24
2 4 3 * foo(2) 3*2 6
3 4 2 * foo(1) 2*1 2
4 4 1 1 1
O código da função foo() é a implementação da função fatorial() de forma recursiva, porém

bem mais simplificado do que estudamos.
O resultado retornado por foo(4) é 24.
14. (FGV/2018/MPE-AL/ANALISTA DO MINISTÉRIO PÚBLICO/ADMINISTRADOR DE

REDE) Considere a seguinte definição da função f, declarada na sintaxe Python.
def f(n):
if n < 3:
return n-1
else:
return f(n-2) + f(n-1)
print f(10)
Assinale o valor produzido pela execução do código acima.

a. 13
b. 17
c. 21
d. 34
e. 55
Letra d.
O código da função f() é a implementação da função fibonacci() de forma recursiva que

gera a série começando com o valor 0, como estudamos.
Na linha 7, há a impressão do valor retornado pela função f(), passando o valor 10 como
parâmetro real:
• f(1) = 1 - 1 = 0;
• f(2) = 2 + 1 = 1;
• f(3) = f(1) + f(2) = 0 + 1 = 1;
• f(4) = f(2) + f(3) = 1 + 1 = 2;
• f(5) = f(3) + f(4) = 1 + 2 = 3;
• f(6) = f(4) + f(5) = 2 + 3 = 5;
• f(7) = f(5) + f(6) = 3 + 5 = 8;
• f(8) = f(6) + f(7) = 5 + 8 = 13;
• f(9) = f(7) + f(8) = 8 + 13 = 21; e
• f(10) = f(8) + f(9) = 13 + 21 = 34.
Portanto, f(10) vai retornar 34, o que faz a letra D ser nosso gabarito.
15. (COMPERVE/2019/UFRN/TÉCNICO DE TECNOLOGIA DA INFORMAÇÃO) Com a lin-

guagem de programação Python, é possível realizar a criação de funções recursivas,
que são bastante úteis para resolução de problemas computacionais. Tendo isso em
mente, analise o código em Python abaixo.
def f(i):
if i == 1 or i == 2:
return 1
return f(i-1) + f(i-2)
print(f(10))
Nesse caso, ao executar o programa, o valor impresso será

a. 22.
b. 11.
c. 55.
d. 50.
Letra c.
O código da função f() é a implementação da função fibonacci() de forma recursiva, que

gera a série começando com o valor 1, como estudamos.
A única diferença é que o trecho “return f(i-1) + f(i-2)” está fora da declaração if-else, mas,
no final, dará o mesmo resultado.
Na linha 6, há a impressão do valor retornado pela função f(), passando o valor 10 como
parâmetro real:
• f(1) = 1;
• f(2) = 1;
• f(3) = f(2) + f(1) = 1 + 1 = 2;
• f(4) = f(3) + f(2) = 2 + 1 = 3;
• f(5) = f(4) + f(3) = 3 + 2 = 5;
• f(6) = f(5) + f(4) = 5 + 3 = 8;
• f(7) = f(6) + f(5) = 8 + 5 = 13;
• f(8) = f(7) + f(6) = 13 + 8 = 21;
• f(9) = f(8) + f(7) = 21 + 13 = 34; e
• f(10) = f(9) + f(8) = 34 + 21 = 55.
Portanto, f(10) vai retornar 55, logo a letra C é o gabarito da questão.
1.5. FUNÇÕES LAMBDA
São pequenas funções anônimas. Podem receber qualquer número de parâmetros,

mas só podem ter uma expressão.
Sintaxe:
lambda parâmetro 1, parâmetro 2,...: expressão
Para a criação de uma função lambda, usamos a palavra-chave lambda seguida de:
• Um ou mais parâmetros;
• Uma expressão.
Exemplos:
No código acima, temos a primeira função lambda, que é referenciada pela variável x.
Essa função possui um parâmetro formal a e tem como expressão a + 10.
Para usar a função lambda mencionada, utilizamos a variável x como se fosse uma
função normal, citando um parâmetro formal. O nome da variável é semelhante ao nome de
uma função normal.
No exemplo, a função lambda referenciada pela variável x foi acionada usando o nome
dessa variável e passando o valor 5 como parâmetro real: x(5). O resultado disso é o retorno
do valor 15 (valor do parâmetro real 5 somado com 10).
A segunda função lambda é referenciada pela variável y. Essa função possui três parâ-
metros formais: a, b e c. A expressão dessa função é: a + b * c.
Usamos a variável y como se fosse uma função comum, passando três parâmetros reais.
No exemplo, foram passados os valores 5, 3 e 10: y(5, 3, 10). O resultado retornado é 35: 5
+ 3 * 10, como definido na expressão da função lambda.
DIRETO DO CONCURSO
16. (CESPE/2013/FUB/ANALISTA DE TECNOLOGIA DA INFORMAÇÃO) Julgue o item

que se segue, acerca de linguagens de programação.
Na linguagem Phyton, uma função lambda atribui à nova função o nome que está no
cabeçalho, em vez de retorná-la como resultado.
Errado.
O texto da questão está citando, na verdade, a criação de uma função com a palavra-chave
def, em que atribuímos um nome à função:
def nome_funcao([parâmetro formal 1, parâmetro formal 2,...]):

{bloco de instruções}
[return] {valor}
Já uma função lambda é anônima. Ela é criada com a palavra-chave lambda e pode ser
referenciada por uma variável:
lambda parâmetro 1, parâmetro 2,...: expressão
Corrigindo a questão:
Na linguagem Phyton, uma função normal atribui à nova função o nome que está no cabe-
çalho (def nome_funcao()), em vez de retorná-la como resultado, como acontecem com as
funções lambda.
1.6. Recebendo um número arbitrário de parâmetros
1.6.1. Introdução
Considere a seguinte situação:

Temos uma função com quatro parâmetros formais e queremos chamá-la, passando
como parâmetro real uma lista de quatro elementos. A função espera quatro parâmetros, mas
estamos passando apenas um, mesmo que represente quatro valores. Ao chamar a função,
teremos um erro, conforme o exemplo abaixo:
O erro retornado foi: o parâmetro a recebeu a lista como valor, mas os outros parâmetros
não receberam nada e estão esperando algum valor na chamada da função.
Figura 1.7: Formas de recebimento de um número arbitrário de parâmetros em Python.
Como poderíamos passar para a lista em que cada elemento poderia inicializar cada
parâmetro formal da função?
Em Python, pode-se criar funções que recebam números arbitrários de parâmetros.
Podemos descompactar parâmetros, quando se chama a função (unpacking), ou compactar
parâmetros, quando se cria a função (packing).
1.6.2. Descompactando (unpacking) parâmetros
A descompactação de parâmetros é usada para descompactar uma coleção (lista, tupla

e dicionário) passada como parâmetro real no momento da chamada de uma função. Dessa
forma, cada elemento dessas coleções será passado para o parâmetro formal correspondente.
Para descompactação de uma lista ou tupla, utiliza-se o operador * aplicado no parâme-
tro real antes do nome da variável que representa a lista ou a tupla.
Exemplos com listas e tuplas:
Para descompactação de um dicionário, utiliza-se o operador ** aplicado no parâmetro

real antes do nome da variável que representa o dicionário.
Exemplo com dicionário:
Podemos fazer uma junção da descompactação com listas, tuplas e dicionários.
Exemplos:
Perceba que tanto a lista quanto o dicionário, no exemplo acima, possuem dois elemen-
tos para cada coleção. A função possui quatro parâmetros formais.
Ao chamar a função, passamos os elementos da lista (*lista) e os elementos do dicio-
nário (**dicionario).
ATENÇÃO
A quantidade de parâmetros formais e de elementos da coleção ou da junção das
coleções devem ser iguais na descompactação de parâmetros.
Exemplo 1, com erro na descompactação com listas ou tuplas:
Exemplo 2, com erro na descompactação com dicionário:
Nos exemplos 1 e 2, as coleções (lista e dicionário) contêm quatro elementos cada uma
delas, e a função espera três parâmetros.
Exemplo 3, com erro na descompactação com listas ou tuplas:
Agora, a coleção contém três elementos, e a função espera quatro parâmetros.
1.6.3. Compactando (packing) parâmetros
A compactação de parâmetros acontece quando não se sabe quantos parâmetros

são necessários para a uma função em Python. Acontece na criação da função.
Para compactação de listas ou tuplas, usa-se o operador * no parâmetro formal, na
criação da função, e não no parâmetro real, quando chamamos a função, como acontece
na descompactação.
Exemplo:
Veja que podemos passar qualquer quantidade para a função.

Para a compactação de dicionários, usa-se o operador ** no parâmetro formal, na cria-
ção da função, e não no parâmetro real, quando chamamos a função, como acontece na
descompactação.
Exemplo:
O PULO DO GATO
Em resumo: A descompactação dos parâmetros acontece na chamada da função, nos pa-
râmetros reais. Já a compactação acontece na criação da função, nos parâmetros formais.
DIRETO DO CONCURSO
17. (MS CONCURSOS/2018/GHC-RS/PROGRAMADOR) Em Python 3, qual é o processo

que é executado dentro da função e não na chamada?
a. Parâmetros.
b. Packing.
c. Unpacking.
d. Import.
e. Traceback.
Letra c.
Estudamos que a descompactação dos parâmetros acontece na chamada da função, nos
parâmetros reais. Já a compactação acontece na criação da função, nos parâmetros for-
mais. Por conta disso, marcaríamos a letra B. Porém, a banca citou a letra C. Mas por que
a banca trouxe unpacking como processo executado dentro da função, e não na chamada?
Meu(minha) prezado(a), a questão foi baseada no livro Python: Escreva seus primeiros
programas, do autor Felipe Cruz. No livro, Cruz cita que a compactação (packing) de parâ-
metros acontece na chamada da função, e a descompactação (unpacking) é “... o processo
que acontece dentro da função, e não na chamada”.
Isso é totalmente diferente do que estudamos. Aqui mesmo nesta aula, trago várias fontes
que explicam e demonstram que a descompactação dos parâmetros acontece na chamada
da função e a compactação acontece na criação da função. Infelizmente, é aquele tipo de
questão que traz mais uma divergência de autores dentro da área de TI. =(
Comentando as outras letras:
• A letra A cita parâmetros, que são informações citadas na chamada de uma função
(parâmetros reais) ou na criação de função (parâmetros formais);
• A letra D traz o import, que é usado para importar pacotes de códigos usados em
seu código;
• A letra E cita traceback, um relatório que contém as chamadas de função feitas em
seu código em um ponto específico.
1.7. FUNÇÕES DE PRIMEIRA CLASSE
1.7.1. Introdução
Os objetos de primeira classe são tratados uniformemente, podendo ser:
• Armazenados em estruturas de dados;

• Passados como parâmetros; ou
• Usados em estruturas de controle.
As funções que são tratadas como objetos de primeira classe são chamadas de funções
de primeira classe.
Propriedades das funções de primeira classe:
• São instâncias do tipo Object;

• Podem ser armazenadas em uma variável;
• Podem ser passadas como parâmetro para outra função;
• Podem ser retornadas por outra função;
• Podem ser armazenadas em estruturas de dados, como tabelas de hash, listas,
entre outras.
As funções em Python são tratadas como objetos de primeira classe porque aquelas
possuem as propriedades citadas acima.
Figura 1.8: Propriedades das funções de primeira classe.
DIRETO DO CONCURSO
18. (IFPE/2019/IFPE/TÉCNICO EM TECNOLOGIA DA INFORMAÇÃO/DESENVOLVI-

MENTO/ADAPTADA) Sobre a linguagem de Programação Python, julgue o item a
Funções em Python são tratadas como elementos de segunda ordem, podendo ser
guardadas em variáveis, passadas como parâmetro para outras funções.
Errado.
As funções em Python são tratadas como objetos de primeira classe, podendo ser guarda-
das em variáveis, passadas como parâmetro para outras funções.
1.7.2. Tipo das funções em Python
Uma função em Python é um objeto do tipo function:
1.7.3. Armazenando uma função em uma variável
Como uma função é um objeto, ela pode ser referenciada ou armazenada em uma variá-
vel. Dessa maneira, podemos trabalhar a variável como se estivesse chamando a função de
forma direta e passando parâmetros, se houver.
Exemplo:
No exemplo, a variável x está referenciando a função dobra(). Com isso, podemos usar a
variável x como se fosse a própria função, passando um parâmetro.
1.7.4. Passando uma função como parâmetro para outra
Como uma função é um objeto, ela pode ser passada como parâmetro para outras funções.
As funções que aceitam outras como parâmetros são chamadas de funções de
ordem superior.
Exemplo:
No exemplo, temos três funções:
• tudoMinusculo():
– Possui o parâmetro chamado texto;
– Retorna o texto do parâmetro todo minúsculo.
• tudoMaisculo():
– Possui o parâmetro chamado texto;
– Retorna o texto do parâmetro todo minúsculo.
• formataTexto():
– Possui o parâmetro chamado funcao;
– Possui a variável local texto, que recebe o retorno da função passada como parâmetro;
– Retorna o texto da variável local tudo em minúsculo ou maiúsculo, dependendo da
função passada.
1.7.5. Retornando uma função por outra
Como uma função é um objeto, ela pode ser retomada por outras funções.
Exemplo:
No exemplo, temos a função retornaFuncao(). Ela possui o parâmetro formal a. Dentro

dela, há uma outra função soma(), com o parâmetro formal b. Dentro da função soma,
há o retorno da soma do parâmetro a da função retornaFuncao() com o parâmetro b da
função soma().
A variável x receberá o retorno da função retornaFuncao(), com o valor 15 como parâmetro
real. Com isso, a variável x receberá a função soma(), ou seja, a variável está referenciando
a função soma() retornada pela função retornaFuncao(), como estudamos na seção 1.7.3.
Na linha 8, a variável x é chamada passando o valor 10 como parâmetro real. Então é

impresso o valor 25 (15 quando foi chamada a função retornaFuncao() mais 10 quando foi
chamada a função referenciada pela variável x, ou seja, a função soma()).
A mesma lógica é aplicada com a variável y.
1.7.6. Armazenando funções em coleções
Como uma função é um objeto, ela pode ser armazenada em coleções, tais como listas,
tuplas, sets e dicionários.
Exemplo:
No exemplo, temos três funções: tudoMinisculo(), tudoMaiusculo() e primeiraMaiuscula().

Cada função retorna uma manipulação de uma string passada como parâmetro.
A variável lista contém uma lista cujos elementos representam cada função criada. Então
é uma lista com três elementos.
A variável x contém uma string “rogerão Araújo”.
Na linha 13, temos um exemplo de acesso ao elemento da posição 1 da lista. No caso,
o elemento contém a função tudoMaiusculo(). Com isso, passamos como parâmetro para o
elemento o valor da variável x:
lista[1](x)
Como essa chamada está na função print(), será impressa a string “ROGERÃO ARAÚJO”.
Nas linhas 15 e 16, temos uma declaração for para percorrer os elementos na lista, pas-
sando para cada elemento a variável x como parâmetro.
Usei como exemplo o armazenamento das funções em uma lista, mas poderíamos usar
tuplas, sets e dicionários.
2. PROGRAMAÇÃO ORIENTADA A OBJETOS EM PYTHON

2.1. INTRODUÇÃO À POO
A Programação Orientada a Objetos (POO) é uma maneira de pensar os problemas,

utilizando modelos organizados a partir de conceitos do mundo real.
É definida como um modelo de análise, projeto e programação de sistemas baseados
na composição e interação entre diversas unidades de software chamadas de objetos.
O conceito de objeto é o componente fundamental da POO. Um objeto combina, em
uma única entidade, uma estrutura e um comportamento. É considerado entidade única
e indivisível.
Já as classes são definições de atributos e funções de um tipo de objetos, por exem-
plo, uma classe chamada Professor. Elas são abstrações e descrevem como os dados
serão representados e manipulados.
São seis os conceitos-chave da POO:
• Abstração:
– Elucida apenas as propriedades comuns de um conjunto de objetos, omitindo
os detalhes.
• Classes:
– São um conjunto de objetos que possuem o mesmo tipo.
• Objetos:
– São instâncias das classes.
• Encapsulamento:
– Distingue a especificação e a implementação das operações de um objeto.
• Herança:
– Permite ao usuário definir tipos de forma incremental, a partir de tipos existentes.
• Polimorfismo:
– Define que uma determinada operação pode se comportar de diferentes formas em
diferentes classes.
Figura 2.1: Conceitos-chave da POO.
Alguns autores citam apenas que são quatro os pilares da POO:
• Abstração;
• Encapsulamento;
• Herança;
• Polimorfismo.
Porém, a Abstração se desdobra em Classes e Objetos.
Figura 2.2: Pilares da POO.
A POO, ao ser usada como forma de desenvolvimento de sistemas, traz os seguin-

tes benefícios:
• Modularidade:
– O código fonte para um objeto pode ser escrito e mantido independentemente do
código fonte para outros objetos;
– Uma vez criado, um objeto pode ser facilmente introduzido no sistema.
• Encapsulamento de informações:
– Ao interagir somente com métodos de um objeto, os detalhes de sua implementação
interna permanecem escondidos do mundo exterior.
• Reutilização de código:
– Se um objeto já existe, pode-se usar esse objeto em outro programa.
• Facilidade de depuração e inserção:

– Se há um objeto problemático, pode-se removê-lo da aplicação e inserir um objeto
diferente para substituí-lo.
Figura 2.3: Benefícios da POO.
Python é uma linguagem de programação orientada a objetos, pois suporta os con-

ceitos da orientação a objetos.
Vamos entender como implementar em Python conceitos da POO com Python, tais como
classes, objetos, herança e polimorfismo.
DIRETO DO CONCURSO
19. (SUGEP/UFRPE/2018/UFRPE/TÉCNICO DE TECNOLOGIA DA INFORMAÇÃO/SIS-

TEMAS/ADAPTADA) Sobre Programação Orientada a Objetos (POO), julgue o item
seguinte como CERTO ou ERRADO.
POO é um paradigma de programação, sugerindo um padrão de desenvolvimento que
independe da linguagem utilizada.
Certo.
Os conceitos da POO são independentes de qualquer linguagem de programação, mas,
para que uma linguagem possa ser chamada de orientada a objetos, é necessário que ela
implemente os conceitos da POO.
20. (OBJETIVA/2012/EPTC/ANALISTA DE SISTEMAS) Além de métodos e atributos, para

que uma linguagem possa ser considerada orientada a objetos, quais conceitos também
devem estar implementados?
a. Abstração, persistência, herança e procedimentos.
b. Banco de dados, herança, procedimentos e persistência.
c. Abstração, encapsulamento, herança e polimorfismo.
d. Encapsulamento, recursividade, herança e procedimentos.
Letra c.
São quatro os pilares da POO: Abstração, Encapsulamento, Herança e Polimorfismo. Lem-
bre-se de que a Abstração se desdobra em Classes e Objetos.
Portanto, a letra C é o gabarito da questão.
21. (QUADRIX/2017/SEDF/PROFESSOR/INFORMÁTICA) Acerca de aspectos de lingua-

gens de programação, algoritmos e estruturas de dados e objetos, programação orien-
tada a objetos e arquitetura MVC, julgue o item subsequente.
Uma das desvantagens da programação orientada a objetos está no fato de que seus
programas são de difícil manutenção, uma vez que esse tipo de abordagem lida com
problemas complexos.
Errado.
Pelo contrário. Uma das vantagens da programação orientada a objetos está no fato de
que seus conceitos podem facilitar a manutenção dos programas, podendo lidar com pro-
blemas complexos.
22. (CESPE/2011/MEC/CARGO 9) Julgue o próximos item, a respeito de orientação a objetos.

Modularidade e reuso de código são alguns dos benefícios da orientação a objetos.
Certo.
A POO, ao ser usada como forma de desenvolvimento de sistemas, traz os seguintes be-
nefícios: modularidade, encapsulamento de informações, reutilização de código e facilida-
de de depuração e inserção.
23. (IFMT/2018/IFMT/INFORMÁTICA/ADAPTADA) Sobre a linguagem Python, julgue o

item a seguir como CERTO ou ERRADO.
Suporta os paradigmas: imperativo, orientado a objetos e funcional.
Certo.
Python é uma linguagem imperativa, orientada a objetos e funcional, o que torna a questão
totalmente correta.
24. (CESPE/2008/SERPRO/ANALISTA/DESENVOLVIMENTO DE SISTEMAS) Com rela-

ção às linguagens, julgue o item a seguir.
Python é uma linguagem livre de alto nível, orientada a objetos e de difícil leitura, pois
não permite identação de linhas de código.
Errado.
Python:
• É uma linguagem livre:

– De alto nível;
– Orientada a objetos;
– De fácil leitura.
• Exige indentação de linhas de código.
Lembre-se: Para Python, a indentação é de extrema importância.
25. (AOCP/2018/FUNPAPA/TÉCNICO EM COMPUTAÇÃO) Qual das linguagens de pro-

gramação a seguir NÃO possui suporte à orientação a objeto?
a. Python
b. C
c. Java
d. C#
e. Ruby
Letra b.
Sabemos que Python suporta os conceitos da orientação a objetos. Além dela, temos as
linguagens: Java, C++, C# e Ruby.
Das letras acima, apenas a linguagem C não suporta a orientação a objetos.
26. (IFB/2017/IFB/PROFESSOR INFORMÁTICA/DESENVOLVIMENTO DE SISTEMAS/

ADAPTADA) Com relação a Algoritmos e Estrutura de Dados, dadas as afirmações
abaixo, segundo Farrer (1999), julgue o item seguinte como CERTO ou ERRADO.
Python é uma linguagem procedural a qual não contempla orientação a objetos.
Errado.
Python tem, sim, suporte aos conceitos da orientação a objetos.
27. (UFMT/2016/UFMT/TÉCNICO DE TECNOLOGIA DA INFORMAÇÃO/ADAPTADA)

Sobre as linguagens de programação mais utilizadas na academia e indústria, julgue o
item seguinte como CERTO ou ERRADO.
As linguagens de programação C++, Python e Java utilizam o modelo de orientação
a objetos.
Certo.
A linguagem Python suporta os conceitos da orientação a objetos. Além dela, temos as
linguagens: Java, C++, C# e Ruby.
28. (QUADRIX/2019/CRA-PR/ANALISTA SISTEMA I) Julgue o item quanto à programação

orientada a objetos e à linguagem de programação Python.
Na estrutura de um programa em Python, as instruções contêm expressões que, por
sua vez, criam e processam objetos.
Certo.
Como estudado na aula I, as instruções contêm expressões. Nas instruções formadas por
expressões, podemos ter a criação de variáveis e a utilização delas.
29. (CETAP/2010/DETRAN/RR/ANALISTA DE SISTEMAS/ADAPTADA) Sobre as lingua-

gens de programação, julgue o item a seguir como CERTO ou ERRADO.
Pynthon não tem suporte à orientação a objetos.
Errado.
Python suporta, sim, os conceitos da orientação a objetos.
2.2. CLASSES E OBJETOS EM PYTHON
2.2.1. Criando classes e objetos
As classes podem definir:
• Construtor;
• Atributos e métodos de:
– Instâncias; ou
– Classe.
Sintaxe:
class NomeClasse:
def __init__(self, parâmetro 1, parâmetro 2, parâmetro N):
self.atributo 1 = parâmetro 1
self.atributo N = parametron N
def nomeMetodo(self, [parâmetro 1, parâmetro 2,...]):
[return] {valor}
Ao longo da seção 2.2, estudaremos cada item da sintaxe acima, porém iniciaremos com
uma sintaxe mais simples para a criação de uma classe:
class NomeClasse:
Na criação de uma classe, usamos a palavra-chave class, seguida do nome da classe.

Para criar um objeto, usamos a seguinte sintaxe:
variável = NomeClasse()
A sintaxe anterior mostra como um objeto é criado e inicializado e como uma variável
recebe essa nova instância como retorno.
Essa sintaxe representa um construtor de instâncias de classe. Ele serve para iniciali-
zar o estado de uma instância, podendo, para isso, receber alguns valores como parâmetros.
Figura 2.4: Fases da criação de um objeto.
Na figura 2.4, temos a ideia do processo de criação e inicialização de um objeto a partir

de um construtor.
Começaremos com o exemplo da criação da classe Professor, com os atributos nome
e disciplina.
Exemplo:
Cada objeto foi criado por ter valores diferentes para esses atributos de instância.
No exemplo, foi criado um objeto da classe Professor, que é referenciado pela variá-
vel rogerio:
rogerio = Professor()
A partir da variável rogerio, acessamos os atributos de instância nome e disciplina:
• rogerio.nome = “Rogerão Araújo”;

• rogerio. disciplina = “Desenvolvimento de Sistemas”.
ATENÇÃO
Os atributos definidos em uma classe em Python são públicos, o que faz com que
qualquer objeto possa ter acesso direto aos atributos de outro objeto.
Exemplo:
Uma classe não pode ter um bloco vazio de instruções:
Caso haja necessidade de ter uma classe com um bloco vazio, pode-se utilizar a pala-
vra-chave pass. Dessa forma, o erro não aparecerá:
Em Python, usa-se a palavra-chave None para representar objetos nulos. None não é
igual a 0, False ou uma string vazia. É um tipo de dado próprio (NoneType).
Exemplo:
No exemplo acima, o valor da variável objeto é nulo (None), por isso as instruções da
declaração if, da linha 3, e da declaração else, da linha 13, serão executadas.
Finalmente, objetos são abstrações de Python para dados. Todos os dados em um pro-
grama Python são representados por objetos ou por relações entre objetos.
• Os tipos de dados:
– int, float, complex, str e bool.
• As coleções:
– Listas, tuplas, sets e dicionários.
Os tipos de dados em Python são considerados classes, e os valores desses tipos são
considerados objetos. Veja: o tipo de dados (int, por exemplo) é como se fosse uma classe,
e um valor desse tipo (15, por exemplo) é como se fosse um objeto. Além disso, temos uma
variável que apontou para um objeto de tipo de dados, por exemplo, x = 15.
A mesma ideia pode ser replicada para as coleções em Python. Elas também são con-
sideradas classes, e é considerado objeto um conjunto de dados estruturados por algum
tipo dessas coleções. As coleções oferecem uma série de métodos que podem trabalhar os
dados de uma coleção, assim como uma classe oferece para um objeto criado a partir dela.
Além disso, um objeto de uma coleção é referenciado por uma variável.
Exemplo:
A variável linguagens apontou para um objeto do tipo list. A partir desse objeto, podemos
usar os métodos definidos para trabalhar com os dados, por exemplo, o método append().
O PULO DO GATO
Em Phyton, tudo é um objeto (tipos, valores, funções, métodos e instâncias) e todos pos-
suem atributos e métodos associados.
DIRETO DO CONCURSO
30. (FCC/2012/TER-CE/ANALISTA JUDICIÁRIO/ANÁLISE DE SISTEMAS/ADAPTADA)

Sobre a linguagem Phyton, julgue o item a seguir como CERTO ou ERRADO.
Instâncias são objetos criados a partir de uma classe definida pelo programador; o que
Python chama de instância é frequentemente denominado objeto em outras linguagens.
Certo.
Os objetos são instâncias das classes. Quando um objeto é criado, ele usa a estrutura de-
finida da sua classe, ou seja, o estado e o comportamento definidos pela classe.
31. (FCC/2012/TER-CE/ANALISTA JUDICIÁRIO/ANÁLISE DE SISTEMAS/ADAPTADA)

É possível acessar os atributos da instância diretamente, sem a necessidade de usar
um método.
Certo.
Sim, é possível acessar os atributos de uma instância de classe (objeto) sem a neces-
sidade de utilizar um método, porque os atributos definidos em uma classe em Python
são públicos.
32. (CCV/UFS/2014/UFS/TÉCNICO DE TECNOLOGIA DA INFORMAÇÃO/ADAPTADA)

Sobre a linguagem Python, julgue o item como CERTO ou ERRADO.
Possui uma implementação de orientação a objetos em que todos os atributos são,
obrigatoriamente, privados.
Errado.
Python suporta, sim, os conceitos da orientação a objetos, porém os atributos definidos em
uma classe em Python são públicos.
33. (IFPE/2019/IFPE/TÉCNICO EM TECNOLOGIA DA INFORMAÇÃO/DESENVOLVI-

MENTO/ADAPTADA) Sobre a linguagem de Programação Python, julgue o item a
Como qualquer outra linguagem orientada a objetos, Python segue o princípio do aces-
so uniforme (uniform access principle), sugerindo que atributos das classes sejam pri-
vados e que sejam acessados apenas através de métodos gets e sets.
Errado.
Os atributos definidos em uma classe em Python são públicos, o que faz com que qualquer
objeto possa ter acesso direto aos atributos de outro objeto, não precisando de métodos
gets e sets.
34. (FUNCERN/2017/IFRN/PROFESSOR/SISTEMAS DE INFORMAÇÃO/ADAPTADA) Em

relação às estruturas de controles da linguagem de programação Python, julgue o item
a seguir como CERTO ou ERRADO.
Null representa o tipo para objetos nulos.
Errado.
Em Python, usa-se a palavra-chave None para representar objetos nulos.
35. (FCC/2012/TRE-CE/ANALISTA JUDICIÁRIO/ANÁLISE DE SISTEMAS/ADAPTADA)

Sobre a linguagem Python, julgue o item a seguir como CERTO ou ERRADO.
Excetuando-se as classes, tudo é um objeto (tipos, valores, funções, métodos e instân-
cias), e todos possuem atributos e métodos associados.
Errado.
Em Python, tudo é um objeto, e todos possuem atributos e métodos associados.
2.2.2. Método __new__()
Estudamos que, para criar um objeto, utiliza-se a seguinte sintaxe:

A partir dessa linha de código, acontecem dois passos em Python:
1) A criação de um objeto;
2) A inicialização desse objeto.
O método que representa a criação do objeto é o método __new__(). Ele é um método

estático especial que cria uma instância de uma classe, ou seja, um objeto. Esse método
deve retornar o objeto criado.
Após o método __new__() retornar a instância criada, um outro método especial é cha-
mado para inicializar o objeto: método __init__(). Veremos na próxima seção.
Todas as classes possuem os métodos __new__() e __init__(), sendo que este é sempre
executado após a criação de um objeto a partir de classe, ou seja, o método __init__() é exe-
cutado após o método __new__():
• O método __new__() cria um o objeto;

• O método __init__() inicializa o estado do objeto:
– Ou seja, inicializa os atributos de instância.
Caso o método __new__() não retorne uma instância, o método __init__() não será chamado.
ATENÇÃO
Os nomes dos métodos __new__() e __init__() são nomes padrões em Python, e o
método __new__() é sempre chamado antes do método __init__(), quando se instan-
cia uma classe.
Quando chamamos um construtor de classe (por exemplo, rogerio = Professor(“Rogerão

Araújo”, “Desenvolvimento de Sistemas”)), o método __new__() da classe é chamado para
receber os parâmetros reais do construtor, criar o objeto e então repassar os valores dos
parâmetros para o método __init__(), para que este inicialize os atributos de instância.
Sintaxe do método __new__():
def __new__(cls, *args):

return object.__new__(cls)
ATENÇÃO
Por ser um método estático, ou seja, um método de classe, e não das instâncias
da classe, o método __new__() não precisa do parâmetro self, que estudaremos
mais adiante.
O parâmetro cls representa o tipo da própria classe da qual estamos criando um objeto.
Já o parâmetro *args representa os parâmetros citados no momento da criação de um
objeto a partir da classe.
Revisando: Como estudado na aula III, quando um parâmetro está com o operador * ou
o operador **, significa que há a compactação de parâmetros. Ela acontece quando não
se sabe quantos parâmetros são necessários para uma função em Python. Para compacta-
ção de listas ou tuplas, usa-se o operador * no parâmetro formal, na criação da função. Para
compactação de dicionários, usa-se o operador ** no parâmetro formal.
Exemplo:
Os valores dos parâmetros do método __new__() são passados depois para o método
__init__().
No exemplo acima, de forma explícita, os métodos __new__() e __init__() foram imple-
mentados na classe.
Na linha 16, criamos uma variável para apontar para o objeto recém-criado, chamando
o construtor da classe. Quando se chama o construtor, há os dois processos acontecendo:
• A criação de um objeto com o método __new__();

• A inicialização do objeto com o método __init__().
ATENÇÃO
Dificilmente há uma implementação explícita do método __new__() em questões so-
bre classes em Python. Normalmente, as questões trazem a implementação do mé-
todo __init__().
No exemplo, na área do resultado da execução do código, aparece a ordem de execução

dos métodos citados. De forma resumida, é o que consta na figura 2.5:
Figura 2.5: Processo da criação e inicialização de um objeto em Python.
DIRETO DO CONCURSO
36. (FUNCERN/2017/IFRN/PROFESSOR/SISTEMAS DE INFORMAÇÃO/ADAPTADA) Em

relação ao seguinte código escrito em Python, que define a estrutura da classe Conta-
Bancaria:, julgue o item a seguir como CERTO ou ERRADO.
class ContaBancaria:
num_contas = 0
def __init__(self, agencia, numero, saldo):
self.agencia = agencia
self.numero = numero
self.saldo = saldo
ContaBancaria.num_contas += 1
def __del__(self):
ContaBancaria.num_contas -= 1
def depositar(self, valor):
self.saldo = self.saldo + valor
def sacar(self, valor):
self.saldo = self.saldo -valor

def consultarSaldo(self):
return self.saldo
Criação de objetos chama primeiro o método __init__() e, em seguida, o __new__().
Errado.
Quando se chama o construtor de uma classe, acontecem dois processos:
A criação de um objeto com o método __new__();
A inicialização do objeto com o método __init__().
O método __new__() é sempre chamado antes do método __init__(), quando se instancia
uma classe.
2.2.3. Método __init__()
O método ou função __init__() é um método especial de uma classe. Ele atribui

valores aos atributos de instância ou outros métodos necessários, quando o objeto está
sendo inicializado.
Fazendo uma comparação com linguagens como C++ e Java, o método método __init__
() é semelhante ao conceito puro dos construtores. Estes são usados para inicializar o
estado do objeto.
No entanto, em Python, estudamos que há dois processos quando se chama um cons-
trutor de uma classe:
• A criação de um objeto com o método __new__();

• A inicialização do objeto com o método __init__().
Sintaxe do método __init__():

O parâmetro self (o primeiro parâmetro do método __init__()) é uma referência à ins-

tância atual da classe e é usado para acessar atributos de instância definidos na classe.
ATENÇÃO
O parâmetro self deve ser o primeiro parâmetro de qualquer método de instância
definido na classe (que estudaremos na seção 2.2.5), ou seja, são métodos que tra-
balham com atributos de instância dos objetos.
Para criar um objeto, usamos a seguinte sintaxe:
variável = NomeClasse(parâmetro 1, parâmetro 2, parâmetro N)
Quando o método __init__() não é trabalhado explicitamente na classe, utilizamos o cons-

trutor padrão, sem parâmetros (como vimos na seção 1.3.1):
ATENÇÃO
Não passamos um valor como parâmetro real para o parâmetro self. O parâmetro self
é usado dentro do método __init__() para acessar atributos de instância definidos na
classe. Isso também acontece com outros métodos de instância definidos na classe.
Exemplo:
No exemplo acima, a classe Professor foi modificada para explicitamente alterarmos o

método construtor __init__(). Ela continua ainda com os dois atributos de instância, mas defi-
nidos dentro do método __init__(). Os atributos são inicializados pelos parâmetros formais
nome e disciplina.
No método __init__(), temos os:
• atributos de instâncias (referenciados pelo parâmetro self):

– self.nome;
– self.disciplina;
• parâmetros formais (definidos no cabeçalho do método):

– self (referência à intância atual);
– nome;
– disciplina.
Para criar um objeto da nova versão da classe Professor, precisamos chamar o constru-
tor, passando dois parâmetros: um para nome e outro para disciplina:
rogerio = Professor(“Rogerão Araújo”, “Desenvolvimento de Sistemas”)
Dessa forma, um objeto da classe Professor foi criado (chamando implicitamente o

método __new__()), e depois os atributos de instância nome e disciplina foram inicializados
(via método __init__() de forma explícita, pois implementamos o método).
A partir da variável rogerio, acessamos os atributos de instância nome e disciplina:
• rogerio.nome;
• rogerio. disciplina.
DIRETO DO CONCURSO

O método construtor (p.ex.: __init__()) é um método opcional invocado quando a classe
é instanciada.
Certo.
Todas as classes possuem o método __init__(), que sempre é executado após a criação de
um objeto a partir de classe. O método __init__() é executado após o método __new__().
Acredito que o adjetivo “opcional” seja pelo fato de o programador explicitamente trabalhar
o método ou não.
Quando o método __init__() não é trabalhado explicitamente na classe, utilizamos o cons-
trutor padrão, sem parâmetros:
38. (FCC/2018/MPE-PE/ANALISTA MINISTERIAL/INFORMÁTICA) Considere o fragmento

de código Python abaixo.
class Cliente:
___I___
self.nome = nome
self.renda = renda
p1 = Cliente(“Maria”, 5678.98)
print(p1.nome)
print(p1.renda)
Para que o código seja compilado e executado corretamente, a lacuna I deverá ser
preenchida com
a. __init__(self, nome, renda):
b. function __init(self, nome, renda):
c. def __construct(self, nome, renda):
d. def __init__(self, nome, renda):
e. Cliente(self, nome, renda):
Letra d.
Para que o código seja compilado e executado corretamente, a lacuna I deverá ser pre-
enchida com:
def __init__(self, nome, renda):
A letra D traz a linha que falta para que o código seja executado.
No código da questão, temos a classe Cliente com dois atributos de instância: nome e renda.
Ao chamar o construtor da classe Cliente na linha 6 do código organizado:
• O método __new__() cria o objeto de forma implícita;

• O método __init__() explicitamente inicializa os atributos de instância desse objeto criado.
Em síntese, na linha 6, a variável p1 apontou para um objeto da classe Cliente. O objeto

foi criado chamando o construtor da classe e passou por dois parâmetros reais: “Maria”
e 5678.78.
Na linha 7, foi impresso o valor do atributo de instância nome do objeto, apontado pela
variável p1. Na linha 8, foi impresso o valor do atributo de instância renda.
39. (CESGRANRIO/2016/UNIRIO/TÉCNICO EM TECNOLOGIA DA INFORMAÇÃO) Con-

sidere o seguinte código em Python
>>> class Empregado:

... def __init__ (self, nome, sexo, salario):
... self.nome = nome
... self.sexo = sexo
... self.salario = salario
...
>>> Fulano = Empregado(“Fulano de Tal”,”m”, 2500.00)
>>> print (Fulano.nome[0:6], Fulano.salario)
A saída na tela após a execução será

a. Fulano m
b. Fulano 2500.0
c. Fulano de Tal m
d. Fulano de Tal 2500.0
e. Fulano de Tal m 2500.0
Letra b.
No código da questão, temos a classe Empregado com três atributos de instância: nome,
sexo e salário.
Como estudado, quando o objeto é criado a partir dessa classe, o método __init__() inicia-
liza os atributos de instância.
Na linha 7 do código organizado, há a variável Fulano, que apontou para um objeto da
classe Empregado. O objeto foi criado chamando o construtor da classe e passou por três
parâmetros reais: “Fulano de Tal”, “m” e 2500.00.
Na linha 8, foram impressos o intervalo da posição 0 até a posição 5 do valor do atributo de
instância nome (“Fulano”) e o valor do atributo de instância salario (2500.00).
Na linha 9, foram impressos os valores dos atributos de instância nome, sexo e salário.
40. (FCC/2012/TRE/CE/ANALISTA JUDICIÁRIO/ANÁLISE DE SISTEMAS/ADAPTADA)

Considere:
1 class A:
2 a = 1
3 class B(A):
4 _c = 3
5 def__init__(self):
6 print self.a
7 print self._c
8 a = A()
9 print isinstance(a, B)
10 b = B()
11 print isinstance(b, B)
12 b = A()
13 print isinstance(b, A)
Em relação à sintaxe em Python, julgue o item seguinte como CERTO ou ERRADO.

Linha 5 exibe um método construtor.
Certo.
Fazendo uma comparação com linguagens como C++ e Java, o método __init__() é se-
melhante ao conceito puro dos construtores. Os construtores são usados para inicializar
o estado do objeto.
2.2.4. Atributos e métodos de instância
Um atributo de instância é um atributo que representa um valor de um objeto. Por

exemplo, o atributo nome da classe Professor. Cada objeto dessa classe poderá ter um
nome diferente.
Os atributos de instância nas classes em Python são referenciados dentro de uma classe
com a palavra-chave self e são inicializados dentro do método __init__().
Um método de instância, por sua vez, é um método que trabalha com atributos de ins-
tância. Sendo assim, todos os métodos de instância precisam do parâmetro self.
ATENÇÃO
Os membros (atributos e métodos) definidos em uma classe em Python são públi-
cos, o que faz com que qualquer objeto possa ter acesso direto aos atributos ou mé-
todos de outro objeto. Além disso, os métodos definidos em uma classe são virtu-
ais, ou seja, são métodos cujo comportamento pode ser sobrescrito em uma classe
derivada por um método com a mesma assinatura. Esse conceito é uma parte muito
importante do polimorfismo em programação orientada a objetos.
A sintaxe da criação de método segue a sintaxe de funções vista na aula III:

[return] {valor}
Como uma sintaxe mais completa, podemos ter a seguinte sintaxe para a criação de uma
classe, com a implementação explícita do método __init__() (com atributos de instância) e a
criação de um método de instância:
class NomeClasse:
[return] {valor}
Exemplo:
No método __init__() da classe Professor, temos os:
• Atributos de instâncias (referenciados pelo parâmetro self):

– self.nome;
– self.disciplina.
• Parâmetros formais (definidos no cabeçalho do método):

– self (referência à instância atual);
– nome;
– disciplina.
Além disso, criamos o método de instância gerarDados(), que retorna uma string conca-
tenada com os valores dos atributos de instância nome e a disciplina do objeto criado a partir
da classe Professor.
Na linha 10, temos a variável rogerio, que apontou para um objeto da classe Professor:
rogerio = Professor(“Rogerão Araújo”, “Desenvolvimento de Sistemas”)
Passamos para o construtor dois parâmetros reais: “Rogerão Araújo” e “Desenvolvimento

de Sistemas”.
Na linha 12, foi impresso o valor do atributo de instância nome do objeto apontado pela
variável rogerio e, na linha 13, foi impresso o valor do atributo de instância disciplina.
Na linha 14, foi impresso o resultado retornado do método gerarDados() a partir da vari-
ável rogerio (print(rogerio.gerarDados())):
Professor Rogerão Araújo: Desenvolvimento de Sistemas
DIRETO DO CONCURSO

Um ponto fundamental da sintaxe para métodos é que o primeiro argumento é especial,
e convenciona-se utilizar o nome self para ele.
Certo.
O parâmetro self deve ser o primeiro parâmetro de qualquer método de instância definido
na classe, ou seja, é o método que trabalha com atributos de instância dos objetos.
42. (FUNCERN/2017/IFRN/PROFESSOR/SISTEMAS DE INFORMAÇÃO/ADAPTADA)

Analise o seguinte código escrito em Python, que define a estrutura da classe Conta-
Bancaria, e julgue o item a seguir como CERTO ou ERRADO.
num_contas = 0
self.saldo = saldo
def __del__(self):
return self.saldo
Palavra self deve ser fornecida como argumento em todos os métodos de instâncias.
Certo.
O parâmetro self deve ser o primeiro parâmetro de qualquer método de instância definido
na classe, ou seja, é o método que trabalha com atributos de instância dos objetos.
Todos os métodos do código da questão são de instância, por isso que eles possuem como
primeiro parâmetro o self.
2.2.5. Atributos e métodos de classe
Um atributo de classe é um atributo que representa um valor da classe, e não de suas

instâncias. Os valores desses atributos são compartilhados entre os objetos de uma classe.
Em Python, podemos usar como atributos de classe os atributos que não são referencia-
dos com a palavra-chave self e que são definidos fora do método __init__().
Exemplo:
No exemplo anterior, a classe Professor possui um atributo de instância nome. Cada

instância da classe poderá ter seu próprio nome. Na linha 7, temos uma variável rogerio
apontando para um objeto criado, passando o parâmetro real “Rogerão Araújo” para popular
o atributo de instância nome. Já na linha 10, a variável wash apontou para um objeto criado,
passando o parâmetro real “Washington Almeida” para popular o atributo de instância.
A classe Professor também possui um atributo chamado curso, já inicializado com o valor
“Gran Cursos”. Podemos acessar o atributo a partir do nome da classe (linha 13) ou a partir
das instâncias (linhas 14 e 15).
Já na linha 17, houve a mudança do valor do atributo curso, a partir do nome da classe.
Perceba que o novo valor do atributo é o mesmo, seja ele acessado pelo nome da classe,
seja ele acessado pelas instâncias (linhas 18 a 20).
Se a mudança do valor do atributo acontecer a partir de uma instância, o valor do atributo

acontecerá apenas para essa instância. Isso essencialmente substitui o atributo de classe e
o transforma em um atributo de instância disponível apenas para essa instância.
Exemplo:
O código do exemplo é mais enxuto que o primeiro exemplo. Na linha 10, a mudança do
valor do atributo curso aconteceu a partir do nome da variável rogerio, que apontou para uma
instância da classe Professor. Com isso, o atributo curso agora virou um atributo de instância
para o objeto.
Veja que o valor do atributo curso mudou apenas para o objeto apontado variável rogerio
(linhas 11 a 13).
Agora estudaremos o método de classe, também chamado de método estático. Ele é
um método que trabalha com atributos de classe e, por isso, não precisa do parâmetro self.
A sintaxe da criação de método segue a sintaxe de funções vista na seção 1.2, porém
adicionada com a anotação @staticmethod:
@staticmethod
def nomeMetodo([parâmetro 1, parâmetro 2,...]):
[return] {valor}
Exemplo:
A classe Professor, no exemplo anterior, continua com o atributo de classe curso e há a

criação do método de classe gerarDadosCurso(), que retorna o atributo de classe.
De acordo com a sintaxe de criação de métodos de classe, na criação do método gerar-
DadosCurso(), podemos notar as duas diferenças em relação aos métodos de instância:
• Não foi citado o parâmetro self;

• O método foi anotado com @staticmethod.
Agora podemos acessar o atributo de classe:
• Diretamente a partir do nome da classe;

– Professor.curso, na linha 16 do exemplo.
• Retornado pelo método de classe gerarDadosCurso();

– Professor.gerarDadosCurso(), na linha 17 do exemplo.
Podemos também acessar os atributos e métodos de classe através das variáveis que
referenciam os objetos dessa classe:
• rogerio.curso, na linha 21 do exemplo; ou

• rogerio.gerarDadosCurso(), na linha 22 do exemplo.
No exemplo, o valor do atributo de classe curso se manteve o mesmo para os dois obje-
tos criados (rogerio e washington).
Vejamos outro exemplo:
No exemplo acima, temos a classe ContaBancaria. Ela possui:
• Atributo de classe:
– num_contas.
• Atributos de instância:
– agencia;
– numero;
– saldo;
• Método de classe:
– consultarNumeroContas().
• Métodos de instância:
– depositar();
– sacar();
– consultarSaldo().
A cada objeto criado, o atributo de classe num_contas é atualizado. Isso acontece no

método __init__():
Temos dois objetos, por isso o valor do atributo num_contas é igual a 2. Podemos aces-
sar o valor desse atributo de classe a partir:
• Do nome da classe:
– Acessando o atributo: ContaBancaria.num_contas; ou
– Acessando o método de classe: ContaBancaria.consultarNumeroContas();
• Do objeto da classe:
– Acessando o atributo: conta1.num_contas; ou
– Acessando o método de classe: conta2.consultarNumeroContas();
O método consultarNumeroContas() não possui o parâmetro self e foi anotado com a

anotação @staticmethod.
Os atributos de instância agencia, numero e saldo possuem valores únicos para cada
instância, e podemos acessar e manipular o valor do atributo saldo através dos métodos de
instância depositar(), sacar() e consultarSaldo().
DIRETO DO CONCURSO

Bancaria, e julgue o item a seguir como CERTO ou ERRADO.
num_contas = 0
self.saldo = saldo
def __del__(self):
return self.saldo
Variável num_contas é encapsulada e individual para cada instância da classe.
Errado.
Segundo o código da questão, e como foi estudado na parte teórica nesta seção, num_
contas é um atributo de classe, ou seja, é um valor único para classe, e não para suas
instâncias. Então não há uma variável individual para cada instância.

Bancaria:, e julgue o item a seguir como CERTO ou ERRADO.
num_contas = 0
self.saldo = saldo
def __del__(self):
return self.saldo
Palavra @static escrita antes da definição do método sacar() torna o método estático.
Errado.
O método sacar(), por trabalhar com o atributo de instância saldo, não deveria ser um mé-
todo estático ou de classe.
Além disso, se houvesse um método de classe, ele não deveria possuir o parâmetro self e
deveria ser anotado com @staticmethod, e não com @static.

Considere:
1 class A:
2 a = 1
3 class B(A):
4 _c = 3
5 def__init__(self):
6 print self.a
7 print self._c
8 a = A()
9 print isinstance(a, B)
10 b = B()
11 print isinstance(b, B)
12 b = A()
13 print isinstance(b, A)
Em relação à sintaxe em Python, é INCORRETO afirmar que, na linha 4, o atributo é

considerado privado.
Certo, mas deveria ser errado.

Na linha 4 do código da questão, temos um atributo _c, que pode ser usado como atributo
de classe, sendo acessado diretamente pela classe ou pelas instâncias dessa classe.
Os atributos definidos em uma classe em Python são públicos, o que faz com que qualquer
objeto possa ter acesso direto aos atributos de outro objeto. Isso faz o texto do item ser
errado, mas a banca deu como certo.
2.2.6. Método __del__()
Já entendemos a criação de objetos com o método __new__() e a inicialização de objetos

com o método __init__(). Agora vamos entender como deletar um objeto e o que pode ser
feito quando isso acontece.
A princípio, vamos entender como deletar um objeto. Para isso, podemos usar a
palavra-chave del.
Exemplo:
Como o objeto foi deletado na linha 13, então haverá um erro na linha 14 (print(rogerio.
gerarDados())): o objeto ‘rogerio’ não foi definido.
Ao ser deletado, pode-se limpar (fechar) recursos abertos no método __init__(), por
exemplo, um arquivo ou uma conexão de banco de dados. Isso pode ser feito implemen-
tando o método __del__().
Esse método, assim como o método __init__(), é um método especial de uma classe.
Também é nomeado de método destruidor e é acionado quando a instância (objeto) da
classe está prestes a ser destruída.
ATENÇÃO
O nome do método __del__() é um nome padrão em Python.
Sintaxe:
def __del__(self):
[return] {valor}
Exemplo:
A nova versão da classe Professor possui a implementação explícita do método __del__

(). Agora, quando o objeto dessa classe, por exemplo, o objeto da variável rogerio, é deletado
com del, o método __del__() será chamado. No exemplo acima, foi impresso: “Deletando um
objeto do professor Rogerão Araújo”.
Melhorando o exemplo da classe ContaBancaria, podemos usar o método __del__() para
diminuir o número de contas abertas. No método __init__(), o valor do atributo de classe
num_contas é incrementado, e, no método __del__(), ao deletar um objeto, o valor do atri-
buto num_contas é decrementado.
Exemplo:
Perceba que, no exemplo acima, ao ser criado o objeto referenciado pela variável conta1,
o valor de num_contas foi incrementado em 1. Assim acontece quando é criado o objeto da
variável conta2, fazendo o atributo num_contas passar para 2. Ao se deletar o objeto da vari-
ável conta 1, o valor de num_contas foi decrementado em 1.
Como uma sintaxe mais completa, podemos ter a seguinte sintaxe para a criação de uma
classe, com a implementação explícita do método __init__() (com atributos de instância), a
criação de um método de instância e a implementação explícita do método __del__():
class NomeClasse:
[return] {valor}
def __del__(self):
[return] {valor}
ATENÇÃO
Assim como o método __new__(), dificilmente há uma implementação explícita do
método __del__() em questões sobre classes em Python. Normalmente, as questões
trazem a implementação do método __init__().
2.2.7. Tipos de objetos, classes old-style e new-style e tipo object
Criar uma classe é como criar um novo “tipo” de objetos, permitindo que instâncias desse
tipo sejam produzidas.
Exemplo:
Podemos verificar o tipo de uma instância das seguintes formas:
• Utilizando o próprio nome da classe criada (linha 9);

• Utilizando a função type() (linha 10);
– Passando uma variável que representa um objeto; ou
• Utilizando o atributo __class__ implícito (linha 11);

– Que pode ser acessado por qualquer objeto.
Todas essas formas retornam o mesmo tipo:
<class ‘__main__.Professor’>
Essa unificação dos conceitos de classes e dos tipos de objetos iniciou a partir do
Python 2.2, com a entrada das classes new-style. A principal motivação para a introdução
dessas classes é fornecer um modelo de objeto unificado com um metamodelo completo.
Até a versão 2.1 da linguagem Python, o conceito de classe não era o mesmo que o
conceito de tipo de um objeto. Isso acontecia quando havia, nessa versão do Python, o tipo
clássico de classes ou classes old-style.
Quando existia esse tipo de classe, a instrução objeto.__ class__ retornava a classe
do objeto (como vimos mais acima), entretanto, ao usar type(objeto), retornava <type ‘ins-
tance’>. Isso porque todas as instâncias de classes old-style, independentemente de sua
classe, eram implementadas com um único tipo integrado, chamado instance.
ATENÇÃO
Da versão 2.2 até antes da versão 3 da linguagem Python, os dois tipos de classes
existiam, por razões de compatibilidade. As classes old-style foram removidas do
Python 3, existindo apenas as classes new-style. Portanto, todas as classes neste
curso são new-style.
Na versão 2.2 da linguagem Python, a sintaxe da declaração de classes new-style era:
class ClasseNewStyle(object):
Já a sintaxe da declaração de classes old-style era:
class ClasseOldStyle:
Todas as classes new-style descendem direta ou indiretamente do tipo de alto-ní-

vel object e, para ter uma diferenciação de sintaxe das classes old-style na versão 2.2,
na declaração das classes new-style, era necessário informar entre o tipo object, como
acontece na sintaxe da declaração de uma subclasse, que estudaremos na seção sobre
herança em Python.
ATENÇÃO
Uma classe new-style é uma classe derivada do tipo de alto-nível object. Já uma clas-
se old-style é aquela que não tem uma classe base ou aquela que é derivada somen-
te de outras classes old-style.
A partir da versão 3, as classes old-style deixaram de existir e, com isso, a sintaxe da

declaração de classes new-style ficou igual à declaração das old-style:
class ClasseNewStyle:
Mesmo assim, com essa nova sintaxe para as classes new-style, elas continuam des-
cendendo direta ou indiretamente do tipo de alto-nível object. Quando não é informado expli-
citamente uma superclasse na declaração de uma classe, então essa classe descende do
tipo object.
ATENÇÃO
Todas as classes new-style descendem direta ou indiretamente do tipo de alto-ní-
vel object.
DIRETO DO CONCURSO
46. (COMPERVE/2016/UFRN/TÉCNICO DE TECNOLOGIA DA INFORMAÇÃO) Classes

do tipo new-style foram incorporadas à linguagem Python a partir da sua versão 2.7, o
que permite expandir a capacidade de declaração de classes. Classes do tipo new-style
a. permitem uma separação mais definida entre types e classes.
b. são declaradas com herança direta ou indireta da classe object.
c. foram desenvolvidas a partir da versão 1.8 da linguagem.
d. possuem suporte a implementação de herança restrita.
Letra b.
Comentando cada letra:
a. Errada. As classes new-style permitem a unificação entre os conceitos de classes e dos
tipos de objetos.
b. Certa. Todas as classes new-style descendem direta ou indiretamente do tipo de alto-ní-
vel object.
c. Errada. As classes new-style surgiram na versão 2.2 da linguagem Python.
d. Errada. Há dois tipos de herança: simples e múltipla. As classes new-style em Python
possuem suporte aos dois tipos.
Portando, letra B é nosso gabarito.
2.2.8. Função isinstance()
A função isinstance() retorna True se o objeto especificado for do tipo especificado,

caso contrário, False.
Sintaxe:
isinstance(objeto, tipo)
Exemplo:
Há duas classes no exemplo acima: A e B.

Na linha 7, a variável x apontou para um objeto da classe A, e, na linha 8, a variável y,
para um objeto da classe B.
Na linha 10, foi retornado o tipo da variável x (classe A). Por isso que a linha 11 (isinstan-
ce(x, A)) retornou True e a linha 12 (isinstance(x, B)) retornou False.
Fizemos a mesma coisa com a variável y: na linha 14, foi retornado o tipo da variável y
(classe B). Por isso que a linha 15 (isinstance(y, A)) retornou False e a linha 16 (isinstance(y,
B)) retornou True.
REFERÊNCIAS
1. APOSTILA DE PROGRAMAÇÃO FÁCIL EM PYTHON EM PDF. Disponível em: https://

www.passeidireto.com/arquivo/30903709/apostila-de-programacao-facil-em-python-em-
-pdf. Acesso em: 13 jan. 2023.
2. PARA QUÊ É UTILIZADO A PROGRAMAÇÃO EM PYTHON? Disponível em: https://br.bi-

tdegree.org/tutoriais/programacao-em-python/. Acesso em: 13 jan. 2023.
3. DOWNEY, Allen B. Pense Python. 2 ed. Tradução do livro Pense em Python (2ª ed.), de
Allen B. Downey. Disponível em: https://penseallen.github.io/PensePython2e/. Acesso em:
13 jan. 2023.
4. MATOS, David. Por que Cientistas de Dados escolhem Python?. Disponível em: http://
www.cienciaedados.com/por-que-cientistas-de-dados-escolhem-python/. Acesso em: 13
jan. 2023.
5. PYTHON. Disponível em: https://www.python.org/. Acesso em: 13 jan. 2023.
6. APOSTILA PYTHON E ORIENTAÇÃO A OBJETOS. Disponível em: https://www.caelum.

com.br/apostila-python-orientacao-a-objetos. Acesso em: 13 jan. 2023.
7. PYTHON PARA PROGRAMADORES. Disponível em: https://python-para-programadores.

readthedocs.io/pt/latest/index.html. Acesso em: 13 jan. 2023.
8. PYTHON TUTORIAL. Disponível em: w3schools.com/python/. Acesso em: 13 jan. 2023.
PYTHON – FUNÇÕES E POO #VEM
SER
ASSINATURA GRAN
ILIMITADA
CONCURSOS, OAB E RESIDÊNCIAS
Mude de vida. Garanta seu

futuro com a melhor plataforma de
estudos para concurso público.
A realização do seu sonho merece um
investimento de qualidade. Não desperdice
tempo, dinheiro e energia. Invista no seu sucesso,
no seu futuro e na sua realização proﬁssional.
Assine AGORA a melhor e mais completa

plataforma de ensino para concursos públicos.
Sua nomeação na palma da sua mão com a
Assinatura Ilimitada 8.0 do Gran Cursos Online.
FACILITE SEUS ESTUDOS: TUDO NO SEU TEMPO VOCÊ NÃO ESTÁ SOZINHO:
rotas de aprovação, mapas E ESPAÇO: mentorias diárias, ao vivo,
mentais, resumos e faça o download de e fórum de dúvidas não
exercícios irão te guiar por videoaulas e de PDFs e te deixarão só
um caminho mais simples estude onde e quando nesta caminhada.
e rápido. você quiser e puder.
TUDO DE NOVO QUANTAS NÚMEROS GRANDES: TUDO NA SUA MÃO:

VEZES VOCÊ QUISER: milhares de alunos só a Assinatura Ilimitada
quantas vezes você quiser, aprovados, mais de 2 milhões oferece, de forma livre
quantas vezes você precisar, de questões, mais de 27 mil e gratuita: Gran Questões,
estude com o material mais cursos e centenas de Gerenciador de Estudos,
atualizado e de melhor professores para te ajudar Audiobooks e muito mais!
qualidade do mercado. a passar.
Contato para vendas: Quero ser assinante

(61) 99884-6348 | De segunda a quinta até as 22h e sexta até as 21h. ilimitado agora

E Book Python Funcoes e Poo

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

E Book Python Funcoes e Poo

Enviado por

Direitos autorais:

Formatos disponíveis

GRAN CURSOS ONLINE

DIRETORIA DE PRODUÇÃO EDUCACIONAL

FICHA TÉCNICA DO MATERIAL

1.1. Introdução sobre modularização..........................................................................6

1.1.3. Tipos de módulos................................................................................................7

1.1.4. Escopo de variáveis............................................................................................8

1.1.5. Tipos de parâmetros...........................................................................................9

1.1.6. Tipos de passagens de parâmetros..................................................................9

1.2. Funções em Python...............................................................................................10

1.3. Variáveis globais....................................................................................................16

1.4. Funções recursivas...............................................................................................24

1.5. Funções lambda.....................................................................................................34

1.6. Recebendo um número arbitrário de parâmetros...............................................36

1.6.2. Descompactando (unpacking) parâmetros......................................................37

1.6.3. Compactando (packing) parâmetros.................................................................39

1.7. Funções de primeira classe..................................................................................41

1.7.2. Tipo das funções em Python.............................................................................42

1.7.3. Armazenando uma função em uma variável....................................................43

1.7.4. Passando uma função como parâmetro para outra........................................43

1.7.5. Retornando uma função por outra....................................................................44

1.7.6. Armazenando funções em coleções.................................................................45

2. PROGRAMAÇÃO ORIENTADA A OBJETOS EM PYTHON.........................................46

2.1. Introdução à POO...................................................................................................46

2.2. Classes e objetos em Python...............................................................................51

2.2.1. Criando classes e objetos..................................................................................51

2.2.2. Método __new__()...............................................................................................57

2.2.3. Método __init__().................................................................................................60

2.2.4. Atributos e métodos de instância......................................................................66

2.2.5. Atributos e métodos de classe..........................................................................69

2.2.6. Método __del__().................................................................................................75

2.2.7. Tipos de objetos, classes old-style e new-style e tipo object........................79

2.2.8. Função isinstance()............................................................................................81

Fala, meu (minha) consagrado(a) concurseiro(a)? Tudo beleza com você?

Professor Rogério Araújo – @profRogeraoAraujo

1.1. INTRODUÇÃO SOBRE MODULARIZAÇÃO

A modularização é a forma de dividir as tarefas em módulos, também chamados de

Figura 1.1: Características fundamentais da modularização.

• Cuidam de uma parte separada de um problema;

• Reduzir o tamanho do algoritmo;

1.1.3. Tipos de módulos

Há dois tipos de módulos:

Figura 1.2: Tipos de módulos.

1. (IFPA/2016/IFPA/TÉCNICO DE TECNOLOGIA DA INFORMAÇÃO) Em programação

1.1.4. Escopo de variáveis

Em relação ao escopo de variáveis, há as variáveis globais, que são declaradas no

Figura 1.3: Escopo de variáveis.

2. (UNIRIO/2014/UNIRIO/ANALISTA TECNOLOGIA DA INFORMAÇÃO/DESENVOL-

1.1.5. Tipos de parâmetros

Figura 1.4: Tipos de parâmetros.

Os parâmetros formais são definidos no cabeçalho do módulo. Eles possuem escopo

1.1.6. Tipos de passagens de parâmetros

Na passagem por valor, há a transmissão do valor do parâmetro real para o parâme-

Figura 1.5: Tipos de passagens de parâmetros.

3. (CESPE/2011/STM/ANALISTA JUDICIÁRIO/ANÁLISE DE SISTEMAS/ESPECÍFICOS)

1.2. FUNÇÕES EM PYTHON

As funções, como estudado, são blocos de código executados apenas quando

• Receber dados através de parâmetros;

def nomeFuncao([parâmetro formal 1, parâmetro formal 2,...]):

Para a criação de uma função em Python, usamos a palavra-chave def, seguida do

• Retornar o valor para uma variável;

• Ser usada com outras funções;

• A condição da declaração while é feita com a variável b;

4. (CETAP/2010/AL-RR/ANALISTA DE SISTEMAS/ADAPTADA) Sobre a linguagem de

2.2.2. Método new()...............................................................................................57

2.2.3. Método init().................................................................................................60

2.2.6. Método del().................................................................................................75