Arquivo de Análise de Dados - Página 3 de 12

Regularização Min-Max Scaling no Python

19/12/202520/09/2025 Por antonino

O Min-Max Scaling é uma técnica de pré-processamento de dados que transforma features (características) escalando cada feature para um range específico, geralmente [0, 1]. É uma das técnicas de normalização mais comuns em aprendizado de máquina.

O que é Min-Max Scaling?

Min-Max Scaling é um método de normalização que transforma os dados redimensionando-os para um intervalo fixo, normalmente [0, 1]. A transformação é dada pela fórmula:

$X_{\text{scaled}} = \frac{X – X_{\text{min}}}{X_{\text{max}} – X_{\text{min}}}$

Onde:

$X$ é o valor original
$X_{\text{min}}$ é o valor mínimo da feature
$X_{\text{max}}$ é o valor máximo da feature
$X_{\text{scaled}}$ é o valor normalizado

Implementação manual em Python:

import numpy as np

def min_max_scaling_manual(data):
    """Implementação manual do Min-Max Scaling"""
    data = np.array(data)
    min_val = np.min(data)
    max_val = np.max(data)
    scaled_data = (data - min_val) / (max_val - min_val)
    return scaled_data, min_val, max_val

# Dados de exemplo
dados_originais = [10, 20, 30, 40, 50]
dados_normalizados, min_val, max_val = min_max_scaling_manual(dados_originais)

print("Dados originais:", dados_originais)
print("Valor mínimo:", min_val)
print("Valor máximo:", max_val)
print("Dados normalizados:", dados_normalizados)

import numpy as np

def min_max_scaling_manual(data):

"""Implementação manual do Min-Max Scaling"""

data = np.array(data)

min_val = np.min(data)

max_val = np.max(data)

scaled_data = (data - min_val) / (max_val - min_val)

return scaled_data, min_val, max_val

# Dados de exemplo

dados_originais = [10, 20, 30, 40, 50]

dados_normalizados, min_val, max_val = min_max_scaling_manual(dados_originais)

print("Dados originais:", dados_originais)

print("Valor mínimo:", min_val)

print("Valor máximo:", max_val)

print("Dados normalizados:", dados_normalizados)

Em R, podemos implementar Min-Max Scaling similarmente:

# Implementação manual do Min-Max Scaling em R
min_max_scaling_manual <- function(data) {
  min_val <- min(data)
  max_val <- max(data)
  scaled_data <- (data - min_val) / (max_val - min_val)
  return(list(scaled_data = scaled_data, min_val = min_val, max_val = max_val))
}

# Dados de exemplo
dados_originais <- c(10, 20, 30, 40, 50)
resultado <- min_max_scaling_manual(dados_originais)

print(paste("Dados originais:", paste(dados_originais, collapse = ", ")))
print(paste("Valor mínimo:", resultado$min_val))
print(paste("Valor máximo:", resultado$max_val))
print(paste("Dados normalizados:", paste(round(resultado$scaled_data, 3), collapse = ", ")))

# Implementação manual do Min-Max Scaling em R

min_max_scaling_manual <- function(data) {

min_val <- min(data)

max_val <- max(data)

scaled_data <- (data - min_val) / (max_val - min_val)

return(list(scaled_data = scaled_data, min_val = min_val, max_val = max_val))

}

# Dados de exemplo

dados_originais <- c(10, 20, 30, 40, 50)

resultado <- min_max_scaling_manual(dados_originais)

print(paste("Dados originais:", paste(dados_originais, collapse = ", ")))

print(paste("Valor mínimo:", resultado$min_val))

print(paste("Valor máximo:", resultado$max_val))

print(paste("Dados normalizados:", paste(round(resultado$scaled_data, 3), collapse = ", ")))

Implementação com Scikit-Learn

Usando MinMaxScaler

A biblioteca Scikit-Learn fornece a classe MinMaxScaler que implementa eficientemente a normalização Min-Max:

from sklearn.preprocessing import MinMaxScaler
import numpy as np

# Dados de exemplo
dados = np.array([[10], [20], [30], [40], [50]])

# Criando e ajustando o scaler
scaler = MinMaxScaler()
scaler.fit(dados)

# Transformando os dados
dados_normalizados = scaler.transform(dados)

