Análise de dados com Python

Módulo 1 - Primeiros passos

na análise de dados
Sumário

Aula 1: Contextualização Aula 2: Ferramentas Essenciais

1.1 Introdução à Análise de Dados com Python 4 2.1 Criação e Manipulação de Arrays com NumPy 15
1.2 Configurando Ambientes: Jupyter 6 2.2 Pandas: Series e DataFrames 18
1.3 Revisão dos conceitos básicos de Python 11
 3

Aula 1 - Contextualização
 4

1.1 Introdução à Análise

de Dados com Python
Vamos começar do zero, entendendo o que é análise dados. A análise de
dados é um processo que nos permite extrair conhecimento de informações • Análise Descritiva de Dados: o que aconteceu? Informa sobre a situação
brutas, auxiliando na tomada de decisões mais assertivas e no direcionamento atual do objeto ou evento em análise. Utiliza dados reais para descrever um
estratégico para o futuro. Esse processo envolve várias etapas, incluindo comportamento.
examinar, tratar, transformar e modelar os dados, com o objetivo principal de
extrair informações significativas, geralmente para apoiar decisões e
responder a perguntas específicas. • Análise Diagnóstica e/ou Confirmatória de Dados (ACD): por que
aconteceu? Testa hipóteses usando técnicas estatísticas para validar se os
padrões identificados são significativos, determinando a causa de
Para realizar esses tipos de análises, diferentes técnicas são utilizadas, desde resultados específicos.
as mais simples, como a análise descritiva, até as mais complexas, como a
análise prescritiva. A escolha da técnica adequada dependerá do objetivo da
análise e dos dados disponíveis. • Análise Preditiva de Dados (APD): o que pode acontecer? Utiliza
As mais comuns são: algoritmos para prever eventos futuros com base em dados históricos,
permitindo ações proativas, como prever a renovação de contratos de
• Business Intelligence (BI): quais dados temos? Foco na coleta/ clientes.
mineração e armazenamento de dados de qualidade para auxiliar na
compreensão do negócio.
• Análise Prescritiva de Dados: o que devemos fazer? Recomenda ações de
negócios, utilizando algoritmos complexos e aprendizado de máquina para
• Análise Exploratória de Dados (AED): o que os dados revelam? Explora abordar problemas e antecipar tendências.
dados brutos para descobrir padrões, tendências e relações,
proporcionando uma compreensão inicial dos dados.
O dia a dia de um analista de dados envolve diversas etapas. Veja uma visão
geral das etapas e as ferramentas comumente utilizadas em cada uma delas.
 5

1. Limpeza e organização de dados

4. Visualização de dados
• Python (usando bibliotecas como Pandas e Numpy): para manipulação
e limpeza de dados. • Tableau: para criação de dashboards interativos e visualizações
• R: para limpeza de dados e manipulação de dados estatísticos. avançadas.
• OpenRefine: para limpeza de dados em formato de tabela. • Power BI: para criação de relatórios interativos.
• Excel: para tarefas simples de limpeza e formatação de dados. • Python (bibliotecas como matplotlib, seaborn e plotly): para criação de
gráficos e visualizações personalizadas.

2. Análise exploratória de dados

• Excel: para gráficos básicos e visualizações rápidas.

• Python (bibliotecas como Pandas, Nump e Scipy): para análise estatística 5. Comunicação dos resultados
e de dados.
• R: para análise estatística avançada. • PowerPoint: para criação de apresentações.
• Excel: para análises simples e uso de fórmulas e tabelas dinâmicas. • Tableau/ Power BI: para apresentações interativas.
• SPSS/Stata/SAS: para análise estatística avançada. • Jupyter Notebook: para apresentar resultados em um formato narrativo e
interativo.

3. Modelagem de dados
• R e Markdown: para relatórios interativos.

