Exemples d’utilisation de l’outil Python Calculate Field (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. Dans certains cas, vous pouvez effectuer un calcul mathématique permettant de définir la valeur d’un champ pour un seul enregistrement ou 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 Calculate Field (Calculer un champ). Pour en savoir plus sur les expressions Arcade, reportez-vous au guide ArcGIS Arcade. Pour plus d’informations sur les expressions SQL, reportez-vous à la rubrique Calcul d’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, n’oubliez pas que Python respecte la casse. Ainsi, valeur n’est pas équivalent à Valeur.
• 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 Python courantes sur les chaînes

Exemples de mathématiques simples

Python fournit des outils pour le traitement des nombres. 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

Multiplication

!Rank! * 2

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

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

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 comporte plusieurs fonctions intrinsèques qui peuvent être utilisées, notamment max, min, round et sum.

• Fonctions intrinsèques Python

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

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

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

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

Utilisation de blocs de code

Avec des expressions Python et le paramètre Code Block (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 3	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. Les calculs ne sont pas appliqués à une entité ou rangée à la fois, mais une requête unique est envoyée au 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 (rétrocompatibilité) mais ils ne sont plus proposés parmi les choix. Les scripts Python qui utilisent ces mots-clés fonctionnent toujours.

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

Remarque :

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

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 :

Gardez à l’esprit que 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

Lorsque vous utilisez les échantillons math ci-dessous, ayez recours au type d’expression de Python 3.

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!)))
Bloc de code :
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!)
Bloc de code :
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 :
MySub(!shape!)
Bloc de code :
def MySub(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!)
Bloc de code :
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é exprimés avec un signe @.

• Mots-clés d'unité de mesure surfacique :
  • ACRES | ARES | HECTARES | SQUARECENTIMETERS | SQUAREDECIMETERS | SQUAREINCHES | SQUAREFEET | SQUAREKILOMETERS | SQUAREMETERS | SQUAREMILES | SQUAREMILLIMETERS | SQUAREYARDS | SQUAREMAPUNITS | UNKNOWN
• Mots-clés d'unité de mesure linéaire :
  • CENTIMETERS | DECIMALDEGREES | DECIMETERS | FEET | INCHES | KILOMETERS | METERS | MILES | MILLIMETERS | NAUTICALMILES | POINTS | UNKNOWN | YARDS

Remarque :

Si les données sont stockées dans un système de coordonnées géographiques et qu’une unité linéaire (par exemple, pieds) est fournie, le calcul de longueur est converti à l’aide d’un algorithme géodésique.

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.length@yards!

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

Expression :
!shape.area@acres!

La surface et la longueur géodésiques peuvent également être calculées à l'aide des propriétés geodesicArea and geodesicLength avec @ suivi d'un mot-clé d'unité de mesure.

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

Expression :
!shape.geodesicLength@yards!

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

Expression :
!shape.geodesicArea@acres!

Exemples de code-dates

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.datetime.now()

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

Expression :
datetime.datetime(2000, 12, 31)

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

Expression :
(datetime.datetime.now() - !field1!).days

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

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

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

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

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!)
Bloc de code :
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()
Bloc de code :
rec=0
def autoIncrement():
    global rec
    pStart = 1  # adjust start value, if req'd 
    pInterval = 1  # adjust interval value, if req'd
    if (rec == 0): 
        rec = pStart 
    else: 
        rec = rec + pInterval 
    return rec

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

Expression :
accumulate(!FieldA!)
Bloc de code :
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!))
Bloc de code :
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()
Bloc de code :
import numpy
def getRandomValue():
    return numpy.random.random()

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

Expression :
random.randint(0, 10)
Bloc de code :
import random

Calcul de valeurs Null

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

Remarque :

Le calcul suivant fonctionnera seulement si le champ accepte les valeurs Null.

Utilisez une valeur Python None pour calculer des valeurs Null.

Expression :
None