print("Dados originais:")
print(dados)
print("\nDados normalizados:")
print(dados_normalizados)
print("\nValor mínimo aprendido:", scaler.data_min_)
print("Valor máximo aprendido:", scaler.data_max_)

# Transformando novos dados
novos_dados = np.array([[15], [25], [35]])
novos_dados_normalizados = scaler.transform(novos_dados)
print("\nNovos dados normalizados:")
print(novos_dados_normalizados)

from sklearn.preprocessing import MinMaxScaler

import numpy as np

# Dados de exemplo

dados = np.array([[10], [20], [30], [40], [50]])

# Criando e ajustando o scaler

scaler = MinMaxScaler()

scaler.fit(dados)

# Transformando os dados

dados_normalizados = scaler.transform(dados)

print("Dados originais:")

print(dados)

print("\nDados normalizados:")

print(dados_normalizados)

print("\nValor mínimo aprendido:", scaler.data_min_)

print("Valor máximo aprendido:", scaler.data_max_)

# Transformando novos dados

novos_dados = np.array([[15], [25], [35]])

novos_dados_normalizados = scaler.transform(novos_dados)

print("\nNovos dados normalizados:")

print(novos_dados_normalizados)

O MinMaxScaler também permite definir um range personalizado:

# MinMaxScaler com range personalizado (-1, 1)
scaler_custom = MinMaxScaler(feature_range=(-1, 1))
dados_custom = scaler_custom.fit_transform(dados)
print("Dados com range personalizado (-1, 1):")
print(dados_custom)

# MinMaxScaler com range personalizado (-1, 1)

scaler_custom = MinMaxScaler(feature_range=(-1, 1))

dados_custom = scaler_custom.fit_transform(dados)

print("Dados com range personalizado (-1, 1):")

print(dados_custom)

Aplicação em DataFrame Pandas

O MinMaxScaler pode ser aplicado diretamente em DataFrames do Pandas:

import pandas as pd
from sklearn.preprocessing import MinMaxScaler

# Criando DataFrame de exemplo
df = pd.DataFrame({
    'idade': [25, 30, 35, 40, 45, 50],
    'salario': [5000, 6000, 7000, 8000, 9000, 10000],
    'horas_trabalho': [40, 42, 38, 45, 40, 35]
})

print("DataFrame original:")
print(df)

# Aplicando MinMaxScaler
scaler = MinMaxScaler()
df_normalizado = pd.DataFrame(
    scaler.fit_transform(df),
    columns=df.columns,
    index=df.index
)

print("\nDataFrame normalizado:")
print(df_normalizado)

# Estatísticas do scaler
print("\nEstatísticas do scaler:")
for i, col in enumerate(df.columns):
    print(f"{col}: min={scaler.data_min_[i]:.2f}, max={scaler.data_max_[i]:.2f}")

import pandas as pd

from sklearn.preprocessing import MinMaxScaler

# Criando DataFrame de exemplo

df = pd.DataFrame({

'idade': [25, 30, 35, 40, 45, 50],

'salario': [5000, 6000, 7000, 8000, 9000, 10000],

'horas_trabalho': [40, 42, 38, 45, 40, 35]

})

print("DataFrame original:")

print(df)

# Aplicando MinMaxScaler

scaler = MinMaxScaler()

df_normalizado = pd.DataFrame(

scaler.fit_transform(df),

columns=df.columns,

index=df.index

)

print("\nDataFrame normalizado:")

print(df_normalizado)

# Estatísticas do scaler

print("\nEstatísticas do scaler:")

for i, col in enumerate(df.columns):

print(f"{col}: min={scaler.data_min_[i]:.2f}, max={scaler.data_max_[i]:.2f}")

Em R, podemos usar a função scale() com parâmetros apropriados ou o pacote caret:

# Min-Max Scaling em R usando scale()
min_max_scale <- function(x) {
  (x - min(x)) / (max(x) - min(x))
}

# Criando data frame de exemplo
df <- data.frame(
  idade = c(25, 30, 35, 40, 45, 50),
  salario = c(5000, 6000, 7000, 8000, 9000, 10000),
  horas_trabalho = c(40, 42, 38, 45, 40, 35)
)

print("Data frame original:")
print(df)

# Aplicando Min-Max Scaling
df_normalizado <- as.data.frame(lapply(df, min_max_scale))
print("Data frame normalizado:")
print(df_normalizado)

