%%time

FILE = 'protokolle_txt.json.zip'

if os.path.exists(FILE):
    # Protokolle aus Datei laden
    with gzip.open(FILE, 'rt') as f:
        protokolle_txt = json.load(f)
else:
    # Protokolle herunterladen
    protokolle_txt = dict()

%%time

# Status 8.8.2016
# Stenographische Protokolle in strukturiertem HTML Format ab XXII. Gesetzgebungsperiode (23.05.2006, 150. NR Sitzung)
# Ab XXIII. Gesetzgebungsperiode (1. Sitzung 30.10.2006) durchgehend neues Format.
# Analysiere daher ab XXIII. Gesetzgebungsperiode
# Aktuellstest Protokoll: XXV. Gesetzgebungsperiode, 24.02.2016
gesetzgebungsperioden = ('XXV', 'XXIV', 'XXIII')

for gp in gesetzgebungsperioden:
    print(' ')
    print(gp)

    # Internetseite mit Links zu den Protokollen der entsprechenden Gesetzgebungsperidoe wird abgerufen
    r = requests.get(BASIS_URL + LISTE_URL.format(gp = gp))

    soup = BeautifulSoup(r.text, 'lxml')

    # Alle Links in der Ergebnistabelle
    links = soup.find('table', class_='tabelle filter').find_all('a')
    # Davon alle auf Stenographisches Protokoll in HTML Format
    links = [link for link in links if link.text == 'HTML']
    # Davon die URL
    links = [link.get('href') for link in links]

    for link in links:
        # In der URL steckt die Nummer der Sitzung, der zur Information ausgegeben wird
        print(link.split('/')[5].split('_')[1], end=' ')
        # Eindeutiger key des Protokolls, bestehend aus Gesetzperiode, Art der Sitzung (Nationalrat) und Nummer
        key = gp + '_' + link.split('/')[5]
        r_temp = requests.get(BASIS_URL + link)
        protokolle_txt[key] = r_temp.text
        
print()
# Protokolle in gezippten JSON File speichern
with gzip.open(FILE, mode="wt") as f:
    json.dump(protokolle_txt, f)

len(protokolle_txt)

protokolle_txt['XXIII_NRSITZ_00043'][:400]

%%time

FILE = 'df_protokolle.pkl'

if os.path.exists(FILE):
    # Protokolle aus Datei laden
    df = pd.read_pickle(FILE)

%%time

# key_okay speichert alle Protokolle, die bereits ausgelesen wurden.
# Nun sollte das Auslesen in einem Lauf funktioneren. Während des Entwickeln des Codes, 
# wurde der folgende Code öfters ausgeführt und ich wollte nicht jedesmal ganz von vorne anfangen.
key_okay=[]

# Ergebnis wird in einem Datenframe gespeichert
df = pd.DataFrame()
# Countdown damit man sieht, wie viele Protokolle noch ausgelesen werden müssen
countdown = len(protokolle_txt) - len(key_okay)

