Mustererkennung mit Regulären Ausdrücken

Mustererkennung mit Regular Expressions (RegEx)

https://oer-informatik.de/regex

https://bildung.social/@oerinformatik/110397061085890869

tl/dr; (ca. 20 min Lesezeit): Die Mustererkennung Regulärer Ausdrücke (RegEx) ermöglicht Automatisierungen an Stellen, wo Handarbeit mühsam und langwierig ist. Telefonnummern in unterschiedlichen Formaten gespeichert? In einer CSV-Datei alle Spalten in verkehrter Reihenfolge? Wo stecken im Fließtext Geldbeträge mit Nachkommastellen? Derlei Aufgaben lassen sich mit RegEx lösen - besser man kennt sie! (Zuletzt geändert am 23.05.2023)

Was sind Reguläre Ausdrücke?

Ein Regulärer Ausdruck (RegEx) ist eine Zeichenkette, die Muster in Zeichenketten mithilfe von syntaktischen Regeln beschreibt.

Reguläre Ausdrücke helfen vor allem dabei, Teilstrings zu finden oder zu ersetzen, die einem einheitlichen Muster entsprechen, sich aber nicht durch einfache Wildcards (wie z.B. ? oder *) ausdrücken lassen.

So lassen sich beispielsweise relativ einfach Muster bilden, die in einem vorhandenen langen Text alle Geldbeträge, Telefonnummern, Internetlinks, EAN-Nummern oder E-Mail-Adressen finden.

Ein Einstiegs-Beispiel für eine RegEx: die Klassenbezeichnungen an unserer Schule folgen der Logik:

1. Großbuchstabe: Abteilung
2.+3. Großbuchstabe: Ausbildungsberuf
4. Zahl: Einschulungsjahr (letzte Stelle)
5. Großbuchstaben für Parallelklassen
==> 3 Großbuchstaben, eine Zahl, ein Großbuchstabe

Ein Regulärer Ausdruck, der das beschreiben würde, wäre beispielsweise:

[A-Z][A-Z][A-Z][0-9][A-Z]

Es wurden einfach fünf Zeichenklassen hintereinander geschrieben. Das geht noch einfacher:

[A-Z]{3}[0-9][A-Z]

• [A-Z] definiert hier die Zeichenklasse der Großbuchstaben (alle Zeichen, die in der ASCII/Unicode-Tabelle zwischen A und Z stehen)

• [0-9] die Zeichenklasse der Zahlen (ASCII zwischen 0 und 9)

• {3} definiert das mehrfache Vorkommen der Zeichenklasse (ein Quantifizierer).

Suchmuster bestehen also in erster Linie aus Aneinanderreihungen von Zeichenklassen und Quantifizierern.

Literale und Metacharaktere als Elementarbausteine

