1_Apostila_Python_-_Programa_Caça_Talentos_material (2)

Prévia do material em texto

1 
Rua Professor Ângela Pinto, 88, Sala 5 Torre - Recife - PE - CEP 50710-010 - Fone: (81) 9 99046260 
CNPJ. 35.328.913/0001-16 - E-mail: suporte.cursos@admtec.org.br 
 
 
 
 
 
 
 
 
 
SERVIÇO DE CAPACITAÇÃO, NO ÂMBITO DO PROGRAMA CAÇA 
TALENTOS, PARA DESENVOLVIMENTO SÓCIO EMOCIONAIS, E 
SÓCIO PROFISSIONAIS AMBOS EM FORMATO EAD, COM 
ENFOQUE NO ACESSO AO MERCADO DE TRABALHO, POR MEIO 
DE QUALIFICAÇÃO NO SETOR DE TECNOLOGIA, INOVAÇÃO E 
ATIVIDADES CORRELATAS NO ESTADO DE PERNAMBUCO 
 
 
 
 
CURSO DE PROGRAMAÇÃO EM PYTHON – 240 HORAS 
 
 
 
 
 
 
 
 
 
 
 
 
 
2 
Rua Professor Ângela Pinto, 88, Sala 5 Torre - Recife - PE - CEP 50710-010 - Fone: (81) 9 99046260 
CNPJ. 35.328.913/0001-16 - E-mail: suporte.cursos@admtec.org.br 
 
Sumário 
 
1. O que é Python? .............................................................................................................. 6 
1.1 Python no mercado de trabalho ................................................................................ 6 
1.2 Por que aprender Python?......................................................................................... 7 
1.3 Carreiras em Python .................................................................................................. 8 
1.4 Características do Python ......................................................................................... 9 
2. Variáveis e tipos de dados em Python ........................................................................... 9 
2.1 Identação .................................................................................................................... 9 
2.2 Variáveis ................................................................................................................... 10 
2.3 Comentários ............................................................................................................. 11 
2.4 Casting/Conversão ................................................................................................... 12 
2.5 Identificar o tipo da variável .................................................................................... 12 
2.6 Strings/literais .......................................................................................................... 12 
2.6a Strings são como arrays/listas .......................................................................... 12 
2.6b Uso de repetições em Strings: .......................................................................... 13 
2.6c Tamanho de Strings: .......................................................................................... 13 
2.6d Checar existência de uma String em outra ....................................................... 13 
2.6e Cortando Strings ................................................................................................. 14 
Cortando desde o início desde o índice .................................................................... 14 
Cortando até o fim ...................................................................................................... 14 
2.6f Modificando Strings ............................................................................................ 15 
2.6g Caracteres de escape ......................................................................................... 16 
2.7 Variáveis são sensíveis a variação de Caixa alta e baixa (letras maiúsculas e 
minúsculas) .................................................................................................................... 17 
2.8 Nomes de variáveis .................................................................................................. 17 
2.9 Nomes compostos ................................................................................................... 17 
2.10 Output de variáveis ................................................................................................ 18 
2.11 Output de múltiplas variáveis ................................................................................ 18 
2.12 Tipos de dados no Python ..................................................................................... 18 
2.13 Booleanos ............................................................................................................... 19 
2.14 Operadores ............................................................................................................. 19 
Operadores aritméticos .............................................................................................. 20 
Operadores de atribuição .......................................................................................... 20 
 
3 
Rua Professor Ângela Pinto, 88, Sala 5 Torre - Recife - PE - CEP 50710-010 - Fone: (81) 9 99046260 
CNPJ. 35.328.913/0001-16 - E-mail: suporte.cursos@admtec.org.br 
Operadores de comparação ....................................................................................... 21 
Operadores lógicos .................................................................................................... 22 
Operadores de identidade .......................................................................................... 22 
Operadores de associação ........................................................................................ 22 
Operadores Bitwise Python ....................................................................................... 23 
Estruturas Condicionais ................................................................................................... 24 
3.1 If ................................................................................................................................. 24 
3.2 Elif ............................................................................................................................. 24 
3.3 Else ............................................................................................................................ 25 
3.3 Operadores complementares .................................................................................. 26 
4. Estruturas de repetição ................................................................................................. 26 
4.1 While ......................................................................................................................... 26 
4.2 Break ......................................................................................................................... 27 
4.3 Continue .................................................................................................................... 27 
4.4 For ............................................................................................................................. 27 
4.5 Range() ...................................................................................................................... 28 
5. Listas .............................................................................................................................. 29 
5.1 Tamanho de uma lista .............................................................................................. 29 
5.2 Acessando itens da lista .......................................................................................... 30 
5.3 Verificando itens na lista ......................................................................................... 30 
5.4 Modificando itens na lista ........................................................................................ 31 
5.5 Adicionando itens na lista ....................................................................................... 31 
5.6 Removendo itens da lista ........................................................................................ 31 
5.6 Comprehension ........................................................................................................ 32 
6. Funções e Expressões Lambda ....................................................................................33 
6.1 Criando funções ....................................................................................................... 33 
6.2 Chamando funções .................................................................................................. 34 
6.3 Argumentos .............................................................................................................. 34 
6.3.b Numero de argumentos ..................................................................................... 34 
6.4 Retorno ..................................................................................................................... 35 
6.5 Recursão ................................................................................................................... 35 
6.6 Funções Lambda ...................................................................................................... 36 
6.6.a Sintaxe ................................................................................................................ 37 
6.6b Por que usar funções lambda? .......................................................................... 37 
7. Debug e tratamento de erros ........................................................................................ 38 
 
4 
Rua Professor Ângela Pinto, 88, Sala 5 Torre - Recife - PE - CEP 50710-010 - Fone: (81) 9 99046260 
CNPJ. 35.328.913/0001-16 - E-mail: suporte.cursos@admtec.org.br 
8. Módulos em Python ....................................................................................................... 40 
8.1 Criando um modulo.................................................................................................. 40 
8.2 Utilizando um modulo .............................................................................................. 41 
8.3 Variáveis em um modulo ......................................................................................... 41 
8.4 Renomeando Módulos ............................................................................................. 42 
8.5 Módulos Nativos ....................................................................................................... 42 
9. Leitura e Escrita ............................................................................................................. 42 
9.1 Input do usuário ....................................................................................................... 42 
9.2 Utilizando arquivos .................................................................................................. 43 
Sintaxe ......................................................................................................................... 44 
9.3 Lendo arquivos ......................................................................................................... 44 
Ler partes do arquivo ................................................................................................. 45 
Ler linha por linha ....................................................................................................... 45 
9.4 Escrevendo em arquivos ......................................................................................... 46 
Criando um novo arquivo do zero ............................................................................. 47 
10. Paradigma Orientação a Objeto .................................................................................. 48 
10.1 Criando uma classe ................................................................................................ 48 
10.2 Criando um objeto .................................................................................................. 48 
10.3 A função construtora: __init__() ............................................................................ 48 
10.4 Métodos do objeto.................................................................................................. 49 
10.5 Modificando atributos de um objeto ..................................................................... 50 
11. Herança ........................................................................................................................ 50 
11.1 Criando uma classe base ....................................................................................... 50 
11.2 Criando uma classe derivada ................................................................................ 51 
11.3 Criando um construtor próprio ............................................................................. 52 
11.4 Utilizando a função super() .................................................................................... 52 
11.5 Adicionando atributos ........................................................................................... 53 
11.6 Adicionando métodos ............................................................................................ 53 
12. Polimorfismo ................................................................................................................ 54 
Exemplo de funções polimórficas definidas pelo usuário: ..................................... 54 
Polimorfismo com métodos de classe ...................................................................... 55 
Polimorfismo com herança ........................................................................................ 56 
13. Iteradores e funções geradoras .................................................................................. 57 
13.1 Iterador e Iteraveis.................................................................................................. 57 
13.2 Aplicando iteradores a laços de repetição ........................................................... 58 
 
5 
Rua Professor Ângela Pinto, 88, Sala 5 Torre - Recife - PE - CEP 50710-010 - Fone: (81) 9 99046260 
CNPJ. 35.328.913/0001-16 - E-mail: suporte.cursos@admtec.org.br 
13.3 Criando um iterador ............................................................................................... 58 
13.4 Yield ........................................................................................................................ 59 
13.5 Função geradora .................................................................................................... 60 
14. Decoradores ................................................................................................................. 61 
Propriedades das funções de primeira classe: ........................................................ 61 
Aninhando decoradores ............................................................................................. 65 
15. Manipulando arquivos CSV e JSON ........................................................................... 66 
15.1 CSV .......................................................................................................................... 66 
15.1a Lendo arquivos CSV ......................................................................................... 66 
15.1b Escrevendo em arquivos CSV ......................................................................... 68 
15.2 Json ......................................................................................................................... 70 
15.2a JSON em Python ............................................................................................... 70 
15.2b Parsing do JSON - Convertendo JSON para Python ...................................... 70 
15.2c Convertendo Python para JSON ...................................................................... 71 
15.2d Formatando os resultados ............................................................................... 72 
16. Datas e horas ............................................................................................................... 72 
16.1 Criando objetos do tipo data ................................................................................. 73 
16.2 O métodostrftime() ................................................................................................ 74 
Tabela de formatos: .................................................................................................... 74 
17. Testes ........................................................................................................................... 76 
Testes de unidade ...................................................................................................... 76 
18. Gerenciamento de memoria ........................................................................................ 77 
 
 
 
 
 
 
 
 
 
 
 
 
 
6 
Rua Professor Ângela Pinto, 88, Sala 5 Torre - Recife - PE - CEP 50710-010 - Fone: (81) 9 99046260 
CNPJ. 35.328.913/0001-16 - E-mail: suporte.cursos@admtec.org.br 
 
1. O que é Python? 
 
Python é uma linguagem de programação interpretada, interativa, orientada a objetos 
e de alto nível extremamente popular. Python é uma linguagem de programação 
dinamicamente tipada que faz uso de Garbage Collection (Coletor de lixo). Foi criado 
por Guido van Rossum durante 1985-1990. Assim como o Perl, o código-fonte Python 
também está disponível sob a GNU General Public License (GPL). 
 
