LINGUAGEM PYTHON

PARA

ANÁLISE DE DADOS

1
Sumário
...............................................................................................................................Erro! Indicador não definido.
PYTHON PARA DADOS........................................................................................................................................2
VARIÁVEIS.......................................................................................................................................................3
Tipos de dados e transformações...............................................................................................................3
Comandos com números............................................................................................................................4
Como descobrir se uma variável tem valor numérico par ou ímpar?.........................................................5
Operações com textos................................................................................................................................5
CONDIÇÕES (condicionais).............................................................................................................................7
Operações de comparação.........................................................................................................................8
Condicionais com operações lógicos........................................................................................................10
Múltiplas condições..................................................................................................................................11
Condições alinhadas.................................................................................................................................12
LISTAS E REPETIÇÕES....................................................................................................................................15
Listas.........................................................................................................................................................15
Repetições................................................................................................................................................17
DICIONÁRIOS................................................................................................................................................23
Criando Dicionários..................................................................................................................................24
Métodos úteis para dicionários................................................................................................................26
FUNÇÕES......................................................................................................................................................28
Definindo Funções....................................................................................................................................29
Escopo......................................................................................................................................................31
Utilizando funções....................................................................................................................................31
DATAFRAMES................................................................................................................................................33
Criando DataFrames.................................................................................................................................33
Métodos em DataFrames.........................................................................................................................34
Sumarizando DataFrames.........................................................................................................................35

PYTHON PARA DADOS

Programação é sobre resolver problemas.

Informação = dados

2
Os dados podem ser de diversas maneiras: texto, número, data, número decimal, ...
Textos devem estar sempre entre aspas “ ”
Números decimais não são separados por vírgula, mas por pontos. (ex: altura = 1.60)
O python não reconhece espaços no nome da variável.
O python é sensível a letras maiúsculas e minúsculas, ou seja, se a variável foi declarada com todos os
caracteres em minúsculo, deve-se, ao declarar a variável, colocar todos os caracteres conforme foi escrito –
neste caso, tudo minúsculo.

VARIÁVEIS

Variáveis são locais onde armazenamos informações.

Tipos de dados e transformações

 Tipos primitivos:
 Booleano (bool) = esse tipo de variável aceita apenas dois tipos de informação, True (1) e
False (0). É uma variável que representa essa binaridade;
 Número inteiro (int) = armazena um número inteiro;
 Número decimal (float) = armazena um número decimal;
 String (str) = armazena os dados como um texto;
 None = uma palavra chave que indica ausência de valor.

 Transformação dos tipos de dados:

int() = transforma elementos de outros tipos para um número inteiro.

float() = transforma elementos de outros tipos para número flutuante ou decimal.

3
str() = transforma elementos de outros tipos para texto ou String.

Comandos com números

 Operações com números:

Soma;
Subtração;
Multiplicação;
Divisão;
Divisão inteira (traz apenas o valor inteiro, sem valor decimal);
Módulo (o valor correspondente a sobra da divisão inteira – o resto)
Exponenciação;

4
Como descobrir se uma variável tem valor numérico par ou ímpar?

Basta fazer o módulo deste número por dois (x%2) e, se retornar 0 é um número par, caso volte o número 1,
é ímpar.

Operações com textos

Assim como vimos que é possível fazer diversas alterações com números, também é possível performar
alterações com manipulação de textos (strings). Podemos fazer diversas operações, tais como:
 Juntar textos que estão em variáveis diferentes em uma mesma “sentença”;

5
  Utilizar variáveis em um texto para mudar informação automaticamente;
 Utilização de “receitas” prontas para nos ajudar a manipular textos, como, por exemplos: separar,
contar as letras, trocar caracteres e capitalizar.

 Operações com textos:

Operador +: operador que concatena uma String a outra String, retornando à junção das strings.

f-strings: operador que permite colocar uma variável dentro de um texto. Legal para formatar textos de uma
forma mais legível ao programador. Basta adicionar um f antes de iniciar o texto (lembrando que textos ficam
entre aspas) e colocar a variável desejada entre chaves {nome_variável}.

len(): retorna à quantidade de caracteres em uma String passada, diretamente ou guardada numa variável.
(lembrando que caracteres também contam espaços)

upper(), lower(): retorna à String passada alterando todos os caracteres para maiúsculas quando usado o
.upper() e para minúsculas quando usado o .lower(). Não altera a variável.

6
replace(): substitui strings especificadas por novas strings. Retorna a String manipulada. Não altera a
variável. (é similar ao comando substituir do excel)

