Référence des Fonctions#

Dans une formule, $field est traduit en rec.field, où rec est l’Enregistrement pour lequel la formule est évaluée.

Par exemple :

def Nom_Complet(rec, table):
  return rec.Prenom + ' ' + rec.NomDeFamille

def Longueur_Nom(rec, table):
  return len(rec.Nom_Complet)

Voir Ensemble d’Enregistrements pour les propriétés utiles offertes par l’objet retourné.

Exemples :

sum($group.Montant)                        # Somme du champ Montant dans les enregistrements correspondants
sum(r.Montant for r in $group)             # Même que sum($group.Montant)
sum(r.Montant for r in $group if r > 0)    # Somme uniquement des montants positifs
sum(r.Actions * r.Prix for r in $group)   # Somme des produits actions * prix

Un Ensemble d’Enregistrements permet d’itérer à travers les enregistrements :

sum(r.Montant for r in Etudiants.lookupRecords(Prenom="John", NomDeFamille="Doe"))
min(r.DateEcheance for r in Tâches.lookupRecords(Propriétaire="Bob"))

Les Ensembles d’Enregistrements fournissent également un moyen pratique d’accéder à la liste des valeurs pour un champ particulier pour tous les enregistrements, comme record_set.Field. Par exemple, les exemples ci-dessus sont équivalents à :

sum(Etudiants.lookupRecords(Prenom="John", NomDeFamille="Doe").Montant)
min(Tâches.lookupRecords(Propriétaire="Bob").DateEcheance)

Vous pouvez obtenir le nombre d’enregistrements dans un Ensemble d’Enregistrements en utilisant len, par exemple len($group).

Transactions.lookupRecords(..., order_by="Date").find.lt($Date)
Table.lookupRecords(..., order_by=("Foo", "Bar")).find.le(foo, bar)

Si l’attribut find est masqué par une colonne utilisateur du même nom, vous pouvez utiliser _find à la place.

Les méthodes disponibles sont :

• lt: (moins que) trouver l’enregistrement le plus proche avec des valeurs de tri < les valeurs données
• le: (moins que ou égal à) trouver l’enregistrement le plus proche avec des valeurs de tri <= les valeurs données
• gt: (plus que) trouver l’enregistrement le plus proche avec des valeurs de tri > les valeurs données
• ge: (plus que ou égal à) trouver l’enregistrement le plus proche avec des valeurs de tri >= les valeurs données
• eq: (égal à) trouver l’enregistrement le plus proche avec des valeurs de tri == les valeurs données

Exemple de notre modèle de Paie. Chaque personne a un historique de taux de paiement, dans la table Taux. Pour trouver un taux applicable à une date donnée, voici comment vous pouvez le faire à l’ancienne :

# Obtenez tous les taux pour la Personne et le Rôle dans cette ligne.
taux = Taux.lookupRecords(Personne=$Personne, Rôle=$Rôle)

# Sélectionnez uniquement les taux dont le Début_Taux est à ou avant la Date de cette ligne.
taux_passés = [r for r in taux if r.Début_Taux <= $Date]

# Sélectionnez le dernier des taux_passés, c'est-à-dire le maximum par Début_Taux.
taux = max(taux_passés, key=lambda r: r.Début_Taux)

# Retournez le Taux_Horaire du taux pertinent.
return taux.Taux_Horaire

Avec les nouvelles méthodes, c’est beaucoup plus simple :

taux = Taux.lookupRecords(Personne=$Personne, Rôle=$Rôle, order_by="Début_Taux")
taux = taux.find.le($Date)
return taux.Taux_Horaire

Notez que cela est également beaucoup plus rapide lorsqu’il y a de nombreux taux pour la même Personne et Rôle.

Chaque table dans le document est disponible pour toutes les formules.

Par exemple, cela évalue le nombre d’enregistrements dans la table Etudiants.

len(Etudiants.all)

Cela évalue la somme du champ Population pour chaque enregistrement dans la table Pays.

sum(r.Population for r in Pays.all)

Par exemple :

Personnes.lookupOne(Prenom="Lewis", NomDeFamille="Carroll")
Personnes.lookupOne(Email=$Email_Travail)

En savoir plus sur lookupOne.

Si plusieurs enregistrements sont trouvés, le premier match est retourné. Vous pouvez définir le paramètre optionnel order_by au ID de colonne par lequel trier les correspondances, pour déterminer lequel d’entre eux est retourné en premier. Par défaut, l’enregistrement avec le plus petit ID de ligne est retourné.

Voir lookupRecords pour les détails de toutes les options disponibles et du comportement de order_by (et de son alternative héritée, sort_by).

Par exemple :

Tâches.lookupOne(Projet=$id, order_by="Priorité")  # Tâche avec la plus petite Priorité.
Taux.lookupOne(Personne=$id, order_by="-Date")      # Taux avec la dernière Date.

Par exemple :

Personnes.lookupRecords(Email=$Email_Travail)
Personnes.lookupRecords(Prenom="George", NomDeFamille="Washington")

Vous pouvez définir le paramètre optionnel order_by au ID de colonne par lequel trier les résultats. Vous pouvez préfixer l’ID de colonne avec “-” pour inverser l’ordre. Vous pouvez également spécifier plusieurs IDs de colonnes sous forme de tuple (par exemple, order_by=("Compte", "-Date")).

Par exemple :

Transactions.lookupRecords(Compte=$Compte, order_by="Date")
Transactions.lookupRecords(Compte=$Compte, order_by="-Date")
Transactions.lookupRecords(Actif=True, order_by=("Compte", "-Date"))

Pour les enregistrements avec des champs order_by égaux, les résultats sont triés selon leur apparence dans les vues (ce qui est déterminé par la colonne spéciale manualSort). Vous pouvez définir order_by=None pour correspondre à l’ordre des enregistrements dans des vues non triées.

Par défaut, sans order_by, les enregistrements sont triés par ID de ligne, comme si avec order_by="id".

Pour des raisons de compatibilité, sort_by peut être utilisé à la place de order_by, mais ne permet qu’un seul champ, et revient à l’ID de ligne (plutôt qu’à manualSort).

Voir Ensemble d’Enregistrements pour les propriétés utiles offertes par l’objet retourné. En particulier, des méthodes comme .find.le permettent de rechercher des valeurs les plus proches.

Voir CONTIENT pour un exemple utilisant UserTable.lookupRecords pour trouver des enregistrements où un champ de type liste (tel que Liste de Choix ou Liste de Références) contient la valeur donnée.

En savoir plus sur lookupRecords.

Par exemple,

PRÉCÉDENT(rec, order_by="Date")    # L'enregistrement précédent lorsqu'il est trié par date croissante.
PRÉCÉDENT(rec, order_by="-Date")   # L'enregistrement précédent lorsqu'il est trié par date décroissante.

Vous pouvez utiliser group_by pour rechercher l’enregistrement précédent dans un groupe filtré. Par exemple, cela trouve l’enregistrement précédent avec le même Compte que rec, lorsque les enregistrements sont filtrés par le Compte de rec et triés par date croissante :

PRÉCÉDENT(rec, group_by="Compte", order_by="Date")

Lorsque plusieurs enregistrements ont les mêmes valeurs order_by (par exemple, la même Date dans les exemples ci-dessus), l’ordre est déterminé par la position relative des lignes dans les vues. Cela se fait en interne en retombant sur la colonne spéciale manualSort et la colonne ID de ligne id.

Utilisez order_by=None pour trouver l’enregistrement précédent dans une table non triée (lorsque les lignes peuvent être réarrangées en les faisant glisser manuellement). Par exemple :

PRÉCÉDENT(rec, order_by=None)      # L'enregistrement précédent dans la liste non triée des enregistrements.

Vous pouvez spécifier plusieurs IDs de colonnes sous forme de tuple, pour group_by et order_by. Cela peut être utilisé pour correspondre aux vues triées par plusieurs colonnes. Par exemple :

PRÉCÉDENT(rec, group_by=("Compte", "Année"), order_by=("Date", "-Montant"))

Le paramètre order peut être "asc" (qui est la valeur par défaut) ou "desc".

Lorsque order est "asc" ou omis, le premier enregistrement dans le groupe dans l’ordre trié aurait le rang de 1. Lorsque order est "desc", le dernier enregistrement dans l’ordre trié aurait le rang de 1.

S’il y a plusieurs groupes, il y aura plusieurs enregistrements avec le même rang. En particulier, chaque groupe aura un enregistrement avec le rang 1.

Par exemple, RANG(rec, group_by="Année", order_by="Score", order="desc") retournera le rang de l’enregistrement actuel (rec) parmi tous les enregistrements de sa table pour la même année, ordonné par score décroissant.

Si l’année est comprise entre 0 et 1899 (inclus), ajoute 1900 pour calculer l’année.

>>> DATE(108, 1, 2)
datetime.date(2008, 1, 2)

>>> DATE(2008, 1, 2)
datetime.date(2008, 1, 2)

Si le mois est supérieur à 12, passe à l’année suivante.

>>> DATE(2008, 14, 2)
datetime.date(2009, 2, 2)

Si le mois est inférieur à 1, soustrait ce nombre de mois plus 1, du premier mois de l’année.

>>> DATE(2008, -3, 2)
datetime.date(2007, 9, 2)

Si le jour est supérieur au nombre de jours dans le mois donné, passe aux mois suivants.

>>> DATE(2008, 1, 35)
datetime.date(2008, 2, 4)

Si le jour est inférieur à 1, soustrait ce nombre de jours plus 1, du premier jour du mois donné.

>>> DATE(2008, 1, -15)
datetime.date(2007, 12, 16)

Par exemple, DATEADD(date, 1) est identique à DATEADD(date, days=1), et ajoute un jour à date. DATEADD(date, years=1, days=-1) ajoute un an moins un jour.

>>> DATEADD(DATE(2011, 1, 15), 1)
datetime.date(2011, 1, 16)