Python suporta vários paradigmas de programação, incluindo o paradigma 
Procedural, Orientado a Objetos e Funcional. A filosofia de design do Python enfatiza 
a legibilidade do código com o uso significativo de identação no código ao ponto de 
substituir as chaves ({}) utilizadas em outras linguagens famosas como python,c,c++ 
etc. 
Esta apostila visa fornece uma base solida para o estudo e a pratica da linguagem de 
programação Python, desde conceitos básicos até alguns conceitos avançados dentro 
do escopo temporal do curso. 
 
1.1 Python no mercado de trabalho 
 
Hoje, o Python tem uma demanda muito alta e todas as grandes empresas estão 
procurando ótimos programadores Python para desenvolver sites, componentes de 
software e aplicativos ou para trabalhar com tecnologias de Data Science, IA e ML. 
No momento em que essa apostila está sendo feita, há uma grande escassez de 
programadores de Python, onde o mercado demanda mais programadores Python 
devido à sua aplicação em Machine Learning, Inteligência Artificial etc. 
 
Hoje, um programador Python com 3-5 anos de experiência pode exigir um salário 
mensal de cerca de RS$ 8.000, caso o programador esteja aberto a oportunidades 
internacionais empresas americanas pagam anualmente US$ 150.000 a 
programadores plenos afinal Python é uma das linguagens mais demandadas no 
mundo. Embora o salário possa variar dependendo da localização do trabalho. É 
 
7 
Rua Professor Ângela Pinto, 88, Sala 5 Torre - Recife - PE - CEP 50710-010 - Fone: (81) 9 99046260 
CNPJ. 35.328.913/0001-16 - E-mail: suporte.cursos@admtec.org.br 
impossível listar todas as empresas que usam Python, para citar algumas grandes 
empresas são: 
 
 Google 
 Serasa 
 Intel 
Accenture 
 NASA 
 Globo 
 PayPal 
 Mercado Livre 
 Facebook 
 IBM 
 Amazon 
 Netflix 
 Pinterest 
 Uber 
 
Então, você pode ser o próximo funcionário em potencial para qualquer uma dessas 
grandes empresas. 
 
1.2 Por que aprender Python? 
 
Python é consistentemente classificado como uma das linguagens de programação 
mais populares do mundo. Python é bastante fácil de aprender, portanto, se você está 
começando a aprender qualquer linguagem de programação, o Python pode ser sua 
ótima escolha. Hoje, várias escolas, faculdades e universidades (Regionalmente 
temos Cesar School e UFPE ensinando Python em seus cursos introdutórios de 
programação dos seus respectivos cursos de Ciência da computação) estão 
ensinando Python como sua principal linguagem de programação. Existem muitas 
outras boas razões que fazem do Python a melhor escolha de qualquer programador: 
 
Python é Open Source, o que significa que está disponível gratuitamente. 
 
8 
Rua Professor Ângela Pinto, 88, Sala 5 Torre - Recife - PE - CEP 50710-010 - Fone: (81) 9 99046260 
CNPJ. 35.328.913/0001-16 - E-mail: suporte.cursos@admtec.org.br 
Python é simples e muito fácil de aprender 
Python é versátil e pode ser usado para criar muitas coisas diferentes. 
Python possui bibliotecas de desenvolvimento poderosas, incluindo AI, ML, etc. 
Python é muito procurado e garante alto salário 
Python é OBRIGATÓRIO para estudantes e profissionais que trabalham para se 
tornarem um grande Engenheiro de Software. Algumas das principais vantagens de 
aprender Python: 
 
Python é interpretado - Python é processado em tempo de execução pelo 
interpretador. Você não precisa compilar seu programa antes de executá-lo. Isso é 
semelhante ao PERL e PHP. 
Python é interativo - você pode realmente abrir um prompt de comando do Python e 
interagir diretamente com o interpretador para escrever seus programas. 
Python é Orientado a Objetos – Python da suporta ao estilo de programação Orientada 
a Objetos ou técnicas que encapsulam código dentro de objetos. 
Python é uma linguagem para iniciantes - Python é uma ótima linguagem para 
programadores de nível iniciante e suporta o desenvolvimento de uma ampla gama 
de aplicações, desde processamento de texto simples até navegadores web e jogos. 
 
Para aqueles que já tem uma ferramenta de python instalada podem copiar este 
código para testar: 
 
# Este é o meu primeiro programa Python. 
# Isto irá imprimir 'Olá, Mundo!' como a saída 
print("Olá, Mundo!") 
 
vocês podem mudar o valor dentro de print() 
 
1.3 Carreiras em Python 
 
Se você aprender bem Python, então você terá uma grande carreira pela frente. Aqui 
estão apenas algumas das opções de carreira onde o Python é uma habilidade 
essencial: 
 
9 
Rua Professor Ângela Pinto, 88, Sala 5 Torre - Recife - PE - CEP 50710-010 - Fone: (81) 9 99046260 
CNPJ. 35.328.913/0001-16 - E-mail: suporte.cursos@admtec.org.br 
 
 Desenvolvedor de jogos 
 Web designer 
 Desenvolvedor Python 
 Desenvolvedor full-stack 
 Engenheiro de aprendizado de máquina 
 Cientista de dados 
 Analista de informações 
 Engenheiro de dados 
 Engenheiro de DevOps 
 Engenheiro de software 
 
1.4 Características do Python 
 
A seguir estão características importantes da linguagem Python: 
 
Ela suporta métodos tanto da programação funcional e estruturada, além de 
orientação a objeto (posteriormente sendo referida como “OO”) 
Ela pode ser usada como uma linguagem de script ou pode ser compilada em byte-
code para construir grandes aplicativos. 
Ela fornece tipagem dinâmica de alto nível de dados e suporta verificação de tipos 
dinâmicos. 
Ela dá suporte a coleta de lixo (outros materiais podem se referir a 
feature/característica como garbage collector) automática. 
Ela pode ser facilmente integrada com C, C++, Java entre outras 
linguagens/ferramentas. 
 
2. Variáveis e tipos de dados em Python 
 
2.1 Identação 
 
A identação (através do tab, espaços ou até mesmo automaticamente a depender do 
ambiente de programação) refere-se aos espaços no início de uma linha de código. 
 
10 
Rua Professor Ângela Pinto, 88, Sala 5 Torre - Recife - PE - CEP 50710-010 - Fone: (81) 9 99046260 
CNPJ. 35.328.913/0001-16 - E-mail: suporte.cursos@admtec.org.br 
 
Onde em outras linguagens de programação a identação do código serve apenas para 
legibilidade e boa pratica, no Python ela é muito importante e um erro na identação 
ocasionará na quebra do código. 
 
Python usa a identação para indicar um bloco de código geralmente iniciado após o 
caractere ‘:’ (dois pontos): 
௙௚ 
if 5 > 2: 
 print("Cinco é maior que dois!") 
 
Python apresentará um erro se você falhar na identação: 
௥ 
if 5 > 2: 
print("Cinco é maior que dois!") 
 
O espaçamento mais comum equivale a quatro espaços/um tab. 
 
2.2 Variáveis 
 
Em Python, as variáveis são criadas quando você atribui um valor a elas: 
 
x = 5 
y = "Olámundo!" 
 
Python ao contrário de algumas linguagens como Java e C++ interpreta 
dinamicamente o tipo da variável e não é necessário declarar seu tipo, haverá uma 
interpretação inteligente através do valor atribuído a variável, as variáveis podem até 
mudar de tipo depois de definidas: 
 
x = 4 # x é do tipo int 
x = "Amanda" # x agora é do tipo str 
 
11 
Rua Professor Ângela Pinto, 88, Sala 5 Torre - Recife - PE - CEP 50710-010 - Fone: (81) 9 99046260 
CNPJ. 35.328.913/0001-16 - E-mail: suporte.cursos@admtec.org.br 
print(x) #print imprime o que há dentro dos parênteses 
2.3 Comentários 
 
O Python tem suporte para comentários para fins de documentação no código. 
 
Os comentários começam com um # e o Python interpretará o restante da linha como 
um comentário: 
 
#Isso é um comentário. 
print("Olá, mundo!") 
 
Os comentários podem ser usados para explicar o que está escrito no código, tornar 
o código mais legível e também podem ser usados para impedir a execução de linha(s) 
ao testar o código. 
 
Os comentários também podem ser colocados no final de uma linha e o Python 
ignorará o resto da linha: 
 
print("Olá, Mundo!") #Este é um comentário 
 
Exemplo de prevenção de execução de um código: 
#print("Olá, Mundo!") 
print("Sigamos em frente") 
 
Para fazer comentários em várias linhas em sequência pode-se utilizar “”” 3 aspas 
duplas para iniciar e novamente para finalizar colocando seu comentário no meio: 
""" 
Este é um comentário 
escrito em 
mais do que apenas uma linha 
 
12 
Rua Professor Ângela Pinto, 88, Sala 5 Torre - Recife - PE - CEP 50710-010 - Fone: (81) 9 99046260 
CNPJ. 35.328.913/0001-16 - E-mail: suporte.cursos@admtec.org.br 
""" 
print("Olá mundo!") 
2.4 Casting/Conversão 
 
Se você deseja especificar o tipo de dado de uma variável, isso pode ser feito através 
do cast. 
 
x = str(3) # x será '3' 
y = int(3) # y será 3 
z = float(3) # z será 3,0 
 
2.5 Identificar o tipo da variável 
 
Você pode obter o tipo de dados de uma variável com a função type(). 
 
x = 5 
y = "Joao" 
print(type(x)) #retornara int 
print(type(y)) #retornara str 
 
2.6 Strings/literais 
 
Palavras e texto em geral são armazenados em Strings que podem ser identificados 
através das aspas duplas ao redor do texto: 
 
x = "João" 
 
2.6a Strings são como arrays/listas 
 
Como muitas outras linguagens de programação populares, strings em Python são 
arrays de bytes que representam caracteres unicode. No entanto, o Python não possui 
 
