ArcGIS Desktop

  • ArcGIS Pro
  • ArcMap

  • My Profile
  • Aide
  • Sign Out
ArcGIS Desktop

ArcGIS Online

La plateforme cartographique de votre organisation

ArcGIS Desktop

Un SIG professionnel complet

ArcGIS Enterprise

SIG dans votre entreprise

ArcGIS Developers

Outils de création d'applications de localisation

ArcGIS Solutions

Modèles d'applications et de cartes gratuits pour votre secteur d'activité

ArcGIS Marketplace

Téléchargez des applications et des données pour votre organisation.

  • Documentation
  • Support
Esri
  • Se connecter
user
  • Mon profil
  • Déconnexion

ArcMap

  • Accueil
  • Commencer
  • Carte
  • Analyser
  • Gérer les données
  • Outils
  • Extensions

Définition de paramètres dans une boîte à outils Python

  • Utilisation de sorties dérivées
  • Création de paramètres à valeurs multiples
  • Création des paramètres de la table des valeurs
  • Définition des valeurs par défaut d'un paramètre
  • Définition de l'objet Schema d'un paramètre
  • Application de filtres à un paramètre
  • parameterDependencies
  • symbology
  • category

Presque tous les outils possèdent des paramètres. Vous pouvez définir leurs valeurs dans la boîte de dialogue de l'outil ou à partir d'un script. Lorsque l'outil est exécuté, les valeurs du paramètre sont envoyées au code source de l'outil. Votre outil lit ces valeurs et poursuit son travail.

Pour en savoir plus sur les paramètres, consultez la rubrique Présentation des paramètres des outils de script.

Dans une boîte à outils Python (.pyt), vous définissez les paramètres d'outils dans la méthode getParameterInfo d'une classe d'outils en créant des objets Parameter et en définissant leurs propriétés.

Les objets Parameter ont de nombreuses propriétés en lecture-écriture, mais celles qui doivent être définies pour chaque paramètre incluent les suivantes :

PropriétéDescription

displayName

Nom du paramètre tel qu'il apparaît dans la boîte de dialogue de l'outil.

name

Nom du paramètre tel qu'il apparaît dans la syntaxe de l'outil dans Python.

datatype

Tous les paramètres de la boîte d'outils Python sont associés à un type de données. Lorsque la boîte de dialogue de l'outil de script s'ouvre, le géotraitement utilise le type de données pour vérifier la valeur du paramètre.

Le type de données sert également à rechercher des données : seules les données correspondant au type de données du paramètre sont affichées dans la boîte de dialogue Parcourir.

Pour obtenir une liste de types de données de paramètre, consultez la rubrique Définition de types de données de paramètre dans une boîte à outils Python.

parameterType

Trois options sont disponibles pour parameterType :

  • Requis : l'outil ne peut pas être exécuté tant qu'une valeur n'a pas été fournie.
  • Facultatif : le paramètre ne requiert aucune valeur.
  • Dérivé : le paramètre est uniquement destiné aux paramètres en sortie (voir « direction » ci-dessous). Un paramètre en sortie dérivé ne s'affiche pas dans la boîte de dialogue de l'outil.

direction

Cette propriété détermine si le paramètre est une entrée ou une sortie de l'outil.

Si parameterType est défini sur Dérivé, la propriété direction du paramètre doit être définie sur Sortie.

Dans l'exemple suivant, trois paramètres sont définis pour un outil : un paramètre en entrée qui accepte une couche d'entités, un paramètre en entrée qui accepte un nouveau nom de champ et un paramètre en sortie dérivé basé sur le premier paramètre en entrée. Pour que les paramètres soient pris en compte dans l'outil, vous devez les renvoyer à la fin de la méthode getParameterInfo.

def getParameterInfo(self):
    #Define parameter definitions
    # First parameter
    param0 = arcpy.Parameter(
        displayName="Input Features",
        name="in_features",
        datatype="GPFeatureLayer",
        parameterType="Required",
        direction="Input")
    # Second parameter
    param1 = arcpy.Parameter(
        displayName="Sinuosity Field",
        name="sinuosity_field",
        datatype="Field",
        parameterType="Optional",
        direction="Input")
    param1.value = "sinuosity"
    # Third parameter
    param2 = arcpy.Parameter(
        displayName="Output Features",
        name="out_features",
        datatype="GPFeatureLayer",
        parameterType="Derived",
        direction="Output")
    param2.parameterDependencies = [param0.name]
    param2.schema.clone = True
    params = [param0, param1, param2]
    return params