in: operador que verifica se existe uma String em outra String, retornado verdadeiro ou falso. Não altera a
variável.

CONDIÇÕES (condicionais)

7
Vimos que programação é sobre resolver problemas e utilizamos as variáveis para resolvê-los. Bem sabemos
que os problemas nem sempre são tão simples de serem resolvidos. Os valores das variáveis podem
depender de condições para entender e resolver um problema. E é justamente o que veremos a seguir, como
criar condições e alterar, ou não, as informações dentro da linguagem Python.

Condição = comparação

Exemplos:
 Se a minha idade é maior a 18 anos, então eu sou adulto.
 Se compro à vista, tenho desconto.
 Se chover não vou lavar a roupa.
 Se a viagem for longa, vou dormir.
A comparação está em fazer está relação de uma informação (variável) com outra informação. Então
continuando nos mesmos exemplos:
 Se idade > 18, então adulto.
 Se modo de pagamento = à vista, então desconto.
 Se nível de chuva > 0, então não lavar roupa.
 Se distância > 500 Km, então dormir.
Para realizar estas comparações dentro do Python, utilizaremos dos operadores de comparação.
if: o if (se, em português) é o comando usado para atribuir uma condição. Ele executa um teste lógico e, caso
correspondido, retorna o valor declarado.
else: o else (senão, em português) surge depois do if, em complemento lógico a ele. Então, não existe
hipótese de escrever um else sem um if antes. Geralmente, o else não requer um teste, uma comparação,
pois ele executa algo caso a comparação do if não passe.
Operações de comparação

8
Neste último exemplo, os valores de 4 são diferentes, pois estão em formas diferentes. Enquanto um está
como número, o outro está como texto e, portanto, o Python reconhece com sendo diferentes.
Exemplo 1:

Neste exemplo a condição retornou um resultado de um número maior do que 7.

*INDENTAÇÃO*: é o espaço que fica entre o início da linha e ó código. Isso quer dizer que aquela informação
que estamos colocando após este espaço está relacionado com a informação anterior (linha anterior), ou
seja, isso significa que estamos dizendo para o python que está dentro daquela condição. No exemplo
anterior, trata-se do espaço antes do código “print...”.
Exemplo 2:

9
 Neste exemplo, o valor retornado seria a condição de ‘else’.

Condicionais com operações lógicos

Os operadores lógicos no Python mais comumente usados são:

Exemplos:

Neste exemplo, o valor retornado seria a primeira condição.

10
 Neste exemplo, o valor retornado seria a segunda condição.

Neste exemplo, o valor retornado seria a segunda condição.

Aqui mostra o que acontece “por baixo dos panos”.

Múltiplas condições
Existe outro operador lógico que sai um pouco da estrutura binária do If e else, que vem para ajudar a
solucionar problemas que apresentem mais de duas condições. Vejamos:
elif(): O elif é uma estrutura intermediária dentro da seção if-else no python e deve vir como um
complemento a ambos. Quando você já tem um if e um else, mas precisa de uma condição para especificar
outra regra, pode usar o elif.

11
Esta condição será entre ambos.
Exemplo:

Condições alinhadas
Para entender um pouco melhor, vamos imaginar a seguinte situação:

A condição alinhada é uma condição que está dentro de outra condição. Neste exemplo, a condição para
verificar se “está frio” está atrelada a primeira condição de “estar chovendo”. A condição de “estar frio” só
será atendida caso a condição “estar chovendo” não tenha sido atendida. Caso a primeira condição tenha
sido atendida, a outra instantaneamente não será mais necessária.
Como isso ficaria na programação? Vejamos:

12
Exemplo 2:

13
14
 LISTAS E REPETIÇÕES

As variáveis que vimos até agora são do tipo simples. Vamos conhecer uma variável do tipo composta.
Listas
As listas permitem o armazenamento de vários valores em um só variável.
Abaixo, veremos alguns métodos de listas:
append(): adiciona um item no final da lista, alterando a variável.

count(): retorna à quantidade de itens da lista que correspondem ao elemento desejado.

15
insert(): insere um item em uma posição específica desejada na lista. Ele exigirá dois argumentos, o primeiro
é a posição em que queremos colocá-lo (lembrando que a contagem inicia em 0) e o segundo é qual
elemento desejamos adicionar.

index(): retorna à posição onde um elemento se encontra na lista.

Atenção! = retorna apenas o índice da primeira aparição do elemento na lista.

len(): retorna o tamanho da lista, ou seja, a quantidade de elementos presentes nela.

Strings e Listas