>>> DATEADD(DATE(2011, 1, 15), months=1, days=-1)
datetime.date(2011, 2, 14)

>>> DATEADD(DATE(2011, 1, 15), years=-2, months=1, days=3, weeks=2)
datetime.date(2009, 3, 4)

>>> DATEADD(DATE(1975, 4, 30), years=50, weeks=-5)
datetime.date(2025, 3, 26)

• “Y” : Le nombre d’années complètes dans la période.
• “M” : Le nombre de mois complets dans la période.
• “D” : Le nombre de jours dans la période.
• “MD” : La différence entre les jours dans start_date et end_date. Les mois et années des dates sont ignorés.
• “YM” : La différence entre les mois dans start_date et end_date. Les jours et années des dates sont ignorés.
• “YD” : La différence entre les jours de start_date et end_date. Les années des dates sont ignorées.

Deux années complètes dans la période (2)

>>> DATEDIF(DATE(2001, 1, 1), DATE(2003, 1, 1), "Y")
2

440 jours entre le 1er juin 2001 et le 15 août 2002 (440)

>>> DATEDIF(DATE(2001, 6, 1), DATE(2002, 8, 15), "D")
440

75 jours entre le 1er juin et le 15 août, en ignorant les années des dates (75)

>>> DATEDIF(DATE(2001, 6, 1), DATE(2012, 8, 15), "YD")
75

La différence entre 1 et 15, en ignorant les mois et les années des dates (14)

>>> DATEDIF(DATE(2001, 6, 1), DATE(2002, 8, 15), "MD")
14

>>> DATEVALUE("1/1/2008")
datetime.datetime(2008, 1, 1, 0, 0, tzinfo=moment.tzinfo('America/New_York'))

>>> DATEVALUE("30-Jan-2008")
datetime.datetime(2008, 1, 30, 0, 0, tzinfo=moment.tzinfo('America/New_York'))

>>> DATEVALUE("2008-12-11")
datetime.datetime(2008, 12, 11, 0, 0, tzinfo=moment.tzinfo('America/New_York'))

>>> DATEVALUE("5-JUL").replace(year=2000)
datetime.datetime(2000, 7, 5, 0, 0, tzinfo=moment.tzinfo('America/New_York'))

En cas d’ambiguïté, préférez le format M/J/A.

>>> DATEVALUE("1/2/3")
datetime.datetime(2003, 1, 2, 0, 0, tzinfo=moment.tzinfo('America/New_York'))

Voir XL_TO_DATE pour plus d’explications.

>>> DATE_TO_XL(datetime.date(2008, 1, 1))
39448.0

>>> DATE_TO_XL(datetime.date(2012, 3, 14))
40982.0

>>> DATE_TO_XL(datetime.datetime(2012, 3, 14, 1, 30))
40982.0625

>>> DAY(DATE(2011, 4, 15))
15

>>> DAY("5/31/2012")
31

>>> DAY(datetime.datetime(1900, 1, 1))
1

>>> DAYS("3/15/11","2/1/11")
42

>>> DAYS(DATE(2011, 12, 31), DATE(2011, 1, 1))
364

>>> DAYS("2/1/11", "3/15/11")
-42

Le datetime retourné aura son fuseau horaire défini sur l’argument tz, ou le fuseau horaire par défaut du document lorsque tz est omis ou None. Si l’entrée est elle-même un datetime avec le fuseau horaire défini, il est retourné sans changement (sans modifications de son fuseau horaire).

>>> DTIME(datetime.date(2017, 1, 1))
datetime.datetime(2017, 1, 1, 0, 0, tzinfo=moment.tzinfo('America/New_York'))

>>> DTIME(datetime.date(2017, 1, 1), 'Europe/Paris')
datetime.datetime(2017, 1, 1, 0, 0, tzinfo=moment.tzinfo('Europe/Paris'))

>>> DTIME(datetime.datetime(2017, 1, 1))
datetime.datetime(2017, 1, 1, 0, 0, tzinfo=moment.tzinfo('America/New_York'))

>>> DTIME(datetime.datetime(2017, 1, 1, tzinfo=moment.tzinfo('UTC')))
datetime.datetime(2017, 1, 1, 0, 0, tzinfo=moment.tzinfo('UTC'))

>>> DTIME(datetime.datetime(2017, 1, 1, tzinfo=moment.tzinfo('UTC')), 'Europe/Paris')
datetime.datetime(2017, 1, 1, 0, 0, tzinfo=moment.tzinfo('UTC'))

>>> DTIME("1/1/2008")
datetime.datetime(2008, 1, 1, 0, 0, tzinfo=moment.tzinfo('America/New_York'))

>>> EDATE(DATE(2011, 1, 15), 1)
datetime.date(2011, 2, 15)

>>> EDATE(DATE(2011, 1, 15), -1)
datetime.date(2010, 12, 15)

>>> EDATE(DATE(2011, 1, 15), 2)
datetime.date(2011, 3, 15)

>>> EDATE(DATE(2012, 3, 1), 10)
datetime.date(2013, 1, 1)

>>> EDATE(DATE(2012, 5, 1), -2)
datetime.date(2012, 3, 1)

>>> EOMONTH(DATE(2011, 1, 1), 1)
datetime.date(2011, 2, 28)

>>> EOMONTH(DATE(2011, 1, 15), -3)
datetime.date(2010, 10, 31)

>>> EOMONTH(DATE(2012, 3, 1), 10)
datetime.date(2013, 1, 31)

>>> EOMONTH(DATE(2012, 5, 1), -2)
datetime.date(2012, 3, 31)

>>> HOUR(XL_TO_DATE(0.75))
18

>>> HOUR("7/18/2011 7:45")
7

>>> HOUR("4/21/2012")
0

>>> ISOWEEKNUM("3/9/2012")
10

>>> [ISOWEEKNUM(DATE(2000 + y, 1, 1)) for y in [0,1,2,3,4,5,6,7,8]]
[52, 1, 1, 1, 1, 53, 52, 1, 1]

>>> MINUTE(XL_TO_DATE(0.75))
0

>>> MINUTE("7/18/2011 7:45")
45

>>> MINUTE("12:59:00 PM")
59

>>> MINUTE(datetime.time(12, 58, 59))
58

>>> MONTH(DATE(2011, 4, 15))
4

>>> MONTH("5/31/2012")
5

>>> MONTH(datetime.datetime(1900, 1, 1))
1

• Avec output="days", la sortie est l’âge de la lune en jours (nouvelle lune étant 0).
• Avec output="fraction", la sortie est la fraction du mois lunaire depuis la nouvelle lune.

Le calcul n’est pas astronomiquement précis, mais suffisant pour les loups et les marins.

NE PAS utiliser output="lunacy".

>>> MOONPHASE(datetime.date(1900, 1, 1), "days")
0.0

>>> MOONPHASE(datetime.date(1900, 1, 1), "fraction")
0.0

>>> MOONPHASE(datetime.datetime(1900, 1, 1)) == '🌑'
True

>>> MOONPHASE(datetime.date(1900, 1, 15)) == '🌕'
True

>>> MOONPHASE(datetime.date(1900, 1, 30)) == '🌑'
True

>>> [MOONPHASE(DATEADD(datetime.date(2023, 4, 1), days=4*n)) for n in range(8)] == ['🌔', '🌕', '🌖', '🌗', '🌘', '🌑', '🌒', '🌓']
True

>>> [round(MOONPHASE(DATEADD(datetime.date(2023, 4, 1), days=4*n)), 1) for n in range(8)]
[10.4, 14.4, 18.4, 22.4, 26.4, 0.9, 4.9, 8.9]

>>> SECOND(XL_TO_DATE(0.75))
0

>>> SECOND("7/18/2011 7:45:13")
13

>>> SECOND(datetime.time(12, 58, 59))
59

Return_type détermine le type de la valeur retournée.

• 1 (par défaut) - Retourne 1 (dimanche) à 7 (samedi).
• 2 - Retourne 1 (lundi) à 7 (dimanche).
• 3 - Retourne 0 (lundi) à 6 (dimanche).
• 11 - Retourne 1 (lundi) à 7 (dimanche).
• 12 - Retourne 1 (mardi) à 7 (lundi).
• 13 - Retourne 1 (mercredi) à 7 (mardi).
• 14 - Retourne 1 (jeudi) à 7 (mercredi).
• 15 - Retourne 1 (vendredi) à 7 (jeudi).
• 16 - Retourne 1 (samedi) à 7 (vendredi).
• 17 - Retourne 1 (dimanche) à 7 (samedi).

>>> WEEKDAY(DATE(2008, 2, 14))
5

>>> WEEKDAY(DATE(2012, 3, 1))
5

>>> WEEKDAY(DATE(2012, 3, 1), 1)
5

>>> WEEKDAY(DATE(2012, 3, 1), 2)
4

>>> WEEKDAY("3/1/2012", 3)
3

Return_type détermine quelle semaine est considérée comme la première semaine de l’année.

• 1 (par défaut) - La semaine 1 est la première semaine commençant dimanche qui contient le 1er janvier.
• 2 - La semaine 1 est la première semaine commençant lundi qui contient le 1er janvier.
• 11 - La semaine 1 est la première semaine commençant lundi qui contient le 1er janvier.
• 12 - La semaine 1 est la première semaine commençant mardi qui contient le 1er janvier.
• 13 - La semaine 1 est la première semaine commençant mercredi qui contient le 1er janvier.
• 14 - La semaine 1 est la première semaine commençant jeudi qui contient le 1er janvier.
• 15 - La semaine 1 est la première semaine commençant vendredi qui contient le 1er janvier.
• 16 - La semaine 1 est la première semaine commençant samedi qui contient le 1er janvier.
• 17 - La semaine 1 est la première semaine commençant dimanche qui contient le 1er janvier.
• 21 - Approche ISO 8601 : La semaine 1 est la première semaine commençant lundi qui contient le 4 janvier. Équivalemment, c’est la semaine qui contient le premier jeudi de l’année.