# Min-Max Scaling em R usando scale()

min_max_scale <- function(x) {

(x - min(x)) / (max(x) - min(x))

}

# Criando data frame de exemplo

df <- data.frame(

idade = c(25, 30, 35, 40, 45, 50),

salario = c(5000, 6000, 7000, 8000, 9000, 10000),

horas_trabalho = c(40, 42, 38, 45, 40, 35)

)

print("Data frame original:")

print(df)

# Aplicando Min-Max Scaling

df_normalizado <- as.data.frame(lapply(df, min_max_scale))

print("Data frame normalizado:")

print(df_normalizado)

Vantagens e Desvantagens do Min-Max Scaling

Vantagens:

Preserva a forma da distribuição original
Mantém as relações entre os valores originais
Fácil de implementar e interpretar
Não distorce as distâncias entre os valores
Ideal para dados com distribuição não-normal

Desvantagens:

Sensível a outliers (valores extremos)
Não centraliza os dados na média zero
Não reduz a variabilidade dos dados
Não é adequado quando a presença de outliers é significativa

⚠️ Cuidado com Outliers

O Min-Max Scaling é sensível a outliers pois os valores mínimo e máximo são determinados pelos valores extremos do conjunto de dados:

# Exemplo com outlier
dados_com_outlier = np.array([[10], [20], [30], [40], [50], [1000]])  # 1000 é um outlier

scaler = MinMaxScaler()
dados_com_outlier_normalizados = scaler.fit_transform(dados_com_outlier)

print("Dados com outlier:", dados_com_outlier.flatten())
print("Dados normalizados:", dados_com_outlier_normalizados.flatten().round(3))

# Exemplo com outlier

dados_com_outlier = np.array([[10], [20], [30], [40], [50], [1000]]) # 1000 é um outlier

scaler = MinMaxScaler()

dados_com_outlier_normalizados = scaler.fit_transform(dados_com_outlier)

print("Dados com outlier:", dados_com_outlier.flatten())

print("Dados normalizados:", dados_com_outlier_normalizados.flatten().round(3))

Neste caso, o outlier (1000) comprime todos os outros valores em uma faixa muito estreita próximo a zero.

Quando Usar Min-Max Scaling

Algoritmos Baseados em Distância

Use Min-Max Scaling para algoritmos que dependem de medidas de distância, como K-NN, K-Means e SVM.

# Pré-processamento para K-NN
from sklearn.neighbors import KNeighborsClassifier
from sklearn.pipeline import Pipeline

pipeline = Pipeline([
    ('scaler', MinMaxScaler()),
    ('classifier', KNeighborsClassifier())
])

# Pré-processamento para K-NN

from sklearn.neighbors import KNeighborsClassifier

from sklearn.pipeline import Pipeline

pipeline = Pipeline([

('scaler', MinMaxScaler()),

('classifier', KNeighborsClassifier())

])

Redes Neurais

Use Min-Max Scaling para normalizar inputs de redes neurais, especialmente com funções de ativação como sigmoid ou tanh.

# Pré-processamento para redes neurais
from sklearn.neural_network import MLPClassifier

pipeline = Pipeline([
    ('scaler', MinMaxScaler()),
    ('nn', MLPClassifier(hidden_layer_sizes=(100, 50)))
])

# Pré-processamento para redes neurais

from sklearn.neural_network import MLPClassifier

pipeline = Pipeline([

('scaler', MinMaxScaler()),

('nn', MLPClassifier(hidden_layer_sizes=(100, 50)))

])

Processamento de Imagens

Use Min-Max Scaling para normalizar valores de pixels (0-255) para o range 0-1.

# Normalizando pixels de imagem
from sklearn.preprocessing import MinMaxScaler

# Supondo que 'imagem' seja uma matriz de pixels (0-255)
scaler = MinMaxScaler(feature_range=(0, 1))
imagem_normalizada = scaler.fit_transform(imagem)

# Normalizando pixels de imagem

from sklearn.preprocessing import MinMaxScaler

# Supondo que 'imagem' seja uma matriz de pixels (0-255)

scaler = MinMaxScaler(feature_range=(0, 1))

imagem_normalizada = scaler.fit_transform(imagem)

Comparação com Outras Técnicas de Normalização

