Einen Geoverarbeitungs-Workflow mit Python automatisieren

Viele Workflows in GIS bestehen aus wiederkehrenden Aufgaben. Geoverarbeitungswerkzeuge können über den Bereich Geoverarbeitung in ArcGIS Pro ausgeführt werden, sie sind jedoch auch in Python als Funktionen von ArcPy verfügbar. Auf diese Weise können Sie wiederkehrende Geoverarbeitungsaufgaben mit einem Python-Skript automatisieren.

In diesem Lernprogramm schreiben Sie ein Python-Skript zum Überprüfen des Koordinatensystems mehrerer Datasets und bestimmen mithilfe dieser Informationen im Skript, wie das Dataset verarbeitet werden sollte.

Die in diesem Lernprogramm behandelten Themen werden detaillierter im Buch Python Scripting for ArcGIS Pro von Esri Press erläutert.

Dieses Lernprogramm wurde zuletzt am 26. April 2024 mit ArcGIS Pro 3.3 getestet. Wenn Sie eine andere Version von ArcGIS Pro verwenden, sind die Funktionalität und Ergebnisse möglicherweise unterschiedlich.

Anforderungen

• ArcGIS Pro (siehe die Optionen für den Zugriff auf die Software)

Einen Geoverarbeitungs-Workflow mit Python automatisieren

Ein Projekt öffnen und Datasets überprüfen

Bevor Sie mit dem Verwenden von Python zum Ausführen von Geoverarbeitungswerkzeugen beginnen, laden Sie die Datasets in ArcGIS Pro herunter und überprüfen sie.

1. Laden Sie die Daten für dieses Lernprogramm herunter, und extrahieren Sie den Inhalt in einem Verzeichnis auf Ihrem Computer.

   Die .zip-Datei enthält einen Ordner namens PythonWorkflow.

   In diesem Lernprogramm werden die Daten in C:\Lessons\PythonWorkflow\ angezeigt. Sie können einen anderen Ordner verwenden. In diesem Fall müssen Sie jedoch die Pfade in den folgenden Anweisungen und im Code anpassen.

2. Doppelklicken Sie im Ordner C:\Lessons\PythonWorkflow\ auf Workflow.aprx.

   Das Projekt "Workflow" wird in ArcGIS Pro geöffnet.

3. Wenn der Bereich Katalog nicht bereits sichtbar ist, klicken Sie auf der Registerkarte Anzeigen auf den Bereich Katalog.
4. Blenden Sie im Bereich Katalog die Option Ordner ein, und blenden Sie PythonWorkflow ein.
5. Blenden Sie Transportation.gdb ein.

   

   Die Feature-Classes in dieser Geodatabase beziehen sich auf das Verkehrswesen. Angenommen, Sie müssen aus diesen Feature-Classes ein Netzwerk erstellen. Dazu müssten diese im gleichen Feature-Dataset gespeichert sein und die gleichen Koordinatensysteme aufweisen. Zurzeit ist dies nicht der Fall.

   In diesem Lernprogramm verwenden Sie Python-Code zum Überprüfen des Koordinatensystems der Feature-Classes. Außerdem verwenden Sie das Werkzeug Projizieren zum Konvertieren von Datasets, die noch nicht das richtige Koordinatensystem aufweisen, sowie zum Kopieren derselben in eine neue Geodatabase und ein neues Feature-Dataset. Auf diese Weise könnten Sie auch ein Netzwerk erstellen. Das ist jedoch nicht Bestandteil dieses Lernprogramms.

   Vor dem Arbeiten mit dem Python-Code überprüfen Sie das Koordinatensystem ausgewählter Datasets und führen das Werkzeug Projizieren manuell aus. Dadurch erhalten Sie Informationen, die Sie zum Automatisieren des Prozesses mit Python-Code benötigen.

6. Klicken Sie mit der rechten Maustaste auf bike_racks, und klicken Sie auf Zu aktueller Karte hinzufügen.

   

7. Fügen Sie auf die gleiche Weise die Feature-Class "roads" der Karte hinzu.

   Diese Feature-Classes stellen Fahrradparkplätze und Straßen in Washington, D.C. dar.

   Als Nächstes sollten Sie sich die Koordinatensysteme der beiden Feature-Classes anschauen.

8. Klicken Sie im Bereich Inhalt mit der rechten Maustaste auf Karte, und klicken Sie auf Eigenschaften.

   

9. Klicken Sie im Fenster Karteneigenschaften: Karte auf Koordinatensysteme.

   

10. Blenden Sie Layer ein, und blenden Sie die Einträge für die Koordinatensysteme WGS 1984 und NAD 1983 StatePlane Maryland FIPS 1900 (US Feet) ein.

    

    Die Feature-Class "bike_racks" liegt in einem geographischen Koordinatensystem namens "WGS 1984" vor, während die Feature-Classes "road" und "boundary" das projizierte State Plane-Koordinatensystem für Maryland aufweisen, NAD 1983 StatePlane Maryland FIPS 1900 (US Feet).

    Ihr Ziel ist es, alle Feature-Classes in ein Dataset mit dem projizierten Koordinatensystem zu überführen.

11. Klicken Sie auf OK, um das Fenster Karteneigenschaften zu schließen.

    Sie haben die Geodatabase untersucht und die beiden von den Feature-Classes verwendeten Koordinatensysteme identifiziert. Im nächsten Schritt projizieren Sie eine der Feature-Classes.

Eine Feature-Class projizieren

Als Nächstes projizieren Sie eine der Feature-Classes und untersuchen die für das Werkzeug erforderlichen Parameter.

1. Klicken Sie auf dem Menüband auf Analyse und im Abschnitt Geoverarbeitung auf Werkzeuge.

   

   Daraufhin wird der Bereich Geoverarbeitung angezeigt.

