O Brasil em Dados: Do Óbvio ao Oculto

# Filtrando o dataset para analisar a população geral
df_city = df[['CITY','STATE','IBGE_RES_POP', 'IBGE_RES_POP_BRAS','IBGE_RES_POP_ESTR']]

# Agrupando as cidades e somando a população
cols_cidade = ['IBGE_RES_POP','IBGE_RES_POP_BRAS','IBGE_RES_POP_ESTR']
df_city = df_city.groupby(['CITY', 'STATE'])[cols_cidade].sum().reset_index()

# Ordenando os valores
df_city.sort_values(by='IBGE_RES_POP', ascending=False, inplace=True)
df_city.reset_index(drop=True, inplace=True)

# Criando a coluna auxiliar de percentual
df_city['Perc_BRAS'] = round((df_city['IBGE_RES_POP_BRAS'] / df_city['IBGE_RES_POP']) * 100, 2)
df_city['Perc_Estr'] = round((df_city['IBGE_RES_POP_ESTR'] / df_city['IBGE_RES_POP']) * 100, 2)

# Separando os top 10
top10_city = df_city.nlargest(10,'IBGE_RES_POP')
top10_city_estr = df_city.nlargest(10,'IBGE_RES_POP_ESTR').reset_index(drop=True)
top10_menor_city = df_city.nsmallest(10,'IBGE_RES_POP').reset_index(drop=True)

# Plotando os gráficos de Top 10 (Geral, Estrangeira e Menores)
plt.figure(figsize=(16,6))
sns.barplot(data=top10_city, x='CITY', y='IBGE_RES_POP')
plt.title('Top 10 Cidades com a Maior População Geral', fontsize=14, fontweight='bold')
plt.show()

# Extraindo as variáveis formatadas para resposta
df_maior_city = top10_city.iloc[0]
df_menor_cidade = top10_menor_city.iloc[0]

# Filtrando o dataset para tratar o valor per capita
df_pcapita = df[['CITY','STATE','GDP_CAPITA', 'REGION']]

# Agrupando os valores por regiao e calculando a media
df_pcapita = df_pcapita.groupby('REGION')['GDP_CAPITA'].mean().reset_index()

# Ordenando os valores e reajustando o index
df_pcapita.sort_values(by='GDP_CAPITA', ascending=False, inplace=True)
df_pcapita.reset_index(drop=True, inplace=True)

# Ajustando a Coluna GDP_CAPITA para o valor mensal
df_pcapita['GDP_CAPITA'] = df_pcapita['GDP_CAPITA'] / 12

# Plotando o grafico de pizza
plt.figure(figsize=(10,6))
plt.pie(df_pcapita['GDP_CAPITA'],
        labels=df_pcapita['REGION'],
        autopct='%1.1f%%',
        startangle=90)
        
centro_circulo = plt.Circle((0,0), 0.7, fc='white')
fig = plt.gcf()
fig.gca().add_artist(centro_circulo)

plt.title('Média Mensal de Renda Per Capita por Região')
plt.show()

# Filtrando o dataset para analisar as cidades e estados pela contribuição imposto
df_imposto = df[['CITY', 'STATE', 'TAXES']]

# Agrupando o Estado para buscar o valor total
df_imposto_estado = df_imposto.groupby('STATE')['TAXES'].sum().reset_index()

# Ordenando os valores
df_imposto.sort_values(by='TAXES', ascending=False, inplace=True)
df_imposto_estado.sort_values(by='TAXES', ascending=False, inplace=True)

# Ajustando o index
df_imposto.reset_index(drop=True, inplace=True)
df_imposto_estado.reset_index(drop=True, inplace=True)

# Distribuição das populações (Histograma)
plt.figure(figsize=(12, 5))
sns.histplot(df_imposto_estado['TAXES'], kde=True, color='blue', label='STATE')
plt.title('Histograma de Contribuição de Impostos por Estado')
plt.show()

# Plotando um grafico de Boxplot
plt.figure(figsize=(18, 6))
sns.boxplot(data=df_imposto, x='STATE', y='TAXES' )
plt.title('Distribuição de Contribuição de Impostos por Estado')
plt.xlabel('Estado', fontstyle='italic')
plt.ylabel('Imposto', fontstyle='italic')
plt.show()

