"text = input(\"Geben Sie eine Zeichenkette zum Testen ein:\")\n",
"ergebnis = re.findall(regaus, text)\n",
...
...
%% Cell type:markdown id: tags:
# Seminar Problemorientierte Programmierung
## 3 Extra: Reguläre Ausdrücke
Dieses Kapitel taucht nicht im englischen Python-Kurs auf und wird separat gepflegt.
In der Praxis können wir reguläre Ausdrücke nutzen, um in Texten zu suchen und Muster zu entdecken. Python bietet uns im `re`-Modul (re = Regular Expression = Regulärer Ausdruck) viele Funktionen an, um mit regulären Ausdrücken zu arbeiten.
Es gibt dabei zwei "Dimensionen" an denen wir uns "entlanghangeln" müssen: die Funktionen, die vom `re`-Modul bereitgestellt werden und die regulären Ausdrücke selber, die komplex werden können. Wir beginnen zunächst mit nur einer Funktion und werden Stück für Stück komplexere Ausdrücke kennenlernen. Danach schauen wir uns weitere Funktionen an.
### Ihre Lernziele
Beschreiben Sie in 2-3 Stichpunkten kurz was Sie im Seminar heute lernen wollen. Klicken Sie dazu doppelt auf diesen Text und bearbeiten Sie dann den Text:
-
-
-
### Exkurs: Was mir an Python gefällt
In ihrem Verzeichnis sollte eine Datei `test.txt` liegen. Öffnen Sie diese in einem Texteditor Ihrer Wahl. Schauen Sie jetzt, wie leicht man mit dem Modul `re` in Python E-Mail-Adressen extrahieren kann:
Wir können mit der Funktion `findall` alle Teilzeichenketten in einer Zeichenkette finden, die auf ein gegebenes Muster (in Form eines regulären Ausdrucks) passen. Die Funktion erwartet zwei Argumente: einen regulären Ausdruck und die Zeichenkette, die durchsucht werden soll:
%% Cell type:code id: tags:
```
import re
re.findall(r'f[a-z]*', 'which foot or hand fell fastest')
```
%% Cell type:markdown id: tags:
1. In der ersten Zeile wird das `re`-Modul importiert. Das muss einmal am Anfang unseres Programms passieren. Hier im Jupyter-Notebook reicht es, wenn das Modul in einem Block importiert wird - sobald der Block ausgeführt wurde, kann es in allen folgenden Blöcken verwendet werden.
2. In der nächsten Zeile wird - mittels der Punkt-Notation - die `findall`-Funktion im `re`-Modul aufgerufen.
3. Der Funktion werden zwei Argumente übergeben: `r'f[a-z]*'` und `'which foot or hand fell fastest'`.
4. Das erste Argument ist ein regulärer Ausdruck. Reguläre Ausdrücke werden in Hochkommata `''` eingeschlossen und beginnen mit einem `r`.
5. Das heißt, der eigentliche reguläre Ausdruck lautet `f[a-z]*`. Dieser Ausdruck beschreibt Zeichenketten, die mit einem `f` beginnen und von beliebig vielen - auch 0! - (`*`) Kleinbuchstaben (`[a-z]`) gefolgt werden. Dabei beschreibt der Ausdruck `[a-z]` in eckigen Klammern ein Zeichen, welches die Werte `a` bis `z` haben darf, das `*` dahinter besagt, dass dieses Zeichen beliebig oft wiederholt werden darf.
6. Das zweite Argument (`'which foot or hand fell fastest'`) ist die Zeichenkette, in der wir nach Teilzeichenketten suchen, die auf den übergebenen regulären Ausdruck passen.
Das Ergebnis des Aufrufs von `findall` ist eine Liste der Teilzeichenketten, die auf das Muster passen - in unserem Beispiel sind das die Zeichenketten `foot`, `fell` und `fastest`.
Probieren Sie es hier selber aus:
%% Cell type:code id: tags:
```
#SIMON: Warum wird nichts erkannt?
regaus = r'f[a-z]*'
text = input("Geben Sie eine Zeichenkette zum Testen ein:")
ergebnis = re.findall(regaus, text)
if ergebnis:
print("Es wurden folgende Teilzeichenketten erkannt:", ergebnis)
else:
print("Leider wurde nichts erkannt, probieren Sie es noch einmal.")
```
%% Cell type:markdown id: tags:
Ändern Sie den regulären Ausdruck im folgenden Beispiel, so dass alle Wörter, die mit einem `b` beginnen ausgegeben werden:
%% Cell type:code id: tags:
```
re.findall(r'b', 'Wir bauten und bohrten bis das Haus fertig war.')
```
%% Cell type:markdown id: tags:
Die Ausgabe sollte so aussehen:
```
['bauten', 'bohrten', 'bis']
```
Ändern Sie den regulären Ausdruck, so dass jetzt nur Wörter ausgegeben werden, die mit einem `b` beginnen und mit einem `n` enden. Die Ausgabe sollte dann so aussehen:
```
['bauten', 'bohrten']
```
Welche Probleme sind bei Ihren Versuchen aufgetreten?
-
-
%% Cell type:markdown id: tags:
### 3.2 Schritt für Schritt: ein beliebiges Zeichen
Der Punkt `.` steht für ein beliebiges Zeichen:
%% Cell type:code id: tags:
```
re.findall(r'a.', "Am Anfang aßen wir alle Manna und Kartoffeln")
```
%% Cell type:markdown id: tags:
Im Satz `Am Anfang aßen wir alle Kartoffeln.` gibt es genau sechs Vorkommen von einem kleinen `a` mit einem Zeichen dahinter. Wie wir sehen, wird auch das `a` am Ende von `Manna`, welches von einem Leerzeichen gefolgt ist, erkannt. Das liegt daran, dass der Punkt für wirklich jedes Zeichen (auch das Leerzeichen) steht. Die zwei Zeichenketten `Am` und `An` werden nicht erkannt, da sie ein großes `A` enthalten, wir aber nach einem kleinen gesucht haben.
%% Cell type:markdown id: tags:
### 3.3 Und weiter
Sie kennen jetzt eine Funktion, um reguläre Ausdrücke in Python anzuwenden und damit Texte zu durchsuchen. Weitere Funktionen ermöglichen die Extraktion und das Ersetzen von Teilzeichenketten in Texten. Bevor wir diese Funktionen kennenlernen, ist es praktisch, mit regulären Ausdrücken vertraut zu werden. Eine sehr gute interaktive Übungsseite dazu finden Sie [hier](https://regexone.com/lesson/introduction_abcs). Arbeiten Sie diese Seite gemeinsam Schritt für Schritt durch. Schrecken Sie nicht vor dem englischen Text zurück - ich helfe Ihnen bei Fragen gerne weiter.
Es gibt noch viele andere gute Tutorials zu regulären Ausdrücken, z.B. [hier](https://ryanstutorials.net/regular-expressions-tutorial/) oder [hier](https://www.python-kurs.eu/re.php). Sie können auch eine dieser Anleitungen durcharbeiten, wenn Sie damit besser zurechtkommen.
%% Cell type:markdown id: tags:
### 3.4 weitere nützliche Funktionen des `re`-Moduls
Sie haben in den Tutorials einige regulären Ausdrücke kennengelernt. Nun können wir weitere Funktionen des `re`-Moduls benutzen. Im Folgenden werden mehrere Funktionen vorgestellt. Anschließend können Sie diese in Übungen testen.
%% Cell type:markdown id: tags:
#### 3.4.1 Suchen und Matchen
Die Funktion `findall(regex,string)` haben sie schon kennengelernt:
%% Cell type:code id: tags:
```
import re
re.findall(r'f[a-z]*', 'which foot or hand fell fastest')
```
%% Cell type:markdown id: tags:
Zudem gibt es eine Funktion `search(regex,string)`. Die Argumente sind diesselben wie bei `findall`.
Diese Funktion durchsucht eine Zeichenkette *string* nach dem Vorkommen eines Teilstrings, der auf den regulären Ausdruck *regex* passt. Der erste gefundene Teilstring wird zurückgeliefert. Die Rückgabe ist ein sogennantes *match-Objekt*.
%% Cell type:code id: tags:
```
import re
object1 = re.search(r'f[a-z]*', 'which foot or hand fell fastest')
object2 = re.search(r'f[a-z]*', 'The regex did not match anything.')
print(object1,"\n",object2)
```
%% Cell type:markdown id: tags:
Ein *match-Objekt* enthält die Methoden `group()`, `span()`, `start()` und `end()`, die man im folgenden Beispiel im selbsterklärenden Einsatz sieht:
%% Cell type:code id: tags:
```
object1 = re.search(r'f[a-z]*', 'which foot or hand fell fastest')
print(object1.group())
print(object1.span())
print(object1.start())
print(object1.end())
```
%% Cell type:markdown id: tags:
Es gibt zuletzt noch eine dritte Funktion `match(regex,string)`. Diese Funktion checkt, ob ein Teilstring, der auf den regulären Ausdruck *regex* passt, am Anfang der Zeichenkette *string* vorkommt, Die Rückgabe ist wieder ein *match-Objekt*.
%% Cell type:code id: tags:
```
object1 = re.match(r'f[a-z]*', 'foot or hand fell fastest')
object2 = re.match(r'f[a-z]*', 'which foot or hand fell fastest')
print(object2)
print(object1)
print(object1.group())
print(object1.span())
print(object1.start())
print(object1.end())
```
%% Cell type:markdown id: tags:
#### 3.4.1 Übung:
Denken Sie sich eine Zeichenkette und einen regulären Ausdruck aus, die die Unterschiede der drei kennengelernten Funktionen wiedergibt.
%% Cell type:code id: tags:
```
```
%% Cell type:markdown id: tags:
#### 3.4.2 Ersetzen
%% Cell type:markdown id: tags:
Das `re`-Modul stellt nicht nur Funktionen zum Durchsuchen von Zeichenketten zur Verfügung. Mit der Funktion `re.sub(regex, replacement, string)` kann man Teilstrings ersetzen. Jede Übereinstimmung des regulären Ausdrucks *regex* in der Zeichenkette *string* wird durch die Zeichenkette *replacement* ersetzt.
%% Cell type:code id: tags:
```
re.sub(r'f[a-z]*', 'beer', 'which foot or hand fell fastest')
```
%% Cell type:markdown id: tags:
#### 3.4.3 Kompilieren
Wenn man bestimmte reguläre Ausdrücke mehrmals benutzen möchte, kann man die Funktion `compile(regex)` benutzen. Diese Funktion kompiliert einen regulären Ausdruck *regex* in eine regex-Objekt. Dieses kann man dann für weitere Funktionen nutzen.
%% Cell type:code id: tags:
```
regex_1 = re.compile(r'f[a-z]*')
print(regex_1.findall('which foot or hand fell fastest'))
print(regex_1.search('which foot or hand fell fastest'))
print(regex_1.match('which foot or hand fell fastest'))
print(regex_1.sub('beer','which foot or hand fell fastest'))
```
%% Cell type:markdown id: tags:
### Aufgaben
#### Aufgabe 1
Schreiben Sie eine Funktion, die eine Zeichenkette als Parameter entgegennimmt und überprüft, ob die Zeichenkette nur Kleinbuchstaben und Zahlen enthält.
Benutzen Sie reguläre Ausdrücke und die obigen Funktionen.
%% Cell type:code id: tags:
```
```
%% Cell type:markdown id: tags:
#### Aufgabe 2
Schreiben Sie eine Funktion, die eine Zeichenkette als Parameter entgegennimmt und überprüft, ob die Zeichenkette einen Teilstring enthält, der aus einem "a" und nachfolgend aus mindestens einem "b" besteht. (z.B. "abb", "abbbbb", "abbbbbbbbbbbbbbbb").
Benutzen Sie reguläre Ausdrücke und die obigen Funktionen.
%% Cell type:code id: tags:
```
```
%% Cell type:markdown id: tags:
#### Aufgabe 3
Schreiben Sie eine Funktion, die eine Zeichenkette als Parameter entgegennimmt und alle darin enthaltenen Leerzeichen durch ein Minus ersetzt.
Benutzen Sie reguläre Ausdrücke und die obigen Funktionen.
%% Cell type:code id: tags:
```
```
%% Cell type:markdown id: tags:
#### Aufgabe 4
Schreiben Sie eine Funktion, die eine Zeichenkette *s* und eine natürliche Zahl *n* als Parameter entgegennimmt und alle Wörter der Länge n aus der Zeichenkette *s* entfernt.
Benutzen Sie reguläre Ausdrücke und die obigen Funktionen.
%% Cell type:code id: tags:
```
```
%% Cell type:markdown id: tags:
 Speichern Sie dieses Notebook so, dass Ihre Änderungen nicht verlorengehen (nicht auf einem Pool-Rechner). Klicken Sie dazu oben links auf das Disketten-Icon und nutzen Sie beispielsweise einen USB-Stick, E-Mail, Google Drive, Dropbox oder Ihre [HU-Box](https://box.hu-berlin.de/).
Dieses Notebook ist als freies Werk unter der Lizenz [Creative Commons Attribution-NonCommercial 3.0 Unported](http://creativecommons.org/licenses/by-nc/3.0/) verfügbar. Sie dürfen die Inhalte kopieren, verteilen und verändern, solange Sie die Urheber nennen und sie nicht für kommerzielle Zwecke nutzen.