>>> WEEKNUM(DATE(2012, 3, 9))
10

>>> WEEKNUM(DATE(2012, 3, 9), 2)
11

>>> WEEKNUM('1/1/1900')
1

>>> WEEKNUM('2/1/1900')
5

(Cela correspond à l’interprétation de Google Sheets. Excel commence avec le 31 décembre 1899 mais considère à tort 1900 comme une année bissextile. Excel pour Mac doit être configuré pour utiliser le système de date 1900, c’est-à-dire décocher l’option “Utiliser le système de date 1904”.)

Le datetime retourné aura son fuseau horaire défini sur l’argument tz, ou le fuseau horaire par défaut du document lorsque tz est omis ou None.

>>> XL_TO_DATE(41100.1875)
datetime.datetime(2012, 7, 10, 4, 30, tzinfo=moment.tzinfo('America/New_York'))

>>> XL_TO_DATE(39448)
datetime.datetime(2008, 1, 1, 0, 0, tzinfo=moment.tzinfo('America/New_York'))

>>> XL_TO_DATE(40982.0625)
datetime.datetime(2012, 3, 14, 1, 30, tzinfo=moment.tzinfo('America/New_York'))

>>> YEAR(DATE(2011, 4, 15))
2011

>>> YEAR("5/31/2030")
2030

>>> YEAR(datetime.datetime(1900, 1, 1))
1900

Basis est le type de base de comptage des jours à utiliser.

• 0 (par défaut) - US (NASD) 30/360
• 1 - Actuel/actuel
• 2 - Actuel/360
• 3 - Actuel/365
• 4 - Européen 30/360
• -1 - Actuel/actuel (variation Google Sheets)

Cette fonction est utile pour les calculs financiers. Pour la compatibilité avec Excel, elle par défaut utilise le calendrier standard NASD. Pour une utilisation dans des contextes non financiers, l’option -1 est probablement le meilleur choix.

Voir https://en.wikipedia.org/wiki/360-day_calendar pour l’explication des méthodes US 30/360 et Européenne 30/360. Voir pour l’analyse de l’implémentation particulière d’Excel.

Fraction de l’année entre le 1/1/2012 et le 30/7/12, en omettant l’argument Basis.

>>> "%.8f" % YEARFRAC(DATE(2012, 1, 1), DATE(2012, 7, 30))
'0.58055556'

Fraction entre les mêmes dates, en utilisant l’argument de base Actuel/Actuel. Parce que 2012 est une année bissextile, elle a une base de 366 jours.

>>> "%.8f" % YEARFRAC(DATE(2012, 1, 1), DATE(2012, 7, 30), 1)
'0.57650273'

Fraction entre les mêmes dates, en utilisant l’argument de base Actuel/365. Utilise une base de 365 jours.

>>> "%.8f" % YEARFRAC(DATE(2012, 1, 1), DATE(2012, 7, 30), 3)
'0.57808219'

NoteCette fonction n’est pas actuellement implémentée dans Grist.

NoteCette fonction n’est pas actuellement implémentée dans Grist.

Notez que la vérification de la validité des emails n’est pas une science exacte. La norme technique considère de nombreuses adresses email comme valides qui ne sont pas utilisées dans la pratique, et ne seraient pas considérées comme valides par la plupart des utilisateurs. Au lieu de cela, nous suivons l’implémentation de Google Sheets, avec quelques différences, notées ci-dessous.

>>> ISEMAIL("Abc.123@example.com")
True

>>> ISEMAIL("Bob_O-Reilly+tag@example.com")
True

>>> ISEMAIL("John Doe")
False

>>> ISEMAIL("john@aol...com")
False

NOTE : Grist implémente cela en enveloppant automatiquement l’argument pour utiliser l’évaluation paresseuse.

Une approche plus Pythonique pour vérifier les erreurs est :

try:
  ... value ...
except Exception, err:
  ... faire quelque chose à propos de l'erreur ...

Par exemple :

>>> ISERR("Hello")
False

NOTE : Grist implémente cela en enveloppant automatiquement l’argument pour utiliser l’évaluation paresseuse.

>>> ISERROR("Hello")
False

>>> ISERROR(AltText("fail"))
True

>>> ISERROR(float('nan'))
True

>>> ISLOGICAL(True)
True

>>> ISLOGICAL(False)
True

>>> ISLOGICAL(0)
False

>>> ISLOGICAL(None)
False

>>> ISLOGICAL("Test")
False

>>> ISNA(float('nan'))
True

>>> ISNA(0.0)
False

>>> ISNA('text')
False

>>> ISNA(float('-inf'))
False

>>> ISNONTEXT("asdf")
False

>>> ISNONTEXT("")
False

>>> ISNONTEXT(AltText("text"))
False

>>> ISNONTEXT(17.0)
True

>>> ISNONTEXT(None)
True

>>> ISNONTEXT(datetime.date(2011, 1, 1))
True

>>> ISNUMBER(17)
True

>>> ISNUMBER(-123.123423)
True

>>> ISNUMBER(False)
True

>>> ISNUMBER(float('nan'))
True

>>> ISNUMBER(float('inf'))
True

>>> ISNUMBER('17')
False

>>> ISNUMBER(None)
False

>>> ISNUMBER(datetime.date(2011, 1, 1))
False

Par exemple, si une colonne personne est de type Référence à la table Personnes, alors ISREF($personne) est True. De même, ISREF(Personnes.lookupOne(name=$name)) est True. Pour tout autre type de valeur, ISREF() évaluerait à False.

>>> ISREF(17)
False

>>> ISREF("Roger")
False

Par exemple, si une colonne personnes est de type Liste de Références à la table Personnes, alors ISREFLIST($personnes) est True. De même, ISREFLIST(Personnes.lookupRecords(name=$name)) est True. Pour tout autre type de valeur, ISREFLIST() évaluerait à False.

>>> ISREFLIST(17)
False

>>> ISREFLIST("Roger")
False

>>> ISTEXT("asdf")
True

>>> ISTEXT("")
True

>>> ISTEXT(AltText("text"))
True

>>> ISTEXT(17.0)
False

>>> ISTEXT(None)
False

>>> ISTEXT(datetime.date(2011, 1, 1))
False

Les protocoles valides incluent ftp, http, https, gopher, mailto, news, telnet et aim.

>>> ISURL("http://www.getgrist.com")
True

>>> ISURL("https://foo.com/test_(wikipedia)#cite-1")
True

>>> ISURL("mailto://user@example.com")
True

>>> ISURL("http:///a")
False

>>> N(7)
7

>>> N(7.1)
7.1

>>> N("Even")
0

>>> N("7")
0

>>> N(True)
1

>>> N(datetime.datetime(2011, 4, 17))
40650.0

>>> math.isnan(NA())
True

Par exemple, si la formule pour A dépend de $B et la formule pour B dépend de $A, cela provoquerait normalement une erreur de référence circulaire car chaque valeur doit être calculée avant l’autre. Mais si A utilise PEEK($B) alors il obtiendra simplement la valeur déjà stockée dans $B sans nécessiter que $B soit d’abord calculé à la dernière valeur. Ainsi, A sera calculé en premier, et B pourra utiliser $A sans problèmes.

Si dates_as_iso est défini, les valeurs Date et DateTime sont converties en chaîne en utilisant le format ISO 8601.

Si expand_refs est défini à 1 ou plus, les valeurs de Référence sont remplacées par une représentation RECORD de l’enregistrement référencé, en développant le nombre donné de niveaux.

Les valeurs d’erreur présentes dans les cellules de l’enregistrement sont remplacées par une valeur None, et une clé spéciale de “error” est ajoutée contenant les messages d’erreur pour ces cellules. Par exemple : {"Ratio": None, "_error_": {"Ratio": "ZeroDivisionError: integer division or modulo by zero"}}

Notez qu’il faut faire attention à éviter les références circulaires lors de l’utilisation de RECORD(), car cela crée une dépendance sur chaque cellule de l’enregistrement. Dans le cas de RECORD(rec), la cellule contenant cet appel sera omise du dictionnaire résultant.

Par exemple :

RECORD($Personne)
RECORD(rec)
RECORD(Personnes.lookupOne(Prenom="Alice"))
RECORD(Personnes.lookupRecords(Département="RH"))

NoteCette fonction n’est pas actuellement implémentée dans Grist.

NoteCette fonction n’est pas actuellement implémentée dans Grist.

>>> AND(1)
True

>>> AND(0)
False

>>> AND(1, 1)
True

>>> AND(1,2,3,4)
True

>>> AND(1,2,3,4,0)
False

>>> FALSE()
False

L’expression Python équivalente est :

valeur_si_vrai si expression_logique sinon valeur_si_faux

Comme Grist prend en charge les formules multi-lignes, vous pouvez également utiliser des blocs Python tels que :

if expression_logique:
  return valeur_si_vrai
else:
  return valeur_si_faux

NOTE : Grist suit le modèle Excel en n’évaluant qu’une des expressions de valeur, en enveloppant automatiquement les expressions pour utiliser l’évaluation paresseuse. Cela permet à IF(False, 1/0, 1) d’évaluer à 1 plutôt que de lever une exception.

>>> IF(12, "Oui", "Non")
'Oui'

>>> IF(None, "Oui", "Non")
'Non'

>>> IF(True, 0.85, 0.0)
0.85

>>> IF(False, 0.85, 0.0)
0.0

NOTE : Grist gère les valeurs qui lèvent une exception en les enveloppant pour utiliser l’évaluation paresseuse.

>>> IFERROR(float('nan'), "**NAN**")
'**NAN**'

>>> IFERROR(17.17, "**NAN**")
17.17

>>> IFERROR("Texte")
'Texte'

>>> IFERROR(AltText("bonjour"))
''

>>> NOT(123)
False

>>> NOT(0)
True

>>> OR(1)
True

>>> OR(0)
False

>>> OR(1, 1)
True

>>> OR(0, 1)
True

