Processeur Expression

Anthony Pépin Mis à jour le par Anthony Pépin

Le processeur Expression est versatile. Il peut comprendre une expression comme étant un argument et afficher le résultat dans un champ.

L'expression peut être composée des :

  • Identifiants
  • Littéraux (nombres, littéraux textuels, booléens et mots-clés)
  • Opérateurs
  • Fonctions
N'oubliez pas que pour créer une expression, vous devez toujours commencer par un signe égal (=). Si vous ne le faites pas, le processeur n'évaluera pas l'expression. Le signe égal de départ (=) sera omis dans tous les exemples suivants.

Configurer le processeur

Pour définir les paramètres du processeur Expression, suivez les indications du tableau ci-dessous.

Label

Description

Obligatoire

Expression

Modèle d'expression

Oui

Champ de sortie

Champ dans lequel l'expression sera appliquée. Il peut s'agir d'un champ existant choisi dans la liste ou d'un champ créé à cette fin (dans ce cas, choisissez Saisir du texte dans la liste et écrivez le nom du nouveau champ dans la zone de texte en dessous).

Oui

Construire une expression

Une expression est une instruction permettant au processeur d'effectuer une opération, puis de renvoyer la valeur dans une colonne nouvelle ou existante du jeu de données.

Ces expressions ressemblent à ce qu'on appelle des "formules" dans un tableur. La principale différence est qu'au lieu de référencer des cellules (par exemple : A1 + B2 ), le processeur peut effectuer des opérations avec les valeurs de colonnes données (par exemple : column_1 + column_2 ).

Comme dans une formule, les expressions peuvent être n'importe quelle combinaison de divers éléments. Le processeur Expression prend en charge les éléments suivants :

  • Les Identifiants (ex : un nom de champ comme column_1 ou un nom de champ verrouillé comme $column_1 ),
  • Les Littéraux :

- Nombres (ex : 2 ou 3.6 )

- Littéraux textuels (par exemple "hello" ou 'world' )

- Booléens (ex : 'true' ou 'false' )

- Mots clés (ex : une constante mathématique comme pi et e )

  • Opérateurs (ex : + , OR , not , <= )
  • Fonctions (ex: now() , sin(number) , startswith("hello", 'he') )

Les Identifiants

La caractéristique principale du processeur d'expression est la possibilité d'effectuer des opérations sur les colonnes d'un enregistrement. L'identifiant technique (ou nom de champ) d'une colonne peut être utilisé dans n'importe quelle expression pour accéder à la valeur de ce champ pour l'enregistrement en cours. Cet identifiant technique se trouve dans les options de champ, sous le Nom du champ concerné.

Exemples:

  • column_1 pour accéder à un champ nommé column_1 (et peut-être intitulé "Column 1")
  • name_en pour accéder à un champ nommé name_en (et peut-être intitulé "Name (EN)")