Utilisation de sorties dérivées

Le dernier paramètre affiché ci-dessus est un paramètre en sortie dérivé. Il existe cinq cas d'utilisation pour un paramètre en sortie dérivé :

  • La sortie est la même que l'entrée, comme pour Calculer un champ ou l'exemple ci-dessus. L'outil Calculer un champ modifie les valeurs d'un champ particulier dans la table en entrée, il ne crée pas une nouvelle table ni ne modifie la structure de l'entrée. D'autres outils dont la sortie est la même que l'entrée sont disponibles dans la boîte à outils Editing.
  • L'outil modifie la structure de l'entrée, comme pour Ajouter un champ. L'outil Ajouter un champ ajoute un champ à la table en entrée, il ne crée pas de nouvelle table en sortie.
  • L'outil crée une sortie à l'aide des informations contenues dans d'autres paramètres, tels que l'outil Créer une classe d'entités. L'outil Créer une classe d'entités permet de spécifier l'espace de travail et le nom de la nouvelle classe d'entités. La classe d'entités est alors créée.
  • L'outil génère une valeur scalaire contrairement à un jeu de données. L'outil Compter, par exemple, génère une variable de type Long (le nombre d'enregistrements). Lorsque l'outil génère une valeur scalaire, la sortie est Derived.
  • L'outil créera les données dans un emplacement connu. Par exemple, vous pouvez avoir un script qui met à jour une table existante dans un espace de travail connu. L'utilisateur n'a pas besoin de fournir cette table dans la boîte de dialogue ou dans des scripts.

Création de paramètres à valeurs multiples

Si votre paramètre doit pouvoir gérer une liste de valeurs plutôt qu'une seule, attribuez la valeur multiValue à la propriété True.

Dans les boîtes de dialogue d'outil, deux différents contrôles d'interface utilisateur sont utilisés pour les valeurs multiples, comme illustré ci-dessous.

  • Une liste de cases à cocher est utilisée pour les champs et les chaînes, longs et doubles s'ils contiennent un ValueListfiltre.
  • Tous les autres types de données affichent le contrôle de paramètre à valeurs multiples.

Les deux types de contrôles à valeurs multiples sont illustrés ci-dessous.

Contrôles à valeurs multiples

D'après l'illustration précédente, si l'utilisateur a sélectionné tous les types de routes, la valeur du paramètre serait définie comme suit : ["Interstates", "Primary roads", "Secondary roads"].

def getParameterInfo(self):
    param0 = arcpy.Parameter(
        displayName="Input Features",
        name="in_features",
        datatype="GPFeatureLayer",
        parameterType="Required",
        direction="Input",
        multiValue=True)

Création des paramètres de la table des valeurs

Certains paramètres, appelés Tables des valeurs, vous permettent de spécifier plusieurs entrées. Par exemple, vous pouvez inclure plusieurs jeux de données pour le paramètre Entités en entrée dans les outils Ajouter, Agréger et un certain nombre d'autres outils, ou inclure plusieurs champs pour le paramètre Champ(s) statistique(s) dans les outils Fusionner et Résumés statistiques.

Illustration du contrôle de paramètre à valeurs multiples

Pour spécifier les paramètres de la table des valeurs, vous devez définir datatype sur GPValueTable et définir une propriété columns pour spécifier les types de données et les en-têtes de colonne du paramètre. Dans l'exemple suivant, un paramètre de la table de valeurs est défini avec deux colonnes qui acceptent les noms de champ et les valeurs de chaîne pour Type de statistique (GPString). A l'aide d'un ValueListfiltre et d'une liste de valeurs, une liste déroulante peut être générée sous la colonne GPValueTable correspondante. Pour définir les valeurs par défaut pour un paramètre de la table de valeurs, utilisez la propriété values et spécifiez les valeurs de paramètre dans une liste de valeurs.

def getParameterInfo(self):
    param0 = arcpy.Parameter(
        displayName ='Input Features',
        name ='in_features',
        datatype ="GPFeatureLayer",
        parameterType ='Required',
        direction ='Input')
    param1 = arcpy.Parameter(
        displayName='Statistics Field(s)',
        name='stat_fields',
        datatype='GPValueTable',
        parameterType='Required',
        direction='Input')
    param1.parameterDependencies = [param0.name]
    param1.columns = [['Field', 'Field'], ['GPString', 'Statistic Type']]
    param1.filters[1].type = 'ValueList'
    param1.values = [['NAME', 'SUM']]
    param1.filters[1].list = ['SUM', 'MIN', 'MAX', 'STDEV', 'MEAN']

Définition des valeurs par défaut d'un paramètre

Vous pouvez définir les valeurs par défaut d'un paramètre en appliquant une valeur directement avec la propriété value ou en appliquant la valeur d'un paramètre d'environnement à l'aide de defaultEnvironmentName.

La valeur par défaut est le contenu du paramètre lors de l'ouverture de la boîte de dialogue de l'outil de script. C'est également la valeur qui est utilisée si un # est entré pour le paramètre dans les scripts. Si vous ne spécifiez pas la propriété value, la valeur du paramètre reste vide lorsque la boîte de dialogue du script est ouverte.

Définition d'une valeur par défaut à partir d'un environnement

Vous pouvez définir la valeur par défaut d'un paramètre sur la valeur d'un paramètre d'environnement en attribuant la propriété defaultEnvironmentName au nom d'un paramètre d'environnement. Lorsque vous sélectionnez un paramètre d'environnement, la propriété value est ignorée.

def getParameterInfo(self):
    param0 = arcpy.Parameter(
        displayName="Input Workspace",
        name="in_workspace",
        datatype="DEWorkspace",
        parameterType="Required",
        direction="Input")
    # In the tool's dialog box, the first parameter will show 
    #  the workspace environment's value (if set)
    param0.defaultEnvironmentName = "workspace"

Définition de l'objet Schema d'un paramètre

Chaque paramètre de type classe d'entités, table, raster ou espace de travail en sortie dispose d'un objet Schema. Seules les classes d'entités, tables, raster et espaces de travail en sortie disposent d'un objet Schema, tous les autres types n'en ont pas. L'objet Schema est créé par géotraitement. Vous pouvez accéder à cet objet Schema via l'objet Parameter et définir les règles de description de la sortie de votre outil. Une fois les règles de l'objet Schema définies, le code de validation interne du géotraitement examine les règles que vous avez définies et actualise la description de la sortie.

Pour en savoir plus sur l’utilisation des objets Schema, reportez-vous à Mise à jour de la structure dans une boîte à outils Python.

Lorsque le type de données du paramètre en entrée est un Jeu d'entités ou un Jeu d'enregistrements, vous devez spécifier les valeurs fieldsRule et geometryType des entités à entrer.

A propos des jeux d'entités et d'enregistrements

Les types de données Jeu d'entités et d'enregistrements permettent la saisie interactive de données. Un Jeu d'entités permet à l'utilisateur de votre script de créer de façon interactive des entités dans ArcMap en cliquant sur la carte. Le Jeu d'enregistrements permet à votre utilisateur de créer de façon interactive des lignes dans une grille de table simple.

Jeux d'entités et d'enregistrements

La symbologie et la structure (attributs et type de géométrie) peuvent être définies pour le contrôle de jeu d'entités et de jeu d'enregistrements en définissant la propriété value du paramètre sur une classe d'entités, une table ou un fichier de couche (.lyr).

def getParameterInfo(self):
    param0 = arcpy.Parameter(
        displayName="Input Feature Set",
        name="in_feature_set",
        datatype="GPFeatureRecordSetLayer",
        parameterType="Required",
        direction="Input")
    # Use __file__ attribute to find the .lyr file (assuming the
    #  .pyt and .lyr files exist in the same folder)
    param0.value = os.path.join(os.path.dirname(__file__),
                                "Fire_Station.lyr")

Pour en savoir plus sur les Jeux d'entités et d'enregistrements, cliquez sur les liens ci-dessous.

RubriqueDescription

Objets FeatureSet et RecordSet

Cette rubrique décrit la manière d'utiliser les objets FeatureSet et RecordSet dans Python.

Utilisation des contrôles d'entrée d'entités et d'enregistrements interactifs

Cette rubrique décrit la manière d'utiliser des contrôles de jeu d'entités et d'enregistrements.

Rubriques sur les jeux d'entités et d'enregistrements

Application de filtres à un paramètre

L'application d'un filtre à un paramètre vous permet de restreindre les choix possibles pour l'utilisateur de ce même paramètre. Par exemple, vous pouvez définir un filtre de champ qui limite les choix uniquement aux champs de texte.

Le géotraitement crée automatiquement des filtres pour les paramètres de type chaîne, long, double, classe d'entités, fichier, champ et espace de travail. Même si vous ne définissez pas de filtre pour le paramètre, il y a tout de même un filtre associé au paramètre, mais il est vide. Un filtre vide équivaut à n'avoir aucun filtre. En ajoutant des valeurs à un filtre vide, vous activez le filtre et les choix de l'utilisateur sont limités par le contenu du filtre :

  • Un filtre présente uniquement à l’utilisateur les choix valides lors de la recherche de données. Si vous définissez votre filtre pour les classes d’entités ponctuelles, seules les classes d’entités ponctuelles sont montrées à l’utilisateur lors de la recherche de données. Si vous définissez votre filtre pour les champs de texte, la liste déroulante des champs affiche uniquement les champs de texte.
  • Si un utilisateur saisit une valeur de paramètre (plutôt que de sélectionner une valeur dans la liste ou l’explorateur de fichiers), la valeur est comparée au filtre. Si l'utilisateur saisit une valeur incorrecte (un champ numérique au lieu d'un champ de texte, par exemple), un avertissement ou une erreur est automatiquement générée.