O Min-Max Scaling é uma entre várias técnicas de normalização. Vamos compará-lo com outras abordagens comuns:

Standardization (Z-score Normalization)

$X_{\text{standardized}} = \frac{X – \mu}{\sigma}$

Centraliza os dados na média 0
Escala para desvio padrão 1
Menos sensível a outliers
Ideal para dados com distribuição normal

Robust Scaling

$X_{\text{robust}} = \frac{X – \text{mediana}}{\text{IQR}}$

Usa mediana e IQR (Intervalo Interquartil)
Robusto a outliers
Ideal para dados com outliers significativos

Exemplo comparativo:

from sklearn.preprocessing import StandardScaler, RobustScaler, MinMaxScaler
import numpy as np

# Dados com outlier
dados = np.array([[10], [20], [30], [40], [50], [1000]])

# Aplicando diferentes técnicas
minmax_scaler = MinMaxScaler()
standard_scaler = StandardScaler()
robust_scaler = RobustScaler()

dados_minmax = minmax_scaler.fit_transform(dados)
dados_standard = standard_scaler.fit_transform(dados)
dados_robust = robust_scaler.fit_transform(dados)

print("Original:    ", dados.flatten())
print("Min-Max:     ", dados_minmax.flatten().round(3))
print("Standard:    ", dados_standard.flatten().round(3))
print("Robust:      ", dados_robust.flatten().round(3))

from sklearn.preprocessing import StandardScaler, RobustScaler, MinMaxScaler

import numpy as np

# Dados com outlier

dados = np.array([[10], [20], [30], [40], [50], [1000]])

# Aplicando diferentes técnicas

minmax_scaler = MinMaxScaler()

standard_scaler = StandardScaler()

robust_scaler = RobustScaler()

dados_minmax = minmax_scaler.fit_transform(dados)

dados_standard = standard_scaler.fit_transform(dados)

dados_robust = robust_scaler.fit_transform(dados)

print("Original: ", dados.flatten())

print("Min-Max: ", dados_minmax.flatten().round(3))

print("Standard: ", dados_standard.flatten().round(3))

print("Robust: ", dados_robust.flatten().round(3))

Conclusão

O Min-Max Scaling é uma técnica fundamental de pré-processamento de dados no machine learning. Sua simplicidade e eficácia o tornam uma escolha popular para normalizar features para um range específico, especialmente quando a distribuição original dos dados não é normal e não há outliers significativos.

Lembre-se de sempre:

Ajustar o scaler apenas com dados de treinamento
Aplicar a mesma transformação em dados de teste/validação
Considerar técnicas alternativas como StandardScaler ou RobustScaler quando houver outliers
Documentar os parâmetros de transformação para reprodutibilidade

Referências

Scikit-Learn Documentation: MinMaxScaler
Introduction to Machine Learning with Python: Andreas C. Müller & Sarah Guido
Hands-On Machine Learning with Scikit-Learn, Keras, and TensorFlow: Aurélien Géron

Análise de Valores Únicos com df.unique() no Pandas

19/12/202520/09/2025 Por antonino

O método unique() é uma função essencial na biblioteca Pandas para Python que retorna os valores únicos de uma Series (coluna) em ordem de aparecimento. É extremamente útil para análise exploratória de dados, especialmente para variáveis categóricas.

O que é df.unique()?

O método unique() retorna um array NumPy com os valores únicos de uma Series (coluna) do Pandas. Os valores são retornados na ordem em que aparecem na Series, o que preserva a sequência original.

Características importantes:

Retorna apenas valores únicos, eliminando duplicatas
Preserva a ordem de aparecimento dos valores
Funciona apenas com Series (colunas individuais), não com DataFrames completos
Ignora valores NaN por padrão (dependendo da versão do Pandas)

Exemplo básico de uso:

import pandas as pd
import numpy as np

# Criando um DataFrame de exemplo
df = pd.DataFrame({
    'fruta': ['maçã', 'banana', 'laranja', 'maçã', 'uva', 'banana', 'maçã'],
    'quantidade': [5, 3, 2, 4, 6, 3, 2],
    'cor': ['vermelho', 'amarelo', 'laranja', 'vermelho', 'roxo', 'amarelo', 'verde']
})