2. Klicken Sie in das Suchfeld im Bereich Geoverarbeitung, und geben Sie Project ein.
3. Klicken Sie in der Liste der Suchergebnisse auf Projizieren (Data Management Tools).
4. Wählen Sie im Werkzeugbereich Projizieren für den Parameter Eingabe-Dataset oder -Feature-Class die Option bike_racks aus.
5. Klicken Sie für den Namen für Ausgabe-Dataset oder -Feature-Class auf die Schaltfläche "Durchsuchen", und navigieren Sie zur Geodatabase Transportation. Blenden Sie die Geodatabase ein, und geben Sie bike_racks_sp im Feld Name ein. Klicken Sie auf Speichern.
6. Klicken Sie für das Ausgabe-Koordinatensystem auf die Dropdown-Liste und dann auf roads.

   

   Durch die Auswahl von roads wird der Wert von Ausgabe-Koordinatensystem auf das Koordinatensystem der Feature-Class "roads", also das State Plane-Koordinatensystem für Maryland, festgelegt.

   Der Parameter Geographische Transformation wird auf WGS_1984_(ITRF00) To_NAD_1983 festgelegt, da sich die geographischen Koordinatensysteme von Eingabe und Ausgabe unterscheiden.

   Hinweis:

   Eine geographische Transformation ist notwendig, wenn die geographischen Koordinatensysteme der Eingabe-Feature-Class und der Ausgabe-Feature-Class unterschiedlich sind. Bei identischen geographischen Koordinatensystemen wird für diesen Parameter keine Werteliste angezeigt. Wenn eine Transformation erforderlich ist, wird auf Grundlage der geographischen Eingabe- und Ausgabekoordinatensysteme eine Dropdown-Liste angezeigt und eine Standardtransformation ausgewählt. In diesem Lernprogramm verwenden Sie diese Standardtransformationsmethoden.

7. Klicken Sie auf Ausführen.

   Das Werkzeug Projizieren wird ausgeführt, und die projizierte Feature-Class wird der aktiven Karte hinzugefügt.

   Zum Vorbereiten der Daten, die in einem Netzwerk verwendet werden sollen, müssten Sie diesen Vorgang für jede Feature-Class in der Geodatabase wiederholen: Überprüfen des Koordinatensystems und Entscheiden, ob Sie das Werkzeug Projizieren ausführen müssen. Projizieren Sie die Feature-Classes, die projiziert werden müssen. Kopieren Sie die anderen Feature-Classes, ohne sie zu projizieren.

   Anstatt diese Schritte manuell zu wiederholen, automatisieren Sie den Prozess mit Python-Code.

8. Schließen Sie das Werkzeug Projizieren.
9. Klicken Sie im Bereich Katalog mit der rechten Maustaste auf die Feature-Class bike_racks_sp, klicken Sie auf Löschen, und klicken Sie auf Ja, um die Feature-Class dauerhaft zu löschen.

   Jetzt können Sie den Workflow mithilfe von Python-Code starten.

Eine Feature-Class mithilfe von Python beschreiben

Mit dem ersten Schritt des Workflow wird das Koordinatensystem der Feature-Class untersucht. Dazu verwenden Sie Python-Code im Python-Fenster.

1. Klicken Sie auf dem Menüband auf die Registerkarte Analyse, klicken Sie im Abschnitt Geoverarbeitung auf den Dropdown-Pfeil der Schaltfläche Python, und klicken Sie dann auf Python-Fenster.

   

2. Klicken Sie auf den Eingabeaufforderungsbereich unten im Python-Fenster, geben Sie den folgenden Code ein, und drücken Sie die Eingabetaste:

   desc = arcpy.da.Describe("bike_racks")

   

   Wenn Sie die Eingabetaste drücken, wird der Code sofort ausgeführt. Dabei werden keine Informationen ausgegeben, aber es wird eine Variable namens desc erstellt. Dieser Variable wird das Ergebnis der Funktion Describe zugewiesen, die für die Feature-Class "bike_racks" ausgeführt wird.

   Die Funktion Describe gibt ein Dictionary mit den Eigenschaften des Datasets zurück. Damit erhalten Sie Zugriff auf den Raumbezug und andere Eigenschaften.

3. Fügen Sie im Eingabeaufforderungsbereich den folgenden Code hinzu, und drücken Sie die Eingabetaste.

   sr = desc["spatialReference"]

   Damit wird die neue Variable sr dem Wert zugewiesen, der im Key SpatialReference des Dictionarys der Dataset-Eigenschaften gespeichert ist. Das SpatialReference-Objekt enthält alle relevanten Informationen zum Koordinatensystem des Datasets. Auf diese Weise können Sie überprüfen, ob bestimmte Eigenschaften vorhanden sind.

4. Fügen Sie im Eingabeaufforderungsbereich den folgenden Code hinzu, und drücken Sie die Eingabetaste.

   print(sr.name)

   Damit wird der Name des Raumbezugsobjekts ausgegeben.

   

   Da es etwas umständlich ist, das Koordinatensystem für jede einzelne Feature-Class auf diese Weise zu überprüfen, verwenden Sie eine Listenfunktion, um eine Liste zu erstellen und dann alle Feature-Classes zu verarbeiten.

Eine Liste der Feature-Classes erstellen und die Feature-Classes beschreiben

Sie können die Überprüfung der Koordinatensysteme der Feature-Classes beschleunigen, indem Sie eine Liste der Feature-Classes erstellen und dann mithilfe einer Schleifenstruktur in Python die Liste verarbeiten und die einzelnen Feature-Classes beschreiben.

1. Fügen Sie im Eingabeaufforderungsbereich den folgenden Code hinzu, und drücken Sie die Eingabetaste.

   fcs = arcpy.ListFeatureClasses()

   Damit wird eine Variable namens fcs erstellt und dem Ergebnis der Funktion ListFeatureClasses zugewiesen, die für den aktuellen Workspace ausgeführt wird. Sie haben den Workspace nicht explizit festgelegt, aber Transportation.gdb ist der Standard-Workspace für dieses Projekt. Die Funktion gibt eine Liste der Feature-Classes in Transportation.gdb zurück.

2. Fügen Sie im Eingabeaufforderungsbereich den folgenden Code hinzu, und drücken Sie die Eingabetaste.

   print(fcs)

   Das Ergebnis ist eine Python-Liste mit Feature-Class-Namen. Sie ist in eckige Klammern eingeschlossen, und bei den Feature-Class-Namen handelt es sich um durch Kommas getrennte Python-Zeichenfolgen.

   ['bus_lines', 'boundary', 'street_lights', 'roads', 'traffic_analysis_zones', 'bike_routes', 'bike_racks', 'parking_zones', 'intersections', 'station_entrances']

   Als Nächstes verwenden Sie eine for-Schleife, um die einzelnen Elemente in der Liste zu verarbeiten.