In Regulären Ausdrücken wird zwischen Literalen und Metacharakteren unterschieden: Literale repräsentieren das jeweilige Zeichen, Metacharaktere haben eine syntaktische Bedeutung. Alle Zeichen, die Metacharaktere repräsentieren, lassen sich über einen Backslash maskieren und repräsentieren so das eigentliche Zeichen (z.B. \[ für die eckige Klammer).

Immer dann, wenn für ein Zeichen in der obigen Tabelle eine Metacharakterbedeutung zugewiesen ist, muss das Zeichen maskiert werden, wenn es als Literal gesucht werden soll.

Lazy / Greedy

Reguläre Ausdrücke mit den Quantifizierern * und + sind gierig (greedy): sie versuchen, so viel wie möglich Treffer zu erzielen und das Suchmuster über möglichst viele Zeichen auszudehnen. In der Regel ist dies jedoch nicht gewünscht: Bestimmte Zeichenklassen sollen sich nur so lange wiederholen, bis das erste Vorkommen der folgenden Zeichenklasse auftritt. Diese genügsamere Suchcharakteristik (lazy) lässt sich umstellen, in dem die lazy Varianten der Multiplizität genutzt werden (*? und +?): Das Fragezeichen kommt hier als Metacharakter erneut zum Zug:

Übersicht vordefinierter Zeichenklassen

Definition von Zeichenklassen

Vordefinierte Zeichenklassen

Position und Grammatik (außerhalb der Zeichenklassendefinition!)

Quantifizierer: Häufigkeit des Auftretens (außerhalb der Zeichenklassendefinition!)

POSIX-Zeichenklassen

Unicode-Zeichenklassen

Flags

Beispiele zum Verständnis

• CSBME findet exakt die Zeichenkette CSBME
• ^CSBME$ findet eine Zeile, die ausschließlich aus der Zeichenkette CSBME besteht
• (Hund|Katze|Maus) findet die Wörter Hund oder Katze oder Maus
• [Hund|Katze|Maus] die Buchstaben HKMadenstuz sowie die Pipe
• [0-9]{2}-[0-9]{2}-[0-9]{4} findet ein Datum der Notation 01-01-2000
• suche: ([0-9]{2})-([0-9]{2})-([0-9]{4})
  ersetze: \1\.\2\.\3
  wandelt ein Datum von der Form 01/01/2000 in die Form 01.01.2000 um.

RegEx in Programmiersprachen nutzen:

Java Python all none

if (!text.matches("[0-9]*")) {
  // Findet Werte, die keine (!) Zahlen sind
}
if (text.matches("[0-9A-Za-z]*")) {
  // Findet Zahlen, Buchstaben, ohne Sonderzeichen
}

text = "Alle 14 Zahlenziffern, die in diesen 392 Buchstaben an 4 verschiedenen Stellen stehen sollen 1 mal ersetzt werden.";
text = text.replaceAll("[0-9]","X"); 
System.out.println(text);

String str = "X";
String regex = "[A-Z]"; 

// Test auf Großbuchstabe (ASCII)
boolean matches = str.matches(regex);

// Alternative: pre-compiled pattern
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(str);
matches = matcher.matches();

// LookingAt
matcher = pattern.matcher("Hallo");
matches = matcher.matches(); // false
startsWith = matcher.lookingAt(); // true

String str = "17-25";
String regex = "(\\d+)-(\\d+)"; // Backslash im Sourcecode verdoppeln!

Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(str);
if (matcher.matches()) {
  System.out.printf("Von %s bis %s\n", 
    matcher.group(1), matcher.group(2));
}

String str = "1,2, 3, 4,   5,6";
String regex = "\\W+";
String[] elements = str.split(regex); // Aufteilen an Wortgrenzen

// Alternative: pre-compiled pattern
Pattern pattern = Pattern.compile(regex);
elements = pattern.split(str);

String str = "Alle RDBMS benutzen SQL";
String regex = "\\p{Lu}{2,}";

// Finde all Wörter mit mindestens zwei 
// Großbuchstaben (Unicode)
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(str);
while (matcher.find()) {
  System.out.println(str.substring(
    matcher.start(), matcher.end()));
}

String str = "value  with spaces";
String regex = "\\s+";
String replacement = "+"; // Ersetze whitespace mit +
String no_spaces =  str.replaceAll(regex, replacement);

// Alternative: pre-compiled pattern
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(str);
no_spaces = matcher.replaceAll(replacement);

// Ersetze ${name} mit System.getProperty(name)
String str = "Hallo ${user.name}!"; 
String regex = "\\$\\{([a-z.]+)\\}";
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(str);
StringBuffer sb = new StringBuffer();
while (matcher.find()) {
  matcher.appendReplacement(sb, System.getProperty(matcher.group(1)));
}
matcher.appendTail(sb);
System.out.println(sb.toString());

import re

text = "Ist hier eine Zahl in acht Wörtern versteckt?"
if (re.search("[0-9]*, text)):
   # Text enthält Zahlen
   pass

import re

text = "Ist hier eine Zahl in acht Wörtern versteckt?"
ergebnisliste = re.findall("[acehinr]+", text)
print(ergebnisliste)

import re

text = "Ist hier eine Zahl in acht Wörtern versteckt?"
ergebnisliste = re.split("[in]+", text)
print(ergebnisliste)

import re

text = "Drei Flötisten mit dem Kontrabass."
ergebnis = re.sub("[aeiouAEIOUÄÖÜäöü]+", "u", text)
print(ergebnis)

import re

text = "030kleinbuchstabenersetzenDASHIERNICHT."
ergebnis = re.sub("([0-9]*)([^A-Z]*)([A-Z]*)", r'\g<1> neuer Text \g<3> \g<2>', text)

print(ergebnis)

RegEx in Powershell und Bash

Mit RegEx über das Terminal nach Dateiinhalten suchen

Beispiel: in einer Datei befindet sich irgendwo ein ungewöhnliches Zeichen, weswegen die Datei nicht verarbeitet werden kann. Folgende Aufrufe mit regulären Ausdrücken finden die betreffenden Zeilen:

PowerShell Linux Terminal / Bash all none

get-childitem *.md | select-string -pattern [^!-~\s\w] -allmatches -CaseSensitive`

grep -onP "[^\x00-\x7FöüäßÜÜ]" *.md

Mit RegEx über das Terminal Dateiinhalte verändern

sed -E -i "s/([0-9\.]+,[0-9]{2})(\ ?EUR)\)/\1 €)/g" dateiname.txt

RegEx in SQL-Abfragen

SELECT
firstname 
FROM User 
WHERE firstname REGEXP "^H.*-.*"

SELECT * FROM db.table WHERE regexp_like( text, "[A-Z]")

SELECT regexp_replace ( text, '[aeiou]', 'u') FROM db.table 

SELECT * FROM db.table WHERE text LIKE '%Oracle%'

SELECT * FROM db.table WHERE text LIKE '%SQLite%'

Links und weitere Informationen

• Gute RegEx-Übersicht und Java-Code zur Nutzung von Martin Kompf

• Learn Regular expressions in 55 Minutes

• RegEx101 - RegEx online ausprobieren

• RegExR - RegEx online ausprobieren

Hinweis zur Nachnutzung als Open Educational Resource (OER)

Dieser Artikel und seine Texte, Bilder, Grafiken, Code und sonstiger Inhalt sind - sofern nicht anders angegeben - lizenziert unter CC BY 4.0. Nennung gemäß TULLU-Regel bitte wie folgt: “Mustererkennung mit Regular Expressions (RegEx)” von oer-informatik.de (H. Stein), Lizenz: CC BY 4.0. Der Artikel wurde unter https://oer-informatik.de/regex veröffentlicht, die Quelltexte sind in weiterverarbeitbarer Form verfügbar im Repository unter https://gitlab.com/oer-informatik/regex/regex-basics. Stand: 23.05.2023.

[Kommentare zum Artikel lesen, schreiben] / [Artikel teilen] / [gitlab-Issue zum Artikel schreiben]