Filiados a Partidos

https://cdn.tse.jus.br/estatistica/sead/odsele/filiacao_partidaria/filiados_pp_PT.zip
https://cdn.tse.jus.br/estatistica/sead/odsele/filiacao_partidaria/filiados_pp_PL.zip
https://cdn.tse.jus.br/estatistica/sead/odsele/filiacao_partidaria/filiados_pp_MDB.zip
https://cdn.tse.jus.br/estatistica/sead/odsele/filiacao_partidaria/filiados_pp_PSDB.zip
https://cdn.tse.jus.br/estatistica/sead/odsele/filiacao_partidaria/filiados_pp_PP.zip

import requests
import zipfile
import pandas as pd
from io import BytesIO
from pathlib import Path
 
 
def baixar_filiados(partido: str, destino: Path = Path("./dados_tse")) -> pd.DataFrame:
    """
    Baixa e carrega dados de filiados de um partido.
 
    Args:
        partido: Sigla do partido (ex: 'PT', 'PL', 'MDB')
        destino: Diretório para salvar os arquivos
 
    Returns:
        DataFrame com todos os filiados do partido
    """
    url = (
        f"https://cdn.tse.jus.br/estatistica/sead/odsele/"
        f"filiacao_partidaria/filiados_pp_{partido.upper()}.zip"
    )
    print(f"Baixando filiados do {partido.upper()}...")
 
    response = requests.get(url)
    response.raise_for_status()
 
    destino.mkdir(parents=True, exist_ok=True)
 
    with zipfile.ZipFile(BytesIO(response.content)) as zf:
        zf.extractall(destino)
        csvs = [f for f in zf.namelist() if f.endswith(".csv")]
 
    # Carregar e concatenar todos os CSVs (um por UF)
    dfs = []
    for csv_file in csvs:
        df = pd.read_csv(
            destino / csv_file,
            sep=";",
            encoding="latin-1",
            dtype=str,
        )
        dfs.append(df)
 
    df_completo = pd.concat(dfs, ignore_index=True)
    print(f"Filiados do {partido.upper()}: {len(df_completo):,}")
    return df_completo
 
 
# Baixar filiados do PT
df_pt = baixar_filiados("PT")
print(df_pt.head())

def distribuicao_por_uf(df: pd.DataFrame) -> pd.DataFrame:
    """
    Analisa a distribuição de filiados por UF.
 
    Args:
        df: DataFrame com dados de filiados
 
    Returns:
        DataFrame com contagem por UF, ordenada decrescente
    """
    # Filtrar apenas filiados com registro regular
    ativos = df[df["SITUACAO_REGISTRO"].str.upper() == "REGULAR"]
 
    por_uf = (
        ativos.groupby("UF")
        .size()
        .reset_index(name="total_filiados")
        .sort_values("total_filiados", ascending=False)
    )
 
    por_uf["percentual"] = (
        por_uf["total_filiados"] / por_uf["total_filiados"].sum() * 100
    ).round(2)
 
    return por_uf
 
 
distribuicao = distribuicao_por_uf(df_pt)
print("Distribuição de filiados do PT por UF:")
print(distribuicao.head(10))

def comparar_partidos(
    partidos: list[str],
    apenas_regulares: bool = True,
) -> pd.DataFrame:
    """
    Compara a quantidade de filiados entre partidos.
 
    Args:
        partidos: Lista de siglas de partidos
        apenas_regulares: Se True, conta apenas filiados com registro regular
 
    Returns:
        DataFrame comparativo
    """
    resultados = []
 
    for sigla in partidos:
        try:
            df = baixar_filiados(sigla)
            if apenas_regulares:
                df = df[df["SITUACAO_REGISTRO"].str.upper() == "REGULAR"]
 
            resultados.append({
                "partido": sigla,
                "total_filiados": len(df),
                "ufs_com_filiados": df["UF"].nunique(),
                "municipios_com_filiados": df["NOME_MUNICIPIO"].nunique(),
            })
        except Exception as e:
            print(f"Erro ao processar {sigla}: {e}")
 
    return pd.DataFrame(resultados).sort_values("total_filiados", ascending=False)
 
 
# Comparar os 5 maiores partidos
resultado = comparar_partidos(["PT", "PL", "MDB", "PP", "UNIÃO"])
print(resultado)

def tendencia_filiacao(df: pd.DataFrame) -> pd.DataFrame:
    """
    Analisa a evolução das filiações ao longo dos anos.
 
    Args:
        df: DataFrame com dados de filiados
 
    Returns:
        DataFrame com contagem de novas filiações por ano
    """
    df["DATA_FILIACAO"] = pd.to_datetime(
        df["DATA_FILIACAO"], format="%d/%m/%Y", errors="coerce"
    )
    df["ANO_FILIACAO"] = df["DATA_FILIACAO"].dt.year
 
    por_ano = (
        df.groupby("ANO_FILIACAO")
        .size()
        .reset_index(name="novas_filiacoes")
        .sort_values("ANO_FILIACAO")
    )
 
    return por_ano[por_ano["ANO_FILIACAO"] >= 2000]
 
 
tendencia = tendencia_filiacao(df_pt)
print("Novas filiações ao PT por ano:")
print(tendencia)

import pandas as pd
 
# 1. Carregar filiados de um partido
df_filiados = pd.read_csv(
    "dados_tse/filiados_pp_PT_SP.csv",
    sep=";",
    encoding="latin-1",
    dtype=str,
)
 
# Contar filiados regulares por município
filiados_ativos = df_filiados[df_filiados["SITUACAO_REGISTRO"] == "REGULAR"]
filiados_por_mun = (
    filiados_ativos.groupby(["CODIGO_MUNICIPIO", "NOME_MUNICIPIO"])
    .size()
    .reset_index(name="total_filiados")
)
 
# 2. Carregar eleitorado por município (previamente baixado)
df_eleitorado = pd.read_csv(
    "dados_tse/perfil_eleitorado_2024_SP.csv",
    sep=";",
    encoding="latin-1",
    dtype=str,
)
 
# Agregar eleitorado por município
df_eleitorado["QT_ELEITORES_PERFIL"] = pd.to_numeric(
    df_eleitorado["QT_ELEITORES_PERFIL"], errors="coerce"
)
eleitores_por_mun = (
    df_eleitorado.groupby("CD_MUNICIPIO")
    .agg(total_eleitores=("QT_ELEITORES_PERFIL", "sum"))
    .reset_index()
)
 
# 3. Calcular taxa de filiação
taxa = pd.merge(
    filiados_por_mun,
    eleitores_por_mun,
    left_on="CODIGO_MUNICIPIO",
    right_on="CD_MUNICIPIO",
    how="inner",
)
taxa["taxa_filiacao_pct"] = (
    taxa["total_filiados"] / taxa["total_eleitores"] * 100
).round(2)
 
print("Municípios com maior taxa de filiação ao PT (SP):")
print(
    taxa.sort_values("taxa_filiacao_pct", ascending=False)
    [["NOME_MUNICIPIO", "total_filiados", "total_eleitores", "taxa_filiacao_pct"]]
    .head(15)
)