3. Fügen Sie im Eingabeaufforderungsbereich den folgenden Code hinzu:

   for fc in fcs:
       desc = arcpy.da.Describe(fc)
       sr = desc["spatialReference"]
       print(f"{fc}: {sr.name}")

   

   Mit der ersten Zeile wird eine for-Schleife definiert. Dabei wird eine temporäre Variable namens fc erstellt, welcher der Name jeder Feature-Class in der fcs-Liste zugewiesen wird. Die Codezeile endet mit einem Doppelpunkt. Das bedeutet, dass der Codeblock folgt, der für jedes einzelne Element in der Liste ausgeführt wird. Die nächsten drei Zeilen sind um vier Leerzeichen eingerückt. Dies bedeutet, dass sie Teil des Codeblocks sind. Mit der ersten Zeile im Codeblock wird eine Variable namens desc erstellt und dem Ergebnis der Funktion Describe zugewiesen, die für den aktuellen in der Variable fc gespeicherten Feature-Class-Wert ausgeführt wird. Mit der zweiten Zeile wird die Variable sr erstellt und dem in desc gespeicherten spatialReference-Objekt zugewiesen. Mit der dritten Zeile wird eine formatierte Zeichenfolge ausgegeben, die den Feature-Class-Namen, einen Doppelpunkt und den Namen des Raumbezugs enthält.

   Mit dem Code in diesem Block wird der Prozess wiederholt, den Sie zuvor ausgeführt haben, um den Namen des Raumbezugs für die Feature-Class "bike_racks" abzurufen. Es wird jedoch eine Variable dafür verwendet, die jedem Element in der Liste zugewiesen ist, sodass die Ergebnisse für alle Feature-Classes verarbeitet und ausgegeben werden.

4. Drücken Sie zweimal die Eingabetaste, um die for-Schleife und den zugehörigen Codeblock auszuführen.

   

   Die Hälfte der Feature-Classes liegt in einem Koordinatensystem und die andere Hälfte in einem anderen Koordinatensystem vor.

   Im nächsten Schritt schreiben Sie Code zum Erstellen einer Geodatabase und Verwenden der Werkzeuge Projizieren und Features kopieren, um die Feature-Classes im gleichen Dataset mit einem gemeinsamen projizierten Koordinatensystem zu vereinen. Sie exportieren Ihre bisherige Arbeit und verwenden sie als Grundlage für ein Skript.

Ein Skript erstellen

Als Nächstes fahren Sie mit dem Schreiben des Codes fort, um diesen Prozess als Skript zu automatisieren. Sie können Code im Python-Fenster testen, aber bei längeren Skripten empfiehlt es sich in der Regel, diese in einem Python-Editor zu schreiben. Sie exportieren den bisherigen Code und setzen Ihre Arbeit in IDLE fort, dem Standard-Editor für Python.

1. Klicken Sie mit der rechten Maustaste in den Protokollabschnitt des Python-Fensters, und klicken Sie auf Transkript speichern.

   

2. Navigieren Sie im Fenster Transkript speichern zum Ordner PythonWorkflow, in den Sie die Daten extrahiert haben, legen Sie workflow_project.py als Namen für das Protokoll fest, und klicken Sie auf Speichern.

   Damit wird das Protokoll als Python-Skriptdatei gespeichert, die Sie in einem Python-Editor öffnen können.

3. Starten Sie Microsoft File Explorer, und navigieren Sie zum Ordner PythonWorkflow.
4. Klicken Sie mit der rechten Maustaste auf workflow_project.py, und klicken Sie auf Edit with IDLE (ArcGIS Pro).

   

   Hinweis:

   Wenn auch ArcGIS Desktop 10.x (ArcMap) installiert ist, enthält das Kontextmenü zudem die Verknüpfung Edit with IDLE. Verwenden Sie diese Verknüpfung nicht. Damit wird nicht die richtige Version von Python geöffnet.

   Hinweis:

   Wenn Edit with IDLE (ArcGIS Pro) im Kontextmenü nicht angezeigt wird, klicken Sie auf Start, blenden Sie ArcGIS ein, und klicken Sie auf die Python-Eingabeaufforderung. Geben Sie im Python-Eingabeaufforderungsfenster die Zeichenfolge idle ein, und drücken Sie die Eingabetaste. Das Fenster von IDLE (Python 3.9-Shell) wird angezeigt. Klicken Sie auf Datei und dann auf Öffnen. Navigieren Sie zur Datei workflow_project.py, und öffnen Sie sie.

   Das Skript wird in IDLE, dem Standard-Editor für Python, geöffnet. Das Skript enthält den gesamten Code aus dem Protokollabschnitt des Python-Fensters einschließlich aller ausgegebenen Meldungen, die als Kommentare mit Rautenzeichen am Zeilenanfang angezeigt werden.

   

5. Entfernen Sie im Fenster des IDLE-Editors den gesamten Code vor der Zeile fcs = arcpy.ListFeatureClasses().
6. Entfernen Sie alle Kommentarzeilen.
7. Entfernen Sie die Zeile print(fcs).

   Folgender Code verbleibt:

   fcs = arcpy.ListFeatureClasses()
   for fc in fcs:
       desc = arcpy.da.Describe(fc)
       sr = desc["spatialReference"]
       print(f"{fc}: {sr.name}")

   Als Nächstes fügen Sie Zeilen hinzu, um zwei Bibliotheken zu importieren, Variablen festzulegen und den Workspace festzulegen.

8. Fügen Sie vor der Zeile fcs = arcpy.ListFeatureClasses() eine neue Zeile hinzu, und fügen Sie am Anfang des Skriptes die folgenden Zeilen hinzu.

   import arcpy
   import os

   Mit der ersten Codezeile wird das ArcPy-Paket importiert, um sicherzustellen, dass die Funktionalität von ArcPy im Skript verfügbar ist, wenn dieses außerhalb von ArcGIS Pro ausgeführt wird. Mit der zweiten Zeile wird das Modul "os" importiert, das zum Verarbeiten von Dateipfaden verwendet wird.