Si vous voulez que seuls certains types de jeux de données ou valeurs soient entrés pour un paramètre, vous pouvez spécifier un filtre. Définissez filtertype sur la valeur appropriée. Il y a six types de filtres. Le type de filtre que vous pouvez sélectionner dépend du type de données du paramètre.

Type de filtreValeurs

Liste de valeurs

Liste de valeurs de type chaîne ou numériques. Utilisé avec des types de données de paramètre String, Long, Double et Boolean.

Plage

Valeurs minimale et maximale. Utilisé avec les types de données Long et Double.

Classe d'entités

Liste des types de classe d'entités autorisés : Point, Multi-points, Polyligne, Polygone, MultiPatch, Sphère, Annotation et Dimension. Plusieurs valeurs peuvent être appliquées au filtre.

Fichier

Une liste de suffixes de fichier, par exemple, ['zip', 'xml'].

Terrain

Liste de types de champs autorisés : Court, Long, Réel simple, Réel double, Texte, Date, OID, Géométrie, Blob, Raster, GUID, GlobalID et XML. Plusieurs valeurs peuvent être appliquées au filtre.

Espace de travail

Liste des types d'espace de travail autorisés : Système de fichiers, Base de données locale ou Base de données distante. Plusieurs valeurs peuvent être appliquées.