for key in protokolle_txt:
#for key in ('XXIV_NRSITZ_00207',):
    if key in key_okay:
        continue
    countdown = countdown - 1
    
    # HTML-Protokoll parsen mittels BeautifulSoup
    txt = protokolle_txt[key]
    soup = BeautifulSoup(txt, 'lxml')
    
    # Bei manchen Sitzungen gibt es Fehler bei den IDs (Name, Datum, ...).
    # Diese werden manuell überschrieben
    if key == 'XXIV_NRSITZ_00026':
        # Falsche IDs in entsprechendem Protokoll
        sitzung = '26. Sitzung des\r\nNationalrates der Republik Österreich'
        periode = 'XXIV. Gesetzgebungsperiode'
        datum = 'Dienstag, 16. Juni 2009'
    elif key == 'XXIII_NRSITZ_00060':    
        # Falsche IDs in entsprechendem Protokoll
        sitzung = '60. Sitzung des\r\nNationalrates der Republik Österreich'
        periode = 'XXIII. Gesetzgebungsperiode'
        datum = 'Donnerstag, 8. Mai 2008'        
    # Normalerweise lassen sich die IDs auslesen, Identifikation anhand HTML-Class IDs
    else:
        sitzung = soup.find('p', class_='DBl02').get_text()
        periode = soup.find('p', class_='DBl04').get_text()
        datum = soup.find('p', class_='DBl05').get_text()

    # Nochmals eine manuelle Datenbereinigung
    if key == 'XXIV_NRSITZ_00220':
        sitzung = '220. Sitzung des\r\nNationalrates der Republik Österreich'
        
    if key == 'XXV_NRSITZ_00001':
        datum = 'Dienstag, 29. Oktober 2013'

    if key == 'XXIII_NRSITZ_00021':    
        datum = 'Donnerstag, 3. Mai 2007' 
    
    print(countdown, ' - ', key, ' - ', periode[:periode.find('.')], ' - ', sitzung[:sitzung.find('.')])
    
    # Normalerweise sind Reden an HTML-Class 'StandardRB' (RB scheint für Rede-Beginn zu stehen) erkennbar
    rede_pos = soup.find('p', class_='StandardRB')

    while rede_pos != None:
        # Nun wird der Text der Rede ausgelesen.
        # Zuerst der Text des Paragraphs mit der 'StandardRB'-Class
        rede_txt = rede_pos.get_text()
        # Doch leider kann der Text über mehrere Paragraphen gehen.
        # Zusätzlich Reden des Schriftführers/der Schriftführerin ausschließen, gibt es bei den Angelobungen neuer
        # Abgeordneter, inklusive der Antworten "Ich gelobe." 
        # Hier gibt es oft Probleme mit den HTML-Classes, ebenso bei 
        while ((rede_txt.startswith('Schriftführer') == False) & 
               (max(rede_txt.find('Ich gelobe.'),rede_txt.find('Ich\r\ngelobe.')) == -1)):
            # Identifikation der HTML Klasse des nächsten Paragraphs
            rede_pos = rede_pos.find_next('p')
            klasse = rede_pos['class'] 
            # Paragraphen mit den folgenden Klassen sind eine Fortsetzung der Rede.
            # Daher wird der Text zur bestehenden Rede hinzugefügt 
            if klasse in (['MsoNormal'], ['StandardRB'], ['MsoBodyText'], ['MsoListBullet'], 
                          ['INHANTR'], 
                          ['MsoListBulletCxSpFirst'], ['MsoListBulletCxSpMiddle'], ['MsoListBulletCxSpLast'], 
                          ['MsoBodyText2'], ['MsoNormalCxSpMiddle']) :
                # INHANTR z.B. wegen XXII_NRSITZ_00058
                # MsoListBulletCxSpFirst, ...Middle und ... Last z.B. wegen XXV_NRSITZ_00012
                # MsoBodyText2 z.B wegen XXII_NRSITZ_00051, könnte man auch als Ende verwenden 
                # MsoNormalCxSpMiddle z.B. wegen XXIV_NRSITZ_00159
                rede_txt = rede_txt + rede_pos.get_text()
            # Die folgenden Klassen markieren das Ende einer Rede 
            elif klasse in (['StandardRE'], ['RE'], ['StandardR'], ['SB'], ['RE0']):
                # RE0 z.B. wegen XXII_NRSITZ_00035
                rede_txt = rede_txt + rede_pos.get_text()
                df = df.append({'key':key, 'sitzung': sitzung, 'periode': periode, 'datum': datum, 'rede': rede_txt}, 
                               ignore_index=True)
                break
            # Die folgenden Klassen markieren einen Zwischentext, der nicht Teil der Rede ist
            elif klasse in (['ZM'],['RB'], ['Format1']):
                # 'ZM' - Entschließungsantrag
                # 'RB' - Redebeginn, nicht benötigt, verwende StandardRB
                pass
            # Nicht oben erwähnte Klasse führt zu Fehlermeldung und speichert Dokument, 
            # damit es genauer analysiert werden kann.
            # Wurde während der Entwicklung verwendet, sollte jetzt nicht vorkommen, es sei denn,
            # es kommen neue Protokolle mit neuen Formatierungen vor
            else:
                print(key)
                print(klasse)
                print(rede_txt)
                with open('temp.html', 'w', encoding='utf8') as fp:
                    fp.write(protokolle_txt[key])
                raise ValueError('Unerwartetes Element in Rede')
        
        # Finde Start der nächsten Rede
        if key == 'XXIV_NRSITZ_00120':
            # 'Falsches StandardR in entsprechendem Protokoll
            rede_pos = rede_pos.find_next('p', class_=lambda x: x in ('StandardRB', 'StandardR'))
        else:
            rede_pos = rede_pos.find_next('p', class_='StandardRB')
            
            
    key_okay.append(key)
    
df.to_pickle('df_protokolle.pkl')

df.info()

df[:3]

df.loc[df.key=='XXIV_NRSITZ_00023', 'datum'].iloc[0]