>>> OR(0, 0)
False

>>> OR(0,False,0.0,"",None)
False

>>> OR(0,None,3,0)
True

>>> TRUE()
True

Par exemple :

People.lookupOne(First_Name="Lewis", Last_Name="Carroll")
People.lookupOne(Email=$Work_Email)

En savoir plus sur lookupOne.

Si plusieurs enregistrements sont trouvés, le premier match est renvoyé. Vous pouvez définir le paramètre optionnel order_by au ID de colonne par lequel trier les correspondances, pour déterminer lequel d’entre eux est renvoyé en premier. Par défaut, l’enregistrement avec le plus petit ID de ligne est renvoyé.

Voir lookupRecords pour des détails sur toutes les options disponibles et le comportement de order_by (et de son alternative héritée, sort_by).

Par exemple :

Tasks.lookupOne(Project=$id, order_by="Priority")  # Tâche avec la plus petite priorité.
Rates.lookupOne(Person=$id, order_by="-Date")      # Taux avec la dernière date.

Par exemple :

People.lookupRecords(Email=$Work_Email)
People.lookupRecords(First_Name="George", Last_Name="Washington")

Vous pouvez définir le paramètre optionnel order_by au ID de colonne par lequel trier les résultats. Vous pouvez préfixer l’ID de colonne avec “-” pour inverser l’ordre. Vous pouvez également spécifier plusieurs ID de colonnes sous forme de tuple (par exemple, order_by=("Account", "-Date")).

Par exemple :

Transactions.lookupRecords(Account=$Account, order_by="Date")
Transactions.lookupRecords(Account=$Account, order_by="-Date")
Transactions.lookupRecords(Active=True, order_by=("Account", "-Date"))

Pour les enregistrements avec des champs order_by égaux, les résultats sont triés selon leur apparition dans les vues (ce qui est déterminé par la colonne spéciale manualSort). Vous pouvez définir order_by=None pour correspondre à l’ordre des enregistrements dans des vues non triées.

Par défaut, sans order_by, les enregistrements sont triés par ID de ligne, comme si avec order_by="id".

Pour des raisons de compatibilité, sort_by peut être utilisé à la place de order_by, mais ne permet qu’un seul champ, et revient à l’ID de ligne (plutôt qu’à manualSort).

Voir Ensemble d’Enregistrements pour des propriétés utiles offertes par l’objet renvoyé. En particulier, des méthodes comme .find.le permettent de rechercher les valeurs les plus proches.

Voir CONTIENT pour un exemple utilisant UserTable.lookupRecords pour trouver des enregistrements où un champ d’un type de liste (tel que Liste de Choix ou Liste de Références) contient la valeur donnée.

En savoir plus sur lookupRecords.

NoteCette fonction n’est pas actuellement implémentée dans Grist.

NoteCette fonction n’est pas actuellement implémentée dans Grist.

NoteCette fonction n’est pas actuellement implémentée dans Grist.

NoteCette fonction n’est pas actuellement implémentée dans Grist.

Par exemple :

MoviesTable.lookupRecords(genre=CONTAINS("Drama"))

renverra des enregistrements dans MoviesTable où la colonne genre est une liste ou un autre conteneur tel que ["Comedy", "Drama"], c’est-à-dire "Drama" in $genre.

Notez que la colonne recherchée (par exemple, genre) doit avoir des valeurs d’un type de conteneur tel que liste, tuple ou ensemble. En particulier, les valeurs ne doivent pas être des chaînes, par exemple "Comedy-Drama" ne correspondra pas même si "Drama" in "Comedy-Drama" est True en Python. Cela ne correspondra également pas aux sous-chaînes dans les éléments du conteneur, par exemple ["Comedy-Drama"].

Vous pouvez éventuellement passer un deuxième argument match_empty pour indiquer une valeur qui devrait être comparée aux listes vides dans la colonne recherchée.

Par exemple, étant donné cette formule :

MoviesTable.lookupRecords(genre=CONTAINS(g, match_empty=''))

Si g est '' (c’est-à-dire égal à match_empty), alors la colonne genre dans les enregistrements renvoyés sera soit une liste vide (ou un autre conteneur) soit une liste contenant g comme d’habitude.

NoteCette fonction n’est pas actuellement implémentée dans Grist.

NoteCette fonction n’est pas actuellement implémentée dans Grist.

NoteCette fonction n’est pas actuellement implémentée dans Grist.

NoteCette fonction n’est pas actuellement implémentée dans Grist.

NoteCette fonction n’est pas actuellement implémentée dans Grist.

NoteCette fonction n’est pas actuellement implémentée dans Grist.

NoteCette fonction n’est pas actuellement implémentée dans Grist.

NoteCette fonction n’est pas actuellement implémentée dans Grist.

NoteCette fonction n’est pas actuellement implémentée dans Grist.

NoteCette fonction n’est pas actuellement implémentée dans Grist.

La chaîne renvoyée est au format URL, éventuellement précédée d’une étiquette et d’un espace (le format attendu pour les colonnes de texte Grist avec l’option HyperLink activée).

Un numéro de page numérique peut être fourni, ce qui créera un lien vers la page spécifiée. Pour trouver le numéro de page numérique dont vous avez besoin, visitez une page et examinez son URL pour une partie /p/NN.

Un nombre quelconque d’arguments sous la forme LinkKey_NOM peut être fourni, pour définir les valeurs user.LinkKey.NOM qui seront disponibles dans les règles d’accès. Par exemple, si une règle permet aux utilisateurs de voir des lignes lorsque user.LinkKey.Code == rec.Code, nous pourrions vouloir créer des liens avec SELF_HYPERLINK(LinkKey_Code=$Code).

>>> SELF_HYPERLINK()
u'https://docs.getgrist.com/sbaltsirg/Example'

>>> SELF_HYPERLINK(label='doc')
u'doc https://docs.getgrist.com/sbaltsirg/Example'

>>> SELF_HYPERLINK(page=2)
u'https://docs.getgrist.com/sbaltsirg/Example/p/2'

>>> SELF_HYPERLINK(LinkKey_Code='X1234')
u'https://docs.getgrist.com/sbaltsirg/Example?Code_=X1234'

>>> SELF_HYPERLINK(label='order', page=3, LinkKey_Code='X1234', LinkKey_Name='Bi Ngo')
u'order https://docs.getgrist.com/sbaltsirg/Example/p/3?Code_=X1234&Name_=Bi+Ngo'

>>> SELF_HYPERLINK(Linky_Link='Link')
Traceback (most recent call last):
...
TypeError: unexpected keyword argument 'Linky_Link' (not of form LinkKey_NAME)

L’objet renvoyé est un enregistrement dont les champs sont disponibles en utilisant la syntaxe .champ. Par exemple, VLOOKUP(Employees, EmployeeID=$EmpID).Salary.

Notez que VLOOKUP n’est pas couramment nécessaire dans Grist, puisque les Colonnes de Référence sont le meilleur moyen de lier des données entre des tables, et permettent une utilisation simple et efficace telle que $Person.Age.

VLOOKUP est exactement équivalent à table.lookupOne(**champ_valeur_paires). Voir lookupOne.

Par exemple :

VLOOKUP(People, First_Name="Lewis", Last_Name="Carroll")
VLOOKUP(People, First_Name="Lewis", Last_Name="Carroll").Age

>>> ABS(2)
2

>>> ABS(-2)
2

>>> ABS(-4)
4

>>> round(ACOS(-0.5), 9)
2.094395102

>>> round(ACOS(-0.5)*180/PI(), 10)
120.0

>>> ACOSH(1)
0.0

>>> round(ACOSH(10), 7)
2.9932228

>>> ARABIC("LVII")
57

>>> ARABIC('mcmxii')
1912

>>> round(ASIN(-0.5), 9)
-0.523598776

>>> round(ASIN(-0.5)*180/PI(), 10)
-30.0

>>> round(DEGREES(ASIN(-0.5)), 10)
-30.0

>>> round(ASINH(-2.5), 9)
-1.647231146

>>> round(ASINH(10), 9)
2.99822295

>>> round(ATAN(1), 9)
0.785398163

>>> ATAN(1)*180/PI()
45.0

>>> DEGREES(ATAN(1))
45.0

>>> round(ATAN2(1, 1), 9)
0.785398163

>>> round(ATAN2(-1, -1), 9)
-2.35619449

>>> ATAN2(-1, -1)*180/PI()
-135.0

>>> DEGREES(ATAN2(-1, -1))
-135.0

>>> round(ATAN2(1,2), 9)
1.107148718

>>> round(ATANH(0.76159416), 9)
1.00000001

>>> round(ATANH(-0.1), 9)
-0.100335348

>>> CEILING(2.5, 1)
3

>>> CEILING(-2.5, -2)
-4

>>> CEILING(-2.5, 2)
-2

>>> CEILING(1.5, 0.1)
1.5

>>> CEILING(0.234, 0.01)
0.24

>>> COMBIN(8,2)
28

>>> COMBIN(4,2)
6

>>> COMBIN(10,7)
120

>>> round(COS(1.047), 7)
0.5001711

>>> round(COS(60*PI()/180), 10)
0.5

>>> round(COS(RADIANS(60)), 10)
0.5

>>> round(COSH(4), 6)
27.308233

>>> round(COSH(EXP(1)), 7)
7.6101251

>>> round(DEGREES(ACOS(-0.5)), 10)
120.0

>>> DEGREES(PI())
180.0

>>> EVEN(1.5)
2

>>> EVEN(3)
4

>>> EVEN(2)
2

>>> EVEN(-1)
-2

>>> round(EXP(1), 8)
2.71828183

>>> round(EXP(2), 7)
7.3890561

>>> FACT(5)
120

>>> FACT(1.9)
1

>>> FACT(0)
1

>>> FACT(1)
1

>>> FACT(-1)
Traceback (most recent call last):
  ...
ValueError: factorial() not defined for negative values

>>> FACTDOUBLE(6)
48

