Exemples Python d’utilisation de l’outil Calculer un champ

La saisie de valeurs avec le clavier n’est pas la seule façon de mettre à jour les valeurs d’une table. Vous pouvez effectuer un calcul mathématique pour définir une valeur de champ pour un seul enregistrement ou pour tous les enregistrements. Vous pouvez effectuer des calculs simples ainsi que des calculs avancés sur tous les enregistrements ou sur une sélection d'enregistrements. De plus, vous pouvez calculer la surface, la longueur, le périmètre et d'autres propriétés géométriques des champs de tables attributaires. Les sections suivantes comprennent des exemples d'utilisation du calculateur de champs. Les calculs sont effectués à l’aide de Python, SQL et Arcade.

Cette rubrique présente les exemples de l’outil Python Calculer un champ. Pour en savoir plus sur les expressions Arcade, reportez-vous au guide ArcGIS Arcade. Pour en savoir plus sur les expressions SQL, reportez-vous à la rubrique Calculer des valeurs de champ. Pour en savoir plus sur les exemples VBScript, reportez-vous à la rubrique Exemples VBScript d’utilisation de l’outil Calculer un champ.

Remarque :

• Python applique une indentation du code dans le cadre de la syntaxe. Utilisez deux ou quatre espaces pour définir chaque niveau logique. Alignez le début et la fin des blocs d'instruction en restant cohérent.
• Les champs d’expression de calcul Python sont délimités par des points d’exclamation (!!).
• Lorsque vous nommez des variables, notez que Python respecte la casse. Ainsi, value n’est pas équivalent à Value.
• Après la saisie des instructions, cliquez sur le bouton Export (Exporter) si vous souhaitez les écrire dans un fichier. Le bouton Import (Importer) vous invite à rechercher et sélectionner un fichier de calcul existant.

Calculs simples

Les expressions courtes permettent d’effectuer divers calculs.

Exemples de chaînes simples

Les chaînes sont prises en charge par une série de fonctions de chaîne Python, notamment capitalize, rstrip et replace.

Mettez en majuscule la première lettre de la chaîne dans le champ CITY_NAME.

!CITY_NAME!.capitalize()

Supprimez tout espace en fin de chaîne dans le champ CITY_NAME.

!CITY_NAME!.rstrip()

Remplacez toutes les occurrences de « california » par « California » dans le champ STATE_NAME.

!STATE_NAME!.replace("california", "California")

Les caractères dans un champ de type chaîne sont accessibles par indexation et découpage dans Python. L'indexation extrait des caractères à une position d'index ; le découpage extrait un groupe de caractères. Dans la table suivante, supposez que !fieldname! est un champ de chaîne avec une valeur « "abcde" ».

Exemple	Explication	Résultat
!fieldname![0]	Premier caractère	"a"
!fieldname![-2]	Avant-dernier caractère	« d »
!fieldname![1:4]	Deuxième, troisième et quatrième caractères	"bcd"

Python prend également en charge la mise en forme de chaîne à l’aide de la méthode format().

Combiner FieldA et FieldB, séparés par le signe deux points.

"{}:{}".format(!FieldA!, !FieldB!)

• Opérations courantes sur les chaînes Python.

Exemples de mathématiques simples

Python fournit des outils pour le traitement des nombres. Python Python prend également en charge plusieurs fonctions numériques et mathématiques, notamment math, cmath, decimal, random, itertools, functools et operator.

Opérateur	Explication	Exemple	Résultat
x + y	x plus y	1.5 + 2.5	4.0
x - y	x moins y	3.3 - 2.2	1.1
x * y	x fois y	2.0 * 2.2	4.4
x / y	x divisé par y	4.0 / 1.25	3.2
x // y	x divisé par y (division du sol)	4.0 // 1.25	3.0
x % y	x modulo y	8 % 3	2
-x	expression négative de x	x = 5 -x	-5
+x	x est inchangé	x = 5 +x	5
x ** y	x puissance y	2 ** 3	8

Multipliez les valeurs d’un champ par 2.

!Rank! * 2

Calculer le volume d'une sphère à partir du champ de rayon.

4.0 / 3.0 * math.pi * !Radius! ** 3

Remarque :

Les champs d’entier court, long et très grand diffèrent dans les plages suivantes de nombres entiers qu’ils acceptent :

• Champs courts (entier 16 bits) : acceptent les nombres entiers de -(2¹⁵) et 2¹⁵ (-32 768 et 32 767)
• Champs longs (entier 32 bits) : acceptent les nombres entiers de -(2³¹) et 2³¹ (-2 147 483 648 et 2 147 483 647)
• Très grands champs (entier 64 bits) : acceptent les nombres entiers de -2(⁵³) et 2⁵³ (9 007 199 254 740 992 et 9 007 199 254 740 991)