13 
Rua Professor Ângela Pinto, 88, Sala 5 Torre - Recife - PE - CEP 50710-010 - Fone: (81) 9 99046260 
CNPJ. 35.328.913/0001-16 - E-mail: suporte.cursos@admtec.org.br 
um tipo de dados para caractere, um único caractere é simplesmente uma string com 
um comprimento 1. 
 
Colchetes podem ser usados para acessar elementos da string. 
 
a = "Olá, Mundo!" 
print(a[1]) #imprimira "l" pois as casas/espaços das strings/listas #começam a ser 
contadas a partir do 0 
 
2.6b Uso de repetições em Strings: 
 
Como strings são arrays, podemos fazer um laço de repetição através dos caracteres 
de uma string, com um loop for: 
 
for x in "banana": 
 print(x) 
#imprimira todas as letras de banana separadas por uma linha cada x representa 
cada caractere da palavra quando usado neste contexto 
 
2.6c Tamanho de Strings: 
 
Para obter o comprimento de uma string, use a função len(): 
 
a = "Olá, Mundo!" 
print(len(a)) #imprimira 11 pois além das letras e sinais espaço também conta como 
um caractere 
 
2.6d Checar existência de uma String em outra 
 
Para verificar se uma determinada frase ou caractere está presente em uma string, 
podemos usar a palavra-chave in: 
 
 
14 
Rua Professor Ângela Pinto, 88, Sala 5 Torre - Recife - PE - CEP 50710-010 - Fone: (81) 9 99046260 
CNPJ. 35.328.913/0001-16 - E-mail: suporte.cursos@admtec.org.br 
txt = "As melhores coisas da vida são de graça!" 
print("graça" in txt) #retornara True(verdadeiro) 
 
podendo inclusive ser usado em uma estrutura de decisão como o if que abordaremos 
mais tarde 
 
2.6e Cortando Strings 
 
Você pode retornar uma substring usando a sintaxe de corte. Especifique o índice 
inicial e o índice final, separados por dois pontos, para retornar uma parte da string: 
 
b = "Olá, Mundo!" 
print(b[2:5])#imprimira os caracteres da posição 2 até a posição 5 (não inclusa) 
gerando "á, " 
 
Cortando desde o início desde o índice 
 
Ao deixar de fora o índice inicial, o intervalo começará no primeiro caractere: 
 
Obtenha os personagens desde o início até a posição 5 (não incluído): 
 
b = "Olá, Mundo!" 
print(b[:5])#imprimira os caracteres desde o inicio até a posição 5 (não inclusa) 
gerando "Olá, " 
 
Cortando até o fim 
 
Ao deixar de fora o índice final, o intervalo irá até o final: 
 
Pegue os personagens da posição 2 e até o final: 
 
 
15 
Rua Professor Ângela Pinto, 88, Sala 5 Torre - Recife - PE - CEP 50710-010 - Fone: (81) 9 99046260 
CNPJ. 35.328.913/0001-16 - E-mail: suporte.cursos@admtec.org.br 
b = "Olá, Mundo!" 
print(b[2:])#imprimira os caracteres da posição 2 até o fim gerando "á, Mundo!" 
 
2.6f Modificando Strings 
 
Python tem um conjunto de métodos que você pode usar em strings. 
 
O método upper() retorna a string em letras maiúsculas: 
 
a = "Olá, Mundo!" 
print(a.upper()) #Imprimira "OLÁ, MUNDO!" 
 
O método lower() retorna a string em letras minúsculas: 
 
a = "Olá, Mundo!" 
print(a.lower()) #Imprimira "olá, mundo!" 
 
O método strip() remove qualquer espaço em branco no início ou no fim do texto: 
 
a = " Olá, Mundo! " 
print(a.strip()) # retorna "Olá, Mundo!" 
 
O método replace() substitui uma string por outra string: 
 
a = "Olá, Mundo!" 
print(a.replace("l", "m")) #imprime "Oma, Mundo!" 
 
O método split() divide a string em substrings se encontrar instâncias do separador 
entre parênteses: 
 
 
16 
Rua Professor Ângela Pinto, 88, Sala 5 Torre - Recife - PE - CEP 50710-010 - Fone: (81) 9 99046260 
CNPJ. 35.328.913/0001-16 - E-mail: suporte.cursos@admtec.org.br 
a = "Olá, Mundo!" 
print(a.split(",")) # retorna ['Olá', 'Mundo!'] uma lista composta de 2 strings que foram 
separadas pela ',' 
 
Pode-se concatenar duas strings através do +: 
 
a = "Olá" 
b = "Mundo" 
c = a + b 
print(c)#Mescla a variável a com a variável b na variável c gerando "OláMundo" caso 
queira separar as palavras deve-se ter um caractere de espaço em uma das strings 
 
2.6g Caracteres de escape 
 
Para inserir alguns caracteres especiais em uma string, use um caractere de escape 
que é uma barra invertida \ seguida pelo caractere que você deseja inserir. 
 
Um exemplo de um caractere especial é uma aspa dupla dentro de uma string que é 
cercada por aspas duplas: 
 
txt = "Nos somos o "Leão" do norte." #dara erro 
 
Para corrigir esse problema, use o caractere de escape \": 
 
txt = "Nos somos o \"Leão\" do norte."#o \" sera substituido pelo caractere das aspas 
na hora da interpretação da string 
 
Outros exemplos de caracteres especiais são: 
 
\' Aspas Simples 
\\ Barra invertida 
 
17 
Rua Professor Ângela Pinto, 88, Sala 5 Torre - Recife - PE - CEP 50710-010 - Fone: (81) 9 99046260 
CNPJ. 35.328.913/0001-16 - E-mail: suporte.cursos@admtec.org.br 
\n Nova Linha 
\t Tab 
 
2.7 Variáveis são sensíveis a variação de Caixa alta e baixa (letras maiúsculas 
e minúsculas) 
 
a = 4 
A = "Sandra" 
#A nao substituira a 
 
 
2.8 Nomes de variáveis 
 
Uma variável pode ter um nome curto (como x e y) ou um nome mais descritivo (idade, 
nomeDoCarro, volume_total). 
 
Regras para variáveis: 
 
1. Um nome de variável deve começar com uma letra ou o caractere sublinhado 
‘_’ 
2. Um nome de variável não pode começar com um número 
3. Um nome de variável pode conter apenas caracteres alfanuméricos e 
sublinhados (A-z, 0-9 e _ ) 
4. Os nomes das variáveis diferenciam maiúsculas de minúsculas (idade, Idadee IDADE são três variáveis diferentes) 
 
2.9 Nomes compostos 
 
Nomes de variáveis com mais de uma palavra podem ser difíceis de ler. 
 
Existem várias técnicas que você pode usar para torná-los mais legíveis por 
convenção em Python usa-se o snake_case: 
 
 
18 
Rua Professor Ângela Pinto, 88, Sala 5 Torre - Recife - PE - CEP 50710-010 - Fone: (81) 9 99046260 
CNPJ. 35.328.913/0001-16 - E-mail: suporte.cursos@admtec.org.br 
meu_nome_de_variavel = "João" 
 
Cada palavra é separada por um caractere de sublinhado, há outros como camelCase 
que também são validos por uma questão de compatibilidade, mas por pura 
convenção recomenda-se usar snake_case 
 
2.10 Output de variáveis 
 
A função print() do Python é frequentemente usada para gerar a saída das variáveis 
e escreve-las 
 
x = "Python é incrível" 
print(x) #imprimira na tela "Python é incrivel" 
 
2.11 Output de múltiplas variáveis 
 
Pode-se utilizar a função print() para gerar output de várias variáveis, separadas por 
uma vírgula: 
 
x = "Python" 
y = "é" 
z = "incrível" 
print(x, y, z) #imprimira na tela "Python é incrivel" 
 
+ também pode ser usado no lugar da virgula, porém deve-se haver cuidado pois ao 
usá-lo junto com números pode ser interpretado como o operador matemático ou até 
dar erro caso tente combinar um operador de string com um inteiro sem fazer a 
conversão(casting). 
 
2.12 Tipos de dados no Python 
 
 
19 
Rua Professor Ângela Pinto, 88, Sala 5 Torre - Recife - PE - CEP 50710-010 - Fone: (81) 9 99046260 
CNPJ. 35.328.913/0001-16 - E-mail: suporte.cursos@admtec.org.br 
Na programação, o tipo de dado é um conceito importante. Variáveis podem 
armazenar dados de diferentes tipos, e diferentes tipos podem fazer coisas diferentes. 
Python tem os seguintes tipos de dados: 
 
Tipo de texto: str “olá” 
Tipos numéricos: int(inteiros), float(racionais), complex(complexos, utilizam j no lugar 
do i) 1, 2.8, 1j operações matematicas do teclado funcionam neles 
Tipos de sequência: list, tuple, range 
Tipo de mapeamento: dict 
Tipos de conjunto: set, frozenset 
Tipo booleano: bool 
Tipos binários: bytes, bytearray, memoryview 
Nenhum Tipo: NoneType(parecido com o nulo/null de outras linguagens) 
 
2.13 Booleanos 
 
Na programação, muitas vezes você precisa saber se uma expressão é 
True(verdadeira) ou False(falsa). Você pode avaliar qualquer expressão em Python e 
obter uma das duas respostas, True ou False.Quando você compara dois valores, a 
expressão é avaliada e o Python retorna a resposta booleana: 
 
print(10 > 9) #True 
print(10 == 9) #False 
print(10 < 9) #False 
 
esse tipo de formato de dado é muito usado em estruturas de decisão e repetição 
 
2.14 Operadores 
 
Os operadores são usados para realizar operações em variáveis e valores. 
No exemplo abaixo, usamos o operador + para somar dois valores: 
 
 
20 
Rua Professor Ângela Pinto, 88, Sala 5 Torre - Recife - PE - CEP 50710-010 - Fone: (81) 9 99046260 
CNPJ. 35.328.913/0001-16 - E-mail: suporte.cursos@admtec.org.br 
print(10 + 5)#imprimira 15 
 
Python divide os operadores nos seguintes grupos: 
 
 Operadores aritméticos 
 Operadores de atribuição 
 Operadores de comparação 
 Operadores lógicos 
 Operadores de identidade 
 Operadores de associação 
 Operadores bit a bit 
 
