Neuanordnen von Feldern (dauerhaft) in einer File-Geodatabase mithilfe von ArcGIS Desktop?

18

Ist es mit ArcGIS 10.0 möglich, die Felder in einer File-Geodatabase neu anzuordnen, und bleibt die Reihenfolge in der Datenbank erhalten?

Wir überlegten, nach XML zu exportieren und einen Parser zu schreiben, um die Feldreihenfolge zu ändern, und dann eine neue Datenbank aus dem XML-Code zu erstellen. Dies scheint ein mühsamer Prozess zu sein.

Eine andere Idee ist, die vorhandenen Felddefinitionen in Excel zu importieren, sie neu zu ordnen, in CSV zu exportieren und dann ein Python-Skript zu schreiben, um diese Felder in einer neuen Geodatabase zu erstellen. Gibt es ein solches Skript, bevor wir es von Grund auf neu schreiben?

Leider scheint ArcGIS Diagrammer die Nachbestellung von Feldern nicht zu unterstützen.

Gibt es Skripte oder Hacks, mit denen wir diesen Prozess vereinfachen könnten?

arcgis-desktop  arcgis-10.0  esri-geodatabase  arccatalog  schema-architecture 
— Stephen Blei
quelle
8
— PolyGeo
Sie können Felder in ArcGIS Diagrammer neu anordnen. Gehen Sie einfach in die Feldsammlung, wählen Sie das Feld aus und drücken Sie die Aufwärts- / Abwärtspfeile.
— blah238
@ blah238 Wenn du das als Antwort hinzufügen kannst, werde ich es akzeptieren. Es funktioniert sehr gut und wird von Esri halb unterstützt, seit einer ihrer Kollegen es geschrieben hat
— Stephen Lead
1
Hier ist die Video-Demonstration - maps.esri.com/Diagrammer/reorderfields.htm
— Geog

Antworten:

6

Wie in den Kommentaren erwähnt, können Sie Felder mit ArcGIS Diagrammer neu anordnen. Ich habe in dieser Antwort Schritt für Schritt eine allgemeinere Beschreibung veröffentlicht: Wie aktualisiere ich die Eigenschaft length eines Feature-Class-Felds?

— blah238
quelle
Vielen Dank. Die ArcGIS-Diagrammer ist ein bisschen instabil - sie stürzt nicht gerade ab, fühlt sich aber manchmal wie hausgemacht an. Zum Ändern des Schemas ist dies jedoch die beste Option.
— Stephen Lead
Könnte jetzt nach 10.0 funktionieren. Die Installation unter Win7 x64 mit ArcGIS 10.1 ist für mich in Ordnung, aber wenn sie ausgeführt wird, treten Just In Time-Kompilierungsfehler auf, und das Programm wird beendet.
— Matt Wilkie
1
Beachten Sie, dass ArcGIS Diagrammer mit ArcGIS 10.3 oder höher nicht mehr funktioniert.
— Map Man
7

In Antwort auf eine andere Frage , sagte ich , dass es möglich ist , zu verwenden Zusammenfassung Statistiken das Äquivalent von PULLITEMS (alt sprechen für Neuordnungsfelder) zu tun. Diese Technik funktioniert nur für Tabellen, aber es gibt jetzt ein anderes Skript , das besagt, dass es sowohl für Feature-Classes als auch für Tabellen funktioniert.

Ich würde auch empfehlen, die Antwort auf das erneute Anordnen von Feldern mit dem ArcGIS-Werkzeug "Abfragetabelle erstellen" dauerhaft zu ändern. Das war inspiriert von @klewis 'Antwort auf diese Frage.

— PolyGeo
quelle
6

Die kostenlose Version von ET Geowizards wird dies tun. Grundlegend -> Formen sortieren. Ich habe es gerade auf einer File-Geodatabase der Version 10 getestet und es funktioniert. Es muss jedoch eine neue Feature-Class erstellt werden.

— pgager
quelle
5

Wenn Sie Visio für Diagramer nicht haben - Alle anderen Antworten hier unterbrechen alle Verknüpfungen. Ich fand, dass dies in meinem Fall gut funktioniert:

  1. Exportieren Sie das Schema für die gesamte Datenbank mit Arccatalog (Export - XML) - Ich habe die Daten nicht exportiert, sondern nur das Schema
  2. Verwenden Sie einen Pretty Print-Onlinedienst zum Formatieren der XML-Datei. Öffnen Sie die XML-Datei in einem Texteditor und ordnen Sie die Felder nach Ihren Wünschen neu an
  3. Importieren Sie das Schema erneut, um eine neue Datenbank zu erstellen
  4. Laden Sie die Daten mit der Originaldatenbank als Quelle neu
