NumPy para análise de dados

Guia Prático de NumPy para Análise de Dados

by

Descubra NumPy para análise de dados, a ferramenta essencial em Python que simplifica o trabalho com números e informações. Ideal tanto para iniciantes quanto para especialistas em análise de dados, este guia oferece um roteiro prático e objetivo. Explore como manipular arrays, realizar cálculos complexos com facilidade e utilizar as poderosas ferramentas do NumPy para análise de dados. Para solidificar o aprendizado, finalize com um mini-projeto prático. Aventure-se no universo do NumPy erevele todo o seu potencial!

Preparando o Ambiente

Antes de começarmos a explorar o NumPy, é crucial configurar o ambiente para executar os exemplos de código e o mini-projeto. Veja como preparar tudo:

  1. Instale o Python: Se o Python ainda não estiver instalado, baixe-o em python.org. Durante a instalação, certifique-se de marcar a opção de adicionar o Python ao seu PATH, facilitando o uso no terminal.
  2. Instale o NumPy: Abra o terminal (ou o Command Prompt no Windows) e execute o seguinte comando: 
   pip install numpy

Este comando instrui o gerenciador de pacotes do Python (pip) a buscar e instalar o NumPy.

  1. Escolha um editor de código: Selecione uma ferramenta para escrever seu código. Algumas opções incluem:
    • IDLE: Já vem com o Python. Basta procurá-lo após a instalação.
    • VS Code: Um editor gratuito e popular, disponível em code.visualstudio.com.
    • Ou qualquer editor de texto de sua preferência!
  2. Teste a instalação: Para confirmar se tudo está funcionando, crie um arquivo (por exemplo, test.py) no seu editor e adicione o seguinte: 
   import numpy as np
   print(np.__version__)

Ao executar o arquivo, se um número de versão for exibido (como 1.26.4), significa que está tudo pronto para começar!

Com o ambiente configurado, podemos mergulhar no NumPy!

O que é NumPy?

NumPy é uma biblioteca Python essencial para computação numérica. Ela oferece uma estrutura de dados especial chamada ndarray (n-dimensional array), que é mais rápida e eficiente do que as listas tradicionais do Python. É uma base fundamental para análise de dados em Python e funciona perfeitamente com bibliotecas como Pandas e Matplotlib.

Para começar a usar o NumPy no seu código, importe-o da seguinte forma:

import numpy as np  # 'np' é o atalho comum

Por que usar NumPy?

Antes de prosseguirmos, é importante entender por que o NumPy é tão valioso:

  • Velocidade: Incrivelmente rápido para cálculos, otimizando o trabalho.
  • Facilidade: Dispensa o uso de loops complexos, pois o NumPy cuida do trabalho pesado.
  • Poder: Oferece uma variedade de funções integradas para simplificar a análise de dados.

Com esses benefícios em mente, vamos ver o que o NumPy pode fazer!

Criando Arrays NumPy

Os arrays são a base do NumPy, e exploraremos diversas maneiras de criá-los.

A partir de uma lista

Podemos transformar uma lista Python comum em um array NumPy para começar a trabalhar com ela.

# Transformando uma lista em um array 1D
array = np.array([1, 2, 3, 4])
print(array)

Entendendo o código:

  • np.array() transforma a lista em um array NumPy.
  • Saída: [1 2 3 4] — um array 1D, como uma única linha de números.

Array 2D (Matriz)

Também podemos construir um array 2D, que se assemelha a uma grade ou matriz, usando uma lista de listas.

# Construindo um array 2D com linhas e colunas
array_2d = np.array([[1, 2], [3, 4]])
print(array_2d)

Entendendo o código:

  • Cada lista interna se torna uma linha no array 2D.
  • Saída: 
  [[1 2]
   [3 4]]
  • Isso nos dá uma matriz 2×2.

Arrays Especiais

O NumPy permite gerar rapidamente arrays com padrões específicos, como todos zeros, uns ou uma sequência.

# Gerando um array de zeros
zeros = np.zeros((2, 3))  # 2 linhas, 3 colunas
print(zeros)

# Gerando um array de uns
ones = np.ones((3, 2))   # 3 linhas, 2 colunas
print(ones)

# Gerando um intervalo de números
range_array = np.arange(0, 10, 2)  # Começa em 0, para antes de 10, incrementa de 2 em 2
print(range_array)

Entendendo o código:

  • np.zeros((2, 3)): Retorna um array 2×3 preenchido com 0.0.
    • Saída: [[0. 0. 0.] [0. 0. 0.]]
  • np.ones((3, 2)): Cria um array 3×2 de 1.0.
    • Saída: [[1. 1.] [1. 1.] [1. 1.]]
  • np.arange(0, 10, 2): Produz [0 2 4 6 8], similar ao range() do Python, mas como um array.

Arrays Aleatórios

Para testes ou simulações, podemos gerar arrays com valores aleatórios.

# Gerando números de ponto flutuante aleatórios entre 0 e 1
random_array = np.random.rand(2, 2)  # Array 2x2
print(random_array)

Entendendo o código:

  • np.random.rand(2, 2): Cria um array 2×2 de números aleatórios entre 0 e 1.
  • Saída: Algo como [[0.45 0.12] [0.78 0.33]] (os valores serão diferentes a cada execução).

Propriedades do Array

Entender a estrutura do array é crucial para análise. Vamos examinar algumas propriedades úteis.

# Configurando um array 2D
array = np.array([[1, 2, 3], [4, 5, 6]])

# Verificando o formato: linhas e colunas
print("Shape:", array.shape)  # (2, 3)

# Verificando o número total de elementos
print("Size:", array.size)   # 6

# Verificando o tipo de dado
print("Type:", array.dtype)  # int64 (ou similar)