Héritage :

ArcGIS Pro utilise Python 3 et ArcGIS Desktop utilise Python 2. Python 2 utilise l’outil mathématique des entiers, ce qui signifie que la division de deux valeurs entières génère toujours une valeur entière (3 / 2 = 1). Dans Python 3, la division de deux valeurs entières génère une valeur à virgule flottante (3 / 2 = 1.5).

Fonctions intrinsèques Python

Python comprend plusieurs fonctions intrinsèques, notamment max, min, round et sum.

• Fonctions intrinsèques Python

Calculez la valeur maximale pour chaque enregistrement dans une liste de champs.

Expression:
max([!field1!, !field2!, !field3!])

Calculez la somme pour chaque enregistrement dans une liste de champs.

Expression:
sum([!field1!, !field2!, !field3!])

Utiliser des blocs de code

Avec des expressions Python et le paramètre Bloc de code, vous pouvez :

• utiliser n’importe quelle fonction Python dans l’expression,
• Accéder aux fonctions et aux objets de géotraitement.
• accéder aux propriétés de géométrie d'entité,
• accéder au nouvel opérateur de valeur aléatoire,
• reclasser des valeurs à l'aide d'une logique if-then-else,

Type d’expression	Bloc de code
Python (mot-clé PYTHON3)	Prend en charge les fonctionnalités Python. Le bloc de code est exprimé à l’aide de fonctions Python (def). Les propriétés de géométrie sont exprimées à l’aide d’objets de géotraitement tels que les objets Point, le cas échéant.
Arcade	Prend en charge les fonctionnalités Arcade.
SQL	Prend en charge les expressions SQL. Les expressions SQL ont été implémentées afin de mieux prendre en charge les calculs à l’aide des services d’entités et géodatabases d’entreprise, en particulier en ce qui concerne les performances. Au lieu d’effectuer les calculs entité par entité ou ligne par ligne, une requête unique est définie pour le service d’entités ou la base de données.

Héritage :

Dans ArcGIS Desktop, l’outil Calculer un champ prend en charge les types d’expression VB, PYTHON et PYTHON_9.3. Le type d’expression VB, qui est pris en charge dans certains produits, n’est pas pris en charge dans les produits 64 bits, notamment dans ArcGIS Pro.

Les mots-clés PYTHON et PYTHON_9.3 sont toujours pris en charge dans ArcGIS Pro selon le principe de compatibilité ascendante, mais ne font pas partie de la liste des choix. Les scripts Python utilisant ces mots-clés continueront de fonctionner.

La seule différence entre le type d’expression PYTHON3 et le mot-clé hérité de PYTHON_9.3 est que PYTHON3 renvoie les valeurs dans des champs de date sous forme d’objets Python datetime.

Remarque :

Le type d’expression PYTHON3 n’est pas lié à la version de Python installée avec ArcGIS Pro. Il s’agit du troisième mot-clé Python historiquement (après PYTHON et PYTHON_9.3, désormais masqués).

