# Vornamen Dataset: https://opendata.muenchen.de/dataset/99ad40ec-9d7b-4a2e-87eb-9bac783fb57a/

import requests
search_url = "https://opendata.muenchen.de/api/3/action/package_search"
search_params = {"q": "vornamen"}
response = requests.get(search_url, params=search_params)
package = response.json()["result"]["results"][0]
for resource in package['resources']:
    print(resource['url'])

import pandas as pd
df = pd.DataFrame()
for resource in package['resources']:
    df_jahr = pd.read_csv(resource['url'], delimiter=',')
    Jahreszahl = int(resource['url'][-8:-4]) # hier holen wir uns die Jahreszahl aus der URL, das 8.letzte bis 5.letzte Zeichen aus dem String
    df_jahr['jahr'] = Jahreszahl
    df = pd.concat([df, df_jahr], ignore_index=True)
df

df = pd.DataFrame()

# Mehrere Spalten standardisieren
mapping = {
    'vorname': 'vorname', 
    'vornamen': 'vorname',
    'anzahl': 'anzahl',
    'häufigkeit': 'anzahl',
    'geschlecht': 'geschlecht',
    'gender': 'geschlecht'
}

for resource in package['resources']:
    df_jahr = pd.read_csv(resource['url'], sep=',|;', engine='python') # versuche ; oder (das oder wird durch | ausgedrückt) ,
    Jahreszahl = int(resource['url'][-8:-4]) # hier holen wir uns die Jahreszahl aus der URL, das 8.letzte bis 5.letzte Zeichen aus dem String
    df_jahr['jahr'] = Jahreszahl
    df_jahr = df_jahr.rename(columns=lambda x: mapping.get(x.lower(), x)) # Spaltennamen standardisieren, unabhängig von Groß-/Kleinschreibung
    df = pd.concat([df, df_jahr], ignore_index=True) # Zusammenführen der Daten

df

df['anzahl'] = df['anzahl'].replace('4 oder weniger', 1)
df['anzahl'] = df['anzahl'].replace('4 oder wenniger', 1)
df['anzahl'] = pd.to_numeric(df['anzahl'])
df['anzahl'] = df['anzahl'].astype('Int64')
df

df[df['anzahl'].isna()]

# Finde doppelte Einträge
duplicates = df[df.duplicated(subset=['jahr', 'vorname', 'geschlecht'], keep=False)]

# Zeige die doppelten Einträge an
print(f"Anzahl der doppelten Einträge: {len(duplicates)}")
print("\nDoppelte Einträge:")
duplicates_sorted = duplicates.sort_values(['jahr', 'vorname', 'geschlecht'])
display(duplicates_sorted)

import seaborn as sns
import matplotlib.pyplot as plt

geburten_pro_jahr_geschlecht = df.groupby(['jahr', 'geschlecht'])['anzahl'].sum().reset_index()

plt.figure(figsize=(10, 6))
sns.lineplot(data=geburten_pro_jahr_geschlecht, x='jahr', y='anzahl', hue='geschlecht', marker='o')
plt.title('Anzahl der Geburten pro Jahr nach Geschlecht')
plt.xlabel('Jahr')
plt.ylabel('Anzahl der Geburten')
plt.legend(title='Geschlecht')
plt.grid(True, linestyle='--')
sns.despine()
plt.tight_layout()
plt.show()

import plotly.graph_objects as go
from plotly.subplots import make_subplots
import plotly.io as pio
pio.renderers.default='notebook'


# Dataframe für Jungen
df_boys = df[df['geschlecht'] == 'm'].pivot(
    index='jahr',
    columns='vorname',
    values='anzahl'
).fillna(0)

# Dataframe für Mädchen
df_girls = df[df['geschlecht'] == 'w'].pivot(
    index='jahr',
    columns='vorname',
    values='anzahl'
).fillna(0)

# Sortiere die Spalten nach der Gesamtsumme
df_boys = df_boys[df_boys.sum().sort_values(ascending=False).index]
df_girls = df_girls[df_girls.sum().sort_values(ascending=False).index]