Entendendo o código:

  • shape: (2, 3) indica que temos 2 linhas e 3 colunas.
  • size: 6 é o número total de elementos (2 * 3).
  • dtype: int64 indica que os elementos são números inteiros.

Operações Básicas

O NumPy simplifica a matemática com as chamadas operações vetorizadas, que permitem evitar o uso de loops!

Operações Elemento a Elemento

Podemos aplicar operações a cada elemento em um array com facilidade.

# Adicionando 2 a cada elemento
a = np.array([1, 2, 3])
print(a + 2)  # [3 4 5]

# Multiplicando cada elemento por 3
print(a * 3)  # [3 6 9]

Entendendo o código:

  • a + 2: Adiciona 2 a cada elemento: [1+2, 2+2, 3+2].
  • a * 3: Multiplica cada elemento: [1*3, 2*3, 3*3].

Operações Array a Array

Também podemos combinar dois arrays elemento a elemento.

# Adicionando dois arrays juntos
b = np.array([4, 5, 6])
print(a + b)  # [5 7 9]

# Multiplicando dois arrays
print(a * b)  # [4 10 18]

Entendendo o código:

  • a + b: Realiza a adição elemento a elemento: [1+4, 2+5, 3+6].
  • a * b: Realiza a multiplicação elemento a elemento: [1*4, 2*5, 3*6].

Operações com Matrizes

Para arrays 2D, podemos realizar operações específicas de matrizes, como transposição ou multiplicação.

# Configurando uma matriz 2x2
matrix = np.array([[1, 2], [3, 4]])

# Transpondo (trocando linhas e colunas)
print(matrix.T)

# Realizando a multiplicação de matrizes
print(np.dot(matrix, matrix))

Entendendo o código:

  • matrix.T: Inverte [[1 2] [3 4]] para [[1 3] [2 4]].
  • np.dot(): Multiplica a matriz por ela mesma, resultando em:
    • Saída: [[7 10] [15 22]].

Funções Essenciais para Análise de Dados

Vamos explorar as poderosas funções do NumPy que facilitam a análise de dados.

Indexação e Slicing

Podemos acessar partes específicas dos nossos arrays usando indexação e slicing.

# Trabalhando com um array 1D
array = np.array([10, 20, 30, 40])
print(array[1])      # 20 (2º elemento)
print(array[1:3])    # [20 30] (elementos 2 a 3)

# Trabalhando com um array 2D
array_2d = np.array([[1, 2, 3], [4, 5, 6]])
print(array_2d[0, 1])  # 2 (linha 1, coluna 2)
print(array_2d[:, 1])  # [2 5] (todas as linhas, coluna 2)

Entendendo o código:

  • array[1]: Recupera o elemento no índice 1.
  • array[1:3]: Obtém os elementos do índice 1 até o 2.
  • array_2d[0, 1]: Busca a linha 0, coluna 1.
  • array_2d[:, 1]: : seleciona todas as linhas, 1 escolhe a coluna 1.

Funções Estatísticas

O NumPy oferece ferramentas práticas para resumir nossos dados estatisticamente.

# Analisando um conjunto de dados simples
data = np.array([1, 2, 3, 4, 5])
print(np.mean(data))    # 3.0 (média)
print(np.median(data))  # 3.0 (valor do meio)
print(np.std(data))     # 1.414... (dispersão)
print(np.min(data))     # 1 (menor)
print(np.max(data))     # 5 (maior)

Entendendo o código:

  • mean: Calcula a média, somando todos os valores e dividindo pela contagem.
  • median: Encontra o valor do meio quando os dados são ordenados.
  • std: Mede a dispersão dos dados.
  • min/max: Identifica os valores mínimo e máximo.

Filtrando com np.where()

Podemos filtrar nossos dados ou substituir valores com base em condições usando np.where().

# Filtrando valores maiores que 3
data = np.array([1, 5, 3, 6, 2])
indices = np.where(data > 3)
print(indices)        # (array([1, 3]),)
print(data[indices])  # [5 6]

# Substituindo valores > 3 por 10
data_new = np.where(data > 3, 10, data)
print(data_new)  # [ 1 10  3 10  2]

Entendendo o código:

  • np.where(data > 3): Retorna os índices [1, 3] onde os valores excedem 3.
  • data[indices]: Extrai esses valores: [5, 6].
  • np.where(condition, x, y): Usa x (10) onde a condição é verdadeira, caso contrário, mantém y (valor original).

Remodelando Arrays

Às vezes, precisamos mudar o formato de um array para ajustar à nossa análise, e reshape() nos ajuda a fazer isso.

# Remodelando um array 1D em 2D
array = np.arange(6)  # [0 1 2 3 4 5]
reshaped = array.reshape(2, 3)
print(reshaped)

Entendendo o código:

  • reshape(2, 3): Transforma 6 elementos em um array 2×3:
    • Saída: [[0 1 2] [3 4 5]].

Ordenação

Podemos organizar nossos dados em ordem usando sort().

# Ordenando um array não ordenado
unsorted = np.array([3, 1, 4, 2])
print(np.sort(unsorted))  # [1 2 3 4]

Entendendo o código:

  • np.sort(): Organiza o array do menor para o maior.

Valores Únicos

Para encontrar valores distintos em nossos dados, usamos unique().

# Encontrando valores únicos
data = np.array([1, 2, 2, 3, 1])
print(np.unique(data))  # [1 2 3]

Entendendo o código:

  • np.unique(): Remove duplicatas e ordena o resultado.

Agregação

Podemos resumir nossos dados, como somar valores, com funções de agregação.

# Resumindo um array 2D

array_2d = np.array([[

Leave a Comment

Exit mobile version