9. Fügen Sie nach den ersten zwei Zeilen eine neue Zeile hinzu, und fügen Sie die folgenden Codezeilen hinzu:
   mypath = "C:/Lessons/PythonWorkflow"
   gdb = "Transportation.gdb"
   arcpy.env.workspace = os.path.join(mypath, gdb)

   Mit der ersten Zeile wird der Speicherort der Daten angegeben. Wenn Sie den Ordner PythonWorkflow an einem anderen Speicherort extrahiert haben, müssen Sie diese Zeile so anpassen, dass sie dem Pfad auf dem Computer entspricht. Dieser Wert ist einer Variablen mit dem Namen mypath zugewiesen. Diese Variable wird zum Festlegen des Workspace sowie wie für andere Tasks wie das Erstellen einer File-Geodatabase verwendet.

   Im Pfad wird anstelle eines umgekehrten Schrägstrichs (\) ein regulärer Schrägstrich (/) verwendet. Ein einzelner umgekehrter Schrägstrich dient in Python als Escape-Zeichen und kann unerwünschte Folgen haben. Anstelle eines regulären Schrägstrichs können Sie auch den Buchstaben "r" (für "raw") vor der Zeichenfolge hinzufügen (z. B. r"C:\Lessons\PythonWorkflow") oder zwei umgekehrte Schrägstriche verwenden (z. B. "C:\\Lessons\\PythonWorkflow"). Alle drei Notationen gelten als richtig und sind austauschbar.

   Mit der nächsten Zeile wird die Variable gdb auf den Namen der Geodatabase festgelegt, in der die relevanten Feature-Classes gespeichert sind.

   Mit der letzten Zeile wird der Workspace festgelegt, indem der Ordner, in dem sich die Daten befinden (mypath), mit dem Namen der Geodatabase (gdb) kombiniert wird. Mit der Funktion os.path.join() werden diese beiden Zeichenfolgen zu einer neuen Zeichenfolge für den Pfad des Workspace kombiniert. Es wird empfohlen, hierfür os.path.join() zu verwenden, da auf diese Weise robuste Pfadzeichenfolgen ohne einfache umgekehrte Schrägstriche (\) erstellt werden. Diese werden von Python als Escape-Zeichen gelesen und können zu Fehlern führen.

   Nachfolgend finden Sie den aktuellen Stand des vollständigen Skriptes:

   import arcpy
   import os
   mypath = "C:/Lessons/PythonWorkflow"
   gdb = "Transportation.gdb"
   arcpy.env.workspace = os.path.join(mypath, gdb)
   fcs = arcpy.ListFeatureClasses()
   for fc in fcs:
       desc = arcpy.da.Describe(fc)
       sr = desc["spatialReference"]
       print(f"{fc}: {sr.name}")

   

   Jetzt können Sie das Skript testen, um sich zu vergewissern, dass es funktioniert.

10. Klicken Sie auf File und dann auf Save.

    Damit werden Ihre Änderungen am Skript gespeichert. Sie können Ihre Arbeit auch mit der Tastenkombination Strg+S in IDLE speichern.

11. Klicken Sie auf Run und dann auf Run Module.

    

    Damit wird das Skript ausgeführt. Sie können das Skript auch mit der Taste F5 ausführen.

    Das Fenster der IDLE-Shell wird angezeigt, und nach einer kurzen Pause, in der das Modul ArcPy den Import ausführt, werden die Feature-Class-Namen und Raumbezugnamen ausgegeben.

    

    Um das Skript zur Automatisierung dieses Workflows zu vervollständigen, müssen Sie die folgenden Funktionen hinzufügen: 1) Erstellen einer Geodatabase, 2) Erstellen eines Feature-Datasets, 3) Kopieren der bereits projizierten Feature-Classes und 4) Projizieren der Feature-Classes, die ein geographisches Koordinatensystem aufweisen. Sie schreiben Code für jede dieser Funktionen, testen den Code und fahren dann mit der nächsten Funktion fort.

Code zum Erstellen einer Geodatabase verwenden

Im nächsten Schritt fügen Sie Ihrem Skript Code hinzu, um eine Geodatabase zu erstellen. Da Sie das Skript möglicherweise mehrmals testen müssen, müssen Sie in der Lage sein, zuvor erstellte Daten zu überschreiben. Zu diesem Zweck fügen Sie eine Umgebungseinstellung hinzu.

1. Fügen Sie nach der mit arcpy.env.workspace beginnenden Zeile eine Zeile hinzu, und fügen Sie den folgenden Code hinzu:

   arcpy.env.overwriteOutput = True

   Als Nächstes erstellen Sie Variablen zum Speichern der Namen der neuen Geodatabase und des neuen Feature-Datasets.

2. Fügen Sie nach der Zeile gdb = "Transportation.gdb" eine Zeile hinzu, und fügen Sie den folgenden Code hinzu:

   new_gdb = "Metro_Transport.gdb"
   fds = "Metro_Network"

   Durch die Verwendung von Variablen vermeiden Sie das Wiederholen von Namen im restlichen Skript. Der Code kann dadurch leichter wiederverwendet werden. Wenn Sie für die Geodatabase oder das Dataset einen anderen Namen verwenden möchten, müssen Sie ihn nur an einer Stelle im Skript ändern.

   Als Nächstes fügen Sie Code hinzu, um die Geodatabase zu erstellen.

3. Fügen Sie nach der mit arcpy.env.overwriteOutput beginnenden Zeile den folgenden Code hinzu:

   new_gdb_path = arcpy.CreateFileGDB_management(mypath, new_gdb)

   Mit dieser Zeile wird das Werkzeug "File-Geodatabase erstellen" aufgerufen. In den Klammern geben Sie an, dass der erste erforderliche Parameter – der Speicherort für die neue Geodatabase – auf die Variable mypath festgelegt wird, die den von Ihnen festgelegten Pfad enthält. Nach einem Komma geben Sie den zweiten erforderlichen Parameter des Werkzeugs an – den Namen der File-Geodatabase. Die Variable new_gdb enthält den Namen der neuen Geodatabase.

   Mit der Zeile wurden außerdem die Ergebnisse der Erstellung der Geodatabase einer Variablen zugewiesen. Die Variable new_gdb_path enthält den Pfad und den Namen der neu erstellten Geodatabase. Dadurch kann diese neue Geodatabase im Skript leichter referenziert werden.

   Vor dem Testen des Skriptes kommentieren Sie einen Teil des Codes aus, der nicht getestet werden muss.

4. Wählen Sie alle Codezeilen nach der Zeile new_gdb_path aus.

   

5. Klicken Sie auf Format und dann auf Comment Out Region.

   

   Damit werden am Anfang jeder der ausgewählten Codezeilen zwei Rautenzeichen hinzugefügt. Mit Rautenzeichen beginnende Zeilen werden von Python als Kommentare interpretiert und daher nicht ausgeführt. Sie könnten diese Zeilen löschen, aber ein Teil des Codes wird wiederverwendet. Durch Auskommentieren dieser Zeilen können Sie den Code zur späteren Wiederverwendung im Skript lassen, ohne dass er ausgeführt wird.

   

   Der Code sieht jetzt so aus:

   import arcpy
   import os
   mypath = "C:/Lessons/PythonWorkflow"
   gdb = "Transportation.gdb"
   new_gdb = "Metro_Transport.gdb"
   fds = "Metro_Network"
   arcpy.env.workspace = os.path.join(mypath, gdb)
   arcpy.env.overwriteOutput = True
   new_gdb_path = arcpy.CreateFileGDB_management(mypath, new_gdb)
   ##fcs = arcpy.ListFeatureClasses()
   ##for fc in fcs:
   ##    desc = arcpy.da.Describe(fc)
   ##    sr = desc["spatialReference"]
   ##    print(f"{fc}: {sr.name}")