Type de filtre et valeurs

PropriétéDescription

type

Type de filtre (ValueList, Range, FeatureClass, File, Field et Workspace). Vous pouvez définir le type de filtre lorsque vous utilisez des paramètres Long et Double (consultez la remarque ci-dessous). Pour les autres types de paramètres, il existe un seul type de filtre valide, la définition du type pour ces paramètres est donc ignorée. Si vous ne voulez pas filtrer les valeurs, définissez la propriété list sur une liste vide.

list

Liste Python de valeurs pour le filtre. Si vous ne voulez pas filtrer les valeurs, définissez la propriété list sur une liste vide.

Propriétés filter

Vous pouvez généralement choisir un seul type de filtre. Seuls les types Long et Double ont deux options : Liste de valeurs et Plage.

Liste de valeurs

Le filtre Liste de valeurs est très utile pour fournir un ensemble de mots-clés. De nombreux outils disposent d'un ensemble prédéfini de mots-clés, tels que le paramètre Type de champ figurant dans l'outil Ajouter un champ ou le paramètre Attributs de jointure de nombreux outils dans le jeu d'outils Superposition.

Un filtre Liste de valeurs peut être utilisé pour les types de données Long et Double. Pour ces types, saisissez les valeurs numériques autorisées.

def getParameterInfo(self):
    param0 = arcpy.Parameter(
        displayName="Input value",
        name="in_value",
        datatype="GPLong",
        parameterType="Required",
        direction="Input")
    # Set a value list of 1, 10 and 100
    param0.filter.type = "ValueList"
    param0.filter.list = [1, 10, 100]