df.loc[df.key=='XXIV_NRSITZ_00023', 'datum'].iloc[0]

df.groupby(df.datum.dt.year)[['key']].count()

sns.set(context='talk', style='whitegrid')
sns.countplot(y=df.datum.dt.year, data=df)
sns.despine()
sns.set(font_scale=1.5)
sns.plt.title('Anzahl Reden pro Jahr')
sns.set(font_scale=1)
sns.axlabel('Reden', 'Jahr')
sns.plt.savefig('reden_pro_jahr.svg')

sns.set(context='talk', style='whitegrid')
sns.countplot(y=df.datum.dt.month, data=df)
sns.despine()
sns.set(font_scale=1.5)
sns.plt.title('Anzahl Reden pro Monat')
sns.set(font_scale=1)
sns.axlabel('Reden', 'Monat')
sns.plt.savefig('reden_pro_monat.svg')

sns.set(context='talk', style='whitegrid')
ax = sns.countplot(y=df.datum.dt.dayofweek, data=df)
sns.despine()
sns.set(font_scale=1.5)
sns.plt.title('Anzahl Reden pro Wochentag')
sns.set(font_scale=1)
sns.axlabel('Reden', 'Wochentag')
#labels = [item.get_text() for item in ax.get_yticklabels()]
labels = ['Mo', 'Di', 'Mi', 'Do', 'Fr', 'Sa']
ax.set_yticklabels(labels)
sns.plt.savefig('reden_pro_wochentag.svg')

df_temp = (df.groupby([df.datum.dt.year, df.datum.dt.month])['key'].count()).unstack()
mask = df_temp.isnull()
df_temp = df_temp.fillna(value=0)
df_temp = df_temp.astype('int')
df_temp[:3]

sns.set(context='talk', style='whitegrid')
sns.heatmap(df_temp, annot=True, linewidths=.5, fmt='d', mask=mask)
#sns.despine()
sns.set(font_scale=1.5)
sns.plt.title('Anzahl Reden (in 100 Reden)')
sns.set(font_scale=1)
sns.axlabel('Monat', 'Jahr')
sns.plt.savefig('reden_pro_jahr_monat.svg')

df_temp = (df.groupby([df.datum.dt.dayofweek, df.datum.dt.year])['key'].count()).unstack()
df_temp.index = ['Mo', 'Di', 'Mi', 'Do', 'Fr', 'Sa']
mask = df_temp.isnull()
df_temp = df_temp.fillna(value=0)
df_temp = df_temp.astype('int')
df_temp[:3]

sns.set(context='talk', style='whitegrid')
sns.heatmap(df_temp, annot=True, linewidths=.5, fmt='d', mask=mask)
sns.set(font_scale=1.5)
sns.plt.title('Anzahl Reden (in 100 Reden)')
sns.set(font_scale=1)
sns.axlabel('Jahr', 'Wochentag')
sns.plt.savefig('reden_pro_wochentag_jahr.svg')

df_temp = (df.groupby([df.datum.dt.dayofweek, df.datum.dt.month])['key'].count()).unstack()
df_temp.index = ['Mo', 'Di', 'Mi', 'Do', 'Fr', 'Sa']
mask = df_temp.isnull()
df_temp = df_temp.fillna(value=0)
df_temp = df_temp.astype('int')
df_temp[:3]

sns.set(context='talk', style='whitegrid')
sns.heatmap(df_temp, annot=True, linewidths=.5, fmt='d', mask=mask)
sns.set(font_scale=1.5)
sns.plt.title('Anzahl Reden (in 100 Reden)')
sns.set(font_scale=1)
sns.axlabel('Monat', 'Wochentag')
sns.plt.savefig('reden_pro_wochentag_monat.svg')

len(TITEL_REGIERUNG)

%%time
df = pd.concat([df, df.rede.apply(formatieren)], axis=1)

df[:3]

df.redner_anrede.value_counts()

len(df[df.redner_anrede == 'Abgeordneter']) / len(df[df.redner_anrede == 'Abgeordnete'])

len(df[df.redner_anrede == 'Abgeordnete']) / len(df[df.redner_anrede == 'Abgeordneter'])

len(df.redner_anrede.unique())

df.loc[df.redner_anrede.str.contains('Kultur'), 'redner_anrede'].value_counts()

df_temp = df.loc[df.redner_anrede.str.contains('Kultur'), ['redner_anrede', 'datum']]
df_temp.groupby([df.datum.dt.year, df.redner_anrede])['redner_anrede'].count()