Operadores aritméticos 
 
Os operadores aritméticos são usados com valores numéricos para realizar operações 
matemáticas comuns: 
 
Operador Nome Exemplo 
+ Adição x+y 
- Subtração x-y 
* Multiplicação x*y 
/ Divisão x/y 
% Módulo x%y 
** Exponenciação x**y 
// Divisão inteira x//y 
 
Operadores de atribuição 
 
Os operadores de atribuição são usados para atribuir valores a variáveis: 
 
 
21 
Rua Professor Ângela Pinto, 88, Sala 5 Torre - Recife - PE - CEP 50710-010 - Fone: (81) 9 99046260 
CNPJ. 35.328.913/0001-16 - E-mail: suporte.cursos@admtec.org.br 
Operador Exemplo Equivalência 
= x = 5 x = 5 
+= x += 3 x = x + 3 
-= x -= 3 x = x - 3 
*= x *= 3 x = x * 3 
/= x /= 3 x = x / 3 
%= x %= 3 x = x % 3 
//= x //= 3 x = x //3 
**= x **= 3 x = x ** 3 
&= x &= 3 x = x & 3 
|= x |= 3 x = x |= 3 
^= x ^= 3 x = x ^= 3 
>>= x >>= 3 x = x >> 3 
<<= x <<= 3 x = x << 3 
 
Operadores de comparação 
 
Os operadores de comparação são usados para comparar dois valores gerando um 
booleano: 
 
Operador Nome Exemplo 
== Igualdade x == y 
!= Diferente de x != y 
> Maior que x > y 
< Menor que x < y 
>= Maior ou igual a x >= y 
<= Menor ou igual a x <= y 
 
 
22 
Rua Professor Ângela Pinto, 88, Sala 5 Torre - Recife - PE - CEP 50710-010 - Fone: (81) 9 99046260 
CNPJ. 35.328.913/0001-16 - E-mail: suporte.cursos@admtec.org.br 
Operadores lógicos 
 
Os operadores lógicos são usados para combinar instruções condicionais: 
 
Operador Descrição Exemplo 
and Retorna True se ambas as 
declarações forem 
verdadeiras 
x < 5 and x < 10 
or Retorna True se uma das 
declarações for verdadeira 
x < 5 or x < 4 
not Inverte o resultado, 
retorna False se o 
resultado for verdadeiro e 
vice-versa 
not(x < 5 and x < 10) 
 
Operadores de identidade 
 
Os operadores de identidade são usados para comparar os objetos, não se tem 
valores iguais, mas se forem realmente o mesmo objeto, com o mesmo endereço de 
memória: 
 
Operador Descrição Exemplo 
is Retorna True se ambas as 
variáveis forem o mesmo 
objeto 
x is y 
is not Retorna True se ambas 
as variáveis não forem o 
mesmo objeto 
x is not y 
 
Operadores de associação 
 
Os operadores de associação são usados para testar se uma sequência existe em um 
objeto: 
 
 
23 
Rua Professor Ângela Pinto, 88, Sala 5 Torre - Recife - PE - CEP 50710-010 - Fone: (81) 9 99046260 
CNPJ. 35.328.913/0001-16 - E-mail: suporte.cursos@admtec.org.br 
Operador Descrição Exemplo 
in Retorna True se uma 
sequência com o valor 
especificado estiver 
presente no objeto 
x in y 
not in Retorna True se uma 
sequência com o valor 
especificado não estiver 
presente no objeto 
x not in y 
 
Operadores Bitwise Python 
 
Operadores bit a bit são usados para comparar números binários: 
 
Operador Nome Descrição 
& AND Define cada bit como 1 se 
ambos os bits forem 1 
| OR Define cada bit como 1 se 
um dos dois bits for 1 
^ XOR Define cada bit como 1 se 
apenas um dos dois bits 
for 1 
 
~ NOT Inverte todos os bits 
<< Empurrar para a esquerda Empurra o número para a 
esquerda preenchendo 
com zeros a casa mais a 
direita e retirando os bits 
mais à esquerda 
>> Empurrar para a direita Empurra o número para a 
direita preenchendo a 
casa a mais à esquerda 
com uma cópia da casa 
mais à esquerda e 
retirando os bits mais a 
direita 
 
 
24 
Rua Professor Ângela Pinto, 88, Sala 5 Torre - Recife - PE - CEP 50710-010 - Fone: (81) 9 99046260 
CNPJ. 35.328.913/0001-16 - E-mail: suporte.cursos@admtec.org.br 
Para demais métodos relacionados aos tipos de dados consultar a 
documentação da linguagem: https://docs.python.org/3/library/stdtypes.html 
 
 
3. Estruturas Condicionais 
 
3.1 If 
 
O Python se utiliza dos operadores booleanos de várias maneiras, dentre elas em 
condicionais e loops. 
 
Uma condicional básica é escrita usando a palavra-chave if: 
a = 33 
b = 200 
if b > a: 
 print("b é maior que a") 
#imprimira o que tem dentro da condicional ja que de fato b é maior que a 
 
Lembrando Python conta com o uso da indentação (espaço em branco/tab no início 
de uma linha) para definir o escopo no código. Outras linguagens de programação 
costumam usar chaves para essa finalidade. 
a = 33 
b = 200 
if b > a: 
print("b é maior que a") # desse jeito o print não estará sujeito a estrutura de decisão 
possivelmente causando um erro 
 
3.2 Elif 
 
A palavra-chave elif é uma maneira de dizer "se as condições anteriores não forem 
verdadeiras, tente esta condição". 
 
25 
Rua Professor Ângela Pinto, 88, Sala 5 Torre - Recife - PE - CEP 50710-010 - Fone: (81) 9 99046260CNPJ. 35.328.913/0001-16 - E-mail: suporte.cursos@admtec.org.br 
a = 33 
b = 33 
if b > a: 
 print("b é maior que a") 
elif a == b: 
 print("a e b são iguais") 
#Neste exemplo a é igual a b, então a primeira condição não é verdadeira, mas a 
condição em elif é verdadeira, então imprimimos na tela que "a e b são iguais". 
 
3.3 Else 
 
A palavra-chave else pega qualquer coisa que não seja capturada pelas condições 
anteriores. 
a = 200 
b = 33 
if b > a: 
 print("b é maior que a") 
elif a == b: 
 print("a e b são iguais") 
else: 
 print("a é maior que b") 
#Neste exemplo a é maior que b, então a primeira condição não é verdadeira, 
também a condição elif não é verdadeira, então vamos para a condição else e 
imprimimos na tela que "a é maior que b". 
 
Você também pode ter um else sem o elif: 
 
a = 200 
b = 33 
if b > a: 
 print("b é maior que a") 
 
26 
Rua Professor Ângela Pinto, 88, Sala 5 Torre - Recife - PE - CEP 50710-010 - Fone: (81) 9 99046260 
CNPJ. 35.328.913/0001-16 - E-mail: suporte.cursos@admtec.org.br 
else: 
 print("b não é maior que a") #essa opcao sera impressa ao executar o codigo 
 
 
3.3 Operadores complementares 
 
and e or também podem ser usados nas expressões para compor o resultado, além 
disso você pode aninhar estruturas de decisão por exemplo: 
 
x = 41 
if x > 10: 
 print("Acima de dez,") 
 if x > 20: 
 print("e também acima de 20!") 
 else: 
 print("mas não acima de 20.") 
#o codigo checara se x é maior que 10 tendo isso como verdadeiro checara se e 
maior que 20 e como tambem e verdadeiro executara o que a dentro desse if 
ignorando o else interno 
 
4. Estruturas de repetição 
 
Python tem 2 estruturas de repetição base while e for 
 
4.1 While 
 
Com o while podemos executar um conjunto de instruções repetidamente enquanto 
uma condição for verdadeira. 
 
i = 1 
while i < 6: 
 
27 
Rua Professor Ângela Pinto, 88, Sala 5 Torre - Recife - PE - CEP 50710-010 - Fone: (81) 9 99046260 
CNPJ. 35.328.913/0001-16 - E-mail: suporte.cursos@admtec.org.br 
 print(i) 
 i += 1 
#Imprime i enquanto i for menor que 6 
Nota: lembre-se de incrementar o i, senão resultará em um loop infinito. 
 
4.2 Break 
 
A instrução break pode parar o loop mesmo quando a condição while for verdadeira: 
 
i = 1 
while i < 6: 
 print(i)9 
 if i == 3: 
 break 
 i += 1 
#Sai do loop quando i for 3 
 
4.3 Continue 
 
A instrução continue para a iteração atual e continua com a próxima iteração: 
 
i = 0 
while i < 6: 
 i += 1 
 if i == 3: 
 continue 
 print(i) 
#pula para a próxima iteração se i for 3 efetivamente não executando o print quando 
for 3 
 
4.4 For 
 
 
28 
Rua Professor Ângela Pinto, 88, Sala 5 Torre - Recife - PE - CEP 50710-010 - Fone: (81) 9 99046260 
CNPJ. 35.328.913/0001-16 - E-mail: suporte.cursos@admtec.org.br 
O for é usado para iterar sobre uma sequência (que pode ser uma lista, uma tupla, um 
dicionário, um set ou até mesmo uma string). 
 
Com o for podemos executar um conjunto de instruções, uma vez para cada item de 
uma lista, tupla, conjunto etc. 
 
frutas = ["maçã", "banana", "cereja"] 
for x in frutas: 
 print(x) 
#Imprime cada fruta em uma lista de frutas 
 
Quando aplicado a uma string ele iterara em todos os caracteres dessa string. 
 
Break e Continue também são comandos validos no for com a mesma função 
 
4.5 Range() 
 
Para percorrer um bloco de código um determinado número de vezes, podemos usar 
a função range(),ela retorna uma sequência de números, começando em 0 por padrão 
e incrementando em 1 (por padrão também) e termina em um número especificado. 
 
for x in range(6): 
 print(x) 
#Observe que range(6) não retorna os valores de 0 a 6, mas os valores de 0 a 5. 
 