— Ozmo
quelle
Ich habe das in der ursprünglichen Frage als "mühsamen Prozess" abgetan - aber tatsächlich, wenn man es so formuliert, hört es sich nicht schlecht an;)
— Stephen Lead
4

Sie müssen MakeTableQuery über das Toolset Layer und Tabellenansichten ausführen, um die Felder neu anzuordnen. In der Dokumentation gibt die Reihenfolge der Felder in der Feldliste die Reihenfolge an, in der die Felder in der Ausgabeebene oder in der Tabellenansicht angezeigt werden. Wenn der Feldliste eine Formspalte hinzugefügt wird, ist das Ergebnis eine Ebene. Andernfalls handelt es sich um eine Tabellenansicht. Dies ist mit jeder Lizenzstufe möglich.

— klewis
quelle
Ich frage mich nur, ob Sie dies getestet haben, da ich keine Möglichkeit sehe, wie das Werkzeug Abfragetabelle erstellen die Felder neu anordnet. Im Werkzeugdialog können Sie nur entscheiden, ob Felder eingeschlossen werden sollen oder nicht.
— PolyGeo
Ja, ich habe dies mit einem Python-Skript getestet. Das Tool scheint so konzipiert zu sein, dass es mehrere Tabellen kombiniert oder verknüpft. Ich kann jedoch eine neue Tabelle oder Feature-Class mit neu angeordneten Feldern erstellen, indem ich eine einzelne Feature-Class eingebe.
— Klewis
Ich muss etwas vermissen, also habe ich hier eine neue Frage gestellt. Gis.stackexchange.com/questions/32310/… - können Sie mir bitte die Schritte dort erläutern?
— PolyGeo
Ich habe gerade die neue Frage beantwortet, indem ich nicht nur MakeQueryTable, sondern auch CopyFeatures und einige geringfügige Änderungen von Code verwendet habe, die ich mit Copy As Python Snippet im Python-Fenster erhalten habe.
— PolyGeo
4

Mit dem Merge-Tool können Sie Felder einfach dauerhaft neu anordnen. Es funktioniert mit Tabellen und Feature-Classes. Die Neuordnung kann über ein Python-Skript und sogar über das Werkzeug-Dialogfeld erfolgen (indem ein Feld entfernt und im Dialogfeld erneut hinzugefügt wird). Eine Nachbestellung über den Dialog ist jedoch kein perfekter Ansatz.

Es wird empfohlen, das Zusammenführungs-Tool einmal zu verwenden und dann Als Python-Snippet kopieren zu verwenden und dann die Feldreihenfolge manuell zu ändern und dann den Python-Code in Python-Fenster einzufügen.

Hier ist ein Python-Skript, das das Merge-Tool verwendet, um Felder neu anzuordnen (von hier kopiert ).

import arcpy

def reorder_fields(table, out_table, field_order, add_missing=True):
    """ 
    Reorders fields in input featureclass/table
    :table:         input table (fc, table, layer, etc)
    :out_table:     output table (fc, table, layer, etc)
    :field_order:   order of fields (objectid, shape not necessary)
    :add_missing:   add missing fields to end if True (leave out if False)
    -> path to output table
    """
    existing_fields = arcpy.ListFields(table)
    existing_field_names = [field.name for field in existing_fields]

    existing_mapping = arcpy.FieldMappings()
    existing_mapping.addTable(table)

    new_mapping = arcpy.FieldMappings()

    def add_mapping(field_name):
        mapping_index = existing_mapping.findFieldMapIndex(field_name)

        # required fields (OBJECTID, etc) will not be in existing mappings
        # they are added automatically
        if mapping_index != -1:
            field_map = existing_mapping.fieldMappings[mapping_index]
            new_mapping.addFieldMap(field_map)

    # add user fields from field_order
    for field_name in field_order:
        if field_name not in existing_field_names:
            raise Exception("Field: {0} not in {1}".format(field_name, table))

        add_mapping(field_name)

    # add missing fields at end
    if add_missing:
        missing_fields = [f for f in existing_field_names if f not in field_order]
        for field_name in missing_fields:
            add_mapping(field_name)

    # use merge with single input just to use new field_mappings
    arcpy.Merge_management(table, out_table, new_mapping)
    return out_table