df_ratio = df.groupby(df.datum.dt.year)[['redner_anrede']].agg(lambda x: 
                                                               sum(x == 'Abgeordnete') / sum(x == 'Abgeordneter') * 100)
df_ratio.columns = ['Frau pro Mann']
df_ratio[:3]

sns.set(context='talk', style='whitegrid')
sns.barplot(x='datum', y='Frau pro Mann', data=df_ratio.reset_index())
sns.despine()
sns.set(font_scale=1.5)
sns.plt.title('Reden von weiblichen Abgeordneten pro 100 Reden von männlichen')
sns.set(font_scale=1)
sns.axlabel('Jahr', 'Anzahl')
sns.plt.savefig('geschlecht.svg')

df.redner_partei.value_counts()

df.loc[df.redner_partei == '', ['redner_name', 'redner_partei']]

df.loc[df.redner_partei == 'Andere', 'redner_anrede'].value_counts()

df.redner_partei.value_counts()

parteien_ordnung = ['Regierung', 
                    'SPÖ', 
                    'ÖVP', 
                    'FPÖ', 
                    'Grüne', 
                    'BZÖ',
                    'STRONACH',
                    'NEOS',
                    'Andere']

# Farbennamen von http://www.luminoso.com/colors/
parteien_farben = ['grey', #Regierung 
                   'red', 
                   'black', 
                   'blue', 
                   'green', 
                   'orange',
                   'yellow',
                   'pink', 
                   'light grey'] #Andere
sns.palplot(sns.xkcd_palette(parteien_farben))

df.groupby(['redner_partei', 'periode'])[['key']].count().unstack()

sns.set(context='talk', style='whitegrid', palette=sns.xkcd_palette(parteien_farben))
sns.countplot(y='redner_partei', data=df, order=parteien_ordnung)
sns.despine()
sns.set(font_scale=1.5)
sns.plt.title('Reden pro Partei')
sns.set(font_scale=1)
sns.axlabel('Reden', '')
sns.plt.savefig('reden_pro_partei.svg')

df_temp = df.groupby([df.datum.dt.year, 'redner_partei'])[['key']].count().unstack()
df_temp[:3]

df_temp = df_temp.apply(lambda x: x / np.sum(x), axis=1) * 100
df_temp[:3]

df_temp = df_temp.stack().reset_index()
df_temp = df_temp.rename(columns={'redner_partei': 'Partei'})
df_temp[:3]

sns.set(context='talk', style='whitegrid', palette=sns.xkcd_palette(parteien_farben))
ax = sns.factorplot(x = 'datum', y = 'key', hue = 'Partei' , data = df_temp, size=8, hue_order=parteien_ordnung)
ax.set(ylim=(0, 30))
sns.despine()
sns.set(font_scale=1.5)
sns.plt.title('% Reden pro Partei')
sns.set(font_scale=1)
sns.axlabel('Jahr', 'Prozent')
sns.plt.savefig('reden_pro_partei_pro_jahr.svg')

df_temp = (df.groupby([df.datum.dt.year, df.redner_partei])['key'].count()).unstack()
df_temp = df_temp[parteien_ordnung]
df_temp = df_temp.transpose()
mask = df_temp.isnull()
df_temp = df_temp.fillna(value=0)
df_temp = df_temp.astype('int')
df_temp[:13]

sns.set(context='talk', style='whitegrid', palette=sns.xkcd_palette(parteien_farben))
sns.heatmap(df_temp, annot=True, linewidths=.5, fmt='d', mask=mask)
#sns.despine()
sns.set(font_scale=1.5)
sns.plt.title('Anzahl Reden (in 100 Reden)')
sns.set(font_scale=1)
sns.axlabel('Partei', 'Jahr')
#sns.plt.savefig('geschlecht.svg')

df_ratio = df.groupby([df.datum.dt.year, 'redner_partei'])[['redner_anrede']].agg(lambda x: 
                                                               sum(x == 'Abgeordnete') / sum(x == 'Abgeordneter')*100)
df_ratio = df_ratio.reset_index()
df_ratio = df_ratio.rename(columns={'redner_partei': 'Partei', 'redner_anrede': 'Rednerin pro Redner'})

df_ratio = df_ratio.loc[df_ratio.Partei != 'Regierung']
df_ratio[:3]

sns.set(context='talk', style='whitegrid', palette=sns.xkcd_palette(parteien_farben_ohne_regierung))

ax = sns.factorplot(x = 'datum', y = 'Rednerin pro Redner', hue = 'Partei' , data = df_ratio, size=8, 
                    hue_order=parteien_ordnung_ohne_regierung)