# Obtendo valores únicos da coluna 'fruta'
valores_unicos = df['fruta'].unique()
print("Valores únicos na coluna 'fruta':")
print(valores_unicos)
print(f"Tipo de retorno: {type(valores_unicos)}")

import pandas as pd

import numpy as np

# Criando um DataFrame de exemplo

df = pd.DataFrame({

'fruta': ['maçã', 'banana', 'laranja', 'maçã', 'uva', 'banana', 'maçã'],

'quantidade': [5, 3, 2, 4, 6, 3, 2],

'cor': ['vermelho', 'amarelo', 'laranja', 'vermelho', 'roxo', 'amarelo', 'verde']

})

# Obtendo valores únicos da coluna 'fruta'

valores_unicos = df['fruta'].unique()

print("Valores únicos na coluna 'fruta':")

print(valores_unicos)

print(f"Tipo de retorno: {type(valores_unicos)}")

Saída esperada do código acima:

Valores únicos na coluna 'fruta':
['maçã' 'banana' 'laranja' 'uva']
Tipo de retorno: &lt;class 'numpy.ndarray'&gt;

Valores únicos na coluna 'fruta':

['maçã' 'banana' 'laranja' 'uva']

Tipo de retorno: <class 'numpy.ndarray'>

Comparação com Funções Similares

unique() vs value_counts()

Enquanto unique() retorna apenas os valores únicos, value_counts() retorna tanto os valores únicos quanto suas contagens:

unique():

Retorna array com valores únicos
Preserva ordem de aparecimento
Não mostra frequências
Mais rápido para apenas obter valores distintos

value_counts():

Retorna Series com valores únicos e contagens
Ordenado por frequência (padrão)
Mostra contagem de cada valor
Mais informativo para análise estatística

Exemplo comparativo:

# Usando unique()
valores_unicos = df['fruta'].unique()
print("unique():", valores_unicos)

# Usando value_counts()
contagem_valores = df['fruta'].value_counts()
print("\nvalue_counts():")
print(contagem_valores)

# Usando unique()

valores_unicos = df['fruta'].unique()

print("unique():", valores_unicos)

# Usando value_counts()

contagem_valores = df['fruta'].value_counts()

print("\nvalue_counts():")

print(contagem_valores)

Em R, as funções equivalentes são unique() e table():

# Criando um data frame de exemplo em R
df <- data.frame(
  fruta = c('maçã', 'banana', 'laranja', 'maçã', 'uva', 'banana', 'maçã'),
  quantidade = c(5, 3, 2, 4, 6, 3, 2),
  cor = c('vermelho', 'amarelo', 'laranja', 'vermelho', 'roxo', 'amarelo', 'verde')
)

# Usando unique() em R
valores_unicos <- unique(df$fruta)
print("Valores únicos:")
print(valores_unicos)

# Usando table() em R
contagem_valores <- table(df$fruta)
print("Contagem de valores:")
print(contagem_valores)

# Criando um data frame de exemplo em R

df <- data.frame(

fruta = c('maçã', 'banana', 'laranja', 'maçã', 'uva', 'banana', 'maçã'),

quantidade = c(5, 3, 2, 4, 6, 3, 2),

cor = c('vermelho', 'amarelo', 'laranja', 'vermelho', 'roxo', 'amarelo', 'verde')

)

# Usando unique() em R

valores_unicos <- unique(df$fruta)

print("Valores únicos:")

print(valores_unicos)

# Usando table() em R

contagem_valores <- table(df$fruta)

print("Contagem de valores:")

print(contagem_valores)

unique() vs nunique()

Enquanto unique() retorna os valores únicos, nunique() retorna apenas a contagem de valores únicos:

unique():

Retorna os valores únicos
Útil quando precisamos dos valores específicos
Permite iterar sobre os valores distintos

nunique():

Retorna apenas o número de valores únicos
Útil para estatísticas rápidas
Mais eficiente quando só precisamos da contagem

Exemplo comparativo:

# Usando unique() para obter os valores
valores_unicos = df['fruta'].unique()
print("Valores únicos:", valores_unicos)
print("Número de valores únicos:", len(valores_unicos))

# Usando nunique() para obter apenas a contagem
numero_unicos = df['fruta'].nunique()
print("Número de valores únicos (com nunique()):", numero_unicos)

# Usando unique() para obter os valores

valores_unicos = df['fruta'].unique()