VERWENDUNG:

new_field_order = ["field2", "field3", "field1"]
reorder_fields(in_fc, out_fc, new_field_order)
— Farid Cheraghi
quelle
Das scheint in dem Werkzeugdialog gut zu funktionieren, in dem ich zuerst ein Feld gelöscht habe, das ich als letztes verschieben wollte, ein neues Feld hinzugefügt und dann Eingabefeld hinzugefügt habe. Wie Sie bereits sagten, ist die Verwendung in Python jedoch einfacher als über das Tool, wenn komplexere Nachbestellungen erforderlich sind.
— PolyGeo
3

Es gibt eine kostenlose Erweiterung von Esri namens X-Ray, die ein Werkzeug enthält, mit dem Felder neu angeordnet werden können. Hat bei uns super geklappt und ist einfach zu bedienen.

Mit dem X-Ray-Add-In für ArcCatalog können Sie Ihre Geodatabase-Designs entwickeln, verfeinern und dokumentieren

— Kennzeichen
quelle
Willkommen bei GIS Stack Exchange und vielen Dank für den Tipp. Ich habe Ihre Antwort neu formatiert, um sie den Stack Exchange-Standards anzupassen. Ich habe einen Link und ein Zitat zum Produkt hinzugefügt und überflüssige Informationen entfernt.
— Stephen Lead
2

Die bisher effizienteste Methode, Felder umzubenennen, ihre Standardreihenfolge zu ändern und eine Reihe anderer Dinge zu tun, ist die Verwendung von Microsoft Access:

  1. Neue Personal Geodatabase erstellen
  2. Ziehen Sie die Feature-Class oder Tabelle in die p-gdb und legen Sie sie dort ab
  3. In Access öffnen und:
    • Wenn Sie alle beginnenden GDB_Tabellen ignorieren , öffnen Sie die Tabellen im Tabellenentwurfsmodus
    • umbenennen, Reihenfolge ändern, neue hinzufügen usw.
  4. Ziehen Sie und legen Sie zurück zu Ihrem realen Betriebs-GDB

Anmerkungen:

Immer einen aktuellen Backup haben. Sie arbeiten direkt mit der internen GDB-Struktur und können Ihre Daten leicht in den Papierkorb werfen, indem Sie die DB so ändern, dass ArcGIS nicht mehr weiß, wie sie gelesen werden soll.

Auf der ArcGIS-Seite sind einige Schlüsselwörter reserviert , die nicht für Feldnamen verwendet werden können. Access erstellt gerne Felder mit diesen Schlüsselwörtern oder benennt sie um. Wenn Sie sie jedoch zurückholen, wird automatisch ein Unterstrich angehängt. So Currentwird es Current_. Beachten Sie auch dort die teilweise überlappenden reservierten Access-Schlüsselwörter .

Personal GDB hat eine Dateigrößenbeschränkung von 2 GB, sodass die Gesamtgröße aller Tabellen und Feature-Classes in der GDB diese Grenze nicht überschreiten darf.

Es kann verlockend sein, für kleine Projekte (<2 GB) immer persönliche GDBs zu verwenden. Nicht. Die Leistung ist miserabel und es gibt geringfügige Unterschiede in der SQL-Syntax von Access, die Label-Ausdrücke, Definitionsabfragen usw. nicht portierbar machen.

— Matt Wilkie
quelle
Natürlich ist diese Methode nicht offiziell sanktioniert, und wenn etwas schief geht, können Sie den technischen Support nicht anrufen;)
— Stephen Lead
2

Dieses Python-Skript ist eine Art "Klebeband" -Methode dafür. Es ist auf 20 Felder begrenzt, kann jedoch problemlos hinzugefügt werden, damit es für alle Felder Ihrer Daten ausgeführt werden kann.

Das Skript kann als Skriptwerkzeug ausgeführt werden, sodass Sie Parameter in ArcCatalog einrichten müssen.

Die Parameter sollten wie folgt lauten:

  • InputFC - Feature Class
  • Ausgabeort - Arbeitsbereich
  • Ausgabename - Zeichenfolge
  • Field1 - Feld
  • Field2 - Feld
  • Bis nach Field20