# Extraindo as Variáveis Máximas e Mínimas (Estado e Cidade)
df_maior_imposto_estado = df_imposto_estado[df_imposto_estado['TAXES'] == df_imposto_estado['TAXES'].max()]
df_menor_imposto_cidade = df_imposto[df_imposto['TAXES'] == df_imposto['TAXES'].min()]
# (Trecho omitido para brevidade visual)

# Filtrando o dataset para analisar a população real
df_ppl_real = df[['STATE', 'IBGE_RES_POP', 'ESTIMATED_POP']].copy()

# Calcular a variação absoluta entre a população real e estimada
df_ppl_real['VARIATION'] = abs(df_ppl_real['IBGE_RES_POP'] - df_ppl_real['ESTIMATED_POP'])

# Agrupar por estado e somar a variação
df_estado_var = df_ppl_real.groupby('STATE')['VARIATION'].sum().sort_values(ascending=False).reset_index()

# Plotando um de dispersão para comparação entre população real e estimada
plt.figure(figsize=(12, 6))
sns.scatterplot(data=df_ppl_real, x='IBGE_RES_POP', y='ESTIMATED_POP')
plt.title('Comparação entre População Real e Estimada')
plt.show()

# Boxplot para análise de outliers
plt.figure(figsize=(7,9))
sns.boxplot(data=df_ppl_real[['IBGE_RES_POP', 'ESTIMATED_POP']])
plt.title('Boxplot das Populações Real e Estimada')
plt.show()

# Plotando um grafico para analisar a variação por estado
plt.figure(figsize=(12,6))
sns.barplot(data=df_estado_var, x='STATE', y='VARIATION')
plt.title('Variação entre População Real e Estimada por Estado')
plt.show()

# Extraindo a resposta final
df_maior_maior_var = df_estado_var.iloc[0]
# (Trecho da variável final formatada ocultado para brevidade)

# Filtrando o dataset para analisar a area por km²
df_area = df[['REGION', 'STATE', 'CITY', 'AREA', 'LONG', 'LAT', 'ALT']]

# Calcular o total de Area km^2 de cada regiao
regiao_area = df_area.groupby('REGION')['AREA'].sum().reset_index()

# Identificacao de regiao com o maior area km²
area_regiao_max = regiao_area.loc[regiao_area['AREA'].idxmax()]

# Criando os objetos para responder a pergunta
nome_maior_area = area_regiao_max["REGION"]
area_total_maior_regiao = '{:,.0F}'.format(area_regiao_max["AREA"]).replace(',', '.')

# Limpando do dataset Longitude, Latitude e Altitude zeradas
df_area_plt = df_area[(df_area['LONG'] != 0) & (df_area['LAT'] != 0) & (df_area['ALT'] != 0)]

# Plotando o grafico de dispersao 
plt.figure(figsize=(7,7))
sns.scatterplot(data=df_area_plt,
                x='LONG',
                y='LAT',
                hue='REGION',
                size='AREA',
                sizes=(20,200),
                legend=False)

max_region_data = df_area_plt[df_area_plt['REGION'] == area_regiao_max['REGION']]
plt.scatter(max_region_data['LONG'], max_region_data['LAT'], color='green', label=f'Maior Área: {area_regiao_max["REGION"]}')

plt.title('Dispersão da Area km² por Regiões com a Longitude e Latitude')
plt.xlabel('Longitude', fontstyle='italic')
plt.ylabel('Latitude', fontstyle='italic')
plt.legend(fontsize=9, bbox_to_anchor=(0.32, 0.073))
plt.show()

# Filtrando o dataset para analisar a area plantada
df_area_plantada = df[['REGION','IBGE_PLANTED_AREA']]

# Calcular o total de Area km^2 de cada regiao
regiao_area_plantada = df_area_plantada.groupby('REGION')['IBGE_PLANTED_AREA'].sum().sort_values(ascending=False).reset_index()

# Criando os objetos para responder a pergunta
df_maior_area_plantada = regiao_area_plantada[regiao_area_plantada['IBGE_PLANTED_AREA'] == regiao_area_plantada['IBGE_PLANTED_AREA'].max()]
nome_maior_area_plantada = df_maior_area_plantada['REGION'].iloc[0]
maior_renda_area_plantada = df_maior_area_plantada['IBGE_PLANTED_AREA'].iloc[0]