Les fonctions Python sont définies à l’aide du mot-clé def suivi du nom de la fonction et des arguments en entrée de la fonction. Une fonction Python peut être écrite pour accepter tout nombre d’arguments en entrée (y compris aucun). Une valeur est renvoyée de la fonction à l’aide de l’instruction return. Vous choisissez le nom de la fonction (il ne doit toutefois pas contenir d'espace ni commencer par un chiffre).

Remarque :

Si aucune valeur n’est explicitement renvoyée à partir d’une fonction à l’aide d’une instruction return, la fonction renvoie None.

Remarque :

Python applique une indentation du code dans le cadre de la syntaxe. Utilisez quatre espaces pour définir chaque niveau logique. Alignez le début et la fin des blocs d'instruction en restant cohérent.

Exemples de code : math

Des expressions mathématiques simples peuvent être ajoutées à l’aide du paramètre Expression et des exemples plus complexes peuvent être créés à l’aide des paramètres Expression et Code Block (Bloc de code).

Arrondi d'une valeur de champ à deux décimales.

Expression:
round(!area!, 2)

Utilisation du module math pour convertir des mètres en pieds. La conversion est élevée à la puissance 2 et multipliée par la surface.

Expression:
MetersToFeet((float(!shape.area!)))

Code Block:
import math
def MetersToFeet(area):
    return math.pow(3.2808, 2) * area

Calcul des valeurs de champs à l’aide de logique avec Python

Les modèles logiques peuvent être inclus dans un bloc de code à l’aide des instructions if, else et elif.

Classification selon des valeurs de champ.

Expression:
Reclass(!WELL_YIELD!)

Code Block:
def Reclass(WellYield):
    if (WellYield >= 0 and WellYield <= 10):
        return 1
    elif (WellYield > 10 and WellYield <= 20):
        return 2
    elif (WellYield > 20 and WellYield <= 30):
        return 3
    elif (WellYield > 30):
        return 4

Exemples de code-géométrie

Outre les exemples de code suivants, reportez-vous à la section Conversions d’unités de géométrie ci-dessous pour plus d’informations sur la conversion des unités de géométrie.

Calcul de la surface d'une entité.

Expression:
!shape.area!

Calcul de l'abscisse maximale d'une entité.

Expression:
!shape.extent.XMax!

Calcul du nombre de sommets d'une entité.

Expression:
getVertexCount(!shape!)

Code Block:
def getVertexCount(feat):    
    partnum = 0

    # Count the number of points in the current multipart feature
    partcount = feat.partCount
    pntcount = 0

    # Enter while loop for each part in the feature (if a singlepart 
    # feature, this will occur only once)
    while partnum < partcount:
        part = feat.getPart(partnum)
        pnt = part.next()

        # Enter while loop for each vertex
        while pnt:
            pntcount += 1   
            pnt = part.next()
   
            # If pnt is null, either the part is finished or there 
            # is an interior ring
            if not pnt: 
                pnt = part.next()
        partnum += 1
    return pntcount

Pour une classe d'entités points, déplacer la coordonnée x de chaque point de 100.

Expression:
shiftXCoordinate(!SHAPE!)

Code Block:
def shiftXCoordinate(shape):
    shiftValue = 100
    point = shape.getPart(0)
    point.X += shiftValue
    return point

Conversions d'unités de géométrie

Les propriétés de surface et de longueur du champ de géométrie peuvent être modifiées avec des types d’unité en utilisant les méthodes de géométrie getArea et getLength.

En savoir plus sur les unités linéaires et de surface prises en charge dans le géotraitement

Reportez-vous aux objets Polygon et Polyline pour plus d’informations.

Attention :

La conversion des unités de surface pour des données dans un système de coordonnées géographiques produit des résultats douteux, puisque les degrés décimaux ne sont pas cohérents sur l’ensemble du globe.

Calcul de la longueur d'une entité en yards.

Expression:
!shape@getLength('PLANAR', 'YARDS')

Calcul de la surface d'une entité en acres.

Expression:
!shape@getArea('PLANAR', 'ACRES')

La surface et la longueur géodésiques peuvent également être calculées à l’aide de la méthode de type GEODESIC.

Pour plus d’informations, reportez-vous aux objets Polygon et .Polyline

En savoir plus sur les outils de géotraitement et les unités linéaires et surfaciques

Calcul de la longueur géodésique d'une entité en yards.

Expression:
!shape@getLength('GEODESIC', 'YARDS')

Calcul de la surface géodésique d'une entité en acres.

Expression:
!shape@getArea('GEODESIC', 'ACRES')

Exemples de code : champs de date

La date et l’heure peuvent être calculées à l’aide des modules datetime et time.

Calcul de la date courante.

Expression:
time.strftime("%d/%m/%Y")

Calcul de la date et de l'heure courantes.

Expression:
datetime.now()

Calcul d’une date pour qu’elle soit égale au 15 mars 2015, 13h30.

Expression:
datetime(year=2015, month=3, day=15, hour=13, minute=30, second=0))

Calcule le nombre de jours compris entre la date actuelle et la valeur d'un champ.

Expression:
datetime.now().day - !OID!

Calcule une date en ajoutant 100 jours à la valeur de date d'un champ.

Expression:
!field1! + timedelta(days=100)

Code Block:
from datetime import timedelta

Calcul d’une chaîne représentant la date à l’aide de la méthode ctime du module datetime. L’exemple crée une chaîne au format : 'Mon Feb 22 10:15:00 2021'.

Expression:
!field1!.ctime()

Calcule le jour de la semaine (par exemple, dimanche) pour une valeur de date d'un champ.

Expression:
!field1!.strftime('%A')

Calcul d’une chaîne formatée à partir d’un champ de date à l’aide de la méthode strftime du module datetime et une chaîne de format explicite. L’exemple crée une chaîne au format : '02/22/2021, 10:15:00'.

Expression:
!field1!.strftime("%m/%d/%Y, %H:%M:%S")

Calcul d’une date en utilisant une chaîne formatée ISO 8601.