A função range() tem como padrão ter o 0 como valor inicial, porém é possível 
especificar o valor inicial adicionando um parâmetro: range(2, 6), que significa valores 
de 2 a 6 (mas não incluindo 6): 
 
for x in range(2, 6): 
 print(x) 
 
29 
Rua Professor Ângela Pinto, 88, Sala 5 Torre - Recife - PE - CEP 50710-010 - Fone: (81) 9 99046260 
CNPJ. 35.328.913/0001-16 - E-mail: suporte.cursos@admtec.org.br 
#Imprime de 2 a 5 
 
O padrão de incremento da função range() é 1 durante toda a sequência, porém é 
possível especificar o valor do incremento adicionando um terceiro parâmetro: 
range(2, 30, 3): 
 
for x in range(2, 30, 3): 
 print(x) 
#Começa com 2 depois 5 depois 8 e assim por diante até chegar ao último número 
antes de 30 na sequencia 
 
5. Listas 
 
No Python lidamos com conjuntos de variáveis utilizando as listas que são usadas 
para armazenar vários itens em uma única variável e são criadas usando colchetes: 
 
lista = ["maçã", "banana", "cereja"] 
print(lista) 
#A primeira linha cria uma lista com 3 strings representando as frutas, e a segunda 
imprime a lista com todos os elementos separados por , e envolta em colchetes 
 
 Os itens da lista são ordenados, alteráveis e permitem valores duplicados. 
 
 Os itens da lista são indexados, o primeiro item tem índice [0], o segundo item 
tem índice [1] etc. 
 
5.1 Tamanho de uma lista 
 
Para determinar quantos itens uma lista possui, usa-se a função len(): 
 
lista = ["maçã", "banana", "cereja"] 
 
30 
Rua Professor Ângela Pinto, 88, Sala 5 Torre - Recife - PE - CEP 50710-010 - Fone: (81) 9 99046260 
CNPJ. 35.328.913/0001-16 - E-mail: suporte.cursos@admtec.org.br 
print(len(lista)) #Imprime o número de itens da lista 
 
5.2 Acessando itens da lista 
 
Os itens da lista são indexados e você pode acessá-los atravez do número do índice: 
 
lista = ["maçã", "banana", "cereja"] 
print(lista[1]) #Imprime banana o segundo item da lista 
Nota: O primeiro item tem índice 0. 
 
Também pode-se usar Indexação negativa que significa começar do fim e ir de trás 
pra frente -1 refere-se ao último item, -2 refere-se ao penúltimo item etc. 
lista = ["maçã", "banana", "cereja"] 
print(lista[-1]) #imprime cereja afinal é o ultimo item da lista 
 
Pode se extrair uma sublista com a mesma sintaxe das substrings por exemplo: 
Ao especificar um intervalo, o valor de retorno será uma nova lista com os itens 
especificados. 
lista = ["maçã", "banana", "cereja", "laranja", "kiwi", "melão", "manga"] 
print(lista[2:5])#A sublista começará no índice 2 (incluso) e terminará no índice 5 
(não incluído) 
 
5.3 Verificando itens na lista 
 
Para determinar se um item especificado está presente em uma lista, use a palavra-
chave in: 
lista = ["maçã", "banana", "cereja"] 
if "maçã" in lista: 
 print("Sim, 'maçã' está na lista de frutas") 
#verifica se a maçã está na lista e corretamente imprime que ela está 
 
 
31 
Rua Professor Ângela Pinto, 88, Sala 5 Torre - Recife - PE - CEP 50710-010 - Fone: (81) 9 99046260 
CNPJ. 35.328.913/0001-16 - E-mail: suporte.cursos@admtec.org.br 
5.4 Modificando itens na lista 
 
Para alterar o valor de um item específico, utilize o número do índice: 
 
lista = ["maçã", "banana", "cereja"] 
lista[1] = "jabuticaba" 
print(lista) #imprimira a nova lista com jabuticaba no lugar de banana 
 
5.5 Adicionando itens na lista 
 
Para adicionar um item ao final da lista, use o método append(): 
 
lista = ["maçã", "banana", "cereja"] 
lista.append("laranja") 
print(lista) #imprimira a nova lista com a string "laranja" no final como o quarto item 
 
Para inserir um item na lista em um índice especifico, use o método insert(): 
 
lista = ["maçã", "banana", "cereja"] 
lista.insert(1, "laranja") 
print(lista) #imprime a nova lista com laranja inserida entre maçã e banana 
 
5.6 Removendo itens da lista 
 
O método remove() remove o item especificado. 
 
lista = ["maçã", "banana", "cereja"] 
lista.remove("banana") 
print(lista) #imprime a lista sem a banana que foi removida 
 
O método pop() remove o índice especificado. 
 
 
32 
Rua Professor Ângela Pinto,88, Sala 5 Torre - Recife - PE - CEP 50710-010 - Fone: (81) 9 99046260 
CNPJ. 35.328.913/0001-16 - E-mail: suporte.cursos@admtec.org.br 
lista = ["maçã", "banana", "cereja"] 
lista.pop(1) 
print(lista) #remove a banana que é o segundo item 
 
caso não seja especificado o índice pop() removerá o último item da lista 
 
5.6 Comprehension 
 
Assim como demonstrado na parte de laços de repetição, eles podem ser aplicados 
as listas tanto for quanto while quanto range (os números no range representarão os 
índices) 
 
Além dos laços apresentados antes também temos a List Comprehension que oferece 
uma sintaxe mais curta quando você deseja criar uma nova lista com base nos valores 
de uma lista existente. 
 
Por exemplo: 
 
Baseando-se em uma lista de frutas, você deseja criar uma nova lista, contendo 
apenas as frutas com a letra "a" no nome. 
 
Sem o uso de Comprehension, você terá que escrever um for com um teste 
condicional dentro dele: 
 
frutas = ["maçã", "banana", "cereja", "kiwi", "manga"] 
listanova = [] 
for x in frutas: 
 if "a" in x: 
 listanova.append(x) 
print(listanova) 
 
Com Comprehension, você pode fazer tudo isso com apenas uma linha de código: 
 
33 
Rua Professor Ângela Pinto, 88, Sala 5 Torre - Recife - PE - CEP 50710-010 - Fone: (81) 9 99046260 
CNPJ. 35.328.913/0001-16 - E-mail: suporte.cursos@admtec.org.br 
 
frutas = ["maçã", "banana", "cereja", "kiwi", "manga"] 
listanova = [x for x in frutas if "a" in x] 
print(listanova) 
 
Sintaxe: listanova = [expressão for item in iteravel if condicional == True] 
 
A condição é como um filtro que só aceita valores que dão True após serem avaliados 
o iterável pode ser qualquer conjunta, lista ou até mesmo range dentro da lista, a 
expressão é o(s) item(ns) do iterável a ser(em) avaliado(s) pelo condicional 
 
Além dos métodos apresentados outros métodos específicos relacionados a 
listas e estruturas de dados podem ser encontrados em: 
https://docs.python.org/3/tutorial/datastructures.html 
 
6. Funções e Expressões Lambda 
 
Uma função é um bloco de código que só é executado quando é chamado. 
 
Você pode repassar passar dados, também conhecidos como parâmetros, para uma 
função. 
 
Uma função pode retornar dados como resultado da execução dela 
 
6.1 Criando funções 
 
Em Python, uma função é definida usando a palavra-chave def: 
 
def minha_função(): 
 print("Olá eu sou uma função") 
 
 
34 
Rua Professor Ângela Pinto, 88, Sala 5 Torre - Recife - PE - CEP 50710-010 - Fone: (81) 9 99046260 
CNPJ. 35.328.913/0001-16 - E-mail: suporte.cursos@admtec.org.br 
Qualquer coisa que você escreveria em um código pode ser colocada dentro do bloco 
definido por uma função, é muito util para poder reutilizar códigos que serão usados 
repetidamente na execução da aplicação 
 
6.2 Chamando funções 
 
Para chamar uma função, use o nome da função seguido de parênteses: 
 
def minha_função(): 
 print("Olá eu sou uma função") 
minha_função()#esta linha executara o bloco de código definido imprimindo "Olá eu 
sou uma função" na tela 
 
6.3 Argumentos 
 
Informações/dados podem ser passados para funções como argumentos/parâmetros. 
 
Os argumentos são especificados após o nome da função, dentro dos parênteses. 
Você pode adicionar quantos argumentos quiser, basta separá-los com uma vírgula 
para cada novo argumento além do primeiro. 
 
def minha_função(nome): 
 print(nome + " Lacerda") 
minha_função("Joao") #imprime "Joao Lacerda" 
minha_função("Tiago")#imprime "Tiago Lacerda" 
minha_função("Linus")#imprime "Linus Lacerda" 
 
O exemplo acima tem uma função com um argumento (nome). Quando a função é 
chamada, passamos um primeiro nome, que é usado dentro da função para imprimir 
o nome completo 
 
6.3.b Numero de argumentos 
 
 
35 
Rua Professor Ângela Pinto, 88, Sala 5 Torre - Recife - PE - CEP 50710-010 - Fone: (81) 9 99046260 
CNPJ. 35.328.913/0001-16 - E-mail: suporte.cursos@admtec.org.br 
Por padrão, uma função deve ser chamada com o número correto de argumentos. 
Isso significa que, se sua função foi definida com e espera 2 argumentos, você deve 
chamar a função com 2 argumentos, nem mais, nem menos. 
 
def minha_função(primeironome, ultimonome): 
 print(primeironome + " " + ultimonome) 
minha_função("Linus", "Torvalds") #imprime o nome "Linus Torvalds" 
 
Esta função espera 2 argumentos caso você repasse 1 ou 3 ou qualquer coisa 
diferente de 2 argumentos a função retornará um erro 
 
Para todos os efeitos os parâmetros aceitam qualquer tipo de dado sejam 
strings literais, números ou até mesmo listas, etc. 
 
6.4 Retorno 
 
Para opcionalmente permitir que uma função retorne um valor, use a palavra chave 
return: 
 
def minha_função(x):1 
 return 5 * x 
