Ausdrucksprozessor¶

Dieser Prozessor ist ein vielseitiger Prozessor, der einen Ausdruck als Argument verwendet und sein Ergebnis in einem Feld ausgibt.

Der Ausdruck kann sich aus Folgendem zusammensetzen:

Kennungen,
Literale (Zahlen, Textliterale, boolesche Variable, Ausdrücke und Schlüsselwörter)
Operatoren,
Funktionen.

Voraussetzung

Der Ausdrucksprozessor macht am meisten Sinn im Evaluierungsmodus (d.h. "berechnen und das Ergebnis des Ausdrucks ausgeben"), der durch Starten des Ausdrucks mit einem Gleichheitszeichen (`=`) aktiviert wird. Andernfalls wertet der Prozessor den Ausdruck nicht aus und setzt ihn einfach so ein, wie er im Ausgabefeld steht.

Das beginnende Gleichheitszeichen (`=`) wird bei allen folgenden Beispielen weggelassen.

Den Prozessor einrichten¶

Befolgen Sie die Anweisungen der unteren Tabelle, um die Parameter des Ausdrucksprozessors einzurichten.

Beschriftung	Beschreibung	Obligatorisch
Ausdruck	Ausdrucksmuster	ja
Ausgabefeld	Feld, in dem der Ausdruck angewendet wird. Es kann sich um ein vorhandenes Feld handeln, das aus der Liste ausgewählt wird, oder ein neues Feld, das zu diesem Zweck erstellt wurde (in diesem Fall bitte Eingabetext aus der Liste wählen und den Namen des neuen Feldes in den unteren Textbereich eingeben).	ja

Einen Ausdruck erstellen¶

Ein Ausdruck ist eine Anweisung an den Prozessor, eine Operation auszuführen und den Wert in einer neuen oder bestehenden Spalte des Datensatzes auszugeben.

Diese Ausdrücke ähneln Formeln in einer Tabellenkalkulationssoftware. Der Hauptunterschied besteht darin, dass der Prozessor anstelle der Referenzierung von Zellen (z.B. "A1 + B2") Operationen mit den Werten bestimmter Spalten durchführen kann (z.B. "Spalte_1 + Spalte_2").

Wie in einer Formel können Ausdrücke eine beliebige Kombination von verschiedenen Elementen sein. Der Ausdrucksprozessor unterstützt die folgenden Elemente:

Kennungen (z.B.: ein Feldname wie Spalte_1 oder ein erzwungener Feldname wie $Spalte_1),
Literale:
- Zahlen (z.B.: 2 oder 3.6),
- Textliterale (z.B. "hallo" oder 'Welt'),
- Boolesche Elemente (z. B.: '`true'` oder 'false'),
- Schlüsselwörter (z.B.: eine mathematische Konstante wie pi und e),
Operatoren (z.B.: +, OR, not, <=),
Funktionen (z.B.: now(), sin(Zahl), startswith("hallo', 'er')).

Kennungen¶

Das Hauptmerkmal des Ausdrucksprozessors ist seine Fähigkeit, Operationen mit den Spalten eines Datensatzes durchzuführen. Die technische Kennung (oder der Feldname) einer Spalte kann in jedem beliebigen Ausdruck verwendet werden, um auf den Wert dieses Feldes für den aktuellen Eintrags zuzugreifen. Diese technische Kennung finden Sie in den Feldoptionen als Name dieses Feldes.

Beispiele:

Spalte_1 um auf ein Feld mit dem Namen Spalte_1 zuzugreifen (und ggf. mit der Bezeichnung "Spalte 1")
name_en um auf ein Feld mit dem Namen name_en zuzugreifen (und ggf. mit der Bezeichnung "Name (EN)")

Wichtig

In einigen Fällen kann der Feldname mehrdeutig sein, z.B. wenn es sich um eine Zahl handelt, wenn er mit einer Zahl beginnt oder wenn es sich um ein belegtes Schlüsselwort wie "pi" (die mathematische Konstante PI) oder "e" (die mathematische Konstante Eulersche Zahl) handelt.

Um den Ausdrucksprozessor zu zwingen, eine Kennung als Feldnamen auszuwerten, ist es möglich, jeder Kennung ein Dollarzeichen ($) voranzustellen. Das Dollarzeichen kann für jeden beliebigen Feldnamen verwendet werden, ist aber nur bei mehrdeutigen Feldnamen zwingend erforderlich.

Beispiele:

$Spalte_1 um auf ein Feld mit dem Namen Spalte_1 zuzugreifen (und ggf. mit der Bezeichnung "Spalte 1")
$name_en um auf ein Feld mit dem Namen name_en zuzugreifen (und ggf. mit der Bezeichnung "Name (EN)")
$20_to_25_yo um auf ein Feld mit dem Namen 20_to_25_yo zuzugreifen (und ggf. mit der Bezeichnung "20 to 25 years old")
$33 um auf ein Feld mit dem Namen 33 zuzugreifen
$pi um auf ein Feld mit dem Namen pi zuzugreifen

In allen folgenden Beispielen kann jede beliebige Zahl oder jedes Textliteral durch einen Feldnamen ersetzt werden, der Werte des gleichen Typs enthält. Der Ausdrucksprozessor extrahiert den Wert für die angegebene Spalte und führt damit die gewünschte Operation durch.

Mehrere Felder (oder sogar mehrmals das gleiche Feld) können gleichzeitig in einem Ausdruck verwendet werden.

Literale¶

Literale wie Zahlen, Textliterale (mit einfachen oder doppelten Anführungszeichen), boolesche Variable und Schlüsselwörter können in jedem Ausdruck verwendet werden.

Beispiele:

3
2.5
"Hallo" oder 'Hallo'
'Ein längerer Satz'
'true' oder 'false'
pi, PI oder Pi
e oder E

Operatoren¶

Operatoren sind Symbole, die sich im Wesentlichen wie Funktionen verhalten, aber mit einer natürlicheren Syntax verwendet werden.

Der Ausdrucksprozessor unterstützt 3 Arten von Operatoren, abhängig von der Anzahl der Parameter, die sie umgeben:

Unäre Operatoren können als Präfixe oder Suffixe verwendet werden, um den Wert eines Ausdrucks zu ändern,
Binäre Operatoren können arithmetische Operatoren sein, um eine Kalkulation zwischen 2 Ausdrücken durchzuführen, oder boolesche Operatoren, um das Ergebnis von 2 Ausdrücken zu vergleichen,
der ternäre Operator, um einen bedingten Ausdruck in eines von 2 möglichen Ergebnissen umzuwandeln.

Hinweis

Es gilt die folgende Operatorrangfolge: Fakultät, exponential, Vorzeichen, euklidische Division, Funktionsbewertung, Multiplikation/Division, Addition/Subtraktion, Verkettung, nicht, Vergleich, und, ternärer Operator, ternärer Operator ohne weiteres.

Unäre Operatoren¶

Operator	Beschreibung	Beispiel
`-`	Präfix, das den folgenden Wert negiert	`- 4`, `- [Ausdruck]`
`not`, `!` (not)	Boolescher Operator, der die folgende Bedingung umkehrt	`not('true')` oder `!('true')` ist `false` `not(4 > 5)` ist `true` `!(5 <= 10)` ist `false`
`!` (Fakultät)	Suffix, das die Fakultät eines Ausdrucks berechnet	`3!` ergibt `123`

Binäre Operatoren¶

Operator	Beschreibung	Beispiel
`+`, `-`, `*`, `/`, `%`, `//`, `^`	Arithmetische Operatoren: Addition, Subtraktion, Multiplikation, Division, Modulo, euklidische Division, Potenz	`2 + 3` ergibt `5` `5 - 8` ergibt `-3` `9 * 3` ergibt `27` `15 / 6` ergibt `2.5` `15 % 6` ergibt `3` `15 // 6` ergibt `2` `2 ^ 3` ergibt `8` `Spalte_1 + Spalte2`
`und`, `&&`, `oder`, `\|\|` (ergibt einen booleschen Wert)	Boolesche Operatoren: and, or	`'true' und 'true'` ist `true` `'true' && 'false'` ist `false` `'true' oder 'false'` ist `true` `'false' \|\| 'false'` ist `false`
`>`, `<`, `>=`, `<=`, `==`, `!=`	Vergleichsoperatoren: größer als, kleiner als, größer oder gleich, kleiner oder gleich, gleich, ungleich ergeben einen booleschen Wert	`3 < 4` ist `true` `5 >= 10` ist `false`
`&`	Zeichenfolgen-Verkettungsoperator	`'Hallo' & ' Welt'` ergibt `'Hallo Welt'`

Ternärer Operator¶

Der Ausdruck [Bedingung] ? [Ergebnis wenn wahr] : [Ergebnis wenn falsch] wird als ternärer Operator bezeichnet und ermöglicht es, je nach Bedingung unterschiedliche Ergebnisse zu ergeben.

Hinweis

Ein ternärer Ausdruck kann als "wenn [Bedingung] dann [Ergebnis wenn wahr] sonst [Ergebnis wenn falsch]" gelesen werden.

Beispiele:

'true' ? 'hallo' : 'tschüss' ergibt 'hallo'
'false' ? 'hallo' : 'tschüss' ergibt 'tschüss'
4 > 3 ? '4 ist größer als' : '3 ist größer' ergibt '4 ist größer'
10 <= 9 ? '9 ist größer' : '10 ist größer' ergibt '10 ist größer'

Der letzte Teil des ternären Operators ist optional. Deshalb sind die folgenden Ausdrücke gültig:

'true' ? 'hallo' ergibt 'hallo'
'false' ? 'hallo' ergibt ein leeres Ergebnis

Hinweis

Einige Vorgänge können fehlschlagen, wenn sie ein Feld beinhalten, dessen Typ von der Plattform bei der Erstellung des Datensatzes falsch eingeschätzt wurde, auch wenn der Feldtyp im Nachhinein geändert wurde. Wenden Sie sich in diesem Fall an das Support-Team von Opendatasoft.

Funktionen¶

Funktionen werden verwendet, um fortgeschrittene Operationen in einem Ausdruck durchzuführen. Sie können 0 oder mehr Parameter annehmen und Transformationen anwenden, wie z.B.:

Textverarbeitung,
mathematische Funktionen,
Verarbeitung von Datum und Uhrzeit.

Textverarbeitung¶

Boolesche Funktionen

Funktion	Beschreibung	Beispiel
`isalpha([text])`	Wahr, wenn der Text nur Buchstaben enthält
`isnumeric([text])`	Wahr, wenn der Text nur Zahlen enthält
`isalnum([text])`	Wahr, wenn der Text nur Buchstaben oder Zahlen enthält
`isdecimal([text])`	Wahr, wenn der Text eine gültige Dezimalzahl ist
`isdigit([text])`	Wahr, wenn der Text eine einstellige Zahl ist
`islower([text])`	Wahr, wenn der Text klein geschrieben ist
`isupper([text])`	Wahr, wenn der Text groß geschrieben ist
`empty([text])`	Wahr, wenn der Text leer ist
`contains([text],[text])`, `startswith([text],[text])`, `endswith([text],[text])`	Wahr, wenn der Text (1. Argument) Text enthält, mit ihm beginnt oder mit ihm endet (2. Argument)	`contains("hallo", "lch")` ergibt `True` `startswith("hallo", 'ha')` ergibt `True` `endswith("hallo", 'ha')` ergibt `False`

Verarbeitungsfunktionen

Funktion	Beschreibung	Beispiel
`length([text])`	Ergibt die Länge des Texts	`length('hallo')` ergibt `5`
`lower([text])`, `upper([text])`	Konvertiert Text in Kleinbuchstaben, in Großbuchstaben
`capitalize([text])`, `capitalize_all([text])`	Großschreibung des ersten Buchstabens des Textes, des ersten Buchstabens jedes Wortes
`ljust([text],[numeric],[text])` `rjust([text],[numeric],[text])` `center([text],[numeric],[text])`	Einen Text links, rechts und mittig ausrichten (1. Argument), bis er [numerische] Zeichen mit einem anderen Text (3. Argument) erreicht	`ljust("4400", 5, "0")` ergibt `"44000"` `rjust("4400", 5, "0")` ergibt `"04400"` `center("4400", 6,"0")` ergibt `"044000"`
`normalize([text])`	Konvertiert einen Text in seine ASCII-Darstellung	`normalize("你好")` ergibt `"ni hao"`
`substring([text],[numeric],[numeric])`	Extrahiert eine Teilzeichenkette aus Text, beginnend mit dem durch das 2. Argument angegebenen Index und einer Länge, die durch das 3. Argument angegeben wird (optional)	`substring('hallo', 1, 3)` ergibt``"all"``
`count([text], [text])`	Gibt an, wie oft das 2. Argument innerhalb des 1. Arguments gefunden wird	`count("Hallo Welt", "l")` ergibt `3`
`left([text],[numeric])` `right([text],[numeric])` `mid([text],[numeric])`	Extrahiert einen Textteil (1. Argument) von links, aus der Mitte oder von rechts; die Länge des Auszugs wird für `left` und `right` durch das 2. Argument, für `mid` durch das 2. und 3. Argument angegeben.	`left("hallo", 2)` ergibt `"ha"` `right("hallo", 3)` ergibt `"llo"` `mid("hallo", 2, 3)` ergibt `"all"`

Mathematische Funktionen¶

Funktion	Beschreibung	Beispiel
`abs([numeric])`	Absoluter Wert	`abs(-4)` ergibt `4`
`sqrt([numeric])`	Quadratwurzel
`floor([numeric])`, `ceil([numeric])`	Boden- und Deckenfunktionen	`floor(4.6)` ergibt `4` `ceil(3.3)` ergibt `4`
`max([numeric],[numeric])`, `min([numeric],[numeric])`	Max- und Min-Funktionen
`round([numeric])`	Ergibt die nächstgelegene Ganzzahl	`round(4.6)` ergibt `5` `round(3.3)` ergibt `4`
`random([numeric])`	Zufallszahlengenerator (zwischen 0 und [numeric])	`random(10)` ergibt zum Beispiel `7.27846540481`
`pow([numeric], [numeric])`	Potenzfunktion	`pow(2, 3)` ergibt `8`
`exp([numeric])`, `log([numeric])`, `log10([numeric])`	Exponentielle, logarithmische und Basis 10 Logarithmusfunktionen	`exp(1)` ergibt `E`
`radians([numeric])`	Konvertiert einen Winkel von Grad in Radiant	`radians(180)` ergibt `PI`
`degrees([numeric])`	Konvertiert einen Winkel von Radiant in Grad	`degrees(PI)` ergibt `180`
`cos([numeric])`, `cosh([numeric])`, `sin([numeric])`, `sinh([numeric])`, `tan([numeric])`, `tanh([numeric])`	Kosinus, hyperbolischer Kosinus, Sinus, hyperbolischer Sinus, Tangens, hyperbolischer Tangens (in Radiant)	`sin(PI)` ergibt `0`
`acos([numeric])`, `acosh([numeric])`, `asin([numeric])`, `asinh([numeric])`, `atan([numeric])`, `atanh([numeric])`	Umgekehrter Kosinus, umgekehrter hyperbolischer Kosinus, umgekehrter Sinus, umgekehrter hyperbolischer Sinus, umgekehrter Tangens, umgekehrter hyperbolischer Tangens (in Radiant)	`acos(0)` ergibt `PI/2`

Verarbeitung von Datum und Uhrzeit¶

Funktion	Beschreibung	Beispiel
`year([datetime])`, `quarter([datetime])`, `month([datetime])`, `week([datetime])`, `day([datetime])`, `dayofweek([datetime])`, `hour([datetime])`, `minute([datetime])`, `second([datetime])`	Extrahiert das Jahr, das Vierteljahr, den Monat, die Woche, den Tag, den Wochentag, die Stunden, Minuten und Sekunden aus einer DateTime	`year("2014-06-07")` ergibt `2014` `hour("2014-06-07 17:00")` ergibt `17` `hour("2014-06-07 17:00", "Europe/Paris")` ergibt `19` Gehen wir davon aus, dass das aktuelle Datum wie folgt lautet: "2021-04-21". In diesem Fall ergibt `month(now())` `4`.
`add_years([datetime],[numeric])`, `add_months([datetime],[numeric])`, `add_days([datetime],[numeric])`, `add_hours([datetime],[numeric])`, `add_minutes([datetime],[numeric])`, `add_seconds([datetime],[numeric])`	Fügt einer DateTime Jahre, Monate, Tage, Stunden, Minuten, Sekunden hinzu	`add_months("2014-11-14", 3)` ergibt `2015-02-14` Gehen wir davon aus, dass das aktuelle Datum wie folgt lautet: "2020-04-21". In diesem Fall ergibt `add_months(now(), 3)` `2021-07-21`.
`fromtimestamp([numeric])`	Konvertiert einen Zeitstempel in eine DateTime
`quartertodaterange([numeric])`	Konvertiert ein Quartal (z.B.: "2014Q2", "2019q1") in einen Datumsbereich	`quartertodaterange("2014Q2")` ergibt `"2014-04-01 / 2014-06-30"`
`datediff([datetime], [datetime], [unit])`	Zählt die Anzahl der Einheiten zwischen den zwei DateTime-Ausdrücken. `[unit]` kann "year" (Jahr), "month" (Monat), "day" (Tag), "hour" (Stunde), "minute" (Minute), "second" (Sekunde) sein.	`datediff("2014-02-28", "2015-02-28", "month")` ergibt `12` `datediff("2014-02-28T20:00:00Z", "2014-02-28T21:00:00Z", "minute")` ergibt `60` Gehen wir davon aus, dass das aktuelle Datum wie folgt lautet: "2021-04-21". In diesem Fall ergibt `datediff("2020-04-01", now(), "year")` `1`.