import pandas as pd
from sklearn.preprocessing import LabelEncoder
 
# 1. Dados de exemplo: Tamanhos de camiseta (variável ordinal)
data = {
    'Tamanho': ['P', 'M', 'G', 'P', 'G', 'M', 'P', 'GG'],
    'Cor': ['Vermelho', 'Azul', 'Verde', 'Azul', 'Vermelho', 'Verde', 'Vermelho', 'Azul'],
    'Preco': [50, 60, 70, 55, 75, 65, 52, 80]
}
df = pd.DataFrame(data)
 
print("DataFrame Original:")
print(df)
print("-" * 30)
 
# 2. Criando uma instância do LabelEncoder
label_encoder = LabelEncoder()
 
# 3. Aplicando Label Encoding à coluna 'Tamanho'
# fit_transform() aprende as categorias únicas e as transforma em números
df['Tamanho_Encoded'] = label_encoder.fit_transform(df['Tamanho'])
 
print("\nDataFrame com 'Tamanho' codificado por Label Encoding:")
print(df)
print("-" * 30)
 
# 4. Visualizando as classes e seus mapeamentos
print("\nMapeamento das classes pelo LabelEncoder:")
for i, item in enumerate(label_encoder.classes_):
    print(f"{item} -> {i}")
 
# 5. Invertendo a transformação (útil para entender as previsões)
# Vamos pegar o primeiro valor codificado de 'Tamanho'
first_encoded_size = df['Tamanho_Encoded'].iloc[0]
original_size = label_encoder.inverse_transform([first_encoded_size])
print(f"\nValor codificado '{first_encoded_size}' retransformado: {original_size[0]}")
 
# Exemplo de uma categoria nova (não vista no fit)
# Se tentarmos transformar uma categoria nova, o LabelEncoder vai falhar
# try:
#     label_encoder.transform(['XG'])
# except ValueError as e:
#     print(f"\nErro ao tentar codificar uma categoria não vista: {e}")

import pandas as pd
from sklearn.preprocessing import OneHotEncoder
 
# Reutilizando o DataFrame original
data = {
    'Tamanho': ['P', 'M', 'G', 'P', 'G', 'M', 'P', 'GG'],
    'Cor': ['Vermelho', 'Azul', 'Verde', 'Azul', 'Vermelho', 'Verde', 'Vermelho', 'Azul'],
    'Preco': [50, 60, 70, 55, 75, 65, 52, 80]
}
df = pd.DataFrame(data)
 
print("DataFrame Original:")
print(df)
print("-" * 30)
 
# 1. Criando uma instância do OneHotEncoder
# handle_unknown='ignore': Ignora categorias não vistas durante o fit, atribuindo 0s.
#                          Útil em produção para evitar erros se novas categorias aparecerem.
# sparse_output=False: Retorna um array denso em vez de uma matriz esparsa (mais fácil de visualizar).
# drop='first': Remove a primeira categoria de cada feature para evitar multicolinearidade.
one_hot_encoder = OneHotEncoder(handle_unknown='ignore', sparse_output=False, drop='first')
 
# 2. Aplicando One-Hot Encoding à coluna 'Cor' (variável nominal)
# Precisamos passar um array 2D (DataFrame com uma única coluna)
encoded_features = one_hot_encoder.fit_transform(df[['Cor']])
 
# 3. Criando um DataFrame com as novas colunas codificadas
# one_hot_encoder.get_feature_names_out() retorna os nomes das novas colunas
encoded_df = pd.DataFrame(encoded_features, columns=one_hot_encoder.get_feature_names_out(['Cor']))
 
print("\nDataFrame com 'Cor' codificada por One-Hot Encoding:")
print(encoded_df)
print("-" * 30)
 
# 4. Combinando com o DataFrame original (opcional, mas comum)
df_combined = pd.concat([df, encoded_df], axis=1)
# Agora podemos dropar a coluna 'Cor' original se quisermos
df_combined = df_combined.drop('Cor', axis=1)
 
print("\nDataFrame Original com 'Cor' substituída por One-Hot Encoding:")
print(df_combined)

import pandas as pd
from sklearn.preprocessing import LabelEncoder, OneHotEncoder
 
# DataFrame original
data = {
    'Tamanho': ['P', 'M', 'G', 'P', 'G', 'M', 'P', 'GG'],
    'Cor': ['Vermelho', 'Azul', 'Verde', 'Azul', 'Vermelho', 'Verde', 'Vermelho', 'Azul'],
    'Preco': [50, 60, 70, 55, 75, 65, 52, 80],
    'Avaliacao_Cliente': ['Ruim', 'Bom', 'Excelente', 'Regular', 'Bom', 'Ruim', 'Excelente', 'Regular']
}
df = pd.DataFrame(data)
 
print("DataFrame Original:")
print(df)
print("-" * 50)
 
# --- 1. Label Encoding para 'Tamanho' (Ordinal) ---
label_encoder_tamanho = LabelEncoder()
df['Tamanho_Encoded'] = label_encoder_tamanho.fit_transform(df['Tamanho'])
print("\nMapeamento de Tamanho:", dict(zip(label_encoder_tamanho.classes_, label_encoder_tamanho.transform(label_encoder_tamanho.classes_))))
 