Si vous voulez que l'utilisateur soit en mesure de sélectionner plusieurs valeurs, définissez la propriété multiValue sur True.

Une Liste de valeurs peut être utilisée pour les types de données Boolean. Pour les types de données Boolean, la liste de valeurs contient deux valeurs : True et False. La valeur True est toujours la première valeur dans la liste. Les valeurs sont utilisées dans la ligne de commande pour spécifier la valeur. Prenez par exemple l'outil Ajouter un champ et les mots-clés NULLABLE et NON_NULLABLE utilisés pour le paramètre Champ acceptant les valeurs nulles.

Plage

Un paramètre Long ou Double peut avoir un filtre Plage. Les filtres Plage ont deux valeurs, une valeur minimale et une valeur maximale. La première valeur de la liste est la valeur minimale. La plage est inclusive, les valeurs minimale et maximale sont donc des choix valides.

def getParameterInfo(self):
    param0 = arcpy.Parameter(
        displayName="Input range",
        name="in_range",
        datatype="GPLong",
        parameterType="Required",
        direction="Input")
    # Set an acceptable range of 1 to 10
    param0.filter.type = "Range"
    param0.filter.list = [1, 10]

Classe d'entités

Pour ce filtre, sélectionnez une ou plusieurs valeurs de filtre. Les classes d'entités en entrée seront comparées aux valeurs de filtre. Par exemple, si vous sélectionnez uniquement la valeur de filtre Point, l'utilisateur peut uniquement saisir des classes d'entités ponctuelles comme valeur de paramètre.

def getParameterInfo(self):
    param0 = arcpy.Parameter(
        displayName="Input Features",
        name="in_features",
        datatype="GPFeatureLayer",
        parameterType="Required",
        direction="Input")
    param0.filter.list = ["Polygon"]

Fichier

Le paramètre filter du fichier contient une liste des suffixes susceptible d'être acceptés par un fichier, tels que txt (fichier texte simple) et csv (valeurs séparées par des virgules). Le suffixe peut être n'importe quel texte : il n'a pas besoin d'être reconnu par ArcGIS. La longueur du suffixe est illimitée et les points ne sont pas acceptés.

def getParameterInfo(self):
    param0 = arcpy.Parameter(
        displayName="Input File",
        name="in_file",
        datatype="DEFile",
        parameterType="Required",
        direction="Input")
    # To define a file filter that includes .csv and .txt extensions,
    #  set the filter list to a list of file extension names
    param0.filter.list = ['txt', 'csv']

Terrain

Le champ filter définit les types de champs autorisés : Short, Long, Float, Single, Double, Text, Date, OID, Geometry, Blob, Raster, GUID, GlobalID et XML. Plusieurs valeurs peuvent être appliquées au filtre.

def getParameterInfo(self):
    param0 = arcpy.Parameter(
        displayName="Input Features",
        name="in_features",
        datatype="GPFeatureLayer",
        parameterType="Required",
        direction="Input")
    param1 = arcpy.Parameter(
        displayName="Field",
        name="field",
        datatype="Field",
        parameterType="Required",
        direction="Input")
    # Set the filter to accept only fields that are Short or Long type
    param1.filter.list = ['Short', 'Long']
    param1.parameterDependencies = [param0.name]

Espace de travail

Le filtre d'espace de travail spécifie les types d'espaces de travail en entrée autorisés. Trois valeurs sont disponibles :

Filtres Espace de travailDescription

Système de fichiers

Dossier système utilisé pour stocker des fichiers de formes, des couvertures, des tables INFO et des grilles

Base de données locale

Une géodatabase

Base de données distante

Une connexion à une base de données d'entreprise

def getParameterInfo(self):
    param0 = arcpy.Parameter(
        displayName="Input Workspace",
        name="in_workspace",
        datatype="DEWorkspace",
        parameterType="Required",
        direction="Input")
    # Set the filter to accept only local (personal or file) geodatabases
    param0.filter.list = ["Local Database"]