16
Conversão de Strings em listas:
split(): recorta uma string em várias utilizando um caractere para definir o lugar do corte.

find(): procura o índice dos pedaços de texto específicos dentro de uma string.
Retorna a primeira posição que corresponde ao texto passado.

Repetições
A programação é uma grande aliada na automatização de tarefas repetitivas. Dessa forma, é possível criar
loops ou laços. Vejamos.
Loops/ laços

17
Existem dois tipos de Loops ou laços:
 Com quantidade determinada de repetições; (vai começar no elemento X e vai terminar no elemento
Y)
 Com quantidade indeterminada de repetições. (não se sabe quando a aplicação terminará)
Aplicações:
 Imprimir individualmente todos os itens de uma lista;
 Testar quais itens de uma lista satisfazem a uma determinada condição;
 Imprimir uma mensagem até que o usuário faça a ação desejada.

For
Um dos tipos de laços de repetições muito utilizado na programação é o for. Essa linguagem não é exclusiva
do Python, ou seja, existem outras ferramentas que também se utilizam deste tipo de código.
O for é um laço com quantidade determinada de repetições, ou seja, vai começar no elemento X e vai
terminar no elemento Y. Essa repetição ocorre ao longo de uma lista.
Exemplo de aplicação: Para todos os elementos de determinado conjunto, repita determinado comando.

Exemplo prático: Imprimir cada item de uma lista.

18
Exemplo prático: Executar comandos dentro do loop.

*Lembrete = Tudo o que estiver após os dois pontos, vamos indentar.

19
20
While
Outro tipo de laço de repetições muito utilizado na programação é o while (enquanto, em português). É um
laço com quantidade indeterminada de repetições. A repetição acontece quando uma condição é satisfeita.
Exemplo de aplicação: Enquanto determinada condição é satisfeita, repita determinado comando.

21
Exemplo prático: Imprimir cada item em um contador.

Exemplo prático: Executar comandos dentro do loop.

Exemplo prático: Imprimir cada item de uma lista.

22
 DICIONÁRIOS
Dicionário é um tipo de variável onde conseguimos acessar cada valor através de uma chave correspondente.
É um conjunto de dados onde existe uma chave para cada valor definido.

23
Criando Dicionários
O dicionário tem um identificador para cada valor armazenado, como um conjunto de variáveis organizadas.
Para declarar um dicionário, definimos o seu nome e colocamos entre chaves a chave do comando e o valor.
Nome = {chave : valor}

Exemplo 1: Guardando nota das alunas e acessando através de seus nomes, como chave.

24
Exemplo 2: Adicionando mais uma aluna em um dicionário já existente.
Nome [nova chave] = valor

Exemplo 3: Percorrendo um dicionário assim como em uma lista. Lembrando que chaves podem ser
números.

25
Exemplo 4: Dicionário que guarda os dados de uma aluna, sendo utilizado para calcular a média final.

Métodos úteis para dicionários

keys(): retorna todas as chaves de um dicionário como lista.

26
values(): retorna todas os valores de um dicionário independente da chave, como uma lista.

pop(): remove um item de um dicionário.

items(): retorna todas as chaves e valores de um dicionário como uma lista de listas.

27
sorted(): retorna as chaves de um dicionário de forma ordenada em ordem crescente como uma lista.

FUNÇÕES
Funções são blocos de códigos que executam uma tarefa específica, ou seja, uma tarefa que foi programada
para aquela função fazer.

28
Para ilustrar, vamos pensar numa receita de um bolo, por exemplo. Os argumentos são como os ingredientes
e o retorno seria o resultado que desejamos alcançar que, neste exemplo, seria o próprio bolo.
Seguindo essa mesma linha de raciocínio, se queremos um bolo de laranja, um dos ingredientes deve ser a
laranja. Se trocamos esse ingrediente por morango, teremos então, dessa maneira, um bolo de morango.

Definindo Funções
Em Python, uma função é uma sequência de comandos que executa alguma tarefa e que tem um nome. A
sua principal finalidade é nos ajudar a organizar programas em pedaços que correspondam a como
imaginamos uma solução do problema.
Podemos definir como sendo um pedaço de código que realiza alguma tarefa específica:
 Podem ser chamadas em qualquer parte do programa (quantas vezes desejarmos)

29
  Deixa nosso programa mais limpo e organizado (evita escrever código repetitivo)
Para que o python reconheça que queremos iniciar uma função, colocamos o código def. Logo em seguida,
vamos colocar o nome dessa função e, em seguida, dentro dos parênteses, colocar os argumentos dessa
função. Vamos indentar, após os dois pontos, e adicionar os comandos que iremos utilizar com estes
argumentos. Logo em seguida, vamos inserir o comando return e colocar entre parênteses o resultado que
está função deve retornar.