>>> FACTDOUBLE(7)
105

>>> FACTDOUBLE(3)
3

>>> FACTDOUBLE(4)
8

>>> FLOOR(3.7,2)
2

>>> FLOOR(-2.5,-2)
-2

>>> FLOOR(2.5,-2)
Traceback (most recent call last):
  ...
ValueError: facteur argument invalide

>>> FLOOR(1.58,0.1)
1.5

>>> FLOOR(0.234,0.01)
0.23

>>> GCD(5, 2)
1

>>> GCD(24, 36)
12

>>> GCD(7, 1)
1

>>> GCD(5, 0)
5

>>> GCD(0, 5)
5

>>> GCD(5)
5

>>> GCD(14, 42, 21)
7

>>> INT(8.9)
8

>>> INT(-8.9)
-9

>>> 19.5-INT(19.5)
0.5

>>> LCM(5, 2)
10

>>> LCM(24, 36)
72

>>> LCM(0, 5)
0

>>> LCM(5)
5

>>> LCM(10, 100)
100

>>> LCM(12, 18)
36

>>> LCM(12, 18, 24)
72

>>> round(LN(86), 7)
4.4543473

>>> round(LN(2.7182818), 7)
1.0

>>> round(LN(EXP(3)), 10)
3.0

>>> LOG(10)
1.0

>>> LOG(8, 2)
3.0

>>> round(LOG(86, 2.7182818), 7)
4.4543473

>>> round(LOG10(86), 9)
1.934498451

>>> LOG10(10)
1.0

>>> LOG10(100000)
5.0

>>> LOG10(10**5)
5.0

>>> MOD(3, 2)
1

>>> MOD(-3, 2)
1

>>> MOD(3, -2)
-1

>>> MOD(-3, -2)
-1

>>> MROUND(10, 3)
9

>>> MROUND(-10, -3)
-9

>>> round(MROUND(1.3, 0.2), 10)
1.4

>>> MROUND(5, -2)
Traceback (most recent call last):
  ...
ValueError: facteur argument invalide

>>> MULTINOMIAL(2, 3, 4)
1260

>>> MULTINOMIAL(3)
1

>>> MULTINOMIAL(1,2,3)
60

>>> MULTINOMIAL(0,2,4,6)
13860

>>> NUM(-17.0)
-17

>>> NUM(1.5)
1.5

>>> NUM(4)
4

>>> NUM("NA")
'NA'

>>> ODD(1.5)
3

>>> ODD(3)
3

>>> ODD(2)
3

>>> ODD(-1)
-1

>>> ODD(-2)
-3

>>> round(PI(), 9)
3.141592654

>>> round(PI()/2, 9)
1.570796327

>>> round(PI()*9, 8)
28.27433388

>>> POWER(5,2)
25.0

>>> round(POWER(98.6,3.2), 3)
2401077.222

>>> round(POWER(4,5.0/4), 9)
5.656854249

>>> PRODUCT([5,15,30])
2250

>>> PRODUCT([5,15,30], 2)
4500

>>> PRODUCT(5,15,[30],[2])
4500

>>> QUOTIENT(5, 2)
2

>>> QUOTIENT(4.5, 3.1)
1

>>> QUOTIENT(-10, 3)
-3

>>> round(RADIANS(270), 6)
4.712389

>>> ROMAN(499,0)
'CDXCIX'

>>> ROMAN(499.2,0)
'CDXCIX'

>>> ROMAN(57)
'LVII'

>>> ROMAN(1912)
'MCMXII'

Arrondit loin de zéro (‘vers le haut’ pour les nombres positifs) en cas d’égalité, c’est-à-dire lorsque le dernier chiffre est 5.

>>> ROUND(1.4)
1.0

>>> ROUND(1.5)
2.0

>>> ROUND(2.5)
3.0

>>> ROUND(-2.5)
-3.0

>>> ROUND(2.15, 1)
2.2

>>> ROUND(-1.475, 2)
-1.48

>>> ROUND(21.5, -1)
20.0

>>> ROUND(626.3,-3)
1000.0

>>> ROUND(1.98,-1)
0.0

>>> ROUND(-50.55,-2)
-100.0

>>> ROUND(0)
0.0

>>> ROUNDDOWN(3.2, 0)
3

>>> ROUNDDOWN(76.9,0)
76

>>> ROUNDDOWN(3.14159, 3)
3.141

>>> ROUNDDOWN(-3.14159, 1)
-3.1

>>> ROUNDDOWN(31415.92654, -2)
31400

>>> ROUNDUP(3.2,0)
4

>>> ROUNDUP(76.9,0)
77

>>> ROUNDUP(3.14159, 3)
3.142

>>> ROUNDUP(-3.14159, 1)
-3.2

>>> ROUNDUP(31415.92654, -2)
31500

>>> SERIESSUM(1,0,1,1)
1

>>> SERIESSUM(2,1,0,[1,2,3])
12

>>> SERIESSUM(-3,1,1,[2,4,6])
-132

>>> round(SERIESSUM(PI()/4,0,2,[1,-1./FACT(2),1./FACT(4),-1./FACT(6)]), 6)
0.707103

>>> SIGN(10)
1

>>> SIGN(4.0-4.0)
0

>>> SIGN(-0.00001)
-1

>>> round(SIN(PI()), 10)
0.0

>>> SIN(PI()/2)
1.0

>>> round(SIN(30*PI()/180), 10)
0.5

>>> round(SIN(RADIANS(30)), 10)
0.5

>>> round(2.868*SINH(0.0342*1.03), 7)
0.1010491

>>> SQRT(16)
4.0

>>> SQRT(-16)
Traceback (most recent call last):
  ...
ValueError: math domain error

>>> SQRT(ABS(-16))
4.0

>>> round(SQRTPI(1), 6)
1.772454

>>> round(SQRTPI(2), 6)
2.506628

NoteCette fonction n’est pas actuellement implémentée dans Grist.

>>> SUM([5,15,30])
50

>>> SUM([5.,15,30], 2)
52.0

>>> SUM(5,15,[30],[2])
52

NoteCette fonction n’est pas actuellement implémentée dans Grist.

NoteCette fonction n’est pas actuellement implémentée dans Grist.

>>> SUMPRODUCT([3,8,1,4,6,9], [2,6,5,7,7,3])
156

>>> SUMPRODUCT([], [], [])
0

>>> SUMPRODUCT([-0.25], [-2], [-3])
-1.5

>>> SUMPRODUCT([-0.25, -0.25], [-2, -2], [-3, -3])
-3.0

NoteCette fonction n’est pas actuellement implémentée dans Grist.

>>> round(TAN(0.785), 8)
0.99920399

>>> round(TAN(45*PI()/180), 10)
1.0

>>> round(TAN(RADIANS(45)), 10)
1.0

>>> round(TANH(-2), 6)
-0.964028

>>> TANH(0)
0.0

>>> round(TANH(0.5), 6)
0.462117

>>> TRUNC(8.9)
8

>>> TRUNC(-8.9)
-8

>>> TRUNC(0.45)
0

Puisque UUID() produit une valeur différente chaque fois qu’il est appelé, il est préférable de l’utiliser dans formule de déclenchement pour de nouveaux enregistrements. Cela ne calculerait UUID() qu’une seule fois et figerait la valeur calculée. En revanche, une formule ordinaire peut être recalculée à chaque fois que le document est rechargé, produisant une valeur différente pour UUID() à chaque fois.

L’horaire a le format “INTERVALLE : SLOTS, …”. Par exemple :

annuel : Jan-15, Apr-15, Jul-15  -- Trois fois par an aux dates données à minuit.
annuel : 1/15, 4/15, 7/15        -- Identique à ce qui précède.
mensuel : /1 14h, /15 14h        -- Le 1er et le 15 de chaque mois, à 14h.
3-mois : /10, +1m /20           -- Tous les 3 mois le 10 du mois 1, le 20 du mois 2.
hebdomadaire : Lu 9h, Ma 9h, Ve 14h  -- Trois fois par semaine à des heures spécifiées.
2-semaines : Lu, +1s Ma             -- Toutes les 2 semaines le lundi de la semaine 1, le mardi de la semaine 2.
quotidien : 07:30, 21:00             -- Deux fois par jour à des heures spécifiées.
2-jours : 00h, 16h, +1j 08h       -- Trois fois tous les deux jours, espacés uniformément.
horaire : :15, :45                -- 15 minutes avant et après chaque heure.
4-heures : :00, 1:20, 2:40         -- Trois fois toutes les 4 heures, espacés uniformément.
10-minutes : +0s                  -- Toutes les 10 minutes à la minute.

L’INTERVALLE doit être soit de la forme N-unité où N est un nombre et unité est l’un des année, mois, semaine, jour, heure; ou l’un des alias : annuel, mensuel, hebdomadaire, quotidien, horaire, qui signifient 1-année, 1-mois, etc.

Les SLOTS prennent en charge les unités suivantes :

`Jan-15` ou `1/15`    -- Mois et jour du mois ; disponible lorsque l'INTERVALLE est basé sur l'année.
`/15`                 -- Jour du mois, disponible lorsque l'INTERVALLE est basé sur le mois.
`Lun`, `Lu`, `Vendredi` -- Jour de la semaine (ou abréviation), lorsque l'INTERVALLE est basé sur la semaine.
10h, 13h30, 15h45   -- Heure de la journée, disponible pour des intervalles basés sur le jour ou plus longs.
:45, :00              -- Minutes de l'heure, disponibles lorsque l'INTERVALLE est basé sur l'heure.
+1j, +15j             -- Combien de jours ajouter au début de l'INTERVALLE.
+1s                   -- Combien de semaines ajouter au début de l'INTERVALLE.
+1m                   -- Combien de mois ajouter au début de l'INTERVALLE.

Les SLOTS sont toujours relatifs à l’INTERVALLE plutôt qu’à début. Les intervalles basés sur la semaine commencent le dimanche. Par exemple, hebdomadaire : +1j, +4j est identique à hebdomadaire : Lun, Jeu, et génère des heures les lundis et jeudis, quel que soit début.