print("Valores únicos:", valores_unicos)

print("Número de valores únicos:", len(valores_unicos))

# Usando nunique() para obter apenas a contagem

numero_unicos = df['fruta'].nunique()

print("Número de valores únicos (com nunique()):", numero_unicos)

Em R, podemos usar length(unique()) para obter o equivalente a nunique():

# Número de valores únicos em R
numero_unicos <- length(unique(df$fruta))
print(paste("Número de valores únicos:", numero_unicos))

# Número de valores únicos em R

numero_unicos <- length(unique(df$fruta))

print(paste("Número de valores únicos:", numero_unicos))

Aplicações Práticas do unique()

O método unique() é extremamente útil em diversas situações de análise de dados:

1. Análise de Variáveis Categóricas

Identificar todas as categorias presentes em uma variável:

# Analisando categorias em uma coluna
categorias = df['cor'].unique()
print("Cores disponíveis:", categorias)

# Analisando categorias em uma coluna

categorias = df['cor'].unique()

print("Cores disponíveis:", categorias)

2. Criação de Mapas de Valores

Usar os valores únicos para criar dicionários de mapeamento:

# Criando um mapeamento de valores
valores_unicos = df['fruta'].unique()
mapeamento = {valor: idx for idx, valor in enumerate(valores_unicos)}
print("Mapeamento:", mapeamento)

# Criando um mapeamento de valores

valores_unicos = df['fruta'].unique()

mapeamento = {valor: idx for idx, valor in enumerate(valores_unicos)}

print("Mapeamento:", mapeamento)

3. Filtragem de Dados

Usar valores únicos para filtrar o DataFrame:

# Filtrando para incluir apenas certos valores
valores_permitidos = ['maçã', 'uva']
df_filtrado = df[df['fruta'].isin(valores_permitidos)]

# Filtrando para incluir apenas certos valores

valores_permitidos = ['maçã', 'uva']

df_filtrado = df[df['fruta'].isin(valores_permitidos)]

Em R, aplicações similares com unique():

# Análise de categorias
categorias <- unique(df$cor)
print(paste("Cores disponíveis:", paste(categorias, collapse = ", ")))

# Filtragem de dados
valores_permitidos <- c('maçã', 'uva')
df_filtrado <- df[df$fruta %in% valores_permitidos, ]

# Análise de categorias

categorias <- unique(df$cor)

print(paste("Cores disponíveis:", paste(categorias, collapse = ", ")))

# Filtragem de dados

valores_permitidos <- c('maçã', 'uva')

df_filtrado <- df[df$fruta %in% valores_permitidos, ]

Quando Usar df.unique()

Análise Exploratória de Dados

Use unique() para entender rapidamente as categorias presentes em uma coluna.

# Explorando categorias em uma coluna
print("Departamentos únicos:", df['departamento'].unique())
print("Cargos únicos:", df['cargo'].unique())

# Explorando categorias em uma coluna

print("Departamentos únicos:", df['departamento'].unique())

print("Cargos únicos:", df['cargo'].unique())

Pré-processamento de Dados

Use unique() para identificar valores que precisam ser tratados antes da modelagem.

# Identificando valores problemáticos
valores_unicos = df['idade'].unique()
valores_estranhos = [v for v in valores_unicos if not isinstance(v, (int, float)) or v < 0 or v > 120]
print("Valores problemáticos na coluna 'idade':", valores_estranhos)

# Identificando valores problemáticos

valores_unicos = df['idade'].unique()

valores_estranhos = [v for v in valores_unicos if not isinstance(v, (int, float)) or v < 0 or v > 120]

print("Valores problemáticos na coluna 'idade':", valores_estranhos)

Criação de Variáveis Dummy

Use unique() para identificar todas as categorias necessárias para criar variáveis dummy.

# Preparando para one-hot encoding
categorias = df['categoria'].unique()
print("Categorias para encoding:", categorias)

# Preparando para one-hot encoding

categorias = df['categoria'].unique()

print("Categorias para encoding:", categorias)

Em R, uso similar para one-hot encoding:

# Preparando para criar variáveis dummy
categorias <- unique(df$categoria)
print(paste("Categorias para encoding:", paste(categorias, collapse = ", ")))

# Preparando para criar variáveis dummy

categorias <- unique(df$categoria)