df_menor_area_plantada = regiao_area_plantada[regiao_area_plantada['IBGE_PLANTED_AREA'] == regiao_area_plantada['IBGE_PLANTED_AREA'].min()]
nome_menor_area_plantada = df_menor_area_plantada['REGION'].iloc[0]
menor_renda_area_plantada = df_menor_area_plantada['IBGE_PLANTED_AREA'].iloc[0]

# Plotando o grafico com maior area
plt.figure(figsize=(7,6))
sns.barplot(data=regiao_area_plantada,
            y='REGION', 
            x='IBGE_PLANTED_AREA',
            orient='h' )

plt.xlabel('Area Plantada',fontstyle='italic')
plt.ylabel('Região', fontstyle='italic')
plt.show()

# Filtrando o dataset (usando df_clean)
df_idh = df_clean[['STATE','NAME_STATE','REGION', 'CITY', 'IDHM','LONG', 'LAT', 'ALT']].copy()

# Calcular a mediana do IDH por estado
df_idh_estado = (df_idh
                .groupby(['STATE','NAME_STATE','REGION'])
                .agg({'IDHM': 'median'})
                .sort_values(by=['IDHM'], ascending=False)
                .reset_index())

# Extração de percentis para identificar outliers (LCI e LCS)
percentis = np.percentile(df_idh_estado['IDHM'], [25, 50, 75])
iqr = percentis[2] - percentis[0]
lci = percentis[0] - 1.5 * iqr
lcs = percentis[2] + 1.5 * iqr

# Região com o maior IDH
df_maior_idh = df_idh_estado[df_idh_estado['IDHM'] >= percentis[2]].head(5)
nome_maior_idh_regiao = ', '.join(df_maior_idh['NAME_STATE'].values.tolist())

# Região com o menor IDH
df_menor_idh = df_idh_estado[df_idh_estado['IDHM'] <= percentis[0]].tail(5)
nome_menor_idh_regiao = ', '.join(df_menor_idh['NAME_STATE'].values.tolist())

# Criando o Dashboard com três gráficos (Subplot2Grid)
fig = plt.figure(figsize=(11, 8.3))

# Plot 1: Barras Horizontais com anotações de Quartis
ax1 = plt.subplot2grid((3, 2), (0, 0), rowspan=3)
sns.barplot(data=df_idh_estado, x='IDHM', y='STATE', orient='h', palette="cividis", ax=ax1)
ax1.axvline(percentis[2], color='blue', linestyle='--') # Q3
ax1.axvline(percentis[0], color='orange', linestyle='--') # Q1

# Plot 2: Dispersão Geoespacial
ax2 = plt.subplot2grid((3, 2), (1, 1), rowspan=2)
sns.scatterplot(data=df_idh_plt, x='LONG', y='LAT', hue='REGION', size='IDHM', palette='pastel', ax=ax2)

# Plot 3: Histograma com Média, Mediana e Assimetria
ax3 = plt.subplot2grid((3, 2), (0, 1))
sns.histplot(df_idh_estado['IDHM'], kde=True, color='#5EAAA8', bins=10, ax=ax3)

plt.tight_layout()
plt.show()

# Preparacao dos dados para o modelo
X = np.array(df_pib_idh['IDHM']).reshape(-1,1)
y = df_pib_idh['GDP_CAPITA']

# Dividindo dados em treinamento e teste
X_treino, X_teste, y_treino, y_teste = train_test_split(X, y, test_size=0.2, random_state=42)

# Criando o modelo de regressao linear
modelo_regressao = LinearRegression()
modelo_regressao.fit(X_treino, y_treino)

# Avalia o modelo nos dados de teste
score = modelo_regressao.score(X_teste,y_teste)
score_perc = score * 100

# Visualizacao da reta de regressao linear (previsoes)
plt.scatter(X, y, label='Dados Reais')
plt.plot(X, modelo_regressao.predict(X), color='orange', label='Reta com as previsões do modelo')
plt.title('Relação entre o PIB per capita e IDH')
plt.show()

# Preparacao dos dados para o modelo - Independente
X1 = np.array(df_pib_idh_long['IDHM_Longevidade']).reshape(-1,1)
y1 = df_pib_idh_long['GDP_CAPITA']

# Adicao constante da variavel independente
X1 = sm.add_constant(X1)

# Criando e treinando o modelo OLS - Statsmodels
modelo_ols = sm.OLS(y1, X1)
resultado_ols = modelo_ols.fit()