Exemplo 1: Função que recebe dois números, X e Y, e retorna o valor da sua soma.

Exemplo 2: Função que recebe o nome, idade, altura e profissão de alguém e retorna o texto “Olá! Meu
nome é <nome>, tenho <idade> anos, <altura>m de altura e sou <profissão>.”

Exemplo 3: Função que recebe uma idade e retorna a faixa etária da pessoa.
 Até 18 anos: “Jovem”
 De 19 a 60 anos: “Adulto”
 Acima de 60 anos: “Idoso”

30
Exemplo 4: Função que recebe uma lista de números e retorna a soma dos seus valores.

Escopo
Um escopo é uma região textual de um programa Python onde um espaço de nomes é diretamente
acessível. Aqui, “diretamente acessível” significa que uma referência sem um prefixo qualificador permite o
acesso ao nome. Basicamente, temos que nos atentar com qual tipo de variável estamos trabalhando.
Dentro de um programa Python, existem dois tipos de variáveis:
 Variáveis globais: Podem ser acessadas em qualquer momento no código a partir do momento em
que foi declarada.
 Variáveis locais: Só podem ser acessadas dentro da função em que ela foi declarada.

Utilizando funções
 Não há limites para a utilização de funções!
 Podemos usá-las:
o Como argumento de uma função;
o Dentro de uma função.

31
Exemplo 1: Função dentro de outra função.

Exemplo 2: Função como argumento.

32
 DATAFRAMES
Este é um dos tipos de dados mais utilizados por analistas de dados. É um tipo de dado onde estruturamos as
nossas informações através de tabelas.

Assim como nas listas, no DateFrame podemos inserir dados de todos os tipos.

Criando DataFrames

Pandas
O Pandas é a biblioteca mais importante para a análise de dados em Python.

 Biblioteca = conjunto de módulos e funções que facilitam a vida do programador.

 Devem ser importadas para serem utilizadas;
 No Colab, as principais bibliotecas já vêm instaladas, basta importar.

Criando um DateFrame
A partir de um dicionário: as chaves serão as colunas e os valores serão as linhas.

33
A partir de uma lista: precisamos também definir as colunas, seguindo o padrão de dados da lista.

Importante: Lembre-se de colocar columns (colunas) para que reconheça que são referentes às colunas.

Localizando-se dentro de um DataFrame

Um DataFrame é como uma tabela. Para utilizar um valor armazenado, é necessário saber as suas
coordenadas.

Sempre começamos pelo índice da linha e depois pelo índice da coluna

Existe alguns comandos que nos ajudarão a acessar a informação de acordo com as suas coordenadas.

iloc: Procura a informação através do índice da linha e o índice da coluna. As informações estarão dentro de
colchetes separados.

loc: Procura a informação através do índice da linha e do nome da coluna em que a informação está contida.
As informações estarão dentro de colchetes separados.

iat: Procura a informação através do índice da linha e o índice da coluna. As informações estarão todas
dentro do mesmo colchete, porém separadas por vírgulas.

at: Procura a informação através do índice da linha e do nome da coluna em que a informação está contida.
As informações estarão todas dentro do mesmo colchete, porém separadas por vírgulas.

Métodos em DataFrames
O que podemos fazer com os DataFrames? Veremos, a seguir, alguns métodos valiosos que vão nos ajudar a
obter informações sobre as tabelas e dados que vamos utilizar.

34
Shape
O shape retorna as dimensões da tabela, ou seja, a quantidade de linhas e colunas, no formato (linhas,
colunas). Basta colocar o nome da nossa base de dados e, em seguida, adicionar o comando shape, e
retornará a quantidade de linhas e colunas. nome.shape

Size
O size retorna à quantidade de elementos ou células presentes na tabela. Multiplica o número de linhas pelo
número de colunas. nome.size

Len
O len retornará à quantidade de linhas da tabela. len(nome)

Sumarizando DataFrames
Quais informações podemos ter da base? Vamos aprender como resumir informações que uma tabela
contém.

Vamos utilizar uma base de dados para testes presente no próprio Python, denominada Iris Dataset. Ela
possui dados de flores de íris e apresenta algumas informações destas.

35
Abaixo, veremos algumas informações para entendermos um pouco sobre estes tipos de flores, apenas para
nos situarmos quanto à exemplificação.