• Python (bibliotecas como Scikit-learn, TensorFlow e Keras): para Neste contexto, podemos observar que Python é uma linguagem extremamente
modelagem preditiva e machine learning. versátil, pois possui uma ferramenta para quase todas as etapas e possui um
PyData stack (conjunto de ferramentas e bibliotecas em Python) muito útil para
• R: para modelagem estatística e machine learning. ciência de dados. Por isso, para a nossa trilha, adotamos o Python, juntamente
• SQL: para modelagem e agregação de dados. com o Jupyter Notebook, uma ferramenta que facilita a criação, o teste e o
compartilhamento de códigos.
 6

1.2 Configurando Ambientes: Jupyter

Jupyter Notebook

O Jupyter Notebook é muito usado em análise de dados por ser fácil de instalar
e de utilizar. Ele permite escrever o código, separar o código em células para
melhor visualização e entendimento e facilita o compartilhamento do trabalho
que você fizer. Além disso, é leve, amigável ao usuário e compatível com
qualquer sistema operacional, pois funciona direto do navegador.

Para utilizar a versão online da ferramenta, realize os seguintes passos:

1. Acesse site oficial aqui.
2. No topo da página, clique em “Try”.
3. Em seguida, selecione uma das opções ou “JupyterLab”, ou "Jupyter
Notebook”.

JupyterLab vs Jupyter Notebook

O JupyterLab é a próxima geração da interface de usuário do Jupyter, que

oferece uma experiência mais flexível e extensível. Ele fornece uma interface de
usuário baseada em abas e painéis que permite trabalhar com múltiplos
documentos e ferramentas simultaneamente. Entretanto, a interface mais
avançada pode ter uma curva de aprendizado mais acentuada para novos
Foto de fabricasimf
disponível no Freepik.

usuários. Assim, aconselhamos novos usuários a começarem pelo Jupyter Editada pelo autor.

Notebook, que possui uma interface intuitiva e fácil de navegar.

 7

Instalar Jupyter Notebook Usando o Miniconda No Windows, realize os seguintes passos:

• Execute o arquivo .exe baixado.
Uma alternativa para utilizar o Jupyter Notebook é fazer a instlação no nosso • Siga as instruções do instalador.
compputador por meio do Anaconda, um gerenciador com ferramentas pré • Apenas marque a opção "Add Miniconda to my PATH environment
instaladas, que facilitam o uso e a configuração para os usuários. Com o objetivo de variable" se você quiser abrir o Jupyter de qualquer terminal. Mas tenha em
deixar a instalação mais leve e personalizada, sugerimos o baixar o Miniconda, uma mente que, se você tiver outras instalações do Python, isso vai substitui-la por
versão que evita a instalação de dependências que não iremos utilizar.Primeiro, vá essa que vem junto com o Miniconda. Por padrão, vamos deixar desmarcado
no site do Anaconda e baixe o Miniconda, em seguida clique em "Installing e isso vai exigir que você utilize o terminal do Anaconda sempre que quiser
Miniconda". abrir o Jupyter.

Escolha o instalador adequado para seu sistema operacional (Windows, macOS ou

Linux). Depois de baixar, execute o instalador e siga o passo a passo, mantendo as
configurações padrão (só aperte next!)
 8

Instalar o Jupyter Notebook

Agora, vamos utilizar o terminal para instalar o Jupyter notebook. Para isso, vamos
usar o gerenciador de pacotes do Python, chamado pip. Primeiro, procure nos
programas do seu computador o terminal do Anaconda.

Execute no Anaconda Powershell Prompt: "pip install jupyter"

Iniciar o Jupyter Notebook

Execute no Anaconda Powershell Prompt: "jupyter notebook".

Isso abrirá o Jupyter Notebook em seu navegador padrão.

IMPORTANTE! Se você não marcou a caixinha de adicionar o Python no PATH do

seu sistema operacional durante a instalação, este comando deve ser executado a
partir do terminal do Anaconda, porque outros terminais podem não conseguir
executar o comando de instalação. Caso contrário, deve funcionar de qualquer
terminal.