# --- 2. Label Encoding para 'Avaliacao_Cliente' (Ordinal) ---
# Aqui, a ordem alfabética padrão do LabelEncoder pode não ser a que queremos.
# Para ter controle sobre a ordem, poderíamos usar OrdinalEncoder ou mapeamento manual.
# Para este exemplo, vamos usar LabelEncoder e aceitar a ordem padrão.
label_encoder_avaliacao = LabelEncoder()
df['Avaliacao_Encoded'] = label_encoder_avaliacao.fit_transform(df['Avaliacao_Cliente'])
print("\nMapeamento de Avaliação (padrão LabelEncoder):", dict(zip(label_encoder_avaliacao.classes_, label_encoder_avaliacao.transform(label_encoder_avaliacao.classes_))))
 
 
# --- 3. One-Hot Encoding para 'Cor' (Nominal) ---
one_hot_encoder_cor = OneHotEncoder(handle_unknown='ignore', sparse_output=False, drop='first')
encoded_cor_features = one_hot_encoder_cor.fit_transform(df[['Cor']])
encoded_cor_df = pd.DataFrame(encoded_cor_features, columns=one_hot_encoder_cor.get_feature_names_out(['Cor']))
 
# --- 4. Combinando tudo ---
# Primeiro, dropamos as colunas categóricas originais que foram codificadas
df_processed = df.drop(columns=['Tamanho', 'Cor', 'Avaliacao_Cliente'])
 
# Depois, concatenamos as colunas One-Hot Encoded
df_final = pd.concat([df_processed, encoded_cor_df], axis=1)
 
print("\nDataFrame Final Após Codificação:")
print(df_final)

import pandas as pd
data_imoveis = {
    'Bairro': ['Centro', 'Jardins', 'Centro', 'Pinheiros', 'Jardins', 'Centro', 'Pinheiros', 'Centro'],
    'Tipo_Imovel': ['Apartamento', 'Casa', 'Apartamento', 'Studio', 'Casa', 'Studio', 'Apartamento', 'Casa'],
    'Qualidade_Acabamento': ['Boa', 'Excelente', 'Regular', 'Boa', 'Excelente', 'Regular', 'Boa', 'Regular'],
    'Num_Quartos': [2, 3, 1, 1, 4, 1, 2, 3],
    'Preco_Venda': [300000, 800000, 200000, 350000, 950000, 280000, 400000, 600000]
}
df_imoveis = pd.DataFrame(data_imoveis)

# Seu código começa aqui!
import pandas as pd
from sklearn.preprocessing import LabelEncoder, OneHotEncoder
 
# 1. Carregar o DataFrame
data_imoveis = {
    'Bairro': ['Centro', 'Jardins', 'Centro', 'Pinheiros', 'Jardins', 'Centro', 'Pinheiros', 'Centro'],
    'Tipo_Imovel': ['Apartamento', 'Casa', 'Apartamento', 'Studio', 'Casa', 'Studio', 'Apartamento', 'Casa'],
    'Qualidade_Acabamento': ['Boa', 'Excelente', 'Regular', 'Boa', 'Excelente', 'Regular', 'Boa', 'Regular'],
    'Num_Quartos': [2, 3, 1, 1, 4, 1, 2, 3],
    'Preco_Venda': [300000, 800000, 200000, 350000, 950000, 280000, 400000, 600000]
}
df_imoveis = pd.DataFrame(data_imoveis)
 
print("--- Tarefa 1 & 2: DataFrame Original e Análise Inicial ---")
print(df_imoveis.head())
print("\nInformações do DataFrame:")
df_imoveis.info()
 
# Classificação das variáveis categóricas:
# Bairro: Nominal
# Tipo_Imovel: Nominal
# Qualidade_Acabamento: Ordinal (Regular < Boa < Excelente)
 
print("\n--- Tarefa 3: Codificação de Variáveis Ordinais ---")
# Codificar 'Qualidade_Acabamento'
label_encoder_qualidade = LabelEncoder()
df_imoveis['Qualidade_Acabamento_Encoded'] = label_encoder_qualidade.fit_transform(df_imoveis['Qualidade_Acabamento'])
 
print("\nMapeamento de Qualidade_Acabamento:", dict(zip(label_encoder_qualidade.classes_, label_encoder_qualidade.transform(label_encoder_qualidade.classes_))))
# Note que o LabelEncoder ordenou alfabeticamente: Boa=0, Excelente=1, Regular=2.
# Se quiséssemos Regular=0, Boa=1, Excelente=2, precisaríamos de OrdinalEncoder com a ordem explícita.
# Por enquanto, vamos seguir com o LabelEncoder para simplificar o exercício.
 
print("\nDataFrame com Qualidade_Acabamento codificada:")
print(df_imoveis.head())
 
print("\n--- Tarefa 4: Codificação de Variáveis Nominais ---")
# Codificar 'Bairro' e 'Tipo_Imovel'
one_hot_encoder_nominal = OneHotEncoder(handle_unknown='ignore', sparse_output=False, drop='first')
 
# Aplicar One-Hot Encoding às colunas nominais
encoded_nominal_features = one_hot_encoder_nominal.fit_transform(df_imoveis[['Bairro', 'Tipo_Imovel']])
 
# Criar DataFrame com as colunas One-Hot Encoded
encoded_nominal_df = pd.DataFrame(encoded_nominal_features, columns=one_hot_encoder_nominal.get_feature_names_out(['Bairro', 'Tipo_Imovel']))
 
print("\nDataFrame apenas com colunas One-Hot Encoded:")
print(encoded_nominal_df.head())
 
print("\n--- Tarefa 5: Combinar o DataFrame Final ---")
# Remover as colunas categóricas originais
df_processed = df_imoveis.drop(columns=['Bairro', 'Tipo_Imovel', 'Qualidade_Acabamento'])
 
# Concatenar com as colunas One-Hot Encoded
df_final = pd.concat([df_processed, encoded_nominal_df], axis=1)
 
print("\nDataFrame Final Após Todas as Codificações:")
print(df_final.head())