Para acessarmos essas informações, vamos importar uma biblioteca (pacote) da base de dados do Python
com o nome Seaborn. Veremos mais à frente que o Seaborn é um pacote que é muito utilizado para
confecção de gráficos, mas ele também fornece alguns datasets prontos, que são interessantes para
estudarmos e para fazer testes.

Recomendo que utilize está base para treinar e fixar os conteúdos que veremos a seguir.

36
head(): Retorna as primeiras 5 linhas de um DataFrame. Usado para ter uma amostra do conteúdo, sem
precisar carregar a base completa. Para aplicar, basta colocarmos o nome da nossa base, e logo em seguida,
acionar o comando head( ). Caso eu queira acionar mais de 5 linhas, basta colocarmos entre parênteses a
quantidade de linhas que desejamos. nome.head()

tail(): É similar ao head. O tail retorna as últimas 5 linhas de um DataFrame. Usado para ter uma amostra do
conteúdo, sem ter que carregar toda a base. Assim como no head, para aplicar, basta colocarmos o nome da
nossa base e, logo em seguida, acionar o comando tail( ). Caso eu queira acionar mais de 5 linhas, basta
colocarmos entre parênteses a quantidade de linhas que desejamos. nome.tail()

sort_values(): Ordena o DataFrame de acordo com uma coluna desejada. Podemos indicar se a ordem é
crescente ou decrescente. Para declarar, basta inserir o nome da base, o comando sort_values, e dentro dos
parênteses vamos definir os argumentos; no primeiro argumento colocamos o nome da coluna e no segundo
argumento vamos definir se queremos que a ordem seja crescente (true) ou decrescente (false).
nome.sot_values(argumento 1, argumento 2)

Ele não reordena os índices

37
dtypes: O dtypes retorna o tipo dos dados de cada coluna do DataFrame. Para declarar, basta declarar o
nome do DataFrame e adicionar o comando dtypes. nome.dtypes

count(): O count retorna à quantidade de observações não-nulas em cada coluna. Para declarar, basta
declarar o nome do DataFrame e adicionar o comando count(). nome.count()

min(): O min retorna o valor mínimo de cada coluna da base de dados. Para declarar, basta declarar o nome
do DataFrame e adicionar o comando min(). nome.min()

max(): O max retorna o valor máximo de cada coluna da base de dados. Para declarar, basta declarar o nome
do DataFrame e adicionar o comando max(). nome.max()

38
mean(): O mean retorna a média dos valores de cada coluna do DataFrame. Para declarar, basta declarar o
nome do DataFrame e adicionar o comando mean(). nome.mean()

median(): O median retorna a mediana dos valores de cada coluna do DataFrame. Para declarar, basta
declarar o nome do DataFrame e adicionar o comando median(). nome.median()

Observação: para pular linhas, basta colocar o comando “\n”.

39
Selecionando valores
A partir de agora vamos aprender como selecionamos valores dentro de um DataFrame.

columns: O columns retorna um objeto, que se comporta como lista, apresentando os nomes das colunas no
DataFrame. Para declarar, basta declarar o nome do DataFrame e adicionar o comando columns.
nome.columns

Selecionando colunas: Podemos selecionar apenas colunas específicas de um DataFrame. Isso é muito útil
quando temos uma base com muitas colunas, mas só precisamos manipular algumas. Para declarar, basta
declarar o nome do DataFrame e colocar entre dois colchetes e entre aspas os nomes das colunas desejadas.
nome[[‘coluna x’, ‘coluna y’, ‘coluna z’]]

Selecionando linhas e colunas: o comando loc() e iloc() também são utilizados para selecionar linhas e
colunas específicas. Pode ser feita de duas formas:

 Por intervalo;
 Por índice.

Seleção por intervalo: Suponha que quero selecionar as 5 primeiras linhas das 3 primeiras colunas. Para
declararmos, colocamos o nome do DataFrame seguido do comando (loc) e, entre colchetes, vamos
adicionar os argumentos. O primeiro argumento se refere as linhas, onde colocamos o índice da primeira e

40
da última linha desejadas. O segundo argumento se refere as colunas, onde declararemos o nome das
colunas desejadas entre aspas. nome.loc[0:10, ‘coluna_x”:’coluna_y’]

Seleção por índice: Suponha que quero selecionar as linhas de índice 0, 3 e 4 das colunas sepal_lenght e
petal_length. Declaramos colocando o nome do DataFrame seguido do comando (loc) e, entre colchetes,
vamos adicionar os argumentos (em formato de listas, estes também envoltos por colchetes). O primeiro
argumento se refere as linhas, onde colocamos os índices correspondentes que desejamos (neste caso, 0, 3 e
4). O segundo argumento se refere as colunas, onde declararemos o nome das colunas desejadas entre
aspas. nome.loc[[0,00,000] , [‘coluna_x”:’coluna_y’]]