print(minha_função(3)) #imprimira o retorno da função que é 5*3 que é 15 
print(minha_função(5)) #imprimira o retorno de função que é 5*5 que é 25 
print(minha_função(9)) #imprimira o retorno de função que é 5*9 que é 45 
 
6.5 Recursão 
 
Python também aceita recursão em suas funções, o que significa que uma função 
definida pode chamar a si mesma. 
 
 
36 
Rua Professor Ângela Pinto, 88, Sala 5 Torre - Recife - PE - CEP 50710-010 - Fone: (81) 9 99046260 
CNPJ. 35.328.913/0001-16 - E-mail: suporte.cursos@admtec.org.br 
A recursão é um conceito matemático aplicado a programação frequentemente. Isso 
significa que uma função chama a si mesma. Isso traz a vantagem de você pode 
percorrer os dados para chegar a um resultado. 
 
O desenvolvedor deve ter muito cuidado com a recursão, pois pode ser muito fácil 
escrever uma função que nunca termina, ou uma que usa quantidades excessivas de 
memória ou poder do processador. No entanto, quando escrita corretamente, a 
recursão pode ser uma abordagem de programação muito eficiente e 
matematicamente elegante. 
 
Neste exemplo, recursao_trigonometrica() é uma função que definimos para chamar 
a si mesma ("recursar"). Usamos a variável k como os dados, que decrementam (-1) 
toda vez que recursamos. A recursão termina quando a condição de maior que 0 da 
False (ou seja, quando é 0). 
 
Para um novo desenvolvedor, pode levar algum tempo para descobrir exatamente 
como isso funciona, a melhor maneira de descobrir é testando e modificando. 
 
def recursao_trigonometrica(k): 
 if(k > 0): 
 resultado = k + recursao_trigonometrica(k - 1) 
 print(resultado) 
 else: 
 resultado = 0 
 return resultado 
print("\n\nResultados da recursão") 
recursao_trigonometrica(6) #imprimira a sequência 1,3,6,10,15,21 separados por 
linha 
 
6.6 Funções Lambda 
 
Uma função lambda é uma pequena função anônima. 
 
 
37 
Rua Professor Ângela Pinto, 88, Sala 5 Torre - Recife - PE - CEP 50710-010 - Fone: (81) 9 99046260 
CNPJ. 35.328.913/0001-16 - E-mail: suporte.cursos@admtec.org.br 
Uma função lambda pode receber qualquer número de argumentos, mas pode ter 
apenas uma expressão. 
 
6.6.a Sintaxe 
 
lambda argumentos: expressão 
A expressão é executada e o resultado é retornado: 
x = lambda a: a + 10 
print(x(5)) #imprime 15 que é o resultado da expressão que é soma do argumento 
a que tem valor 5 com 10 
As funções lambda podem receber qualquer número de argumentos: 
 
Exemplo 
Multiplique o argumento a pelo argumento b e retorne o resultado: 
 
x = lambda a, b: a * b 
print(x(5, 6)) #imprime 30 que é o resultado da expressão que multiplica os 
argumentos a(5) por b(6) 
 
x = lambda a, b, c : a + b + c 
print(x(5, 6, 2)) #como esperado imprime 13 que é a soma dos 3 args 
 
6.6b Por que usar funções lambda? 
 
Assim como a recursão é um dos melhores aliados de um programador eficiente o 
poder do lambda é melhor demonstrado quando você os usa como uma função 
anônima dentro de outra função. 
 
Digamos que você tenha uma definição de função que recebe um argumento e esse 
argumento será multiplicado por um número desconhecido: 
def minhafunc(n):38 
Rua Professor Ângela Pinto, 88, Sala 5 Torre - Recife - PE - CEP 50710-010 - Fone: (81) 9 99046260 
CNPJ. 35.328.913/0001-16 - E-mail: suporte.cursos@admtec.org.br 
 return lambda a : a * n 
 
Use essa definição de função para fazer uma função que sempre duplique o número 
que você enviar: 
def minhafunc(n): 
 return lambda a : a * n 
meuduplicador = minhafunc(2) 
print(meuduplicador(11)) #imprime o resultado de meuduplicador que é uma função 
lambda que recebe um argumento e multiplica por 2 resultando em 22 já que o 
argumento repassado é 11 
 
Ou use a mesma definição da função para fazer uma função que sempre triplique o 
número que você envia: 
 
def minhafunc(n): 
 return lambda a : a * n 
meutriplicador = minhafunc(3) 
print(meutriplicador(11)) #imprime 33 
 
Ou use a mesma definição de função para fazer as duas funções, no mesmo 
programa: 
 
def minhafunc(n): 
 return lambda a : a * n 
meuduplicador = minhafunc(2) 
meutriplicador = minhafunc(3) 
print(meuduplicador(11)) #imprime 22 
print(meutriplicador(11)) #imprime 33 
 
7. Debug e tratamento de erros 
 
 
39 
Rua Professor Ângela Pinto, 88, Sala 5 Torre - Recife - PE - CEP 50710-010 - Fone: (81) 9 99046260 
CNPJ. 35.328.913/0001-16 - E-mail: suporte.cursos@admtec.org.br 
No processo de desenvolvimento erros(bugs) podem ocorrer, alguns erros são mais 
nítidos ao executar, podendo quebrar seu código completamente, as vezes o próprio 
ambiente de desenvolvimento gera um alerta sobre um possível erro, porém alguns 
erros podem ser silenciosos seu código até executa e em algum momento algo no 
meio do código leva a um resultado que não é o esperado, quando isso acontece o 
programador deve buscar estes erros mais a fundo, e por assim dizer colocar uma 
lupa sob seu código. 
 
Existem vários métodos de fazer o que chamamos de Debug. 
Um dos métodos mais antigos é colocar imprimir as variáveis a cada passo que o 
código dá populando todo o seu código com vários prints, assim podendo acompanhar 
o progresso e a variação delas ao longo da execução do código, é um método que 
apesar de primitivo é eficiente a depender do problema. 
 
Um método mais refinado porém que podemos usar é a própria ferramenta de Debug 
comum a ambientes integrados de desenvolvimento(IDEs), para começar escolhe-se 
um ponto de início para o debug que chamamos de breakpoint clicando ao lado da 
linha de código que deseja começar assim será inserido uma bolinha(a cor pode variar 
a depender do IDE e menos frequentemente o formato) 
 
 
 após isso deve-se clickar no botão de debug que normalmente se assemelha a um 
inseto na parte superior da tela que iniciará o modo de debug: 
 
 
 
ao abrir o modo de debug além do console que apresenta a saída e recebe a entrada 
do seu código temos também uma aba para acompanhar o estado das variáveis 
 
 
40 
Rua Professor Ângela Pinto, 88, Sala 5 Torre - Recife - PE - CEP 50710-010 - Fone: (81) 9 99046260 
CNPJ. 35.328.913/0001-16 - E-mail: suporte.cursos@admtec.org.br 
 
 
ao contrário de uma execução normal aqui você deve manualmente executar linha por 
linha, o console se comportara do mesmo jeito que antes, você poderá escrever algo 
quando for pedido, porém uma das abas acompanhará em tempo real as variáveis e 
seus valores como pode ser visto a esquerda da imagem incluindo dados mais 
complexos como listas que podem ser destrinchados em seus vários elementos por 
fim temos vários botões de setas que podem ser utilizados na parte superior dos mais 
importantes o Step Over e o Step Into enquanto o primeiro avança sobre o código de 
forma mais rápida ignorando alguns processos “internos” o Step Into procura de forma 
bem detalhada cada parte do processo inclusive códigos internos da própria 
linguagem caso você esteja usando, com esta ferramenta poderosa você estará muito 
bem preparado para caçar os bugs em seu código. 
 
8. Módulos em Python 
 
Um módulo é por assim dizer o mesmo que uma biblioteca de código, um arquivo 
contendo um conjunto de funções que você deseja incluir em seu aplicativo. 
 
Você pode nomear o arquivo do módulo como quiser, mas deve ter a extensão de 
arquivo .py sempre 
 
8.1 Criando um modulo 
 
Para criar um módulo basta salvar o código desejado em um arquivo com a extensão 
de arquivo .py,por exemplo: 
 
 
41 
Rua Professor Ângela Pinto, 88, Sala 5 Torre - Recife - PE - CEP 50710-010 - Fone: (81) 9 99046260 
CNPJ. 35.328.913/0001-16 - E-mail: suporte.cursos@admtec.org.br 
def saudacao(nome): 
 print("Olá, " + nome) 
 
Salve este código em um arquivo chamado meumodulo.py 
 
8.2 Utilizando um modulo 
 
Agora podemos usar o módulo que acabamos de criar, usando a palavra-chave 
import: 
 
Importe o módulo chamado meumodulo e chame a função de saudação: 
import meumodulo 
meumodulo.saudacao("Joao")#chamara o modulo importado e executara a função 
saudacao salva nele 
Nota: Ao usar uma função de um módulo, use a sintaxe: modulo_nome.funcao_nome. 
 
caso o modulo tenha múltiplas funções/variáveis e você apenas queira importar algo 
especifico pode usar a sintaxe: from modulo_nome import func/var_nome 
ao fazer isso quando for usar o elemento especifico se refira diretamente ao nome 
dele sem usar a sintaxe modulo_nome.funcao_nome, apenas funcao_nome 
 
8.3 Variáveis em um modulo 
 
Além do módulo poder conter funções, também pode conter variáveis de todos os 
tipos (arrays, dicionários, objetos etc): 
 
idade = 36 
Salve este código no arquivo memodulo.py 
 
Importe o módulo chamado meumodulo e acesse a variável idade: 
 
 
42 
Rua Professor Ângela Pinto, 88, Sala 5 Torre - Recife - PE - CEP 50710-010 - Fone: (81) 9 99046260 
CNPJ. 35.328.913/0001-16 - E-mail: suporte.cursos@admtec.org.br 
import meumodulo 
a = meumodulo.idade 
print(a) 
 
8.4 Renomeando Módulos 
 
Você pode criar um alias ao importar um módulo, usando a palavra-chave as: 
 
import meumodulo as mx #cria um alias/nome alternativo para o modulo chamado 
mx 
a = mx.idade 
print(a) 
 