print(paste("Categorias para encoding:", paste(categorias, collapse = ", ")))

Exemplo Prático Completo

Vamos explorar um exemplo prático de uso do unique() em um conjunto de dados mais complexo:

import pandas as pd
import numpy as np

# Criando um DataFrame mais complexo com dados missing
np.random.seed(42)
dados = {
    'id': range(1, 21),
    'idade': np.random.randint(18, 70, 20),
    'cidade': np.random.choice(['São Paulo', 'Rio de Janeiro', 'Belo Horizonte', 'Curitiba', None], 20),
    'nível_educacional': np.random.choice(['Fundamental', 'Médio', 'Superior', 'Pós-graduação', None], 20),
    'salário': np.random.normal(5000, 2000, 20)
}

df = pd.DataFrame(dados)

# Adicionando alguns outliers no salário
df.loc[::5, 'salário'] = df.loc[::5, 'salário'] * 3

print("Primeiras linhas do DataFrame:")
print(df.head())

print("\n" + "="*50)
print("ANÁLISE COM unique()")
print("="*50)

# Analisando valores únicos em cada coluna categórica
print("\n1. Valores únicos na coluna 'cidade':")
cidades_unicas = df['cidade'].unique()
print(cidades_unicas)

print("\n2. Valores únicos na coluna 'nível_educacional':")
niveis_unicos = df['nível_educacional'].unique()
print(niveis_unicos)

print("\n3. Número de valores únicos por coluna:")
for coluna in df.columns:
    if df[coluna].dtype == 'object' or pd.api.types.is_categorical_dtype(df[coluna]):
        n_unicos = df[coluna].nunique()
        print(f"{coluna}: {n_unicos} valores únicos")

print("\n4. Valores únicos na coluna numérica 'idade':")
idades_unicas = df['idade'].unique()
print(f"Idades únicas: {np.sort(idades_unicas)}")
print(f"Range de idades: {idades_unicas.min()} - {idades_unicas.max()}")

import pandas as pd

import numpy as np

# Criando um DataFrame mais complexo com dados missing

np.random.seed(42)

dados = {

'id': range(1, 21),

'idade': np.random.randint(18, 70, 20),

'cidade': np.random.choice(['São Paulo', 'Rio de Janeiro', 'Belo Horizonte', 'Curitiba', None], 20),

'nível_educacional': np.random.choice(['Fundamental', 'Médio', 'Superior', 'Pós-graduação', None], 20),

'salário': np.random.normal(5000, 2000, 20)

}

df = pd.DataFrame(dados)

# Adicionando alguns outliers no salário

df.loc[::5, 'salário'] = df.loc[::5, 'salário'] * 3

print("Primeiras linhas do DataFrame:")

print(df.head())

print("\n" + "="*50)

print("ANÁLISE COM unique()")

print("="*50)

# Analisando valores únicos em cada coluna categórica

print("\n1. Valores únicos na coluna 'cidade':")

cidades_unicas = df['cidade'].unique()

print(cidades_unicas)

print("\n2. Valores únicos na coluna 'nível_educacional':")

niveis_unicos = df['nível_educacional'].unique()

print(niveis_unicos)

print("\n3. Número de valores únicos por coluna:")

for coluna in df.columns:

if df[coluna].dtype == 'object' or pd.api.types.is_categorical_dtype(df[coluna]):

n_unicos = df[coluna].nunique()

print(f"{coluna}: {n_unicos} valores únicos")

print("\n4. Valores únicos na coluna numérica 'idade':")

idades_unicas = df['idade'].unique()

print(f"Idades únicas: {np.sort(idades_unicas)}")

print(f"Range de idades: {idades_unicas.min()} - {idades_unicas.max()}")

Em R, podemos realizar uma análise similar com:

set.seed(42)
dados <- data.frame(
  id = 1:20,
  idade = sample(18:70, 20, replace = TRUE),
  cidade = sample(c('São Paulo', 'Rio de Janeiro', 'Belo Horizonte', 'Curitiba', NA), 20, replace = TRUE),
  nivel_educacional = sample(c('Fundamental', 'Médio', 'Superior', 'Pós-graduação', NA), 20, replace = TRUE),
  salario = rnorm(20, 5000, 2000)
)