BÔNUS:

Join
A função join em Python é uma ferramenta poderosa para manipulação de strings. Ela permite combinar
elementos de uma lista em uma única string, utilizando um separador específico. Isso é extremamente útil
em situações em que precisamos juntar valores separados por vírgulas, espaços ou qualquer outro caractere.

A sintaxe básica da função join é a seguinte: string_final = separador.join(lista_de_elementos)

41
Onde:

 separador é o caractere que será utilizado para separar os elementos da lista na string final;
 lista_de_elementos é a lista que contém os elementos que serão unidos.

Exportando csv
A função to_csv permite exportar a nossa tabela em arquivo csv. Basta declarar o nome do nosso DataFrame
e adicionar o comando to_csv. Entre parênteses, vamos adicionar o nome que desejamos para o arquivo e o
formato, que neste caso é o formato csv. nome.to_csv(nome_novo_arquivo.csv)

Fazendo o download do arquivo

Para fazer o download de um arquivo, basta acionarmos o comando files.donwload. Para tal, basta acionar
este comando e entre parênteses colocar o nome do arquivo desejado. files.download(nome_do_arquivo)

OBSERVAÇÃO: No Google Colab, para fazer esse tipo de operação, é necessário importar uma biblioteca,
também, do próprio Colab. O comando é: from google.colab import files

Logo em seguida o Python rodará esse código e fará o download do arquivo em sua máquina.

Operações matemáticas em DataFrames

Veremos agora com realizar operações matemáticas em nossas tabelas do DataFrame. Para entendermos
melhor, vamos utilizar os seguintes DataFrames como base:

Podemos utilizar os seguintes comandos:

42
add(): é o comando que que pode:

Adicionar um valor a todos os itens de uma tabela. Para utilizá-lo, declaramos o nome do DataFrame e
acionamos o comando add, e entre parênteses colocamos o valor que desejamos acrescentar.
nome.add(valor)

Fazer a soma dos itens de duas tabelas, levando em consideração o número da linha e o nome da coluna.
Vale lembrar que aqui é importante as tabelas terem as mesmas dimensões. nome1.add(nome2)

sub(): é o comando que que pode:

Subtrai um valor a todos os itens de uma tabela. Para utilizá-lo, declaramos o nome do DataFrame e
acionamos o comando sub, e entre parênteses colocamos o valor que desejamos retirar. nome.add(valor)

Fazer a subtração dos itens de duas tabelas, levando em consideração o número da linha e o nome da
coluna. Vale lembrar que aqui é importante as tabelas terem as mesmas dimensões. nome1.add(nome2)

43
mul(): é o comando que que pode:

Multiplica um valor a todos os itens de uma tabela. Para utilizá-lo, declaramos o nome do DataFrame e
acionamos o comando mul, e entre parênteses colocamos o valor que desejamos multiplicar.
nome.add(valor)

Fazer a multiplicação dos itens de duas tabelas, levando em consideração o número da linha e o nome da
coluna. Vale lembrar que aqui é importante as tabelas terem as mesmas dimensões. nome1.add(nome2)

div(): é o comando que que pode:

44
Divide um valor a todos os itens de uma tabela. Para utilizá-lo, declaramos o nome do DataFrame e
acionamos o comando div, e entre parênteses colocamos o valor que desejamos dividir. nome.add(valor)

Fazer a divisão dos itens de duas tabelas, levando em consideração o número da linha e o nome da coluna.
Vale lembrar que aqui é importante as tabelas terem as mesmas dimensões. nome1.add(nome2)

FILTROS EM DATAFRAMES
Vamos aprender agora como fazer filtros em DataFrames. Isso é importante, pois, às vezes, não será
necessário vislumbrarmos toda a nossa base de dados, contudo, em certos momentos, apenas algumas
partes específicas da tabela.

Projeção de DataFrames
A projeção de DataFrames se dá pela extração de partes de um DataFrame alocados em um novo
DataFrame.

45
É possível utilizar condições para ser mais seletivo.

É possível utilizar de condições com o comando query. Toda a minha condição deve estar entre aspas e
colocamos de forma direta o nome da nossa coluna.

Selecionando colunas
Podemos selecionar as colunas de acordo com as colunas, baseado nos tipos, utilizando o comando
select_dtypes(). É importante para nos ajudar a buscar dados específicos.

Selecionando apenas colunas por tipo