Dans certains cas, le nom du champ peut être ambigu, par exemple s'il s'agit d'un nombre ou s'il s'agit d'un mot-clé réservé comme "pi" (la constante mathématique PI) ou "e" (le nombre d'Euler).

Pour forcer le processeur Expression à évaluer un identifiant comme un nom de champ, il est possible de préfixer n'importe quel identifiant avec le signe dollar ( $ ). Le signe dollar peut être utilisé pour n'importe quel nom de champ, mais il n'est obligatoire que pour les noms de champ ambigus.

Exemples :

  • $column_1 pour accéder à un champ nommé column_1 (et peut-être intitulé "Column 1")
  • $name_en pour accéder à un champ nommé name_en (et peut-être intitulé "Name (EN)")
  • $20_to_25_yo pour accéder à un champ nommé 20_to_25_yo (et peut-être intitulé "20 to 25 years old")
  • $33 pour accéder à un champ nommé 33
  • $pi pour accéder à un champ nommé pi

Dans tous les exemples suivants, tout nombre ou littéral textuel peut être remplacé par un nom de champ contenant des valeurs du même type. Le processeur Expression extrait la valeur de la colonne spécifiée et effectue l'opération requise avec celle-ci.

Une même expression peut contenir plusieurs champs (ou le même champ réutilisé plusieurs fois).

Expressions littérales

Les littéraux comme les nombres , les littéraux textuels (guillemets simples ou doubles), les booléens et les mots-clés peuvent être utilisés dans n'importe quelle expression.

Exemples:

  • 3
  • 2.5
  • "Hello" ou 'Hello'
  • 'A bigger sentence'
  • 'true' ou 'false'
  • pi , PI ou Pi
  • e ou E

Les opérateurs

Les opérateurs sont des symboles qui se comportent généralement comme des fonctions mais sont utilisés avec une syntaxe plus naturelle.

Le processeur Expression prend en charge trois types d'opérateurs, selon le nombre de paramètres qui les entourent :

  • Les opérateurs unaires peuvent être utilisés comme préfixes ou suffixes pour modifier la valeur d'une expression
  • Les opérateurs binaires peuvent être des opérateurs arithmétiques pour effectuer un calcul entre deux expressions, ou des opérateurs booléens pour comparer le résultat de deux expressions
  • L'opérateur ternaire , pour convertir une expression conditionnelle en l'un des deux résultats possibles
La priorité des opérateurs fonctionne dans l'ordre suivant : factorielle, exponentielle, signe, division euclidienne, évaluation de fonction, multiplication/division, addition/soustraction, concaténation, not, comparaison, and, or, opérateur ternaire, opérateur ternaire sans else.

Opérateurs unaires

Opérateur

Description

Exemple

-

Préfixe rendant la valeur suivante négative

- 4 , - [expression]

not , !

Opérateur booléen qui inverse la condition suivante

  • not('true') ou !('true') est false
  • not(4 > 5) est true
  • !(5 <= 10) est false

! (factorielle)

Suffixe qui calcule la factorielle d'une expression

3! renvoie 1*2*3

Opérateurs binaires

Opérateur

Description

Exemple

+ , - , * , / , % , // , ^

Opérateurs arithmétiques : additionner, soustraire, multiplier, diviser, modulo, division euclidienne, puissance

  • 2 + 3 retours 5
  • 5 - 8 retours -3
  • 9 * 3 retours 27
  • 15 / 6 retours 2.5
  • 15 % 6 retours 3
  • 15 // 6 retours 2
  • 2 ^ 3 renvoie 8
  • column_1 + column2

and , && , or , || (retournent un booléen)

Opérateurs boléens : and, or

  • 'true' and 'true' est true
  • 'true' && 'false' est false
  • 'true' or 'false' est true
  • 'false' || 'false' est false

> , < , >= , <= , == , !=

Opérateurs de comparaison : supérieur à, inférieur à, supérieur ou égal à, inférieur ou égal à, égal à et différent de retournent un booléen

  • 3 < 4 est true
  • 5 >= 10 est false

&

Opérateur de concaténation des chaînes de caractères

'Hello' & ' world' renvoie 'Hello world'

Opérateur ternaire

L'expression [condition] ? [résultat si vrai] : [résultat si faux] s'appelle l'opérateur ternaire et permet de retourner différents résultats en fonction d'une condition.

Une expression ternaire peut être lue comme "si [condition] alors [résultat si vrai] sinon [résultat si faux]".

Exemples:

  • 'true' ? 'hello' : 'goodbye' renvoie 'hello'
  • 'false' ? 'hello' : 'goodbye' renvoie 'goodbye'
  • 4 > 3 ? '4 is bigger' : '3 is bigger' renvoie '4 is bigger'
  • 10 <= 9 ? '9 is bigger' : '10 is bigger' renvoie '10 is bigger'

La dernière partie de l'opérateur ternaire est facultative, ce qui signifie que les expressions suivantes sont valides :

  • 'true' ? 'hello' renvoie 'hello'
  • 'false' ? 'hello' renvoie un résultat vide
Certaines opérations peuvent échouer si elles impliquent un champ dont le type a été mal déterminé par la plateforme lors de la création du jeu de données, même si le type du champ a été modifié par la suite. Dans ce cas, contactez l'équipe de support d'Opendatasoft.

Les fonctions

Les fonctions sont utilisées pour effectuer des opérations plus avancées dans une expression, telles que :

  • Gestion du texte
  • Fonctions mathématiques
  • Gestion de la date et de l'heure

Gestion du texte

Fonctions booléennes

Fonction

Description

Exemple

isalpha([text])

Vrai si le texte ne contient que des lettres

isnumeric([text])

Vrai si le texte ne contient que des chiffres

isalnum([text])

Vrai si le texte ne contient que des lettres ou des chiffres

isdecimal([text])

Vrai si le texte est un nombre décimal valide

isdigit([text])

Vrai si le texte est composé d'un seul chiffre

islower([text])

Vrai si le texte est en minuscule

isupper([text])

Vrai si le texte est en majuscule

empty([text])

Vrai si le texte est vide

contains([text],[text]) , startswith([text],[text]) , endswith([text],[text])

Vrai si le texte (1er argument) contient, commence ou se termine par du texte (2ème argument)

  • contains("hello", "l") renvoie True
  • startswith("hello", 'he') renvoie True
  • endswith("hello", 'he') renvoie False
Fonctions de traitement

Fonction

Description

Exemple

length([text])

Retourne la longueur du texte

length('bonjour') retourne 7

lower([text]) , upper([text])

Convertir le texte en minuscule, en majuscule

capitalize([text]) , capitalize_all([text])

Met la première lettre du texte en majuscule ou la première lettre de chaque mot

  • ljust([text],[numeric],[text])
  • rjust([text],[numeric],[text])
  • center([text],[numeric],[text])

Justifie à gauche, à droite et au centre un texte (1er argument), jusqu'à atteindre le [nombre] de caractères à l'aide d'un autre texte (3e argument)

  • ljust("4400", 5, "0") renvoie "44000"
  • rjust("4400", 5, "0") renvoie "04400"
  • center("4400", 6,"0") renvoie "044000"

normalize([text])

Remplace un texte par sa représentation ASCII

normalize("你好") renvoie "ni hao"

substring([text],[numeric],[numeric])

Extrait une sous-chaîne de texte, en commençant à l'index indiqué par le 2nd argument et d'une longueur indiquée par le 3e argument (optionnel).

substring('hello', 1, 3) renvoie "ell"

count([text], [text])

Retourne le nombre de fois où le 2nd argument apparaît dans le 1er argument

count("Hello world", "l") renvoie 3

  • left([text],[numeric])
  • right([text],[numeric])
  • mid([text],[numeric])

Extrait une partie du texte (1er argument) en partant de la gauche, de la droite ou du milieu ; la taille de l'extrait est déterminé par le 2nd argument pour gauche et droite, par les 2nd et 3e arguments pour mid

  • left("hello", 2) renvoie "he"
  • right("hello", 3) renvoie "llo"
  • mid("hello", 2, 3) renvoie "ell"

Fonctions mathématiques

Fonction

Description

Exemple

abs([numeric])

Valeur absolue

abs(-4) renvoie 4

sqrt([numeric])

Racine carrée

floor([numeric]) , ceil([numeric])

Fonctions arrondi à l'entier inférieur et supérieur

  • floor(4.6) renvoie 4
  • ceil(3.3) renvoie 4

max([numeric],[numeric]) , min([numeric],[numeric])

Fonctions minimales et maximales

round([numeric])

Arrondit à l'entier le plus proche

  • round(4.6) renvoie 5
  • round(3.3) renvoie 4

random([numeric])

Génère un nombre aléatoire (entre 0 et [nombre])

random(10) renvoie par exemple 7.27846540481

pow([numeric], [numeric])

Fonction puissance

pow(2, 3) renvoie 8

exp([numeric]) , log([numeric]) , log10([numeric])

Fonctions exponentielles, logarithmiques et du logarithme en base 10

exp(1) renvoie E

radians([numeric])

Convertit un angle de degrés en radians

radians(180) renvoie PI

degrees([numeric])

Convertit un angle de radians en degrés

degrees(PI) renvoie 180

cos([numeric]) , cosh([numeric]) , sin([numeric]) , sinh([numeric]) , tan([numeric]) , tanh([numeric])

Cosinus, cosinus hyperbolique, sinus, sinus hyperbolique, tangente, tangente hyperbolique (en radians)

sin(PI) renvoie 0

acos([numeric]) , acosh([numeric]) , asin([numeric]) , asinh([numeric]) , atan([numeric]) , atanh([numeric])

Cosinus inverse, cosinus inverse hyberbolique, sinus inverse, sinus inverse hyperbolique, tangente inverse, tangente inverse hyperbolique (en radians)

acos(0) renvoie PI/2

Gestion de la date et de l'heure

Fonction

Description

Exemple

year([datetime]) , quarter([datetime]) , month([datetime]) , week([datetime]) , day([datetime]) , dayofweek([datetime]) , hour([datetime]) , minute([datetime]) , second([datetime])

Extrait l'année, le trimestre, le mois, la semaine, la date, le jour de la semaine, les heures, les minutes et les secondes d'un(e) date/datetime

  • year("2014-06-07") renvoie 2014
  • hour("2014-06-07 17:00") renvoie 17
  • hour("2014-06-07 17:00", "Europe/Paris") renvoie 19
  • Supposons que la date actuelle soit "2021-04-21". Dans ce cas, month(now()) renvoie 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])

Ajoute des années, des mois, des jours, des heures, des minutes ou des secondes à un datetime

  • add_months("2014-11-14", 3) renvoie 2015-02-14
  • Supposons que la date actuelle soit "2020-04-21". Dans ce cas, add_months(now(), 3) renvoie 2021-07-21 .

fromtimestamp([numeric])

Convertit un indicateur temporel en datetime

quartertodaterange([numeric])

Convertit un trimestre en intervalle de dates

quartertodaterange("2014Q2") renvoie "2014-04-01 / 2014-06-30"

datediff([datetime], [datetime], [unit])

Compte le nombre d'unités entre deux expressions datetime. [unité] peut être être "year", "month", "day", "hour", "minute" ou "second".

  • datediff("2014-02-28", "2015-02-28", "month") renvoie 12
  • datediff("2014-02-28T20:00:00Z", "2014-02-28T21:00:00Z", "minute") renvoie 60
  • Supposons que l'heure actuelle soit "2021-04-21". Dans ce cas, datediff("2020-04-01", now(), "year") renvoie 1 .

Êtes-vous satisfait ?

Processeur Déplier les champs à valeur multiples

Processeur Extraire du HTML

Contactez-nous

Powered by HelpDocs (opens in a new tab)