Linguagem Python aplicada a

Engenharia de Dados
Bárbara Silveira Fraga
2022
SUMÁRIO
Capítulo 1. Introdução ao Python .......................................................................... 5

1.1. PEP ........................................................................................................................... 6

1.2. Qual versão utilizar? ................................................................................................. 7

1.3. Como instalar? .......................................................................................................... 7

1.4. Ambiente Virtual ...................................................................................................... 8

1.5. Como executar o Python? ......................................................................................... 8

1.6. Qual ferramenta de desenvolvimento utilizar? ......................................................... 9

Capítulo 2. Variáveis, Tipos e Estruturas de Dados ............................................ 12

2.1. O básico da Linguagem Python ............................................................................... 12

2.2. Variáveis.................................................................................................................. 13

2.3. Operadores............................................................................................................... 15

2.4. Manipulando Strings ............................................................................................... 17

2.5. Estruturas de Dados ................................................................................................. 19

Capítulo 3. Estruturas de Lógica .......................................................................... 27

3.1. Condicionais ............................................................................................................ 27

3.2. Estruturas de repetição (Loops) ............................................................................... 29

Capítulo 4. Estruturas de Python.......................................................................... 35

4.1. Funções ................................................................................................................... 35

4.2. Utilidades da Linguagem ........................................................................................ 40

4.3. Tratamento de Erros ............................................................................................... 51

Capítulo 5. Orientação Objeto ............................................................................. 57

5.1. Classe e objetos ....................................................................................................... 59

5.2. Método .................................................................................................................... 60

5.3. Atributo ................................................................................................................... 61

5.4. Herança.................................................................................................................... 62

Capítulo 6. Principais Bibliotecas ........................................................................ 69

2
 6.1. Numpy ..................................................................................................................... 69

6.2. Pandas...................................................................................................................... 72

Glossário .................................................................................................................. 76

Referência ................................................................................................................ 80

3
1
Capítulo 1. Introdução ao Python
O objetivo deste módulo é capacitar e auxiliar profissionais com programação
em Python, apresentando as principais estruturas de dados e de lógica. O Python é
utilizado por grandes empresas, como Google, Instagram, Spotify, Netflix, Uber,
Dropbox, Pinterest, entre outras [1] e é uma das principais linguagens de programação
para o trabalho com dados.

Python é uma linguagem de programação orientada a objetos e interpretada.

Uma linguagem ser interpretada significa que existe um sistema (interpretador)
responsável por fazer a “tradução em tempo real” do código Python para código de
máquina (processador ou sistema operacional) [2]. O código interpretado é executado
instrução por instrução.

Algumas características do Python, segundo a documentação oficial [3], são:

 Possui uma sintaxe simples, tornando os programas que você escreve fáceis de
ler.

 Possui várias bibliotecas que suportam muitas tarefas comuns de programação,

como conectar-se a servidores da Web, pesquisar texto com expressões
regulares, ler e modificar arquivos.

 O modo interativo do Python facilita o teste de pequenos trechos de código e

existem diversos ambiente de desenvolvimento (IDE).

 Funciona em qualquer lugar, incluindo Mac OS X, Windows, Linux e Unix,

com versões não oficiais também disponíveis para Android e iOS.

Todos as versões de Python são de código aberto:

– Veja: http://www.opensource.org.

5
 Para escrever um código Pythonic (ou seja, um código que se refere às boas
práticas de Python) você deve se acostumar com as regras de estilo de código (PEP).
Abaixo iremos descrever o que são as PEPs.

1.1.PEP
O Python possui PEP’s (Python Enhancement Proposals) ou Propostas para
Melhoramento no Python. PEP é um documento que fornece informações para a
comunidade ou descreve um novo recurso para ou seus processos ou ambiente [4].
Qualquer um pode escrever uma PEP e a comunidade Python testa, avalia e decide se
deve ou não publicá-la.

Existem três tipos de PEPs:

 Standards Track: descreve um novo recurso ou implementação para Python.

 Informativo: descreve um problema de design, diretrizes gerais ou informação

à comunidade, não propõe um novo recurso.

 Processo: descreve um processo ou propõe uma mudança para um processo.

Existem algumas PEPs que são leituras obrigatórias:

 PEP 8: o Guia de Estilo do Python.

– Fornece convenções de codificação para o código Python que

compreende a biblioteca padrão.

 PEP 20: o Zen do Python.

– Uma lista de 19 frases que explicam brevemente a filosofia por trás

do Python.

 PEP 257: Convenções de Docstring.

– Documentar a semântica e as convenções associadas às docstrings.

Docstring é um texto que documenta um módulo, função, classe ou
definição de método.

6
 Existem algumas ferramentas que verificam a qualidade do seu seu código,
como o Pythonchecker.

1.2.Qual versão utilizar?

Existem o Python 2 e Python 3. Qual devemos utilizar? Para responder essa
pergunta, vamos a documentação oficial do Python [5]:

 Python 2 foi o padrão da linguagem por muito tempo.

 Python 3 introduziu algumas mudanças que quebraram a compatibilidade com

a versão anterior, o que criou a necessidade de se manter duas versões da
linguagem.

 Python 2 recebeu atualizações de segurança até 2020, seu suporte foi

descontinuado.

 Python 3 está constantemente evoluindo e recebendo novas funcionalidades,