Le premier temps généré est déterminé par l’unité de l’INTERVALLE sans tenir compte du multiple. Par exemple, à la fois “2-semaine : Lun” et “3-semaine : Lun” commencent le premier lundi après début, et génèrent ensuite soit tous les deuxièmes soit tous les troisièmes lundis après cela. De même, 24-heures : :00 commence avec le premier début d’heure après début (pas avec minuit), puis se répète toutes les 24 heures. Pour commencer avec la minuit après début, utilisez quotidien : 0:00.

Pour les unités d’intervalle d’un jour ou plus, si l’heure de la journée n’est pas spécifiée, elle par défaut à minuit.

Le fuseau horaire de début détermine le fuseau horaire des temps générés.

>>> def show(dates): return [d.strftime("%Y-%m-%d %H:%M") for d in dates]

>>> start = datetime(2018, 9, 4, 14, 0);   # 14h le mardi 4 septembre 2018.

>>> show(SCHEDULE('annual: Jan-15, Apr-15, Jul-15, Oct-15', start=start, count=4))
['2018-10-15 00:00', '2019-01-15 00:00', '2019-04-15 00:00', '2019-07-15 00:00']

>>> show(SCHEDULE('annual: 1/15, 4/15, 7/15', start=start, count=4))
['2019-01-15 00:00', '2019-04-15 00:00', '2019-07-15 00:00', '2020-01-15 00:00']

>>> show(SCHEDULE('monthly: /1 14h, /15 17h', start=start, count=4))
['2018-09-15 17:00', '2018-10-01 14:00', '2018-10-15 17:00', '2018-11-01 14:00']

>>> show(SCHEDULE('3-months: /10, +1m /20', start=start, count=4))
['2018-09-10 00:00', '2018-10-20 00:00', '2018-12-10 00:00', '2019-01-20 00:00']

>>> show(SCHEDULE('weekly: Lu 9h, Ma 9h, Ve 14h', start=start, count=4))
['2018-09-07 14:00', '2018-09-10 09:00', '2018-09-11 09:00', '2018-09-14 14:00']

>>> show(SCHEDULE('2-semaines: Lu, +1s Ma', start=start, count=4))
['2018-09-11 00:00', '2018-09-17 00:00', '2018-09-25 00:00', '2018-10-01 00:00']

>>> show(SCHEDULE('quotidien: 07:30, 21:00', start=start, count=4))
['2018-09-04 21:00', '2018-09-05 07:30', '2018-09-05 21:00', '2018-09-06 07:30']

>>> show(SCHEDULE('2-jours: 00h, 16h, +1j 08h', start=start, count=4))
['2018-09-04 16:00', '2018-09-05 08:00', '2018-09-06 00:00', '2018-09-06 16:00']

>>> show(SCHEDULE('horaire: :15, :45', start=start, count=4))
['2018-09-04 14:15', '2018-09-04 14:45', '2018-09-04 15:15', '2018-09-04 15:45']

>>> show(SCHEDULE('4-heures: :00, +1H :20, +2H :40', start=start, count=4))
['2018-09-04 14:00', '2018-09-04 15:20', '2018-09-04 16:40', '2018-09-04 18:00']

NoteCette fonction n’est pas actuellement implémentée dans Grist.

Chaque argument peut être une valeur ou un tableau. Les valeurs qui ne sont pas des nombres, y compris les valeurs logiques et vides, et les représentations textuelles de nombres, sont ignorées.

>>> AVERAGE([2, -1.0, 11])
4.0

>>> AVERAGE([2, -1, 11, "Bonjour"])
4.0

>>> AVERAGE([2, -1, "Bonjour", DATE(2015,1,1)], True, [False, "123", "", 11])
4.0

>>> AVERAGE(False, True)
Traceback (most recent call last):
  ...
ZeroDivisionError: float division by zero

Chaque argument peut être une valeur ou un tableau. Les valeurs qui ne sont pas des nombres, y compris les dates et les représentations textuelles de nombres, sont comptées comme 0 (zéro). La valeur logique de True est comptée comme 1, et False comme 0.

>>> AVERAGEA([2, -1.0, 11])
4.0

>>> AVERAGEA([2, -1, 11, "Bonjour"])
3.0

>>> AVERAGEA([2, -1, "Bonjour", DATE(2015,1,1)], True, [False, "123", "", 11.5])
1.5

>>> AVERAGEA(False, True)
0.5

NoteCette fonction n’est pas actuellement implémentée dans Grist.

NoteCette fonction n’est pas actuellement implémentée dans Grist.

Si vous avez deux listes, de valeurs et de poids, utilisez la fonction intégrée Python zip() pour créer une liste de paires.

>>> AVERAGE_WEIGHTED(((95, .25), (90, .1), ("X", .5), (85, .15), (88, .2), (82, .3), (70, None)))
87.7

>>> AVERAGE_WEIGHTED(zip([95, 90, "X", 85, 88, 82, 70], [25, 10, 50, 15, 20, 30, None]))
87.7

>>> AVERAGE_WEIGHTED(zip([95, 90, False, 85, 88, 82, 70], [.25, .1, .5, .15, .2, .3, True]))
87.7

NoteCette fonction n’est pas actuellement implémentée dans Grist.

NoteCette fonction n’est pas actuellement implémentée dans Grist.

NoteCette fonction n’est pas actuellement implémentée dans Grist.

Chaque argument peut être une valeur ou un tableau. Les valeurs qui ne sont pas des nombres ou des dates, y compris les valeurs logiques et vides, et les représentations textuelles de nombres, sont ignorées.

>>> COUNT([2, -1.0, 11])
3

>>> COUNT([2, -1, 11, "Bonjour"])
3

>>> COUNT([DATE(2000, 1, 1), DATE(2000, 1, 2), DATE(2000, 1, 3), "Bonjour"])
3

>>> COUNT([2, -1, "Bonjour", DATE(2015,1,1)], True, [False, "123", "", 11.5])
4

>>> COUNT(False, True)
0

Chaque argument peut être une valeur ou un tableau.

>>> COUNTA([2, -1.0, 11])
3

>>> COUNTA([2, -1, 11, "Bonjour"])
4

>>> COUNTA([2, -1, "Bonjour", DATE(2015,1,1)], True, [False, "123", "", 11.5])
9

>>> COUNTA(False, True)
2

NoteCette fonction n’est pas actuellement implémentée dans Grist.

NoteCette fonction n’est pas actuellement implémentée dans Grist.

NoteCette fonction n’est pas actuellement implémentée dans Grist.

NoteCette fonction n’est pas actuellement implémentée dans Grist.

NoteCette fonction n’est pas actuellement implémentée dans Grist.

NoteCette fonction n’est pas actuellement implémentée dans Grist.

NoteCette fonction n’est pas actuellement implémentée dans Grist.

NoteCette fonction n’est pas actuellement implémentée dans Grist.

NoteCette fonction n’est pas actuellement implémentée dans Grist.

NoteCette fonction n’est pas actuellement implémentée dans Grist.

NoteCette fonction n’est pas actuellement implémentée dans Grist.

NoteCette fonction n’est pas actuellement implémentée dans Grist.

Note Cette fonction n’est pas actuellement implémentée dans Grist.

Note Cette fonction n’est pas actuellement implémentée dans Grist.

Note Cette fonction n’est pas actuellement implémentée dans Grist.

Note Cette fonction n’est pas actuellement implémentée dans Grist.

Note Cette fonction n’est pas actuellement implémentée dans Grist.

Note Cette fonction n’est pas actuellement implémentée dans Grist.

Chaque argument peut être une valeur ou un tableau. Les valeurs qui ne sont pas des nombres ou des dates, y compris les valeurs logiques et les valeurs vides, ainsi que les représentations textuelles de nombres, sont ignorées. Renvoie 0 si les arguments ne contiennent aucun nombre ou date.

>>> MAX([2, -1.5, 11.5])
11.5

>>> MAX([2, -1.5, "Hello"], True, [False, "123", "", 11.5])
11.5

>>> MAX(True, -123)
-123

>>> MAX("123", -123)
-123

>>> MAX("Hello", "123", True, False)
0

>>> MAX(DATE(2015, 1, 1), DATE(2015, 1, 2))
datetime.date(2015, 1, 2)

>>> MAX(DATE(2015, 1, 1), datetime.datetime(2015, 1, 1, 12, 34, 56))
datetime.datetime(2015, 1, 1, 12, 34, 56)

>>> MAX(DATE(2015, 1, 2), datetime.datetime(2015, 1, 1, 12, 34, 56))
datetime.date(2015, 1, 2)

Chaque argument peut être une valeur d’un tableau. Les valeurs qui ne sont pas des nombres, y compris les dates et les représentations textuelles de nombres, sont comptées comme 0 (zéro). La valeur logique de True est comptée comme 1, et False comme 0. Renvoie 0 si les arguments ne contiennent aucun nombre.

>>> MAXA([2, -1.5, 11.5])
11.5

>>> MAXA([2, -1.5, "Hello", DATE(2015, 1, 1)], True, [False, "123", "", 11.5])
11.5

>>> MAXA(True, -123)
1

>>> MAXA("123", -123)
0

>>> MAXA("Hello", "123", DATE(2015, 1, 1))
0

Chaque argument peut être une valeur ou un tableau. Les valeurs qui ne sont pas des nombres, y compris les valeurs logiques et les valeurs vides, ainsi que les représentations textuelles de nombres, sont ignorées.

Produit une erreur si les arguments ne contiennent aucun nombre.

La médiane est le nombre du milieu lorsque toutes les valeurs sont triées. Ainsi, la moitié des valeurs dans l’ensemble de données sont inférieures à la médiane, et l’autre moitié est supérieure. S’il y a un nombre pair de valeurs dans l’ensemble de données, renvoie la moyenne des deux nombres du milieu.