# Erstelle die Figuren
fig = make_subplots(rows=1, cols=2, 
                   subplot_titles=('Top 10 Jungennamen', 'Top 10 Mädchennamen'),
                   horizontal_spacing=0.15)

available_years = sorted(df['jahr'].unique())

# Erstelle die Frames für die Animation
frames = []
for year in available_years:
    df_year = df[df['jahr'] == year]
    top_m = df_year[df_year['geschlecht'] == 'm'].nlargest(10, 'anzahl').sort_values('anzahl')
    top_w = df_year[df_year['geschlecht'] == 'w'].nlargest(10, 'anzahl').sort_values('anzahl')
    
    frame = go.Frame(
        data=[
            go.Bar(x=top_m['anzahl'], y=top_m['vorname'], orientation='h', marker_color=secondary_colors[4]),
            go.Bar(x=top_w['anzahl'], y=top_w['vorname'], orientation='h', marker_color=secondary_colors[2])
        ],
        name=str(year)
    )
    frames.append(frame)

# Füge die Frames hinzu
fig.frames = frames

# Initiale Daten
initial_year = available_years[0]
df_initial = df[df['jahr'] == initial_year]
top_m_initial = df_initial[df_initial['geschlecht'] == 'm'].nlargest(10, 'anzahl').sort_values('anzahl')
top_w_initial = df_initial[df_initial['geschlecht'] == 'w'].nlargest(10, 'anzahl').sort_values('anzahl')

# Füge die initialen Daten hinzu
fig.add_trace(
    go.Bar(x=top_m_initial['anzahl'], y=top_m_initial['vorname'], orientation='h', marker_color=secondary_colors[4]),
    row=1, col=1
)

fig.add_trace(
    go.Bar(x=top_w_initial['anzahl'], y=top_w_initial['vorname'],orientation='h', marker_color=secondary_colors[2]),
    row=1, col=2
)

# Erstelle die Slider-Animation
sliders = [{
    'transition': {'duration': 300, 'easing': 'cubic-in-out'},
    'pad': {'b': 10, 't': 50},
    'len': 0.9,
    'x': 0.1,
    'y': 0,
    'steps': [{
        'args': [[f.name], {
            'frame': {'duration': 300, 'redraw': True},
            'mode': 'immediate',
            'transition': {'duration': 300}
        }],
        'label': str(year),
        'method': 'animate'
    } for f, year in zip(frames, available_years)]
}]

# Aktualisiere das Layout
fig.update_layout(
    sliders=sliders,
    height=600,
    showlegend=False,
    margin=dict(l=100, r=100, t=50, b=50),
    updatemenus=[{
        'type': 'buttons',
        'x': 0.05,
        'y': -0.17,
        'showactive': False,
        'buttons': [{
            'label': 'Abspielen',
            'method': 'animate',
            'args': [None, {
                'frame': {'duration': 1000, 'redraw': True},
                'fromcurrent': True,
                'transition': {'duration': 500}
            }]
        }]
    }]
)

# Zeige die Figur an
fig.show()

name1 = "Leon"
name2 = "Maximilian"

name1_data = df[df['vorname'] == name1]
name2_data = df[df['vorname'] == name2]

name1_by_year = name1_data.groupby('jahr')['anzahl'].sum().reset_index()
name2_by_year = name2_data.groupby('jahr')['anzahl'].sum().reset_index()

plt.plot(name1_by_year['jahr'], name1_by_year['anzahl'], marker='o', label=name1)
plt.plot(name2_by_year['jahr'], name2_by_year['anzahl'], marker='s', label=name2)

plt.title(f'Häufigkeit: {name1} vs. {name2} über die Jahre')
plt.xlabel('Jahr')
plt.ylabel('Anzahl')
plt.legend()
plt.grid(True)
plt.tight_layout()
plt.show()

# Wir gruppieren nach Vorname und Jahr, summieren und sortieren
trend_data = df.groupby(['vorname', 'jahr'])['anzahl'].sum().reset_index()

