I metodi più veloci per modificare le tabelle degli attributi con Python?

Qualche tempo fa, ho scritto una rapida funzione Python per convertire una tabella di attributi in un dizionario python, in cui la chiave è presa da un campo ID univoco specificato dall'utente (in genere il campo OID). Inoltre, per impostazione predefinita tutti i campi vengono copiati nel dizionario, ma ho incluso un parametro che consente di specificare solo un sottoinsieme.

def make_attribute_dict(fc, key_field, attr_list=['*']):
    dict = {}
    fc_field_objects = arcpy.ListFields(fc)
    fc_fields = [field.name for field in fc_field_objects if field.type != 'Geometry']
    if attr_list == ['*']:
        valid_fields = fc_fields
    else:
        valid_fields = [field for field in attr_list if field in fc_fields]
    if key_field not in valid_fields:
        cursor_fields = valid_fields + [key_field]
    else:
        cursor_fields = valid_fields
    with arcpy.da.SearchCursor(fc, cursor_fields) as cursor:
        for row in cursor:
            key = row[cursor_fields.index(key_field)]
            subdict = {}
            for field in valid_fields:
                subdict[field] = row[cursor_fields.index(field)]
            dict[key] = subdict
            del subdict
    return dict

Funziona benissimo per set di dati relativamente piccoli, ma l'ho appena eseguito su una tabella contenente circa 750.000 righe e 15 campi - circa 100 MB in un geodatabase di file. Su questi, la funzione funziona molto più lentamente di quanto mi aspettassi: circa 5-6 minuti (e questo dopo aver copiato la tabella in_memorynell'area di lavoro). Mi piacerebbe davvero trovare un modo per accelerare la conversione in dizionario o ottenere informazioni su una strategia migliore per la manipolazione di grandi quantità di dati di attributi utilizzando Python.

UpdateCursors non funzionerà bene per me, perché quando cambia una riga, ha il potenziale per innescare cambiamenti in molti altri. Effettuare il ciclo e processarli uno alla volta è troppo ingombrante per quello di cui ho bisogno.

Penso che il problema sia probabilmente le tue due righe in cui stai andando oltre i campi e aggiungendo ogni campo singolarmente al tuo subdictdizionario.

for field in valid_fields:
    subdict[field] = row[cursor_fields.index(field)]

Il tuo rowoggetto è già una tupla nello stesso ordine dei campi, approfittane e usa la zipfunzione.

def make_attribute_dict(fc, key_field, attr_list=['*']):
    attdict = {}
    fc_field_objects = arcpy.ListFields(fc)
    fc_fields = [field.name for field in fc_field_objects if field.type != 'Geometry']
    if attr_list == ['*']:
        valid_fields = fc_fields
    else:
        valid_fields = [field for field in attr_list if field in fc_fields]
    #Ensure that key_field is always the first field in the field list
    cursor_fields = [key_field] + list(set(valid_fields) - set([key_field]))
    with arcpy.da.SearchCursor(fc, cursor_fields) as cursor:
        for row in cursor:
            attdict[row[0]] = dict(zip(cursor.fields,row))
    return attdict

Ciò ha funzionato attraverso una classe di funzionalità di geodatabase di file di campo 16 record 218k in 8 secondi sul mio sistema.

Modifica: ho provato un test più rigoroso. 518k record su una connessione SDE remota con 16 campi tra cui OBJECTID e Shape, eseguiti a 32 bit. 11 secondi :)