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

16

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

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

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

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

    
pregunta Fezter 13.07.2016 - 11:12

5 respuestas

14

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

Por ejemplo, la función Dissolve_management acepta una lista de nombres de campos para disolver en:

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 el número de elementos, ya que las tuplas son inmutable . 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 de tamaño, ser reordenada, ordenada, etc. Vea esto pregunta de StackOverflow para obtener más información sobre los usos de listas y tuplas.

Un diccionario se puede usar como una tabla de búsqueda rápida para almacenar en memoria caché un conjunto relativamente pequeño pero usado frecuentemente de pares clave-valor en la memoria. Vi un ejemplo interesante de esto en los foros de ArcGIS: enlace

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 los propósitos de visualización que desea deletrear el nombre correcto (California), puede usar este diccionario como una tabla de búsqueda al rellenar un campo de nombre de estado completo.

No he encontrado la necesidad de escribir una clase en Python para mi uso en arcpy, pero eso no quiere decir que no haya un 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 es probable que sea específico de la lógica de negocios y no esté relacionado con arcpy.

    
respondido por el blah238 23.05.2017 - 14:39
7

Blah238 cubre este tema bien, así que solo agregaré un par de ejemplos de mi propio trabajo. Desarrollé una gran cantidad de datos del aeropuerto, y una de las cosas que tengo que hacer con regularidad se lee en orden a lo largo de los puntos de la línea central de la pista inspeccionada desde una pista. Usted pensaría que estos puntos ya estarían en orden (en la base de datos GIS), pero rara vez lo están. Los puntos de la línea central se producen cada 10 pies a lo largo de la línea central y están flanqueados a cada lado por otras dos filas de puntos de inspección separados por 10 pies. Obtiene la imagen: una gran cantidad de puntos ... y, por lo general, todos mezclados en una 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 de cada uno y volcar los resultados en una lista de Python. Luego, puedo ordenar, hacer clic, revertir, etc. la lista como lo necesite, y es rápido.

Del mismo modo, uso los diccionarios de Python ampliamente (probablemente mucho más de lo que algunos aprobarían). Tengo que crear conjuntos de vectores de unidades 3D para cada extremo de pista en un aeropuerto, y accedo a estos constantemente dentro de un script y lo hago en muchos de mis scripts. También guardo 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 encuentre rápidamente.

    
respondido por el celticflute 28.09.2012 - 07:21
5

Yo también amo los diccionarios - utilícelos todo el tiempo. Este método obtiene algunas propiedades de referencia espacial y las almacena todas 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 disparos:

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 en lo que estoy trabajando actualmente implica extraer las coordenadas y los atributos de las clases de entidades vectoriales y los rasters para que los datos puedan insertarse en otra pieza de software que ni siquiera sabe qué son los datos GIS. Por lo tanto, uso mucho las listas y los diccionarios para esto.

    
respondido por el Chad Cooper 17.07.2018 - 06:14
2

Lea esto mientras preparaba una respuesta y tuvo que hacer algunas modificaciones.

No soy un experto en Python, pero creo que la idea de usar clases es que puede crear una instancia de un objeto que tiene un montón de métodos listos para usar que se relacionan con la estructura de datos y centralizan sus métodos. También hay algunos beneficios de alcance variable con las clases vs módulos, el enlace anterior llega a este punto de alguna manera.

Tengo una clase llamada featureLayer (probablemente no tiene el nombre pitón ... aún 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 entidades, partes y vértices. Luego puedo convertir mi objeto de puntos en una instancia de featureLayer y hacer otras cosas que mi clase tiene.

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

    
respondido por el Justin 14.02.2015 - 07:48
0

Trabajo principalmente en VB .net pero me encuentro usando python y arcpy cada vez más. En VB me gusta y trato de 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 hack era crear una Clase exponiendo algunas propiedades, se discuten un montón de ejemplos en Stack Overflow . Ahora parece que la última versión de python implementa esto, que se trata aquí .

    
respondido por el Hornbydd 23.05.2017 - 14:39

Lea otras preguntas en las etiquetas