# Umwandeln zu Zeitreihe für jeden Namen
trend_pivot = trend_data.pivot(index='jahr', columns='vorname', values='anzahl').fillna(0)

# Differenz zum Vorjahr berechnen
trend_diff = trend_pivot.diff().fillna(0)

# Mittelwert der letzten 3 Jahre vergleichen mit den vorherigen 3
trend_score = (trend_pivot.tail(3).mean() - trend_pivot.iloc[-6:-3].mean()).sort_values(ascending=False)

# Erstelle zwei Subplots nebeneinander
plt.figure(figsize=(15, 6))

# Subplot für die häufigsten Jungennamen
plt.subplot(1, 2, 1)
sns.barplot(x=trend_score.head(10).index, y=trend_score.head(10).values)
plt.title('Top 10 Aufsteiger der letzten Jahre')
plt.ylim(-trend_score.abs().max(), trend_score.abs().max())  # Setze y-Achsengrenzen
plt.ylabel('Trend Score')
plt.xlabel('')

# Subplot für die häufigsten Mädchennamen
plt.subplot(1, 2, 2)
sns.barplot(x=trend_score.tail(10).index, y=trend_score.tail(10).values)
plt.ylim(-trend_score.abs().max(), trend_score.abs().max())
plt.title('Top 10 Absteiger der letzten Jahre')
plt.xlabel('')
ax = plt.gca()
ax.set_yticklabels([])

plt.tight_layout()
plt.show()

# Gruppieren nach Vorname und Geschlecht und Summieren
geschlecht_counts = df.groupby(['vorname', 'geschlecht'])['anzahl'].sum().unstack(fill_value=0)

# Umbenennen der Spalten
geschlecht_counts.columns = ['Anzahl (männlich)', 'Anzahl (weiblich)'] if 'm' in geschlecht_counts.columns and 'w' in geschlecht_counts.columns else geschlecht_counts.columns

# Gesamtsumme berechnen
geschlecht_counts['Anzahl (gesamt)'] = geschlecht_counts['Anzahl (männlich)'] + geschlecht_counts['Anzahl (weiblich)']

sns.scatterplot(data=geschlecht_counts, x="Anzahl (männlich)", y="Anzahl (weiblich)")
plt.show()

# Voraussetzung: geschlecht_counts aus vorherigem Schritt (siehe vorherige Antwort)

# Nur Namen mit beiden Geschlechtern
unisex = geschlecht_counts[(geschlecht_counts['Anzahl (männlich)'] > 0) & (geschlecht_counts['Anzahl (weiblich)'] > 0)].copy()

# Verhältnis berechnen
unisex['Verhältnis m/w'] = unisex['Anzahl (männlich)'] / unisex['Anzahl (weiblich)']
unisex['Verhältnis w/m'] = unisex['Anzahl (weiblich)'] / unisex['Anzahl (männlich)']
unisex['Anteil m'] = unisex['Anzahl (männlich)'] / unisex['Anzahl (gesamt)']
unisex['Anteil w'] = unisex['Anzahl (weiblich)'] / unisex['Anzahl (gesamt)']
unisex['Ratio_Diff'] = unisex[['Verhältnis m/w', 'Verhältnis w/m']].min(axis=1)  # je näher an 1, desto ausgeglichener

# Optional: Nur relevante Namen behalten (z. B. mind. 50 Nennungen)
unisex = unisex[unisex['Anzahl (gesamt)'] >= 50]

# Sortieren: zuerst nach Gleichverteilung, dann nach Häufigkeit
unisex_sorted = unisex.sort_values(by=['Ratio_Diff', 'Anzahl (gesamt)'], ascending=[False, False]).reset_index()

# Erstelle Figure und Achse
plt.figure(figsize=(15, 6))

# Stacked Bar Plot
bars = plt.bar(range(20), unisex_sorted['Anteil m'].head(20), color=secondary_colors[4], label='Männlich')
plt.bar(range(20), unisex_sorted['Anteil w'].head(20), bottom=unisex_sorted['Anteil m'].head(20), 
        color=secondary_colors[2], label='Weiblich')

