¿Cómo utilizan las personas las estructuras de datos de Python y las clases en ArcPy?

Esta pregunta puede exponer mi ignorancia sobre la programación, pero tengo curiosidad acerca de cómo las personas usan diferentes estructuras de datos de Python dentro de ArcPy.

Esta página enumera las estructuras de datos en Python. Entiendo cómo se pueden implementar listas en SIG (lista de clases de entidad, lista de tipos de entidad, lista de marcos de datos, etc.). Entiendo cómo se pueden usar los conjuntos también (para eliminar duplicados). ¿Cómo implementan las personas tuplas, diccionarios y otras estructuras de datos dentro de ArcPy? Además, ¿hay otros ejemplos de listas y conjuntos que no haya enumerado?

Además, sin duda, las personas están creando clases personalizadas en ArcPy. ¿En qué circunstancias y situaciones los necesita? ¿Puedes dar ejemplos? ¿Alguien está creando clases personalizadas que heredan de las clases integradas de arcpy?

No necesito respuestas a todas estas preguntas, solo tengo curiosidad por saber cómo las personas usan Python en SIG y qué flujos de trabajo requieren estas personalizaciones.

Muchas funciones arcpy que toman múltiples entradas aceptan objetos de lista de Python.

Por ejemplo, la Dissolve_managementfunción acepta una lista de nombres de campo para disolver:

arcpy.Dissolve_management("taxlots", "C:/output/output.gdb/taxlots_dissolved",
    ["LANDUSE", "TAXCODE"], "", "SINGLE_PART", "DISSOLVE_LINES")

Se puede usar una tupla en lugar de una lista cuando no es necesario modificar el orden o la cantidad de elementos, ya que las tuplas son inmutables . Son una estructura de datos útil para datos heterogéneos pero relacionados, como los elementos de una marca de tiempo o las coordenadas de un punto. A menudo verá listas de tuplas, donde una tupla sirve como un registro distinto con un número fijo de atributos, mientras que la lista podría cambiar fácilmente el tamaño, reordenarse (clasificarse), etc. Consulte esta pregunta de StackOverflow para obtener más información sobre los usos de listas contra tuplas.

Un diccionario se puede usar como una tabla de búsqueda rápida para almacenar en caché un conjunto relativamente pequeño pero de uso frecuente de pares clave-valor en la memoria. Vi un ejemplo interesante de esto en los foros de ArcGIS: http://forums.arcgis.com/threads/55099-Update-cursor-with-joined-tables-work-around-w-dictionaries

El uso de un diccionario en lugar de una combinación aceleró su cálculo de 3,5 horas a 15 minutos.

Un ejemplo más simple podría ser si tiene un millón de registros de direcciones con un atributo con el nombre de estado abreviado (CA), pero para fines de visualización que desea deletrear el nombre propio (California), podría usar este diccionario como una tabla de búsqueda cuando rellenando un campo de nombre de estado completo.

No he encontrado la necesidad de escribir una clase en Python para usar en arcpy, pero eso no quiere decir que no haya tal caso de uso. Una clase puede ser útil cuando tiene un conjunto de funciones estrechamente relacionadas (comportamientos) que operan en alguna entrada (datos), y desea poder usar esos datos y comportamientos de una manera orientada a objetos, pero esto es más probablemente será específico de la lógica de negocios y no estará relacionado con arcpy.

Blah238 cubre bien este tema, así que solo agregaré un par de ejemplos de mi propio trabajo. Desarrollo muchos datos del aeropuerto, y una de las cosas que tengo que hacer regularmente es leer en orden a lo largo de los puntos de la línea central de la pista encuestada desde una pista. Pensaría que estos puntos ya estarían en orden (en la base de datos SIG), pero rara vez lo están. Los puntos de la línea central ocurren cada 10 pies a lo largo de la línea central y están flanqueados a ambos lados por otras dos filas de puntos de levantamiento espaciados a 10 pies de distancia. Obtienes la imagen: una gran cantidad de puntos ... y generalmente todos mezclados en base de datos. Con lo que estoy haciendo en mis scripts, generalmente es más fácil seleccionar los puntos de la línea central por atributos (o espacialmente si es necesario), leer las coordenadas para cada uno y volcar los resultados en una lista de Python. Entonces puedo ordenar, hacer estallar, invertir, etc.

Del mismo modo, uso extensivamente los diccionarios de Python (probablemente mucho más de lo que algunos aprobarían). Tengo que crear conjuntos de vectores de unidades 3D para cada final de pista en un aeropuerto, y accedo a estos constantemente dentro de un guión y hago esto en muchos de mis guiones. También mantengo muchos otros conjuntos de datos a los que se accede regularmente en los diccionarios. Al igual que las listas, son rápidas y flexibles. Muy recomendable.