ax.set(ylim=(0, 110))
sns.despine()
sns.set(font_scale=1.5)
sns.plt.title('Reden weiblicher Abgeordneter je 100 Reden von männlichen Abgeordneten')
sns.set(font_scale=1)
sns.axlabel('Jahr', 'Reden')
sns.plt.savefig('geschlecht_je_partei.svg')

df[df.redner_partei == 'NEOS'].groupby([df.datum.dt.year, 'redner_anrede', 'redner_name'])[['key']].count().unstack('datum')

df[df.redner_partei == 'STRONACH'].groupby([df.datum.dt.year, 'redner_anrede', 'redner_name'])[['key']].count().unstack('datum')

anzahl_woerter('Johnny.Appleseed!is:a*good&farmer')

%%time
df['rede_anzahl_woerter'] = df.rede_txt.apply(anzahl_woerter)

df[:3]

df_temp = (df.groupby(df.datum.dt.year)
            .agg({'rede_anzahl_woerter': 'sum', 'key': 'count'})
            .rename(columns={'rede_anzahl_woerter': 'woerter', 'key': 'reden'}))
df_temp['woerter_pro_rede'] = df_temp['woerter'] / df_temp['reden']
df_temp[:3]

sns.set(context='talk', style='whitegrid', palette=sns.xkcd_palette(parteien_farben))
sns.barplot(x='datum', y='woerter_pro_rede', data=df_temp.reset_index())
sns.despine()
sns.set(font_scale=1.5)
sns.plt.title('Durchschnittliche Anzahl an Worten pro Rede je Jahr')
sns.set(font_scale=1)
sns.axlabel('Jahr', 'Wörter pro Rede')
sns.plt.savefig('woerter_pro_rede_je_jahr.svg')

df_temp = (df.groupby('redner_partei')
            .agg({'rede_anzahl_woerter': 'sum', 'key': 'count'})
            .rename(columns={'rede_anzahl_woerter': 'woerter', 'key': 'reden'}))
df_temp['woerter_pro_rede'] = df_temp['woerter'] / df_temp['reden']
df_temp[:3]

sns.set(context='talk', style='whitegrid', palette=sns.xkcd_palette(parteien_farben))
sns.barplot(x='redner_partei', y='woerter_pro_rede', data=df_temp.reset_index(), order=parteien_ordnung)
sns.despine()
sns.set(font_scale=1.5)
sns.plt.title('Durchschnittliche Anzahl an Worten pro Rede je Partei')
sns.set(font_scale=1)
sns.axlabel('Partei', 'Wörter pro Rede')
sns.plt.savefig('woerter_pro_rede_je_partei.svg')

df_temp = (df.groupby([df.datum.dt.year, 'redner_partei'])
            .agg({'rede_anzahl_woerter': 'sum', 'key': 'count'})
            .rename(columns={'rede_anzahl_woerter': 'woerter', 'key': 'reden'}))
df_temp['woerter_pro_rede'] = df_temp['woerter'] / df_temp['reden']
df_temp = df_temp.woerter_pro_rede
df_temp = df_temp.unstack()
df_temp = df_temp / 100
df_temp = df_temp[parteien_ordnung]
df_temp = df_temp.transpose()
df_temp[:3]

sns.set(context='talk', style='whitegrid', palette=sns.xkcd_palette(parteien_farben))
sns.heatmap(df_temp, annot=True, linewidths=.5)
sns.despine()
sns.set(font_scale=1.5)
sns.plt.title('Durchschnittliche Wörter pro Rede (in 100 Wörtern)')
sns.set(font_scale=1)
sns.axlabel('Jahr', 'Partei')
#sns.plt.savefig('geschlecht.svg')

df.sort_values(by='rede_anzahl_woerter', ascending=False)[:10]

df_temp = df.groupby([df.datum.dt.year, 'redner_partei'])[['rede_anzahl_woerter']].sum().unstack()

df_temp = df_temp.apply(lambda x: x / np.sum(x), axis=1) * 100

df_temp = df_temp.stack().reset_index()
df_temp = df_temp.rename(columns={'redner_partei': 'Partei', '0': 'rede_anzahl_woerter'})
df_temp[:3]

sns.set(context='talk', style='whitegrid', palette=sns.xkcd_palette(parteien_farben))

ax = sns.factorplot(x = 'datum', y = 'rede_anzahl_woerter', hue = 'Partei' , data = df_temp, size=8, 
                    hue_order=parteien_ordnung)