>>> MEDIAN(1, 2, 3, 4, 5)
3

>>> MEDIAN(3, 5, 1, 4, 2)
3

>>> MEDIAN(range(10))
4.5

>>> MEDIAN("Hello", "123", DATE(2015, 1, 1), 12.3)
12.3

>>> MEDIAN("Hello", "123", DATE(2015, 1, 1))
Traceback (most recent call last):
  ...
ValueError: MEDIAN requires at least one number

Chaque argument peut être une valeur ou un tableau. Les valeurs qui ne sont pas des nombres ou des dates, y compris les valeurs logiques et les valeurs vides, ainsi que les représentations textuelles de nombres, sont ignorées. Renvoie 0 si les arguments ne contiennent aucun nombre ou date.

>>> MIN([2, -1.5, 11.5])
-1.5

>>> MIN([2, -1.5, "Hello"], True, [False, "123", "", 11.5])
-1.5

>>> MIN(True, 123)
123

>>> MIN("-123", 123)
123

>>> MIN("Hello", "123", True, False)
0

>>> MIN(DATE(2015, 1, 1), DATE(2015, 1, 2))
datetime.date(2015, 1, 1)

>>> MIN(DATE(2015, 1, 1), datetime.datetime(2015, 1, 1, 12, 34, 56))
datetime.date(2015, 1, 1)

>>> MIN(DATE(2015, 1, 2), datetime.datetime(2015, 1, 1, 12, 34, 56))
datetime.datetime(2015, 1, 1, 12, 34, 56)

Chaque argument peut être une valeur d’un tableau. Les valeurs qui ne sont pas des nombres, y compris les dates et les représentations textuelles de nombres, sont comptées comme 0 (zéro). La valeur logique de True est comptée comme 1, et False comme 0. Renvoie 0 si les arguments ne contiennent aucun nombre.

>>> MINA([2, -1.5, 11.5])
-1.5

>>> MINA([2, -1.5, "Hello", DATE(2015, 1, 1)], True, [False, "123", "", 11.5])
-1.5

>>> MINA(True, 123)
1

>>> MINA("-123", 123)
0

>>> MINA("Hello", "123", DATE(2015, 1, 1))
0

Note Cette fonction n’est pas actuellement implémentée dans Grist.

Note Cette fonction n’est pas actuellement implémentée dans Grist.

Note Cette fonction n’est pas actuellement implémentée dans Grist.

Note Cette fonction n’est pas actuellement implémentée dans Grist.

Note Cette fonction n’est pas actuellement implémentée dans Grist.

Note Cette fonction n’est pas actuellement implémentée dans Grist.

Note Cette fonction n’est pas actuellement implémentée dans Grist.

Note Cette fonction n’est pas actuellement implémentée dans Grist.

Note Cette fonction n’est pas actuellement implémentée dans Grist.

Note Cette fonction n’est pas actuellement implémentée dans Grist.

Note Cette fonction n’est pas actuellement implémentée dans Grist.

Note Cette fonction n’est pas actuellement implémentée dans Grist.

Note Cette fonction n’est pas actuellement implémentée dans Grist.

Note Cette fonction n’est pas actuellement implémentée dans Grist.

Note Cette fonction n’est pas actuellement implémentée dans Grist.

Note Cette fonction n’est pas actuellement implémentée dans Grist.

Note Cette fonction n’est pas actuellement implémentée dans Grist.

Note Cette fonction n’est pas actuellement implémentée dans Grist.

Note Cette fonction n’est pas actuellement implémentée dans Grist.

Note Cette fonction n’est pas actuellement implémentée dans Grist.

Note Cette fonction n’est pas actuellement implémentée dans Grist.

Note Cette fonction n’est pas actuellement implémentée dans Grist.

>>> STDEV([2, 5, 8, 13, 10])
4.277849927241488

>>> STDEV([2, 5, 8, 13, 10, True, False, "Test"])
4.277849927241488

>>> STDEV([2, 5, 8, 13, 10], 3, 12, 15)
4.810702354423639

>>> STDEV([2, 5, 8, 13, 10], [3, 12, 15])
4.810702354423639

>>> STDEV([5])
Traceback (most recent call last):
  ...
ZeroDivisionError: float division by zero

>>> STDEVA([2, 5, 8, 13, 10])
4.277849927241488

>>> STDEVA([2, 5, 8, 13, 10, True, False, "Test"])
4.969550137731641

>>> STDEVA([2, 5, 8, 13, 10], 1, 0, 0)
4.969550137731641

>>> STDEVA([2, 5, 8, 13, 10], [1, 0, 0])
4.969550137731641

>>> STDEVA([5])
Traceback (most recent call last):
  ...
ZeroDivisionError: float division by zero

>>> STDEVP([2, 5, 8, 13, 10])
3.8262252939417984

>>> STDEVP([2, 5, 8, 13, 10, True, False, "Test"])
3.8262252939417984

>>> STDEVP([2, 5, 8, 13, 10], 3, 12, 15)
4.5

>>> STDEVP([2, 5, 8, 13, 10], [3, 12, 15])
4.5

>>> STDEVP([5])
0.0

>>> STDEVPA([2, 5, 8, 13, 10])
3.8262252939417984

>>> STDEVPA([2, 5, 8, 13, 10, True, False, "Test"])
4.648588495446763

>>> STDEVPA([2, 5, 8, 13, 10], 1, 0, 0)
4.648588495446763

>>> STDEVPA([2, 5, 8, 13, 10], [1, 0, 0])
4.648588495446763

>>> STDEVPA([5])
0.0

Note Cette fonction n’est pas actuellement implémentée dans Grist.

Note Cette fonction n’est pas actuellement implémentée dans Grist.

Note Cette fonction n’est pas actuellement implémentée dans Grist.

Note Cette fonction n’est pas actuellement implémentée dans Grist.

Note Cette fonction n’est pas actuellement implémentée dans Grist.

Note Cette fonction n’est pas actuellement implémentée dans Grist.

Note Cette fonction n’est pas actuellement implémentée dans Grist.

Note Cette fonction n’est pas actuellement implémentée dans Grist.

Note Cette fonction n’est pas actuellement implémentée dans Grist.

Note Cette fonction n’est pas actuellement implémentée dans Grist.

Note Cette fonction n’est pas actuellement implémentée dans Grist.

Note Cette fonction n’est pas actuellement implémentée dans Grist.

Note Cette fonction n’est pas actuellement implémentée dans Grist.

>>> CHAR(65)
u'A'

>>> CHAR(33)
u'!'

Cela supprime à la fois les caractères avec des valeurs de 0 à 31, et d’autres caractères Unicode dans la catégorie “caractères de contrôle”.

>>> CLEAN(CHAR(9) + "Rapport mensuel" + CHAR(10))
u'Rapport mensuel'

>>> CODE("A")
65

>>> CODE("!")
33

>>> CODE("!A")
33

>>> CONCAT("Population de ruisseau pour ", "truite", " ", "espèces", " est ", 32, "/mile.")
u'Population de ruisseau pour truite espèces est 32/mile.'

>>> CONCAT("Dans ", 4, " jours, c'est ", datetime.date(2016,1,1))
u'Dans 4 jours, c'est 2016-01-01'

>>> CONCAT("abc")
u'abc'

>>> CONCAT(0, "abc")
u'0abc'

>>> assert CONCAT(2, u" crème ", u"brûlée") == u'2 crème brûlée'

>>> CONCATENATE("Population de ruisseau pour ", "truite", " ", "espèces", " est ", 32, "/mile.")
u'Population de ruisseau pour truite espèces est 32/mile.'

>>> CONCATENATE("Dans ", 4, " jours, c'est ", datetime.date(2016,1,1))
u'Dans 4 jours, c'est 2016-01-01'

>>> CONCATENATE("abc")
u'abc'

>>> CONCATENATE(0, "abc")
u'0abc'

>>> assert CONCATENATE(2, u" crème ", u"brûlée") == u'2 crème brûlée'

>>> assert CONCATENATE(2,  " crème ", u"brûlée") == u'2 crème brûlée'

>>> assert CONCATENATE(2,  " crème ",  "brûlée") == u'2 crème brûlée'

>>> DOLLAR(1234.567)
'$1,234.57'

>>> DOLLAR(1234.567, -2)
'$1,200'

>>> DOLLAR(-1234.567, -2)
'($1,200)'

>>> DOLLAR(-0.123, 4)
'($0.1230)'

>>> DOLLAR(99.888)
'$99.89'

>>> DOLLAR(0)
'$0.00'

>>> DOLLAR(10, 0)
'$10'

>>> EXACT("mot", "mot")
True

>>> EXACT("Mot", "mot")
False

>>> EXACT("m ot", "mot")
False

La recherche est sensible à la casse. La position renvoyée est 1 si within_text commence par find_text. start_num spécifie le caractère à partir duquel commencer la recherche, par défaut à 1 (le premier caractère de within_text).

Si find_text n’est pas trouvé, ou si start_num est invalide, lève une ValueError.

>>> FIND("M", "Miriam McGovern")
1

>>> FIND("m", "Miriam McGovern")
6

>>> FIND("M", "Miriam McGovern", 3)
8

>>> FIND(" #", "Hello world # Test")
12

>>> FIND("gle", "Google", 1)
4

>>> FIND("GLE", "Google", 1)
Traceback (most recent call last):
...
ValueError: substring not found

>>> FIND("page", "homepage")
5

>>> FIND("page", "homepage", 6)
Traceback (most recent call last):
...
ValueError: substring not found

>>> FIXED(1234.567, 1)
'1,234.6'

>>> FIXED(1234.567, -1)
'1,230'

>>> FIXED(-1234.567, -1, True)
'-1230'

>>> FIXED(44.332)
'44.33'

>>> FIXED(3521.478, 2, False)
'3,521.48'

>>> FIXED(-3521.478, 1, True)
'-3521.5'

>>> FIXED(3521.478, 0, True)
'3521'