Caso a página com a aplicação carregada não apareça, clique ou copie e cole o link
que apareceu no terminal no seu navegador:
 9

Usar o Jupyter Notebook

Na interface do Jupyter Notebook, escolha uma pasta onde irá trabalhar e clique
em “File” -> “New” -> “Notebook”. Isso vai criar um arquivo novo com o nome
Untitled.ipynb, que você pode renomear depois.

Feito isso, vamos à interface de edição do Jupyter Notebook:

Ao clicar, o seu novo notebook vai abrir em outra aba, perguntando qual o
Kernel Python, ou versão de interpretação dele, que queremos usar. Você pode
escolher e apertar “Select” para prosseguir.

Adicionar e Executar Código

Começando pelo nome do arquivo: você pode clicar no nome ao lado do logotipo
do Jupyter e renomear o arquivo que criamos, onde está escrito “Untitled”. Ao
clicar lá, poderá renomear à vontade que ele já salva para você.
 10

O Jupyter Notebook é formado de células. Cada célula contém uma seção do seu
projeto. Em cada seção, você pode fazer três ações: Adicione código nas células e execute-o clicando em "Run" (o símbolo de play em
1. Criar células de texto corrido sem formatação e que não executa em Python cima) ou pressionando Shift + Enter.
para descrição ou comentários.
2. Criar células formatadas via Markdown, que é uma linguagem bastante Salvar e Fechar Notebooks
comum para documentação e permite estilizar seu texto com alguns símbolos.
Você encontra orientações no site Markdown Guide.
3. Criar células com código Python. Use o menu "File" para salvar seu trabalho e fechar o notebook.

Para alterar o formato do conteúdo das células, clique na célula desejada. Em

seguida, na parte superior, selecione o menu "Code". Esse menu permite que
você escolha entre diferentes tipos de células, facilitando a troca entre eles.
 11

1.3 Revisão dos conceitos

básicos de Python
Python se tornou uma das linguagens de programação mais populares no campo Os tipos de dados padrão no Python são os seguintes:
da ciência de dados e análise de dados, graças à sua simplicidade e versatilidade. • Inteiro (int): o tipo inteiro é um tipo composto por caracteres numéricos
Neste tópico vamos revisar os principais conceitos de Python aplicados a dados. inteiros, pode ser positivou ou negativo.
• Ponto Flutuante ou Decimal (float): é um tipo composto por caracteres
Tipos de Dados numéricos decimais.
• String (str): é um conjunto de caracteres dispostos numa determinada
ordem, geralmente utilizada para representar palavras, frases ou textos.
Python é uma linguagem dinamicamente tipada, o que significa que não é
necessário declarar o tipo de variável ou fazer casting (mudar o tipo de variável), • Booleano (bool): tipo de dado lógico que pode assumir apenas dois
pois o Interpretador se encarrega disso. Isso significa também que o tipo da valores: falso ou verdadeiro. Na lógica computacional, podem ser
variável pode mudar durante a execução do código. considerados como 0 ou 1.

Saiba que em determinados cenários, pode ser necessário mudar o tipo de uma
variável.

Variáveis

Variáveis são utilizadas para armazenar valores com o operador de atribuição

sendo o sinal de igual. É uma boa prática usar nomes de variáveis com algum
significado. Veja alguns exemplos:
 12

# Armazena o nome do cliente com texto

nome = ‘Joaquim’ Estrutura de Dados

# Armazena a idade do cliente com números inteiros

idade = 21 Continuando a revisão de conceitos, é crucial entender as estruturas de dados
básicas da linguagem. Elas formam a base sobre a qual construímos operações mais
# Indica se o cliente é VIP (bool) (verdadeiro/falso) complexas e análises avançadas. Veja os exemplos principais:
cliente_vip = True
• Lista (list): são coleções ordenadas de itens que podem ser de diferentes
# números quebrados, ou decimais tipos. O endereço de cada elemento em uma lista é chamado de índice, que é
valor_carteira = 13.25 usado para acessar e referir-se aos itens de uma lista. Elas são mutáveis, o
que significa que seus valores podem ser alterados após a criação.