ax.set(ylim=(0, 25))
sns.despine()
sns.set(font_scale=1.5)
sns.plt.title('% Wörter pro Partei')
sns.set(font_scale=1)
sns.axlabel('Jahr', 'Prozent')
sns.plt.savefig('woerter_pro_partei_je_jahr.svg')

df_temp = (df.groupby([df.datum.dt.year, df.redner_partei])['rede_anzahl_woerter'].sum()).unstack()
df_temp = df_temp[parteien_ordnung]
df_temp = df_temp.transpose()
mask = df_temp.isnull()
df_temp = df_temp.fillna(value=0)
df_temp = round(df_temp / 10000)
df_temp = df_temp.astype('int')
df_temp[:13]

sns.set(context='talk', style='whitegrid', palette=sns.xkcd_palette(parteien_farben))
sns.heatmap(df_temp, annot=True, linewidths=.5, fmt='d', mask=mask)
#sns.despine()
sns.set(font_scale=1.5)
sns.plt.title('Anzahl Wörter (in 10 000)')
sns.set(font_scale=1)
sns.axlabel('Partei', 'Jahr')
#sns.plt.savefig('geschlecht.svg')

df_temp = (df.groupby(df.datum.dt.month)
            .agg({'rede_anzahl_woerter': 'sum', 'key': 'count'})
            .rename(columns={'rede_anzahl_woerter': 'woerter', 'key': 'reden'}))
df_temp['woerter_pro_rede'] = df_temp['woerter'] / df_temp['reden']
df_temp[:3]

sns.set(context='talk', style='whitegrid')
sns.barplot(x='datum', y='woerter_pro_rede', data=df_temp.reset_index())
sns.despine()
sns.set(font_scale=1.5)
sns.plt.title('Durchschnittliche Wörter pro Rede je Monat')
sns.set(font_scale=1)
sns.axlabel('Monat', 'Wörter je Rede')
#sns.plt.savefig('geschlecht.svg')

df_temp = (df.groupby([df.datum.dt.month, df.datum.dt.year])
            .agg({'rede_anzahl_woerter': 'sum', 'key': 'count'})
            .rename(columns={'rede_anzahl_woerter': 'woerter', 'key': 'reden'}))
df_temp['woerter_pro_rede'] = df_temp['woerter'] / df_temp['reden']
df_temp = df_temp.woerter_pro_rede
df_temp = df_temp.unstack()
df_temp = df_temp / 100
df_temp[:3]

sns.set(context='talk', style='whitegrid', palette=sns.xkcd_palette(parteien_farben))
sns.heatmap(df_temp, annot=True, linewidths=.5)
sns.despine()
sns.set(font_scale=1.5)
sns.plt.title('Durchschnittliche Wörter pro Rede (in 100 Wörtern)')
sns.set(font_scale=1)
sns.axlabel('Monat', 'Jahr')
#sns.plt.savefig('geschlecht.svg')

df_temp = (df.groupby(df.datum.dt.dayofweek)
            .agg({'rede_anzahl_woerter': 'sum', 'key': 'count'})
            .rename(columns={'rede_anzahl_woerter': 'woerter', 'key': 'reden'}))
df_temp['woerter_pro_rede'] = df_temp['woerter'] / df_temp['reden']
df_temp[:3]

sns.set(context='talk', style='whitegrid')
ax = sns.barplot(y='datum', x='woerter_pro_rede', data=df_temp.reset_index(), orient='h')
sns.despine()
sns.set(font_scale=1.5)
sns.plt.title('Durchschnittliche Wörter pro Rede je Wochentag')
sns.set(font_scale=1)
sns.axlabel('Wörter je Rede', 'Wochentag')
labels = ['Mo', 'Di', 'Mi', 'Do', 'Fr', 'Sa']
ax.set_yticklabels(labels)
sns.plt.savefig('woerter_pro_wochentag.svg')

df_temp = (df.groupby([df.datum.dt.dayofweek, df.datum.dt.month])
            .agg({'rede_anzahl_woerter': 'sum', 'key': 'count'})
            .rename(columns={'rede_anzahl_woerter': 'woerter', 'key': 'reden'}))
df_temp['woerter_pro_rede'] = df_temp['woerter'] / df_temp['reden']
df_temp = df_temp.woerter_pro_rede
df_temp = df_temp.unstack()
df_temp = df_temp / 100
df_temp.index = ['Mo', 'Di', 'Mi', 'Do', 'Fr', 'Sa']
df_temp[:3]