6. Speichern Sie das Skript, und führen Sie es aus.

   Das Fenster der IDLE-Shell wird neu gestartet, und kurz darauf wird die Eingabeaufforderung (>>>) wieder angezeigt. Der Code enthält zurzeit keine funktionsfähigen Zeilen, mit denen Informationen an die Shell ausgegeben werden. Daher lässt sich schwer erkennen, ob der Code funktioniert hat. Sie überprüfen dies in ArcGIS Pro.

7. Klicken Sie in ArcGIS Pro im Bereich Katalog im Abschnitt Ordner mit der rechten Maustaste auf den Ordner PythonWorkflow, und klicken Sie auf Aktualisieren.

   

8. Blenden Sie den Ordner PythonWorkflow ein.

   

   Die neue Geodatabase befindet sich in dem Ordner. Er ist aktuell leer.

9. Klicken Sie mit der rechten Maustaste auf Metro_Transport.gdb, klicken Sie auf Löschen, und klicken Sie auf Ja, um die Geodatabase dauerhaft zu löschen.

   Beim Testen eines Skriptes ist es oft hilfreich, Ausgaben zu löschen, damit Sie leichter erkennen, ob das Skript funktioniert.

   Eine weitere Möglichkeit, herauszufinden, ob ein Skript funktioniert: Fügen Sie Meldungen hinzu, aus denen hervorgeht, was geschehen ist. Sie können dem Code print-Anweisungen hinzufügen, mit deren Hilfe Sie nachvollziehen können, was geschieht.

10. Fügen Sie im Fenster des IDLE-Editors nach der mit new_gdb_path = arcpy.CreateFileGDB beginnenden Zeile eine neue Zeile hinzu, und fügen Sie den folgenden Code hinzu:

    print(f"The geodatabase {new_gdb} has been created.")

    

    Mit dieser print-Anweisung wird eine formatierte Zeichenfolge ausgegeben, die den Wert der Variablen new_gdb enthält. Print-Anweisungen sind für die Ausführung des Skriptes nicht notwendig, erleichtern aber das Nachvollziehen der vom Skript ausgeführten Aktionen. Sie können auch beim Debuggen von Fehlern in langen Skripten sehr hilfreich sein. Sie können mehrere print-Anweisungen hinzufügen, um den Status an verschiedenen Stellen des Skriptes anzugeben. Wenn Sie eine Meldung sehen, wissen Sie, dass das Skript bis zur entsprechenden Stelle ausgeführt wurde. Sie können auch formatierte Zeichenfolgen verwenden, um die Werte von Variablen im Skript auszugeben. Dies kann beim Debuggen von Fehlern sehr hilfreich sein.

11. Speichern Sie das Skript.

Code zum Erstellen eines Feature-Datasets verwenden

Als Nächstes erstellen Sie das Feature-Dataset in der neuen Geodatabase. Eine wesentliche Eigenschaft eines Feature-Datasets besteht darin, dass alle Feature-Classes im Feature-Dataset das gleiche Koordinatensystem aufweisen.

Sie verwenden für dieses Dataset das State Plane-Koordinatensystem für Maryland. Es ist zwar möglich, beim Festlegen des Koordinatensystems in Python den Namen des Koordinatensystems zu verwenden, aber es ist einfacher, als Abkürzungscode die WKID (well-known identifier) zu verwenden.

1. Klicken Sie in ArcGIS Pro im Bereich Inhalt mit der rechten Maustaste auf den Layer roads, und klicken Sie auf Eigenschaften.
2. Klicken Sie im Bereich Layer-Eigenschaften auf die Registerkarte Quelle.

   

3. Klicken Sie auf Datenquelle, um den Abschnitt Datenquelle auszublenden.

   

4. Klicken Sie auf Raumbezug, um es zu erweitern.

   

   Der WKID-Code für dieses Koordinatensystem lautet 2248.

   

5. Klicken Sie auf Abbrechen, um den Bereich Layer-Eigenschaften zu schließen.

   Jetzt verwenden Sie diesen WKID-Code, um den Raumbezug für das Feature-Dataset festzulegen.

