# 8-1
# Frequenzliste wie auf Blatt 7 erzeugen
f = open("dostojewski.txt", "r")
text = f.read()
f.close()
wordCount = {}
for word in text.split():
    if word not in wordCount:
        wordCount[word] = 1
    else:
        wordCount[word] += 1
# Wir legen eine neue LISTE an, in dem die (Wörternamen + Häufigkeit) nach der Häufigkeit absteigend sortiert wird
freq_sorted = sorted(wordCount.items(), key=lambda x: x[1], reverse=True)

# Wir geben das erste WORT in dieser Liste aus und den zugehörigen WERT von dem ersten Eintrag dieser Liste aus
print(
    "Das häufigste Wort ist -" + freq_sorted[0][0] + "- und kommt",
    str(freq_sorted[0][1]),
    "mal vor.",
)

# 8-2
# Import random , damit wir eine Zufallszahl ausgeben können
import random

# Frequenzliste wie auf Blatt 7 erzeugen
f = open("dostojewski.txt", "r")
text = f.read()
f.close()
wordCount = {}
for word in text.split():
    if word not in wordCount:
        wordCount[word] = 1
    else:
        wordCount[word] += 1
# Liste in der alle Wörter mit genau einem Vorkommen drinnen gespeichert werden
singletons = []
for key, value in wordCount.items():
    if value == 1:
        singletons.append(key)
# Eine zufallszahl generieren und das entsprechende Wort aus der Liste ausgegeben
zufallszahl = random.randint(0, len(singletons))
print("Das Wort -", singletons[zufallszahl], "- kommt nur ein mal vor.")

# 8-3
# wget "http://de.wikipedia.org/wiki/Ludwig_Wittgenstein" −O wittgenstein.html
# lynx -dump -assume_charset=utf-8 -hiddenlinks=ignore -nolist -verbose wittgenstein.html > wittgenstein.txt

# 8-4
# Wieder Frequenzliste wie üblich erzeugen
f = open("wittgenstein.txt", "r")
text = f.read()
f.close()
wordCount = {}
for word in text.split():
    if word not in wordCount:
        wordCount[word] = 1
    else:
        wordCount[word] += 1
# Leere Liste erstellen, in der alle Wörter mit 10 oder mehr Vorkommen gespeichert werden
tenPlusOccurences = []
# Durch die Frequenzliste laufen und prüfen, ob der Wert eines Wortes >= 10 ist und dann der Liste anhängen
for key, value in wordCount.items():
    if value >= 10:
        tenPlusOccurences.append(key)
print(tenPlusOccurences)

# 8-5
# Wieder Frequenzliste wie üblich erzeugen
f = open("wittgenstein.txt", "r")
text = f.read()
f.close()
wordCount = {}
for word in text.split():
    if word not in wordCount:
        wordCount[word] = 1
    else:
        wordCount[word] += 1
# Neues Textdatei öffnen, in die reingeschrieben werden soll
with open("grosse_woerter.txt", "w") as f2:
    for key, value in wordCount.items():
        # Wir betrachten den ersten Buchstaben jedes Wortes schauen mit .isupper(), ob dieser groß ist.
        if key[0].isupper():
            f2.write(key + "\n")

#8-6

#a)
3_buchst_reg = re.compile(r'^\w{3}$')  # Alle Wörter mit 3 Buchstaben

#b)
vokal_reg = re.compile(r'[aeiouAEIOU]+')  # Alle Wörter mit Vokalen

#c)
uml_reg = re.compile(r'[äöüÄÖÜ]+')  # Alle Wörter mit Umlauten

#d)
net_reg = re.compile(r'net$')  # Alle Wörter die auf -net Enden

#e)
vok_3_5_reg = re.compile(r'^[aeiouAEIOU]\w{2,4}$')  # Alle Wörter die mit einem vokal anfangen und 3-5 Buchstaben haben

#f)
ung_reg = re.compile(r'^[A-ZÄÖÜ]\w*ung$')  # Alle goßgeschriebenen Wörter, die auf -ung enden

#g)
gr_8_reg = re.compile(r'^[A-ZÄÖÜ]{1,8}$')  # Alle großgeschriebenen Wörter die max. 8 Buchstaben lang sind

#h)
vok_uml_reg = re.compile(r'^[^aeiouöüAEIOUÄÖÜ]*$')  # Alle Wörter, die mit einem vokal oder Umlaut beginnen


#8-7

import re
text = open("wittgenstein.txt", "r").read().split('\n') 
#Datei öffnen, in String einlesen und am Newline aufteilen

wort_regex = re.compile(r'\w+') #alle Wörter
klein_regex = re.compile(r'^[a-zäöü]\w+')  # alle kleingeschriebenen Wörter

freq = {}

# Erzeugen einer Frequenzliste wie auf dem letzten Aufgabenblatt
for zeile in text:
    for word in re.findall(wort_regex, zeile): 
    #alles, was dem Regex entspricht, d.h. nur Buchstaben
        if word in freq:
            freq[word] += 1
        else:
            freq[word] = 1

for word in freq.keys(): #nur die Keys werden durchgegangen
    if re.match(klein_regex, word): #wenn der Regex genau auf den Anfang passt
        print(word)  # Ausgabe aller kleinen Wörter

#8-8

import re
text = open("wittgenstein.txt", "r").read().split('\n') #s.o.

groß_regex = re.compile(r'^[A-ZÄÖÜ]')
#alle Wörter, die mit einem Großbuchstaben anfangen

for zeile in text:
   zeile = zeile.strip() # Leerstellen am Anfang und am Ende der Zeile entfernen
   if re.match(groß_regex, zeile):
        print(zeile)  # Ausgabe aller Zeilen, die mit einem Großbuchtsaben beginnen


#8-9

import re
text = open("wittgenstein.txt", "r").read().split('\n') #s.o.

artikel_regex = re.compile(r'\b(der|die|das|Der|Die|Das)\b')  
# matched der, die, das und Der, Die, Das

for zeile in text:
   zeile = zeile.strip() #s.o.
   if re.search(artikel_regex, zeile): #wenn der Regex irgendwo in der Zeile passt
        print(zeile)

#8-10

import re
text = open("wittgenstein.txt", "r").read().split('\n') #s.o.

wortsz_regex = re.compile(r'\w+[?!.,;;-_:]$')  # matched Satzzeichen am Ende eines Wortes

freqliste = {}

# Erzeugen eine Frequenzliste aus Wörtern mit Satzzeichen am Ende
for zeile in text:
    for word in re.findall(wortsz_regex, zeile): #funktioniert wie der "Wortregex"
        if word in freqliste:
            freqliste[word] += 1
        else:
            freqliste[word] = 1

for word in freqliste.keys():
#jetzt geben wir jedes Wort nur noch einmal aus
    print(word)


# 8-11
# Archive von Herrn Hadersbecks Seite runterladen und entpacken, Textdatei in lokalen Ordner kopieren
search_term = input("Bitte geben Sie einen Suchbegriff ein: ")
# Eingabe umdrehen
reversed_search_term = search_term[::-1]
# Umgedrehten Term einmal ausgeben.
print(search_term, "umgedreht: ", reversed_search_term)
# Große Datei öffnen und in String speichern.
f = open("sz_1Mio.txt", "r")
text = f.read()
f.close()
# Einzeln durch die Wörter durchlaufen
for word in text.split():
    # prüfen ob der string vom reversed_search_term irgendwo innerhalb des "word" vorzufinden ist
    if reversed_search_term in word:
        print(word)