Este é um dado caso em que seja necessário acessar apenas informações, por tipo de variável, dentro de
uma parte da tabela. A ideia é fazer a seleção baseado no tipo de variável.

46
Podemos fazê-lo da seguinte forma:

Selecionando apenas os dados que precisamos com aquele tipo de variável. Para tal, nós declaramos o nome
do nosso DataFrame, acionamos o comando select_dtypes e, entre parênteses, colocamos include= (incluir,
em português) e o tipo da variável. nome.select_dtypes(include=tipo_variável)

Neste exemplo, utilizamos dados do tipo float.

Excluindo apenas colunas por tipo

Este é um dado caso em que seja necessário acessar apenas informações, por tipo de variável, dentro de
uma parte da tabela. A ideia aqui é fazer, também, a seleção baseada no tipo de variável. Sendo assim,
podemos, também, remover as colunas de acordo com o seu tipo.

Podemos fazê-lo da seguinte forma:

Selecionando apenas os dados que precisamos com aquele tipo de variável. Para tal, nós declaramos o nome
do nosso DataFrame, acionamos o comando select_dtypes e, entre parênteses, colocamos exclude= (excluir,
em português) e o tipo da variável. nome.select_dtypes(exclude=tipo_variável)

47
Reiniciando índices
Um ponto interessante é que, quando fazer um filtro ou reordenamos um DataFrame, os índices se mantém
iguais, ou seja, mesmo após executar estes comandos, ele manterá o índice da linha original – similar ao que
ocorre quando fazemos filtros no Excel, por exemplo. Observe, abaixo, que os índices se mantiveram, mesmo
após criarmos um novo DataFrame.

Contudo, é possível reiniciar esse índice, de forma que essa nova linha passe a ter o índice 0. (neste caso, o
índice 100 se tornaria o 0, o 101 o índice 1, e assim por diante)

Podemos fazer essa modificação usando o comando reset index. Para isso, basta passarmos o nome da nossa
base de dados e acionar o comando reset_ index. Pode ser feito de duas maneiras:

nome.reset_index( ) – este comando reiniciará as linhas com novos índices, porém ele fará uma nova coluna,
logo em seguida, com as informações antigas, ou seja, com o índice original da tabela base. É utilizado para,
caso precisemos saber onde estava aquela informação e para não perder esses dados primários, por
exemplo.

nome.reset_index(drop=true) – este comando reiniciará as linhas com novos índices, sem criar uma nova
coluna. Basta adicionarmos, entres os parênteses, o comando drop=true.

Neste exemplo, está mantendo o índice original.

48
Substituição e compreensão de valores
Veremos, a seguir, alguns comandos utilizados para entendermos, de uma maneira um pouco mais clara,
sobre como se dá a substituição e a compreensão de valores: entender como funciona a contagem e como
alterar valores, por exemplo, dentro do DataFrame.

Substituição de valores
Podemos utilizar esta funcionalidade em diversos momentos. É útil para fazer a manutenção de uma base de
forma eficiente, sendo alguns casos onde podemos utilizá-la:

 Em bases com dados faltantes representados por outros valores, como -1 e -999, para NaN ou Null;
 Em bases com valores discrepantes, como “BA” e “Bahia” para referir-se a mesma coisa;
 Em bases com valores que precisam ser padronizadas.

Vejamos alguns comandos que nos possibilitam fazer isso:

fillna(): substitui valores faltantes por novos valores. Esse método não sobrescreve o DataFrame. Para
declararmos, colocamos o nome do DataFrame, acionamos o comando fillna e, entre parênteses, o
argumento.

Argumento = valor que irá substituir os valores faltantes.

replace(): substitui valores existentes por novos valores. Esse método não sobrescreve o DataFrame. Para
declararmos, colocamos o nome do DataFrame, acionamos o comando replace e, entre parênteses, o
primeiro argumento e o segundo argumento.

Argumento 1 = valor(es) a serem substituídos

Argumento 2 = valor(es) que irão substituir

49
apply(): utilizado para aplicar uma função para modificar valores. Esse método não sobrescreve o
DataFrame.

rename(): utilizado para renomear colunas. Para declararmos, colocamos o nome do DataFrame, acionamos
o comando rename e, entre parênteses, colocamos columns = {argumento 1: argumento 2}.
nome.rename(columns = {argumento 1: argumento2})

Argumento 1 = nome da coluna antiga

Argumento 2 = novo nome desejado para a coluna

