## Reguläre Ausdrücke (Regex)

Regex sind Suchmuster für Text. Ein Zeichen steht für sich selbst, außer Sonderzeichen (`*+?{}[]\|()`), die mit einem Backslash `\` "escaped" werden müssen. Wichtige Platzhalter sind `.` für ein beliebiges Zeichen, `\d` für eine Ziffer, `\w` für ein alphanumerisches Zeichen und `\s` für Leerraum (Whitespace); die jeweiligen Großbuchstaben wie `\D` negieren die Auswahl. Eine Zeichenauswahl erfolgt mit `[...]`, auch als Bereich `[a-z]` oder als Negation `[^a-z]`. Wiederholungen steuern `*` (0 oder mehr), `+` (1 oder mehr), `?` (optional) und `{n,m}` (genaue Anzahl); ein angehängtes `?` (z.B. `*?`) macht die Suche "non-greedy". Runde Klammern `()` fassen Ausdrücke zu Gruppen zusammen, `|` trennt Alternativen. Die Position wird mit `^` (Anfang) und `$` (Ende) einer Zeile oder `\b` (Wortgrenze) verankert.

### Detaillierte Regex-Beispiele

| Syntax | Beschreibung | Beispiel |
| :--- | :--- | :--- |
| **Platzhalter** | | |
| `.` | Jedes beliebige Zeichen (außer Zeilenwechsel) | `a.c` |
| `\d` | Dezimalziffer (`[0-9]`) | `\d{3}` |
| `\D` | Jedes Zeichen außer einer Ziffer | `\D+` |
| `\w` | Jedes alphanumerische Zeichen (`[A-Za-z0-9_]`) | `\w+` |
| `\W` | Jedes nicht-alphanumerische Zeichen | `\W` |
| `\s` | Jede Art von Leerzeichen (Whitespace) | `hello\sworld` |
| `\S` | Jedes Zeichen außer Whitespace | `\S+` |
| **Zeichenauswahl** | | |
| `[abc]` | Genau eines der Zeichen a, b oder c | `gr[ae]y` |
| `[^abc]` | Jedes Zeichen außer a, b oder c | `[^0-9]` |
| `[a-z]` | Ein Zeichen im Bereich von a bis z | `[A-Z]` |
| **Wiederholungen** | | |
| `*` | 0 oder mehr Wiederholungen | `\d*` |
| `+` | 1 oder mehr Wiederholungen | `\w+` |
| `?` | 0 oder 1 Wiederholung (optional) | `colou?r` |
| `{n}` | Genau n Wiederholungen | `\d{4}` |
| `{n,}` | Mindestens n Wiederholungen | `\d{2,}` |
| `{n,m}` | Zwischen n und m Wiederholungen | `\d{2,4}` |
| **Gruppen & Alternativen** | | |
| `(...)` | Gruppiert Ausdrücke und fängt das Ergebnis | `(https?://)` |
| `(?P<N>...)`| Benannte Gruppe | `(?P<year>\d{4})` |
| `\|` | Logisches ODER | `GET\|POST` |
| `\1`, `\2` | Rückverweis auf Gruppe 1, 2 etc. | `(\w+)\s\1` |
| **Position (Anchors)** | | |
| `^` | Anfang der Zeile | `^From:` |
| `$` | Ende der Zeile | `11$` |
| `\A` | Anfang der gesamten Zeichenkette | `\A-----BEGIN` |
| `\Z` | Ende der gesamten Zeichenkette | `\n\Z` |
| `\b` | Wortgrenze | `\bWort\b` |
| `\B` | Keine Wortgrenze | `\B-\B` |

## XPath & JSONPath
XPath navigiert durch XML-Dokumente mit `/` (direktes Kind), `//` (beliebiger Nachfahre), `.` (aktueller Knoten) und `..` (Elternknoten). Filter (Prädikate) in eckigen Klammern `[]` wählen nach Position `[1]`, Attribut `[@type="x"]` oder Inhalt `[tag="wert"]` aus. Werte liest man mit `@attribut` oder der Funktion `text()` aus. JSONPath fragt JSON-Daten ab, beginnend beim Wurzelelement `$`. Auf Kindelemente wird mit `.` oder `['name']` zugegriffen. `..` sucht auf allen Ebenen (rekursiv) und `[*]` wählt alle Array-Elemente. Mit `[?(@...)]` werden Filter angewendet, wobei `@` das aktuelle Element ist.
### Detaillierte XPath-Beispiele

| Syntax | Beschreibung | Beispiel |
| :--- | :--- | :--- |
| `tag` | Wählt alle Knoten mit diesem Tagnamen | `lecturer` |
| `*` | Wählt alle Kindknoten aus | `lecturer/*` |
| `//tag` | Wählt passende Nachfahrenknoten auf allen Tiefen | `//name` |
| `.` / `..` | Aktueller Knoten / Elternknoten | `//name/..` |
| `[n]` | Wählt den n-ten Knoten (Zählung startet bei 1) | `lecturer[1]` |
| `[@attrib]` | Wählt Knoten, wo das Attribut gesetzt ist | `lecturer[@type]` |
| `[@a="v"]` | Wählt Knoten, wo Attribut `a` den Wert `v` hat | `lecturer[@type="external"]` |
| `[tag]` | Wählt Knoten, die einen Kindknoten `tag` haben | `lecturer[name]` |
| `[t="v"]` | Wählt Knoten mit Kindknoten `t` mit Inhalt `v` | `lecturer[email="a@b.ch"]` |
| `@attrib` | Gibt den Wert des Attributs aus | `./lecturer/@type` |
| `text()` | Gibt den Text des Knotens aus | `./lecturer/name/text()` |
| `count()` | Gibt die Anzahl der Knoten aus | `count(./lecturer)` |
| `sum()` | Bildet die Summe der Knoten (müssen Zahlen sein) | `sum(./lecturer/units)` |

### Detaillierte JSONPath-Beispiele

| Syntax | Beschreibung | Beispiel |
| :--- | :--- | :--- |
| `$` | Das Wurzelobjekt | `$` |
| `.prop` | Kindobjekt mit dem Namen `prop` | `$.movies` |
| `['prop']` | Alternative zum Punkt | `$['movies']` |
| `..prop` | Nachfahren auf allen Ebenen (rekursiv) | `$..year` |
| `[n]` | n-tes Objekt in einem Array (Zählung startet bei 0) | `$.movies[0]` |
| `[*]` | Alle Einträge eines Objekts oder Arrays | `$.movies[*]` |
| `[n:m]` | Bereich eines Arrays (Slice) | `$.movies[3:5]` |
| `[?(filter)]` | Filtert Elemente basierend auf einem Ausdruck | `$.movies[?(@.year > 1995)]` |
| `@` | Das aktuelle Element in einem Filter | `[?(@.title =~ 'Kill.*')]` |

## HTTP-APIs & Web Crawling

HTTP-APIs nutzen URLs, die aus Schema, Host, Pfad und optionalen Query-Parametern (`?key=val`) bestehen, um Daten via REST-Prinzipien auszutauschen (Methoden: GET, POST, PUT, DELETE). Authentifizierung erfolgt oft über API-Keys. Web Scraping extrahiert Daten aus dem HTML von Webseiten. Die Auswahl der Daten erfolgt mit CSS-Selektoren. Web Crawling folgt Hyperlinks, um weitere Seiten zu verarbeiten. Dabei sollte man die `robots.txt` respektieren. Die `sitemap.xml` kann helfen, alle Unterseiten zu finden.

### Detaillierte CSS-Selektor-Beispiele

| Syntax | Beschreibung | Beispiel |
| :--- | :--- | :--- |
| `*` | Wählt alle Elemente aus | `*` |
| `tag` | Wählt alle Elemente mit diesem Tagnamen | `h1` |
| `.class` | Wählt Elemente mit dieser Klasse | `.intro` |
| `#id` | Wählt das Element mit dieser ID | `#register` |
| `[attr=val]` | Wählt Elemente, deren Attribut `attr` den Wert `val` hat | `[type="text"]` |
| `:first-child` | Wählt das erste Kind seines Elternelements | `p:first-child` |
| `:nth-child(n)`| Wählt das n-te Kind (auch `2n`, `odd`, `even`) | `tr:nth-child(odd)` |
| `A B` | Wählt alle B, die Nachfahren von A sind (Descendant) | `div p` |
| `A > B` | Wählt alle B, die direkte Kinder von A sind (Child) | `ul > li` |
| `A + B` | Wählt B, das direkt auf A auf derselben Ebene folgt | `h1 + p` |
| `A ~ B` | Wählt alle B, die auf A auf derselben Ebene folgen | `h1 ~ p` |

---

## Komplexe Anwendungsbeispiele

### Regex-Vorlage
```python
^(?P<timestamp>\d{4}-\d{2}-\d{2}\s\d{2}:\d{2}:\d{2})\s\[(?P<level>INFO|WARN|ERROR)\]\s\(user:\s'(?P<user>[\w\.-]+@[\w\.-]+)'\)\s"(?P<message>.*?)"$
```


### XPath-Vorlage
```python
//course[@id='cds104']/lecturer[@type='external' and units > 5]/name/text()
```

### JSONPath-Vorlage
```python
$.movies[?(@.year > 1999 && @.title =~ /^Matrix.*/)].actors[*].name
```

### CSS-Selector-Vorlage (für Web Scraping)

```css
main#content article.published:not(.featured) h2 + div.meta a[href*="author"]
```


## GRAPHQL
```python
{
  table1 {
    property1
    property2
    othertable {
      prop_from_other_table
    }
  }
}
```