8.5 Módulos Nativos 
 
Existem vários módulos nativos integrados ao Python, que você pode importar sempre 
que quiser. 
 
Exemplo 
Importe e use o módulo da plataforma: 
 
import platform #modulo nativo que prove informações sobre o seu sistema 
x = plataform.system() #system é uma função do modulo platform que retorna o 
nome do seu sistema operacional 
print(x) 
 
9. Leitura e Escrita 
 
9.1 Input do usuário 
 
Além do output através do print() Python permite receber a entrada do usuário 
também. 
 
43 
Rua Professor Ângela Pinto, 88, Sala 5 Torre - Recife - PE - CEP 50710-010 - Fone: (81) 9 99046260 
CNPJ. 35.328.913/0001-16 - E-mail: suporte.cursos@admtec.org.br 
Solicitando a ele através do comando input() que pode tanto estar vazio entre os 
parênteses quanto com algum texto para informar ao usuário o que está sendo pedido 
 
O exemplo a seguir solicita o nome de usuário e, quando você digita o nome, ele é 
impresso na tela: 
 
usuario = input("Digite o usuario:") 
print("Usuário é: " + usuario) 
Nota: O Python para de executar quando inicia a função input() e continua quando o 
usuário fornece alguma entrada. 
 
9.2 Utilizando arquivos 
 
A manipulação de arquivos é uma parte importante de muitas aplicações. Python tem 
várias funções para criar, ler, atualizar e deletar arquivos. A função principal para 
trabalhar com arquivos se chama open(). Ela recebe dois parâmetros: nome do 
arquivo e modo. 
 
Existem quatro métodos (modos) diferentes para abrir um arquivo: 
 
"r" - Read - Valor padrão. Abre um arquivo para leitura, gera erro se o arquivo não 
existir 
 
"a" - Append - Abre um arquivo para anexação, cria o arquivo se não existir 
 
"w" - Write - Abre um arquivo para escrita, cria o arquivo caso não exista"x" - Create - Cria o arquivo especificado, retorna um erro se o arquivo existir 
 
Além disso você pode especificar se o arquivo deve ser tratado como modo binário ou 
texto 
 
"t" - Text - Valor padrão. Modo de texto 
 
44 
Rua Professor Ângela Pinto, 88, Sala 5 Torre - Recife - PE - CEP 50710-010 - Fone: (81) 9 99046260 
CNPJ. 35.328.913/0001-16 - E-mail: suporte.cursos@admtec.org.br 
 
"b" - Binary - Modo binário (por exemplo, imagens) 
 
Sintaxe 
 
Para abrir um arquivo em modo leitura, basta especificar o nome do arquivo: 
 
f = open("demofile.txt") 
 
O código acima é o mesmo que: 
 
f = open("demofile.txt", "rt") 
 
Como "r" para leitura e "t" para texto são os valores padrão, você não precisa 
especificá-los. 
 
Nota: Certifique-se de que o arquivo existe, caso contrário você receberá um erro. 
 
9.3 Lendo arquivos 
 
Suponha que temos o seguinte arquivo, localizado na mesma pasta do Python: 
 
demofile.txt 
Olá! Bem-vindo ao demofile.txt 
Este arquivo é para fins de teste. 
Boa sorte! 
 
Recapitulando para abrir o arquivo, use a função open() que irá retornar um objeto de 
arquivo, que possui um método read() para ler o conteúdo do arquivo: 
 
f = open("demofile.txt", "r") 
print(f.read()) 
 
45 
Rua Professor Ângela Pinto, 88, Sala 5 Torre - Recife - PE - CEP 50710-010 - Fone: (81) 9 99046260 
CNPJ. 35.328.913/0001-16 - E-mail: suporte.cursos@admtec.org.br 
 
Se o arquivo estiver localizado em um diretório diferente, você terá que especificar o 
caminho do arquivo, assim: 
 
f = open("D:\\myfiles\demofile.txt", "r") #caso ele esteja na pasta myfiles da partição 
D 
print(f.read()) 
 
 
 
Ler partes do arquivo 
 
Por padrão, o método read() retorna o texto inteiro, mas você também pode especificar 
quantos caracteres deseja retornar: 
 
f = open("demofile.txt", "r") 
print(f.read(5)) #Retorna os 5 primeiros caracteres do arquivo 
 
Ler linha por linha 
 
Você pode retornar uma linha usando o método readline(): 
 
f = open("demofile.txt", "r") 
print(f.readline()) #Le uma linha do arquivo 
 
Ao chamar readline() duas vezes, você pode ler as duas primeiras linhas: 
 
f = open("demofile.txt", "r") 
print(f.readline())#Le a primeira linha do arquivo 
print(f.readline())#Le a linha seguinte no caso a segunda 
 
 
46 
Rua Professor Ângela Pinto, 88, Sala 5 Torre - Recife - PE - CEP 50710-010 - Fone: (81) 9 99046260 
CNPJ. 35.328.913/0001-16 - E-mail: suporte.cursos@admtec.org.br 
Também é possível fazer um loop pelas linhas do arquivo, para assim poder ler o 
arquivo inteiro, linha por linha: 
 
Exemplo 
Percorra o arquivo linha por linha: 
 
f = open("demofile.txt", "r") 
for x in f: 
 print(x) #cada x é uma linha do arquivo 
 
É uma boa prática sempre fechar o arquivo quando terminar de utilizar ele com a 
função close(): 
 
f = open("demofile.txt", "r") 
print(f.readline()) 
f.close() 
Nota: Você deve sempre fechar seus arquivos, em alguns casos, devido a 
bufferização do arquivo, as alterações feitas em um arquivo podem não aparecer até 
que você feche o arquivo. 
 
9.4 Escrevendo em arquivos 
 
Para escrever em um arquivo existente, você deve adicionar um parâmetro à função 
open(): 
 
"a" - Append - anexará o que for escrito ao final do arquivo 
 
"w" - Write - substituirá qualquer conteúdo existente 
 
 
Digamos que você quer abrir o arquivo "demofile.txt" e anexar novo conteúdo ao 
arquivo: 
 
47 
Rua Professor Ângela Pinto, 88, Sala 5 Torre - Recife - PE - CEP 50710-010 - Fone: (81) 9 99046260 
CNPJ. 35.328.913/0001-16 - E-mail: suporte.cursos@admtec.org.br 
 
f = open("demofile.txt", "a") 
f.write("Agora o arquivo tem mais conteúdo!") #escrevera no final do arq 
f.close() 
#abra e leia o arquivo após o anexo: 
f = open("demofile.txt", "r") 
print(f.read()) 
 
Agora caso você queira abrir o arquivo "demofile3.txt" e sobrescrever sobre o 
conteúdo existente: 
 
f = open("demofile.txt", "w") 
f.write("Uau! Eu deletei o conteúdo!") 
f.close() 
#abra e leia o arquivo após o anexo: 
f = open("demofile.txt", "r") 
print(f.read()) 
Nota: o método "w" substituirá o conteúdo do arquivo por inteiro. 
 
Criando um novo arquivo do zero 
 
Para criar um novo arquivo, use o método open(), com um dos seguintes parâmetros: 
 
"x" - Create - criará um arquivo, retornará um erro se o arquivo existir 
 
"a" - Append - criará um arquivo se o arquivo especificado não existir 
 
"w" - Write - criará um arquivo se o arquivo especificado não existir 
 
f = open("meuarquivo.txt", "x") #Cria um arquivo chamado "meuarquivo.txt" 
Resultado: um novo arquivo vazio é criado! 
 
 
48 
Rua Professor Ângela Pinto, 88, Sala 5 Torre - Recife - PE - CEP 50710-010 - Fone: (81) 9 99046260 
CNPJ. 35.328.913/0001-16 - E-mail: suporte.cursos@admtec.org.br 
f = open("meuarquivo.txt", "w")#Cria um novo arquivo apenas se ele não existir 
 
10. Paradigma Orientação a Objeto 
 
Python é uma linguagem de programação orientada a objetos. Quase tudo em Python 
é um objeto, com seus atributos (variáveis da classe) e métodos (funções da classe). 
 
Uma classe é como um construtor desses objetos, ou um projeto/blueprint para criar 
objetos a partir dela. 
 
10.1 Criando uma classe 
 
Para criar uma classe, usa a palavra-chave class: 
 
class MinhaClasse: 
 x = 5 
#Cria uma classe chamada MinhaClasse, com um atributo chamado x 
 
10.2 Criando um objeto 
 
Agora podemos usar a classe chamada MinhaClasse para criar objetos: 
 
p1 = MinhaClasse() #Ao chamar o nome da classe seguido de parênteses você 
estará chamando o método construtor interno da classe que criara um objeto a partir 
dos moldes dela 
print(p1.x) 
#Cria um objeto chamado p1 baseado na classe MinhaClasse e imprima o valor de 
x 
Nota: Similar ao comportamento dos módulos 
 
10.3 A função construtora: __init__() 
 
 
49 
Rua Professor Ângela Pinto, 88, Sala 5 Torre - Recife - PE - CEP 50710-010 - Fone: (81) 9 99046260 
CNPJ. 35.328.913/0001-16 - E-mail: suporte.cursos@admtec.org.br 
Os exemplos acima são classes e objetos em sua forma mais simples e não são 
realmente úteis em aplicações da vida real. Para entender o significado das classes, 
temos que entender a função __init__(). Todas as classes possuem uma função 
chamada __init__(), que sempre é executada quando a classe está sendo 
inicializada/instanciada. Use a função __init__() para atribuir valores às propriedades 
do objeto ou outras operações que são necessárias quando o objeto está sendo 
criado: 
 
 
 
Exemplo 
Crie uma classe chamada Person, use a função __init__() para atribuir valores para 
nome e idade: 
 
class Pessoa: 
 #self refere-se ao objeto hipotetico que será criado pela classe 
 def __init__(self, nome, idade): 
 self.nome = nome 
 self.idade = idade 
p1 = Pessoa("João", 36) 
print(p1.nome) 
print(p1.idade) 
Nota: A função __init__() é chamada automaticamente toda vez que a classe está 
sendo usada para criar um novo objeto. 
 