parameterDependencies

La propriété parameterDependencies a deux objectifs :

  • Pour un paramètre en sortie dérivé, la propriété parameterDependencies est définie sur le paramètre en entrée qui sera modifié par l'outil.
  • Pour les paramètres en entrée, parameterDependencies contient le nom des autres paramètres utilisés par le type de données.

# Third parameter
param2 = arcpy.Parameter(
    displayName="Output Features",
    name="out_features",
    datatype="GPFeatureLayer",
    parameterType="Derived",
    direction="Output")
param2.parameterDependencies = [param0.name]
param2.schema.clone = True

Vous pouvez uniquement définir parameterDependencies pour certains paramètres en entrée, comme indiqué dans le tableau ci-dessous.

Type de données en entréeType de données de paramètre dépendantDescription

Champ ou expression SQL

Tableau

Table contenant les champs

Elément INFO ou expression INFO

Table INFO

Table INFO contenant les attributs

Classe d'entités de couverture

Couverture

Couverture contenant des entités

Unités de surface ou unités linéaires

Jeu de données géographiques

Jeu de données géographiques utilisé pour déterminer les unités par défaut

Système de coordonnées

Espace de travail

Espace de travail utilisé pour déterminer le système de coordonnées par défaut.

Paramètres de hiérarchie Network Analyst

Jeu de données réseau

Jeu de données réseau contenant les informations de hiérarchie

Table de valeurs géostatistiques

Couche géostatistique

Table de jeux de données et champs à utiliser dans les outils Geostatistical Analyst.

Types de données parameterDependencies

symbology

Si la sortie de votre outil est une couche de jeu d'entités, raster, de TIN ou Network Analyst, vous pouvez spécifier l'emplacement d'un fichier de couche (.lyr) avec la propriété symbology. Lorsque votre outil est exécuté à partir d'ArcMap, ArcGlobe ou ArcScene, et que l'option Ajouter les résultats du géotraitement à l'affichage est activée, la sortie est ajoutée à la zone d'affichage et dessinée à l'aide de la symbologie définie dans le fichier de couche symbologie.

def getParameterInfo(self):
    param0 = arcpy.Parameter(
        displayName="Input Raster",
        name="in_raster",
        datatype="DERasterDataset",
        parameterType="Required",
        direction="Input")
    param1 = arcpy.Parameter(
        displayName="Output Raster",
        name="out_raster",
        datatype="DERasterDataset",
        parameterType="Required",
        direction="Output")
    # Use __file__ attribute to find the .lyr file (assuming the
    #  .pyt and .lyr files exist in the same folder).
    param1.symbology = os.path.join(os.path.dirname(__file__), 
                                    'raster_symbology.lyr')
Remarque :

le fichier de couche est lu à chaque exécution de l'outil. Si le fichier de couche est introuvable (car il a été déplacé ou supprimé), la symbologie par défaut est utilisée.

category

Vous pouvez placer les paramètres dans différentes catégories pour réduire la taille de la boîte de dialogue de l'outil. Les outils Network Analyst utilisent des catégories, comme indiqué ci-dessous. Les paramètres possédant la même chaîne de catégorie seront regroupés.

Catégories de paramètre

Les catégories sont toujours affichées après les paramètres qui ne sont pas catégorisés. Ne placez pas les paramètres requis dans des catégories, car ils ne sont pas visibles dans la boîte de dialogue de l'outil.

Rubriques connexes

  • Définition de types de données de paramètre dans une boîte à outils Python
  • Qu'est-ce qu'une boîte à outils Python ?
  • Présentation des paramètres des outils de script

ArcGIS Desktop

  • Accueil
  • Documentation
  • Support

ArcGIS

  • ArcGIS Online
  • ArcGIS Desktop
  • ArcGIS Enterprise
  • ArcGIS
  • ArcGIS Developer
  • ArcGIS Solutions
  • ArcGIS Marketplace

A propos d'Esri

  • A propos de la société
  • Carrières
  • Blog d’Esri
  • Conférence des utilisateurs
  • Sommet des développeurs
Esri
Donnez-nous votre avis.
Copyright © 2021 Esri. | Confidentialité | Légal