En cuanto a las clases, como Blah238, no he encontrado la necesidad de crear ninguna. Probablemente hay algunos casos en los que se preferiría una clase en mis scripts, pero realmente no he podido identificar esos lugares. Alguien con más experiencia en programación probablemente los encontraría rápidamente.

Yo también amo los diccionarios, úsalos todo el tiempo. Este método obtiene algunas propiedades de referencia espacial y lo almacena todo en un dict:

def get_coord_sys(self, in_dataset):
    """Get and return info on dataset coord sys/projection"""
    spatial_ref = arcpy.Describe(in_dataset).spatialReference
    # Get spatial ref props and put in dictionary
    spat_ref_dict = {}
    spat_ref_dict["name"] = spatial_ref.name
    spat_ref_dict["type"] = spatial_ref.type
    spat_ref_dict["gcs_code"] = spatial_ref.GCSCode
    spat_ref_dict["gcs_name"] = spatial_ref.GCSName
    spat_ref_dict["pcs_code"] = spatial_ref.PCSCode
    spat_ref_dict["pcs_name"] = spatial_ref.PCSName
    return spat_ref_dict

Este fragmento de método extrae geometrías de puntos de dos clases de características, luego uso las geometrías más adelante para hacer algunos trigonometrajes:

def build_fields_of_view(self):
        """For all KOPs in a study area, build left, right, center FoV triangles"""
        try:    
            fcs = {os.path.join(self.gdb, "WindFarmArray"):[], os.path.join(self.gdb, "KOPs"):[]}
            # Build a dict of WTG and KOP array geometries, looks like:
            #  {'KOPs': [[1, -10049.2697098718, 10856.699451165374], 
            #            [2, 6690.4377855260946, 15602.12386816188]], 
            #   'WindFarmArray': [[1, 5834.9321158060666, 7909.3822339441513], 
            #                     [2, 6111.1759513214511, 7316.9684107396561]]}
            for k, v in fcs.iteritems():
                rows = arcpy.SearchCursor(k, "", self.sr)
                for row in rows:
                    geom = row.shape
                    point = geom.getPart()
                    id = row.getValue("OBJECTID")
                    v.append([id, point.X, point.Y])   

            kops = fcs[os.path.join(self.gdb, "KOPs")] # KOP array
            wtgs = fcs[os.path.join(self.gdb, "WindFarmArray")] # WTG array

MUCHO de lo que estoy trabajando actualmente consiste en extraer las coordenadas y los atributos de las clases de entidad de vector y los rásteres para que los datos puedan insertarse en otro software que ni siquiera sabe qué son los datos SIG. Entonces, uso mucho listas y diccionarios para esto.

Lea esto mientras prepara una respuesta y tuvo que hacer algunas ediciones.

No soy un experto en Python, pero creo que la idea detrás del uso de clases es que puede crear una instancia de un objeto que tenga un montón de métodos listos para usar que se relacionen con la estructura de datos, así como centralizar sus métodos. También hay algunos beneficios de alcance variable con clases vs módulos, el enlace anterior llega a este punto de alguna manera.

Tengo una clase llamada featureLayer (probablemente no tiene un nombre pitónico ... todavía estoy aprendiendo). puedo hacer

sys.path.append(r"\\Path\To\Scripts")
import gpFuncs as gpF
fc = arcpy.GetParameterAsText(0)
featureLayer = gpF.featureLayer(fc)
points = featureLayer.featureVerticesToPoints(featureid, "", first_and_last)

La definición para hacer esto es un método de clase que simplemente itera las características, partes y vértices. Luego puedo convertir mi objeto de puntos en una instancia de featureLayer y hacer otras cosas que tiene mi clase.

Creo que si se construyen correctamente, las clases deberían encapsular la funcionalidad. Por ejemplo, pronto comenzaré a refactorizar para que tenga una clase featureLayer que tenga métodos y atributos que tienen todas las capas de entidades. Luego, herede de él para construir una instancia de clase featureLayerStrict que heredará todos los atributos / métodos de featureLayers pero que se instanciará con un tipo de geometría específica como el polígono.

Trabajo principalmente en VB .net pero me encuentro usando Python y Arcpy cada vez más. En VB me gusta e intento usar Enums, ya que hace que la lectura del código sea más clara. Las versiones anteriores de python no implementaban Enums, por lo que un truco era crear una Clase que exponga algunas propiedades, se discuten un montón de ejemplos en Stack Overflow . Ahora parece que la última versión de Python implementa estos que se discuten aquí .