10.4 Métodos do objeto 
 
Objetos também podem conter métodos. Métodos são funções que pertencem ao 
objeto. 
 
Vamos criar um método na classe Pessoa para imprimir uma saudação e execute-a 
no objeto p1: 
 
 
50 
Rua Professor Ângela Pinto, 88, Sala 5 Torre - Recife - PE - CEP 50710-010 - Fone: (81) 9 99046260 
CNPJ. 35.328.913/0001-16 - E-mail: suporte.cursos@admtec.org.br 
class Pessoa: 
 def __init__(self, nome, idade): 
 self.nome = nome 
 self.idade = idade 
 def minhafunc(self): 
 print("Olá meu nome é " + self.nome) 
p1 = Pessoa("João", 36) 
p1.minhafunc() 
Nota: O parâmetro self é uma referência à instância atual da classe e é usado para 
acessar variáveis que pertencem à classe. 
10.5 Modificando atributos de um objeto 
 
Você pode modificar atributos em objetos como este: 
 
p1.idade = 40 #Define a idade de p1 para 40 
 
11. Herança 
 
A herança nos permite definir uma classe queherda todos os métodos e propriedades 
de outra classe. 
 
A classe mãe é a classe que está sendo herdada, também chamada de classe base 
ou superclasse. 
 
A classe filha é a classe que herda de outra classe, também chamada de classe 
derivada. 
 
11.1 Criando uma classe base 
 
Qualquer classe pode ser uma classe mãe, então a sintaxe é a mesma da criação de 
qualquer outra classe: 
 
Por exemplo crie uma classe chamada Pessoa, com as propriedades primeironome e 
ultimonome e um método printnome: 
 
51 
Rua Professor Ângela Pinto, 88, Sala 5 Torre - Recife - PE - CEP 50710-010 - Fone: (81) 9 99046260 
CNPJ. 35.328.913/0001-16 - E-mail: suporte.cursos@admtec.org.br 
 
class Pessoa: 
 def __init__(self, pnome, unome): 
 self.primeironome = pnome 
 self.ultimonome = unome 
 def printnome(self): 
 print(self.primeironome, self.ultimonome) 
#Use a classe Pessoa para criar um objeto e execute o método printnome: 
x = Pessoa("João", "Lacerda") 
x.printnome() 
 
11.2 Criando uma classe derivada 
 
Para criar uma classe que herda a funcionalidade de outra classe, coloque a classe 
pai como parâmetro ao criar a classe filha: 
 
Para Criar uma classe chamada Aluno, que herdará as propriedades e métodos da 
classe Pessoa: 
 
class Aluno(Pessoa): 
 pass 
Nota: use a palavra-chave pass quando não quiser adicionar outros atributos ou 
métodos à classe. 
 
Agora a classe Aluno tem as mesmas propriedades e métodos que a classe Pessoa. 
 
Por exemplo ao usar a classe aluno para criar um objeto e executa o método 
printnome a sintaxe é: 
 
x = Aluno("Henrique", "Pedrozo") #Por padrão o construtor da classe derivada 
recebe os mesmos parâmetros da classe base 
x.printnome() #E naturalmente como herda tudo pode usar os métodos 
 
52 
Rua Professor Ângela Pinto, 88, Sala 5 Torre - Recife - PE - CEP 50710-010 - Fone: (81) 9 99046260 
CNPJ. 35.328.913/0001-16 - E-mail: suporte.cursos@admtec.org.br 
 
11.3 Criando um construtor próprio 
 
Até agora criamos uma classe filha que herda as propriedades e métodos da sua mãe. 
 
Queremos adicionar uma função construtora __init__() à classe filha (em vez da 
palavra-chave pass). 
 
Nota: A função __init__() é chamada automaticamente toda vez que a classe está 
sendo usada para criar um novo objeto. 
 
Adicione a função __init__() à classe Aluno: 
 
class Aluno(Pessoa): 
 def __init__(self, pnome, unome): 
 #adicionar modificadores de atributos aqui etc. 
Quando você adiciona a função __init__(), a classe filha não herdará mais a função 
__init__() da mãe. 
 
Nota: A função __init__() da filha substitui a função __init__() herdada da mãei. 
 
Para manter a herança da função __init__() da mãe, adicione uma chamada para a 
função __init__() da mãe: 
 
class Aluno(Pessoa): 
 def __init__(self, pnome, unome): 
 Pessoa.__init__(self, pnome, unome) 
Agora adicionamos com sucesso a função __init__() e mantivemos a herança da 
classe mãe, e estamos prontos para adicionar funcionalidade na função __init__(). 
 
11.4 Utilizando a função super() 
 
 
53 
Rua Professor Ângela Pinto, 88, Sala 5 Torre - Recife - PE - CEP 50710-010 - Fone: (81) 9 99046260 
CNPJ. 35.328.913/0001-16 - E-mail: suporte.cursos@admtec.org.br 
Python também tem uma função chamada super() que fará com que a classe filha 
herde todos os métodos e atributos da sua mãe: 
 
class Aluno(Pessoa): 
 def __init__(self, pnome, unome): 
 super().__init__(pnome, unome) 
 
Ao usar a função super(), você não precisa usar o nome da classe base, a classe 
derivada herdará automaticamente os métodos e propriedades da sua mãe. 
 
11.5 Adicionando atributos 
 
Adicione um atributo chamado anodegraduacao à classe Aluno: 
class Aluno(Pessoa): 
 def __init__(self, pnome, unome): 
 super().__init__(pnome, unome) 
 self.anodegraduacao = 2022 
 
No exemplo abaixo, o ano de 2022 deve ser uma variável e passado para a classe 
Aluno ao criar objetos Aluno. Para isso, adicione outro parâmetro na função __init__(): 
 
Adicione um parâmetro de ano e passe o ano correto ao criar objetos: 
class Aluno(Pessoa): 
 def __init__(self, pnome, unome, ano): 
 super().__init__(pnome, unome) 
 self.anodegraduacao = ano 
x = Aluno("Gabriele", "Silva", 2022) 
 
11.6 Adicionando métodos 
 
Como adicionar um método chamado boasvindas à classe Aluno: 
 
 
54 
Rua Professor Ângela Pinto, 88, Sala 5 Torre - Recife - PE - CEP 50710-010 - Fone: (81) 9 99046260 
CNPJ. 35.328.913/0001-16 - E-mail: suporte.cursos@admtec.org.br 
class Aluno(Pessoa): 
 def __init__(self, pnome, unome, ano): 
 super().__init__(pnome, unome) 
 self.anodegraduacao = ano 
 def boasvindas(self): 
 print("Bem-vindo", self.primeironome, self.ultimonome, "à turma de", 
self.anodegraduacao) 
 
Se você adicionar um método na classe filha com o mesmo nome de uma função na 
classe mãe, a herança do método mãe será substituído. 
 
12. Polimorfismo 
 
A palavra polimorfismo significa ter muitas formas. Na programação, polimorfismo 
significa o mesmo nome sendo usado em diferentes funções (mas assinaturas 
diferentes). 
 
Exemplo de funções polimórficas: 
 
# Programa Python para demonstrar funções polimórficas 
# len() sendo usado para uma string 
print(len("Talentos")) 
# len() sendo usado para uma lista 
print(len([10, 20, 30])) 
 
Exemplo de funções polimórficas definidas pelo usuário: 
 
# Uma função simples do Python para demonstrar Polimorfismo 
def adicao(x, y, z = 0): 
 return x + y + z 
#Uma mesma função pode assumir formas diferentes também 
 
55 
Rua Professor Ângela Pinto, 88, Sala 5 Torre - Recife - PE - CEP 50710-010 - Fone: (81) 9 99046260 
CNPJ. 35.328.913/0001-16 - E-mail: suporte.cursos@admtec.org.br 
print(adicao(2, 3)) 
print(adicao(2, 3, 4)) 
 
Polimorfismo com métodos de classe 
 
O código abaixo mostra como o Python pode usar duas classes diferentes, da mesma 
maneira. Criamos um loop for que itera através de uma tupla de objetos. Em seguida, 
chamamos os métodos sem nos preocuparmos com a classe de cada objeto. 
Assumimos que esses métodos realmente existem em cada classe. 
 
class Brasil(): 
 def capital(self): 
 print("Brasilia é a capital do Brasil.") 
 def linguagem(self): 
 print("Português é a língua mais falada do Brasil.") 
 def type(self): 
 print("O Brasil é um país em desenvolvimento.") 
class EUA(): 
 def capital(self): 
 print("Washington, D.C. é a capital dos EUA.") 
 def linguagem(self): 
 print("Inglês é o idioma principal dos EUA.") 
 def type(self): 
 print("EUA é um país desenvolvido.") 
obj_brasil = Brasil() 
obj_eua = EUA() 
for pais in (obj_brasil, obj_eua): 
 pais.capital() 
 pais.linguagem() 
 pais.tipo() 
 
 
56 
Rua Professor Ângela Pinto, 88, Sala 5 Torre - Recife - PE - CEP 50710-010 - Fone: (81) 9 99046260 
CNPJ. 35.328.913/0001-16 - E-mail: suporte.cursos@admtec.org.br 
Polimorfismo com herança 
 
Em Python, o polimorfismo nos permite definir métodos na classe filha que têm o 
mesmo nome dos métodos na classe mãe. Na herança, a classe filha herda os 
métodos da classe mãe. No entanto, é possível modificar um método em uma classe 
filha herdado da classe mãe. Isso é particularmente útil nos casos em que o método 
herdado da classe mãe não se encaixa perfeitamente na classe filha. Nesses casos, 
reimplementamos o método na classe filha. Esse processo de reimplementação de 
um método na classe filha é conhecido como Redefinição de Método. 
class Passaro: 
 def intro(self): 
 print("Existem muitos tipos de pássaros.") 
 
 def voo(self): 
 print("A maioria dos pássaros pode voar, mas alguns não.") 
 
class pardal(Passaro): 
 def voo(self): 
 print("Os pardais podem voar.") 
 
class avestruz (Passaro): 
 def voo(self): 
 print("Avestruzes não