50
Compreendendo valores
É possível consultarmos algumas contagens, entender como alguns valores estão dispostos dentro das nossas
colunas, e por aí vai. Podemos dizer que são mecanismos que nos trazem informações de elementos dentro
da nossa tabela. A seguir, veremos alguns dos comandos que podemos utilizar:

value_counts(): conta a ocorrência dos valores presentes em uma série.

Pode retornar também como porcentagem. O atributo normalize retorna à informação sobre a frequência
relativa de cada valor.

51
unique(): retorna uma lista com os valores únicos da coluna selecionada.

nunique(): retorna a contagem de elementos únicos da coluna selecionada.

RECURSOS AVANÇADOS
Veremos, a partir de agora, alguns temas mais complexos na linguagem Python, mas que nos ajudarão
bastante a simplificar o nosso código.

Existem várias formas de entender se um código é considerado bom ou ruim. Algumas das características são
um consenso entre os programadores, como menos linhas de código e a utilização de boas práticas (uma boa
indentação, por exemplo), estabelecidas pela comunidade de determinada linguagem.

Essas características nos ajudam a gerar um código eficiente e de fácil leitura, pois o código não é de uso
restrito apenas ao programador que o criou, mas é possível também a sua edição por terceiros.

List Comprehention
O List Comprehention é uma sintaxe usada para criar listas baseadas em listas já existentes. É caracterizada
por usar uma abordagem mais elegante e mais eficiente (o python aloca na memória primeiro, ao invés de
alocar na execução), o que agiliza o processo, deixando-o mais rápido. A ideia é fazer a mesmo processo que
faríamos em um loop for, porém numa única linha de código, acelerando o processo.
SINTAXE BÁSICA

Expressão = utilizar os elementos de uma lista antiga

Para visualizarmos de maneira mais clara, vamos analisar a diferença de uma sintaxe com List Comprehention
e outra sem.

52
Usando condicionais
Permite usar expressões condicionais para criar ou modificar listas.
APENAS UMA CONDIÇÃO

COM VÁRIAS CONDIÇÕES

Loops alinhados
Para percorrer duas listas, podemos utilizar loops alinhados. O objetivo aqui é ver todas as possibilidades
possíveis combinatórias que podem ser geradas.

53
Funções Lambda
Muitas vezes, quando estamos na construção de um código, precisamos criar códigos, mas nem sempre essa
função precisa ser reaproveitada em outros lugares do código. Essa função aplica-se apenas para aquele
contexto em específico, como, por exemplo, quando utilizarmos o método apply em DataFrames. Para esse
caso onde temos uma função simples sem reaproveitamento, existe uma sintaxe mais simples, denominada
Lambda Funcitons.

São funções anônimas, ou seja, não precisam ser definidas nem nomeadas. Podem ser utilizadas em
qualquer lugar onde usaríamos uma função padrão, ou seja, vai desempenhar o mesmo papel. Podem,
também, receber qualquer número de argumentos, mas podem ter apenas uma instrução ou retorno (terá
uma linha apenas).

Basicamente funciona desta maneira: acionamos o comando lambda, quais são os argumentos, dois pontos,
e o que deseja fazer com esses argumentos.

Vamos fazer uma comparação entre as sintaxes das funções comuns e das funções que utilizam o lambda.

54
As funções lambda são mais concisas quando comparadas a funções clássicas definidas pelo usuário.

Complementos à função Lambda

Alguns complementos que podem nos ajudar a utilizar a função Lambda.

map(): o map retorna um objeto depois de aplicar uma regra por meio de uma função em cada item de uma
lista existente. É utilizado para gerar novas listas ou manipular valores.
Importante! = É necessário transformar o resultado em uma lista usando o comando list().

É possível, também, aplicar o map em mais de uma lista ao mesmo tempo.

Importante! = É necessário transformar o resultado em uma lista usando o comando list().

filter(): filtra itens em uma lista, sem alterar na lista utilizada.

apply(): o método do pandas também pode receber uma lambda function como argumento.

55
reduce(): o reduce é um método muito utilizado por ser incremental, isto é, ele guarda um valor que pode
ser usado em cada passo do loop, retornando um único valor no final. É muito útil para operações utilizando
todos os itens de uma lista.
Importante! = Para usar esse método temos que importa-lo da biblioteca functools.

O reduce também pode ser aplicado em dicionários. Depois da lista dentro do reduce, podemos passar um
terceiro argumento que será o valor inicial do acumulador.
Importante! = Para usar esse método temos que importa-lo da biblioteca functools.

Outro exemplo do reduce usando dicionários e o terceiro argumento.

Importante! = Para usar esse método temos que importa-lo da biblioteca functools.

56