6. Fügen Sie in IDLE nach der mit print(f"The geodatabase beginnenden Zeile die folgenden Codezeilen hinzu:

   arcpy.CreateFeatureDataset_management(new_gdb_path, fds, 2248)
   print(f"The feature dataset {fds} has been created.")

   

   Mit der ersten Zeile wird das Werkzeug Feature-Dataset erstellen ausgeführt, wobei drei erforderliche Parameter angegeben werden. Der erste Parameter ist der Speicherort der Geodatabase, in der das Feature-Dataset erstellt wird, der zweite ist der Name des Feature-Datasets, und der dritte ist die WKID des Koordinatensystems für das Dataset. Die Variable new_gdb_path enthält den vollständigen Pfad zur Datenbank. Der Name des Feature-Datasets wurde zuvor der Variablen fds zugewiesen.

   Eine andere Möglichkeit zum Festlegen des Koordinatensystems besteht darin, den Pfad zu einer vorhandenen Feature-Class anzugeben, beispielsweise durch Angeben des Pfades zur Feature-Class "roads" in der Geodatabase Transportation.gdb.

   Mit der zweiten Zeile wird eine formatierte Zeichenfolge ausgegeben, aus der hervorgeht, dass das neue Dataset erstellt wurde.

   Nachfolgend finden Sie den vollständigen Code:

   import arcpy
   import os
   mypath = "C:/Lessons/PythonWorkflow"
   gdb = "Transportation.gdb"
   new_gdb = "Metro_Transport.gdb"
   fds = "Metro_Network"
   arcpy.env.workspace = os.path.join(mypath, gdb)
   arcpy.env.overwriteOutput = True
   new_gdb_path = arcpy.CreateFileGDB_management(mypath, new_gdb)
   print(f"The geodatabase {new_gdb} has been created.")
   arcpy.CreateFeatureDataset_management(new_gdb_path, fds, 2248)
   print(f"The feature dataset {fds} has been created.")
   ##fcs = arcpy.ListFeatureClasses()
   ##for fc in fcs:
   ##    desc = arcpy.da.Describe(fc)
   ##    sr = desc["spatialReference"]
   ##    print(f"{fc}: {sr.name}")

7. Speichern Sie den Code, und führen Sie ihn aus.

   Der Code wird ausgeführt, und kurz darauf werden die beiden Statusmeldungen in der IDLE-Shell ausgegeben.

   

8. Klicken Sie in ArcGIS Pro im Bereich Katalog mit der rechten Maustaste auf den Ordner PythonWorkflow, und klicken Sie auf Aktualisieren.

   Die Geodatabase Metro_Transport wurde erstellt.

9. Blenden Sie die Geodatabase Metro_Transport ein.

   Das Feature-Dataset Metro_Network wurde erstellt.

10. Löschen Sie die Geodatabase Metro_Transport.

Code zum bedingungsabhängigen Kopieren von Feature-Classes verwenden

Als Nächstes verwenden Sie einen Teil des zuvor auskommentierten Codes zum Auflisten der Feature-Classes in der Geodatabase Transportation.gdb. Sie fügen Logik hinzu, um zu überprüfen, ob die Raumbezugs-WKID der einzelnen Feature-Classes 2248 lautet, sowie Code zum Kopieren der Feature-Class in die neue Geodatabase, wenn die Bedingung erfüllt ist.

1. Wählen Sie in IDLE die zuvor auskommentierten Codezeilen aus.
2. Klicken Sie auf Format und dann auf Uncomment Region.

   

   Beim Aufheben der Auskommentierung des Codes werden die Rautenzeichen vor den einzelnen Zeilen entfernt, sodass der Code nicht als Kommentar interpretiert, sondern ausgeführt wird.

   Mit dem nicht mehr auskommentierten Code wird eine Liste der Feature-Classes im aktuellen Workspace erstellt. Anschließend werden die Beschreibungen der einzelnen Elemente in der Liste zum Extrahieren des Raumbezugs verwendet. Anstatt diese Informationen auszugeben, ergänzen Sie jetzt den Code, um den Raumbezugswert zu überprüfen und die Feature-Class zu kopieren oder zu projizieren.

   Die Werkzeuge Features kopieren und Projizieren akzeptieren eine Eingabe-Feature-Class und erzeugen eine Ausgabe-Feature-Class. Die Namen der Feature-Classes können gleich bleiben, aber die Pfade für die Ausgaben unterscheiden sich, da sich die neuen Feature-Classes in einer neuen Geodatabase befinden.

   Die Eingabe-Feature-Classes werden mit der Variable fc dargestellt. Bei den Werten von fc handelt es sich um Feature-Class-Namen, die von einer Liste von Feature-Classes im aktuellen Workspace abgeleitet wurden.

   Der vollständige Pfad einer der Eingabe-Feature-Classes lautet beispielsweise C:\Lessons\PythonWorkflow\Transportation.gdb\roads.

   Da der Workspace festgelegt ist, können die Feature-Class-Namen wie roads direkt in Werkzeugen verwendet werden. Beim Arbeiten mit Feature-Classes im aktuellen Workspace wird der vollständige Pfad nicht benötigt. Aus diesem Grund funktioniert desc = arcpy.da.Describe(fc) oder desc = arcpy.da.Describe("roads").

   Sie müssen jedoch für die Ausgabe-Feature-Class-Parameter den vollständigen Pfad für die neuen Feature-Classes im neuen Workspace angeben. Dieser Pfad kann wie weiter oben im Skript beim Festlegen der Umgebungseinstellungen mit os.path.join() konstruiert werden.

3. Wählen Sie die mit print(f"{fc}: beginnende Codezeile aus, und ersetzen Sie sie durch die folgende Codezeile:

   new_fc = os.path.join(mypath, new_gdb, fds, fc)

   Diese Zeile sollte sich auf der gleichen Einrückungsebene im Codeblock der for fc in fcs:-Schleife befinden.

   In dieser Zeile wird der neuen Variable (new_fc) der Pfad zugewiesen, der durch Verbinden des Ordners, in dem sich die Daten befinden (mypath), mit der neuen Geodatabase (new_gdb) und mit dem neuen Feature-Dataset (fds) erstellt wird. Der letzte Teil des Pfades ist der Name der neuen Feature-Class, der mit dem der Eingabe-Feature-Class (dem Wert der Variablen fc) identisch ist. Dieser Teil des Pfades ändert sich mit jeder Iteration der Schleife durch die Liste der Feature-Classes.

   Nun ist der vollständige Pfad für die Ausgabe-Feature-Classes erstellt, und Sie können Code hinzufügen, um zu entscheiden, ob die einzelnen Feature-Classes basierend auf dem Koordinatensystem kopiert oder projiziert werden sollen. Sie können in Python verschiedene Bedingungen mit if-Anweisungen testen und verschiedene Codeblöcke abhängig davon, ob eine Bedingung in der Anweisung erfüllt ist, ausführen lassen.

4. Fügen Sie nach der Zeile new_fc = os.path.join auf der gleichen Einrückungsebene (in der for-Schleife) die folgende Codezeile hinzu:

   if sr.factoryCode == 2248:

   Mit diesem Code wird überprüft, ob die WKID der Feature-Class, die im sr-Objekt als zugehöriger factoryCode-Wert gespeichert ist, mit der WKID 2248 des State Plane-Koordinatensystems für Maryland übereinstimmt.

   Dabei werden eine if-Anweisung und ein Ausdruck verwendet. Der Code endet mit einem Doppelpunkt, um anzugeben, dass ein Codeblock folgt, der ausgeführt wird, wenn die Anweisung zutrifft.

   Für die Anweisung wird ein doppeltes Gleichheitszeichen verwendet. Ein einfaches Gleichheitszeichen wird in Python für das Zuweisen einer Variablen zu einem Wert verwendet, und mit einem doppelten Gleichheitszeichen wird die Gleichheit überprüft.

5. Klicken Sie auf das Ende dieser Codezeile, und drücken Sie die Eingabetaste.

   Dadurch ergibt sich die richtige Einrückung für die nächste Codezeile, das heißt eine Einrückung um vier Leerzeichen in Relation zur Zeile mit der if-Anweisung. Dies ist der Anfang eines neuen Codeblocks, der nur ausgeführt wird, wenn sr.factoryCode gleich dem Wert 2248 ist.

   Nachdem der vollständige Pfad für die Ausgabe-Feature-Classes erstellt wurde und der Test des Koordinatensystems erfolgreich verlaufen ist, können Sie Code hinzufügen, um die Feature-Class zu kopieren.

6. Fügen Sie in der neu eingerückten Zeile die folgenden Codezeilen hinzu:

   arcpy.CopyFeatures_management(fc, new_fc)
           print(f"The feature class {fc} has been copied.")

   Mit der ersten Zeile wird das Werkzeug "Features kopieren" ausgeführt, wobei die aktuelle Feature-Class in die neue Geodatabase kopiert wird.

   Mit der zweiten Zeile wird eine formatierte Zeichenfolge ausgegeben, aus der hervorgeht, dass das neue Dataset erstellt wurde.

   Nachfolgend finden Sie den vollständigen Code:

   import arcpy
   import os
   mypath = "C:/Lessons/PythonWorkflow"
   gdb = "Transportation.gdb"
   new_gdb = "Metro_Transport.gdb"
   fds = "Metro_Network"
   arcpy.env.workspace = os.path.join(mypath, gdb)
   arcpy.env.overwriteOutput = True
   new_gdb_path = arcpy.CreateFileGDB_management(mypath, new_gdb)
   print(f"The geodatabase {new_gdb} has been created.")
   arcpy.CreateFeatureDataset_management(new_gdb_path, fds, 2248)
   print(f"The feature dataset {fds} has been created.")
   fcs = arcpy.ListFeatureClasses()
   for fc in fcs:
       desc = arcpy.da.Describe(fc)
       sr = desc["spatialReference"]
       new_fc = os.path.join(mypath, new_gdb, fds, fc)
       if sr.factoryCode == 2248:
           arcpy.CopyFeatures_management(fc, new_fc)
           print(f"The feature class {fc} has been copied.")

   

7. Speichern Sie den Code, und führen Sie ihn aus.

   

   Der Code wird ausgeführt. Dabei werden die Geodatabase und das Feature-Dataset erstellt, und die fünf Layer mit dem State Plane-Koordinatensystem für Maryland werden kopiert.

8. Aktualisieren Sie in ArcGIS Pro im Bereich Katalog den Ordner PythonWorkflow.
9. Aktualisieren Sie die Geodatabase Metro_Transport, und blenden Sie sie ein.
10. Aktualisieren Sie das Feature-Dataset Metro_Network, und blenden Sie es ein.

    

    Die Geodatabase und das Dataset enthalten die Feature-Classes, die mit dem Koordinatensystem des Datasets übereinstimmen.

Code zum bedingungsabhängigen Projizieren von Feature-Classes hinzufügen

Im letzten Schritt zur Fertigstellung des Skriptes fügen Sie Logik hinzu, um mit dem Werkzeug "Projizieren" die nicht im State Plane-Koordinatensystem von Maryland vorliegenden Feature-Classes zu projizieren und die Ergebnisse in das Feature-Dataset in der neuen Geodatabase zu schreiben.

1. Klicken Sie in IDLE auf das Ende der mit print(f"The feature class beginnenden Codezeile, und drücken Sie die Eingabetaste.
2. Drücken Sie die Rücktaste, um die Einrückung um eine Ebene zu verringern.

   Sie fügen eine else-Anweisung hinzu, die sich auf der gleichen Einrückungsebene wie die vorherige if-Anweisung befinden muss.

   Eine else-Anweisung wird zum Ausführen eines anderen Codeblocks verwendet, wenn die if-Anweisung nicht zutrifft.

3. Fügen Sie in der neuen weniger weit eingerückten Zeile die folgenden Codezeilen hinzu:

   else:
           arcpy.Project_management(fc, new_fc, 2248)
           print(f"The feature class {fc} has been projected.")

   

   Durch die else-Anweisung wird eine logische Verzweigung mit einem Codeblock erstellt, der nach der Überprüfung der if-Anweisung ausgeführt wird, wenn die Bedingung nicht erfüllt ist. Gemäß der Logik wird die Feature-Class kopiert, wenn ihre WKID 2248 lautet, und projiziert, wenn dies nicht der Fall ist.

   Die zweite dieser Zeilen ist um vier Leerzeichen eingerückt, da sie zu dem Codeblock gehört, der in der else-Bedingung ausgeführt wird. Das Werkzeug Projizieren projiziert die Eingabe-Feature-Class in das State Plane-Koordinatensystem für Maryland, und die Ausgabe-Feature-Class wird in der neuen Geodatabase gespeichert. Die Parameter des Werkzeugs Projizieren sind die Eingabe-Feature-Class, die Ausgabe-Feature-Class und das Ausgabekoordinatensystem (für diesen Parameter wird die WKID 2248 verwendet).

   Hinweis:

   Der vierte Parameter des Werkzeugs Projizieren bezieht sich auf eine optionale Transformation. Beim Ausführen des Werkzeugs Projizieren haben Sie gesehen, dass eine Transformation zwischen den geographischen Koordinatensystemen NAD 1983 und WGS 1984 erforderlich ist, die jedoch bei der Ausführung standardmäßig ausgewählt ist. Dies bedeutet, dass es nicht notwendig ist, hier im Code eine Transformation anzugeben.

   Den vorherigen Ergebnissen der Überprüfung des Koordinatensystems aller Feature-Classes können Sie entnehmen, dass die Feature-Classes, die noch nicht im State Plane-Koordinatensystem für Maryland vorliegen, ein bestimmtes geographisches Koordinatensystem aufweisen. Dieses Koordinatensystem muss jedoch nicht angegeben werden. Bei Verwendung einer else-Anweisung wird das Werkzeug Projizieren für alle Feature-Classes ausgeführt, für die die if-Anweisung nicht zutrifft. Das jeweilige Koordinatensystem spielt dabei keine Rolle.

   Nachfolgend finden Sie den vollständigen Code:

   import arcpy
   import os
   mypath = "C:/Lessons/PythonWorkflow"
   gdb = "Transportation.gdb"
   new_gdb = "Metro_Transport.gdb"
   fds = "Metro_Network"
   arcpy.env.workspace = os.path.join(mypath, gdb)
   arcpy.env.overwriteOutput = True
   new_gdb_path = arcpy.CreateFileGDB_management(mypath, new_gdb)
   print(f"The geodatabase {new_gdb} has been created.")
   arcpy.CreateFeatureDataset_management(new_gdb_path, fds, 2248)
   print(f"The feature dataset {fds} has been created.")
   fcs = arcpy.ListFeatureClasses()
   for fc in fcs:
       desc = arcpy.da.Describe(fc)
       sr = desc["spatialReference"]
       new_fc = os.path.join(mypath, new_gdb, fds, fc)
       if sr.factoryCode == 2248:
           arcpy.CopyFeatures_management(fc, new_fc)
           print(f"The feature class {fc} has been copied.")
       else:
           arcpy.Project_management(fc, new_fc, 2248)
           print(f"The feature class {fc} has been projected.")

   

4. Speichern Sie das Skript, und führen Sie es aus.

   Der Code wird ausgeführt. Dabei werden die Geodatabase und das Feature-Dataset erstellt, die fünf Layer mit dem State Plane-Koordinatensystem für Maryland werden kopiert, und die fünf Layer mit dem Koordinatensystem WGS84 werden projiziert.

   

5. Aktualisieren Sie in ArcGIS Pro im Bereich Katalog das Feature-Dataset Metro_Network.

   Das Dataset enthält alle Feature-Classes, die alle das richtige Koordinatensystem aufweisen.

   

   Der Code funktioniert, und Sie könnten jetzt das geometrische Netzwerk erstellen.

Dem Skript Kommentare hinzufügen

Obwohl es sich hier um ein relativ einfaches Skript handelt, sollten Sie dem Code Kommentare hinzufügen, damit er besser verständlich ist. Mit Kommentaren können Sie den Zweck des Skriptes erläutern und auf wichtige Schritte hinweisen. Dadurch können andere Benutzer das Skript leichter verstehen und es für eigene Zwecke ändern. Außerdem können Sie den Code besser verstehen, wenn Sie sich eine Weile nicht mit ihm befassen und ihn dann ändern müssen.

Kommentare beginnen mit mindestens einem Rautenzeichen. Kommentare können am Anfang oder am Ende einer Codezeile hinzugefügt werden.

1. Fügen Sie in IDLE am Anfang des Skriptes eine neue Zeile hinzu.
2. Kopieren Sie den folgenden Kommentar, und fügen Sie ihn in die neue Zeile ein.

   # Author: your name
   # Date: the date
   # Purpose: This script reads all the feature classes in a
   # geodatabase and copies them to a new feature dataset in
   # a new geodatabase. Feature classes not already in the
   # target coordinate system are projected.

3. Bearbeiten Sie die Zeilen Author und Date, um Ihren Namen und das aktuelle Datum hinzuzufügen.
4. Fügen Sie vor der Zeile import arcpy zwei neue Zeilen hinzu, und fügen Sie in der zweiten Zeile den folgenden Kommentar hinzu:

   # Imports

   Die leere Zeile hat keine Auswirkungen auf den Code und verbessert die Lesbarkeit. Aus dem Kommentar geht hervor, dass mit diesem Abschnitt die für den Code benötigten Bibliotheken importiert werden. Importvorgänge werden im Allgemeinen gesammelt in der Nähe des Skriptanfangs platziert.

5. Fügen Sie nach der Zeile import os zwei neue Zeilen hinzu, und fügen Sie den folgenden Kommentar hinzu:

   # Variables for paths, outputs, workspaces

   Aus diesem Kommentar geht hervor, wo diese Variablen anfangs festgelegt werden.

6. Fügen Sie nach der Zeile arcpy.env.overwriteOutput = True zwei neue Zeilen hinzu, und fügen Sie den folgenden Kommentar hinzu:

   # Create a new geodatabase and dataset

7. Fügen Sie vor der Zeile fcs = arcpy.ListFeatureClasses() zwei neue Zeilen hinzu, und fügen Sie den folgenden Kommentar hinzu:

   # Create a list of feature classes in the workspace

8. Fügen Sie nach der Zeile if sr.factoryCode == 2248: den folgenden Kommentar in der gleichen Zeile hinzu:

    # WKID of target coordinate system

   Sie haben Kommentare mit Informationen zum Code hinzugefügt.

   Nachfolgend finden Sie den vollständigen Code:

   # Author: your name
   # Date: the date
   # Purpose: This script reads all the feature classes in a
   # geodatabase and copies them to a new feature dataset in
   # a new geodatabase. Feature classes not already in the
   # target coordinate system are projected.
   
   # Imports
   import arcpy
   import os
   
   # Variables for paths, outputs, workspaces
   mypath = "C:/Lessons/PythonWorkflow"
   gdb = "Transportation.gdb"
   new_gdb = "Metro_Transport.gdb"
   fds = "Metro_Network"
   arcpy.env.workspace = os.path.join(mypath, gdb)
   arcpy.env.overwriteOutput = True
   
   # Create a new geodatabase and dataset
   new_gdb_path = arcpy.CreateFileGDB_management(mypath, new_gdb)
   print(f"The geodatabase {new_gdb} has been created.")
   arcpy.CreateFeatureDataset_management(new_gdb_path, fds, 2248)
   print(f"The feature dataset {fds} has been created.")
   
   # Create a list of feature classes in the workspace
   fcs = arcpy.ListFeatureClasses()
   for fc in fcs:
       desc = arcpy.da.Describe(fc)
       sr = desc["spatialReference"]
       new_fc = os.path.join(mypath, new_gdb, fds, fc)
       if sr.factoryCode == 2248: # WKID of target coordinate system
           arcpy.CopyFeatures_management(fc, new_fc)
           print(f"The feature class {fc} has been copied.")
       else:
           arcpy.Project_management(fc, new_fc, 2248)
           print(f"The feature class {fc} has been projected.")

   

9. Speichern Sie das Skript.

In diesem Lernprogramm haben Sie Folgendes gelernt:

• Python-Skripte können verwendet werden, um wiederkehrende Aufgaben in GIS-Workflows zu automatisieren.
• ArcPy enthält verschiedene Funktionen zum Erstellen von Datasets.
• Indem Sie Datasets mithilfe von Python-Code auflisten und beschreiben, können Sie ein ausführliches Verzeichnis mit GIS-Datasets in einem Workspace erstellen. Danach können Sie die einzelnen Datasets je nach Merkmalen unterschiedlich verarbeiten.
• Gehen Sie beim Ändern von Pfaden und Dateien mit Sorgfalt vor, um richtige Ausgaben zu erhalten.

Auch die Bücher Python Scripting for ArcGIS Pro und Advanced Python Scripting for ArcGIS Pro von Dr. Paul A. Zandbergen, veröffentlicht von Esri Press sind für Sie möglicherweise von Interesse.

Beiträge anderer Softwarehersteller

• Enthält Informationen vom öffentlichen Datenportal von Washington, D.C.