Code:

import arcpy, os, sys
from arcpy import env

arcpy.env.overwriteOutput = True

inFC = arcpy.GetParameterAsText(0)
outLoc = arcpy.GetParameterAsText(1)
outName = arcpy.GetParameterAsText(2)
field1 = arcpy.GetParameterAsText(3)
field2 = arcpy.GetParameterAsText(4)
field3 = arcpy.GetParameterAsText(5)
field4 = arcpy.GetParameterAsText(6)
field5 = arcpy.GetParameterAsText(7)
field6 = arcpy.GetParameterAsText(8)
field7 = arcpy.GetParameterAsText(9)
field8 = arcpy.GetParameterAsText(10)
field9 = arcpy.GetParameterAsText(11)
field10 = arcpy.GetParameterAsText(12)
field11 = arcpy.GetParameterAsText(13)
field12 = arcpy.GetParameterAsText(14)
field13 = arcpy.GetParameterAsText(15)
field14 = arcpy.GetParameterAsText(16)
field15 = arcpy.GetParameterAsText(17)
field16 = arcpy.GetParameterAsText(18)
field17 = arcpy.GetParameterAsText(19)
field18 = arcpy.GetParameterAsText(20)
field19 = arcpy.GetParameterAsText(21)
field20 = arcpy.GetParameterAsText(22)

fieldList = ["SHAPE@"]

arcpy.AddMessage(" ")

arcpy.AddMessage("Appending field choices to new List ")

arcpy.AddMessage(" ")

if (field1 != ""):
    fieldList.append(field1)
if (field2 != ""):
    fieldList.append(field2)
if (field3 != ""):
    fieldList.append(field3)
if (field4 != ""):
    fieldList.append(field4)
if (field5 != ""):
    fieldList.append(field5)
if (field6 != ""):
    fieldList.append(field6)
if (field7 != ""):
    fieldList.append(field7)
if (field8 != ""):
    fieldList.append(field8)
if (field9 != ""):
    fieldList.append(field9)
if (field10 != ""):
    fieldList.append(field10)
if (field11 != ""):
    fieldList.append(field1)
if (field12 != ""):
    fieldList.append(field12)
if (field13 != ""):
    fieldList.append(field13)
if (field14 != ""):
    fieldList.append(field14)
if (field15 != ""):
    fieldList.append(field15)
if (field16 != ""):
    fieldList.append(field16)
if (field17 != ""):
    fieldList.append(field17)
if (field18 != ""):
    fieldList.append(field18)
if (field19 != ""):
    fieldList.append(field19)
if (field20 != ""):
    fieldList.append(field20)

arcpy.AddMessage(" ")

#arcpy.AddMessage(fieldList)

oldFieldList = arcpy.ListFields(inFC)

fieldTypes = []

numOfFields = len(fieldList)

fieldIndex = 1

reorderedFields = []

for fld in fieldList:
    for f in oldFieldList:
        if f.name == fld:
            arcpy.AddMessage(f.name)
            reorderedFields.append(f)
            break

arcpy.AddMessage(" ")

arcpy.AddMessage(reorderedFields)

desc = arcpy.Describe(inFC)
geoType = desc.shapeType.upper()
spatRef = arcpy.Describe(inFC).spatialReference

arcpy.CreateFeatureclass_management(outLoc, outName, geoType, "", "", "", spatRef)
newFeat = os.path.join(outLoc, outName)

for flds in reorderedFields:
    if (flds.type == "String"):
        fLength = flds.length
        arcpy.AddField_management(newFeat, flds.name, flds.type, "", "", str(fLength))
    else:
        arcpy.AddField_management(newFeat, flds.name, flds.type)

arcpy.AddMessage(" ")

arcpy.AddMessage(fieldList)

arcpy.AddMessage(" ")

arcpy.AddMessage("Features will be copied with new Schema...")

count = 0