Funções minha_lista = [1, 2, 3, 'quatro', 5.0]

Outro conceito importante que precisamos lembrar são as funções. Elas permitem • Tupla (tuple): assim como Listas, Tupla é um tipo que agrupa um conjunto de
agrupar um conjunto de instruções que executam uma tarefa específica mais de elementos variados. A diferença para Lista é que Tuplas são imutáveis, ou
uma vez. Ajudam também a separar nosso código em blocos mais fáceis de seja, uma vez criadas, suas entradas não podem ser modificadas. Um índice
entender. Veja exemplos: também é usado para acessar e referir-se aos itens de uma tupla.

# Definição de uma função simples que soma dois números minha_tupla = (1, 2, 3, 'quatro', 5.0)
def soma(valor_um, valor_dois):
return valor_um + valor_dois • Dicionário (dict): eles são utilizados para agrupar elementos através da
estrutura de chave e valor, onde a chave é o primeiro elemento, que deve ser
imutável e único, associada a um valor.
# Chamada da função
resultado = soma(3, 5) meu_dicionario = {'nome': 'Daenerys Targaryen', 'idade': 20}
print(resultado) # Saída: 8

# somando dois números de texto

print(soma("1","2") # Saída: "12" em texto!

# somando texto e número

print(soma("José", 13)) # Dá erro! Os tipos são diferentes :(
 13

Além de conhecer as estruturas de dados, você também precisa saber controlar o

fluxo de execução, usando estruturas de controle: Módulos, Pacotes e Bibliotecas
# Estrutura de controle if-else
# Dica: caso algo for verdadeiro, execute determinado bloco de código; caso contrário,
Por fim, em Python, podemos usar módulos, pacotes e bibliotecas para organizar e
execute outro. reutilizar código. Entenda o que é cada um deles.
idade = 20

if idade >= 18: • Módulos: um módulo é um único arquivo Python que pode conter definições
print("Maior de idade") de funções, classes e variáveis, bem como código executável. Por exemplo:
else: O módulo math fornece funções matemáticas como sin(), que calcula o seno
print("Menor de idade") de uma tangente matemática, e cos(), que calcula o cosseno.
• Pacotes: um pacote é uma coleção de módulos organizados em diretórios que
# Estrutura de controle for loop fornecem uma hierarquia de namespace. Um pacote é simplesmente um
# Dica: rode para todos os itens dentro de um contexto diretório que contém um arquivo especial chamado __init__.py e um ou mais
for i in range(5): módulos. Por exemplo:
print(i) O pacote collections contém tipos de dados especializados como deque,
Counter, OrderedDict etc.
# Estrutura de controle while loop • Bibliotecas: uma biblioteca é uma coleção de módulos e pacotes que
# Dica: rode enquanto uma sentença for verdadeira fornecem funcionalidades específicas e que podem ser reutilizadas em
contador = 0 diferentes projetos. Bibliotecas podem ser instaladas e gerenciadas usando
while contador < 5: ferramentas como pip, que é o gerenciador de pacotes padrão do Python. Por
print(contador) exemplo:
contador += 1 As bibliotecas NumPy e Pandas fornecem funcionalidades avançadas para
manipulação e análise de dados, que utilizaremos ao longo da trilha, inclusive.
# Estrutura de controle try-except:
# Dica: tente fazer, se der errado, faça outra coisa sem explodir tudo
try:
resultado = 10 / 0
except ZeroDivisionError:
print("Erro: Divisão por zero!")
 14

Foto de tohamina
disponível no Freepik.
Editada pelo autor.

Aula 2 - Ferramentas essenciais

 15

2.1 Criação e Manipulação de Arrays

com NumPy
O que é NumPy?

O Python oferece ferramentas poderosas para análise de dados, sendo o

NumPy uma das principais. Essa biblioteca permite manipular dados
multidimensionais e realizar operações matemáticas avançadas de forma
simples e eficiente.

Estrutura de Dados: Arrays

O NumPy utiliza arrays, que são mais rápidos e consomem menos memória que
as listas tradicionais do Python. Além disso, o NumPy fornece uma ampla gama
de funções matemáticas e científicas.

A seguir, temos um código que compara a criação de listas usando o Python

nativo e o numpy, respectivamente, avaliando a performance dos dois (você
pode executar isso no Jupyter Notebook na sua máquina para tirar a prova!):
 16

# instalando o numpy! #### Mãos à obra!

!pip install numpy # Avaliando tempo para criar uma lista usando Python
python_tempo_decorrido = timeit.timeit(cria_lista_em_python, number=1)
import timeit
import sys # Avaliando o tempo para criar uma lista usando NumPy
import numpy as np numpy_tempo_decorrido = timeit.timeit(cria_lista_numpy, number=1)

# Esse código vai criar duas listas: # Usa as funções para saber o tamanho em memória das listas em megabytes
# Uma, usando listas nativas do python, outra usando o numpy. tamanho_lista_python =
# Depois, vê o tempo decorrido para criá-las e o tamanho em memória! avalia_tamanho_da_lista_em_python(cria_lista_em_python())
tamanho_lista_numpy = avalia_tamanho_da_lista_em_numpy(cria_lista_numpy())
# Função que avalia o tamanho da lista em memória para numpy
def avalia_tamanho_da_lista_em_numpy(lista): # Imprime o tempo decorrido e o espaço necessário para criar as listas nos dois
return f'{lista.nbytes / (1024 * 1024):.3f}' cenários
print('Tempo decorrido para criar as listas:')
# Função que avalia o tamanho da lista em memória para listas Python print('-> Python:')
def avalia_tamanho_da_lista_em_python(lista): print(f' - Tempo de execução: {python_tempo_decorrido:.4f} segundos')
list_size = sys.getsizeof(lista) print(f' - Espaço em memória: {tamanho_lista_python} MB')
element_size = sys.getsizeof(0) print()
total_elements_size = len(lista) * element_size print('-> NumPy:')
return f'{(list_size + total_elements_size) / (1024 * 1024):.3f}' print(f' - Tempo de execução: {numpy_tempo_decorrido:.4f} segundos')
print(f' - Espaço em memória: {tamanho_lista_numpy} MB')
# Função para criar uma lista em Python
def cria_lista_em_python():
return [i for i in range(1_000_000 + 1)]
Nesse caso, a saída foi a seguinte:
# Função para criar uma lista em NumPy
def cria_lista_numpy():
return np.arange(0, 1_000_000 + 1, dtype=‘int64')
 17

Veja que a criação do array com o NumPy foi muito mais rápida, usando apenas Saída:
uma fração da memória. Para tarefas e aplicações com uso intensivo de dados
que exigem cálculos numéricos rápidos, o aproveitamento do NumPy pode levar
a acelerações significativas e utilização mais eficiente de recursos. Criação de arrays multidimensionais ou matrizes
# Criando uma matrix quadrada de 3x3 elementos, de 1 a 9
Além disso, podemos fazer muito mais com o NumPy. Veja alguns exemplos. matrix = np.arange(1., 10.).reshape((3, 3))
print(matrix)

Criação de um array de inteiros

import numpy as np
Saída:
arr = np.array([1, 2, 3, 4, 5])
print(f"Elementos: {arr}, Tipo dos elementos: {arr.dtype}, Tamanho do array: Nesse caso, primeiro criamos um array da sequência de números de 1 a 9, com o
{arr.shape}") tipo ponto flutuante, utilizando o “arange”, e em seguida transformamos o
formato desse array para uma matriz de 3 colunas por 3 linhas, usando o
Saída: "reshape”.

Operações matemáticas de forma eficiente em vetores

Indexação e fatiamento
a = np.array([1.0, 2.0, 3.0])
# acesso ao terceiro elemento do array (índice 2): b = 2.0
elemento = arr[2] # Lembra que o índice começa sempre do zero!
print("Elemento:", elemento) resultado = a * b
print("Resultado da multiplicação do vetor:", resultado)
Saída:
Saída:
# obtendo um subconjunto de elementos de índice 1 a 3
subset = arr[1:4]
print("Subconjunto:", subset)
 18

2.2 Pandas: Series e DataFrames

Enquanto o NumPy permite a manipulação de dados em forma de

arrays, o Pandas expande esses conceitos para a manipulação de
conjuntos de dados completos. Os dois elementos principais que
compõem o Pandas são as Series e os Dataframes. Entenda o que é
cada um deles.

Séries
É um arranjo unidimensional, como uma Lista. Ao aplicar alguma
função em uma Serie, ela é aplicada a todos os seus elementos. Para
melhor visualizar na mente, uma série é parecida com uma coluna no
excel. Eles podem ser organizados de acordo com um índice, que
funciona como os rótulos das linhas da sua planilha.

Existem muitas maneiras diferentes de criar uma Serie no Pandas.

Vamos começar criando uma série a partir de listas.

Primeiro, importe a biblioteca pandas como pd, defina uma lista

Python com os nomes ou valores que você quer ter na coluna do seu
dataframe e em seguida transforme esta lista em uma série do
Pandas.
 19

import pandas as pd Dataframe

cidades = ["São Paulo (SP)", "Manaus (AM)", "Brasília (DF)"]

Um Dataframe é composto por linhas e colunas. Para criar um DataFrame,
cidades_serie = pd.Series(cidades)
podemos usar um dicionário, no qual as chaves representam os nomes das
print(cidades_serie)
colunas, e os valores representam os dados. Os índices dos registros estão
à esquerda, de 0 a 2. Também notamos na parte superior os nomes das
colunas, 'cidade' e 'população':
import pandas as pd

cidades_serie = pd.Series([
Saída: "São Paulo (SP)",
"Manaus (AM)",
Assim como nos arrays, conseguimos acessar um índice: "Brasília (DF)"
])
cidades_serie[2]
populacoes_serie = pd.Series([
12.0,
Saída: 6.5,
3.0
])
Ou acessar uma faixa de índices:
cidades_populosas = pd.DataFrame({
print(cidades_serie[:2]) 'Cidade': cidades_serie,
'População em milhões': populacoes_serie
})

print(cidades_populosas)

Saída:

Saída:
 20

Acessando apenas uma Coluna Calculando a média de uma coluna

print(cidades_populosas['Cidade']) media_populacao = cidades_

populosas['População em milhões'].mean()
print("Média de população:", f'{media_populacao:.2f}', 'milhões de
habitantes')
Saída:

Acessando uma faixa de elementos com o método iloc[ ] Saída:

print(cidades_populosas.iloc[:2])
Adicionando uma nova coluna de números como texto
Quando estamos trabalhando com um DataFrame, muitas vezes temos a
necessidade de adicionar novas informações. Para fazer isso no Pandas,
Saída: basta criar uma nova coluna e atribuir os novos elementos:
# Aqui é texto! Lembre-se disso, depois a gente vai converter! :D
area_urbana = ['914', '640', '590']
cidades_populosas['Área urbana em km²'] = area_urbana
print(cidades_populosas)
Os dois pontos indicam que queremos selecionar um intervalo de linhas. O
número antes dos dois pontos (omitido neste caso) representa o índice
inicial (que, por padrão é 0). O número após os dois pontos (2) representa o
índice final (exclusivo), ou seja, a seleção vai até a linha de índice 1 (segunda
linha).
Saída:
 21

Multiplicando valores de uma coluna

Para mudar a escala de representação numérica de uma coluna, podemos Efetuando cálculos sobre uma coluna
criar uma outra coluna e multiplicar os valores por um fator único. Aqui, vamos Com as duas colunas nos formatos e tipos corretos, conseguimos criar uma
representar a população de cada cidade com o número completo e adicionar nova coluna, adicionando ao nosso conjunto de dados a informação sobre a
no nosso dataframe: quantidade de habitantes por km² em cada cidade:
valor_bruto = cidades_populosas['População em milhões'] * 1_000_000 habitantes_km = cidades_populosas['População em milhões'] /
cidades_populosas['População - valor bruto'] = valor_bruto cidades_populosas['Área urbana em km²']
print(cidades_populosas)
cidades_populosas['Habitantes por km²'] = habitantes_km

Saída:

Saída:

Modificando o Tipo de dado de uma coluna

Quando adicionamos as informações sobre a área urbana, lembra que usamos
uma lista de números como texto? Mas, para realizar o cálculo, iremos
transformar o tipo da coluna para inteiros usando o método 'astype' na coluna
e colocando no lugar da antiga.

int_area_urbana = cidades_populosas['Área urbana em km²'].astype(int)

cidades_populosas['Área urbana em km²'] = int_area_urbana
 22

Explore mais!

Pratique Python com exercícios simples, disponibilizados pela

comunidade Phyton Brasil. Clique aqui.

Leia o livro Python Para Análise de Dados: Tratamento de Dados com

Pandas, NumPy & Jupyter de Wes McKinney, para estudar mais sobre
Python e análise de dados.

MyCompiler é uma ferramenta prática ideal para testar rapidamente

pequenos trechos de código sem configurar um ambiente de
desenvolvimento completo, ótimo para revisões. Clique aqui.

Assista ao tutorial Introduction to Numerical Computing with NumPy,

apresentado por Alex Chabot-Leclerc e aprofunde como funciona o NumPy.
Ele aborda funções da biblioteca e aprofunda conceitos e execuções. Clique
aqui.

Acesse o guia PEP-8. Ele cobre convenções de nomenclatura, formatação de

código, e boas práticas de escrita, essenciais para garantir código limpo,
legível e consistente em projetos de Python. Clique aqui.
 23

Referências bibliográficas
Array objects — NumPy v1.26 manual (2024). Disponível em: <https:// SILVA, Andressa. Por onde começar em Análise de Dados. Disponível em:
numpy.org/doc/stable/reference/arrays.html>. Acesso em: 15 abr. 2024. <https://medium.com/data-hackers/por-onde-come%C3%A7ar-em-
an%C3%A1lise-de-dados-a0793af9b6c8>. Acesso em: 24 jul. 2024.

DataFrame — Pandas 2.2.2 documentation (2024). Disponível em: <https://

pandas.pydata.org/docs/reference/frame.html>. Acesso em: 22 abr. 2024.

Executando o Notebook [s.d]. Project Jupyter documentation. Disponível em:

<https://docs.jupyter.org/pt-br/latest/running.html> Acesso em: 15 abr.
2024.

NumPy C-API — NumPy v1.26 manual (2024). Disponível em: <https://

numpy.org/doc/stable/reference/c-api/index.html>. Acesso em: 15 abr. 2024.

Python para quem está começando [s.d]. Python Brasil. Disponível em:
<https://python.org.br/introducao/>. Acesso em: 15 abr. 2024.

Routines — NumPy v1.26 manual (2024). Disponível em: <https://numpy.org/

doc/stable/reference/routines.html>. Acesso em: 17 abr. 2024.

Series — Pandas 2.2.2 documentation (2024). Disponível em: <https://

pandas.pydata.org/docs/reference/series.html>. Acesso em: 18 abr. 2024.