# Line Plot auf derselben Achse
plt.plot(range(20), unisex_sorted['Ratio_Diff'].head(20), color=secondary_colors[0], linewidth=2, 
         marker='o', label='Ratio', zorder=3)  # zorder=3 bringt die Linie in den Vordergrund

# Formatierung
plt.xlabel('')
plt.xticks(range(20), unisex_sorted['vorname'].head(20), rotation=45, ha='right')
plt.ylabel('Anteil / Ratio')
plt.ylim(0, 1)
plt.grid(True, alpha=0.3)
plt.legend(bbox_to_anchor=(1, 1), loc='upper left')

plt.title('Geschlechterverteilung und Balance-Ratio der Top 20 Unisex-Namen')
plt.tight_layout()
plt.show()

def berechne_duale_namen_anteil(df):
    duale_namen_stat = []

    for jahr in sorted(df['jahr'].unique()):
        df_jahr = df[df['jahr'] == jahr]

        # Gruppierung nach Vorname und Geschlecht
        geschlecht_pro_name = df_jahr.groupby(['vorname'])['geschlecht'].nunique()

        # Namen mit mehr als einem Geschlecht
        duale_namen = geschlecht_pro_name[geschlecht_pro_name > 1].index
        anzahl_duale = len(duale_namen)

        # Gesamtanzahl verschiedener Namen im Jahr
        gesamt_namen = df_jahr['vorname'].nunique()

        duale_namen_stat.append({
            'jahr': jahr,
            'duale_namen': anzahl_duale,
            'gesamt_namen': gesamt_namen,
            'anteil_dual': anzahl_duale / gesamt_namen if gesamt_namen > 0 else 0
        })

    return pd.DataFrame(duale_namen_stat)

# Berechnen
duale_namen_df = berechne_duale_namen_anteil(df)

# Plotten
plt.figure(figsize=(10, 6))
sns.lineplot(data=duale_namen_df, x='jahr', y='anteil_dual', marker='o', color='teal')
plt.title('Anteil aller Namen, die für beide Geschlechter vergeben wurden', fontsize=14)
plt.xlabel('Jahr')
plt.ylabel('Anteil dual verwendeter Namen')
plt.grid(True, linestyle='--', alpha=0.5)
plt.tight_layout()
plt.show()

# Für jedes Jahr: durchschnittliche Anzahl pro Name
seltenheit = df.groupby(['jahr', 'vorname'])['anzahl'].sum().reset_index()
seltenheit_avg = seltenheit.groupby('jahr')['anzahl'].mean().reset_index()

# Plot
plt.figure(figsize=(10, 6))
sns.lineplot(data=seltenheit_avg, x='jahr', y='anzahl', marker='o')
plt.title('Durchschnittliche Nennungen pro Name (je niedriger, desto individueller)')
plt.xlabel('Jahr')
plt.ylabel('Ø Anzahl pro Name')
plt.grid(True)
plt.tight_layout()
plt.show()

import matplotlib.pyplot as plt
import seaborn as sns

# Liste der Politiker-Vornamen
politiker_namen = ['Markus', 'Horst', 'Edmund', 'Dieter', 'Christian']

# Filtern der Daten für die ausgewählten Namen
df_politiker = df[df['vorname'].isin(politiker_namen)]

# Gruppieren nach Jahr und Vorname
df_politiker_grouped = df_politiker.groupby(['jahr', 'vorname'])['anzahl'].sum().reset_index()

# Pivotieren für die Darstellung
df_pivot = df_politiker_grouped.pivot(index='jahr', columns='vorname', values='anzahl').fillna(0)

# Plot erstellen
plt.figure(figsize=(14, 8))
for name in politiker_namen:
    if name in df_pivot.columns:
        plt.plot(df_pivot.index, df_pivot[name], marker='o', label=name)

plt.title('Häufigkeit der Politiker-Vornamen in München über die Jahre')
plt.xlabel('Jahr')
plt.ylabel('Anzahl der Neugeborenen mit diesem Vornamen')
plt.legend()
plt.grid(True)
plt.tight_layout()
plt.show()