with arcpy.da.SearchCursor(inFC, fieldList) as cursor:
    for row in cursor:
        insertCursor = arcpy.da.InsertCursor(newFeat, (fieldList))
        if (numOfFields == 21):
            insertCursor.insertRow((row[0], row[1], row[2], row[3], row[4], row[5], row[6], row[7], row[8], row[9], row[10], row[11], row[12], row[13], row[14], row[15], row[16], row[17], row[18], row[19], row[20]))
            arcpy.AddMessage(" ")
            arcpy.AddMessage("Index: " + str(count) + " -----> " + str(row[1]) + ', ' + str(row[2]) + ', ' + str(row[3]) + ', ' + str(row[4]) + ', ' + str(row[5]) + ', ' + str(row[6]) + ', ' + str(row[7]) + ', ' + str(row[8]) + ', ' + str(row[9]) + ', ' + str(row[10]) + ', ' + str(row[11]) + ', ' + str(row[12]) + ', ' + str(row[13]) + ', ' + str(row[14]) + ', ' + str(row[15]) + ', ' + str(row[16]) + ', ' + str(row[17]) + ', ' + str(row[18]) + ', ' + str(row[19]) + ', ' + str(row[20]))
            count += 1
        elif (numOfFields == 20):
            insertCursor.insertRow((row[0], row[1], row[2], row[3], row[4], row[5], row[6], row[7], row[8], row[9], row[10], row[11], row[12], row[13], row[14], row[15], row[16], row[17], row[18], row[19]))
            arcpy.AddMessage(" ")
            arcpy.AddMessage("Index: " + str(count) + " -----> " + str(row[1]) + ', ' + str(row[2]) + ', ' + str(row[3]) + ', ' + str(row[4]) + ', ' + str(row[5]) + ', ' + str(row[6]) + ', ' + str(row[7]) + ', ' + str(row[8]) + ', ' + str(row[9]) + ', ' + str(row[10]) + ', ' + str(row[11]) + ', ' + str(row[12]) + ', ' + str(row[13]) + ', ' + str(row[14]) + ', ' + str(row[15]) + ', ' + str(row[16]) + ', ' + str(row[17]) + ', ' + str(row[18]) + ', ' + str(row[19]))
            count += 1
        elif (numOfFields == 19):
            insertCursor.insertRow((row[0], row[1], row[2], row[3], row[4], row[5], row[6], row[7], row[8], row[9], row[10], row[11], row[12], row[13], row[14], row[15], row[16], row[17], row[18]))
            arcpy.AddMessage(" ")
            arcpy.AddMessage("Index: " + str(count) + " -----> " + str(row[1]) + ', ' + str(row[2]) + ', ' + str(row[3]) + ', ' + str(row[4]) + ', ' + str(row[5]) + ', ' + str(row[6]) + ', ' + str(row[7]) + ', ' + str(row[8]) + ', ' + str(row[9]) + ', ' + str(row[10]) + ', ' + str(row[11]) + ', ' + str(row[12]) + ', ' + str(row[13]) + ', ' + str(row[14]) + ', ' + str(row[15]) + ', ' + str(row[16]) + ', ' + str(row[17]) + ', ' + str(row[18]))
            count += 1
        elif (numOfFields == 18):
            insertCursor.insertRow((row[0], row[1], row[2], row[3], row[4], row[5], row[6], row[7], row[8], row[9], row[10], row[11], row[12], row[13], row[14], row[15], row[16], row[17]))
            arcpy.AddMessage(" ")
            arcpy.AddMessage("Index: " + str(count) + " -----> " + str(row[1]) + ', ' + str(row[2]) + ', ' + str(row[3]) + ', ' + str(row[4]) + ', ' + str(row[5]) + ', ' + str(row[6]) + ', ' + str(row[7]) + ', ' + str(row[8]) + ', ' + str(row[9]) + ', ' + str(row[10]) + ', ' + str(row[11]) + ', ' + str(row[12]) + ', ' + str(row[13]) + ', ' + str(row[14]) + ', ' + str(row[15]) + ', ' + str(row[16]) + ', ' + str(row[17]))
            count += 1
        elif (numOfFields == 17):
            insertCursor.insertRow((row[0], row[1], row[2], row[3], row[4], row[5], row[6], row[7], row[8], row[9], row[10], row[11], row[12], row[13], row[14], row[15], row[16]))
            arcpy.AddMessage(" ")
            arcpy.AddMessage("Index: " + str(count) + " -----> " + str(row[1]) + ', ' + str(row[2]) + ', ' + str(row[3]) + ', ' + str(row[4]) + ', ' + str(row[5]) + ', ' + str(row[6]) + ', ' + str(row[7]) + ', ' + str(row[8]) + ', ' + str(row[9]) + ', ' + str(row[10]) + ', ' + str(row[11]) + ', ' + str(row[12]) + ', ' + str(row[13]) + ', ' + str(row[14]) + ', ' + str(row[15]) + ', ' + str(row[16]))
            count += 1
        elif (numOfFields == 16):
            insertCursor.insertRow((row[0], row[1], row[2], row[3], row[4], row[5], row[6], row[7], row[8], row[9], row[10], row[11], row[12], row[13], row[14], row[15]))
            arcpy.AddMessage(" ")
            arcpy.AddMessage("Index: " + str(count) + " -----> " + str(row[1]) + ', ' + str(row[2]) + ', ' + str(row[3]) + ', ' + str(row[4]) + ', ' + str(row[5]) + ', ' + str(row[6]) + ', ' + str(row[7]) + ', ' + str(row[8]) + ', ' + str(row[9]) + ', ' + str(row[10]) + ', ' + str(row[11]) + ', ' + str(row[12]) + ', ' + str(row[13]) + ', ' + str(row[14]) + ', ' + str(row[15]))
            count += 1
        elif (numOfFields == 15):
            insertCursor.insertRow((row[0], row[1], row[2], row[3], row[4], row[5], row[6], row[7], row[8], row[9], row[10], row[11], row[12], row[13], row[14]))
            arcpy.AddMessage(" ")
            arcpy.AddMessage("Index: " + str(count) + " -----> " + str(row[1]) + ', ' + str(row[2]) + ', ' + str(row[3]) + ', ' + str(row[4]) + ', ' + str(row[5]) + ', ' + str(row[6]) + ', ' + str(row[7]) + ', ' + str(row[8]) + ', ' + str(row[9]) + ', ' + str(row[10]) + ', ' + str(row[11]) + ', ' + str(row[12]) + ', ' + str(row[13]) + ', ' + str(row[14]))
            count += 1
        elif (numOfFields == 14):
            insertCursor.insertRow((row[0], row[1], row[2], row[3], row[4], row[5], row[6], row[7], row[8], row[9], row[10], row[11], row[12], row[13]))
            arcpy.AddMessage(" ")
            arcpy.AddMessage("Index: " + str(count) + " -----> " + str(row[1]) + ', ' + str(row[2]) + ', ' + str(row[3]) + ', ' + str(row[4]) + ', ' + str(row[5]) + ', ' + str(row[6]) + ', ' + str(row[7]) + ', ' + str(row[8]) + ', ' + str(row[9]) + ', ' + str(row[10]) + ', ' + str(row[11]) + ', ' + str(row[12]) + ', ' + str(row[13]))
            count += 1
        elif (numOfFields == 13):
            insertCursor.insertRow((row[0], row[1], row[2], row[3], row[4], row[5], row[6], row[7], row[8], row[9], row[10], row[11], row[12]))
            arcpy.AddMessage(" ")
            arcpy.AddMessage("Index: " + str(count) + " -----> " + str(row[1]) + ', ' + str(row[2]) + ', ' + str(row[3]) + ', ' + str(row[4]) + ', ' + str(row[5]) + ', ' + str(row[6]) + ', ' + str(row[7]) + ', ' + str(row[8]) + ', ' + str(row[9]) + ', ' + str(row[10]) + ', ' + str(row[11]) + ', ' + str(row[12]))
            count += 1
        elif (numOfFields == 12):
            insertCursor.insertRow((row[0], row[1], row[2], row[3], row[4], row[5], row[6], row[7], row[8], row[9], row[10], row[11]))
            arcpy.AddMessage(" ")
            arcpy.AddMessage("Index: " + str(count) + " -----> " + str(row[1]) + ', ' + str(row[2]) + ', ' + str(row[3]) + ', ' + str(row[4]) + ', ' + str(row[5]) + ', ' + str(row[6]) + ', ' + str(row[7]) + ', ' + str(row[8]) + ', ' + str(row[9]) + ', ' + str(row[10]) + ', ' + str(row[11]))
            count += 1
        elif (numOfFields == 11):
            insertCursor.insertRow((row[0], row[1], row[2], row[3], row[4], row[5], row[6], row[7], row[8], row[9], row[10]))
            arcpy.AddMessage(" ")
            arcpy.AddMessage("Index: " + str(count) + " -----> " + str(row[1]) + ', ' + str(row[2]) + ', ' + str(row[3]) + ', ' + str(row[4]) + ', ' + str(row[5]) + ', ' + str(row[6]) + ', ' + str(row[7]) + ', ' + str(row[8]) + ', ' + str(row[9]) + ', ' + str(row[10]))
            count += 1
        elif (numOfFields == 10):
            insertCursor.insertRow((row[0], row[1], row[2], row[3], row[4], row[5], row[6], row[7], row[8], row[9]))
            arcpy.AddMessage(" ")
            arcpy.AddMessage("Index: " + str(count) + " -----> " + str(row[1]) + ', ' + str(row[2]) + ', ' + str(row[3]) + ', ' + str(row[4]) + ', ' + str(row[5]) + ', ' + str(row[6]) + ', ' + str(row[7]) + ', ' + str(row[8]) + ', ' + str(row[9]))
            count += 1
        elif (numOfFields == 9):
            insertCursor.insertRow((row[0], row[1], row[2], row[3], row[4], row[5], row[6], row[7], row[8]))
            arcpy.AddMessage(" ")
            arcpy.AddMessage("Index: " + str(count) + " -----> " + str(row[1]) + ', ' + str(row[2]) + ', ' + str(row[3]) + ', ' + str(row[4]) + ', ' + str(row[5]) + ', ' + str(row[6]) + ', ' + str(row[7]) + ', ' + str(row[8]))
            count += 1
        elif (numOfFields == 8):
            insertCursor.insertRow((row[0], row[1], row[2], row[3], row[4], row[5], row[6], row[7]))
            arcpy.AddMessage(" ")
            arcpy.AddMessage("Index: " + str(count) + " -----> " + str(row[1]) + ', ' + str(row[2]) + ', ' + str(row[3]) + ', ' + str(row[4]) + ', ' + str(row[5]) + ', ' + str(row[6]) + ', ' + str(row[7]))
            count += 1
        elif (numOfFields == 7):
            insertCursor.insertRow((row[0], row[1], row[2], row[3], row[4], row[5], row[6]))
            arcpy.AddMessage(" ")
            arcpy.AddMessage("Index: " + str(count) + " -----> " + str(row[1]) + ', ' + str(row[2]) + ', ' + str(row[3]) + ', ' + str(row[4]) + ', ' + str(row[5]) + ', ' + str(row[6]))
            count += 1
        elif (numOfFields == 6):
            insertCursor.insertRow((row[0], row[1], row[2], row[3], row[4], row[5]))
            arcpy.AddMessage(" ")
            arcpy.AddMessage("Index: " + str(count) + " -----> " + str(row[1]) + ', ' + str(row[2]) + ', ' + str(row[3]) + ', ' + str(row[4]) + ', ' + str(row[5]))
            count += 1
        elif (numOfFields == 5):
            insertCursor.insertRow((row[0], row[1], row[2], row[3], row[4]))
            arcpy.AddMessage(" ")
            arcpy.AddMessage("Index: " + str(count) + " -----> " + str(row[1]) + ', ' + str(row[2]) + ', ' + str(row[3]) + ', ' + str(row[4]))
            count += 1
        elif (numOfFields == 4):
            insertCursor.insertRow((row[0], row[1], row[2], row[3]))
            arcpy.AddMessage(" ")
            arcpy.AddMessage("Index: " + str(count) + " -----> " + str(row[1]) + ', ' + str(row[2]) + ', ' + str(row[3]))
            count += 1
        elif (numOfFields == 3):
            insertCursor.insertRow((row[0], row[1], row[2]))
            arcpy.AddMessage(" ")
            arcpy.AddMessage("Index: " + str(count) + " -----> " + str(row[1]) + ', ' + str(row[2]))
            count += 1
        elif (numOfFields == 2):
            insertCursor.insertRow((row[0], row[1]))
            arcpy.AddMessage(" ")
            arcpy.AddMessage("Index: " + str(count) + " -----> " + str(row[1]))
            count += 1

Mir ist klar, dass dies nicht der schönste oder effizienteste Weg ist, aber es funktioniert tatsächlich ganz gut und es dauerte nur ungefähr eine halbe Stunde, um es zu schreiben. Ich benutze dies die ganze Zeit, wenn ich Felder neu anordnen muss, und es erfordert weder Diagrammer noch Microsoft Access. Natürlich kann die maximale Anzahl von Feldern ein Problem sein, aber auch dies kann innerhalb des Skripts angepasst werden.

— GeoJohn
quelle
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.