# Adicionando outliers
dados$salario[seq(1, 20, by = 5)] <- dados$salario[seq(1, 20, by = 5)] * 3

print("Primeiras linhas do data frame:")
print(head(dados))

cat("\n", rep("=", 50), "\n")
cat("ANÁLISE COM unique()\n")
cat(rep("=", 50), "\n")

# Analisando valores únicos
cat("\n1. Valores únicos na coluna 'cidade':\n")
cidades_unicas <- unique(dados$cidade)
print(cidades_unicas)

cat("\n2. Valores únicos na coluna 'nível_educacional':\n")
niveis_unicos <- unique(dados$nivel_educacional)
print(niveis_unicos)

cat("\n3. Número de valores únicos por coluna:\n")
for (coluna in names(dados)) {
  if (is.character(dados[[coluna]]) || is.factor(dados[[coluna]])) {
    n_unicos <- length(unique(dados[[coluna]]))
    cat(paste0(coluna, ": ", n_unicos, " valores únicos\n"))
  }
}

cat("\n4. Valores únicos na coluna numérica 'idade':\n")
idades_unicas <- unique(dados$idade)
cat(paste("Idades únicas:", paste(sort(idades_unicas), collapse = ", "), "\n"))
cat(paste("Range de idades:", min(idades_unicas, na.rm = TRUE), "-", max(idades_unicas, na.rm = TRUE), "\n"))

set.seed(42)

dados <- data.frame(

id = 1:20,

idade = sample(18:70, 20, replace = TRUE),

cidade = sample(c('São Paulo', 'Rio de Janeiro', 'Belo Horizonte', 'Curitiba', NA), 20, replace = TRUE),

nivel_educacional = sample(c('Fundamental', 'Médio', 'Superior', 'Pós-graduação', NA), 20, replace = TRUE),

salario = rnorm(20, 5000, 2000)

)

# Adicionando outliers

dados$salario[seq(1, 20, by = 5)] <- dados$salario[seq(1, 20, by = 5)] * 3

print("Primeiras linhas do data frame:")

print(head(dados))

cat("\n", rep("=", 50), "\n")

cat("ANÁLISE COM unique()\n")

cat(rep("=", 50), "\n")

# Analisando valores únicos

cat("\n1. Valores únicos na coluna 'cidade':\n")

cidades_unicas <- unique(dados$cidade)

print(cidades_unicas)

cat("\n2. Valores únicos na coluna 'nível_educacional':\n")

niveis_unicos <- unique(dados$nivel_educacional)

print(niveis_unicos)

cat("\n3. Número de valores únicos por coluna:\n")

for (coluna in names(dados)) {

if (is.character(dados[[coluna]]) || is.factor(dados[[coluna]])) {

n_unicos <- length(unique(dados[[coluna]]))

cat(paste0(coluna, ": ", n_unicos, " valores únicos\n"))

}

cat("\n4. Valores únicos na coluna numérica 'idade':\n")

idades_unicas <- unique(dados$idade)

cat(paste("Idades únicas:", paste(sort(idades_unicas), collapse = ", "), "\n"))

cat(paste("Range de idades:", min(idades_unicas, na.rm = TRUE), "-", max(idades_unicas, na.rm = TRUE), "\n"))

⚠️ Considerações Importantes

Ao usar unique(), esteja ciente das seguintes considerações:

unique() não funciona diretamente em DataFrames completos, apenas em Series
Valores NaN são tratados de forma diferente dependendo da versão do Pandas
Para colunas com muitos valores únicos, o resultado pode ser muito grande
A ordem dos valores é preservada conforme aparecem nos dados, não em ordem alfabética/numerica
Para obter valores únicos ordenados, use sorted(df['coluna'].unique())

Conclusão

O método df.unique() é uma ferramenta simples mas poderosa para análise exploratória de dados em Pandas. Ele fornece uma maneira rápida de identificar valores distintos em uma coluna, sendo especialmente útil para variáveis categóricas.

Lembre-se de que unique() é mais eficiente quando você precisa dos valores específicos, enquanto value_counts() é melhor quando você precisa tanto dos valores quanto de suas frequências, e nunique() é mais adequado quando você precisa apenas da contagem de valores únicos.

Referências

Documentação oficial do Pandas: Series.unique()
Pandas User Guide: Working with Unique Values
Real Python: Finding Unique Values in Pandas