>>> FIXED(3521.478, -2, True)
'3500'

>>> LEFT("Prix de vente", 4)
'Sale'

>>> LEFT('Suède')
'S'

>>> LEFT('Texte', -1)
Traceback (most recent call last):
...
ValueError: num_chars invalid

>>> LEN("Phoenix, AZ")
11

>>> LEN("")
0

>>> LEN("     Un   ")
11

>>> LOWER("E. E. Cummings")
'e. e. cummings'

>>> LOWER("Apt. 2B")
'apt. 2b'

>>> MID("Flux de fluide", 1, 5)
'Fluid'

>>> MID("Flux de fluide", 7, 20)
'Flow'

>>> MID("Flux de fluide", 20, 5)
''

>>> MID("Flux de fluide", 0, 5)
Traceback (most recent call last):
...
ValueError: start_num invalid

Sans arguments optionnels, le numéro doit commencer par “+” et le préfixe d’appel international, et sera formaté comme un numéro international, par exemple +12345678901 devient +1 234-567-8901.

L’argument country permet de spécifier un code de pays à 2 lettres (par exemple “US” ou “GB”) pour interpréter les numéros de téléphone qui ne commencent pas par “+”. Par exemple, PHONE_FORMAT('2025555555', 'US') serait considéré comme un numéro américain et formaté comme “(202) 555-5555”. Les numéros de téléphone qui commencent par “+” ignorent country. Par exemple, PHONE_FORMAT('+33555555555', 'US') est un numéro français car ‘+33’ est le préfixe international pour la France.

L’argument format spécifie le format de sortie, selon ce tableau :

• "#" ou "NATL" (par défaut) - utilise le format national, sans le préfixe d’appel international, lorsque c’est possible. Par exemple (234) 567-8901 pour “US”, ou 02 34 56 78 90 pour “FR”. Si country est omis, ou le numéro ne correspond pas au pays donné, le format international est utilisé à la place.
• "+" ou "INTL" - format international, par exemple +1 234-567-8901 ou +33 2 34 56 78 90.
• "*" ou "E164" - format E164, comme international mais sans séparateurs, par exemple +12345678901.
• "tel" ou "RFC3966" - format adapté à utiliser comme un hyperlien, par exemple ‘tel:+1-234-567-8901’.

Lorsque vous spécifiez l’argument format, vous pouvez omettre l’argument country. C’est-à-dire PHONE_FORMAT(value, "tel") est équivalent à PHONE_FORMAT(value, None, "tel").

Pour plus de détails, voir la bibliothèque Python phonenumbers qui sous-tend cette fonction.

>>> PHONE_FORMAT("+12345678901")
u'+1 234-567-8901'

>>> PHONE_FORMAT("2345678901", "US")
u'(234) 567-8901'

>>> PHONE_FORMAT("2345678901", "GB")
u'023 4567 8901'

>>> PHONE_FORMAT("2345678901", "GB", "+")
u'+44 23 4567 8901'

>>> PHONE_FORMAT("+442345678901", "GB")
u'023 4567 8901'

>>> PHONE_FORMAT("+12345678901", "GB")
u'+1 234-567-8901'

>>> PHONE_FORMAT("(234) 567-8901")
Traceback (most recent call last):
...
NumberParseException: (0) Missing or invalid default region.

>>> PHONE_FORMAT("(234)567 89-01", "US", "tel")
u'tel:+1-234-567-8901'

>>> PHONE_FORMAT("2/3456/7890", "FR", '#')
u'02 34 56 78 90'

>>> PHONE_FORMAT("+33234567890", '#')
u'+33 2 34 56 78 90'

>>> PHONE_FORMAT("+33234567890", 'tel')
u'tel:+33-2-34-56-78-90'

>>> PHONE_FORMAT("tel:+1-234-567-8901", country="US", format="*")
u'+12345678901'

>>> PHONE_FORMAT(33234567890)
Traceback (most recent call last):
...
TypeError: Le numéro de téléphone doit être une valeur textuelle. Si vous formatez une valeur d'une colonne Numérique, convertissez d'abord cette colonne en Texte.

>>> PROPER('ceci est un TITRE')
'Ceci Est Un Titre'

>>> PROPER('2-way street')
'2-Way Street'

>>> PROPER('76BudGet')
'76Budget'

>>> REGEXEXTRACT("Google Doc 101", "[0-9]+")
'101'

>>> REGEXEXTRACT("Le prix aujourd'hui est de $826.25", "[0-9]*\.[0-9]+[0-9]+")
'826.25'

S’il y a une expression entre parenthèses, elle est renvoyée au lieu de la correspondance entière.

>>> REGEXEXTRACT("(Contenu) entre crochets", "\(([A-Za-z]+)\)")
'Content'

>>> REGEXEXTRACT("Foo", "Bar")
Traceback (most recent call last):
...
ValueError: REGEXEXTRACT text does not match

>>> REGEXMATCH("Google Doc 101", "[0-9]+")
True

>>> REGEXMATCH("Google Doc", "[0-9]+")
False

>>> REGEXMATCH("Le prix aujourd'hui est de $826.25", "[0-9]*\.[0-9]+[0-9]+")
True

>>> REGEXMATCH("(Contenu) entre crochets", "\(([A-Za-z]+)\)")
True

>>> REGEXMATCH("Foo", "Bar")
False

>>> REGEXREPLACE("Google Doc 101", "[0-9]+", "777")
'Google Doc 777'

>>> REGEXREPLACE("Google Doc", "[0-9]+", "777")
'Google Doc'

>>> REGEXREPLACE("Le prix est de $826.25", "[0-9]*\.[0-9]+[0-9]+", "315.75")
'Le prix est de $315.75'

>>> REGEXREPLACE("(Contenu) entre crochets", "\(([A-Za-z]+)\)", "Mot")
'Mot entre crochets'

>>> REGEXREPLACE("Foo", "Bar", "Baz")
'Foo'

>>> REPLACE("abcdefghijk", 6, 5, "*")
'abcde*k'

>>> REPLACE("2009", 3, 2, "10")
'2010'

>>> REPLACE('123456', 1, 3, '@')
'@456'

>>> REPLACE('foo', 1, 0, 'bar')
'barfoo'

>>> REPLACE('foo', 0, 1, 'bar')
Traceback (most recent call last):
...
ValueError: position invalid

Le résultat de la fonction REPT ne peut pas dépasser 32767 caractères, sinon cela lève une ValueError.

>>> REPT("*-", 3)
'*-*-*-'

>>> REPT('-', 10)
'----------'

>>> REPT('-', 0)
''

>>> len(REPT('---', 10000))
30000

>>> REPT('---', 11000)
Traceback (most recent call last):
...
ValueError: number_times invalid

>>> REPT('-', -1)
Traceback (most recent call last):
...
ValueError: number_times invalid

>>> RIGHT("Prix de vente", 5)
'Price'

>>> RIGHT('Numéro de stock')
'r'

>>> RIGHT('Texte', 100)
'Texte'

>>> RIGHT('Texte', -1)
Traceback (most recent call last):
...
ValueError: num_chars invalid

La recherche est sensible à la casse. La position renvoyée est 1 si within_text commence par find_text. start_num spécifie le caractère à partir duquel commencer la recherche, par défaut à 1 (le premier caractère de within_text).

Si find_text n’est pas trouvé, ou si start_num est invalide, lève une ValueError.

>>> SEARCH("e", "Déclarations", 6)
7

>>> SEARCH("marge", "Marge bénéficiaire")
8

>>> SEARCH(" ", "Marge bénéficiaire")
7

>>> SEARCH('"', 'Le "patron" est ici.')
5

>>> SEARCH("gle", "Google")
4

>>> SEARCH("GLE", "Google")
4

Si instance_num est donné, il spécifie quelle occurrence de old_text remplacer. Si omis, toutes les occurrences sont remplacées.

Identique à text.replace(old_text, new_text) lorsque instance_num est omis.

>>> SUBSTITUTE("Données de vente", "Ventes", "Coût")
u'Données de coût'

>>> SUBSTITUTE("Trimestre 1, 2008", "1", "2", 1)
u'Trimestre 2, 2008'

>>> SUBSTITUTE("Trimestre 1, 2011", "1", "2", 3)
u'Trimestre 1, 2012'

>>> T('Texte')
u'Texte'

>>> T(826)
u''

>>> T('826')
u'826'

>>> T(False)
u''

>>> T('100 points')
u'100 points'

>>> T(AltText('Texte'))
u'Texte'

>>> T(float('nan'))
u''

Ce n’est pas sérieux. Cela est apparu comme un œuf de Pâques, et est conservé en tant que tel. C’est en fait un puzzle pour comprendre la règle simple sous-jacente. Cela a été étonnamment rarement résolu, même après avoir lu le code source, qui est librement disponible et peut divertir les fans de Python.

>>> TASTEME('Banane')
True

>>> TASTEME('Ail')
False

Note Cette fonction n’est pas actuellement implémentée dans Grist.

>>> TRIM(" Premier trimestre\n    Bénéfices     ")
'Premier trimestre\n Bénéfices'

>>> TRIM("")
''

>>> UPPER("e. e. cummings")
'E. E. CUMMINGS'

>>> UPPER("Apt. 2B")
'APT. 2B'

>>> VALUE("$1,000")
1000

>>> assert VALUE("16:48:00") - VALUE("12:00:00") == datetime.timedelta(0, 17280)

>>> VALUE("01/01/2012")
datetime.datetime(2012, 1, 1, 0, 0)

>>> VALUE("")
0

>>> VALUE(0)
0

>>> VALUE("826")
826

>>> VALUE("-826.123123123")
-826.123123123

>>> VALUE(float('nan'))
nan

>>> VALUE("Invalid")
Traceback (most recent call last):
...
ValueError: le texte ne peut pas être analysé en un nombre

>>> VALUE("13/13/13")
Traceback (most recent call last):
...
ValueError: le texte ne peut pas être analysé en un nombre