# Imprimindo a tabela de resultado estatístico detalhado
print(resultado_ols.summary())

# Grafico de Dispersao 
plt.figure(figsize=(10,7))
plt.scatter(df_pib_idh_long['IDHM_Longevidade'], y1, label='Dados Reais', color='#028391')
plt.plot(df_pib_idh_long['IDHM_Longevidade'], resultado_ols.fittedvalues, color='#FDDE55', label='Linha de Previsoes OLS')
plt.title('Relacao entre o PIB per capita e IDH Longividade')
plt.show()

# Filtrando o dataset para analisar o PIB e total de empresas
df_pib_empresa = df[['STATE','REGION','COMP_TOT','GDP_CAPITA']]

# Preparacao dos dados para o modelo
cols_empresas = ['COMP_TOT', 'GDP_CAPITA']
df_pib_empresa_estado = df_pib_empresa.groupby(['STATE','REGION'])[cols_empresas].sum().sort_values(by='GDP_CAPITA',ascending=False).reset_index()

# Preparacao dos dados para o modelo (Independente e Dependente)
X2 = np.array(df_pib_empresa_estado['COMP_TOT']).reshape(-1,1)
y2 = df_pib_empresa_estado['GDP_CAPITA']

# Adicao constante da variavel independente
X2_sm = sm.add_constant(X2) 

# Criando e treinando o modelo OLS - statsmodels
modelo_ols_empresas = sm.OLS(y2, X2_sm)
resultado_empresas = modelo_ols_empresas.fit()

# Imprimindo a tabela de resultado
print(resultado_empresas.summary())

# Grafico de Dispersao 
plt.scatter(y=y2, x=df_pib_empresa_estado['COMP_TOT'], label='Dados reais')
plt.plot(df_pib_empresa_estado['COMP_TOT'], resultado_empresas.fittedvalues, color='#FDDE55', label='Linha de Previsoes do modelo')
plt.xlabel('Total empresas')
plt.ylabel('PIB per capita')
plt.title('Relacao entre o PIB per capita e Total de empresas')
plt.legend()
plt.show()

# Filtrando o dataset para analisar os veículos
df_pib_car_moto = df[['CITY','STATE','REGION', 'GDP_CAPITA', 'Cars', 'Motorcycles']]

# Criando uma coluna auxiliar com a soma de Carros e Motos
df_pib_car_moto['Total_Car_Moto'] = df_pib_car_moto['Cars'] + df_pib_car_moto['Motorcycles']

# Agrupando as medidas por estado (Mediana para PIB, Soma para frota)
df_pib_car_moto_estado = df_pib_car_moto.groupby(['STATE','REGION']).agg({
    'GDP_CAPITA':'median', 
    'Cars':'sum', 
    'Motorcycles':'sum', 
    'Total_Car_Moto':'sum'
}).sort_values(by='GDP_CAPITA', ascending=False).reset_index()

# Calculando Assimetria (Skewness)
skew_car = round(skew(df_pib_car_moto_estado['Cars']),2)
skew_moto = round(skew(df_pib_car_moto_estado['Motorcycles']),2)
skew_car_moto = round(skew(df_pib_car_moto_estado['Total_Car_Moto']), 2)

# Plotando o Histograma dos Dados de carros e Motos em 3 colunas
fig, axes = plt.subplots(1, 3, figsize=(14,4))

# Histograma do Total de Carros
sns.histplot(df_pib_car_moto_estado['Cars'], kde=True, color='#4D869C', bins=15, ax=axes[0])
axes[0].text(0.55, 0.8, f'Assimetria: {skew_car:.2f}', transform=axes[0].transAxes)
axes[0].set_title('Histograma - Carros')

# Histograma do Total de Motos
sns.histplot(df_pib_car_moto_estado['Motorcycles'], kde=True, color='#4D868A', bins=20, ax=axes[1])
axes[1].text(0.55, 0.8, f'Assimetria: {skew_moto:.2f}', transform=axes[1].transAxes)
axes[1].set_title('Histograma - Motos')

# Histograma do Total
sns.histplot(df_pib_car_moto_estado['Total_Car_Moto'], kde=True, color='#4D869C', bins=15, ax=axes[2])
axes[2].text(0.55, 0.8, f'Assimetria: {skew_car_moto:.2f}', transform=axes[2].transAxes)
axes[2].set_title('Histograma - Total')