que não estarão presentes na versão anterior. Atualmente já passamos da versão
3.10. Aqui é possível consultar as versões do python
(https://www.python.org/downloads/)

A recomendação é, sempre que possível, usar Python 3. Portanto, nesta apostila

iremos contemplar apenas o Python 3.

1.3.Como instalar?
Você pode instalar o Python “puro”, do próprio site (https://www.python.org)
ou utilizar o Anaconda, que é um gerenciador de pacotes e de ambiente e uma
distribuição Python que contém uma coleção de muitos pacotes de código aberto
(https://anaconda.org/anaconda/python).

A diferença de utilizar o Python “puro” do Python no Anaconda é basicamente

que na versão do Anaconda vem muitas bibliotecas/pacotes já instalados. O Anaconda
vem com bibliotecas pré-criadas que economizam muito tempo para projetos com ML
começarem rapidamente. Há pessoas que preferem utilizar o Python "puro", outras
preferem o Anaconda.

7
 Seguem os tutoriais oficiais do Anaconda e do Python que recomendamos para
a instalação do Python:

 Instalação Anaconda.

 Instalação Python “puro”.

1.4.Ambiente Virtual
Um conceito muito importante para utilizar o Python é o Ambiente Virtual.
Eles são essenciais para que você isole as bibliotecas que você usa para evitar conflitos
entre projetos, reduzindo a quase zero os problemas de incompatibilidades entre as
bibliotecas.

Para criar ambientes virtuais você pode utilizar o Virtualenv ou o Conda. O

virtualenv cria ambientes isolados apenas para desenvolvimento Python; o Conda, por
sua vez, pode criar ambientes isolados para qualquer linguagem (em teoria).

Este link explica detalhadamente como criar um ambiente virtual com conda e
virtualenv.

1.5.Como executar o Python?

Então vamos escrever nosso primeiro programa! Este programa imprime uma
mensagem na tela. Veja Figura 1, o print é a função responsável por imprimir uma
mensagem na tela.

Figura 1 – Código do meu primeiro programa.

Mas como vamos executar este programa? Existem algumas formas de

executar o Python: o modo interativo e o modo script.

Modo interativo
Para executar este modo, digite python no terminal, assim que digitar este
comando, é exibido a versão do Python que está instalado. Logo em seguida, aparece o
'>>>' que indica que entramos no modo interativo do Python e basta digitar seu
código. Veja na Figura 2.

8
 Figura 2 – Execução Modo Interativo.

Modo script
Este modo é utilizado para execução de códigos maiores. Supondo que você
tenha um código de 500 linhas, você teria que digitar as 500 linhas a cada execução do
programa? A resposta é não! E o modo script nos ajuda nisso.

Para executar este modo, primeiramente precisamos criar um arquivo “.py”

(também conhecido como script). Veja na Figura 3.

Figura 3 – Modo Script.

Depois do script criado, basta executá-lo no prompt. Veja na Figura 4.

Figura 4 – Execução Modo Script.

1.6.Qual ferramenta de desenvolvimento utilizar?

Para o desenvolvimento do Python podemos utilizar editores de textos ou IDEs.
Os editores de textos são estruturas mais simples que IDEs. Alguns editores muito
utilizados são Vim, Notepad++, Sublime, entre outros.

As IDEs são estruturas mais completas que facilitam a vida do desenvolvedor.

IDE (Integrated Development Environment) ou Ambiente de Desenvolvimento
Integrado, é uma ferramenta usada no desenvolvimento de aplicações.

9
 Existem diversas IDEs para desenvolvimento Python. Na documentação oficial
do Python são listadas diversas. As mais utilizadas são: Spyder, PyCharm, Jupyter e VS
code.

Para os exemplos deste livro iremos utilizar o Jupyter e o VS code, as Figuras

5 e 6 ilustram essas ferramentas, respectivamente.

Figura 5 – Jupyter Notebook.

Figura 6 – VS Code.

10
2
Capítulo 2. Variáveis, Tipos e Estruturas de Dados
Neste capítulo iremos abordar as principais estruturas de dados que você
precisa conhecer para conseguir programar em Python.

2.1. O básico da Linguagem Python

Nesta seção vamos apresentar uma visão dos conceitos essenciais na
programação Python.

A indentação promove a legibilidade do código e é fundamental para que o

código funcione. Se você já programou em Java ou C++ sabe que o uso de chaves é
importante para estruturar o código. Aqui no Python quem faz este papel é a indentação.
A Figura 7 ilustra a indentação nas linhas 10 e 12.

Você pode fazer a indentação de duas formas: utilizando tab ou espaços. No

entanto, deve-se atentar em nunca misturar as duas, pois poderá gerar problemas no seu
código.

Figura 7 – Exemplo de Código.

Os comentários no código são uma excelente prática para documentar a lógica

do programa. Eles podem ser feitos de duas formas. A Figura 7 ilustra na linha 1 um dos
comentários que fazemos por meio do # e as linhas 4-8 ilustram o comentário por meio
de três aspas duplas.

12
2.2. Variáveis
Variáveis são responsáveis por guardar valores de um programa. Esses valores
podem ser números inteiros, números decimais, textos etc. A Figura 8 ilustra as
variáveis idade e nome; “idade” armazena o valor 18 e “nome” o valor “Maria”. Isso
quer dizer que quando chamarmos a variável idade, será retornado o valor 18 e a variável
nome retornará o valor “Maria”.

Figura 8 – Exemplo de Código.

Essas variáveis possuem diversos tipos. Neste momento iremos falar dos
números, textos e valores booleanos únicos, ou seja, cada variável possui um único valor
(tipos escalares). A Tabela 1 ilustra os principais tipos:

Tabela 1 – Tipos Escalares.

O comando type é responsável por informar qual é o tipo da variável, como

pode ser visto na Figura 9.

13
 Figura 9 – Tipos no Python.

Na seção 2.5 iremos descrever variáveis que armazenam valores diferentes em

uma mesma variável.

Uma dica importante para trabalhar bem com variáveis e ter códigos
legíveis é dar nomes semânticos as variáveis. Se uma variável vai representar
uma cidade, dê o nome de cidade. A Figura 10 apresenta o bloco 1 um código legível e
com variáveis com nomes claros. Já no bloco 2, não se tem boas definições de variáveis.

Figura 10 – Nomeando variáveis.

Um padrão seguido pelos programadores Python é começar a variável com

letras minúsculas e utilizar underscore (_) para separar palavras como: numero_celular;

14
endereco_trabalho; email_corporativo. Essas boas práticas de nomear variáveis e outras
você encontra no PEP8.

Outro padrão da linguagem Python é com relação às constantes. Constantes são

valores que se mantêm os mesmos, na teoria. A regra de nomeação das constantes no
Python é a seguinte: todas as variáveis são maiúsculas e separadas por “_”.

Caso você dê um nome inválido para uma variável, o interpretador acusará o

erro. A Figura 11 apresenta algumas variáveis com nomes ilegais; “1numero” é ilegal,
pois começa com número; “email@” é ilegal porque contém um caractere especial, (@);
“class” é ilegal pois é uma palavra reservada em Python. O interpretador utiliza
palavras-chave como palavras reservadas da linguagem, como um vocabulário próprio,
o Python possui 33 palavras reservadas: and, class, elif, finally, if, lambda, or, TRUE,
yield, as, continue, else, for, import, None, pass, try, assert, def, except, from, in,
nonlocal, raise, while, break, del, FALSE, global, is, not, return, with.

Figura 11 – Variáveis com nomes ilegais.

2.3. Operadores
Os operadores são responsáveis pelas operações com os números, como somar
ou subtrair. A Tabela 2 apresenta os principais operadores utilizados na programação
Python.

15
 Tabela 2 – Operadores.

Os operadores de lógica podem ser utilizados para strings e números. Já os

aritméticos podem utilizar o + e o *. O operador + funciona concatenando strings. O
operador * funciona repetindo a string. Veja o exemplo na Figura 12.

Figura 12 – Manipulando Strings com Operadores.

16
 Ordem dos Operadores
Quando uma expressão contém mais de um operador, a ordem da avaliação
depende da ordem das operações. Para operadores matemáticos, o Python segue a
convenção matemática. A ordem das operações é:

1. Parênteses: têm a precedência mais alta e podem ser usados para forçar a avaliação
de uma expressão na ordem que você quiser.

2. Exponenciação.

3. Multiplicação e Divisão: Possuem a mesma importância, assim é avaliado pela

ordem em que aparece da esquerda para a direita.

4. Adição e Subtração: possuem a mesma importância, assim é avaliado pela ordem

em que aparece da esquerda para a direita.

Use parênteses caso a ordem dos operadores na expressão não esteja

clara para você. Eles facilitam a leitura.

2.4. Manipulando Strings

Além das manipulações com string que vimos anteriormente com operadores
* e +, podemos fazer diversas outras. As Figuras 13 e 14 mostram algumas
manipulações. E outras podemos consultar a documentação do Python.

17
Figura 13 – Manipulando Strings (Parte 1).

18
 Figura 14 – Manipulando Strings (Parte 2).

2.5. Estruturas de Dados

Nesta seção iremos falar das seguintes estruturas de dados: Sequências (Listas,
Tuplas e range), Conjuntos e Dicionários.

Sequências
Sequências são containers, um tipo de dado que contém outros dados. Os tipos
básicos de sequências são: listas, tuplas e range, e outro tipo de sequência que vimos
anteriormente é a string.

As sequências podem ser mutáveis, isto é, seus valores podem ser modificados,
que é o caso das listas; e elas também podem ser imutáveis, como é o caso das tuplas,
strings e ranges.

19
 A Tabela 3 ilustra as operações que normalmente podemos fazer com todas as
sequências. Sequências do mesmo tipo também suportam comparações.

Tabela 3 – Operações Comuns entre as Sequências.

A Tabela 4 ilustra as operações que podemos realizar apenas com as sequências

mutáveis.

Tabela 4 – Operações com Sequências Mutáveis.

20
Listas
Listas são sequências mutáveis, normalmente usadas para armazenar coleções
de itens homogêneos. Elas possuem todas as operações apresentadas nas Tabelas 3 e 4.
Além disso, ela possui o método sort, que ordena a lista.

A Figura 15 possui exemplos de manipulação da lista. Observe que uma lista

pode ter diferentes tipos: temos números inteiros no bloco 4 e no bloco 5 adicionamos
uma string. Conseguimos fazer operações nos blocos 6 e 7. No bloco 8 ocorreu erro,
pois o método sort não sabe fazer ordenação de uma lista com vários tipos.

Figura 15 – Listas.

Tuplas
Tuplas são sequências imutáveis, normalmente usadas para armazenar coleções
de dados heterogêneos. As tuplas também são usadas para casos de uma sequência
imutável e dados homogêneos. Enquanto listas utilizam colchetes como delimitadores,
as tuplas usam parênteses. As tuplas possuem os métodos da Tabela 3.

21
 A Figura 16 possui exemplos de manipulação da tupla. Observe que os blocos
6, 7 e 8 deram erro pois são operações exclusivas de sequências mutáveis. Além disso,
note no bloco 1 e 2 que quem define uma tupla não são os parênteses.

Figura 16 – Tuplas.

Range
O range é um tipo de sequência imutável. É comumente usado para gerar uma
sequência de números. Ele implementa as operações da Tabela 3.

A Figura 17 ilustra o uso do range. Note que no bloco 7 ocorreu erro ao

implementarmos uma operação exclusiva do mutável.

22
 Figura 17 – Range.

Conjuntos (Set)
Conjuntos (set) são uma coleção não ordenada que não admite elementos
duplicados. Os objetos de conjunto suportam operações matemáticas como união,
interseção, diferença e diferença simétrica.

A Figura 18 mostra algumas das operações que podemos realizar com

conjuntos.

23
 Figura 18 – Set.

Dicionários
Um dicionário se parece com uma lista, mas é mais geral. Em uma lista, os
índices devem ser números inteiros; em um dicionário, eles podem ser de (quase)
qualquer tipo.

Dicionários são estruturas de chave valor, onde podemos ter diversas chaves e
cada chave terá um valor, que pode ser qualquer objeto (sequência, dicionário, conjuntos
etc.). Eles são estruturas poderosas pois acessamos os elementos pelo valor das chaves
e as chaves de um dicionário são valores únicos.

A Figura 19 ilustra o uso de dicionários. Neste exemplo, as chaves são strings

e os valores são inteiros. Conseguimos realizar diversas operações: alterar os valores
(bloco 4) e incluir o novo elemento (bloco 6).

24
Figura 19 – Dicionário.

25
3
Capítulo 3. Estruturas de Lógica
Neste capítulo iremos abordar as principais estruturas de lógica para que você
consiga programar em Python.

3.1. Condicionais
Os condicionais são utilizados quando queremos executar um comando
diferente de acordo com uma lógica. Por exemplo: vamos supor que se o usuário digitou
a senha corretamente, iremos liberar o acesso, caso contrário iremos exibir uma
mensagem de erro. A Figura 20 exemplifica a situação explicada anteriormente.

Figura 20 – Exemplo Condicional.

Observe que o que será executado quando a condição for satisfeita está
indentado (linhas 8 e 10), se não tivesse não iria funcionar, pois ocorreria um erro de
sintaxe. Veja na Figura 21, as linhas 8 e 9 com figura, indicando erro e que, ao
executarmos o código no terminal, aparece uma mensagem informando que estávamos
com problemas de indentação. A indentação é essencial na programação Python, fique
atento no uso delas.

27
 Figura 21 – Exemplo de Erro de Sintaxe.

Note que o comando if deve ter um resultado True ou False, ou seja, booleano.
Quando escrevemos na linha 7, password == senha, isso retornará True ou False. Caso
a senha digitada senha igual password, essa condição será True e ele exibirá a mensagem
da linha 8, caso contrário será a linha 10. Veja este exemplo na Figura 22.

Figura 22 – Executando o Código da condicional.

Todos os operadores de lógica mostrados na Tabela 2 podem ser utilizados

dentro de comandos condicionais.

O comando if/else mapeia duas condições: quando é somente uma o if executa,

caso não seja, o else executa. Mas e se tivermos mais condições para mapear? Se
tivéssemos que avaliar quando o nome fosse o administrador para poder liberar todo o
sistema; outra condição para liberar qualquer usuário; outra condição para quando
houvesse erro, como iríamos fazer? Para isso existe o comando if/elif/else, onde
podemos colocar outras condições e executar outros passos.

28
 Veja o exemplo na Figura 23. Na linha 7 verificamos se a senha está correta e
se o nome é o ‘admin’, caso seja o sistema será liberado completamente. Na linha 9
apenas conferimos a senha, não nos preocupamos com o nome, porque teremos uma
liberação default se a senha estiver correta. A linha 11 será executada caso não caia nem
no if, nem no elif. Note que ao final das condições temos os “:”, caso você esqueça, dará
erro de sintaxe.

Figura 23 – If/Elif/Else.

A Figura 24 ilustra a execução do script da Figura 23.

Figura 24 – Execução do script.

Os operadores lógicos, vide Tabela 2, são muito utilizados nas expressões

condicionais, os mais utilizados são o AND, OR, NOT e IS.

3.2. Estruturas de repetição (Loops)

Iremos estudar duas das estruturas de repetição em Python: for e while.

29
 O for é uma estrutura muito comum e muito utilizada em Python, por sua
simplicidade e versatilidade. Ele nos permite repetir um trecho de código um número
determinado de vezes. A Figura 25 ilustra a estrutura do for.

Figura 25 – Estrutura For.

Imagine: queremos imprimir uma mensagem com um número e este número

vai variar de 1 a 1000. Sem uso do for, teríamos que escrever número por número, o que
seria um tanto quanto cansativo! Já com o for, fica fácil. Veja a Figura 26.

Figura 26 – Loop For.

Na linha 1 temos o trecho de código que declara loop for. Ele começa com o
uso da palavra reservada for, segue para o nome de uma variável (“numero” no nosso
caso), depois tem o uso da palavra reservada in e, por fim, recebe uma lista de elementos
(“range(0,100)” no nosso caso). Essa lista é muito importante, pois a quantidade de
repetições do for será igual ao tamanho da lista. Os elementos da lista são acessados
sequencialmente, a cada loop (ou iteração) e são inseridos dentro da variável informada.

30
É por isso que, na linha 2, imprimimos um número de cada vez. Ou seja: Para cada
elemento dentro de uma lista, execute o trecho de código abaixo.

Já a estrutura de repetição while é um pouco diferente, pois ao invés de ter a

quantidade de execuções já determinada, como é o caso do for, no caso do while não
sabemos de início quantos loops irão ocorrer. Veja na Figura 27.

Figura 27 – Estrutura While.

Figura 28 – Exemplo While

Como podemos ver no exemplo da Figura 28, o loop while é declarado usando
a palavra reservada while e um teste condicional logo depois. A ideia é que, enquanto
esse teste condicional for verdadeiro, o código dentro do loop será executado. Isso
inclusive pode gerar problemas sérios como, por exemplo, loops infinitos, caso o teste
condicional sempre fique verdadeiro.

Para fazer um código similar ao feito no for, mas agora usando while não
fizemos muitas modificações. Na linha 1, atribuímos zero a uma variável que nos servirá
de contador (ou seja, ela vai aguardar a quantidade de loops já realizados). Na linha 2
declaramos o while e o teste condicional que utiliza a variável contador. Na linha 3

31
temos a execução do print e, por fim, na linha 4 incrementamos o valor da variável
contadora. Assim, após 100 execuções o teste condicional será falso e o while está
encerrado.

Além de for e while, que servem para criar as estruturas de repetição, temos
outras duas palavras reservadas que servem para controlar a repetição: break e continue.
Uma informação importante é que essas palavras só podem ser usadas dentro de um
while ou dentro de um for.

O break serve para interromper completamente o loop. Ou seja, quando um

break é executado, o for e o while são parados e o programa continua a ser executado.
A Figura 29 mostra um exemplo do break.

Figura 29 – Exemplo Break.

O continue é diferente. Quando ele é executado, o programa ignora o código

dentro loop e “pula” para o próximo elemento da lista. Veja o exemplo na Figura 30, o
segundo print nunca será impresso por causa do continue.

32
Figura 30 – Exemplo Continue.

33
4
Capítulo 4. Estruturas de Python
Neste capítulo iremos abordar as principais estruturas da linguagem para que
você consiga programar em Python.

4.1.Funções
Funções são muito úteis na programação. Uma das grandes vantagens é o fato
de não precisarmos repetir um código que faz a mesma coisa várias vezes. A função
agrupa um conjunto de instruções que podem ser reutilizadas. O Python possui várias
funções que já vimos anteriormente, como o print() e o type().

Nós também podemos criar nossas próprias funções. Por exemplo, imagine que
você precise, constantemente, gerar um gráfico para cada região do país. Para isso teria
que pegar o código que gera este gráfico e replicar 5 vezes, um para cada região. Isso
seria repetitivo e não deixaria o código limpo. Para resolver esse problema existem as
funções. Elas são responsáveis por encapsular um código, por exemplo, de “gerar um
gráfico” e, quando precisássemos de rodar o código para gerá-lo, chamamos apenas o
nome do método e não todo o código.

A Figura 31.1 ilustra a estrutura de uma função que podemos criar no Python.
Uma função no Python é definida com a palavra reservada def. Logo depois do def
temos o nome da função e entre parênteses, os parâmetros. Como essa função não tem
nenhuma ação, colocamos o termo pass, o qual simplesmente informa ao interpretador
que iremos implementar depois. O pass pode ser utilizado em qualquer bloco, por
exemplo, dentro de funções, if, while e for.

Figura 31.1 – Estrutura Função.

35
 As funções realizam um conjunto de instruções, e depois elas podem ou não
fazer um retorno. Este retorno pode ser de um simples valor/objeto ou um conjunto de
valores e objetos.

A Figura 31.2 exemplifica uma função que calcula o valor do IMC, dado a
altura e o peso. Temos dois exemplos: Um sem retorno, a função imc e a com retorno,
imc_return. Observe que a função imc recebe o peso e a altura, calcula o IMC e dá um
print do valor com uma mensagem. Já a função imc_return, retorna apenas o valor e
inserimos a mensagem ao imprimirmos o valor retornado pela função. Para esta função
realizar o retorno ela utiliza o return, que é o responsável pelo retorno das funções.
Ambos os métodos calculam o valor do IMC, entretanto eles apresentam o resultado
diferente e o melhor uso vai depender da sua necessidade.

Figura 31.2 – Exemplo de Função com e sem retorno.

Como vimos no exemplo anterior, informamos os parâmetros para calcular o

IMC. Neste caso nós sabíamos que para calcular o IMC precisamos de dois parâmetros:
a altura e o peso. Já quando não sabemos todos os parâmetros, o que podemos fazer?
Para isso existem as variáveis mágicas do python: *args e **kwargs. O nome dessas

36
variáveis args e kwargs é apenas uma convenção, poderíamos utilizar outro nome, o que
define de fato essas variáveis é o uso dos asteriscos.

O *args é utilizado quando não sabemos antecipadamente quantos argumentos

queremos passar para uma função. O asterisco (*) executa um empacotamento dos dados
para facilitar a passagem de parâmetros, e a função que recebe este tipo de parâmetro é
capaz de fazer o desempacotamento. A Figura 32 ilustra o uso do *args. Note que no
bloco 1 definimos a função, no bloco 2 não passamos nada pro *args, já nos blocos 3 e
4 passamos quantidade de parâmetros diferentes.

Figura 32 – Exemplo do uso do *args.

O **kwargs permite que passemos não apenas valores, mas também chaves.
Veja o exemplo da Figura 33. Observe que precisamos passar o nome do parâmetro
antes de passarmos o valor. No bloco 4 não foi passado e ele acusa o erro, pois aqui no
**kwargs é obrigatório a chave. Ele trata os parâmetros como um dicionário, então toda
manipulação que podemos fazer o kwargs é idêntica à manipulação e às restrições de
um dicionário.

A diferença entre esses comandos mágicos é que o *args espera uma tupla/lista
de argumentos e o **kwargs um dicionário com argumentos nomeados.

37
 Figura 33 – Exemplo do uso do **kwargs.

Funções Lambda
A função lambda, também conhecida por função inline ou anônima, nos
permite criar funções anônimas, isto é, não precisamos usar o def para defini-la. O
código do lambda é uma única instrução, não um bloco de instruções. A estrutura da
lambda é semelhante à instrução de retorno que utilizamos no def. A Figura 34 mostra
a estrutura de uma função lambda.

Figura 34 – Estrutura lambda.

Ela também pode receber parâmetros ou ser apenas uma expressão. A Figura
35 ilustra como um exemplo de uma função lambda, a função recebe um parâmetro,

38
neste caso o x e adiciona 10 ao valor recebido. Neste caso atribuímos a função lambda
a variável func.

Figura 35 – Exemplo função lambda.

É interessante você usar funções lambdas quando for necessária uma

ação/instrução por um curto período de tempo. O uso dessas funções são muito úteis
quando estamos trabalhando com instruções, como map(), filter() e reduce(), veremos
estas funções na Seção 4.2.

Funções Built-in
O interpretador Python possui várias funções e tipos integrados que estão
sempre disponíveis, são conhecidos como Built-in. Eles estão listados na Figura 36.
Existem vários, iremos destacar com exemplos alguns dos mais utilizados na Seção 4.2
sobre Utilidades da Linguagem.

Figura 36 – Funções Built-in.

Fonte: Documentação Oficial Python.

Para entender o que cada função built-in significa, visite este link com a
documentação do Python.

39
4.2.Utilidades da Linguagem
Nesta seção iremos apresentar alguns conceitos e comandos úteis para você
programar em Python. Algumas funções que apresentaremos são built-ins que vimos na
Figura 36.

Módulos e Pacotes
Um módulo é uma biblioteca de código. Um arquivo contendo um conjunto de
funções que você deseja incluir em seu aplicativo. Para criar um módulo basta salvar o
código desejado em um arquivo com a extensão de arquivo.py, por exemplo. Veja a
Figura 37.

Figura 37 – Exemplo Módulo.

Depois que criamos um módulo podemos utilizá-lo, veja o exemplo da Figura

38. Na linha 1 importamos o módulo que criamos e na linha 3 utilizamos o método
funcao() que foi definido no nosso módulo.

Figura 38 – Exemplo Uso do Módulo.

Também podemos criar um apelido para chamarmos os módulos sem ser com
o nome que salvamos no arquivo py. Para isso, usamos o comando as, como pode ser
visto na Figura 39.

40
 Figura 39 – Exemplo Uso do Módulo com Apelido.

Como vimos no exemplo anterior, podemos criar nossos próprios módulos.

Além disso, podemos utilizar pacotes prontos que estão disponíveis pelo Python. Os
pacotes contêm todos os arquivos necessários para um módulo. Enquanto um módulo é
um arquivo único, um pacote é um diretório de módulos contendo um arquivo
__init__.py.

O PIP é o gerenciador de pacotes/módulos do Python. O PIP normalmente vem

instalado com Python. Caso não venha, você pode instalá-lo, como neste link.

Com PIP podemos instalar vários pacotes para nos ajudar na construção das
nossas aplicações em Python. Para instalar um pacote, basta abrir o terminal e digitar
pip install <nome do pacote> ou conda install <nome do pacote>. Após a instalação,
basta utilizar a biblioteca.

Em um projeto iremos utilizar várias bibliotecas/pacotes, e essas têm diversas

versões e sofrem atualizações constantes. Para evitar problemas de incompatibilidade
futuros, use ambientes virtuais (Seção 1.4). A Figura 40 ilustra a criação de ambiente
virtual no Python com o conda. Observe que ele instala vários pacotes juntos.

41
 Figura 40 – Criando um ambiente virtual.

Depois que criamos um ambiente virtual, precisamos ativá-lo, vide Figura 41.

Figura 41 – Ativando um ambiente virtual.

Agora vamos criar e executar um script que tenha um módulo/biblioteca/pacote

que o nosso ambiente virtual criado, igti, não conheça, vide Figura 42. Estamos
importando a função unidecode do módulo unidecode. Observe no terminal que ocorreu
erro “No module named ‘unidecode’”, informando que o módulo não existe. Este

42
módulo é responsável por remover os acentos de uma string. Então nosso próximo passo
é instalar o pacote com o PIP.

Figura 42 – Executando Script.

Na Figura 43 instalamos o Pacote unidecode, e logo depois chamamos o script

e ele é executado normalmente sem o erro, e temos como resultado a palavra “Barbara”
sem acento. Podemos instalar utilizando o pip ou o conda, se com pip: pip install
unidecode, se conda: conda install unidecode.

Figura 43 – Instalando o Pacote.

Encontre mais pacotes em https://pypi.org/.

Use o comando uninstall para remover um pacote, vide Figura 44.

43
 Figura 44 – Removendo o Pacote.

Para listar os pacotes instalados, use o comando list, vide Figura 45.

Figura 45 – Listando Pacotes instalados.

Datetime
Uma data em Python não é um tipo de dado próprio, mas podemos importar
um módulo chamado datetime para trabalhar com datas como objetos. Ao trabalhar com
esses objetos é importante verificar o fuso horário utilizado. A Figura 46 mostra o uso
do datetime para pegar a data e hora corrente.

Figura 46 – Exemplo do uso do datetime.

O módulo datetime tem vários métodos para manipularmos datas. Entre eles
estão as operações com datas (como somar data, diferença entre datas etc.); extrair
minutos, segundos, horas, dias, meses, anos etc. Todas as operações que podemos fazer
com as datas podem ser consultadas na própria documentação do Python, neste link.

44
 Destacamos o método strftime(), que é um método para formatar datas em
strings legíveis. Por exemplo, veja a Figura 47, temos métodos que extrai o mês do ano,
a semana etc.

Figura 47 – Exemplo do uso do strftime do datetime.

Map
A função map() é built-in que executa uma função especificada para cada item
em um iterável. O item é enviado para a função como um parâmetro. A sintaxe do map()
pode ser vista na Figura 48.

Figura 48 – Sintaxe Map

A Figura 49 mostra um exemplo do uso do map(). No bloco 2 definimos a

função converte_celsisus_to_fahrenheit, que recebe uma temperatura em Celsius e
converte para Fahrenheit. No bloco 2 temos uma lista das temperaturas em Celsius. No
bloco 3, passamos o método e a lista para realizar a conversão. Ele retorna um objeto
map. Para conseguirmos visualizar, transformamos esse objeto map para list, como
podemos ver no bloco 4.

45
 Figura 49 – Exemplo Map.

Reduce
A função reduce() executa a função especificada para cada item em um iterável
(uma lista, por exemplo) diversas vezes até que o resultado da operação seja apenas um
número. A Figura 50 ilustra a sintaxe do reduce().

Figura 50 – Sintaxe Reduce.

A Figura 51 mostra um exemplo do uso do reduce(). Observe que para usarmos

o reduce() é preciso importar do pacote nativo functools. Nos blocos 2 e 3 utilizamos
as operações de soma e multiplicação, respectivamente. Note que temos três elementos
na lista e ao final ele retorna apenas um número. O bloco 6 apresenta passo a passo das
operações que o reduce() fez para somar uma lista de números, ele sempre retorna um
único número.

46
 Figura 51 – Exemplo Reduce.

Filter
A função filter() é built-in que aplica o filtro por meio de uma função e retorna
os itens filtrados, ou seja, os itens que dão True para a função. A sintaxe do filter() pode
ser vista na Figura 52.

Figura 52 – Sintaxe Filter.

47
 A Figura 53 mostra um exemplo do filter. No bloco 1 temos a definição de uma
função para verificar se um número é par. Note que definimos uma função lambda para
este exemplo, mas não é necessário que seja lambda. No bloco 2 e 3 testamos nossa
função e verificamos que ela está funcionando. No bloco 5 aplicamos o filtro e vemos
que foi retornado um objeto iterador. Para visualizar o resultado, basta transformar para
uma lista, vide bloco 6.

Figura 53 – Exemplo Filter.

Zip
A função builtin zip() retorna um objeto zip, que é um iterador de tuplas, onde
o primeiro item em cada iterador passado é emparelhado e, em seguida, o segundo item
em cada iterador passado é emparelhado etc. A Figura 54 mostra o que o zip faz com
duas listas. Ele basicamente faz a combinação das duas listas.

Figura 54 – O que o zip faz.

48
 A sintaxe do zip, mostramos na Figura 55, ele basicamente recebe
sequências/objetos iteradores. Pode receber um ou vários.

Figura 55 – Sintaxe Zip.

A Figura 56 mostra exemplos do uso do zip no Python. Observe no bloco 2,

ele retorna um iterador do tipo zip. No bloco 3, transformamos a lista para conseguirmos
visualizar. No bloco 4, fizemos o zip de três listas, sendo que a lista nova adicionada
tinha um elemento a mais do que as outras duas. Note que ele sempre pega o tamanho
em comum com todas as listas que estão presentes. Isso é claro no bloco 6, que temos 4
listas, duas com 3 elementos, uma com 5 elementos e outra com 2 elementos, o resultado
foi um zip de tamanho 2, pois dois era o tamanho da menor lista que passamos por
parâmetro. Se os iteradores passados tiverem comprimentos diferentes, o iterador com
menos itens decide o comprimento do novo iterador.

Figura 56 – Exemplo Zip.

49
Enumerate
A função built-in enumerate permite retornar o índice de cada valor em uma
sequência, à medida que você percorre toda sequência. Ele retorna uma tupla no formato
tupla(indice, valor). A sintaxe do enumerate está ilustrada na Figura 57.

Figura 57 – Sintaxe Enumerate.

A Figura 58 ilustra um exemplo do uso do enumerate. No bloco 3 vemos os

índices gerados e no bloco 4 mudamos de onde começa nosso índice, no caso do 5.

Figura 58 – Exemplo Enumerate.

List Comprehension
O List Comprehension permite desenvolver listas usando uma notação
diferente. É basicamente uma linha com um loop for construído dentro de []. A Figura
59 ilustra a estrutura do list comprehension.

50
 Figura 59 – Estrutura List Comprehension.

Também podemos colocar condições no list comprehension, conforme

podemos ver na Figura 60.

Figura 60 – Estrutura List Comprehension com Condição.

A Figura 61 mostra exemplos do list comprehension no python.

Figura 61 – Exemplo List Comprehension.

4.3.Tratamento de Erros
Durante o desenvolvimento de programas, em muitos momentos nos deparamos com erros que
ocorrem durante sua execução. Isso pode ocorrer por vários motivos, tais como: usamos
uma variável de um tipo inesperado para uma função; usamos métodos de uma variável

51
quando ela ainda não foi declarada; pedimos para abrir um arquivo que não existe ou que
não está no local indicado; tentamos acessar um elemento em uma posição inexistente em
uma lista e muitos outros. A lista de possíveis erros ou exceções é vasta. Quando um trecho
de código é interrompido porque ocorreu um erro de execução, dizemos que o programa “lançou
uma exceção”. A Figura 62 ilustra um exemplo de erro.

Figura 62 – Exemplo de lançamento de exceção.

Em Python, existe um mecanismo para tratarmos esses eventos de erros, que

recebe o nome de tratamento de erros ou tratamento de exceções. A ideia é envolver o
código que você sabe ou acredita que pode lançar uma exceção em uma estrutura, para
tratamento de erros chamada de try/except, vide Figura 63.

Figura 63 – Exemplo de uso de try/except.

Dessa forma, nos casos em que é possível ou até mesmo esperado de ocorrer
um erro, podemos impedir que o programa pare sua execução, tratando o erro, vide
Figura 64.

52
 Figura 64 – Exemplo de tratamento de erro.

Na figura acima vemos um exemplo de tratamento de erro ocorrendo. A função

recebe uma lista de itens e que precisa fazer uma operação matemática neles. A operação
ocorre na linha 6, em que o número 100 é dividido por um valor presente no elemento.
Contudo, como podemos observar na linha 1, existe um valor zero em um dos
elementos, o que significa que o programa fará uma operação inválida (divisão por
zero). Assim, criamos um código para o tratamento dessa exceção, que reporta para o
usuário qual foi o elemento onde ocorreu o problema, através de um print.

Em alguns momentos, quando estiver escrevendo código para tratamento de

erros, é interessante sabermos qual foi o erro ocorrido. Quando um código que está
envolvido na estrutura do try/except lança uma exceção, é possível analisar o que está
dentro dela, vide Figura 65.

53
 Figura 65 - Analisando uma exceção.

Em nosso exemplo, vemos que é possível adicionar a expressão “Exception as

e” logo após o except, de forma que a variável “e” passa aguardar informações sobre o
erro ocorrido, sendo possível imprimi-la diretamente ou analisar o seu tipo. Assim, fica
mais evidente para o usuário que o problema foi uma divisão zero.

Na figura abaixo vemos outra possibilidade importante para o tratamento de

erros, que é a estrutura com vários except. O princípio é possibilitar tratamentos de erro
específicos por tipo de erro, vide Figura 66.

Figura 66 - Tratamento de vários erros.

54
 Dessa forma, podemos informar ao usuário que ocorreu um erro ao tentar fazer
uma divisão por zero e avisar ao usuário que um dado poderia estar corrompido. Na
linha 8, ao colocar a expressão “except ZeroDivisionError”, indicamos que erros de
divisão por zero serão tratados pelo código na linha 9. Da mesma forma, como a linha
10 indica a captura de erros do tipo “TypeError”, as linhas 11 e 12 serão responsáveis
por esse tratamento. Existe uma lista de erros e exceções prontas em Python, que pode
ser conferida para conhecimento do que pode ser colocado no except.

Por fim, vale a pena conhecer também as estruturas de tratamento de exceções

usando else e finally. O else deve ser colocado após todos os excepts e o bloco de código
referente a ele será executado caso nenhuma exceção seja lançada. Já o finally deve
sempre ser o último elemento da estrutura de tratamento de exceções. O bloco de código
referente a ele sempre executa, independentemente de ter ou não ocorrido lançamento
de exceções, vide Figura 67.

Figura 67 - Exemplo com else e finally.

55
5
Capítulo 5. Orientação Objeto
Até agora, quando falamos de funções, variáveis e módulos, um conceito muito
importante ainda não foi aprofundado: a “Programação Orientada à Objeto” ou somente
“Orientação a Objeto”. Existem várias formas de programar (também chamados de
paradigmas de programação) e, em Python, encontramos as duas mais frequentes: a
forma estruturada e a forma orientada a objeto.

Quando criamos funções e variáveis e as utilizamos de forma direta em nosso

código, estamos usando a forma estruturada e, normalmente, ela é suficiente para a
maioria dos problemas simples. Contudo, existem cenários em que queremos definir
melhor o escopo de um conjunto de variáveis e de funções, deixando claro que todas
elas se referem a um mesmo conceito, a um mesmo objeto. Em geral, quando um
conjunto de variáveis e funções está intimamente ligado a um conceito, é uma boa
prática encapsulá-los (ou seja, envolvê-los) em uma classe.

Antes de entrarmos em mais teoria, vamos desenvolver um programa para um

banco. Um conceito importante para um banco é a Conta, então o primeiro passo é
escrevermos um código que cria uma conta bancária para nosso sistema, vide Figura 68.
Como sabemos que funções ajudam no nosso dia a dia, já colocamos em função. Note
que no bloco 2 criamos uma variável para a conta da Maria e outra para conta do João.
Para criar outras contas, basta criarmos novas variáveis e chamar nosso método
cria_conta().

Figura 68 - Cria a Conta.

57
 Uma conta de um banco tem várias funcionalidades: podemos realizar saque,
depósito, extrato, solicitar um cartão de crédito, solicitar aumento do limite, entre várias
outras operações. Pensando nisso, vamos criar alguns métodos para manipular a conta
do João e da Maria. A Figura 69 ilustra algumas funcionalidades que implementamos.

Figura 69 - Funcionalidades da Conta.

A Figura 70 mostra o uso das funcionalidades em cada uma das contas.

Figura 70 - Executando as funcionalidades nas contas.

58
A nossa conta é um dicionário e, por isso, podemos simplesmente alterar o valor da chave saldo,
vide Figura 71. Isso é seguro em ambiente bancário? Veja bem, quando nosso saldo do
banco é alterado é porque realizamos algum saque, recebemos algum depósito ou
pagamos alguma conta. Fora isso, nosso saldo permanece o mesmo. Pensando nisso, essa
ação ilustrada na Figura 71 não é segura e não deveríamos alterar o saldo assim.
Deveríamos alterar apenas por meio dos métodos de sacar e depositar, pois é assim que
funciona na vida real e o nosso código deve refletir esta realidade. Quem vai nos ajudar
a resolver este problema é a Orientação Objeto.

Figura 71 - Alterando o valor do saldo.

5.1. Classe e objetos

A classe representa o tipo do objeto e é a estrutura básica para a programação
orientada a objetos. É uma entidade que mapeia uma realidade como, por exemplo, a
Conta. Toda conta tem as mesmas características, tais como: número da conta, nome,
saldo, limite, entre outros. Esses atributos são os mesmos para toda conta, o que será
alterado são somente seus valores. A classe é como se fosse um “template” para os
futuros objetos.

A partir de uma classe criamos instâncias, sendo essas instâncias os objetos.

Então, por exemplo, tenho uma classe conta e vou ter instância da conta de Maria e da
conta de João. Esses serão os meus objetos.

Os objetos têm características que são conhecidas na orientação objeto como

atributos e suas ações que são conhecidas como métodos.

Em Python, TUDO é objeto. O list, tuple, dict, int, float, string que vimos
também são objetos, eles possuem métodos para manipulá-los.

59
 Para clarear ainda mais este conceito, trago alguns outros exemplos. O carro
poderia ser uma classe e os objetos seriam seus tipos: Se é uma Mercedes, um Uno, um
Onix etc.; um animal poderia ser uma classe e seus objetos seriam os animais existentes,
como cachorro, gato, pássaro etc.

Diante deste conceito que aprendemos, vamos implementar nossa classe Conta.
A Figura 72 ilustra nosso processo de criação. No bloco 1, linha 1, definimos nossa
classe Conta; as linhas 2 a 6 compõem nosso __init__, este método é responsável por
inicializar a classe com tudo que ela precisa. Ou seja, para eu ter uma conta é preciso
que tenha um número, o titular, saldo e limite. Se eu tentar criar um objeto sem esses
parâmetros ocorrerá erro, vide bloco 2. No bloco 3 conseguimos criar normalmente
nosso objeto. Outro item que merece destaque aqui é o self, que é a referência do objeto
da classe Conta, é a instância do objeto.

Figura 72 - Criando Classe Conta.

Uma vez que esse objeto foi criado, o Python aloca memória para guardar as
informações da conta dentro da memória do programa.

5.2. Método
Agora vamos incluir mais um conceito importante: o método. Métodos são as
ações que aquela classe fará; eles são funções definidas dentro do corpo da classe.
Assim, como utilizamos def para para definir as funções, também utilizamos nos
métodos.

60
 Agora vamos incluir as funções definidas anteriormente na nossa classe Conta.
Observe na Figura 73 que todos os métodos possuem o self. Isso é necessário pois o
método precisa saber qual objeto conta ele deve manipular.

Figura 73 - Incluindo os métodos na classe Conta.

5.3. Atributo
Os atributos são as variáveis da classe. Eles podem receber um valor padrão,
como pode ser visto na Figura 74. Observe que informamos um valor default para limite,
limite=500. Isso faz com que o limite não seja um requisito obrigatório para criar um
objeto (veja o bloco 15). Quando criarmos o objeto, o limite terá o valor de 500. Caso
queira alterar, você deve passar o valor desejado na criação da instância, ou apenas
alterar o atributo do objeto, como no bloco 16.

61
 Figura 74 - Valores default no parâmetro.

5.4. Herança
Um último conceito importante de entendermos sobre Orientação Objeto é a
herança. No mundo real, todo cachorro é cachorro, mas existem algumas
especializações, certo? Um Pinscher é diferente de um Yorkshire, mas ambos são
cachorros. O mesmo vale para veículos. Carros, caminhões e motos são veículos, mas
carros e caminhões são veículos de 4 rodas, enquanto motos são veículos de 2 rodas.
Carros poderiam ser veículos de 4 rodas para transporte de pessoas, enquanto caminhões
seriam veículos de 4 rodas para transporte de cargas.

Quando existem conceitos que herdam características de outros conceitos,

dizemos que ocorreu uma herança. Indo para nosso exemplo de Conta, podemos
imaginar que existe uma conta base que possui informações como Número, Nome e
Saldo e que existem contas especiais, como a Conta Salário, a Conta Corrente e a Conta
Poupança. Nossa conta base não permitirá saldos negativos e não terá nenhuma outra
funcionalidade adicional, além de saque e depósito, veja Figuras 75 e 76.

62
 Figura 75 - Conta Base.

Figura 76 - Usando a Conta Base

Agora que temos a conta base, vamos pensar nos outros tipos de conta. Uma
Conta Poupança seria uma conta que teria uma aplicação de juros sobre o saldo atual,
aumentando o seu valor. Uma Conta Salário seria uma conta que poderia ter um salário
associado e que teria um depósito desse salário no saldo da conta. Por fim, uma Conta
Corrente seria uma conta que teria um limite especial, permitindo que ficasse no
negativo e que tivesse uma aplicação de juros sobre o saldo negativo. A seguir, vamos
ver como ficam os exemplos (Figuras 77, 78 e 79).

63
Figura 77 - Exemplo de Conta Poupança.

Figura 78 - Exemplo de Conta Salário.

64
 Figura 79 - Exemplo de Conta Corrente.

Como podemos ver nos exemplos acima, cada classe conseguiu definir seus
comportamentos (métodos) e características (atributos) próprios, ao mesmo tempo em
que mantiveram as características da classe base. No exemplo da Conta Poupança,
conseguimos usar o atributo “saldo” da conta base mesmo sem defini-lo em nosso
método “__init__”. Isso ocorre por dois motivos: O primeiro, é que na definição Conta
Poupança, que colocamos assim: “class ContaPoupanca (ContaBase):”. Ao colocar o
nome de uma “classe A” entre parênteses na definição de uma outra “classe B”, estamos

65
dizendo que a classe B herda métodos e atributos da classe A. Além disso, na primeira
linha do “__init__” da classe Conta Poupança, fazemos uma chamada para o “__init__”
da classe base, através do seguinte código: “super().__init__(numero, titular, saldo)”.

No exemplo da Conta Salário, podemos definir dois novos métodos (receber

salário e mudar para um novo salário) e um novo atributo (salário), que existem apenas
nesse tipo de conta. Mas repare que o método de receber salário usa o método de
depositar que já existia na conta base. Da mesma forma, no exemplo da Conta Corrente,
definimos métodos e atributos novos e continuamos a conseguir usar os atributos e
métodos da conta base. Contudo, ainda podemos melhorar nosso exemplo com mais
uma funcionalidade que existe na herança, a sobrescrita (override) de métodos. Com
ela, podemos mudar o comportamento dos métodos da classe base (herdada) nas
subclasses (que herdam). Veja a Figura 80.

Figura 80 - Sobrescrita de métodos na Conta Corrente.

66
 Nessa figura sobrescrevemos os métodos “saca” e “extrato” para terem o
comportamento esperado no caso da classe Conta Corrente. Assim, ao invés de
precisarmos criar métodos novos para um saque usando o limite ou para exibir um
extrato com o limite, podemos usar os métodos que já existiam, substituindo o
comportamento por um que programamos. Para isso, basta escrever um método na
subclasse que tenha o mesmo nome que o método na superclasse.

67
6
Capítulo 6. Principais Bibliotecas
A seguir, iremos apresentar duas bibliotecas muito utilizadas na programação
Python: Numpy e Pandas.

6.1. Numpy
O NumPy abreviatura de Numerical Python (Python Numérico), é um dos
pacotes básicos mais importantes para processamento matemático/numérico em Python.
A maioria dos pacotes de processamento com funcionalidades científicas utiliza objetos
array do NumPy. Ele fornece suporte para arrays e matrizes e funções para operá-los.

Você deve estar se perguntando, mas o que é um Array? Um Array Numpy é

um conjunto de valores, todos do mesmo tipo e indexados por uma tupla de valores não
negativos. A Figura 81 ilustra 3 arrays de diferentes dimensões. Podemos fazer o
paralelo de um array com uma lista, porém nele podemos utilizar apenas o mesmo tipo
de dados e ele é muito mais otimizado.

Figura 81 - Exemplo de Arrays.

Algumas das principais características do Numpy são:

69
  ndarray: é o principal objeto do numpy, um array multidimensional, de n
dimensões, eficaz e que oferece operações aritméticas rápidas, orientadas a
arrays e com recursos flexíveis.

 Funções matemáticas para operações rápidas em arrays de dados inteiros, sem

que seja necessário escrever loops.

 Operações de álgebra linear.

 Integração com C, C++ ou FORTRAN.

Um dos motivos para o NumPy ser tão importante para processamentos

numéricos em Python é o fato de ele ser eficaz em arrays de dados grandes. Os
algoritmos baseados no NumPy geralmente são de 10 a 100 vezes mais rápidos (ou
mais) do que suas contrapartidas em Python puro, além de utilizarem significativamente
menos memória. Veja um exemplo: na Figura 82, o numpy resolveu a multiplicação
muito mais rápido do que a lista.

Figura 82 - Numpy exemplo - Mais rápido que listas.

Quando utilizamos o numpy estamos realizando a vetorização, isto é, a

ausência de qualquer loop explícito, indexação etc., no código. Essas coisas estão

70
ocorrendo, é claro, apenas “nos bastidores” em código C otimizado e pré-compilado. O
código vetorizado tem muitas vantagens, entre elas:

 Código vetorizado é mais conciso e fácil de ler.

 Menos linhas de código geralmente significam menos bugs.

 O código se assemelha mais à notação matemática padrão.

 A vetorização resulta em mais código “Pythonic”. Sem vetorização, nosso

código estaria repleto de for/loops ineficientes e difíceis de ler.

O Numpy possui várias operações. Para conhecer todas sugerimos que consulte
a documentação do módulo, que é bem completa e com muitos exemplos. A Figura 83
mostra alguns comandos do Numpy para ilustrarmos o uso dessa biblioteca no Python.

Figura 83 - Exemplo Código Numpy.

71
6.2. Pandas
Pandas é um pacote Python criado para manipular de forma rápida e expressiva,
dados estruturados. Seu objetivo, segundo a documentação, é de se tornar a ferramenta
de análise/manipulação de dados de código aberto mais poderosa e flexível disponível
em qualquer idioma.

As entradas primárias dos Pandas são: Series (1 dimensão) e DataFrame (2

Dimensões). O Pandas é construído em cima do NumPy e tem como objetivo integrar
bem em um ambiente de computação científica com bibliotecas terceiras.

Algumas das operações que o Pandas pode realizar:

 Manipulação de dados ausentes.

 Exclusão ou inclusão de colunas e linhas.

 Mesclar e unir conjuntos de dados.

 Funcionalidade específica de série temporal.

A Figura 84 ilustra exemplos de código manipulando um Series do Pandas.

72
 Figura 84 - Manipulação Series.

A Figura 85 mostra a criação do dataframe. Note que no bloco 12 temos uma

funcionalidade que descreve as principais estatísticas das colunas: nota_maematica e
nota_portugues.

73
 Figura 85 - DataFrame (Parte 1).

Com o Pandas também podemos plotar gráficos (vide Figura 86).

Figura 86 – DataFrame (Parte 2).

Com o Pandas conseguimos filtrar os dataframes, criar colunas e checar valores

vazios (vide Figura 87).

74
Figura 87 - DataFrame (Parte 3).

75
Glossário
 Argumento: um valor apresentado a uma função quando a função é chamada.

 Atribuição: uma instrução que atribui um valor a uma variável.

 Atributo: um dos valores denominados associados a um objeto.

 Bug: um erro em um programa.

 Cabeçalho: a primeira linha de uma definição de função.

 Chamada de função: uma instrução que executa uma função.

 Classe: tipo definido pelo programador. Uma definição de classe cria um objeto
de classe.

 Condicional aninhada: uma instrução condicional que aparece em um dos

ramos de outra instrução condicional.

 Condicional encadeada: uma instrução condicional com uma série de ramos

alternativos.

 Condição: a expressão booleana em uma instrução condicional que determina

qual ramo deve ser executado.

 Corpo: a sequência de instruções dentro de uma definição de função.

 Definição de função: uma instrução que cria uma função nova, especificando
seu nome, parâmetros e as instruções que contém.

 Depuração: o processo de encontrar e corrigir (depurar) bugs.

 Erro de sintaxe: um erro em um programa que torna sua análise impossível (e

por isso impossível de interpretar).

76
 Erro semântico: um erro que faz com que um programa faça algo diferente do
que o programador pretendia.

 Exceção: um erro que se descobre quando o programa é executado.

 Executar: executar uma instrução para fazer o que ela diz.

 Expressão: combinação de variáveis, operadores e valores que representa um

resultado único.

 Expressão booleana: uma expressão cujo valor é true (verdadeiro) ou false

(falso).

 Função: uma sequência nomeada de declarações que executa alguma operação

útil.

 Função com resultado: uma função que devolve um valor.

 Função nula: uma função que sempre devolve none.

 Instanciar: criar um objeto.

 Instrução condicional: uma instrução que controla o fluxo de execução,

dependendo de alguma condição.

 Instrução print: uma instrução que faz o interpretador do python exibir um

valor na tela.

 Interpretador: um programa que lê outro programa e o executa.

 Linguagem de alto nível: uma linguagem de programação como python, que

foi criada com o intuito de ser fácil para os humanos escreverem e lerem.

 Linguagem de baixo nível: uma linguagem de programação criada para o

computador executar com facilidade; também chamada de “linguagem de
máquina” ou “linguagem assembly”.

77
 Linguagem formal: qualquer linguagem que as pessoas criaram com objetivos
específicos, como representar ideias matemáticas ou programas de
computador; todas as linguagens de programação são linguagens formais.

 Linguagem natural: qualquer linguagem que as pessoas falam e que se

desenvolveu naturalmente.

 Modo interativo: um modo de usar o interpretador do python, digitando o

código no prompt.

 Modo script: um modo de usar o interpretador do python para ler código em

um script e executá-lo.

 Módulo: um arquivo que contém uma coleção de funções relacionadas e outras

definições.

 None: um valor especial apresentado por funções nulas.

 Objeto de classe: objeto que contém a informação sobre um tipo definido pelo
programador.

 Operador: um símbolo especial que representa uma operação de computação

simples como adição, multiplicação ou concatenação de strings.

 Operador lógico: um destes operadores, que combina expressões booleanas and

(e), or (ou) e not (não).

 Operador relacional: um destes operadores, que compara seus operandos ==,

!=, >, <, >= e <=.

 Palavra-chave: palavras reservadas pela linguagem de programação.

 Parâmetro: um nome usado dentro de uma função para se referir ao valor

passado como argumento.

78
 Portabilidade: a propriedade de um programa de poder ser executado em mais
de um tipo de computador.

 Programa: conjunto de instruções que especificam uma operação de

computação.

 Prompt: caracteres expostos pelo interpretador para indicar que está pronto
para receber entradas do usuário.

 Refatoração: o processo de alterar um programa funcional para melhorar a

interface de funções e outras qualidades do código.

 Script: um programa armazenado em um arquivo.

 Semântica: o significado de um programa.

 Sintaxe: as regras que governam a estrutura de um programa.

7
 Tipo: uma categoria de valores. Os tipos que vimos por enquanto são números
inteiros (tipo int), números de ponto flutuante (tipo float) e strings (tipo str).

 Valor: uma das unidades básicas de dados, como um número ou string, que um
programa manipula.

 Valor de retorno: o resultado de uma função.

 Variável: um nome que se refere a um valor.

 Variável local: uma variável definida dentro de uma função.

79
 Referência
1. CASTIGLIONE, C. 10 Famous Websites Built Using Python. 2022. Disponível em:
<https://learn.onemonth.com/10-famous-websites-built-using-
python/#:~:text=Instagram%2C%20the%20world's%20biggest%20online,is%20
written%20entirely%20in%20Python>. Acesso em: 27 de jul. 2022.

2. WIKIPÉDIA. Linguagem interpretada. Disponível em:

<https://pt.wikipedia.org/wiki/Linguagem_interpretada>. Acesso em: 27 de jul.
2022.

3. PYTHON . Beginners Guide. Disponível em:

<https://wiki.python.org/moin/BeginnersGuide/Overview>. Acesso em: 27 de
jul, 2022.

4. PYTHON-DEV. PEP 0 – Index of Python Enhancement Proposals (PEPs). 2000.

Disponível em: <https://peps.python.org>. Acesso em: 27 de jul, 2022.

5. PYTHON BRASIL. Qual Python?. Disponível em: <https://python.org.br/qual-

python/>. Acesso em: 27 de jul, 2022.

6. DOWNEY, A. B. Pense em Python: Pense como um cientista da computação.

São Paulo: Novatec Editora, 2019.
7. CAELUM. Caelum, Python e Orientação a Objetos. Disponível em:
<https://www.caelum.com.br/apostila/apostila-python-orientacao-a-
objetos.pdf>. Acesso em: 27 de jul, 2022.
8. W3 SCHOOLS. Python Modules. Disponível em:
<https://www.w3schools.com/python/python_modules.asp>. Acesso em: 27
de jul. 2022.
9. PANDAS. Package overview. Disponível em:
<https://pandas.pydata.org/docs/getting_started/overview.html>. Acesso em:
27 de jul. 2022.

80
10. NUMPY DEVELOPERS. What is NumPy?. 2022. Disponível em:
<https://numpy.org/doc/stable/user/whatisnumpy.html>. Acesso em: 27 de
jul. 2022.

10
9
8

81