Expression:
'1969-07-21 02:56:00'

Calcul d’une date en appliquant les conventions de mois, jour, année et heure.

Expression:
'July 1 2020 12:30:45'

Exemples de code : champs d’heure uniquement

Calcul de l’heure pour qu’elle soit égale à 16h30 en utilisant la fonction time du module datetime.

Expression:
time(hour=16, minute=30, second=0)

Code Block:
from datetime import time

Si un champ de date est calculé en champ d’heure uniquement, seule la portion d’heure de l’objet datetime est appliquée.

Expression:
!date_field!

Exemples de code : champs de date uniquement

Calcul de la date comme étant le 31 décembre 2000.

Expression:
datetime(2000, 12, 31)

Si un champ de date est calculé en champ d’heure uniquement, seule la portion d’heure de l’objet datetime est appliquée.

Expression:
!date_field!

Exemples de code : décalage de l’horodatage

Ajout d’un décalage de l’horodatage UTC à la date et à l’heure du jour en utilisant la propriété utc du module datetime.timezone.

Expression:
datetime.now(tz=timezone.utc)

Code Block:
from datetime import timezone

Ajout d’un décalage de l’horodatage à la date et à l’heure du jour en utilisant la classe ZoneInfo du module .zoneinfo pour définir le fuseau horaire.

Expression:
datetime.now(ZoneInfo('America/New_York'))

Code Block:
from zoneinfo import ZoneInfo

Exemples de code-chaînes

Le calcul des chaînes peut être effectué à l’aide de divers modèles de code Python.

Extraction des trois caractères les plus à droite.

Expression:
!SUB_REGION![-3:]

Remplacement de tous les P majuscules par des p minuscules.

Expression:
!STATE_NAME!.replace("P","p")

Concaténation de deux champs avec une espace comme séparateur.

Expression:
!SUB_REGION! + " " + !STATE_ABBR!

Conversion à la casse appropriée

Les exemples suivants illustrent les différentes manières de convertir des mots afin que la première lettre de chaque mot soit une majuscule et le reste des lettres en minuscules.

Expression:
' '.join([i.capitalize() for i in !STATE_NAME!.split(' ')])

Expression:
!STATE_NAME!.title()

Expressions régulières

Le module re de Python permet d’exécuter des opérations d’appariement d’expressions régulières que vous pouvez utiliser pour exécuter des règles complexes d’appariement et de remplacement de modèles pour des chaînes.

• re — opérations d'expressions régulières
• Procédure des expressions régulières

Remplacez St ou St. au début d'un nouveau mot à la fin de la chaîne par le mot Street.

Expression:
update_street(!ADDRESS!)

Code Block:
import re
def update_street(street_name):
    return re.sub(r"""\b(St|St.)\Z""",  
                  'Street',
                  street_name)

Calculs accumulatifs et séquentiels

Les calculs accumulatifs et séquentiels peuvent se faire à l’aide de variables globales.

Calcul d'un ID ou d'un nombre séquentiel selon un intervalle.

Expression:
autoIncrement(10, 5)

Code Block:
rec = 0
def autoIncrement(start=1, interval=1):
    global rec
    if rec == 0:
        rec = start
    else:
        rec += interval
    return rec

Calcul de la valeur accumulative d'un champ numérique.

Expression:
accumulate(!FieldA!)

Code Block:
total = 0
def accumulate(increment):
    global total
    if total:
        total += increment
    else:
        total = increment
    return total

Calcul du pourcentage d'augmentation d'un champ numérique.

Expression:
percentIncrease(float(!FieldA!))

Code Block:
lastValue = 0
def percentIncrease(newValue):
    global lastValue
    if lastValue:
        percentage = ((newValue - lastValue) / lastValue)  * 100
    else: 
        percentage = 0
    lastValue = newValue
    return percentage

Valeurs aléatoires

Il est possible de calculer des valeurs aléatoires à l’aide du module random.

Utilisez le site-package numpy pour calculer des valeurs flottantes aléatoires entre 0,0 et 1,0.

Expression:
getRandomValue()

Code Block:
import numpy

def getRandomValue():
    return numpy.random.random()

Utilisez le module random pour calculer des entiers aléatoires entre 0 et 10.

Expression:
random.randint(0, 10)

Code Block:
import random

Calcul de valeurs nulles

Dans une expression Python, les valeurs nulles peuvent être calculées avec une valeur Python None.

Remarque :

Le calcul suivant ne fonctionne que si le champ accepte les valeurs Null.

Utilisez une valeur Python None pour calculer des valeurs nulles.

Expression:
None