plt.tight_layout()
plt.show()

# Filtrando o dataset
df_veiculo = df[['STATE', 'IBGE_RES_POP', 'Cars', 'Motorcycles']]

# Criando uma coluna auxiliar com a soma de Carros e Motos
df_veiculo['Total_Car_Moto'] = df_veiculo['Cars'] + df_veiculo['Motorcycles']

# Agrupando por Estado e somando o total de pessoas e o total de veículos
cols_agrupamento = ['IBGE_RES_POP', 'Total_Car_Moto']
df_veiculo_estado = df_veiculo.groupby('STATE')[cols_agrupamento].sum().reset_index()

# Coluna com o Total de Veículo por Pessoa
df_veiculo_estado['Veiculo_Pessoa'] = df_veiculo_estado['Total_Car_Moto'] / df_veiculo_estado['IBGE_RES_POP']

# Organizar por Total de Veículos
df_veiculo_estado = df_veiculo_estado.sort_values(by='Veiculo_Pessoa', ascending=False).reset_index(drop=True)

# Extração de Variáveis (Estatística e Extremos)
media_veiculo = round(df_veiculo_estado['Veiculo_Pessoa'].mean(), 2)
mediana_veiculo = round(df_veiculo_estado['Veiculo_Pessoa'].median(), 2)
nome_maior_veiculo = df_veiculo_estado['STATE'].iloc[0]
nome_menor_veiculo = df_veiculo_estado['STATE'].iloc[-1]

# Histograma do Veículos por Pessoas
plt.figure(figsize=(7,5))
sns.histplot(df_veiculo_estado['Veiculo_Pessoa'], kde=True, color='gray', bins=10)
plt.axvline(media_veiculo, color='red', linestyle='--', linewidth=1, label=f'Média: {media_veiculo:.3f}')
plt.show()

# Plotando o grafico com maiores veículos por estado
plt.figure(figsize=(7,6))
ax = sns.barplot(data=df_veiculo_estado,
                x='Veiculo_Pessoa',
                y='STATE', 
                orient='h',
                palette='seismic',
                alpha=0.9)

for p in ax.patches:
    ax.annotate(f'{p.get_width():.3f}', 
                (p.get_width() + p.get_x(), p.get_y() + p.get_height() / 2.), 
                ha='left', va='center_baseline', fontsize=10, color='black', fontweight='bold')

plt.xlim(0,0.8)
plt.title('Veículo por Estado: Do Maior para o Menor')
plt.show()

# Filtrando o dataset 
df_trator = df[['STATE', 'REGION','IBGE_PLANTED_AREA', 'Wheeled_tractor']]

# Agrupando os dados por Estado
cols_trator = ['IBGE_PLANTED_AREA', 'Wheeled_tractor']
df_trator_estado = df_trator.groupby(['STATE', 'REGION'])[cols_trator].sum().sort_values(by='Wheeled_tractor', ascending=False).reset_index()

# Preparacao dos dados para o modelo OLS 
X_trator = np.array(df_trator_estado['Wheeled_tractor']).reshape(-1,1)
y_trator = df_trator_estado['IBGE_PLANTED_AREA']

# Adicao constante da variavel independente
X_trator_sm = sm.add_constant(X_trator)

# Criando e Treinando o modelo OLS - statsmodels
modelo_trator = sm.OLS(y_trator, X_trator_sm)
resultado_trator = modelo_trator.fit()

# Imprimindo a tabela de resultado
print(resultado_trator.summary())

# Imprimindo a correlacao da Area plantada pelo total de tratores por regiao
for regiao in df_trator_estado['REGION'].unique():
    subset = df_trator_estado[df_trator_estado['REGION'] == regiao]
    print(f"Região {regiao}:", subset.select_dtypes(include='number').corr().iloc[0,1])

# Grafico de Dispersao 
plt.scatter(x=df_trator_estado['Wheeled_tractor'], y=y_trator, label='Dados reais')
plt.plot(df_trator_estado['Wheeled_tractor'], resultado_trator.fittedvalues, color='orange', label='Linha de previsoes')
plt.xlabel('Total de Tratores')
plt.ylabel('Area Plantada')
plt.title('Relacao da Area Plantada com o Total de Tratores')
plt.legend()
plt.show()