FUNDAMENTOS CON PYTHON ESPAÑOL

Prévia do material em texto

Introducción a
Programación y
Fundamentos con
chaowei yang
Traducido del inglés al español - www.onlinedoctranslator.com
https://www.onlinedoctranslator.com/es/?utm_source=onlinedoctranslator&utm_medium=pdf&utm_campaign=attribution
Introducción a SIG
Programación y
Fundamentos con
Python y ArcGIS®
http://taylorandfrancis.com
Introducción a SIG
Programación y
Fundamentos con
Python y ArcGIS®
chaowei yang
Con la colaboración de
Manzhu Yu
Qunying Huang
Zhen Long Li
Sol mínimo
kai liu
yongyao jiang
Jizhe Xia
Prensa CRC
Grupo Taylor & Francis
6000 Broken Sound Parkway NW, Suite 300 
Boca Raton, FL 33487-2742
© 2017 por Taylor & Francis Group, LLC
CRC Press es un sello de Taylor & Francis Group, una empresa de Informa
No reclamar obras originales del gobierno de EE. UU.
Impreso en papel libre de ácido
Libro estándar internacional número 13: 978-1-4665-1008-1 (tapa dura)
Este libro contiene información obtenida de fuentes auténticas y de gran prestigio. Se han realizado esfuerzos 
razonables para publicar datos e información confiables, pero el autor y el editor no pueden asumir responsabilidad 
por la validez de todos los materiales o las consecuencias de su uso. Los autores y editores han intentado localizar a los 
titulares de los derechos de autor de todo el material reproducido en esta publicación y se disculpan con los titulares de 
los derechos de autor si no se ha obtenido el permiso para publicar de esta forma. Si algún material con derechos de 
autor no ha sido reconocido, por favor escríbanos y háganoslo saber para que podamos rectificar en cualquier 
reimpresión futura.
Salvo que lo permita la Ley de derechos de autor de EE. UU., ninguna parte de este libro puede reimprimirse, 
reproducirse, transmitirse o utilizarse de ninguna forma por ningún medio electrónico, mecánico o de otro tipo, ahora 
conocido o inventado en el futuro, incluidas las fotocopias, microfilmaciones y grabaciones, o en cualquier sistema de 
almacenamiento o recuperación de información, sin el permiso por escrito de los editores.
Para obtener permiso para fotocopiar o usar material electrónico de este trabajo, acceda awww. derechos de 
autor.com(http://www.copyright.com/) o comuníquese con Copyright Clearance Center, Inc. (CCC), 222 
Rosewood Drive, Danvers, MA 01923, 978-750-8400. CCC es una organización sin fines de lucro que 
proporciona licencias y registros para una variedad de usuarios. Para las organizaciones a las que la CCC les 
haya otorgado una licencia de fotocopia, se ha dispuesto un sistema de pago separado.
Aviso de marca registrada:Los nombres de productos o empresas pueden ser marcas comerciales o marcas 
comerciales registradas, y se usan solo para identificación y explicación sin intención de infringir.
Visite el sitio Web de Taylor & Francis en 
http://www.taylorandfrancis.com
y el sitio web de CRC Press en 
http://www.crcpress.com
http://www.copyright.com/
http://www.copyright.com/
http://www.copyright.com/
http://www.taylorandfrancis.com
http://www.crcpress.com
Para los padres de Chaowei Yang, Chaoqing Yang y Mingju Tang,
por inculcar continuamente la curiosidad y el espíritu explorador
http://taylorandfrancis.com
Contenido
Prefacio................................................. .................................................... ..................XV 
Agradecimientos .................................................. .............................................xxx 
Editor................................................. .................................................... ................XXIII 
Colaboradores.................................................. .................................................... .....xiv
Sección IVisión general
1. Introducción.................................................... .................................................... .3
1.1 Hardware y software de la computadora ............................................... .......3
1.2 SIG y Programación ............................................... ..........................5
1.3 Pitón................................................... .................................................... ...7
1.4 Clase y objeto .................................................. ......................................9
1.5 Modelos de datos SIG ............................................... .....................................10
1.6 UML .............................................. .................................................... ....11
1.7 Experiencia práctica con Python......................................... ......14
1.8 Resumen del capítulo.................................................... ................................dieciséis
Problemas................................................. .................................................... .......17
2. Programación Orientada a Objetos.................................................... ...............19
2.1 Lenguaje de Programación y Python ............................................... .19
2.2 Clase y objeto .................................................. .....................................21
2.2.1 Definición de clases ............................................. .......................21
2.2.2 Generación de objetos ............................................. .....................23
2.2.3 Atributos .............................................. ....................................23
2.2.4 Herencia ............................................... ................................25
2.2.5 Composición .................................................. ...............................26
2.3 Punto, polilínea y polígono ............................................... ...................27
2.4 Experiencia práctica con Python......................................... ......30
2.5 Resumen del capítulo................................................... ................................30
Problemas................................................. .................................................... .......31
Sección II PitónProgramación
3. Introducción a Python.................................................... ...............................35
3.1 Soporte orientado a objetos ............................................... .......................35
3.2 Sintaxis .................................................. .................................................... .36
3.2.1 Sensibilidad entre mayúsculas y minúsculas ............................... .........................36
3.2.2 Caracteres especiales ............................................. .....................36
viii
viii Contenido
3.2.3 Indentación ............................................... ................................36
3.2.4 Palabras clave .............................................. ....................................37
3.2.5 Asignaciones Múltiples ............................................. ..............38
3.2.6 Espacio de nombres.................................... ................................38
3.2.7 Alcance .............................................. ..........................................38
3.3 Tipos de datos .................................................. .............................................40
3.3.1 Tipos de datos básicos ............................................. ........................40
3.3.2 Tipos de datos compuestos ............................................. ...............42
3.4 Misceláneos .............................................. ......................................48
3.4.1 Variables .............................................. .....................................48
3.4.2 Estilo de código ............................................. ....................................49
3.5 Operadores................................................ .............................................................50
3.6 Declaraciones .............................................. ............................................533.7 Funciones .................................................. .............................................................54
3.8 Experiencia práctica con Python......................................... ......56
3.9 Resumen del capítulo................................................... ................................56
Problemas................................................. .................................................... .......57
4. Estructura de control del lenguaje Python, entrada/salida de archivos,
y manejo de excepciones.................................................... ..........................61
4.1 Toma de decisiones .............................................. ................................61
4.2 Bucles ................................................ .................................................... ...64
4.3 Otras estructuras de control ............................................... .....................66
4.4 Entrada/salida de archivos ........................................... ....................................67
4.5 Excepciones .............................................. ............................................69
4.6 Experiencia práctica con Python......................................... ......70
4.6.1 Encuentre la distancia más larga entre dos puntos cualesquiera .......70
4.6.2 Experiencia práctica: E/S, crear y leer un archivo .........70
4.6.3 Experiencia práctica: E/S, control de flujo y archivo .........72
4.6.4 Experiencia práctica: Ingresar datos de puntos GIS
desde archivo de texto .................................................. ..........................74
4.7 Resumen del capítulo.................................................... ................................75
Problemas................................................. .................................................... .......75
5. Pensamiento de programación y visualización de datos vectoriales.....................77
5.1 Problema: visualización de datos GIS ........................................... .............77
5.2 Transformación del sistema de coordenadas ........................................... .......80
5.2.1 ¿Cómo determinar el valor de la relación? ..........................................82
5.3 Visualización de datos vectoriales ............................................... .......................84
5.4 Punto, Polilínea, Polígono ............................................... ..........................86
5.5 Pensamiento de programación.................................................. ......................87
5.5.1 Análisis de problemas ............................................. ......................88
5.5.2 Pensar en la programación ........................................... .............88
5.5.3 Igualar patrones de lenguaje de programación
y estructura .................................................. ......................89
Contenido ix
5.5.4 Implementar el programa ............................................. ..................89
5.6 Experiencia práctica con Python......................................... ......90
5.6.1 Lectura, análisis sintáctico y análisis de datos de archivos de texto ..................90
5.6.2 Crear Objetos GIS y Verificar Intersección .......................92
5.7 Resumen del capítulo.................................................... ................................95
Problemas................................................. .................................................... .......95
6. Manejo de archivos de forma.................................................... .....................................97
6.1 Manipulación de datos binarios ............................................... ...................97
6.2 Introducción al archivo de forma ........................................... .......................101
6.3 Estructura e interpretación del archivo Shapefile ..................................102
6.3.1 Estructura del archivo principal de un Shapefile ...............................102
6.3.1.1 Encabezado del archivo principal .................................. ......102
6.3.1.2 Registro de funciones ........................................... .........104
6.3.2 Estructura del archivo de índice (.shx) .................................. ...........105
6.3.3 El archivo .dbf ............................................... ...............................107
6.4 Secuencia de Programación General para el Manejo de Shapefiles.........107
6.5 Experiencia práctica con Mini-GIS ............................................... ..108
6.5.1 Visualizar polilíneas y polígonos.......................................108
6.5.2 Interpretar archivos de forma de polilínea .................................. ..109
6.6 Resumen del capítulo.................................................... ...............................113
Problemas................................................. .................................................... .....113
7. Entorno de programación Python.................................................... .....115
7.1 IDE general de Python .................................................. ............................115
7.1.1 Ventanas de programación Python .......................................115
7.1.1.1 GUI de línea de comandos ........................................... .115
7.1.1.2 Interfaz gráfica de usuario interactiva ............................... ........115
7.1.1.3 Programación basada en archivos ...............................116
7.1.2 Configuración del IDE de Python .................................. ................117
7.1.2.1 Resaltar ............................................... ...........117
7.1.2.2 Configuración General de la Ventana de 
Programación......................................... .......................118
7.1.2.3 Configuración de fuentes para la codificación ..................................118
7.1.3 Depuración ............................................... ...............................118
7.1.3.1 Error de sintaxis ............................................... .............120
7.1.3.2 Excepciones de tiempo de ejecución ..................................121
7.1.3.3 Manejo de excepciones ...............................................122
7.1.3.4 Agregar identificadores de excepción y acciones de limpieza a la 
lectura/escritura de archivos ..................123
7.2 Módulos de Python ............................................... ..................................124
7.2.1 Introducción al módulo ............................................. ..............125
7.2.2 Configurar módulos ............................................. ........................125
7.2.3 Módulos integrados del sistema ........................................... ...........126
7.3 Gestión de paquetes y Mini-GIS ............................................... ..127
X Contenido
7.3.1 Organización regular de datos GIS....................................127
7.3.2 Paquete Mini-GIS ............................................... .....................128
7.4 Experiencia práctica con Mini-GIS ............................................... ..131
7.4.1 Gestión de paquetes y Mini-GIS ..................................131
7.4.2 Ejecute y practique el paquete Mini-GIS...........................132
7.5 Resumen del capítulo.................................................... ...............................135
Problemas................................................. .................................................... .....135
8. Algoritmos de datos vectoriales.................................................... ..........................137
8.1 Centroide................................................... .............................................................137
8.1.1 Baricentro de un triángulo ............................................... ..............137
8.1.2 Baricentro de un rectángulo.................................................. ............137
8.1.3 Baricentrode un polígono ............................................... ...............138
8.2 Área.................................................. .................................................... ...139
8.2.1 Área de un polígono simple........................................... ..........139
8.2.2 Área de un Polígono con Agujero(s) ........................................... ....140
8.3 Longitud.................................................. ..........................................................141
8.3.1 Longitud de un segmento de línea recta....................................141
8.3.2 Longitud de una polilínea ........................................... ..................142
8.4 Intersección de línea.................................................... ..................................142
8.4.1 Líneas paralelas ............................................. ..........................145
8.4.2 Líneas verticales ............................................. ..........................145
8.5 Punto en Polígono ............................................... ....................................146
8.5.1 Un escenario especial ............................................. ...................146
8.6 Experiencia práctica con Python......................................... ....148
8.6.1 Usar Python para dibujar un polígono y calcular
el baricentro ................................................ ..........................148
8.6.2 Usar Python para dibujar polígonos y calcular
el área del polígono .............................................. ...............148
8.6.3 Uso de Python para dibujar segmentos de línea y
Calcular la intersección .................................................. ....148
8.7 Resumen del capítulo.................................................... ...............................150
Problemas................................................. .................................................... .....150
Sección III Algoritmos SIG Avanzados y su 
Programación enArcGIS
9. Programación ArcGIS.................................................... ...............................153
9.1 Programación de ArcGIS ............................................... .......................153
9.2 Introducción al Paquete ArcPy ............................................... ..........154
9.2.1 Funciones, clases y módulos de ArcPy ...........................154
9.2.2 Programación con ArcPy en ArcMap....................................155
9.2.3 Programación con ArcPy en la ventana de Python
fuera de ArcMap................................................... .....................156
Contenido xi
9.2.4 Uso de los documentos de ayuda.................................... ...........157
9.3 Automatización de ArcTools con Python ............................................... ...158
9.4 Acceso y edición de datos con cursores ..................................160
9.4.1 Cursor de búsqueda ............................................... ..........................160
9.4.2 Actualizar Cursor ............................................... .........................164
9.4.3 Insertar cursor.................................................... ............................164
9.4.4 NúmPy .............................................. .....................................165
9.5 Describir y enumerar objetos ............................................... ..........166
9.5.1 Describir.................................................... ....................................166
9.5.2 Lista .............................................. ............................................167
9.6 Manipulación de objetos complejos ............................................... ........169
9.7 Automatización de la producción de mapas ............................................... ............172
9.8 Creación de ArcTools a partir de secuencias de comandos......................... ..........172
9.9 Manejo de errores y mensajes ............................................... .........176
9.10 Documentos externos y recursos de video ..................................177
9.11 Implementación de cálculos de relaciones espaciales
Uso de ArcGIS ................................................. .....................................178
9.12 Resumen.................................................. ............................................180
9.13 Asignación ................................................ ........................................182
10. Algoritmo de datos ráster.................................................... ............................185
10.1
10.2
Datos ráster .................................................. .............................................185
Almacenamiento y compresión de ráster ............................................... ......186
10.2.1
10.2.2
Formatos de datos ráster .............................................. ..........................189
10.3.1
10.3.2
10.3.3
10.3.4
10.3.5
10.3.6
10.3.7
10.3.8
10.3.9
Representación de color y reproducción de trama ..................................191
10.4.1
10.4.2
Análisis de ráster................................................. ....................................196
Experiencia práctica con ArcGIS.................................................... ...198
10.6.1
10.6.2
Codificación de la longitud de ejecución ................................. ..............187
Árbol cuádruple ................................................. ...............................188
10.3
TIFF .................................................. .............................................189
GeoTIFF .................................................. ................................190
I.M.G.................................................. .............................................190
NetCDF.................................................. ..................................190
BMP.................................................. .............................................190
SVG.................................................. ........................................191
jpeg .................................................. ......................................191
GIF.................................................. .............................................191
PNG.................................................. .............................................191
10.4
Representación del color.................................................. ...........191
Representación ráster................................................. ..................194
10.5
10.6
Práctica práctica 10.1: Representaciones de color ráster ..................198
Práctica práctica 10.2: Análisis de datos ráster: 
Encuentre el área con el rango de elevación entre
60 y 100 y el Tipo de Cobertura Terrestre como “Bosque” ...........199
xi Contenido
10.6.3 Práctica práctica 10.3. Acceda a la información de atributos del 
conjunto de datos ráster y calcule el área .....200
Resumen del capítulo................................................ .............................205
Problemas................................................. .................................................... .....205
10.7
11. Algoritmos de datos de red.................................................... ......................207
11.1 Representación de la red ............................................... ...................207
11.1.1 Representación básica de la red .............................................207
11.1.2 Redes dirigidas y no dirigidas...................................207
11.1.3 La Matriz de Adyacencia ............................................... .............209
11.1.4 Representación de red en SIG ...............................................209
11.2 Encontrar el camino más corto.................................................. .....................210
11.2.1 Enunciado del Problema ............................................. ..................210
11.2.2 Un enfoquede fuerza bruta para el más corto
Algoritmo de ruta ................................................. .....................211
11.2.3 Algoritmo de Dijkstra ............................................... ..................212
11.3 Tipos de análisis de red ............................................... ................214
11.3.1 Enrutamiento .............................................. .....................................214
11.3.2 Instalación más cercana ............................................. ........................214
11.3.3 Áreas de servicio ............................................. ..........................214
11.3.4 Matriz de costos de OD ........................................... ........................216
11.3.5 Problema de generación de rutas para vehículos ............................... ........216
11.3.6 Ubicación-Asignación ............................................. ..................217
11.4 Experiencia práctica con ArcGIS.................................................. ....218
11.5 Resumen del capítulo.................................................... ...............................221
Problemas................................................. .................................................... .....222
12. Algoritmos de datos de superficie.................................................... .........................223
12.1 Superficie 3D y modelo de datos ............................................. ..................223
12.1.1 Datos de superficie ............................................. .............................223
12.1.2 Modelo de datos de superficie ........................................ ..................223
12.1.2.1 Datos discretos ............................................... ............223
12.1.2.2 Datos continuos ............................................... ......225
12.2 Crear datos de modelo de superficie ............................................. ..................228
12.2.1 Crear modelo de superficie de cuadrícula .................................. ......228
12.2.2 Creación de un modelo de superficie TIN .................................. ...229
12.2.3 Conversión entre TIN y RasterSuperficie
Modelos .................................................. ....................................229
12.3 Análisis de datos de superficie ........................................... .........................230
12.3.1 Elevación ............................................... ....................................230
12.3.2 Pendiente ............................................... .............................................231
12.3.3 Aspecto ............................................... ......................................232
12.3.4 Análisis hidrológico.................................................. ...............234
12.4 Experiencia práctica con ArcGIS.................................................. ....236
Contenido XIII
12.4.1 Práctica práctica 12.1: Conversión entre DEM,
TIN y Contornos ............................................................. ..................236
12.4.2 Práctica práctica 12.2: Generar pendiente y aspecto .....239
12.4.3 Práctica práctica 12.3: Dirección del flujo ...........................239
12.5 Resumen del capítulo.................................................... ...............................242
Problemas................................................. .................................................... .....242
Sección IV AvanzadaTemas
13. Técnicas para mejorar el rendimiento.................................................... ....247
13.1 Problemas ................................................ .............................................247
13.2 Acceso al disco y administración de la memoria ..................................248
13.2.1 Gestión de archivos ............................................... .....................249
13.2.2 Consideración integral ..................................................249
13.3 Procesamiento paralelo y subprocesamiento múltiple ..................................251
13.3.1 Ejecución Secuencial y Concurrente..................................251
13.3.2 Hilos múltiples ............................................... .......................251
13.3.3 Cargar varios Shapefiles al mismo tiempo
Uso de subprocesos múltiples .............................................. ..........252
13.3.4 Procesamiento en Paralelo y Cluster, Grid,
y computación en la nube .............................................. .........253
13.4 Cálculo de relaciones e índice espacial....................................254
13.4.1 Cuadro delimitador en GIS ............................................... ................255
13.4.2 Índice espacial ............................................... ............................256
13.5 Experiencia práctica con Mini-GIS ............................................... ..257
13.5.1 Carga de datos con RAM como búfer de archivos ..................257
13.5.2 Carga de datos con subprocesos múltiples ..................................258
13.5.3 Comprobación del cuadro delimitador para acelerar la intersección ........258
13.5.4 Intersección de líneas usando el índice R-Tree..................................261
13.6 Resumen del capítulo.................................................... ...............................262
Problemas................................................. .................................................... .....263
14. Temas avanzados.................................................... .............................................265
14.1 Estructura de datos espaciales ............................................... ........................265
14.1.1 Estructura de datos ráster en NetCDF/HDF ...........................265
14.1.2 Aplicación de NetCDF/HDF en el estudio del clima .............266
14.2 Algoritmos y modelado GIS.................................................... ...........270
14.2.1 Datos .............................................. ..........................................270
14.2.2 Análisis de densidad ............................................. .....................271
14.2.3 Análisis de regresión (OLS y GWR) ...............................272
14.3 SIG distribuido.................................................... ....................................275
14.3.1 Arquitectura del sistema ............................................. ...............276
14.3.2 Interfaz de usuario................................................ ..........................277
xiv Contenido
14.4 Pensamiento y computación espaciotemporal....................................280
14.4.1 Problema: simulación y computación de polvo
Desafíos .................................................. ........................280
14.4.2 Metodología 1: Uso de computación de alto rendimiento para 
respaldar la simulación de polvo ...............281
14.4.3 Metodología 2: Utilización del pensamiento espaciotemporal
para optimizar la computación de alto rendimiento ..................281
14.4.3.1 Características del agrupamiento de tormentas de polvo:
Métodos de programación ............................................282
14.4.3.2 Continuidad espacio-temporal de las tormentas de polvo: método de 
descomposición .................................. ..283
14.4.3.3 Los eventos de tormentas de polvo están aislados:
Modelo anidado ................................................ ........284
14.4.4 Metodología 3: Utilización de la computación en la nube
para respaldar el pronóstico de tormentas de polvo ...............................284
14.5 Resumen del capítulo ............................................... ...............................285
Problemas................................................. .................................................... .....286
Referencias.................................................... .................................................... .......287
Índice........................................................................................................ ..................291
Prefacio
¿Por qué otro texto de programación SIG?
El sistema de información geográfica (GIS, por sus siglas en inglés) se ha convertido en una 
herramienta popular que sustenta muchos aspectos de nuestra vida diaria, desde la ruta para 
el transporte hasta la búsqueda de un restaurante y la respuesta a emergencias. Las prácticas 
herramientas GIS se desarrollan con diferentes niveles de programación, desde secuencias de 
comandos, usando python para ArcGIS, hasta la creación de nuevos conjuntos de herramientas 
desde cero. La cantidad de programación que se necesita para los proyectos depende en gran 
medida del software GIS, los tipos de aplicaciones y la estructura del conocimiento y los 
antecedentes del diseñador y desarrollador de la aplicación. Por ejemplo, las secuencias de 
comandos simples integran aplicaciones de mapas en línea que utilizan mapas de Google. Las 
aplicaciones de análisis espacial personalizadas utilizan ArcGIS de forma rutinaria con una 
programación mínima. Muchos desarrollan una aplicación que aprovecha el software de código 
abierto para administrar big data, modelar fenómenos complejos, o respondiendo a usuarios 
simultáneos para sistemas en línea populares. El mejor diseño y desarrollo de dichas 
aplicaciones requiere que los diseñadores y desarrolladores tengan un conocimiento profundo 
de los principios GIS, así como la habilidad para elegir entre opciones de software comerciales y 
de código abierto. Para la mayoría de los profesionales de SIG, esto es un desafío porque la 
mayoría son usuarios finales de herramientas SIG o profesionales de tecnología de la 
información (TI) con una comprensión limitada de SIG.
Para llenar este vacío, durante la última década, Chaowei Yang lanzó un curso introductorio 
de programación GIS que fue bien recibido. La inscripción continúa aumentando y los 
estudiantes informan comentarios positivos una vez que están en el lugar de trabajo y utilizan 
el conocimiento desarrollado en la clase. Para beneficiar a un espectro más amplio de 
estudiantes y profesionales que buscan materiales de capacitación para desarrollar 
capacidades de programación GIS, este libro está escrito para integrar y refinar el conocimiento 
de los autores acumulado a través de cursos y proyectos de investigación asociados.
La audiencia de este libro es tanto profesionales de TI para aprender los principios SIG como 
usuarios de SIG para desarrollar habilidades de programación. Por un lado, este libro 
proporciona un puente para que los estudiantes y profesionales de SIG aprendan y practiquen 
la programación. Por otro lado, también ayuda a los profesionales de TI con experiencia en 
programación a adquirir los fundamentos de GIS para perfeccionar sus habilidades de 
programación para el desarrollo de GIS.
En lugar de intentar competir con la literatura de programación GIS actual, los autores 
se esfuerzan por interpretar GIS desde un ángulo diferente mediante la integración de 
algoritmos y programación GIS. Como resultado, este libro proporciona un conocimiento 
práctico que incluye principios SIG fundamentales, habilidades básicas de programación, 
desarrollo SIG de código abierto, desarrollo ArcGIS y desarrollo avanzado.
XV
xvi Prefacio
temas Estructurado para desarrollar funciones, aplicaciones y sistemas GIS.s, Se espera 
que este libro ayude a los estudiantes y profesionales de SIG/TI a ser más competitivos en 
el mercado laboral de la industria de SIG y TI con las habilidades de programación 
necesarias.
¿Qué se incluye en el texto?
Este libro tiene cuatro secciones. Sección I (Capítulos 1y2) es una descripción general 
de la programación SIG e introduce la informática y la programación desde una 
perspectiva práctica. La programación Python (lenguaje de programación integral 
para ArcGIS) se presenta ampliamente en la Sección II (Capítulos 3mediante8) en el 
contexto del diseño y desarrollo de un Mini-GIS usando experiencia práctica 
siguiendo explicaciones de conceptos fundamentales de SIG. Sección III (Capítulos 9
mediante12)se enfoca en algoritmos GIS avanzados e información sobre cómo 
invocarlos para programar en ArcGIS. Los temas avanzados y la optimización del 
rendimiento se presentan en la Sección IV (Capítulos 13y14) utilizando el Mini-GIS 
desarrollado.
Capítulo 1introduce computadoras, programación de computadoras y GIS. 
Además, se analiza el Lenguaje de marcado unificado (UML) para capturar modelos 
GIS implementados a través de la programación simple de Python.Capitulo 2 
presenta características y programación orientada a objetos con ejemplos de tipos 
básicos de datos vectoriales GIS de punto, polilínea y polígono.
Capítulo 3presenta la sintaxis de Python, los operadores, las declaraciones, las 
características misceláneas de las funciones y el soporte de Python para la 
programación orientada a objetos. Usando ejemplos SIG,Capítulo 4presenta 
estructuras de control del lenguaje Python, entrada/salida de archivos y manejo de 
excepciones.Capítulo 5 presenta el pensamiento de programación utilizando la 
visualización de datos vectoriales como un ejemplo del flujo de trabajo de este 
proceso crítico en la programación. Capítulo 6presenta el entorno de programación 
integrado (IDE) de Python, los módulos, la administración de paquetes y el paquete 
Mini-GIS.Capítulo 7analiza los formatos de archivos de forma y los pasos sobre 
cómo manejar los archivos de forma dentro del Mini-GIS.Capítulo 8introduce 
algoritmos de procesamiento de datos vectoriales e incluye intersección de línea, 
centroide, área, longitud y punto en polígono. Esta presentación incluye cómo Mini-
GIS/ArcGIS admite estos algoritmos.
Capítulo 9une las Secciones II y III al presentar la programación de ArcGIS en Python 
usando ArcPy, el entorno de programación de ArcGIS, herramientas de automatización, 
acceso a datos, descripción de objetos y corrección de errores.Capítulo 10 presenta 
algoritmos de datos ráster, incluido el formato, el almacenamiento y la compresión de 
datos ráster con experiencia práctica en el uso de ArcGIS.Capítulo 11aborda algoritmos 
de datos de red para representar redes y calcular la ruta más corta en principios y usar 
ArcGIS.Capítulo 12explora la superficie o
Prefacio xvii
Representación de datos 3D de datos 3D, conversión de formatos de datos y análisis 3D 
para elevación, pendiente, aspecto y dirección de flujo con ejemplos en programación 
ArcGIS.
Capítulo 13introduce técnicas de mejora del rendimiento e incluye acceso y 
gestión de almacenamiento, procesamiento paralelo y subprocesos múltiples, índice 
espacial y otras técnicas para acelerar GIS como se demuestra en Mini-GIS. Los 
temas avanzados, incluidos algoritmos y modelado GIS, estructura de datos 
espaciales, GIS distribuido, pensamiento espaciotemporal y computación, se 
presentan encapitulo 14.
Experiencia práctica
Como texto práctico para desarrollar habilidades de programación, este libro hace todo 
lo posible para garantizar que el contenido sea lo más funcional posible. Para cada 
principio, algoritmo y elemento fundamental de SIG presentado, se explora un ejemplo 
como una experiencia práctica usando Mini-GIS y/o ArcGIS con Python. Este flujo de 
trabajo de aprendizaje ayuda a desarrollar una comprensión profunda de los 
fundamentos y, naturalmente, se relaciona con los fundamentos y las habilidades de 
programación.
Para el desarrollo de sistemas y código abierto, se presenta un desarrollo paso a 
paso de un Mini-GIS basado en python. Para el desarrollo de aplicaciones, se adopta 
ArcGIS para ilustración.
El Mini-GIS es un software de código abierto desarrollado para este texto y se puede 
adoptar para construir otras aplicaciones GIS. ArcGIS, un producto comercial de ESRI, se 
utiliza para experimentar software comercial de última generación. Para fines de 
aprendizaje, ArcGIS está disponible de forma gratuita en ESRI.
Materiales en línea
Este libro viene con los siguientesmateriales en línea:
• Diapositivas instructivas para instructores que utilizan este texto para la educación en 
el aula y profesionales para ayudar en el aprendizaje de la programación GIS.
• Códigos de Python para ejercicios de clase y experiencias prácticas y 
estructurados y etiquetados por capítulo para codificar la secuencia del capítulo.
• Mini-GIS como un paquete de código abierto para aprender los fundamentos 
de GIS y para ejemplificar los principios y algoritmos de GIS.
• Respuestas a problemas para que los instructores verifiquen sus soluciones.
xviii Prefacio
La audiencia y cómo usar este texto
Este texto tiene dos funciones: un texto para la construcción sistemática de habilidades 
de programación SIG y una referencia para identificar una solución Python para 
algoritmos SIG específicos o funciones desde cero y/o ArcGIS. El texto está destinado a 
ayudar a cuatro categorías de lectores:
• Profesores que enseñan programación GIS o estudiantes GIS que aprenden 
con un enfoque específico en la experiencia práctica en el aula.
• Los programadores que deseen aprender a programar GIS 
escaneando la Sección I yCapítulos 3y4, seguido de un estudio paso 
a paso de los capítulos restantes.
• Los diseñadores de sistemas GIS más interesados en descripciones de 
algoritmos, implementación de algoritmos desde cero y ArcGIS para reunir un 
conocimiento práctico sobre la programación GIS para ayudar en la elección de 
GIS para el desarrollo futuro.
• Profesionales de TI con curiosidad de GIS por los principios de GIS pero 
omitiendo los ejercicios de programación.
La intención de los autores para una audiencia tan amplia se basa en el deseo de 
cultivar una fuerza laboral profesional competitiva en el desarrollo de SIG, mejorar la 
literatura de SIG y servir como una introducción práctica a la investigación de SIG.
¿Cómo desarrollamos este texto?
El material de texto fue desarrollado por primera vez por el profesor Chaowei Yang en 
2004 y se ofreció anualmente en un salón de clases durante la última década. Durante 
ese lapso de tiempo, muchos estudiantes desarrollaron y mejoraron sus habilidades de 
programación. Algunos se convirtieron en profesores y conferencistas en universidades y 
fueron invitados a escribir capítulos de libros específicos. Teniendo en cuenta a la 
audiencia, se invitó a varios profesores que enseñan programación GIS en diferentes 
entornos culturales y universitarios a revisar los capítulos del libro.
El siguiente es el flujo de trabajo de desarrollo del libro:
• Utilizando los materiales de su curso, el profesor Yang estructuró este libro 
con la ayuda de Irma Shagla, y se contrató la estructura del texto para 
publicarlo como libro. El profesor asistente Qunying Huang, de la 
Universidad de Wisconsin, Madison, exploró el uso de las versiones 
anteriores de los materiales del texto. Los Profesores Asistentes Huang y 
Zhenlong Li, Universidad de Carolina del Sur, desarrollaron la Sección II del 
texto en colaboración con el Profesor Yang.
Prefacio xix
• El Dr. Min Sun, la Sra. Manzhu Yu, el Sr. Yongyao Jiang y el Sr. Jizhe Xia 
desarrollaron la Sección III en colaboración con el Profesor Yang.
• El profesor Yang editó y revisó todos los capítulos para asegurar una estructura y 
composición comunes.
• La Sra. Manzhu Yu y el profesor Yang editaron las diapositivas del curso.
• El Profesor Asistente Li, el Sr. Kai Liu, la Sra. Joseph George y la Sra. Zifu 
Wang editaron Mini-GIS como software para el texto.
• Después de completar el texto anterior y los materiales del curso, se invitó a 
cuatro profesores y dos desarrolladores a revisar el contenido del texto.
• Los materiales reunidos para el texto finalmente fueron revisados por 
varios profesionales, incluidos la Sra. Alena Deveau, el Sr. Rob 
Culbertson y el profesor George Taylor.
• El texto fue formateado por la Sra. Minni Song.
• La Sra. Manzhu Yu y el profesor Yang completaron una revisión final de los capítulos, 
diapositivas, códigos, datos y todos los materiales relevantes.
http://taylorandfrancis.com
Expresiones de gratitud
Este texto es un proyecto a largo plazo que evoluciona del curso "Introducción a la 
programación GIS" desarrollado y perfeccionado durante la última década en la 
Universidad George Mason. Muchos estudiantes y profesores brindaron sugerencias 
constructivas sobre qué incluir, cuál es la mejor manera de comunicar y desafiar a los 
estudiantes, y quién debe ser considerado como audiencia del texto.
El resultado refleja la carrera de programación del profesor Yang desde sus 
tesis de pregrado en la Universidad del Noreste de China bajo la tutoría del 
profesor Jinxing Wang. El profesor Yang fue asesorado en programación en el 
dominio GIS por los profesores Qi Li y Jicheng Chen. Sus mentores académicos 
en los Estados Unidos, los profesores David Wong y Menas Kafatos, le 
brindaron apoyo durante muchas décadas y le dieron la oportunidad de 
impartir el curso que finalmente condujo a este texto.
El profesor Yang agradece a los estudiantes brillantes y entusiastas de sus clases 
en la Universidad George Mason. Sus preguntas y críticas perfeccionaron sus 
habilidades de enseñanza, mejoraron el contenido y estimularon este esfuerzo de 
desarrollar un texto.
El profesor Yang agradece a su amada esposa, Yan Xiang, y a sus hijos, 
Andrew, Christopher y Hannah, por complacerlo al robarle un tiempo valioso a 
la familia para completar el texto.
La Sra. Manzhu Yu extiende su gratitud a los muchos colegas que 
brindaron apoyo y leyeron, escribieron, comentaron y ayudaron en la 
edición, revisión y formato del texto.
La profesora asistente Huang agradece a su maravilloso esposo, Yunfeng Jiang, ya 
su encantadora hija, Alica Jiang.
La Dra. Min Sun agradece a su supervisor de doctorado, el profesor David Wong, por 
educarla. También agradece a David Wynne, su supervisor en ESRI, donde trabajó como 
pasante, y a sus otros compañeros de trabajo que, en conjunto, la ayudaron a obtener 
una comprensión más completa de la programación con productos de ESRI. Por último, 
pero no menos importante, agradece a sus padres y al adorable perro que la acompañó 
cuando estaba escribiendo el texto.
Yongyao Jiang agradece a su esposa Rui Dong, a su hija Laura ya sus 
padres Lixia Yao y Yanqing Jiang.
xxx
http://taylorandfrancis.com
Editor
chaowei yanges profesor de ciencias de la información geográfica en la Universidad 
George Mason (GMU). Su interés de investigación es la utilización de principios 
espaciotemporales para optimizar la infraestructura informática para respaldar los 
descubrimientos científicos. Fundó el Centro de Computación Espacial Inteligente y el 
Centro de Innovación Espaciotemporal de la NSF. Se desempeñó como PI o Co-I para 
proyectos por un total de más de $ 40 millones y financiados por más de 15 agencias, 
organizaciones y empresas. Ha publicado más de 150 artículos y ha desarrollado varios 
cursos y programas de capacitación en SIG. Ha asesorado a más de 20 estudiantes de 
posdoctorado y doctorado que se desempeñan como profesores y científicos en 
instituciones estadounidenses y chinas muy aclamadas. Recibió muchos premios 
nacionales e internacionales, como el Premio Presidencial de Administración de 
Protección Ambiental de EE. UU. en 2009. Todos sus logros se basan en su conocimiento 
práctico de SIG y sistemas de información geoespacial. Este libro es una colección de 
conocimientos prácticos sobre cómo desarrollar herramientas GIS desde una perspectiva 
de programación. El contenido se ofreció en sus clases de programación y algoritmos GIS 
durante los últimos 10 años (2004–2016) y ha sido adoptado por sus estudiantes y 
colegas que se desempeñan como profesores en muchas universidades de los Estados 
Unidos e internacionalmente.
XXIII
http://taylorandfrancis.com
Colaboradores
fei hues candidato a doctorado en el NSF Spatiotemporal Innovation Center, George Mason 
University. Está interesado en utilizar tecnologías de computación enla nube de alto 
rendimiento para administrar y extraer grandes datos espaciotemporales. Más 
específicamente, ha optimizado el sistema de almacenamiento distribuido (p. ej., HDFS) y el 
marco informático paralelo (p. ej., Spark, MapReduce) para administrar, consultar y analizar de 
manera eficiente grandes conjuntos de datos basados en matrices multidimensionales (p. ej., 
datos climáticos y sensores remotos). datos). Su objetivo es proporcionar a los científicos 
capacidades analíticas de datos bajo demanda para liberarlos de las tareas computacionales 
que consumen mucho tiempo.
Qunying Huanges profesor asistente en el Departamento de Geografía de la Universidad 
de Wisconsin, Madison. Sus campos de especialización incluyen la ciencia de la 
información geográfica (GIScience), la infraestructura cibernética, la extracción de datos 
grandes espaciotemporales y el modelado y simulación ambiental a gran escala. Está muy 
interesada en aplicar diferentes modelos informáticos, como clúster, grid, GPU, 
computación ciudadana y, especialmente, computación en la nube, para abordar los 
desafíos informáticos y de big data contemporáneos en la ciencia GIS. Más 
recientemente, está aprovechando y extrayendo datos de redes sociales para diversas 
aplicaciones, como respuesta a emergencias, mitigación de desastres y movilidad 
humana. Ha publicado más de 50 artículos científicos y editado dos libros.
yongyao jianges candidato a doctorado en sistemas terrestres y ciencias de la geoinformación 
en el Centro de Innovación Espaciotemporal NSF, Universidad George Mason. Obtuvo una 
Maestría (2014) en Ciencias SIG en la Universidad de Clark y una Licenciatura en Ciencias (2012) 
en teledetección en la Universidad de Wuhan. Su investigación se centra en el descubrimiento 
de datos, la minería de datos, la semántica y la computación en la nube. Jiang recibió el premio 
NSF EarthCube Visiting Graduate Student Early-Career Scientist Award (2016), el Microsoft Azure 
for Research Award (2015) y el primer premio en el Robert Raskin CyberGIS Student 
Competition (2015). Se desempeña como líder técnico de MUDROD, un proyecto de motor de 
búsqueda y descubrimiento semántico financiado por el programa AIST de la NASA.
Zhen Long Lies profesor asistente en el Departamento de Geografía de la Universidad de 
Carolina del Sur. La investigación del Dr. Li se centra en la computación espacial de alto 
rendimiento, el procesamiento/minería de macrodatos y la ciberinfraestructura 
geoespacial en el área de datos y ciencias GIS computacionales intensivas. La 
investigación del Dr. Li tiene como objetivo optimizar la infraestructura informática 
espacial mediante la integración de tecnologías informáticas de vanguardia y principios 
espaciales para respaldar aplicaciones de dominio como el cambio climático y la gestión 
de riesgos.
xiv
xxi Colaboradores
kai liues estudiante de posgrado en el Departamento de Geografía y Ciencias de la 
Geoinformación (GGS) en la Facultad de Ciencias de la Universidad George Mason. 
Anteriormente, fue académico visitante en el Centro de Computación Espacial Inteligente 
para la Ciencia del Agua/Energía (CISC) y trabajó durante 4 años en la Oficina de 
Topografía y Cartografía de Heilongjiang en China. Obtuvo una licenciatura en ciencias de 
la información geográfica en la Universidad de Wuhan, China. Su investigación se centra 
en la semántica geoespacial, la gestión de metadatos geoespaciales, la computación en la 
nube espaciotemporal y la ciencia ciudadana.
Sol mínimoes profesor asistente de investigación en el Departamento de Geografía y 
Ciencias de la Geoinformación de la Universidad George Mason. Sus intereses de 
investigación incluyen medir la incertidumbre de los atributos en datos espaciales, 
desarrollar análisis visuales para respaldar la exploración de datos, WebGIS y 
computación en la nube. Es experta en programación de ArcGIS y también se desempeña 
como subdirectora del Centro de Innovación Espaciotemporal de la NSF de EE. UU.
Jizhe Xiaes profesor asistente de investigación en la Universidad George Mason. Obtuvo 
un doctorado en sistemas terrestres y ciencias de la geoinformación en la Universidad 
George Mason en la primavera de 2015. Los intereses de investigación del Dr. Xia son la 
computación espaciotemporal, la computación en la nube y sus aplicaciones en ciencias 
geográficas. Propuso una variedad de métodos para utilizar patrones espaciotemporales 
para optimizar el acceso a big data, la evaluación de la calidad del servicio (QoS) y la 
aplicación de computación en la nube.
Manzhu Yues candidato a doctorado en el Departamento de Geografía y Ciencias 
de la Geoinformación de la Universidad George Mason. Sus intereses de 
investigación incluyen metodología espaciotemporal, detección de patrones y 
aplicaciones espaciotemporales en desastres naturales. Recibió una Beca 
Presidencial de 2012 a 2015. Ha publicado aproximadamente 10 artículos en revistas 
de renombre, comoMás unoyIJGIS, y contribuyó como autor importante en varios 
capítulos de libros.
Sección I
Visión general
http://taylorandfrancis.com
1
Introducción
Este capítulo presenta los conceptos básicos de computadora, hardware, software y 
programación, y establece el contexto para la programación SIG.
1.1 Hardware y software informático
Acomputadoraes un dispositivo que tiene la capacidad de realizar diferentes tipos de tareas 
automatizadas basadas en instrucciones específicas predefinidas por interacciones con los 
usuarios finales o a través de ellas. Por ejemplo, al hacer clic en el icono de ArcGIS se ejecutará 
el software ArcGIS. Podemos seleccionar un destino y un punto de partida para activar un 
análisis de enrutamiento para identificar una ruta de manejo usando Google Maps. Las 
computadoras son algunas de las tecnologías de más rápida evolución, como lo refleja la 
capacidad de procesamiento de las pequeñas calculadoras a las supercomputadoras. El tamaño 
de los dispositivos se ha reducido desde computadoras que ocupan un edificio hasta 
dispositivos móviles en bolsillos (Figura 1.1). Las interacciones del usuario van desde escribir 
tarjetas perforadas (primeras computadoras) hasta la interacción humano-computadora, como 
hablar para invocar una acción o tarea.
Hay dos componentes importantes de una computadora (Hwang y Faye 1984): (1) el 
dispositivo físico que puede realizar el procesamiento automatizado y (2) los paquetes de 
instrucciones que se pueden configurar para proporcionar una funcionalidad específica, 
como el procesamiento de textos o el procesamiento de información geográfica. . El 
primer componente de una computadora, elhardware, es tocable como máquinas físicas. 
El segundo componente, elsoftware, puede comprarse con el hardware en forma de 
sistema operativo o instalarse descargándolo en línea. El hardware de la computadora se 
puede configurar o programar para realizar diferentes tareas; por lo tanto, una 
computadora también puede llamarse un dispositivo de propósito general. El software 
varía mucho, ya sea que proporcione capacidad de procesamiento de documentos, 
gestión financiera, procesamiento de declaraciones de impuestos o simulaciones 
científicas como el cambio climático o la propagación de enfermedades. Según el tipo de 
software, se adquiere públicamente (freeware) o es propietario (requiere compra y 
licencia). Según el uso, el software puede clasificarse como software de sistema, software 
de aplicación o software integrado (Figura 1.2). El software del sistema se refiere al 
software básico que debe instalarse para que una computadora funcione. Windows y 
Linux son ejemplos de software de sistema operativo (SO), un componente esencial de 
una computadora. Soporte de software de aplicación
3
4 Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
(a) (b)
FIGURA 1.1
(a) Supercomputadora de la NASA. (De la supercomputadora de la NASA enhttp://www.nas.nasa.gov/hecc/
resources/pleiades.html.) (b) Otras computadoras: computadora personal(PC), laptop, pad. (De diferentes 
computadoras enhttp://www.computerdoc.com.au/cuáles-son-los-diferentes-tipos-de-computadoras.)
grupos específicos de tareas, como Microsoft Word para el procesamiento de 
documentos y Microsoft Outlook para correos electrónicos. El software integrado es un 
tipo de firmware que se graba en el hardware y se convierte en parte de ese hardware. El 
software integrado existe más tiempo en una computadora que cualquier otro software. 
El firmware siempre vendrá con el hardware cuando compre una computadora, por lo 
que no tendrá que cambiar el firmware con tanta frecuencia, especialmente cuando 
actualice un navegador web o Turbo Tax Return de forma rutinaria.
Sistema de información geográfica(GIS) es un tipo de software de aplicación que 
trata principalmente con información geográfica (Longley et al. 2001). El sistema de 
posicionamiento global (GPS, Misra y Enge 2006) se utiliza para ubicar lugares 
geográficos y se puede instalar tanto en automóviles como en teléfonos inteligentes 
para enrutamiento. El software SIG incluye dos categorías: SIG profesional y SIG 
ligero. El software GIS profesional, como ArcGIS, proporciona la mayor
Software de la aplicacion
Word, navegador web, ArcGIS
Software del sistema
Windows, Linux,...
software integrado
Hardware
FIGURA 1.2
Diferentes tipos de software.
http://www.nas.nasa.gov/hecc/resources/pleiades.html
http://www.nas.nasa.gov/hecc/resources/pleiades.html
http://www.computerdoc.com.au/what-are-the-different-types-of-computers
Introducción 5
conjunto completo de funcionalidades GIS para profesionales en el dominio GIS. El 
software GIS menos intenso, pero popular, que se utiliza para ver el entorno 
geográfico es la aplicación de mapas en línea, como Google Maps y Google Earth.
1.2 SIG y Programación
GIS se origina en varios dominios y se refiere al sistema diseñado para capturar, 
observar, recopilar, almacenar y administrar datos geográficos y proporcionar 
herramientas para análisis y visualización espacial (Longley et al. 2001). Los SIG pueden 
ayudar a obtener datos geográficos que se utilizarán para la toma de decisiones, como la 
elección de rutas para la respuesta a emergencias. Se sabe que GIS comenzó a partir del 
programa informático canadiense de inventario de recursos naturales dirigido por Roger 
Tomlinson en la década de 1960. GIS se está volviendo cada vez más popular en 
dispositivos móviles como un medio para analizar información y patrones relacionados 
con el tráfico y el clima.
Acuñado por Mike Goodchild, el término "GIS" también puede referirse al campo 
de la ciencia de la información geográfica ociencia SIG—el estudio de los principios y 
tecnologías SIG aplicados científicamente (Goodchild 1992). Según los científicos de 
SIG,ciencia SIGinvolucra sensores remotos, sistemas globales de navegación por 
satélite y GIS. Además, en varios dominios,Geoinformáticapuede aplicarse a la 
teledetección, el sistema mundial de navegación por satélite y la información GIS. 
Estos temas, sin embargo, no serán explorados en este libro.
GIS es el sistema que comprende hardware (computadora, dispositivos móviles, GPS), 
software (ArcGIS o mapeo en línea) y datos (información geográfica) que se pueden 
utilizar para lograr un conjunto de funcionalidades para un grupo de usuarios. Los tres 
componentes deben utilizarse para que GIS funcione de manera efectiva. Una diferencia 
significativa entre GIS y otras aplicaciones de software es su capacidad para administrar y 
manipular el gran volumen y la complejidad de los datos geográficos, que comprenden 
información espaciotemporal y de atributos incrustada. El carácter complejo de los datos 
GIS exige un conjunto específico de software para extraer información para la toma de 
decisiones. Los paquetes de software maduros están disponibles públicamente, incluido 
el conjunto más actualizado de software ArcGIS y la última edición del software de mapas 
web Google Maps.
El proceso de desarrollo de software se denominaprogramación. La programación le indica a 
la computadora que realice una tarea en función de las órdenes. Hay muchos tipos diferentes 
de niveles de programación (Mitchell 1996). El nivel más bajo para programar se basa en las 
instrucciones de hardware específicas admitidas por las unidades centrales de procesamiento 
(CPU) y utilizadas por los desarrolladores de instrumentos inteligentes. Debido a que las 
instrucciones de la CPU se procesan como una secuencia de 0 y 1, el lenguaje ensamblador se 
desarrolla para ayudar a los desarrolladores a recordar esas instrucciones. Ambos lenguajes se 
consideran de bajo nivel y son específicos del hardware. Se han desarrollado lenguajes 
avanzados para facilitar la
6 Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
comprensión, pero todavía están restringidos por las instrucciones del hardware. Por 
ejemplo, el lenguaje de programación C se usa comúnmente para desarrollar software 
(Kernighan y Ritchie 2006). Para hacer que la organización de la programación sea más 
similar a cómo vemos el mundo, se propuso C++ para admitir la programación orientada 
a objetos basada en C (Stroustrup 1995). Desde entonces, se han desarrollado y se 
utilizan muchos lenguajes de programación diferentes en la programación GIS. Por 
ejemplo, Java es un lenguaje para el desarrollo de aplicaciones multiplataforma 
propuesto por Sun Microsystems (Arnold et al. 2000). JavaScript se utiliza para realizar 
una programación de secuencias de comandos (más simple) para manipular objetos 
dentro de un navegador web. Además de Java y JavaScript, ArcGIS ha agregado 
recientemente Python a su lista de lenguajes de programación (Van Rossum 2007).
¿Por qué necesitamos la programación GIS? El software GIS maduro y las plantillas de 
aplicaciones brindan muchas herramientas para realizar nuestras tareas diarias; sin 
embargo, para comprender los fundamentos de cómo funciona GIS y personalizar el 
software para problemas específicos, se requiere programación. La siguiente lista 
proporciona ejemplos de programación:
• Software de personalización para la aplicación.: El Servicio de Parques Nacionales 
está desarrollando una sencilla aplicación web de mapas para permitir que el público 
en general seleccione y vea de forma interactiva la información de un Parque 
Nacional en particular. El uso de una herramienta de mapeo en línea como Google 
Maps y la selección de un parque con el mouse activará una consulta de la 
información seleccionada para ese parque. En este escenario, necesitamos 
información geográfica sobre los parques, un programa para la interacción del 
usuario front-end y un lenguaje de consulta de base de datos que generará 
resultados para el parque seleccionado.
• Automatización de un proceso: suponga que hay 100 conjuntos de datos geográficos 
recopilados en formato de archivo de texto y necesitamos convertirlos en un archivo de 
forma, un formato de archivo de datos nativo utilizado por ArcView y ArcGIS, para su 
posterior procesamiento. ArcGIS puede realizar la conversión una por una, pero hacerlo 
manualmente 100 veces es monótono. Por lo tanto, una herramienta de secuencias de 
comandos simple para leer y procesar automáticamente los 100 conjuntos de datos en 
archivos de forma sería beneficioso. El uso de secuencias de comandos de Python en 
ArcGIS brinda la capacidad de hacerlo.
• Satisfaciendo necesidades GIS simples: Supongamos que hay una empresa de 
transporte que necesita realizar un seguimiento de las posiciones de los vehículos de 
su empresa en intervalos de 5 minutos. Sin embargo, la empresa no puede 
permitirse comprar una licencia de software GIS profesional. Para resolver el 
problema, la empresa puede usar Python para crear un mapa que muestre la región 
de servicio de la empresa y las ubicaciones de los vehículos cada 5 minutos. Esta 
programación puede incluir características de Zoom In/Out y Move/Pan, animaciones 
basadas en ubicaciones y una selección de uno o varios vehículos.Introducción 7
• Cultivando profesionales GIS avanzados: Suponga que se le pide a un grupo de 
estudiantes que invente un algoritmo de enrutamiento basado en las 
condiciones de tráfico pronosticadas y la información de tráfico en tiempo real. 
Los estudiantes deberán organizar la información de la red de carreteras 
comparando la velocidad de la red en tiempo real y prevista. Es esencial utilizar 
la información prevista más precisa en el proceso de enrutamiento. Se necesita 
programación a lo largo de todo el proceso para la gestión y el enrutamiento de 
la red, y para reconstruir los resultados en forma de mapa o instrucciones 
escritas.
La información geográfica se ha vuelto cada vez más importante en todos los ámbitos de la vida humana, ya sea 
para el descubrimiento científico, el pronóstico de desastres naturales, el avance de las tecnologías de observación o la 
creación de conciencia pública sobre la ubicación y la ruta. Mientras que algunas aplicaciones requieren tecnologías GIS 
completas para producir resultados valiosos, muchas aplicaciones de información geográfica no requieren sistemas de 
información geográfica sofisticados. Para el último caso, se utiliza un software de información geoespacial pequeño o 
de código abierto, mientras que los sistemas GIS comerciales como ArcGIS están disponibles para el primer caso. Para 
abordar mejor ambas necesidades, es esencial comprender los fundamentos de cómo funciona GIS y su procesamiento 
básico de información geográfica. En este capítulo se presenta la estructura de fondo para construir tales capacidades: 
hardware y software informático, GIS y programación, modelos de datos GIS y lenguaje de marcado unificado (UML, 
Fowler 2004) y Python. Se necesita experiencia práctica en programación para comprender los conceptos y desarrollar 
las habilidades esenciales utilizadas por los profesionales SIG en su trabajo e investigación. Basado en los fundamentos 
de SIG, este libro lo ayudará a desarrollar y mejorar las habilidades de programación sistemática y le brindará una 
comprensión más profunda de los fundamentos de SIG. Debido a su popularidad dentro de la comunidad GIS, Python 
será el lenguaje de programación principal que se utilizará en este libro. Basado en los fundamentos de SIG, este libro 
lo ayudará a desarrollar y mejorar las habilidades de programación sistemática y le brindará una comprensión más 
profunda de los fundamentos de SIG. Debido a su popularidad dentro de la comunidad GIS, Python será el lenguaje de 
programación principal que se utilizará en este libro. Basado en los fundamentos de SIG, este libro lo ayudará a 
desarrollar y mejorar las habilidades de programación sistemática y le brindará una comprensión más profunda de los 
fundamentos de SIG. Debido a su popularidad dentro de la comunidad GIS, Python será el lenguaje de programación 
principal que se utilizará en este libro.
1.3 pitón
Python fue desarrollado originalmente por un programador holandés, Guido van 
Rossum, en 1990. Según los informes, Van Rossum era fanático de la serie de 
comedia británica,El circo volador de Monty Python, y al desarrollar el lenguaje de 
programación de código abierto, tomó prestado el nombre "Python" para el 
lenguaje y su institución sin fines de lucro, Python Software Foundation.
Similar a los lenguajes de programación C++ y Java, Python es un lenguaje orientado a 
objetos e interactivo. Python es dinámico en el sentido de que utiliza un mecanismo 
automático de administración de memoria para asignar y liberar memoria para
8 Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
datos (variables). Python y ArcGIS lanzan regularmente nuevas versiones de sus 
programas; este libro está basado en la versión 2.7 de Python y ArcGIS 10.1.
Hay muchas razones para elegir Python, incluidas las siguientes:*
• Es excelente para principiantes en programación, pero excelente para expertos.
• La sintaxis de Python es muy simple y fácil de aprender. Cuando te 
familiarices con ellos, sentirás que es realmente muy útil.
• Es altamente escalable y muy adecuado para proyectos grandes y pequeños.
• Está en una fase de rápido desarrollo. Casi cada medio año, hay un nuevo 
lanzamiento importante.
• Es multiplataforma portátil. Esto significa que un programa escrito en 
Windows se puede ejecutar con los sistemas operativos Linux o Mac.
• Es fácilmente extensible. Siempre puede agregar más funciones de clase a su 
proyecto actual.
• Dispone de potentes bibliotecas estándar.
• Muchos terceros también ofrecen paquetes altamente funcionales 
para su uso. En lugar de desarrollar funciones GIS desde cero, 
simplemente puede descargar el código fuente e integrarlo en su 
proyecto.
• Es totalmenteorientado a objetoslenguaje, simple pero elegante, estable y 
maduro.
Hay varios pasos para aprender Python para la programación GIS:
• Familiarizarse con el concepto de clase y objeto (Capítulos 1y2).
• Aprenda la sintaxis de Python, incluidas variables, tipos de datos, 
estructuras, controles, instrucciones y otras estructuras de 
programación (Capítulos 1mediante4).
• Cree programas de Python desde cero e integre bibliotecas de código 
abierto para facilitar la programación (Capítulo 5).
• Familiarizarse con el entorno de programación de Python (intérprete de 
Python o editor de texto de Python,Capítulo 6).
• Resolver problemas GIS escribiendo código para algoritmos GIS (Capítulos 7 
mediante13).
Estos componentes se presentan en el orden anterior a lo largo de este libro. 
Este capítulo presenta conceptos importantes como la programación orientada 
a objetos, UML y modelos GIS.
* http://pythoncard.sourceforge.net/what_is_python.html.
http://pythoncard.sourceforge.net/what_is_python.html
Introducción 9
1.4 Clase y Objeto
Dentro de esta sección, discutiremos dos tipos de conceptos fundamentales: clase y objeto 
(Rumbaugh et al. 1991). La clase utiliza un conjunto de atributos y comportamientos para 
representar una categoría de fenómenos del mundo real. Por ejemplo,Figura 1.3 muestra cómo 
extraer los atributos y comportamientos de los estudiantes.
Otro ejemplo son las compras en línea en Amazon o eBay. Tanto los clientes 
como los productos en línea deben resumirse en clases:
• Los clientes tendrían una identificación de cliente, una dirección de envío y una 
dirección de facturación. El comportamiento del cliente incluiría agregar o eliminar 
un producto del carrito de compras.
• Los productos tendrían un ID de producto, un nombre de producto y un precio de 
producto. El comportamiento del producto incluiría establecer el precio y sumar la 
cantidad/cantidad del producto.
Un objeto es una instancia específica de una clase. Podemos considerar objetos 
como instancias de clases asignando valores a sus atributos. Específicamente, una 
clase es la abstracción de una categoría o colección de entidades del mundo real, 
mientras que un objeto es una entidad específica del mundo real dentro de la clase. 
Dentro de una computadora, una clase es la plantilla y un objeto es la entidad 
específica que ocupa la memoria de la computadora. La computadora puede operar 
tanto en los atributos como en los comportamientos de un objeto. Por ejemplo, 
cuando un estudiante inicia sesión en el sistema web de su universidad con un 
nombre de usuario y una contraseña, el sistema creará un nuevo objeto de 
estudiante. La computadora lee a cada estudiante como un objeto independiente 
con varios atributos diferentes (por ejemplo, nombre de usuario, contraseña e ID de 
estudiante). Después de iniciar sesión, un estudiante puede buscar, registrarse,
Capitulo 2presentará cómo definir clases y objetos usando Python.
FIGURA 1.3
Un ejemplo de representación de estudiantes con la clase Student.
10Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
1.5 Modelos de datos SIG
Los modelos de datos GIS se utilizan para capturar elementos geoespaciales esenciales de un 
problema específico (Longley et al. 2001).Hay tres tipos de modelos de datos: datos vectoriales, 
datos raster y datos especiales. Los modelos de datos vectoriales constan de tipos de modelo 
de punto, polilínea y polígono. Los datos ráster incluyen celdas igualmente divididas de 
imágenes y modelos de elevación digitales. Los datos especiales se componen de datos lineales 
y de red. Este libro destaca diferentes tipos de modelos de datos GIS, pero se centrará 
principalmente en modelos de datos vectoriales.
Un punto puede hacer referencia a una clase de datos vectoriales representados por 
un par de coordenadas x, y en un espacio bidimensional (2D) o una tupla de coordenadas 
x, y y z en un espacio tridimensional (3D). Por ejemplo, una ciudad se representa como un 
punto en un mapamundi. Cada ciudad tiene un grupo de atributos, que incluiría el 
nombre de la ciudad, la población, el ingreso familiar promedio y los acro-nombres. Otro 
ejemplo que usa puntos es un mapa que muestra todos los restaurantes dentro de una 
determinada región. Además de su ubicación puntual, cada restaurante contendrá otra 
información relevante, incluido su nombre, la capacidad de la sala, la cocina y el año en 
que abrió. En estos casos, el punto es una clasificación general, mientras que la ciudad o 
el restaurante es un tipo de clase más específico que contiene diferentes atributos. Al 
diseñar, cada punto del rectángulo puede representar una clase (Figura 1.4). Este 
diagrama también se conoce como diagrama de clases UML. La primera fila se refiere al 
nombre de la clase:Ciudad; la segunda fila se refiere a los atributos de la clase:nombrey
ingreso promedio; la tercera fila se refiere a un conjunto de métodos:obtenerNombre,
obtenerIngresoPromedio, yescoger un nombre.
Las polilíneas son una clase de datos vectoriales representados por una lista de puntos. 
Por ejemplo, un río se puede representar como una polilínea en un mapa, que luego se 
puede categorizar como un tipo de clase de polilínea. Una clase de polilínea puede incluir 
coordenadas de puntos, atributos relevantes y un conjunto de métodos. Otro ejemplo de 
dataset de polilínea pueden ser carreteras, autopistas e interestatales. Ambos ejemplos 
son categorías de polilíneas. Los ríos se pueden representar usando UML (Figura 1.5). La 
primera fila del UML es el sujeto de la clase:Río; la segunda fila incluye los atributos del 
río:nombreycoordenadas; y la tercera fila se refiere a los métodos que usará el 
programador:obtenerNombre,establecer coordenadas, yescoger un nombre.
FIGURA 1.4
Un diagrama UML para la clase City.
Introducción 11
FIGURA 1.5
La clase River incluye tres partes.
FIGURA 1.6
La clase County incluye tres partes.
Los polígonos son otra clase de datos vectoriales que también están representados por una 
lista de puntos; sin embargo, con los polígonos, el primer y el último punto son los mismos. Por 
ejemplo, en el mapa del estado de Virginia, un condado específico, como el condado de Fairfax, 
se puede representar como un polígono. El condado es un tipo de clase de polígono, que 
incluye una lista de puntos, atributos relevantes y un conjunto de métodos. Los países en un 
mapa mundial también se pueden representar como polígonos. En cualquier caso, tanto el 
condado como el país son tipos de polígonos. Como se muestra enFigura 1.6, la primera fila es 
el nombre del asunto:Condado; la segunda fila son los atributos del sujeto:nombreypoblación; y 
la tercera fila se refiere a los métodos:obtenerNombre,conjuntoPoblación, yescoger un nombre
.
Desarrollar más métodos requerirá agregar más métodos y atributos a cada 
clase para capturar la evolución de los modelos de datos y la funcionalidad del 
software; Los diagramas UML se utilizan para estandarizar su representación. 
Esta sección utiliza diagramas de clases y estándares UML relevantes para las 
clases de puntos, polilíneas y polígonos.
1.6 UML
En 1997, el Grupo de Gestión de Objetos (OMG)*creó el UML para registrar el diseño 
del software para la programación. Diseñadores y programadores de software
* Ver Dios mío enhttp://www.omg.org/.
http://www.omg.org/
12Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
use UML para comunicar y compartir el diseño. Similar al idioma inglés en el 
que nos comunicamos compartiendo nuestras ideas hablando o escribiendo, 
UML se usa para modelar una aplicación o problema de forma orientada a 
objetos. El modelado UML se puede utilizar para facilitar todo el diseño y 
desarrollo de software.
El diagrama UML se utiliza para capturar la lógica de programación. Hay dos tipos 
de diagramas que discutiremos específicamente: diagramas de clases y diagramas 
de objetos (Figura 1.7).
El diagrama de clases UML puede representar una clase usando tres partes: 
nombre, atributos y métodos. Los atributos y métodos tienen tres 
accesibilidades diferentes: pública (+), privada (-) y protegida (#). Los atributos y 
métodos normalmente se representan en el siguiente formato:
• Atributos: atributo de accesibilidad Nombre: tipo de datos del atributo, por 
ejemplo, +nombre: Cadena
• Métodos: nombre del método de accesibilidad (argumentos del método): tipo de 
devolución del método, por ejemplo, +setName(name:String): void
Público se refiere al método/atributos a los que pueden acceder otras 
clases. Ninguna otra clase puede acceder a métodos/atributos privados.
Otras clases no pueden acceder a los métodos/atributos protegidos, excepto aquellas 
clases heredadas de esta clase (se explica a continuación).
Hay varias relaciones fundamentales entre diferentes clases: dependencia, 
herencia, composición y agregación. La dependencia representa una clase 
dependiente de otra. La herencia es una relación importante en la que una clase es 
un subtipo de otra clase.Figura 1.8ilustra la dependencia entre la geometría y los 
sistemas de coordenadas en el sentido de que la existencia de la geometría 
depende de un sistema de coordenadas. Esta relación está representada por una 
línea discontinua y una flecha desde la geometría hasta la clase del sistema de 
coordenadas. La relación entre un punto, una línea y un polígono se clasifican 
dentro de la clase de geometría.
La agregación y la composición son otras dos relaciones importantes en UML. 
La agregación representa la relación "tiene un" en UML. Por ejemplo, un estado 
es una agregación de varios condados (Figura 1.9a). La composición representa, 
o “posee” la relación. Por ejemplo, una clase multipunto puede estar compuesta 
por dos o más puntos (Figura 1.9b).
La relación se puede cuantificar por el número de elementos involucrados. Por 
ejemplo, una línea incluye más de 2 puntos y un estado incluye más de 0 condados. 
Hay seis tipos diferentes de esta relación de multiplicidad (Figura 1.10). Un 
multipunto se compone de dos o más puntos (Figura 1.9b) y un estado se agrega 
por cero o más condados.
Un objeto es uninstanciaciónde una clase El diagrama de objetos muestra una vista completa o 
parcial de la estructura del sistema modelo en un momento específico. Entonces, el estado
Introducción 13
D
ia
gr
am
a
Es
tr
uc
tu
ra
di
ag
ra
m
a
Co
m
po
rt
am
ie
nt
o
di
ag
ra
m
a
Cl
as
e
di
ag
ra
m
a
Co
m
po
ne
nt
e
di
ag
ra
m
a
O
bj
et
o
di
ag
ra
m
a
Ac
tiv
id
ad
di
ag
ra
m
a
ca
so
 d
e 
us
o
di
ag
ra
m
a
Co
m
pu
es
to
es
tr
uc
tu
ra
di
ag
ra
m
a
Es
ta
do
m
áq
ui
na
di
ag
ra
m
a
Pe
rf
il
di
ag
ra
m
a
D
es
pl
ie
gu
e
di
ag
ra
m
a
Pa
qu
et
e
di
ag
ra
m
a
In
te
ra
cc
ió
n
di
ag
ra
m
a
In
te
ra
cc
ió
n
vi
si
ón
 g
en
er
al
di
ag
ra
m
a
Se
cu
en
ci
a
di
ag
ra
m
a
Co
m
un
ic
ac
ió
n
di
ag
ra
m
a
M
om
en
to
di
ag
ra
m
a
N
ot
ac
ió
n:
 U
M
L
FI
G
U
RA
 1
.7
El
 d
ia
gr
am
a 
de
 c
la
se
s 
y 
el
 d
ia
gr
am
a 
de
 o
bj
et
os
 u
til
iz
ad
os
 e
n 
es
te
 li
br
o.
14Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
Geometría Sistema coordinado
Punto Línea Polígono
FIGURA 1.8
Herencia y dependencia.
(a)(b)
Composición
condados Agregación
0..*
Estado Punto multipunto
2..*
Hueco
diamante
Lleno
diamante
FIGURA 1.9
(a) La agregación y (b) la composición son dos relaciones polares entre clases.
FIGURA 1.10
Relación multiciudad entre clases.
de un objeto se puede cambiar.Figura 1.11El nombre de clase de es worldMap y su 
objeto es el sistema de coordenadas que cambió de WGS 1972 a WGS 1984 después 
de realizar la reproyección.
1.7 Experiencia práctica con Python
Un punto es el modelo de datos básico dentro de GIS. Esta sección examinará 
cómo crear una clase de punto, incluidas las coordenadas y los cálculos de la
Introducción 15
FIGURA 1.11
worldMap es un objeto de la clase Map y el estado cambia con diferentes operaciones.
distancias entre puntos. Aprenderá a crear objetos de punto a partir de la clase 
de punto.
1. Abra el programa (Figura 1.12): ventanas→Todos los 
programas→ArcGIS→Pitón 2.7 o
ventanas→Todos los programas→Pitón 2.7→INACTIVO (GUI de Python)
FIGURA 1.12
Inicie la ventana de programación de Python (GUI).
dieciséisIntroducción a la Programación GIS y Fundamentos con Python y ArcGIS®
> > > importarMatemáticas
> > > clasePunto(): definitivamente__en eso__
(uno mismo):
self.x = 0
self.y = 0
definitivamenteestablecerXY(uno mismo,x,y):
self.x = x
self.y = y
definitivamenteCalDis(uno mismo,p):
devolvermatemáticas.sqrt((self.xp.x)**2+(self.yp.y)**2)
> > > p1 = Punto()
> > > p2 = Punto()
> > > p1.establecerXY(1,2)
> > > p2.establecerXY(2,3)
> > > p1.calDis(p2)
1.4142135623730951
> > >
CÓDIGO 1.1
Creando una clase de punto y generando dos puntos, luego calculando la distancia entre los 
dos puntos.
2. Escriba los códigos de clase de puntos como se muestra en el Código 1.1.
Consejos de programación:
1. La codificación debe ser exactamente igual a la que muestra la figura.
2. El método init se define con cuatro guiones bajos: dos "_" antes y dos 
después de "init".
3. Python distingue entre mayúsculas y minúsculas, por lo que las mayúsculas y minúsculas de la 
misma letra marcarán la diferencia.
4. No hay necesidad de entender cada declaración por ahora; se 
explicarán gradualmente en los siguientes capítulos.
1.8 Resumen del capítulo
Este capítulo introdujo brevemente la programación GIS e incluyó
• Una introducción general al hardware y software de la computadora
• Definiciones de SIG y programación
• Python en un contexto práctico
• Conocimiento práctico sobre varios modelos de datos GIS
Introducción 17
• El lenguaje de modelado unificado para modelar datos GIS orientados a 
objetos
• Experiencia práctica relevante
PROBLEMAS
• Definir computación, programación, software y SIG.
• ¿Cuáles son los diferentes métodos para clasificar el software?
• ¿Cuáles son los tres modelos de datos GIS que se encuentran en el diagrama UML?
• Explicar por qué necesitamos aprender a programar SIG.
• Usar el diagrama UML para modelar la relación entre polilíneas.
• Usar el diagrama UML para modelar la relación entre polígonos.
• Practica PythonCapítulo 3tutorial:https://docs.python.org/3/tutorial/
introduction.html.
• Utilice Python para calcular la distancia entre el Punto (1, 2) y el Punto (2, 
2).
• Discutir cómo identificar las clases usadas en un mapa mundial y cómo usar 
UML para capturar esas clases.
https://docs.python.org/3/tutorial/introduction.html
https://docs.python.org/3/tutorial/introduction.html
http://taylorandfrancis.com
2
Programación orientada a objetos
Este capítulo presenta la programación orientada a objetos con respecto al lenguaje de 
programación Python, las clases y los objetos, la generación de objetos, la herencia, las 
clases y los objetos GIS y una experiencia general de programación.
2.1 Lenguaje de programación y Python
El lenguaje de programación se define como un lenguaje artificial utilizado para 
escribir instrucciones que pueden traducirse a lenguaje de máquina y luego 
ejecutarse por una computadora. Esta definición incluye cuatro aspectos 
importantes: (1) lenguaje artificial, un tipo de lenguaje de programación creado 
únicamente para la comunicación informática; (2) basado en instrucciones, un 
lenguaje de programación con instrucciones limitadas respaldadas por una 
computadora o CPU específica; (3) traducción, la conversión de instrucciones 
humanas a un programa informático técnico o CPU; y (4) traductor, del cual hay dos 
tipos: intérprete y compilador (Aho y Ullman 1972).
Hay dos métodos diferentes que utilizan los programadores de 
computadoras para convertir idiomas a un formato legible en la computadora. 
Un método requiere que un programador de computadoras compile un grupo 
de declaraciones escritas en un lenguaje específico y las convierta a un formato 
legible por máquina antes de ejecutar el programa. El otro método implica 
traducir simultáneamente el idioma mientras se ejecuta el programa. Por 
ejemplo, en la programación C, necesitamos usar el compilador C para traducir 
el programa a códigos de máquina antes de la ejecución. De manera similar, C+
+ y Java son lenguajes de programación de tipo compilación. El lenguaje de 
programación BASIC es un lenguaje de interpretación (Lien 1981), en el que el 
intérprete traducirá el programa mientras se ejecuta. Asimismo, Python, Perl y 
PHP se consideran lenguajes de interpretación. Por lo tanto, para usar con éxito 
Python en una computadora,
Los lenguajes de programación han evolucionado considerablemente desde los lenguajes de 
máquina y ensamblador hasta los lenguajes intermedios y avanzados (Rawen 2016). Las 
instrucciones en lenguaje máquina se representan en una secuencia específica utilizando 0 y 1. 
Un solo dígito, o número, se llama bit. Una combinación de tres bits se denomina número octal 
(una combinación de ocho dígitos que utiliza los números del 0 al 7), mientras que una 
combinación de cuatro bits se denomina número hexadecimal.
19
20Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
FIGURA 2.1
Imprima 'A' 1000 veces usando diferentes tipos de idiomas.
(una combinación de 16 dígitos usando los números 0–15). Los lenguajes ensambladores 
representan las operaciones de bits de la máquina con representaciones de texto fáciles 
de recordar. Los lenguajes intermedios suelen ser más potentes y fáciles de codificar. Los 
lenguajes avanzados son más similares al lenguaje humano, no tienen acceso a funciones 
de hardware específicas y se ejecutan en varios tipos de hardware diferentes.
El ejemplo utiliza diferentes representaciones para la "letra impresa 'A' 1000 
veces" (Figura 2.1).
Los lenguajes de máquina se vuelven cada vez más difíciles de entender para los 
humanos, por lo que solo las CPU específicas pueden leer el lenguaje con precisión 
(Hutchins 1986). Por lo tanto, en la programación GIS, normalmente usamos 
lenguajes avanzados como C, Java o Python en lugar de lenguaje de máquina o 
ensamblador.
C es un lenguaje de procedimiento típico que se desarrolló entre 1969 y 1973 y 
estuvo disponible para el público en general entre 1977 y 1979. Fue estandarizado 
oficialmente por el comité ANSI X3J11 a mediados de la década de 1980 y se ha 
convertido en uno de los lenguajes más utilizados en la industria informática. Las 
primeras ediciones de GRASS (Geographic Resource Analysis Support System, 
Neteler y Mitasova 2013) GIS*El software de código abierto y ArcGIS se desarrollaron 
utilizando C. Bjarne Stroustrup de Bell Laboratories expandió C a C ++ para admitir 
funciones orientadas a objetos. C++ admite características de C en llamadas a 
funciones y clases/objetos orientados a objetos. Tanto C como C++ son complejos 
para los programadores principiantes. Desde 1999, ISO/ANSI ha
* http://grass.osgeo.org/.
http://grass.osgeo.org/
Programación orientada a objetos 21
C++ estandarizado para mejorar y mantener la calidad de vanguardia 
dentro de la industria. C y C ++ se usan comúnmente en Linux y han 
influido en otros lenguajes como C # y Java.
Desarrollado por Sun en SunWorld'95, Java es un lenguaje puro orientadoa 
objetos desarrollado para aplicaciones de Internet y multiplataforma. Con el tiempo, 
Java se ha vuelto cada vez más popular entre las empresas de TI como Microsoft, 
Borland/Eclipse, IBM y Sun. El recurso oficial de Java se puede encontrar en 
java.sun.com y se puede encontrar un entorno de programación/compilador de 
código abierto en el sitio web de la Fundación Eclipse enwww.eclipse.com.
Python es un sistema de programación de lenguaje interactivo creado por Guido van 
Rossum en 1990. Python está escrito de forma dinámica y utiliza una gestión de memoria 
automática. La Python Software Foundation, una organización sin fines de lucro, actualiza 
y administra constantemente este proyecto de código abierto. Python está 
completamente desarrollado en el sentido de que puede escribir una vez y ejecutarse 
muchas veces en diferentes plataformas. Este libro analizará y explicará cómo se aplica 
Python a GIS y ArcGIS.*programación. Puede descargar cualquier versión del sitio web de 
Python; sin embargo, no todas las versiones funcionan de forma interactiva con ArcGIS. 
Python es fácil de aprender y usar, y es compatible con ArcGIS, razón por la cual lo hemos 
elegido como lenguaje de programación para este libro.
2.2 Clase y Objeto
Clasesyobjetosson ampliamente utilizados en Python. Clase define la plantilla para una 
categoría de objetos con nombre, atributos y métodos. Los objetos son instancias de 
clases con atributos y métodos. Se puede hacer referencia a los atributos y métodos 
usando un '.'. Por ejemplo, se puede hacer referencia a los atributos de coordenadas y al 
método calDis de un objeto de punto creado a partir de una clase Point mediante point.x, 
point.y y point.calDis().
2.2.1 Definición de clases
Python proporciona el mecanismo para definir una clase utilizando la palabra clave 
class con la sintaxis de 'class className:', por ejemplo, 'class Point:', 'class Polyline:' 
o 'class Polygon:'. Los atributos y métodos se pueden definir para una clase usando 
la palabra clave 'def'.Figura 2.2muestra el código de Python para definir una clase 
Point con los atributos name, x, y definidos y el método setName() definido. En el 
método __init__, se pasó "0, 0" como valor para x, y y nombre.
Muchas clases definen un método especial llamado __init__() para crear/construir 
objetos. El método será llamado cuando creamos un objeto usando la clase
* http://www.esri.com/software/arcgis.
http://www.esri.com/software/arcgis
www.eclipse.com
22Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
Colón para la inauguración del
cuerpo de clase
palabra clave para
definir todas las clases
Nombre de esta clase
Función de inicio Colón para la apertura
del cuerpo del método
el primer argumento
siempre es uno mismo
Palabra clave utilizada para
definir función
El valor predeterminado para
argumento xEl segundo
el nombre del argumento es x
nombre del método
Asignar valor
Punto solía llamar
el atributo
FIGURA 2.2
Un ejemplo de definición de una clase Point con Python.
(como la clase Point aquí). El método __init__ tiene cuatro '_', dos antes y dos después de 
'init', para convertirlo en el método de construcción que se usará al crear un objeto. Para 
todos los métodos definidos por una clase, el primer parámetro siempre es 'self', que se 
refiere al objeto mismo. Esto se puede utilizar para referirse a los atributos y métodos de 
los objetos. Por ejemplo, el método __init__ creará un objeto de punto con self como el 
primer parámetro y valores iniciales de nombre x, y para el objeto. De forma 
predeterminada (sin especificar los valores), los valores de x, y y el nombre serán 0, 0 y 
una cadena en blanco, respectivamente. Las dos primeras declaraciones del Código 2.1 
crean dos objetos de punto (punto0 y punto1). El objeto point0 se crea con valores 
predeterminados y point1 se crea con argumentos
> > > clasePunto:
definitivamente__en eso__(yo, x=0, y=0, nombre=''):
self.x = x
self.y = y
self.nombre = nombre
definitivamenteescoger un nombre(yo, nombre):
self.nombre = nombre
> > > punto0 = Punto()
> > > punto1 = Punto(1,1,'primer punto')
> > > punto0.x, punto0.y, punto0.nombre (0, 
0, '')
> > > punto1.x, punto1.y, punto1.nombre (1, 
1, 'primer punto')
> > > punto1.establecerNombre('segundo punto')
> > > punto1.nombre 
'segundo punto'
> > >
CÓDIGO 2.1
Crear un punto puede pasarle valor al objeto a través de parámetros.
Programación orientada a objetos 23
de 1, 1 y 'primer punto'. Si no se proporcionan parámetros al crear el punto 0, se 
utilizarán los valores predeterminados 0, 0 y ' '. Cuando los valores (1, 1, 'primer 
punto') reciben parámetros, el método __init__ asignará los valores pasados a los 
atributos del punto1.
2.2.2 Generación de objetos
Para crear un objeto, escribanombre del objeto=nombre de la clase()con ninguno o 
múltiples parámetros, que se pasarán a los atributos declarados en los métodos __init__().
nombre del objeto=className(valor1,valor2,…)
En Code 2.1, generamos dos objetos, point0 y point1. Al declarar el objeto point0, no se 
pasa ningún parámetro mientras que se utilizan tres valores (1, 1, 'primer punto') para 
generar point1.
Para referirnos al atributo o método de un objeto, comenzamos con elnombre del objeto, 
seguido de un punto y luego finaliza con el nombre del atributo o el nombre del método.
nombre_objeto.nombre_atributo 
nombre_objeto.nombre_método()
El código 2.1 usa .x, .y y .name después de los objetos point0 y point1 para 
referirse a los atributos x, y y name. La instrucciónpunto1.establecerNombre()se 
llama para cambiar el nombre del punto 1 a 'segundo punto'.
2.2.3 Atributos
Cada clase puede tener uno o más atributos. La Sección 1.4 explica cómo los atributos 
pueden ser públicos, privados o protegidos para indicar una accesibilidad diferente por 
parte de otros objetos. ¿Cómo se especifican explícitamente los atributos públicos y 
privados al declarar una clase?
• Público:Los atributos en Python son, por defecto, "públicos" todo el tiempo.
• Privado:Atributos que comienzan con un doble guión bajo (“_”). Estos atributos 
se pueden proteger como privados porque no se puede acceder a ellos 
directamente. Sin embargo, se puede acceder a ellos porobjeto._ClassName 
_attributeName, por ejemplo, test._Test_foobar, donde test es un objeto de la 
clase Test y _foobar es un atributo privado (Código 2.2).
• Proteger:Prefijo de atributos con un solo guión bajo "_" por convención. Sin 
embargo, aún se puede acceder a ellos fuera de la clase en Python.
Otro atributo importante en Python es el atributo estático, que se utiliza para 
almacenar datos persistentes e independientes de cualquier objeto de la clase.
24Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
> > > clasePrueba:
definitivamente__en eso__(uno mismo):
self.__foobar ="atr privado" self.foobar 
="atractivo publico"
> > > prueba = prueba()
> > > prueba.foobar 
'atr público'
> > > prueba.__foobar
Rastreo (llamadas recientes más última):
Archivo "<pyshell#23>", línea 1, en <módulo>
prueba.__foobar
AttributeError: la instancia de prueba no tiene el atributo '__foobar'
> > > prueba._Test__foobar 
'atr privado'
> > >
CÓDIGO 2.2
Declare los atributos public, private y protect.
(Código 2.3). Por ejemplo, podemos crear un mapa que incluya diferentes capas, y la escala de 
la capa puede ser estática y la misma para todos los objetos de la capa.
Una clase (y un objeto instanciado) puede tener atributos integrados especiales. Los 
atributos de clase especiales incluyen un nombre de clase y una descripción de la clase 
(Código 2.4).
> > > clasePrueba: versión 
= 1.0
> > > Versión de prueba
1.0
> > > t1 = Prueba()
> > > t2 = Prueba()
> > > versión t1
1.0
> > > versión t2
1.0
> > > Prueba.versión = 2.0
> > > versión t1
2.0
> > > versión t2
2.0
> > > t1.versión = 3.0
> > > versión t1
3.0
> > > Versión de prueba
2.0
> > > versión t2
2.0
> > >
CÓDIGO 2.3
Declarar atributos estáticos.
Traducido del inglés al español - www.onlinedoctranslator.comhttps://www.onlinedoctranslator.com/es/?utm_source=onlinedoctranslator&utm_medium=pdf&utm_campaign=attribution
Programación orientada a objetos 25
> > > clasePunto:
"""Definición de clase de punto""" 
definitivamente__en eso__(uno mismo):
self.x = 0.0
self.y = 0.0
definitivamenteobtenerDistancia():
pasar## ignorar aquí
> > > Punto.__nombre__ 
'Punto'
> > > Punto.__doc__ 'Definición 
de clase de punto'
> > > Punto.__módulo__ 
'__principal__'
> > >
CÓDIGO 2.4
Atributos de clase especiales.
> > > p1 = Punto()
> > > p1.__clase__
<clase __principal__.Punto en 0x02A100D8>
> > > p1.__dict__ {'y': 0.0, 'x': 
0.0}
> > >
CÓDIGO 2.5
Atributos de objetos especiales.
• _name_: nombre de la clase
• _doc_: descripción
• _bases_: clases padres
• _dict_: atributos
• _module_: módulo donde se define la clase
Los atributos de objetos especiales incluyen un nombre de clase y los atributos de un objeto 
(Código 2.5).
• _class_: clase desde la que se instancia el objeto
• _dict_: atributos del objeto
2.2.4 Herencia
Capítulo 1introduce tres relaciones importantes entre objetos en la programación 
orientada a objetos: herencia, encapsulación y polimorfismo. La herencia es una 
forma eficiente de ayudar a reutilizar una clase desarrollada. Si bien los atributos y 
métodos privados no se pueden heredar, las subclases pueden heredar 
automáticamente todos los demás atributos y métodos públicos y protegidos.
26Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
FIGURA 2.3
Un ejemplo de herencia (Estacionamientola clase hereda de la clasePolígono, yPolígonohereda 
deRasgo).
Para heredar una superclase en Python, incluya el nombre de la superclase entre paréntesis 
después del nombre de la clase.
class NombreDeClaseDerivada(SuperClase1)
También podemos heredar varias clases en Python ingresando más de un nombre 
de clase entre paréntesis.
class NombreDeClaseDerivada(SuperClase1, SuperClase2, SuperClase3)
Figura 2.3muestra un ejemplo de herencia. Suponiendo que tenemos una 
clase Rasgo, que incluye un métododibujar(), entonces la clase Polygon 
heredará de la claseRasgo. Con esta herencia, la clase Polygon tendrá el 
métododibujar() también. Cuando definimos laEstacionamientoclase con la 
herencia delPolígono, laEstacionamientotendrá atributos de coordenadas x e y 
así como el métododibujar(). losPolígonoyEstacionamientopuede tener 
diferentes implementaciones de dibujo; sin embargo, puede utilizar eldibujar() 
función tanto para elPolígonoyEstacionamiento. Este método particular que usa 
diferentes implementaciones para diferentes subclases se llama polimorfismo.
2.2.5 Composición
La composición es una forma eficiente de ayudarnos a reutilizar los objetos creados 
y de mantener la relación de parte a todo entre los objetos. para mantener el
Programación orientada a objetos 27
FIGURA 2.4
Ejemplo de composición (unPolígonola clase incluye puntos de atributo como objetos generados a partir de la clase 
Punto).
relación de composición, debe definir una clase con un atributo que puede 
incluir una serie de otros objetos de clase.
Figura 2.4muestra un ejemplo de composición. La clasePuntoy la clase Polígono
heredar de la claseRasgo. La clasePolígonoEl borde está definido por una secuencia 
de puntos formados en un anillo y es capturado por atributos de puntos. Las 
coordenadas de los puntos se mantienen en los objetos de punto. Esto no sólo 
muestra cómo unPolígonoobjeto requiere un número dePuntoobjetos, sino también 
la relación de composición entrePuntoyPolígono.
2.3 Punto, polilínea y polígono
En GIS, existen tres tipos básicos de datos vectoriales, que incluyen Punto, Polilínea y Polígono 
(Chang 2006). Podemos abstraer esas características y definir una clase para que cada una de 
ellas sea reutilizada. También podemos definir una clase de entidad como una superclase para 
punto, polilínea y polígono. Los siguientes son ejemplos de las cuatro clases:
• Rasgo:Normalmente, unRasgoclase (Figura 2.5) tiene un nombre para mantener el 
nombre de la función y un métododibujar() para dibujar la característica en un mapa. 
El método de dibujo debe incluir al menos dos parámetros, self y map. Uno mismo se 
refiere al objeto que accede a los datos del objeto de función mientras se dibuja, 
mientras que un mapa se refiere al fondo sobre el que dibujaremos la función.
28Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
FIGURA 2.5
Diseño UML paraRasgoclase para definir atributos comunes y métodos dePunto,Polilínea, y 
Polígono.
> > > claseRasgo:
definitivamente__en eso__(yo, nombre =''):
self.nombre = nombre
definitivamentedibujar(uno mismo,mapa):
pasar
> > >
CÓDIGO 2.6
Defina una clase de entidad como una superclase para punto, polilínea y polígono.
FIGURA 2.6
Diseño UML paraPuntoclase para mantener los datos vectoriales de puntos.
Por ejemplo, el Código 2.6 es un ejemplo de definiciónRasgocomo una clase 
en Python:
• Punto:Una clase de punto (Figura 2.6) debe tener al menos dos atributos 
espaciales, x e y, para representar las coordenadas de un punto. Otro 
atributo no espacial podría incluir el nombre. Una clase Point también 
podría usar CalDis() para calcular la distancia entre dos puntos. El 
argumento de laCalDisEl método es el objeto de punto actual "yo" y otro 
objeto de punto "punto". El valor devuelto para la distancia entre dos 
puntos se designa como flotante.
Por ejemplo, Code 2.7 es un ejemplo de definición de Point como una clase en 
Python:
Después de declarar una clase Point, podemos iniciar objetos. Por 
ejemplo, podemos llenar dos puntos con datos (1, 2), (2, 2) y luego calcular 
la distancia entre los dos puntos (Código 2.8).
• Polilínea:Definir una clase de polilínea requiere diferentes atributos para 
mantener los datos de polilíneas y métodos por polilíneas. Por ejemplo, se 
pueden usar dos listas de coordenadas x, y o una lista de puntos para mantener
Programación orientada a objetos 29
> > > importarMatemáticas
> > > clasePunto(Rasgo):
definitivamente__en eso__(uno mismo, x = 0.0, y = 0.0):
self.x = x
self.y = y
definitivamenteCalDis(yo, punto):
devolvermath.sqrt((self.x-point.x)**2+(self.y-point.y)**2)
> > >
CÓDIGO 2.7
Defina una clase Point en Python.
> > > p1 = Punto(1,2)
> > > p2 = Punto(2,2)
> > > p1.calDis(p2)
1.0
> > >
CÓDIGO 2.8
Calcula la distancia entre (1, 2) y (2, 2).
las coordenadas x, y dependiendo del diseño. Para fines orientados a objetos, 
podemos usar el segundo enfoque (Figura 2.7a). Para un mejor rendimiento del 
sistema, los puntos de datos en polilíneas son diferentes de los objetos reales 
en GIS, por lo que usamos el primer enfoque (Figura 2.7b).
• Polígono:APolígonoclase (Figura 2.8) podría tener un atributo, "puntos", para 
representar la lista de todos los puntos usados para definir el borde o dos 
listas: las coordenadas x e y para todos esos puntos. APolígono la clase también 
puede tener un métodoobtenerLongitud() para calcular el borde
(a) (b)
FIGURA 2.7
(a) La clase UML Polyline usa la lista de objetos de puntos para mantener las coordenadas de las polilíneas. (b) La clase Polilíneas de UML utiliza 
listas x e y para mantener los datos de las coordenadas de las polilíneas.
FIGURA 2.8
Diseño UML paraPolígonoclase para mantener los datos vectoriales de polígonos.
30Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
> > > # importar módulo matemático desde Python
> > > importarMatemáticas
> > > clasePolilínea(Rasgo):
# Método de inicio para un objeto de polilínea 
definitivamente__en eso__(uno mismo, puntos = []):
self.puntos = puntos
# Un método para establecer puntos 
definitivamentepuntos de ajuste(yo, puntos):
self.puntos = puntos
# Un método para obtener la longitud del objeto polilínea definitivamente
obtenerLongitud(uno mismo):
longitud = 0,0
porienrango(Len(puntos.propios)-1):
longitud+=math.sqrt((puntos[i].x-puntos[i+1].x)**2+
(puntos[i].y-puntos[i+1].y)**2)
devolverlongitud
> > >
CÓDIGO 2.9
Una clase Polyline tiene un atributo (puntos),dos métodos (puntos de ajuste(), yobtenerLongitud()).
longitud del polígono sin argumentos. El valor devuelto para la longitud del 
borde del polígono se designa como flotante.
2.4 Experiencia práctica con Python
El Código 2.9 define una clase de polilínea y crea un objeto de polilínea. Escriba 
el ejemplo en su computadora y describa qué define cada línea y por qué se 
incluye en el código.
2.5 Resumen del capítulo
Este capítulo trata sobre la programación orientada a objetos y sobre cómo 
programar objetos, clases y relaciones. Después de leer, debería poder 
hacer lo siguiente:
• Comprender la programación orientada a objetos usando Python.
• Definir una clase y saber cómo crear objetos usando Punto, Polilínea y 
Polígono.
• Practica heredar superclases.
• Saber reutilizar el código y sus funciones necesarias.
Programación orientada a objetos 31
PROBLEMAS
1. Elija tres puntos, por ejemplo, (1, 100), (25, 60) y (1, 1). ¿Podrías formar 
una polilínea o polígono usando estos tres puntos?
2. Cree un algoritmo para calcular la distancia entre dos puntos, por 
ejemplo, (x1, y1), (X2, y2).
3. Lea el Tutorial de Python 6.2 y 6.3. (Utilice la ventana de línea de comandos de 
Python para 6.2).
4. Definir y programar tres clases paraPunto,Polilínea, yPolígono.
5. Agregue el cálculo de distancia entre cada dos puntos y programe para 
calcular la distancia entre los tres puntos dados.
6. Agrega elobtenerLongitud() método enPolilíneayPolígono; crea una 
polilínea y un polígono usando los tres puntos dados; calcular la longitud 
de la polilínea y el perímetro del polígono.
http://taylorandfrancis.com
Sección II
Programación Python
http://taylorandfrancis.com
3
Introducción a Python
Aprender un lenguaje de programación es un viaje práctico y progresivo. 
Comenzará con lo básico y aumentará gradualmente sus habilidades en la 
codificación compleja. Este capítulo presentará los componentes fundamentales de 
Python, incluidas clases y objetos, sintaxis, tipos de datos, operadores, funciones, 
control de flujo, excepciones, entrada/salida y módulos. Varias bibliotecas están 
disponibles para desarrollo específico, incluidas interfaces gráficas de usuario, bases 
de datos, Internet y programación web. Para facilitar el proceso de aprendizaje, 
utilizará su comprensión de GIS para comenzar a crear un paquete mini-GIS 
mientras aprende el lenguaje de programación.
3.1 Soporte orientado a objetos
Una de las características más importantes de Python es la estructura orientada a 
objetos. La programación fundamental de Python requiere la comprensión de conceptos 
sobre clases y objetos, herencia, composición, paquetes y uso compartido de clases. 
Python proporciona el mecanismo para definir una clase y crear objetos a partir de esa 
clase.
Las clases y los objetos son ampliamente utilizados en Python. Los objetos son 
instancias de clases. Los objetos tienen atributos y métodos. Dot(.) se refiere a los 
atributos y métodos de un objeto. EnCapitulo 2, este libro definióPuntoclase y 
creadop1como objeto puntual. Puedes usarp1.xyp1.calDis() para llamar al atributo y 
método del objeto. La herencia le ayuda a reutilizar los atributos y métodos de una 
clase (superclase) mediante el uso de la superclase para definir nuevas clases en el 
formato 'clase subclase (superclase)'. Todos los atributos y métodos públicos y 
protegidos son heredados por las subclases automáticamente. Los atributos y 
métodos privados no se heredarán. Por ejemplo, tres clases de vectores (Punto,
Polilínea, yPolígono) se definen al heredar el método de la clase Featuredibujar() 
como se detalla enCapitulo 2. La composición ayuda a mantener la relación parte-
todo, donde un objeto de una clase incluye objetos de otras clases. Python usa la 
referencia a objetos para implementar la relación de composición. Como se discutió 
en Capitulo 2, se utiliza una lista de puntos para mantener las coordenadas de un 
borde de polilínea o polígono.
Cuando se desarrollan clases y métodos para software, las clases/métodos 
similares se agrupan en el mismo módulo para facilitar la organización. Así que todo
35
36Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
Las clases de datos GIS se pueden poner en un gran módulo. Los submódulos incluyen clases/
métodos para tipos de datos vectoriales, ráster y especiales. Si otras clases necesitan acceder a 
las clases/métodos en un módulo, primero se debe importar el módulo. Por ejemplo, el módulo 
matemático en Code 2.5 y Code 2.6 se importa para acceder a todos los métodos matemáticos 
(p. ej., math.sqrt).
3.2 Sintaxis
3.2.1 Sensibilidad a mayúsculas y minúsculas
pitón esdistingue mayúsculas y minúsculas, lo que significa que las letras mayúsculas y 
minúsculas representan identificadores diferentes. Puede definir una variable myList con 
mayúsculasLy almacene la lista de elementos "1, 2, 3 y 4". Si obtiene el primer valor de la lista 
usando mi lista[0]con minúsculasyo, verás unError de nombre, lo que demuestra quemi lista no 
está definido porque definiste myList usando una L mayúscula (Código 3.1).
3.2.2 Caracteres especiales
Python tiene una lista de caracteres especiales con significados especiales.Tabla 3.1
enumera algunos caracteres especiales comunes y sus respectivas funciones.
3.2.3 Sangría
En Python, la sangría es importante para agrupar código. Las líneas sangradas comienzan en 
diferentes posiciones o columnas; los números no están permitidos, desencadenarán unError 
de sangría.Puede usar un número diferente de espacios o columnas para sangrar diferentes 
niveles de declaraciones; sin embargo, se recomiendan 4 u 8 espacios. Por lo tanto,espacio y 
pestañasdesempeñan un papel importante en la organización de los códigos. Los diferentes 
editores de programas (p. ej., la línea de comandos y la GUI de Python) usan "pestaña" de 
diferentes maneras. Dependiendo de su editor de texto, puede representar diferentes números 
de espacios.
> > > miLista = [1,2,3,4]
> > > miLista[0]
1
> > > mi lista[0]
Rastreo (llamadas recientes más última):
Archivo "<pyshell#2>", línea 1, en <módulo>
mi lista[0]
NameError: el nombre 'mylist' no está definido
> > >
CÓDIGO 3.1
Distingue mayúsculas y minúsculas.
Introducción a Python 37
TABLA 3.1
Caracteres especiales en Python
simbolos
\
Función Ejemplo
Caracteres de escape que tienen un
significado especial
> > > impresión''prueba'' 
prueba
> > > impresión'\'prueba\'' 
'prueba'
> > > impresión'\\prueba' 
\prueba
\norte Nueva línea > > > impresión'primera línea\nsegunda línea' 
primera linea
segunda linea
\t Pestaña > > > impresión'str1\tstr2' str1 
str2
: Ir al siguiente nivel de declaraciones > > > clasePolilínea: definitivamente
obtenerLongitud():
pasar
#
;
Indicar comentarios de Python > > > # este es un comentario
Unir varias declaraciones en un
linea sola
> > > importarMatemáticas; x = matemáticas.pow(2,3)
> > > importarmatemática y = matemática.pow(2,3) 
Error de sintaxis: sintaxis invalida
3.2.4 Palabras clave
Las palabras clave, como def y del, son palabras reservadas y no se pueden utilizar para 
ningún otro fin (p. ej., como nombres de variables, clases y objetos); de lo contrario, un
Error de sintaxisocurrirá (Código 3.2).Cuadro 3.2enumera las palabras clave en Python.
> > > x =y
Error de sintaxis: sintaxis invalida
> > >
CÓDIGO 3.2
Ejemplo de SyntaxError de palabras clave.
TABLA 3.2
Palabras clave de Python
y
afirmar
descanso
clase
Seguir
Def
Supr
elif
más
excepto
ejecutivo
finalmente
por
de
global
si
importar
en
es
lambda
no
o
pasar
impresión
elevar
devolver
probar
tiempo
38Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
> > > un = segundo = c = 0
> > > a1,b1,c1= 1, 1.0,'c1'
> > > (a1,b1,c1)=(2, 2.0,'c2')
> > > (a2,b2,c2)=(2, 2.0,'c2')
> > > un, segundo, c, a1, b1, c1, a2, b2, c2 (0, 0, 0, 
2, 2.0, 'c2', 2, 2.0, 'c2')
> > >
CÓDIGO 3.3
Múltiples asignaciones.
3.2.5 Asignaciones Múltiples
Las asignaciones múltiples son útiles para declarar variablessimultáneamente.
En Código 3.3,
• La primera línea de código asigna el mismo valor a múltiples variables 
usando “a=b=C=valor.”
• La segunda y tercera líneas de código asignan diferentes valores a 
diferentes variables usando "a1, b1, c1 = v1, v2, v3" o "(a2, b2, c2) = (v1, 
v2, v3)".
3.2.6 Espacio de nombres
un espacio de nombreses un lugar en el que reside un nombre. Las variables dentro de un espacio de nombres son 
distintas de las variables que tienen los mismos nombres pero se encuentran fuera del espacio de nombres. Es muy 
fácil confundir nombres en diferentes espacios de nombres. La estratificación del espacio de nombres se denomina 
alcance. Un nombre se coloca dentro de un espacio de nombres cuando a ese nombre se le asigna un valor. Usar
directoriopara mostrar los nombres disponibles dentro de un espacio de nombres indicado. Por ejemplo,directorio() 
puede encontrar nombres de espacios de nombres actuales,directorio(sistema)
Espacio de nombres incorporado
(nombres integrados, como int()) Más exterior
alcance
Espacio de nombres global
(nombres globales) Global
alcance
Espacio de nombres local
(nombres locales) Local
alcance
FIGURA 3.1
Jerarquía de espacios de nombres.
Introducción a Python 39
encontrará todos los nombres disponibles desistema, ydirectorio(Matemáticas) encontrará todos los nombres 
disponibles deMatemáticas. Un programa típicamente incluye tres capas de alcance (Figura 3.1):
• La capa superior es un espacio de nombres integrado en el sistema, que incluye 
nombres definidos dentro de Python mismo; siempre están disponibles en su 
entorno de programación.
• La capa intermedia es un espacio de nombres global definido dentro de un archivo o módulo.
• La capa inferior es el espacio de nombres local, que incluye nombres definidos dentro 
de una función o un método de clase.
3.2.7 Alcance
Alcancese refiere a una parte del código y se utiliza para identificar la eficacia de las 
variables. El alcance es importante en funciones, módulos, clases, objetos y datos 
devueltos. Los módulos con función y datos actúan de forma similar a los objetos. 
Por ejemplo, al definirPuntoclase, usop1como una variable dentro de la CalDis() 
función de la clase; o usarp1para hacer referencia a un objeto más tarde al crear un 
objeto de punto. El primerop1sólo es eficaz en el ámbito de laPuntoclase' CalDis() 
función. El segundop1solo es efectivo al mismo nivel que el programa general sin 
sangría.
Las variables pueden ser locales o globales:
• Las variables locales se declaran dentro de una función y solo son accesibles 
dentro de la función. Una vez que se ejecuta la función, la variable quedará 
fuera del alcance.
• Las variables globales no son locales y se puede acceder a ellas dentro o fuera de las 
funciones.
En el ejemplo deFigura 3.2, global_x es una variable global y local_y es una 
variable local. Si usa la variable local_y fuera de la función, obtendrá un error. Para 
obtener más información sobre los espacios de nombres y el alcance, consulte 
Raschka (2014).
FIGURA 3.2
Variables locales y globales.
40Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
3.3 Tipos de datos
en pitón,tipos de datosson dinámicos para que no tenga que definir el tipo de datos 
de una variable. El tipo de variable se asignará cuando se asigne un valor. El cambio 
en los valores cambiará el tipo de variables. Hay dos categorías de tipos de datos: 
tipos de datos básicos (entero, flotante, largo, complejo, cadenas, tipo y función) y 
tipos de datos compuestos (listas, tuplas y diccionarios).
3.3.1 Tipos de datos básicos
Los tipos de datos básicos incluyen categorías de números y cadenas. La categoría de 
números incluye enteros, enteros largos y flotantes (Cuadro 3.3).
• Enteros
Los números enteros son equivalentes a los números enteros en el lenguaje de programación C. El rango 
de un entero está limitado de la siguiente manera:
− 231∼232(−2147483648∼4294967296)
El valor entero se puede representar en formato decimal, octal y 
hexadecimal. Por ejemplo,010es una representación octal de 8 y
buey80es un hexadecimal de 8.
• Números enteros largos de longitud no limitada
El rango de enteros largos solo está limitado por la memoria de la computadora. Un 
número entero largo se denota agregando una "L" mayúscula o minúscula. También 
se puede representar en formato decimal octal y hexadecimal.
• Flotar
Los números flotantes son equivalentes a los dobles en lenguaje C. Un 
valor flotante se denota con un punto decimal (.) en el lugar apropiado y
CUADRO 3.3
Tipos de datos básicos
Variable básica
Tipos
Conversión
(Encasillar)Rango
− 231∼232
Descripción Ejemplos
número entero decimales, octales,
y hexadecimal
formato
20, −20, 010,
buey80
int(), por ejemplo, int(2.0),
int('2'), int(2L)
Largo
entero
Limitado solo por
memoria
Denotado por(L)
o(l).
20L, −20L,
010L, buey80L
largo(), por ejemplo,
largo(2), largo('2')
flotar Depende de la máquina
arquitectura y
intérprete de pitón
denotado por un
punto decimal(.)
0,0, −77,0, 1,6,
2.3e25, 4.3e-2
float(), por ejemplo,
flotar(2),
Cuerda N / A Denotado por(''),
(“”)
'prueba prueba" str(), por ejemplo, str(2.0)
Introducción a Python 41
> > > x =En t(2.01)
> > > X
2
> > > flotar(2)
2.0
> > >
CÓDIGO 3.4
Conversión de tipos de datos.
un sufijo "e" opcional (ya sea en minúsculas o mayúsculas) que representa 
la notación científica. La precisión, o el rango del flotador, depende de la 
arquitectura de una máquina, así como del intérprete de Python utilizado.
• Conversión de números
losint(), largo(), flotante()Las funciones integradas se utilizan para convertir de 
cualquier tipo numérico a otro (Código 3.4).
Puntas
Encasillar:Convierta datos de un tipo a otro, por ejemplo, flotante ('3.14'), que convierte 
un tipo de datos de cadena en flotante.
La asignación de tipo conversado puede resultar en una pérdida de precisión, por ejemplo
y = 3.14
x = int(y)
donde x perderá los valores de precisión y tendrá como resultado un valor de 3.
• Cuerdas
Los datos de cadena se denotan con comillas simples '' o comillas dobles "".
• Otros tipos incorporados
Hay varios otros tipos de datos incorporados, como tipo, Ninguno, función 
y archivo. El código 3.5 ilustra los siguientes tipos:
Tipo de función ()toma un objeto como argumento y devuelve el 
tipo de datos del objeto.
Ningunaes el objeto nulo y no tiene atributo.
boolobjeto tiene dos valores potenciales:VerdaderoyFalso. Las expresiones 
condicionales darán como resultado un valor booleano comoVerdaderooFalso.
Puntas
A diferencia del lenguaje C o Java, Python no admite los tipos de datos Byte, 
Boolean, Char, Pointer.
42Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
> > > x =escribe(1)
> > > X
<escriba 'int'>
> > > X ==En t
Verdadero
> > > x =escribe(Verdadero)
> > > X
<escriba 'bool'>
> > > X ==En t
Falso
Expresión condicional
> > > escribe(Ninguna) 
<escriba 'NingunoTipo'>
> > >
CÓDIGO 3.5
Tipo de función, tipo Ninguno y tipo bool.
3.3.2 Tipos de datos compuestos
Otra categoría de tipos de datos variables integrados se denomina tipo de datos compuestos (
Tabla 3.4). Los tipos de datos compuestos se ordenan y se puede acceder a ellos 
secuencialmente a través de compensaciones de índice en el conjunto. Este grupo, también 
conocido como secuencias, generalmente incluye listas, tuplas, diccionarios y conjuntos. Una 
lista son diferentes tipos de datos separados por comas y se incluyen en un par de corchetes, 
por ejemplo, [1, 2, 3, 4]. Las tuplas son listas de diferentes tipos de datos, como (1, "los 
primeros productos calificados", "leche") entre paréntesis. Los diccionarios son listas de claves y 
pares de valores, como se muestra en el siguiente ejemplo {'john':'3-1111', 'phil':'3-4742', 
'david':'3-1212'}
• Lista
El tipo de datos compuestos más utilizado e importante eslista, que se 
puede utilizar para agrupar diferentes valores. Usarlistapara mantener una 
serie de puntos, polilíneas y polígonos en programasGIS.
Definir: Se puede crear un objeto de lista a partir de:[v1, v2, v3, ….], donde 
los elementos están entre corchetes (p. ej., como en el Código 3.6).
Operadores:Los tipos de datos compuestos son buenos para expresar operaciones 
complejas en una sola instrucción.Tabla 3.4enumera los operadores comunes compartidos 
por tipos de datos complejos.
• seq[index]: obtiene un valor para un elemento específico. El índice inicial de todos 
los datos de secuencia es 0 y el índice final es uno menos que el número de 
elementosnorteen la secuencia (es decir,norte-1) (Código 3.6a).
CUADRO 3.4
Tipos de datos compuestos y operadores comunes
Envase Definir Rasgo Ejemplos Operadores comunes
Lista
tupla
Delimitado por [ ]; mudable
inmutable
['a B C']
('a B C')
seq[índice],
seq[índice1: índice2],
seq * expr,
seq1 + seq2, obj en 
seq, obj no en seq, 
len(seq) etc.
Denotado por
paréntesis ()
diccionario {clave: valor, clave:
valor , …}
mudable {'Alicia': '7039931234',
'Beth': '7033801235'}
Introducción a Python 43
> > > a = [1,2,3,4]
> > > a
[1, 2, 3, 4]
> > > b = [x*3porXena]
> > > b
[3, 6, 9, 12]
> > > un[0]
1
> > > un[3]
4
> > > un[4]
Rastreo (llamadas recientes más última):
Archivo "<pyshell#27>", línea 1, en <módulo>
un[4]
IndexError: índice de lista fuera de rango
> > > Len(a)
4
> > > un[1:3]
[2, 3]
> > > delun[0]
> > > a
[2, 3, 4]
> > > un*3
[2, 3, 4, 2, 3, 4, 2, 3, 4]
> > > a+b
[2, 3, 4, 3, 6, 9, 12]
> > > a = [1,4,7,9]
> > > suma= 0
> > > poriena: suma
+=yo
> > > suma
21
> > >
CÓDIGO 3.6
Ejemplo de lista.
Si intenta acceder a un elemento con un índice mayor que el 
número total de elementos, obtendrá unIndexError, lo que indica 
que el índice está fuera de rango (Código 3.6b).
• len[lista]: obtiene la longitud de los elementos (calcula el número total del 
elemento) (Código 3.6c).
> > > a = [1,2,3,4]
> > > un[0]
1
> > > un[3]
4
CÓDIGO 3.6a
Una operación de lista.
44Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
> > > a = [1,2,3,4]
> > > un[4]
Rastreo (llamadas recientes más última):
Archivo "<pyshell#27>", línea 1, en <módulo>
un[4]
IndexError: índice de lista fuera de rango
CÓDIGO 3.6b
Listar operación fuera de rango.
> > > a = [1,2,3,4]
> > > Len(a)
4
CÓDIGO 3.6c
Longitud de la lista.
• seq[index1: index2]: genera una nueva secuencia de tipo de datos con 
elementos secuenciados de index1 a index2 (Código 3.6d).
• delseq[index]: borra los elementos secuenciados comoíndice(Código 3.6e).
• seq * expr (Código 3.6f)
• seq1 + seq2: une dos objetos de secuencia (Código 3.6g)
> > > a = [1,2,3,4]
> > > un[1:3]
[2, 3]
CÓDIGO 3.6d
Subconjunto de una lista.
> > > a = [1,2,3,4]
> > > a
[1, 2, 3, 4]
> > > delun[0]
> > > a
[2, 3, 4]
CÓDIGO 3.6e
Eliminar un elemento de una Lista.
> > > a = [1,2,3,4]
> > > un*3
[1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4]
CÓDIGO 3.6f
List multiplica un entero.
Introducción a Python 45
> > > a = [1,2,3,4]
> > > a = [11,12,13,14]
> > > a + b
[1, 2, 3, 4, 11, 12, 13, 14]
CÓDIGO 3.6g
Unión de dos objetos de secuencia.
> > > a = [1,4,7,9]
> > > suma= 0
> > > poriena: suma
+=yo
> > > suma
21
CÓDIGO 3.6h
Bucle cada objeto en los datos complejos.
• obj in seq (obj not in seq): recorre cada objeto en los datos 
complejos y realiza una operación con cada elemento. El ejemplo 
pasa por cada objeto en la lista a, y suma el valor de cada objeto a 
la suma obj (Código 3.6h).
El tipo de datos de cadena también pertenece al tipo de datos de secuencia, y esos 
operadores se pueden aplicar a un objeto de cadena.
Métodos:Como se vio en las clases creadas en los capítulos anteriores, una lista es una clase 
integrada en el sistema. Los objetos creados a partir de la lista tienen muchos métodos. Los 
métodos más importantes incluyenadjuntar(),insertar(),retirar(),estallido(),clasificar(), y reverso()
(Código 3.7).
> > > a = [1,2,3,4]
> > > a.añadir(10)
> > > a
[1, 2, 3, 4, 10]
> > > a.insertar(2,15)
> > > a
[1, 2, 15, 3, 4, 10]
> > > Un estallido()
10
> > > a
[1, 2, 15, 3, 4]
> > > un tipo()
> > > a
[1, 2, 3, 4, 15]
> > >
Agregue el elemento 10 en la última posición
Insertar elemento 15 en la posición de índice
Mostrar el último elemento
ordenar la lista
CÓDIGO 3.7
Lista de métodos.
46Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
Funciones integradas:Hay tres funciones integradas comunes para manejar 
una lista, que son útiles en la programación GIS (Khalid 2016):
• filtrar(función, lista): el filtro se utiliza para extraer una lista de objetivos de la lista original. 
Por ejemplo, puede usar la función de filtro para seleccionar todas las ciudades dentro de 
Virginia, o seleccionar los restaurantes y hoteles dentro de la ciudad de Fairfax.
• mapa(func, list): Map se usa para convertir la lista original en una nueva 
lista usando la función. Por ejemplo, puede convertirlo de grados a metros.
• reducir(func, list): Reduce es otro método útil para problemas GIS del mundo 
real. Para calcular la longitud total de calles o caminos del condado de Fairfax,
reducirpuede invocar una funciónfunciónde forma iterativa sobre cada 
elemento de la lista, devolviendo un solo valor acumulativo.
• Tupla
Similar a las listas,tuplaes otro tipo de datos complejo. Una diferencia obvia 
entre tupla y lista es que se denota mediante el uso de paréntesis. Otra 
diferencia es que el tipo de datos de tupla es inmutable (Tabla 3.4), lo que 
significa que el elemento no se puede modificar una vez definido. Se 
producirá un error si el valor de untuplase modifica el elemento (Código 
3.8).
• Diccionario
Un diccionario es mutable y un tipo de datos de contenedor que puede almacenar 
cualquier objeto de Python, incluidos otros tipos de contenedor. Un diccionario se 
diferencia de los contenedores de tipo secuencia (listas y tuplas) en cómo se almacenan y 
se accede a los datos.
> > > a = [1,2,3,4]
> > > a
[1, 2, 3, 4]
> > > un[0]=5
> > > a
[5, 2, 3, 4]
> > > x = (1,2,3,4)
> > > X
(1, 2, 3, 4)
> > > x[0]=5
Inmutable, no se puede cambiar.
Rastreo (llamadas recientes más última):
Archivo "<pyshell#55>", línea 1, en <módulo>
x[0]=5
TypeError: el objeto 'tuple' no admite la asignación de elementos
> > >
CÓDIGO 3.8
Operación tupla.
Introducción a Python 47
> > > estacionamientos = {'A': [-101.12, 32.13,'estacionamiento A', 
'Estacionamiento general'],'B': [-101.14, 32.56,'estacionamiento B', 'Solo 
cosas'] }
> > > estacionamientos
{'A': [-101.12, 32.13, 'estacionamiento A', 'Estacionamiento 
general'], 'B': [-101.14, 32.56, 'estacionamiento B', 'Solo cosas']}
> > > estacionamientos['A']
[-101.12, 32.13, 'estacionamiento A', 'Estacionamiento general']
> > >
CÓDIGO 3.9
Operación de diccionario.
Definir:La sintaxis utilizada para definir una entrada de diccionario es {clave:valor, clave:valor, …..}, 
donde todos los elementos están encerrados entre llaves. Es conveniente almacenar objetos de 
características espaciales para que cada objeto incluya un ID de objeto único, atributos espaciales 
(coordenadas) y atributos no espaciales (p. ej., Nombre). Donde se pueden usar ID únicos como clave, 
todos los atributos se pueden usar como valor. Las claves son números enteros o cadenas, mientras 
que los valores pueden ser cualquier tipo de datos, comolistaodiccionario(Código 3.9).
En Código 3.9,estacionamientosse declara como un tipo de datos de diccionario que incluye 
dos elementos. La identificación única y la secuencia del estacionamiento 'A' y 'B' se utilizan 
como claves, y la información de atributo de cada clave se mantiene en una lista distinta.
• Establecer
Establecerse utiliza para construir y manipular colecciones desordenadas de 
elementos únicos. Aestablecerel objeto puede ser creado desde {v1, v2, v3,….} 
donde los elementos están rodeados por llaves, o de unconjunto (lista) donde el 
argumento es unlista(Código 3.10).
Operaciones:Set admite varias operaciones (Cuadro 3.5), incluyendo unión (|), 
intersección (&), diferencia (-) y diferencia simétrica (̂ ) (Linuxtopia 2016).
Métodos:Estableceres una clase incorporadadel sistema. Varios métodos importantes 
están respaldados por unestablecerobjeto, incluidos add(), remove() y pop(). También
> > > s = {1,3}
> > > s
conjunto ([1, 3])
> > > a = [2,4,3,1]
> > > s =establecer(a)
> > > s
conjunto ([1, 2, 3, 4])
> > >
CÓDIGO 3.10
Ajuste la operación.
48Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
TABLA 3.5
Operaciones entre dosEstablecerObjetos,syt
Operación
diferencia
Operador
−
Función Uso
Crear un nuevo conjunto con
elementos enspero no ent
intersección & Crear un nuevo conjunto con
elementos comunes a
syt
Obtenga objetos espaciales con ambos
coincidieron las condiciones, como encontrar 
los restaurantes dentro de Fairfax, así como 
con estilo francés
simétrico
diferencia
^ Crear un nuevo conjunto con
elementos en cualquierasot 
pero no ambos
Unión | Crear un nuevo conjunto con
elementos en ambossyt
Combine las ciudades de dos estados para obtener
recopilación
> > > s =establecer(['A B C D'])
> > > t =establecer(['A', 'B', 'E', 'F'])
> > > S t
conjunto (['C', 'D'])
> > > S t
conjunto (['A', 'B'])
> > > Mierda
conjunto (['C', 'E', 'D', 'F'])
> > > mierda
conjunto (['A', 'C', 'B', 'E', 'D', 'F'])
> > > s.diferencia(t) 
conjunto (['C', 'D'])
CÓDIGO 3.11
Establecer operaciones.
admite cuatro métodos: difference(),intersection(), symmetric_difference() y 
union() (Código 3.11).
3.4 Varios
3.4.1 Variables
Una variable es un espacio de memoria reservado para almacenar datos y al que se hace 
referencia por su nombre. Antes de su uso, se debe asignar un valor a una variable. Las 
variables tienen diferentes tipos de valores. Los tipos básicos de valores de variables incluyen 
byte, short, int, long, text, float y double, como se presentó en la Sección 3.4.1. Algunos tipos de 
datos se pueden convertir mediante typecast. Por ejemplo, float(“3.14”) convertirá los textos en 
un número flotante 3.14.
Introducción a Python 49
FIGURA 3.3
Tipo de datos dinámicos.
En Python, los tipos de variables son dinámicos, y el tipo solo se define cuando se 
asigna su valor. Esto significa que una variable puede cambiar a un tipo de datos 
diferente. Por ejemplo (Figura 3.3), x = float(1) asignará x como flotante, pero x = 'x tiene 
un tipo dinámico' cambiará la variable x de un tipo flotante a un tipo de cadena. Aquí, 
usamos 'p1' como un nombre de variable de objeto.
Se requiere un nombre para cada variable. El nombre de la variable debe ser un 
identificador legal, que es una serie de combinación limitada de letras del alfabeto, 
dígitos y guiones bajos. El nombre debe comenzar con un carácter o guión bajo, pero no 
puede comenzar con un dígito. Por lo tanto, 'punto1' es un nombre legal, pero '1punto' es 
ilegal. Además, no se permiten espacios en blanco en el nombre de la variable. Palabras 
reservadas de Python (Cuadro 3.2) no se puede utilizar como nombre de variable.
3.4.2 Estilo de código
Hay varias pautas para el estilo de programación de Python.
Nombres significativos:Utilice nombres significativos para variables, clases y
paquetes Si el significado no está claro, agregue un comentario para identificar 
qué significa el nombre.
Espacio en blanco en expresiones y declaraciones:Siempre rodea
Operadores con un solo espacio a ambos lados.
Sangría:Los códigos sangrados se utilizan para organizar el código, tal como se introdujo
en la Sección 3.2.3.
Comentarios:Los comentarios se utilizan para documentar o explicar el código.
Python admite dos tipos de comentarios:
# comentarios
50Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
FIGURA 3.4
Estilo de codificación.
El compilador ignora todo, desde el#hasta el final de la línea.
línea de comentarios """ 1
línea de comentarios 2
"""
Este estilo de comentario indica cadenas de documentación (también conocidas como "docstrings"). Una 
cadena de documentación es la primera declaración en una definición de módulo, función, clase o método. 
Todos los módulos deben tener cadenas de documentación, y todas las funciones y clases exportadas por un 
módulo deben tener cadenas de documentación (Figura 3.4).
3.5 Operadores
Los operadores incluyen caracteres básicos, división y conversión de tipos, 
módulo, negación, asignación aumentada y operaciones booleanas. Estos 
operadores se clasifican en varios tipos:
• Operadores aritméticos (Tabla 3.6)
• Operadores bit a bit y de desplazamiento (Tabla 3.7): Los operadores Bitwise&Shift 
pueden ser muy complejos. Debe comprenderse una idea general acerca de estos 
operadores y este libro utilizará la representación de datos binarios.
• Operadores de Asignación (Cuadro 3.8): Los operadores de asignación se utilizan 
para asignar valores a las variables. La asignación más común utiliza el símbolo 
“=”. Un ejemplo es a = b, lo que significa asignar el valor b a la variable a. Las 
asignaciones pueden integrar operadores aritméticos y Bitwise&Shift, lo que 
genera asignaciones complejas como “+=” (Agregar AND) (Código 3.12).
Introducción a Python 51
TABLA 3.6
Operadores aritméticos (Asumir variableaCapacidad para 5 y VariablebSostiene 2)
Operadores aritméticos
+
Descripción Ejemplo
Suma > > >a + b
7
− Sustracción > > > un - segundo
3
* Multiplicación > > > un * segundo
10
/ División > > >un/b
2.5
* * Exponenciación: Realiza exponencial (potencia)
cálculo de operadores
> > > un ** segundo
25
% Módulo: divide el operando de la izquierda por el de la derecha
operando y devuelve el resto
> > > un % segundo
1
// División de piso: La división de operandos donde el
resultado es el cociente en el que se eliminan los dígitos 
después del punto decimal
> > > un // segundo
2
> > >5.0 // 2.0
2.0
• Operadores de comparación (Tabla 3.9): Los operadores de comparación se 
utilizan para comparar dos variables u objetos, para comprobar si son iguales o 
diferentes.
• Operadores Lógicos (Tabla 3.10): Los operadores lógicos se utilizan junto con si, de lo 
contrario, mientraspalabras clave para crear sentencias de control lógico (Sección 
3.4). Las declaraciones con operadores lógicos son verdaderas o falsas. El código 3.13 
muestra un ejemplo.
TABLA 3.7
Operadores bit a bit y de desplazamiento (asumir variableaCapacidad para 5 y VariablebSostiene 2)
Artículo
> >
Descripción Ejemplo
Operador binario de desplazamiento a la derecha. El valor del operando izquierdo se mueve
derecho por el número de bits especificado por el operando derecho.
a >> b dará 1,
que es 0000 0001
<< Operador binario de desplazamiento a la izquierda. El valor del operando izquierdo se mueve
izquierda por el número de bits especificado por el operando derecho.
a << b dará 20,
que es 0001 0100
& El operador AND binario copia un bit al resultado si existe en
ambos operandos.
a & b darán 0,
que es 0000 0000
| El operador OR binario copia un bit si existe en cualquiera de los operandos. un | b dará 7,
que es 0000 0111
^ El operador binario XOR copia el bit si está configurado en un operando
pero no ambos.
a ^ b dará 7,
que es 0000 0111
52Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
TABLA 3.8
Operadores de asignación (asumir variableaCapacidad para 5 y Variableb 
Sostiene 2)
Asignación
Operadores Nombre Cómo utilizar Equivalente Resultado
=
+ =
− =
* =
/=
%=
* * =
|=
^=
<<=
> > =
Asignación igual
Añadir Y
Restar Y
Multiplica Y
Dividir Y
Módulo Y
Exponente Y
Binario O Y
Binario XOR Y
Desplazamiento a la izquierda Y
Desplazamiento a la derecha Y
un = segundo
a+ = segundo
a− = segundo
a* = segundo
un/ = segundo
un % = segundo
un ** = segundo
un| = segundo
un = segundo
un<< = segundo
a>> = b
Establecer a como b
a = a+b
un = un - segundo
un = un * segundo
a = a/b
a = a % b
a = a ** b
un = un | b
un = un ^ segundo
a = a << b
a = a>>b
2
7
3
10
2
1
25
7
7
20
1
> > > b=3
> > > a=b
> > > a
3
> > > a+=b
> > > a
6
CÓDIGO 3.12
Añadir Y ejemplo.
TABLA 3.9
Operadores de comparación (asumir variableaCapacidad para 5 y VariablebSostiene 2)
Comparación
Operadores Cómo utilizar Comparar(o comprobar) Resultados
= =
<
>
> =
<=
!=
es
no es
en
no en
un = = segundo
un < segundo
a > b
un > = segundo
un <= segundo
un != segundo
a es b
a no es b
a en el rango (b)
a no está en el rango (b)
a es igual a b
a es menor que ba 
es mayor que b
a es mayor o igual que ba es 
menor o igual que ba no es 
igual a b
a y b son el mismo objeto a y b 
son objetos diferentes a es 
miembro de [1, 2, …,b] a no es 
miembro de [1, 2, …,b]
(a == b) no es cierto. (a 
< b) no es cierto. (a > b) 
es verdadera.
(a >= b) es verdadera. (a 
<= b) no es cierto. (a != b) 
es verdadera.
(a es b) no es cierto. (a 
no es b) es verdadera.
(a en el rango (b)) no es cierto. (a no 
está en el rango (b)) es verdadero.
Introducción a Python 53
TABLA 3.10
Operadores lógicos (asumir variableaSe mantiene verdadero y variablebSe mantiene cierto)
Operadores Lógicos
Y
Cómo utilizar Resultados
(a y b) es verdadera.Operador lógico AND. Si ambos operandos son
verdadero, entonces la condición se vuelve verdadera.
O Operador lógico OR. Si cualquiera de los dos operandos
son distintos de cero, entonces la condición se vuelve verdadera.
(a o b) es verdadera.
No Operador lógico NOT. Úselo para invertir la lógica.
estado de su operando. Si una condición es 
verdadera, el operador Lógico NO la hará falsa.
No (a y b) es falso.
x =En t(Datos crudos('Ingrese su entrada para x: ')) y =En t(
Datos crudos('Ingrese su entrada para y: ')) six>5yy > 5:
impresión'tanto x como y son mayores que 5' siX 
> 5oy > 5:
impresión'ya sea x o y es mayor que 5' x > y:
impresión'x es más grande que y' 
nox > y:
impresión'x es más pequeño que y'
si
si
CÓDIGO 3.13
Operaciones lógicas.
3.6 Declaraciones
Una declaración es una combinación de variables y operadores. La declaración debe 
cumplir con el uso del operador. Si asigna un valor, debe usar el operador de 
asignación. Si accidentalmente usa operadores de comparación, debe esperar un 
error. Preste atención a la precisión de la declaración. Por ejemplo (Código 3.14), la 
primera y la segunda i parecen estar asignadas con valores similares usando 
operaciones idénticas de división y suma. Sin embargo, generan resultados 
diferentes.
> > > yo = 1/2+1/2
> > > i
0
> > > yo = 1,0/2 + 1,0/2
> > > i
1.0
> > >
CÓDIGO 3.14
Ejemplos de declaraciones.
54Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
3.7 Funciones
Las funciones están definidas por la palabra clavedefinitivamenteseguido del nombre de la 
función con varios argumentos de entrada. Similar a los métodos definidos dentro de una clase, 
la cantidad de argumentos puede ser de cero a muchos. Los métodos de clase son funciones 
especiales con el primer argumento como 'self'.
def funcName(arg1, arg2, …): 
Bloques de instrucciones
Una función se define mediante un nombre de función y otros argumentos de entrada 
necesarios, como funcName(arg1, arg2, …). Los argumentos pasados a una función al 
llamar a una función deben coincidir con lo declarado. Una función puede devolver 
ninguno, uno o más argumentos (Código 3.15).
Cuando declara argumentos predeterminados para métodos de clase (Sección 2.1), también 
puede configurar valores predeterminados para argumentos de función y hacer que esos 
argumentos sean opcionales para la persona que llama. El ejemplo (Código 3.16) muestra cómo 
calcular la función de costo (calCost) y taxRate como argumento predeterminado. Por lo tanto, 
cuando la función calCost se configura con el parámetro 100, la variable taxRate usa 0.05 como 
su valor.
Puntas
Use la palabra clave lambda para declarar una versión de una línea de una función. 
Por lo general, estas funciones son anónimas porque no están definidas de manera 
estándar. El cuerpo de la declaración de la función lambda se debe dar en la misma 
línea, como en la función add() (Código 3.17).
> > > # No devuelves nada
> > > definitivamenteHola():
impresión'¡Hola Mundo!'
> > > hola = hola() 
¡Hola Mundo!
> > > impresiónhola
Ninguna
> > > # Devuelve un valor
> > > definitivamenteagregar
(x,y): devolverx+y
> > > z = suma(1,2)
> > > impresiónz
3
> > >
CÓDIGO 3.15
Valor de retorno de una función.
Introducción a Python 55
> > > # Argumentos predeterminados
> > > definitivamentecostocal(precio, tasa de impuestos = 0.05): 
devolverprecio + precio*tasa de impuestos
> > > costocal(100)
105.0
> > > costocal(100,0.075)
107.5
> > >
CÓDIGO 3.16
Argumentos predeterminados.
> > > definitivamenteagregar
(x,y): devolverx+y
> > > sumar(1,2)
3
> > > un =lambdax,y:x+y
> > > b = a(1,2)
> > > impresiónb
3
CÓDIGO 3.17
ejemplo lambda
El intérprete de Python tiene funciones integradas que siempre están 
disponibles. Se enumeran en orden alfabético enFigura 3.5. Las funciones 
escritas en rojo ya se han introducido. Las funciones escritas en azul son 
importantes y se presentarán en capítulos posteriores.
FIGURA 3.5
Funciones integradas del sistema. (De Python. 2001a. Funciones integradas. https://docs.python.org/3/library/
index.html (consultado el 3 de septiembre de 2016).)
56Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
> > > números =rango(1,101,1)
> > > suma1, suma2, suma3 = 0, 0, 0
> > > poriennúmeros: 
suma1=suma1+i
> > > impresión
suma1 5050
> > > yo = 0
> > > tiempo(i<101): si
(i%2==0):
suma2=suma2+i
i+=1
> > > impresión
suma2 2550
> > > porienrango(100): si
(i%2==1):
suma3+=i
> > > impresión
suma3 2500
> > >
CÓDIGO 3.18
Cálculos sumatorios.
3.8 Experiencia práctica con Python
El programa Python (Código 3.18) calcula la suma de 1 a 100, todos los números 
impares entre 1 y 100 y todos los números pares entre 1 y 100. ¿Puede resolver 
cada uno de esos cálculos? Intente codificar en Python GUI y explique cómo 
funciona cada cálculo y la estructura de los códigos.
3.9 Resumen del capítulo
Este capítulo introduce
• Sintaxis de Python
• Tipos de datos de Python
• Operadores
• Qué es una función y cómo declarar una función
Introducción a Python 57
PROBLEMAS
1. Palabras clave: marque las siguientes palabras clave (Cuadro 3.2.) y explíquelos 
brevemente (conceptos, cuándo/cómo usar palabras clave [use la función help() 
para obtener ayuda sobre cada palabra clave, por ejemplo, help('if')], y diseñe/
programe un ejemplo de cómo usar las palabras clave ). Por ejemplo, palabras 
clave if, elif, else.
una. Explique
if, elif, else son las palabras clave utilizadas para tomar decisiones……
b. Ejemplos (Código 3.19)
2. Operadores: Las cinco categorías de operadores incluyen operadores 
aritméticos, operadores de cambio y bit a bit, operadores de asignación, 
operadores de comparación y operadores lógicos. Para cada par indicado a 
continuación, explique las diferencias entre los dos operadores y luego 
diseñe e ingrese un ejemplo en el intérprete de Python para demostrar la 
diferencia.
una. “+” frente a “+=”
b. “%” frente a “/”
C. “*” frente a “**”
d. “==” frente a “es”
mi. “!=” frente a “no es”
F. “en” vs. “no en”
gramo. “y” contra “o”
H. “no en” vs. “no”
3. Conceptos de clase y objeto
una. Describa brevemente el argumento "self" en el método de clase y proporcione 
un ejemplo.
> > > X = [1,2,3,4,5]
> > > y = 8
> > > z = [6,7,8,9]
> > > siyenX:
impresióny,'es en', X elif
yenz:
impresióny,'está en z', z
más:
impresióny,'no está ni en x ni en z', x, z
8 está en z [6, 7, 8, 9]
> > >
CÓDIGO 3.19
Si…elif…else ejemplo.
58Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
b. Diseñe una clase simple que incluya al menos un atributo estático, uno 
privado, uno protegido y uno público (que también podría ser un 
método).
C. Cree un objeto y luego acceda e imprima esos atributos.
4. Tipos de datos y funciones
En Python, los siete tipos de datos comunes son los siguientes: entero, entero 
largo, flotante, cadena, lista, tupla y diccionario. Los tres tipos básicos de datos 
vectoriales son Punto, Polilínea y Polígono. Intente implementar el siguiente 
diseño de clase de Polygon en Python utilizando los tipos de datos de Python 
adecuados(utilice otros tipos de datos en lugar de float) para los atributos y 
métodos.
Descripción: una clase Point tiene dos atributos, x e y, para representar la 
coordenada de un punto. Una clase Point también tiene un método calDis () para 
calcular la distancia entre dos puntos. Los argumentos para el método calDis son el 
objeto de punto 'self' y el otro objeto de punto es "punto". El valor devuelto para la 
distancia entre dos puntos está diseñado como flotante.
El diseño UML para la clase Point para mantener los datos vectoriales de puntos es el siguiente:
Punto (Característica)
+ x: flotar
+ y: flotar
+ calDis(p: Punto): flotante
El siguiente Código 3.20 ejemplifica cómo implementar la clase Punto: 
Descripción: Una clase Polígono tiene un atributo "puntos" para representar la 
lista de coordenadas. Una clase Polygon también tiene un método getLength() para 
calcular el perímetro del Polygon. Los argumentos para el método getLength son el 
objeto Polygon actual 'self'. El valor devuelto para la longitud del borde de un 
polígono está diseñado como flotante.
> > > importarMatemáticas
> > > clasePunto:
definitivamente__en eso__(uno mismo, x = 0, y = 0):
self.x = x
self.y = y
definitivamenteCalDis(yo, punto):
devolvermath.sqrt((self.x-point.x)**2+(self.y-point.y)**2)
> > >
CÓDIGO 3.20
Definición de clase de punto.
Introducción a Python 59
El diseño UML para una clase Polygon que mantiene datos vectoriales de polígonos es el 
siguiente:
Polígono (Característica)
+ puntos: lista<Puntos>
+ getLength(): flotar
Asigne un polígono con los siguientes datos: [(1.0, 2.0), (3.0, 5.0), (5.0, 6.0), 
(1.0, 2.0)] y calcule la longitud del borde del polígono.
http://taylorandfrancis.com
4
Estructura de control del lenguaje Python, entrada/
salida de archivos y manejo de excepciones
En general, las declaraciones de los programas de computadora se ejecutan secuencialmente. 
Las estructuras de control ayudan a los programas de computadora a romper la secuencia 
saltando de un lado a otro para omitir un conjunto de declaraciones. Las estructuras de control 
hacen que los lenguajes de programación sean mucho más versátiles para resolver problemas 
del mundo real. Las estructuras de control incluyen toma de decisiones y bucles. Este capítulo 
presenta estructuras de control de Python de uso frecuente y demuestra métodos para operar 
objetos SIG. Este capítulo también lo ayuda a aprender cómo leer y/o escribir datos en un 
archivo local. Cuando un programa de Python encuentra un evento de error (también conocido 
como excepción), se bloqueará si no se maneja. Este capítulo cubre brevemente cómo capturar 
y manejar excepciones.
4.1 Toma de decisiones
Las decisiones son una de las formas más básicas de cambiar el flujo de ejecución del 
programa. Usan expresiones condicionales para evaluar si una afirmación es verdadera o 
falsa. Por ejemplo, suponiendo que a = 3 y b = 2, la expresión condicional a > b es 
verdadera, mientras que la expresión a < b es falsa.
Hay varias expresiones/valores que dan como resultado Falso:
• Cualquier número con un valor de cero (p. ej., 0, 0.0, 0L, 0j, Código 4.1 a la derecha)
• Una cadena vacía ('' o "")
• Un contenedor vacío, como lista (Código 4.1 a la izquierda), tupla, conjunto y 
diccionario
• Falso y Ninguno
Las expresiones condicionales constan de operadores y variables/valores relevantes. 
Los operadores lógicos y de comparación se utilizan para construir declaraciones y 
expresiones condicionales.
• Operadores de comparación: >,>=,<,<=,= =, !=,es, no es, en, no en
• Operadores Lógicos: y, o, no
61
62Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
> > > si[]:
impresiónVerdadero
> > > si0:
impresiónVerdadero
más: más:
impresiónFalso impresiónFalso
Falso
> > >
Falso
CÓDIGO 4.1
Expresiones condicionales falsas: lista vacía (izquierda) y cero (derecha).
Los operadores lógicos se utilizan para proporcionar múltiples expresiones 
condicionales, por ejemplo, si x>0 e y>0: imprime 'x e y son positivos', o realiza la 
negación de expresiones usando not.
• si declaración: Cuando se usa una condición para controlar la ejecución de la 
declaración, unasi declaraciónse utiliza para ejecutar el bloque de instrucciones en 
función de los resultados de la evaluación de la expresión de condición. Cuando una 
expresión de condición es verdadera, se ejecutará el siguiente bloque de 
instrucciones; de lo contrario, se omitirá el siguiente bloque de instrucciones.
Sintaxis de declaraciones
si (expresión condicional):
Bloque de declaraciones
Ejemplo de declaración:
si a > b:
escribe "a es más grande que b"
• si... otra declaración: Cuando dos condiciones resultan en ejecuciones 
diferentes, elsi declaraciónse usa con elmáscláusula. Si la expresión condicional 
es verdadera, entonces el bloque de sentencias que siguesiserá ejecutado; de lo 
contrario, el bloque de declaración despuésmásserá ejecutado.
Sintaxis de la declaración:
si (expresión condicional):
Bloque de declaraciones
más:
Bloque de declaraciones
Ejemplo de declaración:
si a > b:
escribe "a es más grande que b"
Estructura de control del lenguaje Python, entrada/salida de archivos 63
más:
escribe "a es más pequeño que b"
• if….elif…else declaración: Cuando más de dos condiciones dan como resultado 
ejecuciones diferentes respectivamente, utilicesi,elif, omás. loselifdeclaración es 
similar a lamás siutilizado en C o Java. Esta declaración permitirá a los 
programadores verificar múltiples condiciones.
elif sintaxis:
si (expresión condicional 1):
Bloque de declaraciones 1
elif (expresión condicional 2):
Bloque de declaraciones 2
elif (expresión condicional 3):
Bloque de declaración 3
…
más:
Bloque de declaraciones n
Si la expresión condicional 1 (o 2, 3,...) es verdadera, entonces se ejecutará el bloque de 
instrucciones 1 (o 2, 3...) y se omitirá el otro bloque de instrucciones. Sin embargo, si 
todas las condiciones anteriores (1, 2, 3, …., n−1) no son verdaderas, los bloques bajo más
(se ejecutará el bloque de instrucciones n).
Puntas: declaración de aprobación (Código 4.2)
pasardeclaración es única en el sentido de que no realiza ninguna función. Se 
utiliza en el proceso de toma de decisiones, diciéndole al intérprete que no haga 
nada bajo ciertas condiciones.
En el proceso de desarrollo de software, puede servir como marcador de posición, para ser 
reemplazado más tarde con código escrito (Código 4.3).
a=b=0
sia>b:
pasar
más:
pasar
CÓDIGO 4.2
Pasar declaración en estructura if… else….
definitivamentedibujar():
pasar
CÓDIGO 4.3
Pass se usa como una declaración de marcador de posición escrita en método.
64Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
4.2 Bucles
Otro tipo de estructura de control es el bucle. Por lo general, un bucle ejecuta un bloque hasta 
que su condición se vuelve falsa o hasta que ha agotado todos los elementos de secuencia en 
un contenedor (por ejemplo, una lista). Puede interrumpir un ciclo para iniciar una nueva 
iteración (usando continuar) o finalizar el ciclo (usandodescanso). Ambas cosastiempoypor se 
puede usar para recorrer un bloque de instrucciones.
• para declaración:Paraloop se utiliza para ejecutar un bloque repetido de 
sentencias por un número definido de veces.Parase usa con tipos de datos 
compuestos (también conocidos como tipos de datos de secuencia), como 
cadena, lista y tupla en la siguiente sintaxis y ejemplo, que usa un bucle for para 
calcular la suma de 1 a 100 (Código 4.4):
sintaxis:
para artículo en secuencia:
Bloque de declaraciones
• mientras declaración:tiempoLa instrucción es muy flexible y puede repetir un bloque 
de código mientras la condición sea verdadera. lostiempoLa declaración 
generalmente se aplica cuando hay un número desconocido de veces antes de 
ejecutar el bucle. El código 4.5 muestra un ejemplo del usotiempobucle para calcular 
la suma de 1 a 100.
• función range() y función len(): Losrango(Pythoncentral 2011) y LenLas 
funciones se utilizana menudo enporytiempobucles Usandorango(inicio, fin, 
paso) genera una lista donde para cualquier k, inicio <= k < fin, y k itera de 
principio a fin con incrementos de paso. Por ejemplo, range(0,4,1) produce una 
lista de [0,1,2,3]; range(0,50,10) produce una lista de [0,10,20,30,40].rangoLa 
función toma 0 como valor inicial predeterminado y 1 como paso 
predeterminado. Por ejemplo, range(4) produce una lista de [0,1,2,3]. El código 
4.4 es un ejemplo que usa range(4) para producir una lista y usa la estructura de 
bucle for para imprimir cada elemento dentro de la lista.
> > > porienrango(4): 
impresióni
0
1
2
3
CÓDIGO 4.4
Use la función de rango con valores predeterminados de inicio y paso.
Estructura de control del lenguaje Python, entrada/salida de archivos sesenta y cinco
> > > yo=0
> > > total=0
> > > tiempoi<101: 
total +=i
i+=1
> > > impresióntotal 
5050
> > >
CÓDIGO 4.5
Cálculo de resumen de 1 a 100 usando while loop.
El siguiente ejemplo ilustra cómo usar la función de rango y cómo 
calcular la suma de 1 a 100 usando eltotalvariable para contener el 
resultado resumido para bucle (Código 4.6).
La funciónlargo()devuelve el número total de elementos en datos compuestos. 
Por ejemplo, len(polyline.points) puede devolver el número de puntos dentro de una 
polilínea. El siguiente ejemplo utilizatiempoylargo()para calcular la longitud de una 
polilínea (Código 4.7).
• descanso: Adescansose utiliza para interrumpir la ejecución de un ciclo, como 
encontrar si dos líneas se cruzan entre sí. El bucle se puede romper una vez que 
los dos segmentos de línea (de cada una de las dos líneas) se cruzan (Código 
4.8).
> > > totales = 0
> > > porienrango(1,101,1): 
total+=yo
> > > impresióntotal 
5050
CÓDIGO 4.6
Calcule el resumen de 1 a 100 usando rango y bucle for.
> > > definitivamenteobtenerLongitud(polilínea):
longitud, i=0.0, 0
tiempoyo<Len(polilínea.puntos)-1:
longitud+=math.sqrt((polilínea.puntos[i].x-
polilínea.puntos[i+1].x)**2 + (polilínea.puntos[i].y-
polilínea.puntos[i+1].y)**2)
CÓDIGO 4.7
Calcular la longitud de una polilínea usandotiempobucle yLen() método.
66Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
> > > bIntersección =Falso
> > > definitivamenteintersecarse(línea1,línea2): porien
Len(línea1.segmentos de línea):
porjenlen(línea2.segmentos de línea):
si(línea1.segmentosdelínea[i].segIntersect
(línea2.segmentosdelínea[j])):
bIntersección =Verdadero
descanso
CÓDIGO 4.8
Prueba si dos líneas se cruzan entre sí usandodescansoyporcírculo.
> > > definitivamentedibujarMapa():
porienrango(Len(capas)):
si(capas[i].layerType =='Imagen'):
Seguir
capas[i].drawLayer()
CÓDIGO 4.9
Dibuja un mapa sin dibujar las capas de la imagen.
• Seguir: LosSeguirLa instrucción se usa con menos frecuencia que la instrucción 
break para omitir el resto del cuerpo de un bucle bajo una determinada 
condición. Esto puede eliminar las ejecuciones de valores de bucle específicos o 
categorías de valores. Por ejemplo, cuando se dibuja un mapa, puede 
desmarcar las capas con una imagen. El código (Código 4.9) salta todas las 
capas de la imagen:
4.3 Otras estructuras de control
• Combinación de loop y decisiones: El bucle y las decisiones se usan juntos para 
construir un control de flujo complejo:
for/while expresión condicional 1:
bloques de declaraciones 1
si expresión condicional 2
bloques de declaraciones 2
más:
romper/continuar
bloques de declaraciones 3
El siguiente ejemplo (Código 4.10) identifica los puntos compartidos entre dos polígonos 
(esto es útil para comprender la estructura de datos, aunque la tupla normalmente no se 
usa para contener coordenadas de puntos):
Estructura de control del lenguaje Python, entrada/salida de archivos 67
> > > p1, p2, p3, p4 = (0,0), (1, 1), (2, 2), (3, 3)
> > > polígono1= [p1, p2, p3]
> > > polígono2 = [p1, p2, p4]
> > > definitivamentegetCommonList(lista1, 
lista2): listacomún = []
porcadaValorenlista1:
sicadaValorenlista2:
commonList.append(eachVal)
devolverlista común
> > > resultados = getCommonList(polígono1, polígono2)
> > > impresión
resultados [(0, 0), (1, 1)]
CÓDIGO 4.10
Ejemplo de combinación de loop y decisiones.
> > > definitivamentedoble circuito():
porienrango(Len(puntos)-1):
porjenrango(Len(puntos)-i-1):
puntos[i].calDis(puntos[Len(puntos)-1-j])
CÓDIGO 4.11
Calcule la distancia entre puntos usando bucles dobles.
• Bucles anidados: Otra estructura compleja son los bucles anidados, 
especialmente los bucles dobles. Dada una lista de puntos, si tuviera que 
calcular la distancia de cada par de puntos en una lista de puntos, necesitará 
usar el bucle doble (Código 4.11).
4.4 Entrada/salida de archivos
Hay una serie de métodos integrados para operar archivos, como abrir, leer y 
escribir (PythonForBeginers 2012).
• Abriendo un archivo: Para operar un archivo, use la funciónabiertocon un nombre de 
archivo y un modo de operación de archivo como argumentos. En el ejemplo f = 
open(filename, mode), el modo podría ser
• 'r': cuando el archivo solo se leerá, y este es el valor 
predeterminado.
• 'w': solo para escritura (se borrará un archivo existente con el mismo 
nombre).
68Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
• 'a': abre el archivo para agregarlo; todos los datos escritos en el archivo se agregan 
automáticamente al final del archivo.
• 'r+': abre el archivo tanto para lectura como para escritura.
• leyendo un archivo: Losabierto() cargará el archivo desde el almacenamiento en disco a la 
memoria y lo devolverá como un objeto de archivo. Este objeto de archivo tiene tres métodos de 
lectura de archivos:
• leer(tamaño): devuelve el archivo completo cuando no se pasa ningún parámetro de tamaño 
(por defecto, el tamaño es igual a −1), o el contenido como una cadena en el tamaño de bytes 
especificado.
• línea de lectura(): lee y devuelve una línea como una cadena (incluido el 
final '\n').
• líneas de lectura(): lee y devuelve todas las líneas del archivo como una lista de 
cadenas (incluido el final '\n').
• escribiendo un archivo: Un objeto de archivo tiene dos métodos escritos:
• escribe(str): escribe la cadena 'str' en el archivo.
• líneas de escritura(lista): escribe una lista de cadenas en el archivo; cada elemento de cadena 
es una línea en el archivo.
losescribeLa función escribe el contenido de una cadena en un archivo. Sin embargo, existen 
otros tipos de datos, como float e integer. ¿Cómo se escriben los datos en un archivo? Dado que 
una cadena actúa como argumento de entrada, elcadena()yrepetir() La función convertirá un 
objeto que no sea una cadena en un objeto de cadena. Por ejemplo, si escribe un número 
flotante 3.14 en un archivo, puede usarescribe(calle(3.14)). Por lo general, un archivo de texto 
se organiza línea por línea, mientras que elescribe() escribe datos en un archivo y los cambia a 
una nueva línea usando los caracteres especiales "\n". Por lo tanto, escribir ("primera 
línea\nsegunda línea") generará dos líneas en el archivo como se muestra a continuación:
primera linea
segunda linea
El valor devuelto también es una cadena al leer los datos de un archivo con leer() ylínea 
de lectura(); por lo tanto, debemos formatear esos valores de cadena en el tipo de datos 
que prefiramos. Nosotros podemos usarflotar(str), por ejemplo,flotar('3.14'),En t(str), por 
ejemplo,En t('2.0'), ylargo(str), por ejemplo,largo('2.0l') para convertir cadenas en 
números.
• Cambiar la posición del puntero del objeto de archivo: Mientras leemos un archivo, es 
posible que necesitemos omitir varias líneas y leer información específica en el 
archivo. En tales circunstancias, podemos localizar líneas y palabras específicas de un 
archivo con los siguientes dos métodos:
Estructura de control del lenguaje Python, entrada/salida de archivos 69
• buscar(fuera de tamaño, de dónde): ir a una posición dentro de un archivo, con bytes 
fuera de tamañocompensardeDe dónde(0==comienzo del archivo, 1==ubicación actual 
o 2==fin del archivo).• decir(): devuelve la posición actual del cursor/puntero dentro de un archivo.
• cerrar un archivo: Después de que terminemos de manipular un archivo, debemos 
cerrar el archivo para liberarlo de la memoria con el método:
• cerca(): cerrar un archivo
Este es un paso muy importante cada vez que leemos o escribimos datos en un 
archivo. Sin este paso, el archivo se mantendrá en la memoria y puede agotar la 
memoria disponible del sistema (pérdida de memoria) si se abren demasiados 
archivos. Es posible que los datos no se conserven en el disco duro antes de cerrar un 
archivo.
4.5 Excepciones
Las excepciones (Python 2001b) son los errores encontrados al ejecutar programas 
de Python, por ejemplo, los errores para abrir un archivo que no existe, dividir por 
cero, concatenar objetos 'str' e 'int'. Estas excepciones se pueden manejar en 
programas de Python usando elprueba... excepto...declaración. Puede haber uno o 
másexceptocláusulas en la declaración. CadaexceptoLa cláusula se utiliza para 
capturar una excepción. Si una cláusula de excepción coincide con la excepción, el 
programa ejecutará laexceptocláusula. Si noexceptocoincide con la cláusula, el 
programa se pasará al exteriorprobardeclaraciones y dan el error de excepción. 
Code 4.12 maneja el ZeroDivisionError usando elprueba... excepto... declaración.
> > > definitivamentePendiente(x1,y1,x2,y2): 
probar:
devolver(y2-y1)/(x2-x1)
exceptoError de división cero:
impresión'Error: x1 es igual a x2' 
devolverNinguna
> > > pendiente (1,2,3,4) 
1
> > > pendiente (1,4,1,5) 
Error: x1 es igual a x2
> > >
CÓDIGO 4.12
Manejar ZeroDivisionError usandoprueba... excepto...declaración.
70Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
4.6 Experiencia práctica con Python
4.6.1 Encontrar la distancia más larga entre dos puntos cualesquiera
• Abrir un archivo de texto
• Ingrese el Código 4.13, donde se usa un solo bucle
• Pruebe y pruebe otro método en el que se utilicen múltiples bucles 
(Código 4.14).
En este método, se utiliza el bucle doble para calcular las distancias entre cada par 
de cuatro puntos (p0, p1, p2, p3). como se muestra comoFigura 4.1, durante el ciclo 
externo nivel 1, cuando i=0, el ciclo interno iterará j de 1 a 2 a 3. Después de que el 
ciclo externo avance a i=1, j se iterará de 2 a 3, y así sucesivamente.
4.6.2 Experiencia práctica: E/S, crear y leer un archivo
1. Abra la consola de Python. Escriba el código 4.15 para el sistema operativo Windows:
> > > importarMatemáticas
> > > clasePunto:## definir una clase de punto definitivamente
__en eso__(uno mismo, x=0.0, y = 0.0):
self.x = x
self.y = y
definitivamenteobtenerDistancia(yo, otro):## declarar getDistance como 
un método
devolvermath.sqrt((otro.x-yo.x)**2+(otro.y-yo.y)**2)
# Declarar tres puntos
> > > p1,p2,p3 = Punto(1,5), Punto(2,8), Punto(10,3)
# # calcular las distancias entre dos puntos aleatorios y guardarlos en una 
lista
> > > dist1 = p1.obtenerDistancia(p2)
> > > dist2 = p1.obtenerDistancia(p3)
> > > dist3 = p2.obtenerDistancia(p3)
> > > distancias = [dist1,dist2,dist3]
# # Declarar la variable Distancia más grande
> > > mayor distancia = 0.0
> > > porienrango(Len(distancias)):
distanciaActual = distancias[i] sidistanciaActual 
> distanciaMayor:
mayorDistancia = distanciaActual
# # Terminar de encontrar e imprimir
> > > impresión'la mayor distancia es ->', distancia mayor la 
mayor distancia es -> 9.43398113206
> > >
CÓDIGO 4.13
Encuentre la distancia más larga entre dos puntos cualesquiera de 3 puntos usando un solo bucle.
Estructura de control del lenguaje Python, entrada/salida de archivos 71
> > > importarMatemáticas
> > > clasePunto:## definir una clase de punto definitivamente
__en eso__(uno mismo, x=0.0, y = 0.0):
self.x = x
self.y = y
definitivamenteobtenerDistancia(yo, otro):## declarar getDistance como un método
devolvermath.sqrt((otro.x-yo.x)**2+(otro.y-yo.y)**2)
# Declarar cuatro puntos
> > > p0, p1,p2,p3 = Punto(), Punto(1,5), Punto(2,8), Punto(10,3)
# # mantener en la lista
> > > puntos = [p0, p1, p2, p3]
# # Declarar la variable Distancia más grande
> > > mayor distancia = 0.0
> > > porienrango(Len(puntos)):
porjenrango(yo+1,Len(puntos)):
distanciaActual = puntos[i].getDistance(puntos[j]) si
distanciaActual > distanciaMayor:
mayorDistancia = distanciaActual
# # Terminar de encontrar e imprimir
> > > impresión'la mayor distancia es ->', distancia mayor la 
mayor distancia es -> 10.4403065089
CÓDIGO 4.14
Calcule la distancia más larga entre dos puntos cualesquiera de un conjunto de 4 puntos usando doblepor
bucle con i y j como variables incrementales.
Nota: (1) Asegúrese de que exista el directorio 'c:/code', o generará un 
error como: "IOError: [Errno 2] No such file or directory: 'c:/code/
points.txt'" . La función makedirs() en el módulo os podría ayudar a 
crear un directorio; (2) Asegúrese de tener permiso para crear un 
archivo en el directorio 'c:/code', de lo contrario generará un error 
como "IOError: [Errno 13] Permiso denegado: 'c:/code/points.txt' ”.
Lazo 1: i = 0 Bucle 2: i = 1 Bucle 3: i = 2
p0 p0 p0 p0 p0 p0
Bucle 11: j = 1
p1p1 p1 p1
Bucle 21: j = 2
p2
p1 p1
Bucle 12: j = 2
p2p2 p2 p2 p2
Bucle 13: j = 3
p3
Bucle 22: j = 3
p3
Bucle 31: j = 3
p3p3 p3 p3
FIGURA 4.1
Use el bucle doble para calcular la distancia entre cada par de cuatro puntos p0, p1, p2, p3.
72Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
> > > f =abierto('C:/Usuarios/Phil/Descargas/puntos.txt', 'w+')
> > > f.escribir('punto:\n')
> > > f.escribir('p1: 1.0, 1.0\n')
> > > f.escribir('p2: 2.0, 2.0\n')
> > > f.cerrar()
CÓDIGO 4.15
Escribe un archivo de texto.
> > > f =abierto('C:/Usuarios/Phil/Descargas/puntos.txt', 'r')
> > > f.readline()# Leer la primera línea
> > > f.readline()# Lee la segunda línea
> > > f.readline()# Lee la 3ra linea
> > > f.readline()# final del archivo
> > > f.buscar(0)#ir al principio del archivo
> > > f.readline()
> > > f.readlines()# leer líneas de descanso en una lista
> > > f.buscar(0)
> > > f.leer()# leer líneas de descanso como una cadena
> > > f.cerrar()
CÓDIGO 4.16
Leer de un archivo de texto.
Para Mac o Linux OS, reemplace el directorio 'c:/code/points.txt' con 
uno diferente, por ejemplo, '/home/points.txt'.
2. Vaya al directorio 'points.txt' y verifique que se haya creado un 
points.txt (que debería ser cierto si no aparece ningún error para su 
código). Ahora abra el archivo y examine la información en el archivo.
3. El código 4.16 lee los datos del archivo points.txt.
4.6.3 Experiencia práctica: E/S, control de flujo y archivo
• Leer y manipular conjuntos de datos de puntos: cree un archivo de texto en c:/
code/points.txt y coloque las siguientes tres líneas en el archivo:
punto:
p1: 1.0, 1.0
p2: 2.0, 2.0
Nota: Este es un archivo de formato de datos GIS simple, donde la primera línea "punto:" indica 
que se trata de un archivo de características de puntos.
• Lea los puntos p1 y p2 del archivo points.txt e imprima las coordenadas x e y. 
Abra el editor de texto de Python y cree un nuevo archivo para guardarlo 
como read_point.py. Ingrese el código 4.17 en read_point.py.
• Pregunta: Si revisamos el archivo points.txt al siguiente formato (reemplace los dos 
puntos por punto y coma):
punto;
p1; 1.0, 1.0
p2; 2.0, 2.0
Estructura de control del lenguaje Python, entrada/salida de archivos 73
"""
GGS 650 Clase 4 Práctica
readPointFile() es la función para analizar los siguientes datos de formato: punto:
p1: 1.0, 1.0
p2: 2.0, 2.0\n
readPolylineFile() es la función para analizar el formato de polilínea como: polilínea;
1: 1,0, 1,0; 2.0, 2.0;.... 2: 2.0, 2.0; 3.0, 
3.0;.... """
> > > importarMatemáticas
> > > clasePunto:## definir una clase de punto
definitivamente__en eso__(uno mismo, x=0.0, y=0.0):## método init para clase de punto
self.x = x
self.y = y
# # Declarar getDistance como método de Point 
definitivamenteobtenerDistancia(yo, otro):
devolvermath.sqrt((otro.x - propio.x)**2 + (otro.y - 
propio.y)**2)
> > > definitivamentereadPointFile(Nombredel archivo): 
expediente=abierto(Nombre del archivo,'r')
# declarar una lista vacía para mantener puntos e índice para la línea Num 
puntos,índice = [],0
porlíneaenexpediente:## Leer cada línea iterativamente
índice += 1## Aumenta el índice después de leer una línea siíndice 
== 1:
Seguir## "Ignorar la primera línea 'point\n'"
# dividir la línea y obtener la coordenada, por ejemplo, 1.0, 1.0 
coords = linea.dividir(':')[1]
# # Obtener el valor del punto x, y 
xCoord = coords.split(',')[0] yCoord = 
coords.split(',')[1]
punto = Punto(flotar(xCoord),flotar(yCoord)) 
puntos.append(punto)
expediente.cerca()# recuerda cerrar el archivo después de leer 
devolverpuntos
# # Llamar a la función para analizar el archivo de puntos
> > > puntos = readPointFile('puntos.txt')#obtener todos los puntos
# imprimir puntos
> > > longitud =Len(puntos)# obtener la longitud de la lista de puntos
> > > porienrango(longitud):
punto = puntos[i]
impresiónpunto.x, punto.y##imprime el valor x, y de cada punto
1.0 1.0
2.0 2.0
10,0 11,0
11,2 13,4
CÓDIGO 4.17
Leer un archivo de datos de puntos GIS formateado.
¿Qué parte del código debemos revisar? ¿Qué tal el siguiente formato?
punto:
1,0, 1,0; 2.0, 2.0
74Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
4.6.4 Experiencia práctica: Ingresar datos de puntos GIS desde un archivo de texto
El código 4.18 lee el archivo de texto de puntos y analiza los datos generando objetos de 
puntos. Luego se encuentra la distancia máxima entre dos puntos cualesquiera y se escribe en 
un archivo de resultados. Pruébelo en su computadora e interprete el ejemplo línea por línea.
> > > importarMatemáticas
> > > clasePunto:
definitivamente__en eso__(uno mismo,x,y):
self.x = x
self.y = y
definitivamentedis(yo, punto):
devolvermath.sqrt((self.x-point.x)**2+ (self.y-
point.y)**2)
> > > f =abierto('puntos.txt', 'r')
> > > f.readline()
> > > yo = 0
> > > puntos = []
> > > tiempo(i==0):
línea = f.readline()
si(línea.buscar(':')!=-1):
cuerdas = linea.split(':')[1] si
(cuerdas.fiand(',')!=-1):
xy = cuerdas.dividir(',') 
puntos.append(Punto(flotar(xy[0]), flotar
(xy[1])))
más:
yo=1
> > > fuera =abierto('puntosResultados4.17.txt','w')
> > > lpuntos = []
> > > dis = 0
> > > impresiónpuntos
[<__main__.Instancia de punto en 0x03373198>, 
<__main__.Instancia de punto en 0x03373990>, 
<__main__.Instancia de punto en 0x03373148>, 
<__main__.Instancia de punto en 0x03373B98>]
> > > porkenrango(Len(puntos)): poryoenrango(k+1,
Len(puntos)):
si(puntos[k].dis(puntos[l])>dis):
dis = puntos[k].dis(puntos[l]) tiempo(
Len(lpuntos)>0):
lpoints.remove(lpoints[0]) 
lpoints.append(puntos[k]) 
lpoints.append(puntos[l])
> > > fuera.escribir('La distancia más larga es entre el punto ['+calle
(lpuntos[0].x)+','+calle(lpuntos[0].y)+'] y ' +
'punto ['+calle(lpuntos[1].x)+','+calle(lpuntos[1].y)+']\norte
la distancia es'+calle(des))
> > > fuera.cerrar()
> > > f.cerrar()
CÓDIGO 4.18
Leer y escribir el contenido de un archivo de datos de puntos.
Estructura de control del lenguaje Python, entrada/salida de archivos 75
Contenido del archivo de texto:
Punto:
1: 1, 2
2: 100, 300
3: 4, 5
4: 0, 500
5: 10, 400
6: 600, 20
7: 500, 400
8: 500, 500
4.7 Resumen del capítulo
Este capítulo presenta diferentes estructuras de control de flujo, incluyendo
• Tomar decisiones usandosi,más, yelif.
• Bucle un bloque de sentencias usandotiempoyporcontrol de flujo.
• Combinar bucle (porytiempo) y sentencias condicionales (si,más, yelif) 
para controles de flujo complejos.
• Leer y escribir archivos de texto.
• Detectar y manejar errores usandoprueba... excepto...declaración.
PROBLEMAS
1. Revise el tutorial de Python "Entrada y salida", que viene con Capítulo 7
del documento de ayuda del software Python.
2. Analice los patrones de la siguiente cadena de texto y guárdelo en un archivo de 
texto, por ejemplo, polylines.txt.
Polilínea:
1. 1603714.835939442,142625.48838266544; 1603749.4678153452,142620.21 
243656706; 1603780.3769339535,142607.37201781105; 1603801.47584667 
8,142582.27024446055; 1603830.4767344964,142536.14692804776;
2. 1602514.2066492266,142330.66992144473; 1602521.4127475217,142414.9 
2978276964; 1602520.1146955898,142433.93817959353; 1602501.3840010 
355,142439.12358761206; 1602371.6780588734,142417.84858870413; 1602
Traducido del inglés al español - www.onlinedoctranslator.com
https://www.onlinedoctranslator.com/es/?utm_source=onlinedoctranslator&utm_medium=pdf&utm_campaign=attribution
76Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
351.6610373354,142408.02716448065; 1602334.5180692307,142388.58748 
627454; 1602331.6999511716,142376.66073128115; 1602334.8067251327, 
142348.965322732; 1602338.308919772,142323.6111663878; 1602349.022 
6452332,142314.50124930218; 1602363.9090971674,142310.79584660195; 
1602514.2066492266,142330.66992144473;
3. Escriba un programa de Python para analizar el archivo de texto y use la lista para 
contener las dos polilíneas. Consulte la Sección 5.6.1 en Referencia de la biblioteca de 
Python (del documento de ayuda de Python) Métodos de cadena para split(), strip() y 
funciones integradas float(x).
4. Genere dos objetos de polilínea.
5. Calcula la longitud de las dos polilíneas.
6. Revise los materiales de la clase sobre el manejo de excepciones y el tutorial de 
Python "Errores y excepciones" (Sección 8.3 en el documento de ayuda de 
Python).
7. Mientras lee el archivo y convierte los datos de cadena a otro tipo de datos, por 
ejemplo, flotante, agregue "intentar... excepto... finalmente...” para capturar las 
Excepciones, por ejemplo, IOError y ValueError.
5
Pensamiento de programación y 
visualización de datos vectoriales
El pensamiento de programación es fundamental para dominar un lenguaje de 
programación (Eckerdal et al. 2005). La única forma de acostumbrarse a pensar en una 
capacidad de programación es a través de la experiencia. Este capítulo visualizará datos 
vectoriales para ilustrar cómo pensar de manera programática.
5.1 Problema: visualización de datos GIS
Visualizar datos GIS es como dibujar o pintar sobre una tela o lienzo en blanco 
(Hearnshaw y Unwin 1994). Los mapas GIS incluyen elementos esenciales como una 
leyenda, un título del mapa, información pertinente y una imagen de los datos 
visualizados. Una imagen de un mapa incluirá diferentes tipos de datos GIS, utilizados de 
diferentes maneras (Figura 5.1, por ejemplo).
Los patrones se denominan símbolos e incluyen patrones geométricos (cuadrados, líneas, 
polígonos), colores (verde, gris y beige) y un nombre de las características de los datos. 
Dependiendo de la cantidad de memoria de la computadora, la visualización de datos GIS en 
forma de mapa es un proceso tedioso porque los datos deben colocarse en orden secuencial. 
Por lo general, el proceso de dibujo comienza con un polígono a una polilínea y luego a una 
entidad de punto. De esta manera, las características de área más pequeñas no cubrirán 
ninguna característica de área grande. Los procesos de dibujo de mapas incluyen múltiples 
pasos, como se indica enFigura 5.2.
Preparar lienzo→preparar datos/características para dibujar (transferencia de coordenadas) y 
saber dónde dibujar→configurar cómo dibujar y dibujar las características→finalizar un proceso 
de dibujo (secado, etc.)
Un programa de computadora requerirá una GUI para interactuar con un usuario final 
para la visualización de entrada y salida. Por ejemplo, la ventana IDLE de Python es un 
tipo de GUI que se usa para programar en Python. ArcGIS tiene un ArcMap y otras GUI 
para la interacción del usuario. En el software GIS, tanto la GUI como la leyenda GIS son 
importantes para interpretar las funciones necesarias para un sistema GIS. Esta sección 
discutirá cómo configurar y usar una interacción de usuario de GUI simple, así como 
preparar Canvas para dibujar mapas.
77
78Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
FIGURA 5.1
Un mapa que utiliza el software ArcGIS, en el que lospolígonos se ilustran en verde claro, las polilíneas en rojo 
oscuro y los puntos en verde.
comienzo
Preparar lienzo
Transferencia de coordenadas
Dibujar características
Finalizar dibujo
Final
FIGURA 5.2
El proceso para visualizar datos GIS.
Pensamiento de programación y visualización de datos vectoriales 79
En Python, Tkinter y las clases y módulos relacionados se usan comúnmente para 
dibujar y desarrollar GUI. Además de Tkinter, hay otros conjuntos de herramientas 
disponibles, como PyGTK, PyQt y wxPython. El código 5.1 mostrará una GUI:
En el código de muestra:
1. La primera línea importará las clases y funciones de Tkinter.
2. La segunda línea llama a Tk() para generar un objeto de ventana raíz.
3. La tercera línea llama a la clase Label para generar un objeto Label de widget.
4. La cuarta línea usa pack() para hacer visible la etiqueta.
5. La última línea abre la primera ventana, que incluye la etiqueta (hecho 
cuando se crea la etiqueta).
En este ejemplo, se creó una ventana con una etiqueta que mostraba "Hola 
mundo". TKinter admite una variedad de objetos widget; los más comunes se 
describen enCuadro 5.1.
Además de los widgets enCuadro 5.1, Tkinter tiene otros widgets, que 
incluyen Entry, Frame, LabelFrame, Menubutton, OptionMenu, 
panelWindow, Scale, Spinbox y Toplevel.
Cuando use otros widgets, reemplace la tercera y la cuarta línea (en el Código 5.1) 
creando un objeto de un widget específico y pasándolo en los argumentos 
relevantes especificados en la referencia en línea,*por ejemplo, cuando use Canvas 
para el mapa, reemplace la tercera y cuarta línea con
can = Canvas(raíz, ancho = 800, alto = 600) 
can.pack()
Entre todos los widgets, Canvas es el más utilizado. Admite muchos métodos, 
como dibujar puntos, líneas, polilíneas y polígonos. Un código típico de 
preparación de Canvas se muestra en el Código 5.2.
En Code 5.2, la tercera línea crea un lienzo con dimensiones de tamaño de píxel de 800 
por 600. Aunque el tamaño se basa en el tamaño del monitor de la computadora, el 
tamaño real se puede ajustar en la pestaña de configuración de pantalla. La penúltima 
línea asegura que Canvas esté visible en la ventana y la última línea
> > > deImportación de Tkinter *
> > > raíz = Tk()
> > > w = Etiqueta (raíz, texto="¡Hola Mundo!")
> > > w.paquete()
> > > raíz.mainloop()
CÓDIGO 5.1
Cree una GUI usando Tkinter.
* http://www.pythonware.com/library/tkinter/introduction/tkinter-reference.htm.
http://www.pythonware.com/library/tkinter/introduction/tkinter-reference.htm
80Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
TABLA 5.1
Widgets populares de TKinter
Widgets Sintaxis Ejemplo
Botón
Lienzo
Etiqueta
Cuadro de lista
Menú
Mensaje
Boton de radio
Barra de desplazamiento
Texto
usando (maestro,
opciones) como
parámetros a
inicializar un widget,
root es el widget 
principal, opciones
son el widget
opciones como
comando, atrás
Botón (raíz, texto = "Aceptar", comando = devolución de 
llamada) Lienzo (raíz, ancho = 800, altura = 600) 
Etiqueta (raíz, texto = "¡Hola, mundo!")
Cuadro de lista (raíz, altura = 8) Menú (raíz, ancho de borde = 2) 
Mensaje (raíz, texto = "este es un mensaje") Botón de opción (raíz, 
texto = "Escala de grises", valor = "L") Barra de desplazamiento = Barra 
de desplazamiento (raíz )
Texto (raíz, fuente = ("Helvética", 16))
> > > deTkinterimportar*
> > > raíz = Tk()
> > > can = Canvas (raíz, ancho = 800, altura = 600) '''dibuja 
características y mapas en el lienzo/tela. . .
. . .
'''
> > > puede.empacar()
> > > raíz.mainloop()
CÓDIGO 5.2
Preparando un lienzo para dibujar.
se asegurará de que aparezca la ventana. El lienzo preparado se puede usar como 
tela de mapa, que se puede usar para dibujar puntos, polilíneas y polígonos. El 
siguiente paso es preparar los datos GIS para que puedan servir como visualización 
en Canvas.
5.2 Transformación del sistema de coordenadas
Los datos GIS se representan en una variedad de formatos y proyecciones, por 
ejemplo, un archivo de forma en ArcView versus un archivo de texto formateado en 
diferentes aplicaciones. El primer paso para visualizar un conjunto de datos GIS es 
leer los datos GIS del archivo de datos para poder manipularlos según sea 
necesario. El proceso de visualización requiere convertir polilíneas en variables 
desde un archivo de texto y luego realizar cálculos (p. ej., longitud) sobre ellas 
utilizando los datos GIS. El vector de datos GIS básico son las coordenadas 
geográficas, que definen dónde se dibujarán en Canvas. Muchas coordenadas de 
datos GIS se presentan en medidas de latitud y longitud (−90 a 90 y −180 a 180), a 
diferencia de las medidas del monitor de la computadora (800×600 o 1024×768
Pensamiento de programación y visualización de datos vectoriales 81
o 1600×1200). El sistema del monitor también se denomina sistema de coordenadas del 
monitor. El sistema de coordenadas del monitor comienza desde la parte superior izquierda 
como un origen (0, 0) y su valor aumenta de arriba a abajo (y) y de izquierda a derecha (x) en el 
monitor.
Otros sistemas de coordenadas de datos, como Universal Transverse Mercator (UTM, 
Grafarend 1995), no caben en un sistema de coordenadas de monitor. Moverse por las 
características del mapa en una ventana GIS mientras se desplaza por el mapa hará que 
la ubicación de las coordenadas se reajuste en el monitor de la computadora. Cabe 
señalar que las coordenadas GIS reales primero se transforman en coordenadas del 
monitor y luego se muestran en el monitor. Esto permite que el sistema de coordenadas 
geográficas se asemeje al sistema de coordenadas del monitor en la computadora. Esta 
sección explica cómo convertir un sistema de coordenadas GIS a un sistema de monitor 
de computadora.
Las coordenadas geoespaciales diarias para puntos, polilíneas o polígonos son números 
flotantes y se representan en el sistema de coordenadas cartesianas 2D (Pick y Šimon 1985). El 
sistema de coordenadas geográficas tiene los valores de coordenadas más bajos en la parte 
inferior izquierda y los valores de coordenadas más grandes en la parte superior derecha. Sin 
embargo, un punto del sistema de coordenadas del monitor se representa como un píxel con 
números enteros x e y numerados desde el origen en la esquina superior izquierda (Figura 5.3
Correcto). Por lo general, el área geográfica que se analiza es más grande que el tamaño de la 
pantalla del monitor, por lo que para representar con precisión los datos geográficos en la 
pantalla, se debe implementar una conversión de mapas. La transformación del sistema de 
coordenadas convierte el punto (x, y) en el sistema de coordenadas geográficas (Figura 5.3
izquierda) a (winx, winy) en el monitor de la computadora (Figura 5.3 Correcto).
Para realizar la transformación de coordenadas, calcule dos parámetros críticos, relaciones 
de longitud y puntos de referencia (o control). La relación de longitud es el factor de reflexión 
del sistema de coordenadas geográficas al sistema de coordenadas del monitor. Por ejemplo, 
usar 800 en el monitor se transformará en una longitud de 360 grados en el sistema de 
coordenadas geográficas. La relación de longitud será de 360/800. Se hace referencia al punto 
de referencia como un punto en el sistema de coordenadas geográficas, que muestra un punto 
específico (p. ej., 0, 0) en el sistema de coordenadas del monitor. Al inicializar un mapa, se debe 
mostrar todo el conjunto de datos del dominio geográfico. Por lo tanto, seleccione el punto 
superior izquierdo de un SIG
(154.23, 85.78)
(0, 0)
Área de datos GIS (–179,00, –89,00,
154.23, 85.78)
Ventana dentro del monitor
(800 × 600)
(–179,00, –89,00) (800, 600)
FIGURA 5.3
Un ejemplo de área geográfica y tamaño de monitor de ventana con 800×600.
82Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
P4 P3 (154,23, 85,78)
RatioX: (maxX–minX)/(800–0)
= (154,23+179,00)/800
= 0,4165375P0
RatioY: (maxY–minY)/600
= (85,78+89,00)/800
= 0,2913
P2
P1 (–179,00, –89,00)FIGURA 5.4
Cálculo de ratioX y ratioY.
conjunto de datos (el punto con la coordenada x más baja y la coordenada y más alta) como el origen 
de un monitor de computadora (0, 0, arriba a la izquierda).
En el proceso de transformación de coordenadas, mantenga la dirección del mapa, es 
decir, tenga el mapa del monitor con la misma dirección de arriba a abajo y de izquierda a 
derecha. A lo largo del eje x, tanto el sistema de coordenadas geográficas como el 
sistema de coordenadas del monitor aumentarán de izquierda a derecha. Sin embargo, a 
lo largo del eje Y, el sistema de coordenadas del monitor aumentará de arriba hacia 
abajo, mientras que el sistema de coordenadas geográficas aumentará de abajo hacia 
arriba. Por lo tanto, invierta la dirección al convertir las coordenadas de un sistema 
geográfico al sistema del monitor. Esto se hace cambiando los signos positivo/negativo 
de longitud a lo largo de la dirección y. A continuación se ilustra cómo calcular las 
coordenadas correspondientes a las coordenadas del monitor (winX, winY).
Tanto la extensión geográfica como las áreas de la pantalla del monitor tienen cinco puntos 
importantes (Figura 5.4) utilizado para calcular las proporciones de longitud: el punto central (p0) y sus 
cuatro esquinas (p1, p2, p3 y p4). Las relaciones de longitud incluyen tanto la relación X, que es la 
relación de conversión de longitud de las coordenadas geográficas a las coordenadas del monitor a lo 
largo de la dirección X, como la relación Y a lo largo de la dirección Y. El finalrelación utilizado para 
convertir las coordenadas geográficas en coordenadas del monitor se selecciona entre ratioX o ratioY.
PUNTAS :El uso de proporciones diferentes para los ejes x e y hará que el mapa se 
distorsione en el mapa visualizado.
Apunto de referenciaes otro elemento importante al convertir coordenadas geográficas 
en coordenadas de monitor. Los puntos de referencia podrían ser los centros de ambos 
sistemas, que son (−12,385, −1,61) y (400, 300), o la parte superior izquierda de ambos 
sistemas: (−179,00, 85,78) y (0, 0).
5.2.1 ¿Cómo determinar el valor de la relación?
Figura 5.4muestra el cálculo de ratioX y ratioY basado en los cuatro puntos de esquina.Figura 
5.5muestra las coordenadas del monitor de cuatro puntos de esquina en función de ratioX y 
ratioY. Usando p2 como ejemplo, use la esquina superior izquierda p4 como el
Pensamiento de programación y visualización de datos vectoriales 83
p4 (0, 0) p3 (800, 0) p4 (0, 0)
p3 (1143.94, 0)
Usar
relación Y
Usar
proporciónX
p1 (0, 419.60) p2 p2 (1143.94, 600)
(800, 600) (800, 600)
FIGURA 5.5
Las coordenadas del monitor de los cuatro puntos de las esquinas se basan en la relación X (izquierda) y la relación Y (derecha), utilizando la 
esquina superior izquierda como punto de referencia.
punto de control y ratioX como la relación para convertirlo de las coordenadas geográficas a las 
coordenadas del monitor:
winX(p2) = (X(p2) − X(p4))/ ratioX = (154,23+179,00)/ 0,4165375 = 800 
winY(p2) = (Y(p2) − Y(p4))/ ratioX = (85,78+ 89,00)/ 0,4165375 = 419,60
Al usar ratioY como ratio, para convertirlo de las coordenadas geográficas a las 
coordenadas del monitor:
winX(p2) = (X(p2) − X(p4))/ ratioX = (154,23+179,00)/ 0,2913 = 1143,94 
winY(p2) = (Y(p2) − Y(p4))/ ratioX = (85,78+ 89,00)/ 0,2913 = 600
Como se muestra enFigura 5.5, el uso de ratioX no utilizará los 600 píxeles de altura de la 
ventana; sin embargo, no todas las funciones se mostrarán al usar ratioY (las coordenadas de la 
ventana están fuera de los límites). Por lo general, el más grande debe seleccionarse como el
relaciónvalor para garantizar que todas las funciones se muestren en la pantalla en la etapa de 
inicialización.
Finalmente, transforme las coordenadas geográficas (x, y) en las coordenadas de píxeles de 
la pantalla (winx, winy) después de determinar tanto la proporción como los puntos de 
referencia (X0, Y0) utilizando la siguiente fórmula:
winx = (X–X0)/proporciónX
winy= − (X – Y0)/ratioY (agregue un signo negativo para cambiar la dirección del eje y)
Por ejemplo, si ratioX y un punto superior izquierdo (−179,00, 85,78) son (0, 0), 
cualquier punto (x, y) de los datos GIS servirá como coordenadas para la ventana del 
monitor (Figura 5.6):
winx = (x – (−179.00))/ratioX 
winy= – (y – (85.78))/ratioX
Por lo tanto, los parámetros de entrada dados son los siguientes:
Sistema de coordenadas geográficas: cualquier punto (x, y), minx, miny, maxx, maxy 
Sistema de coordenadas del monitor: tamaño (ancho, alto) y (0, 0) en la esquina izquierda
84Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
(0,0)
(–179,00, 85,78) Ventana dentro del monitor:
(800 × 600)
Datos SIG (–179,00, 89,00, 154,23, 85,78)
FIGURA 5.6
Coordine la conversión utilizando ratioX como ratio y la esquina superior izquierda como punto de referencia.
Las coordenadas del monitor del punto (x, y) se pueden determinar utilizando la 
siguiente fórmula:
ratioX = (maxx-minx)/ancho ratioY 
= (maxy-miny)/alto ratio = 
ratioX>ratioY?ratioX:ratioY winx = 
(x-(minx))/ratio
winy = -(y-maxy)/ratio
5.3 Visualización de datos vectoriales
Una vez que el sistema de coordenadas geográficas se convierte en el sistema 
de coordenadas del monitor, utilice el paquete Tkinter para visualizar los datos. 
El widget Canvas proporciona un fondo de visualización de propósito general 
(tela) para mostrar y manipular gráficos y otros dibujos. El Lienzo es una 
ventana en sí misma y su origen se encuentra en la esquina superior izquierda 
(0, 0). Por lo tanto, cualquier visualización de datos se mostrará en este 
contexto a partir de la esquina superior izquierda de Canvas. Al crear un objeto 
Canvas, existen varios argumentos importantes, como ancho (que especifica el 
ancho de la ventana Canvas), alto (que especifica el alto de la ventana Canvas) y 
bg (que especifica el color de fondo de la ventana Canvas). Al dibujar en Canvas, 
el create_xx (la segunda columna enCuadro 5.2) construirá diferentes gráficos.
Cada uno de estos métodos tomará diferentes argumentos como se indica en la 
tabla. Por ejemplo, create_arc tomará los parámetros de x0, y0, x1, y1, opciones…. El 
punto (x0, y0) definirá el punto superior izquierdo y el punto (x1, y1)
Pensamiento de programación y visualización de datos vectoriales 85
TABLA 5.2
Los widgets de lienzo se pueden crear utilizando diferentes métodos de creación
gráficos Contexto del método Parámetros Uso en notas GIS
algunos simbolosUna rebanada de un
elipse.
crear_arco(x0, y0,
x1, y1, opciones)
(x0, y0, x1, y1) es el
rectángulo en el que el 
eclipse, (x0, y0) y (x1, y1) 
son los dos puntos 
diagonales
Una imagen como
mapa de bits
create_bitmap(x, y,
opciones)
(x, y) es la ubicación del punto
donde se coloca el mapa 
de bits
Mostrar imágenes de trama
Una imagen gráfica. crear_imagen(x, y,
opciones)
(x, y) es la ubicación del punto
donde se coloca la 
imagen
Mostrar imágenes de trama
Una o más líneas
segmentos
crear_línea(x0, y0,
x1, y1,…,
opciones)
(x0, y0, x1, y1,…) es el
lista de los puntos en 
la polilínea, (x0,y0) y
(x1, y1) son los dos 
puntos diagonales
Alguna polilínea
características tales como
ríos, caminos
una elipse; usar
esto también para
dibujando círculos,
qué área
caso especial de 
una elipse.
crear_oval(x0, y0,
x1, y1, opciones)
(x0, y0, x1, y1) es el
rectángulo en el que el 
eclipse, (x0, y0) y (x1, y1) 
son los dos puntos 
diagonales
Algunas características de elipse
o símbolos
Un polígono. crear_polígono(x0,
y0, x1, y1,…,
opciones)
(x0, y0, x1, y1,…) es el
lista de los puntos en el 
polígono
Algún polígono
características tales como
lagos, mar, ciudades
Un rectángulo. crear_
rectángulo(x0, y0,
x1, y1, opciones)
(x0, y0, x1, y1) es el
rectángulo, (x0,y0) y
(x1, y1) son los dos 
puntos diagonales
Un borde de mapa, etc.
anotación de texto. crear_texto(x, y,
opciones)
(x, y) es la ubicación del punto
donde se coloca el texto
Leyenda de textura
un rectángulo
ventana.
crear_ventana(x,
y,opciones)
(x, y) es la ubicación del punto
donde se coloca la 
ventana
Un lienzo para dibujar el
mapa
definir el punto inferior derecho del rectángulo (en el que se dibujará el arco). Hay 
muchas opciones, como inicio (el ángulo inicial de un arco), extensión (el ancho del 
arco en grados) y relleno (el color utilizado para rellenar el arco). Figura 5.7muestra 
cómo crear un objeto Canvas y crear tres arcos usando los mismos puntos de 
rectángulo, pero con diferentes colores y extensiones. Como se ilustra, el ángulo 
comienza desde un eje x positivo y va en sentido contrario a las agujas del reloj.
Como se muestra enFigura 5.7a, el código fuente crea una ventana, donde se 
dibuja Canvas creando un arco de 30 grados (270 grados rojo, 60 grados azul y 30 
grados verde).
86Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
(a) (b)
desde la importación de Tkinter*
raíz = Tk()
can = Canvas(raíz, ancho = 800, alto = 600) 
can.pack ()
xy = 20, 20, 300, 180
can.create_arc(xy, inicio=0, extensión=270, relleno="rojo") 
can.create_arc(xy, inicio=270, extensión=60, relleno="azul") 
can.create_arc(xy, inicio=330, extensión = 30, relleno = "verde") 
root.mainloop ()
(C)
FIGURA 5.7
Crea un arco con Tkinter. (a) Código fuente, (b) Dibujar arco, (c) Dibujar línea.
QA: reemplace las líneas 6, 7 y 8 con la siguiente línea:
can.create_line (1,2,35,46,5,6,76,280,390,400)
Luego ejecute el código y verifique la GUI para ver si es lo mismo que 
Figura 5.5c.
5.4 Punto, Polilínea, Polígono
Los tres tipos de datos de entidades SIG más populares incluyen punto, polilínea y 
polígono. Deben seleccionarse métodos adecuados para visualizar cada uno de 
ellos. Cuadro 5.1enumera los métodos disponibles para visualizar diferentes tipos 
de gráficos. La polilínea y el polígono pueden coincidir con los métodos create_line() 
y create_polyon(). El punto se puede representar usando otros métodos como 
create_rectangle() o create_arc(). Conocer el tamaño específico de un arco y un 
rectángulo es importante al rellenarlo con un color, formar un círculo o un punto. 
Por lo tanto, los datos de punto, polilínea y polígono se pueden visualizar utilizando 
create_arc(), create_line y create_polygon, respectivamente.
Dentro de los argumentos de create_arc(xy, inicio, extensión, relleno=color),
• xy puede ser una lista de [x0, y0, x1, y1, … xn, yn]
• el inicio y la extensión pueden ser los predeterminados, que es todo el círculo
• el color de relleno se puede tomar como símbolos de visualización de características definidos por los 
usuarios
Pensamiento de programación y visualización de datos vectoriales 87
FIGURA 5.8
Un mapa GIS de Python simple con puntos, polilíneas y polígonos visualizados.
Dentro de los argumentos de create_line(xy, opciones):
• xy puede ser una lista de [x0, y0, x1, y1, x2, y2, …]
• las opciones pueden ser
• relleno: para especificar el color de la línea
• ancho: para especificar el ancho de píxel de la línea
Dentro de los argumentos de create_polygon(xy, opciones):
• xy puede ser una lista de [x0, y0, x1, y1, x2, y2, …., x0, y0]. Nota: el primer y 
último punto son iguales
• las opciones incluyen
• relleno: para especificar el color de relleno del polígono
• contorno: especifique el color de la línea del borde
• ancho: para especificar el ancho de píxel de la línea del borde
Con estos métodos, los datos de puntos, polilíneas y polígonos dibujados en 
Figura 5.1se puede visualizar en Python Tkinter Canvas comoFigura 5.8.
5.5 Pensamiento de programación
Escribir código implica una forma de pensar que es ajena a la mayoría de las personas; 
sin embargo, escribir código no es un proceso único y es un proceso analítico. Practicar 
los siguientes pasos mejorará las habilidades de programación.
88Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
5.5.1 Análisis de problemas
El primer paso en la programación es analizar el problema y comprender los 
requisitos detallados. Uno de los requisitos del problema deCapítulo 3es crear 
un polígono y calcular la longitud del borde del polígono. Parte de los requisitos 
del problema deCapítulo 4son programar las coordenadas de dos polilíneas y 
calcular la longitud de las polilíneas.
5.5.2 Piense en Programación
El segundo paso es pensar desde una perspectiva de programación, considerando 
varios factores:
• ¿Cuántos componentes deben incluirse en el código? por ejemplo, 
en elCapítulo 4problema, se incluyen tres componentes (Figura 5.9
).
• ¿Cuál es la secuencia de estos componentes? Una vez determinados los 
componentes, piense en la secuencia de programación. ¿Qué 
componente debe ejecutarse primero y cuál debe seguir?
• Por último, piense en cómo diseñar estructuras de datos y programas, y 
organizar las estructuras de datos y programas para que sean simples, 
reutilizables y de naturaleza orientada a objetos. Saber gestionar la 
creación de objetos, componer objetos en estructuras más grandes, 
coordinar el flujo de control entre objetos y obtener los resultados en la 
secuencia obtenida de los análisis de problemas.
p2
p3
p4 p5 Calcula el
longitudp7
p1 p6
p8 p1 p2 p3 p4 p5 p6 ...
Componente 1:
Leer datos del archivo.
Componente 2: Analice y 
organice los datos como 
puntos y cree una polilínea
objetos.
Componente 3:
Calcula el
longitud de
polilínea.
FIGURA 5.9
Programación de componentes/pasos para elCapítulo 4problema.
Pensamiento de programación y visualización de datos vectoriales 89
5.5.3 Coincidencia de patrones y estructura del lenguaje de programación
Ahora, haga coincidir los componentes y secuencias de programación (diseño de 
componentes programables) con estructuras y patrones de lenguaje (Proulx 2000). 
Un programa se puede implementar utilizando diferentes lenguajes de 
programación y puede hacer coincidir los componentes con una estructura de 
lenguaje más familiar. Hay varios patrones a seguir para implementar cada 
componente.
• Primero: coincidencia funcional. Similar aCapítulo 4Las operaciones de archivo 
de, la lectura de datos del archivo (componente 1) puede abrir, leer y cerrar el 
archivo de diferentes maneras. Analizar y organizar datos como puntos y crear 
objetos de polilínea es similar a analizar datos de un archivo de texto (usando 
dividir() y operaciones de lista), crear objetos de punto y crear objetos de 
polilínea definiendo y usando Punto, Clases de polilínea y su relación de 
composición .
• Segundo: coincidencia secuencialdiferentes componentes. La secuencia de 
los tres componentes (Figura 5.5) significa que primero debe leer los datos, 
analizarlos y crear objetos, y luego calcular la longitud de la polilínea. Las 
operaciones de archivo son el orden de apertura, lectura y cierre de 
archivos.
• Tercero: datos detallados y coincidencia de estructura de programación. El cálculo de la 
longitud de la polilínea, por ejemplo, agrega muchas longitudes de segmento de línea a 
través de un bucle. El almacenamiento de una lista de puntos utiliza el tipo de datos de 
lista. El análisis de coordenadas utiliza la división y la conversión de datos para cada 
coordenada en forma de bucle.
5.5.4 Implementar programa
Después del análisis, la programación con estructuras y patrones de lenguaje familiar 
debería funcionar en el siguiente orden:
• Leer datos del archivo.
• Agregue clases de puntos y polilíneas y enumere las estructuras de datos para contener los 
conjuntos de datos antes de analizarlos.
• Analizar datos en una lista de coordenadas o puntos.
• Cree un objeto de punto y polilínea antes de usar un objeto de polilínea.
• Llame al método para calcular la longitud de la polilínea.
Una vez desarrollada la primera versión del programa,
• Una vez más, ordene la lógica de la programación, solucione cualquier 
problema restante y optimice los códigos.
90Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
• Depurar y probar los resultados del programa desarrollado.
PUNTAS :En el proceso de pensamiento de programación, habrámomentos en los que no 
esté tan familiarizado con el patrón o la estructura en particular. Entonces, en efecto, hay 
varias formas de realizar la búsqueda:
• Busque patrones similares escritos en "programación Python..." 
reemplazando el... con el patrón o la estructura necesaria.
• Busque el documento de ayuda desde Python IDLE (si no hay Internet 
disponible) escribiendo la parte … en el cuadro de búsqueda de ayuda.
• Discutir con los compañeros: hay patrones problemáticos similares. De lo contrario, 
publique un mensaje o una pregunta en el blog de programación de Python.
Cuantos más patrones practique, más experimentado se volverá un programador para 
encontrar una solución.
5.6 Experiencia práctica con Python
5.6.1 Lectura, análisis sintáctico y análisis de datos de archivos de texto
Pruebe el Código 5.3 para el problema del último capítulo y revise el proceso de 
pensamiento de programación presentado en este capítulo.
"""
Capítulo 4
Leer los siguientes datos: 
Polilínea;
1: 1603714.835939442,142625.48838266544; 1603749.4678153452,142620.212 
43656706; 1603780.3769339535,142607.37201781105; 1603801.475846678,142 
582.27024446055; 1603830.4767344964,142536.14692804776;
2: 1602514.2066492266,142330.66992144473; 1602521.4127475217,142414.92 
978276964; 1602520.1146955898,142433.93817959353; 1602501.3840010355,1 
42439.12358761206; 1602371.6780588734,142417.84858870413; 1602351.6610 
373354,142408.02716448065; 1602334.5180692307,142388.58748627454; 160 
2331.6999511716,142376.66073128115; 1602334.8067251327,142348.9653227 32; 
1602338.308919772,142323.6111663878; 1602349.0226452332,142314.50 
124930218; 1602363.9090971674,142310.79584660195; 1602514.2066492266, 
142330.66992144473;
El código 5.3 define la función 'readPolylineFile' para leer datos línea por 
línea. La función readPolylineFile devolverá dos valores: polilíneas y
Pensamiento de programación y visualización de datos vectoriales 91
> > > importarMatemáticas
> > > clasePuntos:
definitivamente__en eso__(uno mismo, x=0.0, y=0.0):
self.x,self.y = x, y
> > > clasePolilínea:
definitivamente__en eso__(uno mismo, puntos =[]):
self.puntos = puntos
definitivamenteobtenerLongitud(uno mismo):
yo = 0
longitud = 0,0
tiempoyo <Len(auto.puntos)-1:
length += math.sqrt((self.points[i+1].x
- self.puntos[i].x)**2 + 
(self.puntos[i+1].y -self.
puntos[i].y)**2 )
yo += 1
devolverlongitud
#
# # función para leer datos línea por línea y
# # obtener todos los puntos de ambas líneas
# # devuelve dos objetos: lista de puntos y
# # el número de puntos de la primera línea
> > > definitivamentereadPolylineFile(Nombre del archivo):
f =abierto(Nombre del archivo,'r') polilíneas, 
puntos, índice = [], [],0 firstPolyLineNum = 0
porlíneaenF:
índice += 1
siíndice == 1:
Seguir
coords = linea.dividir(':')[1] cadacoords 
= coords.split(';') longitudcoords =Len
(cadacocords) siíndice == 2:
firstPolyLineNum = coordsLen-1 impresión'El 
primer número de polilínea es: ', 
primerPolyLineNum
porienrango(coordsLen-1):
singlecoords = cadacoords[i]
# imprime 'coords unicos,', coords unicos 
xCoord = singlecoords.split(',')[0] yCoord = 
singlecoords.split(',')[1]
# imprime 'xCoord y yCoord, ', xCoord, yCoord
punto = Puntos(flotar(xCoord),flotar(yCoord)) 
puntos.append(punto)
f.cerrar()
devolverpuntos, firstPolyLineNum
El primer número de polilíneaes: 5
CÓDIGO 5.3
Lea desde un archivo de texto y cree una polilínea para contener datos y analizar datos. (Continuado)
92Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
# # llamar a la función para leer datos y ponerlos en la lista de puntos
> > > resultados = readPolylineFile('polilíneasHw4.txt')
> > > puntos = resultados[0]
> > > firstPolylinePointNum = resultados[1]
> > > longitud =Len(puntos)
> > > impresión'El total de puntos y el número de puntos para
primera polilínea es ',\
longitud, firstPolylinePointNum
los puntos totalesyel numero de puntosporprimerapolilíneaes18 5
# # Obtiene los puntos para la primera polilínea y calcula la longitud
> > > puntosParaPrimerPoly = puntos[0:firstPolylinePointNum]
> > > polyLine1 = Polyline(pointsForFirstPoly)
> > > lengthForFirstPoly = polyLine1.getLength()
> > > impresión"Longitud de la primera polilínea -> ", longitudParaPrimerPoly
Longitudporprimera polilínea -> 155.775923237
# # Obtiene los puntos para la segunda polilínea y calcula la longitud
> > > puntosParaSecondPoly = puntos[firstPolylinePointNum:]
> > > polyLine2 = Polyline(pointsForSecondPoly)
> > > lengthForSecondPoly = polyLine2.getLength()
> > > impresión"Longitud de la segunda polilínea ->", longitudParaSegundoPoly
LongitudporSegunda polilínea -> 549.438874589
CÓDIGO 5.3 (Continuado)
Lea desde un archivo de texto y cree una polilínea para contener datos y analizar datos.
firstpolylineNum, que se refiere a cuántos puntos tenemos para la primera 
polilínea.
5.6.2 Crear objetos SIG y verificar intersección
una.Planteamiento del problema: Cree cuatro puntos aleatorios y cuatro rectángulos 
aleatorios, y averigüe si alguno de los puntos está ubicado dentro de alguno de los 
rectángulos. Escriba los resultados en un archivo de texto.
b.Programación pensando en el problema: El flujo de trabajo de este proceso es (a) 
crear cuatro puntos, (b) crear cuatro rectángulos y (c) verificar cada punto para 
determinar si está en alguno de los rectángulos. El problema involucra dos 
estructuras de datos: clases Point y Rectangle. Primero, los patrones de "clases 
declaradas" para Puntos y Rectángulos contendrán conjuntos de datos 
relevantes creados a partir del método aleatorio del módulo aleatorio.
La clase Punto y la clase Rectángulo se pueden definir con los 
siguientes atributos y funciones (Figura 5.10).
# #1. Declare la clase Point 
class Point:
pasar##implementarme
Pensamiento de programación y visualización de datos vectoriales 93
(a) (b)
FIGURA 5.10
Se crearán dos clases para el problema del punto y el rectángulo.
# #2. Declare la clase Rectangle 
class Rectangle:
pasar##implementarme
El problema requiere crear cuatro puntos y rectángulos aleatorios, lo que 
indica que se deben incluir los siguientes dos pasos en el programa:
# #3. Genera cuatro puntos 
puntos = []
para i en el rango (4):##Bucle 4 veces
pasar##implementarme
# # 4.Generar cuatro rectángulos 
rectángulos=[]
para i en el rango (4):##Bucle 4 veces
pasar##implementarme
Para verificar cada uno de los cuatro puntos, recorra los cuatro puntos y verifique si 
cada uno de los puntos está en alguno de los cuatro rectángulos, y luego recorra los 
cuatro rectángulos. Esto requerirá un doble bucle para procesar.
# #5. Verifique qué punto está en qué rectángulo y registre el resultado para i en 
el rango (4):
para j en el rango (4):
# verificar si los puntos [i] están en rectángulos [j] y registrar los resultados en un pase de 
archivo ## Implementarme
Hay dos componentes en el último proceso de verificación: (a) cómo verificar si un punto 
está dentro de un rectángulo (el método contains() en la clase de rectángulo) y cómo 
escribir los resultados en un archivo (el archivo abre, escribe, y patrón cerrado). Dado que 
el archivo debe escribirse a medida que avanza a través de los bucles dobles,
94Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
> > > importaraleatorio
# # 1. Declarar la clase Point
> > > clasePunto:
definitivamente__en eso__(uno mismo, x = 0.0, y = 0.0):
self.x = x
self.y = y
# # 2. Declarar la clase Rectángulo
> > > claseRectángulo: definitivamente
__En t__(uno mismo):
# # Un rectángulo puede ser determinado por (minX, maxX) 
(minY, maxY)
self.minX = self.minY = 0.0 
self.maxX = self.maxY = 1.0
definitivamentecontiene(yo, punto):## Comprobar si un punto está dentro
un rectángulo
pasar## Implementarme
# # 3. Generar cuatro puntos
# definir una lista de puntos para mantener cuatro puntos
> > > puntos = []
# genera cuatro puntos y los agrega a la lista de puntos
> > > pasar## Implementarme
# # 4. Generar cuatro rectángulos
# definir una lista Rectángulo> > > rectas = []
> > > porienrango(4): rectángulo = 
Rectángulo()
# # Generar x
x1 = aleatorio.aleatorio()
x2 = aleatorio.aleatorio()
# # asegúrese de minX != maxX 
tiempo(x1 == x2):
x1 = aleatorio.aleatorio()
six1<x2:
rectángulo.minX=x1
rectángulo.maxX=x2
elifx1>x2:
rectángulo.minX=x2
rectángulo.maxX=x1
# # Desarrollar códigos para generar valores y
# # y asegúrese de que el rectángulo no sea una línea debajo 
pasar## Implementarme
# # añadir a la lista 
rects.append(rectángulo)
# # 5. Agregue código para verificar qué punto está en qué rectángulo
> > > listaresultados = []## Y usa una lista para guardar los resultados
> > > pasar## Implementarme
# # 6. escribir los resultados en el archivo
> > > f=abierto('HM5_Resultado.txt','w')
> > > porresultadoenlista de resultados:
f.escribir(resultado+'\norte')
> > > f.cerrar()
CÓDIGO 5.4
Generar cuatro puntos, rectángulos, verificar las relaciones de contiene () y enviar los resultados a un archivo 
de texto.
Pensamiento de programación y visualización de datos vectoriales 95
ábralo antes de entrar en el ciclo y ciérrelo después de salir del ciclo. Escribe el 
archivo al ejecutar los bucles.
El método random.random() puede generar los mismos valores para x1 y x2 o 
y1 e y2 (lo que significa una línea en lugar de un rectángulo). Esto se puede 
manejar agregando un método para verificar si son iguales para evitar un 
rectángulo no válido.
Con base en este proceso de pensamiento de programación, los códigos de programación se 
pueden desarrollar en el flujo del Código 5.4:
5.7 Resumen del capítulo
Este capítulo presenta cómo pensar como un programador utilizando la visualización de 
datos vectoriales GIS e incluye
• Análisis de problemas
• La coincidencia de patrones
• Transformación de coordenadas
• Dibujo de datos vectoriales en Canvas
• Se utilizan dos ejemplos de codificación para demostrar el proceso de 
pensamiento de programación: (a) leer, analizar y calcular la longitud 
de las polilíneas, y (b) generar puntos y rectángulos aleatorios; y 
verifique la relación de contenido entre cada punto y rectángulo
PROBLEMAS
1. Hay un módulo llamado random en Python; impórtelo y use su método 
random() para generar un número aleatorio de 0 a 1.
2. Existe un algoritmo popular en GIS para encontrar si un punto está dentro 
de un rectángulo en función de sus respectivas coordenadas de punto (x, y 
y minx, miny, maxx, maxy). Describe el algoritmo en un algoritmo 
matemático usando (x, y y minx, miny, maxx, maxy).
3. Escriba un programa para (a) generar m cantidad de puntos y n cantidad de 
rectángulos (m y n se pueden cambiar a través de la entrada del usuario), (b) 
verificar qué puntos están en qué rectángulos.
4. Programe para escribir las coordenadas de los puntos y las coordenadas de los puntos de los 
rectángulos en un archivo de texto, y luego escriba el resultado de (2) en el archivo de texto.
5. En un documento de Word, explique el algoritmo y el programa de "punto en el 
rectángulo" creado, y codifique el programa en un archivo .py para encontrar qué 
punto generado en (3) está dentro de qué rectángulo generado en (3). Luego 
verifique la salida del archivo de texto.
http://taylorandfrancis.com
6
Manejo de archivos de forma
Una de las funciones más importantes del software GIS es leer los formatos de archivo de datos 
GIS populares, como los archivos de forma. Un archivo de forma es un formato de archivo de 
datos binarios desarrollado originalmente por ESRI y ha sido ampliamente utilizado para 
intercambiar datos vectoriales entre diferentes profesionales y comunidades SIG (ESRI 1998). 
Este capítulo presenta cómo se formatean los archivos de formas y cómo leerlos con Python, es 
decir, leer datos binarios, leer un encabezado de archivo de formas, leer un archivo de formas 
de puntos y leer archivos de formas de polilíneas y polígonos.
6.1 Manipulación de datos binarios
Los archivos de forma están en formato binario y el módulo de Python para manipular 
datos binarios se conoce comoestructura. losestructuraEl módulo tiene una serie de 
funciones para leer y escribir datos en formato binario. Esta sección presenta cómo 
podemos usar elestructuramódulo para manejar datos binarios.
estructuramaneja datos binarios convirtiendo datos de un lado a otro entre su formato 
original y el formato binario. La función de paquete deestructurase utiliza para convertir 
datos a un formato binario. Por ejemplo, la siguiente declaración devuelve una cadena 
binaria que contiene los valores v1, v2, … empaquetados de acuerdo con el formato dado
fmt. Los argumentos deben coincidir exactamente con los valores requeridos por el 
formato.
estructura.paquete(fmt, v1, v2, …)
La función de desempaquetar deestructurase utiliza para interpretar datos binarios a 
su valor original (Código 6.1). Por ejemplo, la siguiente declaración desempaqueta el 
binario (presumiblemente empaquetado porestructura.paquete(fmt, v1, v1, …)) según el 
formato dadofmt. El resultado es una tupla, incluso si contiene un solo elemento. Los 
datos binarios deben contener exactamente la misma cantidad de datos que requiere el 
formato, es decir, len (datos binarios) debe ser igual a calcsize (fmt).
struct.unpack(fmt, datos binarios)
losestructurael módulo debe importarse antes de usarlo (la primera declaración del 
Código 6.1). El código también demuestra cómo empaquetar dos números enteros (100, 
200) representados por variables (x, y) en una cadena binaria. La cadena 'ii' se usa para 
representar dos valores enteros con cada 'i' representando un entero. El quinto
97
98Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
importarestructura
x,y = 100,200
s = estructura.paquete('ii',x,y) 
impresións
resultado = struct.unpack('ii',s) 
impresiónresultado
CÓDIGO 6.1
Ejemplos de métodos de empaquetado y desempaquetado del módulo struct.
CUADRO 6.1
Caracteres de formato
Carácter de formato Tipo C Tipo de pitón Tamaño estándar
C
B
B
?
h
H
i
yo
yo
L
q
q
F
d
carbonizarse
carácter firmado
carácter sin firmar
_Bool
corto
corto sin firmar
En t
int sin firmar
largo
largo sin firmar
largo largo
sin firmar mucho tiempo
flotar
doble
cadena de longitud 1 
Entero
Entero
bool
Entero
Entero
Entero
Entero
Entero
Entero
Entero
Entero
Flotar
Flotar
1
1
1
1
2
2
4
4
4
4
8
8
4
8
> > > importarestructura
> > > i,b,x,y,z = 100,Verdadero,-180.0,90,0.212
> > > s = estructura.paquete('<ibdfd',i,b,x,y,z)
> > > Len(s)
> > > resultado = estructura.desempaquetar('<i?dfd',s)
> > > impresiónresultado
(100, Verdadero, -180,0, 90,0, 0,212)
CÓDIGO 6.2
Empaquetar y desempaquetar diferentes tipos de datos utilizando el formato adecuado.
declaración desempaqueta la cadena binaria en su valor de datos original (100, 200). La 
cadena 'ii' es importante y se la conoce como la cadenaformato(denotado comofmt), que 
se utiliza para especificar el formato esperado y es necesario para llamar a los métodos 
de empaquetado y desempaquetado.Tabla 6.1detalla los caracteres de formato utilizados 
en la cadenafmtpara especificar el formato para empaquetar y desempaquetar datos 
binarios.
El código 6.2 muestra cómo empaquetar diferentes formatos utilizando los caracteres de 
formato. Cinco variables que representan cinco valores en tipos de datos de entero, booleano,
Manejo de archivos de forma 99
TABLA 6.2
Carácter inicial de estructura
Personaje Orden de bytes Tamaño Alineación
@
=
<
>
!
nativo
nativo
little-endian
big-endian
red (= big-endian)
nativo
estándar
estándar
estándar
estándar
nativo
ninguna
ninguna
ninguna
ninguna
doble, flotante y doble están empacados. La longitud total de la cuerda empaquetada es 
4(i) + 1(b) + 8(d) + 4(f) + 8(d) = 25. Como elestructurael paquete sigue el estándar C, se 
utiliza el tipo C. Python tiene menos tipos de datos; sin embargo, el tamaño estándar de 
cada tipo de datos se puede mantener si el primer carácter de la cadena de formato se 
indica mediante el orden de bytes, el tamaño y la alineación de los datos empaquetados.De forma predeterminada, se utilizará @ si el primer carácter no es uno de los 
caracteres proporcionados enCuadro 6.2abajo:
• El orden de los bytes nativos es big-endian o little-endian, según el 
sistema host. Por ejemplo, Intel x86 y AMD64 (x86-64) son little endian; 
Motorola 68000 y PowerPC G5 son big-endian; ARM e Intel Itanium 
cuentan con endian-ness conmutable (bi-endian). Usar sist. byteorder 
para verificar el endian-ness del sistema.
• El tamaño nativo y la alineación se determinan utilizando el compilador de C.
tamaño deexpresión. Esto siempre se combina con el orden de bytes 
nativo.
• El tamaño estándar depende únicamente del carácter de formato como se define en 
Tabla 6.1arriba.
• Tenga en cuenta la diferencia entre '@' y '=': ambos usan el orden de bytes nativo, pero 
el tamaño y la alineación del último están estandarizados.
• La forma '!' se usa cuando no podemos recordar si el orden de bytes de 
la red es big-endian o little-endian.
Orden de bytes*El concepto también se utiliza en el formato ESRI Shapefile. Los órdenes de 
bytes big-endian y little-endian son dos formas de organizar palabras de varios bytes en la 
memoria de la computadora o en el disco de almacenamiento. Cuando se usa el orden big-
endian, el primer byte es la parte más grande de los datos, mientras que el primer byte es la 
parte más pequeña de los datos cuando se usa el orden little-endian. Por ejemplo, al almacenar 
una representación hexadecimal de un número entero de cuatro bytes 0×44532011
* “Endianidad”. Wikipedia. Fundación Wikipedia, Inc.,http://en.wikipedia.org/wiki/ Endianidad.
http://en.wikipedia.org/wiki/Endianness
http://en.wikipedia.org/wiki/Endianness
100Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
TABLA 6.3
Entero de cuatro bytes 0×44532011 en el Almacenamiento
Big Endian
Little-Endian
44 53 20 11
11 20 53 44
importarestructura
x,y,z = 100,200,300
s = estructura.paquete('>iii',x,y,z) 
impresións
resultado = struct.unpack('>iii',s) 
impresiónresultado
resultado = struct.unpack('<iii',s) 
impresiónresultado
CÓDIGO 6.3
Empaquetar y desempaquetar debe usar el mismo orden de bytes.
# Este código debe escribirse en la ventana interactiva 
importarestructura
x, y, z = 100, 200, 300
s = struct.pack('<iii',x,y,z) #codificación little_endian
s
'd\x00\x00\x00\xc8\x00\x00\x00,\x01\x00\x00' s = 
struct.pack('iii',x,y,z) #codificación predeterminada s
'd\x00\x00\x00\xc8\x00\x00\x00,\x01\x00\x00'
CÓDIGO 6.4
El orden de bytes predeterminado es little-endian para nuestras computadoras.
(Cuadro 6.3) utilizando el formato binario de orden big-endian, la secuencia de bytes 
sería "44 53 20 11".
• Para el orden de bytes big-endian, utilice '>' al empaquetar o desempaquetar los 
bytes, por ejemplo, struct.unpack('>iiii', s).
• Para el orden de bytes little-endian, use '<', por ejemplo, struct.unpack('<iiii', s).
• Si se mezclan estos dos, por ejemplo, empaquetar usando '>' y desempaquetar 
usando '<', se generará un resultado inesperado, como se muestra en la última 
declaración del Código 6.3.
Al construir la cadena formateada, se debe especificar el orden de los bytes. En 
ausencia de un símbolo de orden de bytes,embalaje y desembalajeutilizará little-endian 
por defecto para PC (Código 6.4). Los resultados de dos códigos no muestran diferencia. 
Los resultados son hexadecimales, es decir, 0x 00000064 representa 100, 0x 0000c8 
representa 200 y x0000012c representa 300. Más información estructuray la información 
de formato se puede encontrar enhttp://docs.python.org/library/ struct.html.
http://docs.python.org/library/struct.html
http://docs.python.org/library/struct.html
Manejo de archivos de forma 101
6.2 Introducción a Shapefile
Un archivo de forma incluye varios archivos con el mismo nombre de archivo y diferentes extensiones 
de archivo. Cada conjunto de datos vectoriales se almacena en varios archivos, como .shp (archivo 
principal), .shx (archivo de índice), .dbf (archivo dBASE), .prj (archivo de proyección), etc. (Figura 6.1). El 
archivo principal, el archivo de índice y el archivo dBASE son necesarios para todo software GIS que 
funcione con archivos de forma. El triple debe tener el mismo nombre, por ejemplo, mymap.shp, 
mymap.shx y mymap.dbf:
• . shp: El archivo .shp contiene los vértices de todas las entidades (Figura 6.1). 
Los vértices se organizan jerárquicamente en entidades/registros, partes y 
puntos. El archivo .shp también contiene información sobre cómo leer los 
vértices (es decir, como puntos, líneas o polígonos). Algunos atributos 
importantes también pueden denominarse tercera dimensión (medidas) y 
almacenarse en el archivo .shp.
• . shx: se mantiene un índice para cada registro, y es beneficioso para encontrar los 
registros más rápidamente.
• . dbf: la información de atributos se almacena en el archivo .dbf asociado con cada 
archivo .shp. El archivo .dbf contiene tablas de dBASE y almacena atributos 
adicionales que no se pueden mantener en las características de un archivo de 
forma. Contiene exactamente la misma cantidad de registros que funciones en el 
archivo .shp (de lo contrario, los datos no podrían interpretarse). Los registros 
pertenecen a las formas secuencialmente, lo que significa que el primer, segundo y 
tercer registro pertenecen, respectivamente, a la primera, segunda y tercera entidad 
del archivo .shp. Si editamos el .dbf con una herramienta de terceros y alteramos los 
registros, es posible que se pierda el pedido. Se puede encontrar más información en 
el libro blanco de formato de archivo de forma de ESRI (ESRI 1998).
Hay más de 14 tipos de características compatibles con los archivos de formas, como puntos, 
polilíneas y polígonos. Las características 3D se agregan a la estructura del archivo de forma con una 
dimensión dedicada al valor z.
FIGURA 6.1
Estructura del archivo de forma. (Adaptado de ESRI. 1998. ESRI Shapefile Technical Description. An ESRI White 
Paper, 34.)
102Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
6.3 Estructura e Interpretación del Shapefile
6.3.1 Estructura del archivo principal de un Shapefile
El archivo principal contiene un encabezado de archivo y todos los registros de características (Figura 6.2). 
Cada registro de característica se compone de un encabezado de registro y contenidos de registro.
6.3.1.1 Encabezado del archivo principal
Figura 6.3muestra el formato del encabezado del archivo, incluidos 100 bytes. Los primeros 4 bytes indican 
que este archivo es un archivo de forma con un valor entero de 9994. Los bytes 4 a 24 son el número entero 0 
y están reservados para uso futuro. Los primeros 28 bytes, incluidos los campos de descripción de datos del 
encabezado del archivo y la longitud del archivo (entero en los bytes 24–27), son
FIGURA 6.2
Estructura del archivo principal de Shapefile.
FIGURA 6.3
Encabezado de archivo del archivo principal de forma.
Manejo de archivos de forma 103
en orden de bytes big-endian, y se requiere '>' para desempaquetar los bytes, por ejemplo, 
estructura.desempaquetar('>iiiiiii', s). La unidad para la longitud total del archivo de formas es 
una palabra de 16 bits, es decir, la longitud total del archivo en bytes sería el doble del valor del 
número interpretado.
El resto del encabezado del archivo está en orden de bytes little-endian, y se requiere '<' para 
descomprimirlos, por ejemplo,estructura.desempaquetar('<iiii', s). Omita el '<' ya que es el valor 
predeterminado para empaquetar o desempaquetar en la mayoría de las PC. A partir del byte 
28, un número entero de 4 bytes (valor de 1000) se refiere a la versión del archivo de forma. A 
partir del byte 32, un entero de 4 bytes, indica el tipo de forma de la entidad (p. ej., 1 significa 
que el archivo es para la entidad Punto y 3 indica que es un archivo de polilínea,Figura 6.3
Correcto). El byte 36 al 100 es el cuadro delimitador de todo el conjunto de datos en el archivo 
de formas. El cuadro delimitador incluye cuatro dimensiones x,y, z y m. Cada dimensión incluye 
valores mínimos y máximos en la secuencia de minx, miny, maxx, maxy, minz, maxz, minm y 
maxm. El cuadro delimitador debe escribirse con fmt '<dddddddd' para todos los valores en 
tipo de datos doble.
práctica práctica: Interpretar el encabezado del archivo de forma (Código 6.5)
• Abra la consola GUI de Python.
• Copie los datos proporcionados, incluidos Schools.shp, Schools.shx, Schools.dbf, 
en c:\code\data\.
• Practique el Código 6.5 con la GUI del intérprete de Python.
Las primeras tres declaraciones tienen 28 bytes del archivo de forma. La cuarta 
declaración descomprime los datos en orden big-endian y tiene siete números enteros. El 
primer entero es 9994, el código de archivo para archivos de forma. Los siguientes cinco 
son cero y están reservados para uso futuro. El último es la longitud del archivo, que es la 
longitud total del archivo principal de forma en unidades de 16 bits o dos bytes. Por lo 
tanto, la longitud total real del archivo es el doble del valor indicado (es decir, 288 * 2 = 
576) bytes. La siguiente instrucción lee 72 bytes y los desempaqueta utilizando el orden 
de bytes little-endian para obtener dos enteros y ocho valores dobles. La primera, con un 
valor de 1000, es la versión de shapefile. El segundo, con valor 1, indica que el tipo de 
característica del archivo de formas es Punto. Los cuatro siguientes se refieren a
> > > importarestructura
> > > f =abierto('Escuelas.shp','rb')
> > > s = f.leer(28)
> > > b = estructura.desempaquetar('>iiiiiii',s)
> > > impresiónb
(9994, 0, 0, 0, 0, 0, 288)
> > > s = f.leer(72)
> > > b = estructura.desempaquetar('<iidddddddd',s)
> > > impresiónb
(1000, 1, 1847318.8628035933, 765532.64196603, 1859639.8841250539, 
778092.9935274571, 0.0, 0.0, 0.0, 0.0)
CÓDIGO 6.5
Interpretación del encabezado del archivo principal del shapefile.
104Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
minx, miny, maxx, maxy, respectivamente, y minz, maxz, minm, maxm son todos ceros ya 
que estas dos dimensiones no se utilizan en este archivo de formas.
6.3.1.2 Registro de características
Figura 6.4muestra el encabezado del registro y la estructura de contenido para un archivo de forma de 
punto. El encabezado del registro es el mismo para todos los tipos de forma, mientras que el 
contenido del registro es diferente para diferentes tipos de características y características específicas. 
El encabezado del registro incluye 8 bytes, donde los primeros 4 bytes indican el número de registro 
secuencial y los 4 bytes siguientes indican la longitud del contenido del registro. El encabezado del 
registro está en orden de bytes bigendian. El contenido del registro para cada característica de punto 
incluye 20 bytes, y los primeros 4 bytes representan el tipo de característica, que es 1 para todos los 
puntos, 8 bytes para la coordenada x y 8 bytes para la coordenada y (Figura 6.5). El contenido del 
registro está en orden de bytes little-endian para el contenido del registro Point.
práctica práctica: Interpretar el archivo de formas de puntos (Código 6.6)
• Abra la ventana de edición de archivos de Python.
• Copie los datos, incluidos Schools.shp, Schools.shx, Schools.dbf en c:
\code\data\.
• Escriba el siguiente código en la ventana del editor de Python.
FIGURA 6.4
Encabezado y contenido del registro de puntos.
FIGURA 6.5
Estructura de archivos para el archivo Point .shp.
Manejo de archivos de forma 105
> > > importarestructura
> > > f =abierto('Escuelas.shp','rb')
> > > f.buscar(24)
> > > s = f.leer(4)#Obtener la longitud del archivo
> > > b = estructura.desempaquetar('>yo',s)##La longitud del archivo es de orden big-endian
entero
> > > featNum = (b[0]*2-100)/28##Cálculo de los números de característica
> > > fuera =abierto('escuelas_shp.txt','w')
> > > porienrango(número de hazaña):
f.buscar(100+i*28+12)
s = f.leer(16)##16 bytes con 8 bytes para x e y
x,y = estructura.desempaquetar('dd',s)##orden little-endian por defecto 
fuera.escribir(calle(yo)+':'+calle(x)+','+str(y)+'\norte')
> > > f.cerrar()
> > > fuera.cerrar()
CÓDIGO 6.6
Lea el archivo de formas de puntos y escriba los resultados en un archivo de texto.
El código 6.6 lee el archivo de forma para obtener la longitud del archivo (bytes 24 a 27 en el encabezado 
del archivo) y usa la longitud del archivo para calcular la cantidad de puntos en este archivo de forma en los 
siguientes pasos:
1. Duplicar el tamaño para convertir de una unidad de 16 bits (dos bytes) a una unidad de 8 
bits (un byte)
2. Restar 100 bytes para un encabezado de archivo
3. Dividir por 28 (cada encabezado de registro y contenido de registro ocupa 28 bytes en el archivo de 
formas de puntos) para obtener el número de característica
A continuación, se imprime la longitud del archivo y el número de entidades de puntos 
y se abre un archivo de texto para escribir los resultados. Aporloop se usa para recorrer 
cada registro/función para leer los valores x, y e imprimir y escribir en el archivo de texto. 
Por último, los dos archivos se cierran para concluir el proceso de lectura/escritura de 
archivos. En elporbucle, la primera línea mueve el puntero del archivo a la posición donde 
comienza el valor x del i-ésimo registro (100 + 12 + i*28, 12 se refieren al encabezado del 
registro [8 bytes] y el tipo de forma entero 1 [4 bytes]), luego lee 16 bytes para x, y y los 
desempaqueta en variables x, y.
6.3.2 Estructura del archivo de índice (.shx)
Figura 6.6muestra la estructura de archivos para el archivo .shx. El encabezado del archivo de índice es el 
mismo que el encabezado del archivo principal, incluidos 100 bytes, y se puede interpretar mediante el Código 
6.7. La longitud del archivo almacenado en el encabezado del archivo de índice es la longitud total del archivo 
de índice en palabras de 16 bits (las 50 palabras de 16 bits del encabezado más 4 veces el número de 
registros). Esto también se puede utilizar para calcular el número de registros. El i-ésimo registro en el archivo 
de índice almacena el desplazamiento y la longitud del contenido para el i-ésimo registro en el archivo 
principal. El desplazamiento de un registro en el archivo principal es el número de palabras de 16 bits desde el 
inicio del archivo principal hasta el primer byte del
106Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
FIGURA 6.6
Estructura de archivos para el archivo .shx.
> > > importarestructura
# Abrir en modo binario para portabilidad
> > > f =abierto('Escuelas.shx','rb')
> > > f.buscar(24)
> > > s = f.leer(4)
> > > b = estructura.desempaquetar('>yo',s)
> > > featNum = (b[0]*2-100)/8
> > > fuera =abierto('escuelas_index.txt','w')
> > > porienrango(número de hazaña):
f.buscar(100+i*8)
s = f.leer(8)
off,longitud = struct.unpack('>ii',s)
fuera.escribir(calle(yo)+':'+calle(apagado)+','+str(longitud)+'\norte')
> > > f.cerrar()
> > > fuera.cerrar()
CÓDIGO 6.7
Interpretación del archivo de índice de forma para obtener el número de registros y la longitud del contenido compensado de 
cada registro.
encabezado de registro para el registro. Por lo tanto, el desplazamiento del primer registro del archivo 
principal es 50, dado el encabezado de 100 bytes.
práctica práctica: Interpretar el archivo de punto .shx
• Abra la ventana del editor de archivos de Python.
• Si la carpeta “c:\code\data\” no tiene los siguientes archivos Escuelas. 
shp, Schools.shx, Schools.dbf, copie los datos en la carpeta.
• Escriba el Código 6.7 en el editor de Python.
Manejo de archivos de forma 107
El código 6.7 primero lee el número entero de la longitud del archivo de índice de los bytes 24 a 27. 
Este número, en unidades de 16 bits o de dos bytes, se utiliza para calcular el número de función 
mediante
1. Duplicar el valor para obtener la longitud en unidad de bytes
2. Restar 100 encabezado de archivo de índice
3. Dividiendo por el número de bytes para cada registro en el archivo de índice (8 bytes)
El número de función y la longitud delarchivo se imprimen y se abre un archivo de 
texto para mantener cada compensación de función y valor de longitud de contenido en 
el archivo principal. lospor loop lee cada registro y lo escribe en el archivo de texto. 
Nuevamente, ambos archivos se cierran al final del programa. losporel ciclo recorre cada 
registro para (a) moverse al inicio del i-ésimo registro (100 + i*8), (b) leer 8 bytes para dos 
enteros, y (c) desempaquetar los dos enteros como desplazamiento y contentLength, que 
se imprimen y se escriben en el archivo de texto siguiendo la secuencia del registro. El 
archivo de texto y la salida en la ventana interactiva se pueden usar para verificar el 
contenido.
6.3.3 El archivo .dbf
El archivo .dbf mantiene atributos para el archivo de forma relacionado. Tiene el mismo nombre que el 
archivo principal e índice. Cada característica debe tener un registro en el archivo .dbf. Cada función 
debe estar en el mismo orden en el archivo .dbf que aparece en los archivos principal y de índice. Los 
detalles del formato de archivo .dbf se pueden encontrar en línea*y no será discutido en este libro.
6.4 Secuencia de Programación General para el Manejo de Shapefiles
Leer el archivo de formas es el primer paso para procesar las características (p. ej., 
visualizar las características en la GUI, hacer un mapa y realizar un análisis espacial). Hay 
varios pasos para leer un archivo de forma:
1. Abra el archivo para leer en modo binario.
2. Lea el encabezado del archivo de índice e interprete la metainformación, por 
ejemplo, el cuadro delimitador y la cantidad de registros.
3. Lea la metainformación de los registros, como el desplazamiento y la longitud del contenido 
de cada registro.
* "Estructura del encabezado del archivo de datos para el archivo de tabla de la versión 7 de dBASE". dbase.http://
www.dbase. com/KnowledgeBase/int/db7_file_fmt.htm.
http://www.dbase.com/KnowledgeBase/int/db7_file_fmt.htm
http://www.dbase.com/KnowledgeBase/int/db7_file_fmt.htm
108Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
4. Leer datos dinámicamente en función de la estructura de contenido de cada registro para 
tipos de forma específicos.
5. Reúna datos en objetos de punto, polilínea y polígono u otros tipos.
6. Analizar y procesar datos según sea necesario.
7. Prepare los datos para escribirlos en un archivo.
8. Escriba datos formateados en archivos.
9. Cerrar archivos.
Los pasos 7 y 8 son para la salida de archivos de forma. A menos que convierta los atributos 
espaciales de cada entidad (coordenadas) o los atributos no espaciales de un formato diferente (por 
ejemplo, un archivo de texto) para generar nuevos archivos de forma, estos dos pasos no son 
necesarios. Esta conversión también se puede lograr fácilmente usando secuencias de comandos 
Python de ArcGIS, que se presentarán más adelante en este libro.
6.5 Experiencia práctica con Mini-GIS
6.5.1 Visualizar polilíneas y polígonos
• Descargue y descomprima el paquete Mini-GIS.
• Haga doble clic en el archivo MiniGIS.py.
• En la ventana de MiniGIS, seleccione Archivo->cargar .shp->seleccione la carpeta de 
países (Figura 6.7a).
(a) (b)
FIGURA 6.7
(a) Seleccione la carpeta 'países' para agregar datos, y (b) la ventana del mapa muestra los países como 
polígonos y los límites de los países como polilíneas.
Manejo de archivos de forma 109
Se mostrarán los polígonos del país y las polilíneas fronterizas del país (Figura 
6.7b). Podemos operar el mapa seleccionando Ver-> [Zoom In |Zoom Out|Zoom 
Extent|Zoom Full]. Todos los códigos fuente para la lectura del archivo, la 
visualización del mapa y la operación del mapa están incluidos en el paquete. 
Intente identificar en el paquete Mini-GIS los archivos que leen archivos de formas y 
visualizan polilíneas y polígonos.
6.5.2 Interpretar archivos de forma de polilínea
Los archivos de formas de polígonos tienen el mismo formato que las polilíneas, excepto que el 
tipo de forma es 5 y el primer punto de una parte de un polígono es el último punto de la 
misma parte de un polígono (Figura 6.8). Por lo tanto, la práctica de esta subsección se puede 
utilizar para leer archivos de forma de polígonos con actualizaciones menores.
La lectura de un archivo de polilínea puede aprovechar el código desarrollado para leer 
el número de entidad, el desplazamiento del registro y la longitud del contenido del 
registro (Código 6.8). Una vez que se identifica el desplazamiento y la longitud del 
contenido de cada registro, el resto irá a la posición inicial de un registro específico para 
comenzar a interpretar la polilínea. Para cada encabezado de registro, el primer entero es 
el número de secuencia del registro y el segundo entero es la longitud del contenido, 
como se muestra enFigura 6.8. En el contenido del registro, el primer valor es un número 
entero que muestra el tipo de forma como un valor de 3 polilíneas. Los siguientes 32 
bytes son el cuadro delimitador para minx, miny, maxx, maxy para la característica actual. 
Dado que una polilínea puede incluir varias líneas, cada línea de una polilínea se 
considera una parte. El número de partes de una polilínea sigue al cuadro delimitador 
como un número entero, seguido por el número de puntos como un número entero. 
Según el número de pieza, hay 4 bytes de número de pieza que contienen el punto de 
inicio de cada pieza en la secuencia de puntos completa de la entidad actual. El número 
inicial es 0 para la primera parte. Siguiendo el índice de la parte están las coordenadas x, 
y de los puntos. Si las dimensiones z y m se proporcionan en el formato, los campos 
relevantes, como el cuadro delimitador y los valores de las coordenadas de los puntos, se 
ajustarán de acuerdo con los valores almacenados de z y m. Con base en estos análisis,
FIGURA 6.8
El formato de polilínea de archivo de forma con el encabezado del archivo y la primera polilínea mostrada. El resto del archivo de 
forma repite el formato de registro de polilínea.
110Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
# módulos de importación para el cálculo de longitud de línea,
# descompresión de datos binarios y visualización. 
importarMatemáticas
deTkinterimportar* 
importarestructura
# definir punto, clases de polilínea clase
Punto:
definitivamente__en eso__(uno mismo, x = 0.0, y = 0.0):
self.x = x
self.y = y
clasePolilínea:
# definir el método de inicialización del objeto
# # número de piezas
definitivamente__en eso__(self, puntos= [], partNum = 0):
self.puntos = puntos
self.partsNum = partsNum
# - - - - - Parte 1: leer y procesar los primeros 100 bytes
# # 1. archivo de índice abierto para leer en modo 
binario shxArchivo =abierto("Calles_parciales.shx","rb")
# el nombre del archivo de forma se puede reemplazar con cualquier polilínea
# # 2. leer el encabezado del archivo de índice e interpretar la metainformación, por ejemplo, el 
cuadro delimitador y el número de #registros
# leer los primeros 28 
bytes s = shxFile.read(28)
# convertir a 7 enteros encabezado = 
struct.unpack(">iiiiiii",s)
# obtener la longitud del archivo
longitud del archivo = encabezado [Len(encabezado)-1]
# calcula los números de polilínea en el archivo de forma según la longitud del archivo de 
índice
polylineNum = (fileLength*2-100)/8
impresión'fileLength, polylineNum:',fileLength, polylineNum
# leer otros 72 bytes en el encabezado s 
= shxFile.read(72)
# convertir en valores
encabezado = struct.unpack("<iidddddddd",s)
# obtener el cuadro delimitador para el archivo de forma
minX, minY, maxX, maxY = encabezado[2],encabezado[3],encabezado[4],encabezado[5]
# # 3. leer registros ¡¯ metainformación, como compensación,
# # y la longitud del contenido de cada registro,
# definir una lista vacía para mantener el desplazamiento de cada función en el archivo 
principal registrosOffset = []
# recorrer cada función porienrango(0, 
número de polilínea):
# saltar al principio de cada registro 
shxFile.buscar(100+i*8)
CÓDIGO 6.8
Lectura y visualización de shapefilesde polilíneas. (Continuado)
Manejo de archivos de forma 111
# leer 4 bytes como compensación s 
= shxFile.read(4)
desplazamiento = struct.unpack('>yo',s)
# mantener el desplazamiento en la lista 
impresión'desplazamiento es:', compensar 
registrosOffset.append(offset[0]*2)
# cerrar el archivo de índice 
impresiónregistrosOffset
# - - - - - - - - Parte 2: lee cada polilínea y prepáralas en el orden correcto.
# abrir el archivo principal para leer en binario 
archivoshp =abierto("Calles_parciales.shp","rb")
# el nombre del archivo de forma se puede reemplazar con cualquier polilínea
# definir una lista vacía para polilíneas 
polilíneas = []
# recorrer cada desplazamiento de todas las polilíneas
# # 4. leer datos de forma dinámica en función de la estructura de contenido de cada registro
# # para tipos de formas específicas por
compensarenDesplazamiento de registros:
# definir dos listas para almacenar valores
x, y = [], []
# saltar a partsNum y pointsNum de la polilínea y leerlos 
shpFile.seek(desplazamiento+8+36) s = shpFile.read(8)
# generar un objeto de polilínea vacío 
polilínea = Polilínea()
partNum, pointsNum = struct.unpack('ii',s) 
polyline.partsNum = partsNum
impresión'NúmPartes, NúmPuntos: ',NúmPartes, NúmPuntos
# leer la lista de partes que contienen el número secuencial inicial de punto
# en esa parte
s = shpFile.read(4*partsNum) """
Componga el formato de desempaquetado según el número de partes
Cuando desempaquetamos una cadena binaria, necesitamos un formato (por ejemplo, 'i' para 
un entero,
'ii' para dos enteros). Sin embargo, no sabemos cuántos enteros 
(partsNum)
necesitamos desempaquetar, por lo tanto, usamos un bucle para iterar 
partsNum.
Para cada partNum, agregamos una 'i' a la str. Por lo tanto, si partNum
igual a, por ejemplo, 2, el str será igual a 'ii' después del ciclo
"""
calle=''
porienrango(número de piezas):
calle=calle+'i'
impresión'str es:',calle
CÓDIGO 6.8 (Continuado)
Lectura y visualización de shapefiles de polilíneas. (Continuado)
112Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
# obtener el número de punto de partida de cada parte y mantenerlo en una 
lista partsIndex
polilínea.partsIndex = struct.unpack(calle,s)
# recorrer cada punto en la polilínea puntos = []
porienrango(númpuntos):
# leer las coordenadas de la polilínea
# y agregar a las listas de coordenadas x, y de los puntos
# AGREGAR CÓDIGOS PARA LEER LOS VALORES DE LAS COORDENADAS AQUÍ
# 5. ensamblar datos en objetos de punto, polilínea,
# y polígono u otros tipos. punto = 
Punto(x, y) puntos.append(punto)
# asignar listas de puntos a la polilínea 
polilinea.puntos = puntos
# añadir la polilínea leída a la 
polilíneas.append(polilínea)
# - - - - - - - - - - - - - - - Parte 3: prepararse para visualizar los datos
# crear objeto de ventana principal
# 8. Analice y procese (visualice) los datos según sea necesario 
raíz = Tk()
# definir el tamaño de la ventana ancho de ventana, 
alto de ventana = 800, 600
# calcular proporciones de visualización 
ratiox = ancho de ventana/(maxX-minX) 
ratioy = altura de ventana/(maxY-minY)
# tomar la relación más pequeña entre el tamaño de la ventana y la distancia geográfica 
proporción = proporciónx
sirazón>razón:
proporción = proporción
# crear objeto lienzo
can = Canvas (raíz, ancho = 800, altura = 600)
# recorrer cada polilínea por
polilineaenpolilíneas:
# definir un xylist vacío para mantener las coordenadas convertidas 
listax = []
# recorrer cada punto
# y calcule las coordenadas de la ventana, coloque xylist porpunto
enpolilínea.puntos:
pasar
# AGREGAR CÓDIGOS AQUÍ PARA TRANSFORMAR EL SISTEMA DE COORDENADAS BASADO EN LA RELACIÓN # 
ENCONTRADA
porkenrango(polilínea.partsNum):
# obtener el número de secuencia final de puntos en la parte si
(k==polilínea.partsNum-1):
índicePuntoFinal =Len(polilínea.puntos) más:
endPointIndex = polyline.partsIndex[k+1]
# definir una lista temporal para mantener las coordenadas de la parte lista 
XY temporal = []
CÓDIGO 6.8 (Continuado)
Lectura y visualización de shapefiles de polilíneas. (Continuado)
Manejo de archivos de forma 113
# sacar las coordenadas de los puntos de la pieza
# y agregar a la lista temporal
pormetroenrango(polilínea.partsIndex[k], endPointIndex):
pasar
# AGREGAR CÓDIGOS AQUÍ PARA COMPONER LA XYlist PARA DIBUJAR CADA SEGMENTO DE LÍNEA.
# crea la linea
# can.create_line(tempXYlist,fill='azul')
# agregue líneas a la ventana y muestre la ventana 
puede.empacar()
raíz.mainloop()
# 9. cerrar archivo
shxFile.cerrar()
shpFile.cerrar()
CÓDIGO 6.8 (Continuado)
Lectura y visualización de shapefiles de polilíneas.
1. Escriba/copie el código en la ventana de programación, guarde el archivo 
python.
2. Copie los datos Partial_Streets.shp y Partial_Streets.shx en la misma 
carpeta donde guardó el archivo python .py.
3. Ejecute el archivo python.
4. Explore y analice el código para comprender cada sección del 
código.
6.6 Resumen del capítulo
Este capítulo presenta los formatos de archivo de datos vectoriales, el formato de archivo de forma de 
ESRI y explica cómo leer los archivos a través del Mini-GIS:
• Aprenda a procesar datos binarios.
• Familiarícese con las diferentes estructuras de archivos de archivos de forma, incluidos
. shp y .shx.
• Lea el .shp y .shx usando Python.
• Manejar archivos de formas de puntos.
• Manejar archivos de forma de polilínea.
PROBLEMAS
1. Elija un archivo de forma de polilínea con 10 a 100 entidades y un archivo de polígono 
con 10 a 100 entidades.
114Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
2. Escriba un programa Python para leer las polilíneas y polígonos de los archivos 
de forma. (Podemos usar archivos .shp y .shx).
3. Construya objetos de polilínea y polígono en Python.
4. Dibujar las polilíneas/polígonos usando el paquete Tkinter.
5. Comente y explique el programa para mostrar el flujo lógico de su 
programación haciendo referencia al Código 6.8.
7
Entorno de programación Python
Hay varias ramas del entorno de programación de Python, la mayoría de las cuales 
se basan en el entorno de desarrollo integrado (IDE) de código abierto de Python 
Software Foundation. Este capítulo presenta los aspectos generales del IDE de 
código abierto, incluidos los diferentes aspectos de las interfaces de programación, 
la configuración de rutas, la depuración, el resaltado y la administración de 
módulos. Esto se ejemplificó en el paquete Mini-GIS en los capítulos anteriores.
7.1 IDE general de Python
Python es un lenguaje interpretativo (o interactivo). Por lo tanto, no necesitamos compilar 
el código en un archivo ejecutable (por ejemplo, un archivo .exe o .jar) para ejecutarlo. 
Hay dos formas para que un intérprete de Python lea y aplique el código.
7.1.1 Ventanas de programación Python
7.1.1.1 GUI de línea de comandos
En el sistema de Windows, se puede acceder a la GUI de línea de comandos de Python 
IDE desde el Programa de Windows→Pitón→Python GUI (línea de comandos). La línea de 
comandos se puede utilizar como una GUI de línea de comandos de DOS o Linux. Una 
declaración de Python escrita en la GUI de la línea de comandos se ejecutará 
directamente. Hay varios comandos de Python que solo se pueden ejecutar en la GUI de 
línea de comandos (Figura 7.1), como probar el método fibo enCapítulo 6del tutorial en 
línea de Python. Sin embargo, esta es la ventana de desarrollo menos amigable porque 
no se puede personalizar y el código no está coloreado para ilustrar la estructura del 
código mientras se escribe.
7.1.1.2 GUI interactiva
Otro IDE de Python es la ventana IDLE de Python, donde el intérprete de Python 
ejecutará cada comando escrito en la GUI interactiva (Figura 7.2). IDLE es útil para 
practicar la sintaxis de Python, particularmente para usuarios novatos que no están 
familiarizados con el lenguaje Python, o para aquellos que quieren usar Python para 
operaciones simples de 'calculadora', por ejemplo, calcular 510. Sin embargo, al usar 
la interfaz IDLE, los comandos sepierden una vez que la ventana
115
116Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
FIGURA 7.1
GUI de línea de comandos de Python.
FIGURA 7.2
GUI interactiva de Python.
está cerrado; por lo tanto, la GUI interactiva no es apropiada para escribir 
programas complejos.
7.1.1.3 Programación basada en archivos
Una ventana de programación basada en archivos (se puede abrir desde Python IDLE a través 
del menú Archivo→New) proporciona una manera conveniente de conservar el código al 
guardar el código en un archivo de Python (Figura 7.3). Esta ventana puede ser invocada
Entorno de programación Python 117
FIGURA 7.3
Ventana de programación basada en archivos de Python.
del 'Archivo→Nueva ventana' de Python IDLE. Dentro de esta ventana, hay tres formas de 
ejecutar el código: (a) presione F5, (b) haga clic en Ejecutar→Ejecute el Módulo, o fuera de 
la ventana (c) haga doble clic en el archivo .py en el explorador de Windows (el IDE de 
Python debe estar instalado para que esto funcione).
7.1.2 Configuración del IDE de Python
Python IDLE se puede personalizar con el cuadro de diálogo "Preferencias de IDLE", 
que se puede invocar a través de Opciones→Configure IDLE en el menú IDLE.
7.1.2.1 Resaltar
Colorear el código puede ayudarlo a comprender, capturar, comunicarse e 
interactuar mejor con otros programadores. En Python IDLE, el código (incluidos los 
comentarios) se puede resaltar con diferentes colores según los tipos de
118Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
FIGURA 7.4
El color de las diferentes partes de un programa se puede resaltar para mejorar el formato, la comunicación, 
la interacción y la programación.
entrada de palabras. Por ejemplo, las palabras clave se pueden configurar en amarillo, las 
variables en negro y las funciones en azul (Figura 7.4). Estos ajustes se pueden personalizar en 
la pestaña "Resaltar".
7.1.2.2 Configuración General de la Ventana de Programación
El estado inicial de Python IDLE se configura en la pestaña “General” (Figura 7.5). La 
configuración incluye qué ventana inicializar (ya sea la ventana interactiva o la ventana de 
edición), cómo guardar el código, el tamaño de la ventana inicial, el formato de párrafo y 
el método de codificación de la fuente.
7.1.2.3 Configuración de fuentes para la codificación
La pestaña "Fuentes/pestañas" puede configurar el tamaño de fuente del código, el estilo y el ancho de la 
sangría (Figura 7.6).
7.1.3 Depuración
Probar el código para corregir errores y mejorar la solidez se denomina depuración. 
Es un proceso imprescindible en la programación porque es casi imposible
Entorno de programación Python 119
FIGURA 7.5
Configuración general para el estado inicial de Python IDLE.
FIGURA 7.6
Personalice el tamaño de fuente, el estilo y la sangría para Python IDLE.
120Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
escribir códigos sin errores. Esta sección repasará las habilidades básicas para el manejo 
y la depuración de errores/excepciones.
7.1.3.1 Error de sintaxis
Los errores de sintaxis ocurren cuando no se cumplen los requisitos de sintaxis y se detectan 
en el proceso de interpretación antes de que se ejecute el programa. Los errores de sintaxis se 
eliminan al traducir el código fuente a un código binario. Cuando se detecta un error de 
sintaxis, el intérprete de Python muestra el mensaje "SyntaxError: sintaxis no válida". Dichos 
errores ocurren con frecuencia, especialmente cuando no está familiarizado con la sintaxis de 
Python. El código 7.1 muestra un error de sintaxis con dos puntos faltantes (':') después de 
True.
Desafortunadamente, los mensajes de error a menudo no son informativos. A continuación se 
describen cuatro errores comunes que resultan en errores de sintaxis; esta lista se puede utilizar para 
ayudarle a detectar problemas:
• ¿Sangrar correctamente? En Código 7.2,elifdeclaración debe tener el mismo nivel 
de sangría quesideclaración.
• ¿Utiliza las palabras clave correctamente? ¿Hay errores tipográficos en las palabras clave?
• ¿Utiliza palabras clave como nombres de variables, funciones o clases?
• Declaraciones incompletas, como
• Un corchete sin cerrar '{', ' (', '[', comillas ', “
• Omitir el símbolo de dos puntos “:”. Por ejemplo, omitir los dos puntos al final de 
unadefinitivamenteotiempodeclaración produciría unaError de sintaxis: sintaxis 
invalidamensaje (Código 7.3).
• Usar if, elif o while sin ninguna expresión condicional.
Para manejar los errores de sintaxis, primero verifique esos cuatro aspectos.
> > > tiempoVerdaderoimpresión'Hola Mundo' 
Error de sintaxis: sintaxis invalida
> > >
CÓDIGO 7.1
Mientras que el problema de sintaxis no válida.
> > > si(yo>0):
impresión'i es mayor que 0' elif:impresión
'i es menor que 0'
Error de sintaxis: sintaxis invalida
> > >
CÓDIGO 7.2
Si la sintaxis no es válida debido a la sangría.
Entorno de programación Python 121
Interrupción del teclado
> > > tiempoVerdadero Error de 
sintaxis: sintaxis invalida
> > > tiempoVerdadero:
(a)
> > > definitivamenteagregar() Error de 
sintaxis: sintaxis invalida
> > > definitivamenteagregar():
(b)
CÓDIGO 7.3
Faltan partes de un error de sintaxis de declaración.
7.1.3.2 Excepciones de tiempo de ejecución
Los errores detectados durante la ejecución se denominan excepciones. Si no se 
soluciona una excepción, el programa finaliza y produce un llamadorastrearmensaje 
de error (Código 7.4). Muchas operaciones podrían dar lugar a excepciones. Por 
ejemplo, transferir una cadena sin dígitos a un flotante (Código 7.4a y b), acceder a 
elementos con índice fuera del límite (Código 7.4c) y números divididos por 0 
(Código 7.4d).Tabla 7.1da excepciones comunes y sus causas correspondientes.
> > > flotar([1,2,3])
Rastreo (llamadas recientes más última):
Archivo "<pyshell#11>", línea 1, en <módulo>
flotante ([1,2,3])
TypeError: el argumento float() debe ser una cadena o un número
(a)
> > > flotar('strv1')
Rastreo (llamadas recientes más última):
Archivo “<pyshell#16>”, línea 1, en <módulo>
flotar('strv1')
ValueError: no se pudo convertir la cadena en flotante: strv1
(b)
> > > X = [1,2,3,4]
> > > x[4]
Rastreo (llamadas recientes más última):
Archivo "<pyshell#14>", línea 1, en <módulo>
x[4]
IndexError: índice de lista fuera de rango
(C)
> > > 1/0
Rastreo (llamadas recientes más última):
Archivo "<pyshell#18>", línea 1, en <módulo>
1/0
ZeroDivisionError: división entera o módulo por cero
(d)
CÓDIGO 7.4
Ejemplos de excepciones en tiempo de ejecución.
122Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
TABLA 7.1
Excepciones integradas
Nombre de la clase Razones para tener excepciones
Excepción
Error de atributo
IOError
IndexError
Error de clave
Error de nombre
Error de sintaxis
Error de tecleado
ValorError
La clase raíz para todas las excepciones.
Intento de acceder a un atributo de objeto indefinido 
Intento de abrir un archivo inexistente
Solicitud de un índice inexistente de una secuencia, por ejemplo, lista 
Solicitud de una clave de diccionario inexistente
Intento de acceder a una variable no declarada El código 
está mal formado
Pase a la función un argumento con un objeto de tipo incorrecto
Pase a la función un argumento con el tipo de objeto correcto pero con un
valor inapropiado
ZeroDivionError División (/) o módulo (%) por un cero numérico
La resolución de problemas de esos errores es muy específica cuando se lanza una excepción 
durante el tiempo de ejecución. Se pueden tomar los siguientes pasos para manejar las excepciones 
de tiempo de ejecución:
• Verifique el tipo de excepción y revise las razones que causan las excepciones (
Tabla 7.1).
• Examine el código, especialmente la línea (indicada en el mensaje de 
excepción) que arroja errores y analice qué resultó en la excepción. A 
veces, es posible que deba subir/bajar algunas líneas para identificar el 
problema real.
• Si aún no está seguro acerca de las causas, use 'imprimir'para generar los valores de 
las variables relativas para verificar si son correctos.
• Revise el código y ejecútelo de nuevo.
7.1.3.3 Manejo de excepciones
El manejo de excepciones es el proceso de detectar las posibles excepciones y 
tratarlas antes de que falle todo el programa (Python 2001b).Probar…. exceptose 
utiliza para capturar excepciones (Figura 7.7). Coloque el código que puede producir 
excepciones en tiempo de ejecución dentro del bloque "intentar" seguido del bloque 
"excepto". Hay tres formas de manejar la parte "excepto" en función de qué tan 
específico sea el mensaje de error después de una excepción.
Puede capturar cada excepción usando un bloque de excepción diferente (Figura 7.7a) o 
atrapar múltiples excepciones dentro de un bloque de excepción (Figura 7.7b). También puede 
detectar todas las excepciones sin ningún tipo de excepción después de excepto
Entorno de programación Python 123
(b)
(a) (C)
FIGURA 7.7
Generar y capturar excepciones.
> > > probar:
pasar#intentar bloque
> > > excepto:
pasar#excepto bloque
> > > finalmente:
pasar#finalmente bloquear # se ejecuta independientemente de excepciones
CÓDIGO 7.5
Utiliza "intentar... excepto... finalmente" para capturar la excepción ZeroDivisionError y eliminar el resultado 
de la memoria si ocurre una excepción.
(Figura 7.7c). Aunque el primer enfoque requiere más codificación, se 
recomienda porque proporciona los mensajes de excepción más detallados 
para la depuración. El último enfoque no se recomienda porque no proporciona 
posibles causas para las excepciones.
losintentar... finalmentese utiliza para definir acciones de limpieza que deben 
ejecutarse en todas las circunstancias (Código 7.5 y Código 7.6). Esto significa que el
finalmenteLas declaraciones se ejecutan independientemente de si se produce o no la 
excepción.
7.1.3.4 Agregar identificadores de excepción y acciones de limpieza a la lectura/escritura de archivos
Las operaciones de archivo pueden generar excepciones en tiempo de ejecución, por ejemplo, el 
archivo o la ruta del archivo no existe. Aintentar... excepto... finalmente...La declaración se puede 
aplicar para capturar y manejar el error. En Code 7.7, el código de operación del archivo se coloca en el 
bloque "intentar", "excepto" se usa para capturar las excepciones de IOError y "finalmente" se usa 
para cerrar el archivo si existe.
124Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
> > > definitivamentedividir(x,y): 
resultado =Ninguna
probar:
resultado = x/y
devolverresultado
exceptoError de división cero:
impresión'División por cero' 
finalmente:
impresión'Limpiar ....' del
resultado
> > > dividir (3,1) 
Limpiar ....
3
> > > dividir (3,0) 
División por cero
Limpiar ....
> > >
CÓDIGO 7.6
Intente…excepto…finalmente limpiar las variables si ocurriera una excepción.
> > > f =Ninguna
> > > probar:
f =abierto('muestra.txt','r+') 
f.readline()
f.readlines()
f.buscar(0)
f.leer()
f.escribir('¡Esto es una prueba!')
> > > exceptoIOError:
impresión'¡El archivo no existe!'
> > > finalmente:
# # Cierra el archivo si el archivo se abrió siF:
f.cerrar()
CÓDIGO 7.7
Usosintentar... excepto... finalmentepara manejar excepciones de operación de archivos.
7.2 Módulos de Python
Los módulos son unidades para administrar un conjunto complejo de códigos 
dentro de Python. Los módulos de Python son una forma conveniente de organizar, 
compartir y reutilizar código. El conocimiento esencial para usar módulos incluye (a) 
comprender el concepto, (b) familiarizarse con los módulos de Python comunes y 
útiles, (c) administrar códigos como módulos y (d) configurar/instalar un nuevo 
módulo en el entorno de Python.
Entorno de programación Python 125
FIGURA 7.8
Módulos del sistema.
7.2.1 Introducción al módulo
Los bloques de código que desarrollamos durante las prácticas se han guardado como archivos 
(.py). Los módulos proporcionan una forma lógica de organizar y reutilizar estos archivos .py. 
Los archivos de código de Python se pueden importar como módulos estándar, como el 
módulo sys y math. Una vez importadas, las funciones y los atributos contenidos en el módulo 
se pueden usar en cualquier parte del programa.
Un módulo se 'compila' en una versión binaria .pyc. Este proceso se lleva a cabo 
automáticamente cuando el módulo se carga y ejecuta por primera vez. Este mecanismo de 
compilación hace que el módulo se cargue más rápido pero no se ejecute más rápido.Figura 7.8 
muestra los módulos del sistema, incluidos los archivos .py, .pyc y los paquetes.
Durante la programación, es posible organizar diferentes clases, funciones y otros 
componentes en diferentes archivos para formar diferentes módulos.
7.2.2 Configurar módulos
Hay tres formas de configurar una ruta para permitir que el sistema encuentre el módulo. 
La forma más fácil es actualizar la ruta del sistema temporalmente usando el método 
sys.path.append() (Código 7.8). Sin embargo, la configuración de la ruta se pierde cuando 
se reinicia la GUI de Python.
Para hacer que la configuración de la ruta sea persistente, cambie la Variable de entorno del 
sistema en los siguientes pasos:
1. Haga clic derecho en "Mi computadora" y seleccione "Propiedades".
2. Haga clic en la pestaña Avanzado en la parte superior; Haga clic en Variables de entorno en la parte 
inferior.
3. Haga clic en Nuevo en cualquier ventana.
126Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
> > > importarsistema
> > > sys.ruta.append('c:\ggs650código')
> > > sys.ruta
['C:/Usuarios/Phil/Documentos/cursos/libro - programación gis/códigos', 'C:\\WINDOWS\
\System32', 'C:\\Python27\\ArcGIS10.2\\Lib\\idlelib' , 'C:\\WINDOWS\\SYSTEM32\\python27.zip', 
'C:\\Python27\\ArcGIS10.2\\DLL', 'C:\\Python27\\ArcGIS10.2\\lib', ' C:\\Python27\\ArcGIS10.2\
\lib\\plat-win', 'C:\\Python27\\ArcGIS10.2\\lib\\lib-tk', 'C:\\Python27\\ArcGIS10 .2', 'C:\
\Python27\\ArcGIS10.2\\lib\\site-packages',
'C:\\Archivos de programa (x86)\\ArcGIS\\Desktop10.2\\bin', 'C:\\Archivos de 
programa (x86)\\ArcGIS\\Desktop10.2\\arcpy', 'C:\ \Archivos de programa (x86)\
\ArcGIS\\Desktop10.2\\ArcToolbox\\Scripts', 'c:\\ggs650code']
> > >
CÓDIGO 7.8
Agregue la ruta al módulo a través del método sys.path.append() agregará la ruta al final de la lista 
sys.path.
4. Agregue la variable "PYTHONPATH" y establezca el valor como "c:\ 
pythoncode".
5. Guardar y salir.
6. Reinicie su GUI interactiva de Python.
7. Verifique si su ruta se puede encontrar con sys.path importando el módulo 
sys.
Otro método para configurar la ruta del archivo del módulo es especificarlo al 
comienzo del programa Python de la siguiente manera:
sistema de importación, sistema operativo
si os.getcwd() no está en sys.path:
sys.ruta.append(os.getcwd)
La primera declaración importa los módulos sys y os. La segunda declaración obtiene 
la ruta del archivo actual usando os.getcwd para verificar si ya está en la ruta del sistema, 
agregando a la ruta del sistema si no es así.
7.2.3 Módulos integrados del sistema
Python viene con muchos módulos integrados (Tabla 7.2). Los más populares 
incluyen os, sys, math, shutil y otros. Una regla para usar un módulo es 
importarlo primero.
• El módulo os permite interacciones con el sistema operativo. Por 
ejemplo, comprobar el sistema operativo actual, el sistema de archivos 
o determinar el número de discos duros.
• LossistemaEl módulo proporciona parámetros y funciones específicos del sistema. Los 
scripts de utilidades comunes a menudo necesitan procesar argumentos de línea de 
comandos. Estos argumentos se almacenan en el atributo argv del módulo sys como 
una lista.
Traducido del inglés al español - www.onlinedoctranslator.com
https://www.onlinedoctranslator.com/es/?utm_source=onlinedoctranslator&utm_medium=pdf&utm_campaign=attribution
Entorno de programación Python 127
TABLA 7.2
Módulos integrados del sistema
Módulo Descripción Ejemplos
sistema operativo
sistema
Interactuar con el sistema operativo sistema operativo ('dir')sys.ruta, sys.exit()Parámetros específicos del sistema y
funciones
Matemáticas
cerrar
globo
Funciones matemáticas de punto flotante 
Operaciones de archivo de alto nivel
matemática.pow()
shutil.copyfile(), shutil.move() 
glob.glob('*.shp')Obtener listas de archivos del directorio
búsquedas con comodines
re Herramientas de expresiones regulares para
procesamiento avanzado de cadenas
re.match('c', 'abcdef')
fecha y hora Manipular fechas y horas 
Archivo y compresión de datos
la fecha de hoy()
ZipFile('spam .zip', 'w')zlib, gzip, bz2,
archivo zip y archivo tar
• cerrares un módulo que proporciona operaciones de archivo de alto nivel.
• globoobtiene listas de archivos de búsquedas con comodines en directorios.
• rees un módulo breve que proporciona herramientas de expresiones regulares para el 
procesamiento avanzado de cadenas.
• LosaleatorioEl módulo proporciona herramientas para hacer selecciones aleatorias.
• Losfecha y horaEl módulo proporciona clases para manipular fechas y 
horas de formas simples y complejas.
• Los formatos comunes de archivo y compresión de datos son compatibles directamente con 
módulos adicionales, incluidoszlib,gzip,bz2,archivo zip, yarchivo tar.
Matemáticas(Figura 7.9) es el módulo más popular utilizado en este libro.
Siempre podemos usar la función integrada dir() para encontrar lo que se admite 
en un módulo nuevo.Figura 7.10muestra que el módulo matemático incluye muchos 
métodos, como acos, sin, fabs, etc., y varios atributos privados, como '__ doc__', 
'__name__' y '__package__'. Estos tres atributos normalmente se incluyen en todos 
los módulos. La función integrada help() se puede utilizar para comprobar la 
descripción del módulo y las funciones.
7.3 Gestión de paquetes y Mini-GIS
7.3.1 Organización de datos GIS regulares
Figura 7.11muestra la interfaz de usuario de ArcMap que administra varios conjuntos de datos. Cada 
conjunto de datos es una capa después de que se carga desde el disco y se representa en el
128Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
FIGURA 7.9
métodos matemáticos.
FIGURA 7.10
Comprobar un módulo.
área de visualización del mapa (Figura 7.12). Las capas compuestas de un mapa muestran 
la calle, el parque, la casa (Parcelas) y la información del río sobre la ciudad de Westerville, 
Ohio. Al cargar un conjunto de datos en la memoria, cada capa incluye una serie de 
objetos (p. ej., cada casa puede tratarse como un objeto).
7.3.2 Paquete Mini-GIS
EnCapítulos 1mediante6, hemos desarrollado una serie de clases y funciones (
Figura 7.13). En nuestra práctica anterior, el módulo de visualización ha sido 
independiente del módulo Punto, Polilínea y Polígono (Figura 7.13a). Sin 
embargo, la visualización se agrega como método al módulo Punto, Polilínea y 
Polígono a través de la herencia de una superclase común, la
Entorno de programación Python 129
FIGURA 7.11
Interfaz de usuario de ArcMap.
Mapa
atributo Mapa
Capa
atributo Capa 1 capa m capa n
Objeto
atributo Objeto 1 Objeto k
FIGURA 7.12
Jerarquía de organización de datos de mapas.
Clase característica (Figura 7.13b). Por lo tanto, la visualización no tiene que 
definirse muchas veces.
Juntarlos crea un paquete para leer y mostrar archivos de forma ESRI, 
incluidas funciones simples (p. ej., calcular la distancia y el centroide). Como se 
muestra enFigura 7.14, Tkinter es un módulo incorporado para la visualización 
de datos en una GUI, y struct se usa para leer datos binarios. Una clase de 
entidad es un módulo simple que incluye solo dos métodos, __init__() y vis() (
Figura 7.14). Las clases Polyline y Point se heredan de la clase Feature e 
incluyen dos métodos, __init__() y vis(), también. Además de estos dos métodos, 
Polylines también incluye un método length(). Un polígono se hereda de la clase 
Polyline y anula la función vis().
130Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
(a)
Lectura de datos
para objetos
Punto Polilínea Polígono Visualización
Coordenadas Coordenadas Coordenadas Texto
Punto,
polilínea,
PolígonoLongitud,
baricentro,
Área
Distancia Longitud archivos de forma
(b)
Lectura de datos
para objetos
Punto Polilínea Polígono
Coordenadas Coordenadas Coordenadas Texto
Distancia Longitud Longitud archivos de forma
Visualización Visualización Visualización
FIGURA 7.13
Código desarrollado. (a) Visualización definida explícitamente separada de Punto, Polilínea y Polígono. (b) La 
visualización se hereda de la clase Feature, por lo tanto, no es necesario definir la visualización explícitamente.
Rasgo
Polilínea Punto
Polígono
Características
estructura ReadShapeFile
Tkinter Capa
Heredar Mapa
Importar En eso
FIGURA 7.14
Jerarquía de módulos Mini-GIS primarios (Tkinter y struct son módulos integrados de Python).
Entorno de programación Python 131
7.4 Experiencia práctica con Mini-GIS
Mini-GIS es un pequeño paquete de software GIS desarrollado con Python. El código 
fuente se puede descargar del paquete de material del curso. Después de descargar y 
descomprimir el archivo miniGIS.zip, habrá una carpeta miniGIS que contiene varios 
archivos de Python y una carpeta de datos de muestra que se muestra enFigura 7.15.
En la carpeta, los archivos *.py son los archivos de Python y los archivos *.pyc son los 
archivos de Python compilados. La carpeta 'sample-data' contiene varias carpetas de datos de 
archivos de forma; la carpeta 'ciudades', que contiene datos de ciudades del mundo; 'países', 
que contiene datos de países del mundo; la carpeta 'Fairfax' contiene escuelas, carreteras, 
principales líneas de servicios públicos y regiones en Fairfax; y la carpeta 'multi-parts-polyline' 
contiene dos polilíneas con multipartes.
7.4.1 Gestión de paquetes y Mini-GIS
El módulo ReadShapeFile lee diferentes tipos de entidades o capas, que 
incluyen puntos, polilíneas y polígonos (Figura 7.16). Los Comunes
FIGURA 7.15
Organización del código Mini-GIS.
132Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
FIGURA 7.16
Las funciones principales son módulos de funciones y módulos de mapas.
el módulo proporciona funciones reutilizables comunes; El Módulo de Diálogos proporciona los 
dos diálogos para seleccionar capas; y el módulo de eventos proporciona manejo de eventos 
operados por mouse.
Mini SIGEl módulo incluye la función principal. Un directorio se convierte 
en un paquete de Python si contiene __init__.py. Incluye las siguientes 
funciones:
1. Las funciones principales para llamar a otras partes.
2. Generar una ventana
3. Ingrese los conjuntos de datos
4. Visualiza los datos
5. Mostrar la ventana
Normalmente, esta es la única parte que necesita comprender completamente si obtiene el 
paquete de otro lugar; de lo contrario, la descripción de la interfaz es suficiente para usar un 
paquete.
7.4.2 Ejecute y practique el paquete Mini-GIS
Podemos ejecutar el paquete en el siguiente flujo de trabajo:
1. Agregue la ruta a la ruta del sistema; o simplemente haga doble clic en 
MiniGIS.py; o use IDLE para ejecutar el paquete. Aquí, use el tercer método para 
abrir MiniGIS.py.
2. Haga clic en Ejecutar→Ejecutar el menú del módulo o el botón 'F5' para ejecutar 
el paquete. Aparecerá una ventana, que tiene el título 'MiniGIS'.
3. Importe el archivo de forma de dos maneras: 'Importar shp' y 'Agregar capa shp' en el menú 
Archivo.Figura 7.17ailustra el mapa de los datos importados de la carpeta del archivo de 
forma de Fairfax.
Entorno de programación Python 133
(a) (b)
(C)
FIGURA 7.17
(a) Uso de Mini-GIS para importar la carpeta de archivos de forma de Fairfax. (b) Ampliar hasta la extensión. (c) Salidas de Python 
Shell.
4. Vea el mapa usando el menú en el menú 'Ver': acercar, alejar, acercar a la 
extensión, acercar a la ventana completa y cerrar la capa.Figura 7.17b
muestra el zoom del mapa hacia el límite izquierdo.Figura 7.17c muestra 
las salidas en Python Shell, que también genera la relación del mapa.
Mini-GIS también admite características de dibujode diferentes tipos: punto, polilínea, 
círculo y polígono. Para dibujar una característica, haga clic en 'Editar' para que aparezca un 
cuadro de diálogo y seleccione una capa.Figura 7.18muestra la característica agregada al mapa 
en la esquina inferior izquierda. Sin embargo, el Mini-GIS actual no admite la exportación de 
estas características añadidas al archivo de formas.
El Mini-GIS también puede calcular las intersecciones entre dos capas de 
polilíneas.Figura 7.19indica las intersecciones entre las capas de servicios y las capas 
de carretera con círculos amarillos.
134Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
FIGURA 7.18
Dibujar características.
FIGURA 7.19
Intersecciones entre las capas HIGHWAY y UTILITY_LINES.
Entorno de programación Python 135
7.5 Resumen del capítulo
El capítulo revisa el IDE de Python y demuestra cómo personalizar la 
configuración de un IDE de Python. También se analizan los módulos y se 
presenta un paquete Mini-GIS para leer y visualizar ESRI Shapefiles. Los 
detalles de implementación (como la lectura de archivos de forma) del Mini-
GIS se presentarán en los siguientes capítulos.
PROBLEMAS
1. Tomar los datos utilizados enCapítulo 4.
2. Basado en la solución de problemas enCapítulo 4, ¿cómo puede encontrar el 
cuadro delimitador (minx, miny, maxx, maxy) de las polilíneas?
3. Prepare los datos para visualizar (transformación de coordenadas, etc.) según el 
tamaño de la ventana que desea dibujar.
4. Programa para dibujar los datos (usando Canvas y objetos/funciones/
widgets relacionados). Organice su programa en un archivo o varios 
archivos para configurar un módulo en el sistema; importar el módulo y 
ejecutar el módulo que fue desarrollado y configurado.
5. Desarrolle un documento de Word que explique el programa.
6. Proporcione comentarios para todas las líneas del código para explicar la lógica.
http://taylorandfrancis.com
8
Algoritmos de datos vectoriales
GIS es diferente de otras tecnologías de software debido a sus algoritmos y análisis 
de relaciones espaciales en datos espaciales. Este capítulo introduce una categoría 
similar de algoritmos para el procesamiento de datos vectoriales, incluidos los 
cálculos de centroide (8.1), área (8.2), longitud (8.3), intersección de línea (8.4) y 
punto en polígono (8.5), que son los fundamentos algoritmos basados en la 
geometría y la relación espacial.
8.1 Centroide
El centroide se puede considerar como el centro de gravedad de una característica 
(wiki.gis 2011). Un ejemplo de aplicación del centroide es configurar la ubicación de 
la anotación, como etiquetar un edificio en un mapa. Esta sección analiza el cálculo 
del centroide para tres tipos de geometría: triángulo, rectángulo y polígono.
8.1.1 Baricentro de un Triángulo
El centroide de un triángulo se define como el punto de intersección de tres medianas de 
un triángulo (Johnson 1929,Figura 8.1). La mediana de un triángulo es el segmento de 
línea que se extiende desde un vértice hasta el punto medio de su lado opuesto. Dados 
tres vértices (X1,y1), (X2,y2), y (X3,y3) de un triángulo, el baricentro (Xcentroide,ycentroide) se puede 
calcular con la Ecuación 8.1.
- (X1+X2+X)-X- centroide =
3
3
(X+X+X)-
(8.1)
-y
--
1 2 3
centroide= 3
8.1.2 Baricentro de un rectángulo
El centroide de un rectángulo es la intersección de las dos diagonales del rectángulo 
(Figura 8.2). Dado el vértice inferior izquierdo (Xmin,ymin) y arriba a la derecha
137
138Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
(X3,y3)
(X,y)
(X1,y1) (X2,y2)
FIGURA 8.1
El baricentro de un triángulo es el punto de intersección de las tres medianas. (Referirse ahttp://
jwilson. coe.uga.edu/EMAT6680Su09/Park/As4dspark/As4dspark.html. para la prueba de concurrencia 
de las tres medianas.)
(Xmáximo,ymáximo)
(X,y)
(Xmin,ymin)
FIGURA 8.2
El centroide de un rectángulo es la intersección de dos diagonales.
vértice (Xmáximo,ymáximo) de un rectángulo, el centroide se puede calcular con la 
Ecuación 8.2.
- (Xmetro +Xmáximo
2
en )-X- centroide =
-
-
--
(8.2)
(ymin+ymáximo)
ycentroide = 2
8.1.3 Baricentro de un polígono
Para cualquier polígono cerrado que no se corte a sí mismo connortepuntos (X0,y0), (X1,y1), 
…, (Xnorte−1,ynorte−1), el centroide se puede calcular con la Ecuación 8.3, dondeAes el área del 
polígono, que se analiza en la Sección 8.2 (Bourke 1988). En esta fórmula, el último vértice 
(Xnorte,ynorte) del polígono se supone que es el mismo que el primer vértice (X0,y0). De 
hecho, los triángulos y los rectángulos son polígonos especiales, por lo que la Ecuación 
8.3 también se puede usar para calcular el centroide del triángulo y el rectángulo.
http://jwilson.coe.uga.edu/EMAT6680Su09/Park/As4dspark/As4dspark.html
http://jwilson.coe.uga.edu/EMAT6680Su09/Park/As4dspark/As4dspark.html
Algoritmos de datos vectoriales 139
-
- ∑
∑
norte−1
(Xi+1+Xi)(Xiyi+1−Xi+1yi)
--
-
-
-
X i=0centroide= 6A
(yi +yi)(Xiyi −Xiyi)
6A
(8.3)
norte−1
+ 1 + 1 + 1
ycentroide = i=0--
8.2 Área
Esta sección presenta cómo calcular el área de la entidad poligonal. Se 
discuten dos tipos de polígonos: un polígono simple y un polígono con 
hueco(s).
8.2.1 Área de un polígono simple
Un polígono simple es un polígono sin lados que se intersecan a sí mismos y que forma un 
camino cerrado.Figura 8.3amuestra un ejemplo de un polígono simple con seis puntos 
(vértices), donde el punto 1 es el mismo que el punto 6, formando un camino cerrado. Los 
puntos se registran en el sentido de las agujas del reloj.
Para calcular el área de este polígono, primero dibujamos líneas 
verticales desde cada punto del polígono hasta elX-eje para formar cinco 
trapecios: A y B (Figura 8.3b) y C, D y E (Figura 8.3c). Al examinar 
visualmente los cinco trapecios, el área del polígono (SPAGS) puede derivarse 
de la Ecuación 8.4.
SPAGS=SA+SB−SC−SD−Smi (8.4)
dóndeSA,SB,SC,SD, ySmidenote las áreas correspondientes de los cinco 
trapecios.
(a)y (b) (C)
2 2 2
1,6 1,63 3 1,6 3
5 4 = A B – 5 4
C D mi
X X X
FIGURA 8.3
Cálculo del área de un polígono simple.
140Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
Como se conocen las coordenadas de cada punto, podemos calcular el área de 
cada trapezoide con la Ecuación 8.5.
(X2−X1)(y2+y1)SA=
2
(X3−X2)(y3+y2)SB=
2
(X4−X3)(y4+y3)SC= (8.5)
2
X4)(y5+y4)(X5−SD=
2
(X6−X5)(y+y5)S= 6mi 2
Al sustituir la Ecuación 8.5 en la Ecuación 8.4, derivamos la Ecuación 8.6 para 
calcular el área del polígono.
5(Xi+1−X)(y+1+y)
2
SPAGS = ∑ i i i 12∑
5
= (Xi+1yi−Xiyi+1) (8.6)
i=1 i=1
Al generalizar la Ecuación 8.6, tenemos la Ecuación 8.7 para calcular el área de 
cualquier polígono simple connortepuntos (punto0= puntonorte).
1norte−1
A= 2∑ (Xiyi+1−Xi+1yi) (8.7)
i=0
8.2.2 Área de un Polígono con Agujero(s)
Un polígono puede tener uno o más agujeros. Por ejemplo, cuando un lago se 
representa como un polígono, una isla en el lago se puede representar como un 
agujero en el polígono. Cuando calculamos el área de un polígono, necesitamos 
restar el área del agujero del área del polígono circundante.Figura 8.4muestra una
- B
–
C
un +
FIGURA 8.4
Un polígono con dos agujeros.
Algoritmos de datos vectoriales 141
polígono (A) con dos agujeros (B y C). En GIS, los vértices de un agujero se registran en 
sentido contrario a las agujas del reloj. Por lo tanto, el área de los agujerosSBySCcalculado 
utilizando la Ecuación 8.7 dará como resultado unnumero negativo(SA< 0,SB< 0). Por lo 
tanto, el área real del polígono A se puede calcular comoS=SA− (−SB) − (−SC) =SA+ SB+SC.
8.3 Longitud
El cálculo de longitud encuentra la longitud de una entidad lineal y el perímetro de una 
entidad poligonal.
8.3.1 Longitud de un segmento de línea recta
Supongamos que hay dos puntos:PAGS1(X1,y1) yPAGS2(X2,y2) en el sistema de coordenadas 
cartesianas 2D. Para calcular la longitud del segmento de líneaPAGS1PAGS2, trazamos una 
línea horizontal desdePAGS1y una línea vertical dePAGS2para formar un triángulorectángulo (Figura 8.5). Supongamos que la longitud del lado horizontal esa, porque el 
lado vertical esb, y la hipotenusa esC. De acuerdo con el teorema de Pitágoras, tenemos 
la ecuaciónC2=a2+b2.
Si las longitudes de los lados de los dos ángulos rectosaybse conocen, la longitud 
del tercer lado, que es la longitud del segmento de rectaPAGS1PAGS2, puede ser 
derivado. Ya queaybson paralelas al eje, tenemosa=X2−X1,b=y2−y1. Reemplazando 
estas dos ecuaciones paraC2=a2+b2, la ecuación 8.8 se deriva para calcular la 
longitud de un segmento de línea:
PAGS1PAGS2=c= (X2−X21) + (y2−y1) 2 (8.8)
y
PAGS2(X2,y2)
C
b
α
PAGS1(X1,y1) a
X
FIGURA 8.5
Cálculo de la longitud de un segmento de línea recta.
142Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
PAGS3(X3,y3) PAGSnorte(Xnorte,ynorte)
PAGS2PAGS3
PAGS2(X2,y2) PAGS3PAGS4
PAGSnortePAGSnorte+1
PAGS(
PAGS1PAGS2 PAGS1(X4,y4)
norte+1Xnorte+1,ynorte+1)
PAGS1(X1,y1)
FIGURA 8.6
Una polilínea connorte+1 puntos
8.3.2 Longitud de una polilínea
Una polilínea consta de muchos segmentos de línea, por lo que la longitud de una polilínea es la suma 
de la longitud de todos los segmentos de línea.
Supongamos que hay una polilínea connorte+1 puntos:pags1,pags2,pags3,…,pagsnorte, ypagsnorte+1
(Figura 8.6). Con base en la Ecuación 8.8, la longitud de esta polilínea se puede calcular 
sumando las longitudes de todos los segmentos de línea (Ecuación 8.9).
Lpolilinea= ∑
norte norte
PAGSiPAGSi+1=∑
i=1
(Xi+1−X)2i + (y 2i+1−yi) (8.9)
i=1
8.4 Intersección de líneas
Verificar las intersecciones entre dos líneas es fundamental para los muchos 
cálculos de relaciones espaciales. Al determinar las intersecciones de línea, debemos 
verificar si los dos segmentos de línea tienen o no puntos compartidos. Dados dos 
segmentos de recta, Line1 ((X1,y1), (X2,y2)) y Línea2 ((X3,y3), (X4,y4)) en el sistema de 
coordenadas cartesianas (Figura 8.7), si dos segmentos de línea se intersecan, 
entonces debe haber al menos un punto (X0,y0) que está en ambos segmentos. 
Entonces, la pregunta es cómo averiguar si hay un punto común para los dos 
segmentos de línea. Además, ¿cómo calculamos los valores de las coordenadas del 
punto común (X0,y0)?
Un método común para representar una línea en el sistema de coordenadas 
cartesianas es usar la ecuación lineal:y=hacha+b, dóndeX,yson las variables,a,bson 
las constantes o parámetros,aes la pendiente de la recta, ybes la intersección de la 
línea cony-eje (Figura 8.8).
En base a esto, Line1 se puede representar comoy=a12X+b12; y Line2 se puede 
representar comoy=a34X+b34, dóndea12,b12,a34,b34son valores constantes que se 
pueden calcular en base a los cuatro puntos (X1,y1), (X2,y2), (X3,y3), y (X4,y4) como se 
detalla a continuación.
Algoritmos de datos vectoriales 143
y
(X,y) (X2,y2)3 3
(X1,y1) (X0,y0)
(X4,y4)
X
FIGURA 8.7
Ilustración de la intersección de segmentos de línea.
y
y=hacha + b
y=b
X
X= –licenciado en Letras
FIGURA 8.8
Representación matemática de una recta en sistema de coordenadas cartesianas.
Calculando un12,b12,a34,b34: Dado que los dos puntos (X1,y1), (X2,y2) están en la Línea 1, 
tenemos el siguiente grupo de ecuaciones (Ecuación 8.10):
-y1=a12X1+b12
--y2=a12X2+b12
(8.10)
Al resolver la Ecuación 8.10,a12,b12se representa como la Ecuación 8.11:
--a12= y−y1
X2−X1
2
- (8.11)
--b12=y1−a12X1
dóndeX2no es igual aX1.
Línea
 1
Líne
a 1Línea 2
Línea 2
144Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
De manera similar, para la Línea 2, tenemos el siguiente grupo de ecuaciones (Ecuación 8.12):
-y3=a34X3+b34
--y4=a34X4+b34
(8.12)
Al resolver la Ecuación 8.12,a34,b34se puede representar como la Ecuación 8.13:
--a34= y−y3
X4−X3
4
- (8.13)
--b34=y3−a34X3
dóndeX3no es igual aX4.
Como se mencionó anteriormente, si la Línea 1 y la Línea 2 se cruzan, debe haber un punto (
X0,y0) que es común a ambos segmentos de línea. En tal caso, (X0,y0) es la solución para el grupo 
de ecuaciones lineales binarias (Ecuación 8.14):
-y=a12X+b12
--y=a12X+b12
(8.14)
En consecuencia, el problema de buscar el punto común se transforma en 
comprobar si el grupo de ecuaciones 8.14 tiene o no solución. La solución (si existe) 
para la Ecuación 8.14 se puede representar como la Ecuación 8.15:
--X b12− b340=
- a34−a12 (8.15)
--y=a12X0+b12
dóndea34no es igual aa12, ya12,b12,a34,b34se puede calcular en base a los cuatro 
puntos dados. Se debe notar que (X0,y0) es la solución para dos rectas infinitas. 
Para comprobar si (X0,y0) cae en la Línea 1 ((X1,y1), (X2,y2)) y Línea2 ((X3,y3), (X4,y4)), 
se requiere la siguiente prueba:
X1≤X0≤X2
X3≤X0≤X4
y1≤y0≤y2
y3≤y0≤y4
Si las cuatro condiciones son verdaderas, la Línea 1 y la Línea 2 se intersecan en el punto (X0,y
0). De lo contrario, no se cruzan.
Algoritmos de datos vectoriales 145
El método anterior para verificar la intersección no funciona para dos escenarios 
especiales: líneas paralelas y líneas verticales.
8.4.1 Líneas paralelas
Como las rectas paralelas tienen la misma pendiente,a34es igual aa12. Por lo tanto, la 
Fórmula 8.15 no funciona para rectas paralelas (divididas por cero cuandoa34=a12). Esto 
tiene sentido ya que las líneas paralelas nunca se intersecarán. Sin embargo, si dos 
segmentos de línea están en la misma línea, también tenemosa34=a12. Para este 
escenario, los dos segmentos de línea se superpondrán (tendrán uno o más de un punto 
compartido) o no se cruzarán.
8.4.2 Líneas verticales
Como se ilustra enFigura 8.9, si Línea1 ((X1,y1), (X2,y2)) es vertical, tenemosX2=X1. 
En este caso, elXcoordenada del punto de intersección es igual aX1(X0=X1), y ely
coordenada del punto de intersección (y0) se puede calcular sustituyendoX0a la 
ecuación de Line2 como Ecuación 8.16.
y0=a34X0+b34 (8.16)
Una vez (X0,y0), se requiere la misma prueba para verificar si el punto de 
intersección cae en ambos segmentos de línea. Se puede aplicar el mismo 
método si Line2 ((X3,y3), (X4,y4)) es vertical.
Si ambas rectas son verticales, son paralelas. Esto se puede manejar de la misma manera 
que las líneas paralelas.
(X4,y4)
(X1,y1)
(X3,y3) (X1,y0)
(X2,y2)
FIGURA 8.9
Línea 1 ((X1,y1), (X2,y2)) es vertical.
146Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
PAGS2(X2,y2)
PAGS1(X1,y1)
PAGSnorte(Xmetro,ymetro)
PAGS(X,y1)1 1 PAGS2(X2,y2 ) PAGSnorte(Xnorte,ynorte)
FIGURA 8.10
Comprobación de intersección de dos polilíneas.
Dado que una polilínea consta de dos o más segmentos de línea (Figura 8.10), se puede 
usar el siguiente procedimiento para verificar si las dos polilíneas se cruzan: para cada 
segmento de línea en polilínea1, verifique si se cruza con alguno de los segmentos de 
línea en polilínea2. Una vez que se encuentra un único punto de intersección, podemos 
concluir que las dos polilíneas se intersecan. También podemos averiguar todos los 
puntos de intersección de dos polilíneas comprobando cada uno de los pares de 
segmentos de línea entre las dos polilíneas.
8.5 Punto en Polígono
A menudo se utiliza un algoritmo de emisión de rayos (Shimrat 1962) para comprobar si 
un punto está dentro de un polígono. Con un algoritmo de proyección de rayos, primero 
se dibuja un rayo a partir del punto en cualquier dirección fija (normalmente se toma una 
dirección vertical u horizontal para simplificar el cálculo), y luego se prueba cuántos 
puntos de intersección tiene ese rayo con el polígono. Si el número de puntos de 
intersección es impar, el punto está en el polígono; de lo contrario, el punto queda fuera 
del polígono.
Figura 8.11ilustra cómo funciona la proyección de rayos para probar si cada uno 
de los siete puntos dados está o no en el polígono.Tabla 8.1resume el número de 
puntos de intersección para los siete rayos verticales.
8.5.1 Un escenario especial
Si el rayo pasa por el vértice del polígono, entonces el rayo se cruza con ambos 
bordes compartiendo el vértice. Contar este escenario como dos puntos de 
intersección es problemático. EnFigura 8.12, el rayo del punto 1 pasapor un vértice, 
lo que genera dos puntos de intersección, lo que sugiere incorrectamente que este 
punto está fuera del polígono según la regla de pares e impares. Para el punto 3, 
que está fuera del polígono, el número de intersecciones también es dos, que es
Algoritmos de datos vectoriales 147
3 6
4
1
2 5
7
FIGURA 8.11
Ilustración del algoritmo de emisión de rayos.
TABLA 8.1
Número de puntos de intersección de los siete rayos
Identificación del punto Número de puntos de intersección ¿Punto en polígono?
1
2
3
4
5
6
7
0
2
1 (impar)
4
5 (impar)
2
6
No
No
Sí
No
Sí
No
No
consistente con la regla. Se necesita una consideración especial para resolver tales 
escenarios.
Examinando cuidadosamente, la diferencia es que, para el punto 1, las dos aristas que 
comparten el vértice están en lados diferentes del rayo, mientras que para el punto tres, 
las dos aristas están en el mismo lado (izquierda) del rayo. Un patrón general es que si los 
bordes están en lados diferentes, lo consideramos como un punto de intersección, pero si 
los bordes están en el mismo lado, lo consideramos como dos puntos de intersección. 
Según este patrón, ambos bordes del punto 2 están en el lado derecho del rayo cuando 
pasa por el vértice (es decir, dos intersecciones); agregar la intersección inequívoca en la 
parte superior del polígono da como resultado un total de tres puntos de intersección, y 
podemos concluir correctamente que cae dentro del polígono.
148Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
1 3
2
FIGURA 8.12
Escenarios especiales: el rayo pasa por el vértice del polígono.
8.6 Experiencia práctica con Python
8.6.1 Usar Python para dibujar un polígono y calcular el centroide
Descargue el archivo de Python chap8_centroid_pract.py del paquete de material del 
curso y ejecute el código para obtener la ventana "Práctica de centroide". Seleccione 
"Dibujar polígono" y haga clic en el lienzo para dibujar el polígono, luego haga clic 
en "Finalizar dibujo" para finalizar el dibujo. Seleccione "Calcular centroide" para 
calcular y visualizar el centroide en el lienzo. Identificar y analizar el código para el 
cálculo y visualización del centroide (Figura 8.13).
8.6.2 Uso de Python para dibujar polígonos y calcular el área del polígono
Descargue el archivo de Python chap8_area_pract.py del paquete de material del curso y 
ejecute el código para que aparezca la ventana "Práctica del área". Seleccione "Dibujar 
polígono" y haga clic en el lienzo para dibujar un polígono, luego haga clic en "Finalizar 
dibujo" para terminar de dibujar la imagen. Finalmente, haga clic en "Calcular área" para 
mostrar el área de este polígono. Identificar y analizar el código para el cálculo del área (
Figura 8.14).
8.6.3 Uso de Python para dibujar segmentos de línea y calcular la intersección
Descargue el archivo de Python chap8_intersection_pract.py del paquete de material 
del curso y ejecute el código para obtener la ventana "Práctica de intersección de 
líneas". Seleccione "Dibujar líneas" y haga clic en el lienzo para dibujar una línea, 
luego haga clic en "Finalizar dibujo". Repita para dibujar otra línea, luego haga clic 
en el botón "Comprobar intersección" para ver si se cruzan. Identifique y analice el 
código para el cálculo de intersección (Figura 8.15).
Algoritmos de datos vectoriales 149
FIGURA 8.13
Ventana “Práctica Centroide”.
FIGURA 8.14
Ventana “Área de práctica”.
150Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
FIGURA 8.15
Ventana “Práctica de intersección de líneas”.
8.7 Resumen del capítulo
Este capítulo presenta varios algoritmos de datos vectoriales populares dentro de 
SIG, que incluyen intersecciones de líneas, cálculos de centroides, cálculos de área y 
longitud y puntos en polígonos. Después de la discusión de los algoritmos, se 
proporcionan prácticas prácticas, con el objetivo de demostrar cómo implementar 
mediante programación los algoritmos de datos vectoriales utilizando Python.
PROBLEMAS
• Revisar el material de clase.
• Revisar el código de práctica de la clase: chap8_intersection_pract.py
• Cree los siguientes cuatro segmentos de línea: [(50 200), (400 200)], [(60 450), (400 
450)], [(100 600), (350 250)], [(300 100), (300 400)]
• Escribir un programa para determinar si se cruzan entre sí.
• Muestre los segmentos de línea en el monitor y dibuje el punto de 
intersección en un color y tamaño diferente.
Sección III
SIG avanzado
Algoritmos y sus
Programación en ArcGIS
http://taylorandfrancis.com
9
Programación ArcGIS
Programar todas las funciones de mapeo o análisis GIS desde cero no es factible 
debido a sus complejidades; sin embargo, muchos paquetes comerciales y de 
código abierto, como ArcGIS, admiten funciones GIS tan completas. La integración 
de varias funciones de paquetes existentes satisfará los requisitos analíticos de una 
aplicación. ArcGIS admite dicha implementación de flujo de trabajo a través de la 
programación de Python, que se ha convertido en una capacidad buscada por los 
profesionales de GIS. Este capítulo presenta la programación en ArcGIS for Desktop 
(es decir, ArcMap) usando Python. El conocimiento de ArcGIS presentado en este 
capítulo sentará las bases para los capítulos posteriores cuando programe 
algoritmos y análisis.
9.1 Programación ArcGIS
Muchas aplicaciones GIS prácticas son complejas e involucran múltiples funciones 
GIS, como modificar y consultar entidades y sus atributos asociados. Tomando la 
hospitalización como un ejemplo típico de SIG, supongamos que hay un grupo de 
pacientes potenciales a los que les gustaría ir a los hospitales más cercanos. Para 
ubicar el hospital más cercano para cada paciente potencial, la iteración debe pasar 
por cada paciente para identificar los hospitales dentro del vecindario de ese 
paciente y luego ubicar el hospital más cercano de cada paciente potencial. Esto se 
vuelve engorroso cuando hay una gran cantidad de pacientes.
Realizar y repetir manualmente la consulta y el procesamiento de datos espaciales requiere 
mucho tiempo, es tedioso y propenso a errores. Por lo tanto, es beneficioso automatizar dichos 
procesos utilizando la funcionalidad de un paquete GIS sofisticado. ArcGIS ModelBuilder (Figura 
9.1, Esri 2016a) permite a los usuarios integrar múltiples herramientas desde ArcToolbox (
Figura 9.1a) para formar un flujo de trabajo de análisis en una interfaz gráfica de usuario. 
Tenga en cuenta que ArcToolbox está reorganizado en la nueva versión de ArcGIS (p. ej., 10.4 y 
versión pro). La información relacionada se puede encontrar enhttp://pro.arcgis.com/en/pro-
app/help/analysis/geoprocessing/ basics/what-is-geoprocessing-.htm. El modelo podría 
procesar por lotes los procesos compatibles con las herramientas. Además, ArcGIS proporciona 
el paquete ArcPy (Esri 2016b), una biblioteca/módulo de Python que puede operar la mayoría 
de las funciones de ArcMap. Automatizar un proceso que involucra múltiples algoritmos GIS o 
pasos usando el paquete ArcPy y Python es rápido y fácil. El proceso por lotes integrado en 
ModelBuilder también se puede exportar como secuencias de comandos de Python. 
ModelBuilder es,
153
http://pro.arcgis.com/en/pro-app/help/analysis/geoprocessing/basics/what-is-geoprocessing-.htm
http://pro.arcgis.com/en/pro-app/help/analysis/geoprocessing/basics/what-is-geoprocessing-.htm
154Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
(a)
(b)
FIGURA 9.1
Geoprocesamiento con (a) ArcToolbox, ModelBuilder y (b) la ventana ArcMap Python.
por lo tanto, similar a las secuencias de comandos de Python con ArcPy; sin embargo, la 
creación de secuencias de comandos con ArcPy es más flexible que ModelBuilder, que está 
restringida por las ArcTools disponibles y la plantilla de operaciones. ArcMap proporciona una 
ventana de edición de complemento de Python (Figura 9.1b). Puede escribir secuencias de 
comandos de Python en un IDE de Python fuera de ArcMap importando el paquete de ArcPy. 
Estecapítulo presenta cómo usar ArcPy y demuestra su uso a través de una serie de ejemplos. 
La Sección 9.2 detalla la estructura de ArcPy, el entorno de programación y cómo usar los 
documentos de ayuda. Las secciones 9.3 a 9.7 presentan varias de las funcionalidades de ArcPy 
más utilizadas. Las Secciones 9.8 y 9.9 muestran cómo agregar las secuencias de comandos de 
Python desarrolladas como una nueva ArcTool para que otros puedan reutilizar la herramienta 
de secuencias de comandos de ArcMap.
9.2 Introducción al Paquete ArcPy
9.2.1 Funciones, clases y módulos de ArcPy
El paquete ArcPy se basa en el 'módulo de secuencias de comandos del geoprocesador de ArcGIS' 
anterior proporcionado a los usuarios desde la versión ArcGIS 10.0 para ofrecer funciones, clases y 
módulos para acceder a la mayoría de las funciones de ArcMap:
• Función: una funcionalidad definida por Esri que finaliza una tarea específica 
(p. ej., ListFeatureClasses, Describe, SearchCursor).
Programación ArcGIS 155
• Clase: una plantilla de objeto definida por Esri que tiene un conjunto de 
propiedades y métodos (p. ej., objetos SpatialReference, FieldMap).
• Módulo: un archivo de Python que generalmente incluye funciones y clases 
que realizan tareas similares. Hay acceso a datos, mapeo, analista de red, 
analista espacial y módulos de tiempo en las versiones de ArcMap 10.1+.
9.2.2 Programación con ArcPy en ArcMap
A partir de la versión 10.0, Esri incrustó una ventana de Python dentro de ArcMap (Figura 
9.2superior), que se puede abrir a través del botón en la barra de herramientas (dentro 
del rectángulo rojo). Podemos escribir el script de Python en el panel izquierdo de la 
ventana de Python (Figura 9.2lower), que tiene ArcPy importado, por lo que no tenemos 
que importar el paquete desde scripting. El documento de ayuda interactivo se incluye en 
el panel derecho para describir la función o clase actual que se está utilizando.
NOTA :Usamos 'ArcPy' en este texto para ser coherentes con la convención de nomenclatura de 
Esri; sin embargo, en la programación, se utilizará 'arcpy' (todo en minúsculas).
Práctica práctica 9.1
• Abra la ventana de Python desde ArcMap y escriba (no copie) el 
siguiente comando:
arcpy.Buffer_analysis(“”,“”,“”, “COMPLETO”, “FLAT”, “TODO”)
FIGURA 9.2
Ventana de ArcMap Python y el botón de apertura.
156Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
• Mientras escribe, observe el cambio en el documento de ayuda interactivo en 
el panel derecho de la ventana.
9.2.3 Programación con ArcPy en la ventana de Python fuera de ArcMap
Si programa con ArcPy fuera de ArcMap, importe el paquete de ArcPy (Figura 9.3) primero 
y luego importe el uso de ArcPy en el entorno externo para asegurarse de que sea el 
mismo que en la ventana de ArcMap Python. ArcGIS debe estar instalado para usar ArcPy. 
Los scripts desarrollados pueden guardarse como archivos *.py, distribuirse a otros o 
agregarse como una nueva ArcTool en la caja de herramientas, como se detalla en la 
Sección 9.8.
Para mejorar la flexibilidad de los scripts desarrollados para los usuarios finales, 
configure la entrada como valor "dinámico" y permita que el programa recupere 
automáticamente la entrada. lossys.argvse puede usar para este propósito con una lista 
de cadenas que contienen el nombre del script y argumentos adicionales que se pasan al 
script.
Práctica práctica 9.2: Obtención de la entrada de parámetros del sistema
1. Abra la ventana del editor de Python e ingrese el Código 9.1. Guarda el código en
un archivo .py, por ejemplo, samplecode.py.
2. Abra la consola de comandos de Windows, navegue a la carpeta donde se 
guardó el archivo *.py y ejecute el script para realizar el análisis de búfer 
con el siguiente comando:
código de muestra.py C:\Default.gdb\out2 C:\Default.gdb\output 5000 
metros
El primer parámetro es la ruta absoluta de los datos de entrada, el segundo 
parámetro es la ruta absoluta de los datos de salida y el tercero describe el tamaño 
del búfer (Figura 9.4).
FIGURA 9.3
Ejemplo de código de uso de ArcPy fuera de ArcMap.
Programación ArcGIS 157
importararcpy
importarsistema
script_name = sys.argv[0] 
fc=sys.argv[1]
salida=sys.argv[2]
bufferSize=sys.argv[3]
arcpy.Buffer_analysis(fc, salida, bufferSize)
CÓDIGO 9.1
Código Python usando ArcPy y permitiendo entradas de parámetros flexibles.
FIGURA 9.4
Captura de pantalla del comando de Windows para ejecutar un archivo .py y la salida. (Si no se informa 
ningún error en la ventana y se genera la salida, entonces la ejecución es exitosa).
9.2.4 Uso de documentos de ayuda
Esri ofrece varios documentos de ayuda para que los usuarios obtengan conocimientos 
detallados sobre secuencias de comandos al utilizar ArcPy. Los usuarios pueden acceder al 
documento de ayuda de escritorio (Figura 9.5) haciendo clic en la opción "ayuda" en la barra de 
menú de ArcMap. Hay otro documento de ayuda disponible en el centro de recursos de ArcGIS (
Figura 9.5). Para la versión de ArcGIS 10.1 a 10.2.2, el contenido se encuentra en "escritorio" -> 
"geoprocesamiento" -> "ArcPy" en el centro de recursos (http://resources.arcgis.com/en/help/
main/10.2/index.html). Para la versión más reciente, la información se puede explorar enhttp://
resources.arcgis.com/en/help/. Tanto el centro de recursos como el documento de 'Ayuda' de la 
versión de escritorio describen cómo usar ArcTools. Al final de la introducción de cada 
herramienta, también hay detalles de sintaxis y un código de muestra para usar la función 
ArcPy (Figura 9.6). Se puede acceder a esto en "escritorio" -> "geoprocesamiento" -> "referencia 
de herramienta". También puede buscar el nombre de la herramienta y la sintaxis para que el 
código de muestra se proporcione en la parte inferior de la página de resultados.
Para los usuarios novatos, una forma de aprender ArcPy es revisar uno de los tres 
documentos de ayuda, probar el código de muestra y realizar cambios en el código 
utilizando datos personalizados. La ventana de solicitud de Python dentro de ArcMap 
incorpora la ayuda interactiva en cada función y clase de ArcPy.
http://resources.arcgis.com/en/help/main/10.2/index.html
http://resources.arcgis.com/en/help/main/10.2/index.html
http://resources.arcgis.com/en/help/
158Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
FIGURA 9.5
Documento de ayuda de escritorio y en línea.
Práctica práctica 9.3: Aprenda a leer documentos de ayuda
1. Lea la ayuda en el centro de recursos de ArcGIS.
2. Busque la herramienta "Agregar campo" en el cuadro de búsqueda en la parte superior derecha.
3. Lea la sintaxis de "arcpy.AddField_management" y ejecute el código 
de muestra con sus propios datos.
9.3 Automatización de ArcTools con Python
Se puede acceder a la mayoría de las herramientas de ArcToolBox mediante el script de ArcPy. Por 
ejemplo, el análisis de clips es
Programación ArcGIS 159
FIGURA 9.6
Sintaxis y código de muestra del script de Python en el documento de ayuda en línea para la herramienta de geoprocesamiento 
correspondiente.
arcpy.Clip_analysis (in_features, clip_features, out_feature_class, 
{ cluster_tolerance})
donde los primeros tres parámetros son obligatorios y el último parámetro con llaves es 
opcional. La creación de secuencias de comandos, en lugar de operar la herramienta a 
través de la interfaz de ArcToolBox, es muy útil cuando el proceso implica un bucle (
declaración for/while)o expresión condicional (sideclaración) para ejecutar la función de 
geoprocesamiento repetidamente bajo ciertas condiciones. Por ejemplo, para calcular la 
longitud de la línea dentro de cada polígono en una capa de datos, el proceso debe incluir 
unporbucle para habilitar el proceso repetido para cada polígono. Dentro deporbucle, 
habrá una función de recorte que puede cortar la línea dentro de ese polígono y una 
función de estadísticas, que suma la longitud total de las líneas dentro del polígono.
160Introducción a la Programación GIS y Fundamentos con Pythony ArcGIS®
Práctica práctica 9.4: Calcular la longitud de la carretera dentro de un área
1. Escriba Código 9.2 en la ventana de Python en ArcMap. Cambie las rutas 
según su espacio de trabajo.
Tenga en cuenta que arcpy.env.workspace se ejecuta al principio para configurar 
el espacio de trabajo, que es la ruta para acceder a los datos de entrada y guardar los 
resultados. Con el espacio de trabajo del entorno configurado, el parámetro de 
entrada y salida se puede configurar mediante la ruta relativa. Si las entradas son 
clase de entidad, imagen, etc., almacenadas en una geodatabase, podemos 
configurar la geodatabase como el espacio de trabajo. Si las entradas son Shapefiles, 
TIN, etc., podemos configurar la geodatabase como la carpeta donde se almacenan 
los archivos de entrada. Por el contrario, si el espacio de trabajo no está configurado, 
los parámetros de entrada y salida deben configurarse mediante rutas absolutas. 
Incluso cuando se configura el espacio de trabajo, aún podemos ingresar o generar 
cualquier conjunto de datos fuera del espacio de trabajo usando directamente la ruta 
absoluta, por ejemplo:
arcpy.MakeFeatureLayer_management("I:\\sampledata\\data.gdb\\ 
bearMove", "inferLy")
2. Abra las tablas de salida y enumere las longitudes totales de las carreteras en cada 
polígono (Figura 9.7)
9.4 Acceso y edición de datos con cursores
Los análisis o procesos de datos a menudo requieren registros para acceder a los valores de los 
campos. Utilice el cursor para apuntar a un registro en una tabla o clase de entidad.
Un cursor es un objeto de acceso a datos que se puede usar para recorrer el 
conjunto de filas de una tabla o para insertar nuevas filas en una tabla. Los cursores 
se utilizan comúnmente para leer y actualizar atributos. Cursor es una de las 
funciones de ArcPy en el módulo de acceso a datos Cursor (que requiere 
ArcGIS10.1+), y se recomienda debido a su alto rendimiento y fácil operación.
Los cursores tienen tres formas. Están
• SearchCursor: acceso de solo lectura para obtener la geometría y los atributos de los 
registros de características
• UpdateCursor: acceso de lectura y escritura para actualizar registros de características
• InsertCursor: acceso de escritura con capacidad para crear nuevos registros
9.4.1 Cursor de búsqueda
La función SearchCursor establece un cursor de solo lectura en una clase de entidad, 
como un archivo de formas o una tabla. El SearchCursor se puede utilizar para iterar
Programación ArcGIS 161
""
"
Es
ta
bl
ez
ca
 la
 r
ut
a 
de
 la
s 
ca
rr
et
er
as
 d
e 
da
to
s 
de
 e
nt
ra
da
 y
 lo
s 
da
to
s 
de
 o
ri
ge
n.
 N
ec
es
it
as
 c
am
bi
ar
 a
 tu
 p
ro
pi
o 
ca
m
in
o.
 E
n 
es
ta
 
m
ue
st
ra
, e
l e
sp
ac
io
 d
e 
tr
ab
aj
o 
es
 u
na
 g
eo
da
ta
ba
se
.
"b
ea
rM
ov
e"
 y
 "
ro
ad
s"
 s
on
 d
os
 c
la
se
s 
de
 e
nt
id
ad
 e
n 
la
 g
eo
da
ta
ba
se
.
""
"
ar
cp
y.
en
v.
es
pa
ci
o 
de
 tr
ab
aj
o 
="
O
:\\
Li
br
o\
\C
ód
ig
o\
\9
\\
ch
p9
D
at
a\
\b
oo
kS
am
pl
eD
at
a.
gd
b"
# 
as
eg
úr
es
e 
de
 q
ue
 b
ea
rM
ov
e 
es
té
 e
n 
el
 e
sp
ac
io
 d
e 
tr
ab
aj
o 
pr
im
er
o 
ar
cp
y.
M
ak
eF
ea
tu
re
La
ye
r_
m
an
ag
em
en
t(
"b
ea
rM
ov
e"
,"
in
fe
rL
y"
) 
ar
cp
y.
M
ak
eF
ea
tu
re
La
ye
r_
m
an
ag
em
en
t(
"c
ar
re
te
ra
s"
,"
ta
rg
et
Ly
")
""
"
"M
ak
eF
ea
tu
re
La
ye
r_
m
an
ag
em
en
t"
 p
ue
de
 c
re
ar
 u
n 
ob
je
to
 d
e 
ca
pa
 d
e 
ca
ra
ct
er
ís
ti
ca
s 
a 
pa
rt
ir
 d
e 
la
 ru
ta
 d
e 
la
 e
nt
ra
da
, 
qu
e 
es
 u
na
 c
ad
en
a.
 A
 c
on
ti
nu
ac
ió
n,
 s
e 
re
al
iz
an
 "
Se
le
ct
La
ye
rB
yA
tt
ri
bu
te
",
 "
Cl
ip
_a
na
ly
si
s"
 y
 "
St
at
is
ti
cs
_a
na
ly
si
s"
 e
n 
la
 
ca
pa
 d
e 
en
ti
da
de
s.
""
"
po
ri
en
ra
ng
o(
0,
9)
:
# 
se
le
cc
io
na
 e
l p
ol
íg
on
o 
co
n 
FI
D
 =
 i
ar
cp
y.
Se
le
ct
La
ye
rB
yA
tt
ri
bu
te
_m
an
ag
em
en
t(
"i
nf
er
ir
",
"N
EW
_S
EL
EC
TI
O
N
",
"\
"O
BJ
EC
TI
D
 \"
="
+c
al
le
(i)
)
# 
ej
ec
ut
ar
 a
ná
lis
is
 d
e 
cl
ip
 y
 e
xt
ra
er
 d
at
os
 in
te
rm
ed
io
s 
"o
ut
_"
 +
 s
tr
(i)
 e
n 
el
 e
sp
ac
io
 d
e 
tr
ab
aj
o 
fc
 =
 
ar
cp
y.
Cl
ip
_a
na
ly
si
s(
"o
bj
et
iv
o"
, "
in
fe
ri
r"
, "
fu
er
a"
+c
al
le
(i)
)
# 
ej
ec
ut
ar
 e
l a
ná
lis
is
 e
st
ad
ís
ti
co
 d
e 
su
m
a 
y 
ge
ne
ra
r e
l r
es
ul
ta
do
 "
su
m
_"
 +
 s
tr
(i)
 e
n 
el
 e
sp
ac
io
 d
e 
tr
ab
aj
o 
ar
cp
y.
St
at
is
ti
cs
_a
na
ly
si
s(
fc
,"
su
m
a"
+c
al
le
(i)
, [
["
Fo
rm
a_
Lo
ng
it
ud
",
"S
U
M
A"
]])
CÓ
D
IG
O
 9
.2
Au
to
m
at
ic
e 
el
 c
ál
cu
lo
 d
e 
la
 lo
ng
itu
d 
de
 la
 c
ar
re
te
ra
 d
en
tr
o 
de
 c
ad
a 
po
líg
on
o.
162Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
FIGURA 9.7
Ejemplo de tabla de resumen de salida generada por Code 9.2.
a través de objetos de fila y extraer valores de campo. La sintaxis de SearchCursor es la 
siguiente:
arcpy.da.searchCursor (in_table, field_names, {where_clause}, {spatial_reference}, 
{explode_to_points}, {sql_clause})
El primer argumento (tabla de características de entrada) y el segundo argumento (los campos 
consultados) son obligatorios, mientras que otros son opcionales (p. ej., limitados por una cláusula where o 
por campo, y opcionalmente ordenados).
Práctica práctica 9.5: Obtener atributos de cada característica de un Shapefile usando el 
cursor de búsqueda
1. Abra una ventana de Python en ArcMap y escriba Código 9.3.
# cambia la ruta según la tuya
datos de entrada ="O:\\Libro\\Código\\9\\chp9Data\\Partial_Streets.shp"
"""
Abra un SearchCursor e incluya una lista de atributos a los que desea acceder (por ejemplo, 
Shape_Leng, NAME, TYPE) en los parámetros.
"""
filas = arcpy.da.SearchCursor(inputdata, ["Forma_Longitud","NOMBRE","ESCRIBE"]) archivo 
de salida =abierto("C:\\ArcGISdata\\resultados.txt","w")
# iterar a través de las filas en el cursor porfilaen
filas:
# se accede a los atributos usando la fila [índice] - por ejemplo, la fila [0] es "Shape_Leng" 
archivodesalida.escribir("{}, {}, {}\n".format(fila[0], fila[1], fila[2]))
"""
El cursor colocará un bloqueo en los datos hasta que se complete el script o se elimine el objeto 
del cursor. Por lo tanto, debemos eliminar los objetos de fila y cursor para eliminar los bloqueos 
de lectura en la fuente de datos.
"""
delfila
delfilas
archivo de salida.cerrar()
CÓDIGO 9.3
SearchCursor con declaración for.
Programación ArcGIS 163
datos de entrada ="O:\\Libro\\Código\\9\\chp9Data\\Partial_Streets.shp"
conarcpy.da.SearchCursor(datos de entrada, ["Forma_Longitud","NOMBRE","ESCRIBE"])comofilas:
porfilaenfilas:
impresión"{}, {}, {}\n".format(fila[0], fila[1], fila[2])
CÓDIGO 9.4
SearchCursor usando la instrucción with.
datos de entrada ="O:\\Libro\\Código\\9\\chp9Data\\Partial_Streets.shp"
# seleccione las funciones con FID < 10
conarcpy.da.SearchCursor(datos de entrada, ["Forma_Longitud", "NOMBRE", "TIPO"], 
"FID < 10")comofilas:
porfilaenfilas:
impresión"{}, {}, {}\n".format(fila[0], fila[1], fila[2])
CÓDIGO 9.5
SearchCursor con cláusula where ("FID < 10").
2. Verifique el archivo results.txt. ¿Qué se incluye en el archivo? ¿Cuántas líneas 
puedes encontrar en el archivo?
3. Los cursores de búsqueda también son compatibles concondeclaración. Usando 
unconLa declaración garantizará que el iterador se cierre y se libere el bloqueo 
de la base de datos. Al aplicar elcondeclaración, el código anterior se puede 
cambiar a Código 9.4.
4. UndóndeLa cláusula puede usarse para limitar los registros devueltos por el cursor. 
Ejecute el Código 9.5 y verifique el resultado nuevamente. ¿Cuántas líneas se incluyen 
en el archivo de resultados?
5. SearchCursor también puede acceder a la geometría característica. Ejecute Code 9.6 y 
Code 9.7, y luego verifique el resultado nuevamente:
conarcpy.da.SearchCursor(datosde entrada, [" FORMA@ ", " FORMA@LONGITUD "], 
"FID < 10")comofilas:
porfilaenfilas:
# devuelve la x y la y del primer punto y la longitud de cada 
característica
impresión"{}, {}\n".format(fila[0].primerpunto, fila[1])
CÓDIGO 9.6
Acceso a la geometría mediante el ejemplo 1 de SearchCursor.
conarcpy.da.SearchCursor(datos de entrada, [" FORMA@ "],"FID < 10")comofilas:
porfilaenfilas:
porpntarrayenfila[0]:
porpuntoenpntarray:
# devolver una tupla de coordenadas x e y de los dos primeros
# características en los datos
impresión("{0}, {1}".format(punto.X, punto.Y))
CÓDIGO 9.7
Acceso a la geometría mediante el ejemplo 2 de SearchCursor.
164Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
datos de entrada ="O:\\Libro\\Código\\9\\chp9Data\\Partial_Streets.shp"
# crear cursor de actualización para la clase de entidad
conarcpy.da.UpdateCursor(datos de entrada, ["Forma_Longitud","DEFENSOR"])comofilas:
porfilaenfilas:
# actualice el campo "Shape_Leng" bajo las condiciones del campo 
"FID"
sifila[1] > 10:
fila[0] = fila[0] * 0,3048
más:
fila[0] = fila[0] * 0.5 
filas.updateRow(fila)
CÓDIGO 9.8
Ejemplo de UpdateCursor.
datos de entrada ="O:\\Libro\\Código\\9\\chp9Data\\railway.shp"
# crear cursor de actualización para la clase de entidad
conarcpy.da.UpdateCursor(datos de entrada, ["Forma","DEFENSOR"])comofilas:
porfilaenfilas:
sifila[1] < 10:
filas.deleteRow()
CÓDIGO 9.9
Uso de UpdateCursor para eliminar filas/registros.
9.4.2 Actualizar Cursor
El objeto UpdateCursor se puede usar para actualizar o eliminar filas específicas en una 
clase de entidad, un archivo de formas o una tabla. La sintaxis de UpdateCursor es similar 
a la de SearchCursor:
arcpy.da.UpdateCursor (in_table, field_names, {where_clause}, {spatial_reference}, 
{explode_to_points}, {sql_clause})
Práctica práctica 9.6: actualice los atributos de cada característica para un archivo 
Shapefile usando UpdateCursor
1. Verifique el valor del atributo de "Shape_Leng" en los datos "Partial_ 
Streets.shp".
2. Abra una ventana de Python en ArcMap y escriba Código 9.8 en el editor.
3. Verifique el resultado "Partial_Streets.shp" para ver si el atributo 
"Shape_Leng" se ha actualizado.
4. Abra una ventana de Python en ArcMap y escriba Código 9.9 en el editor y 
ejecute el código para eliminar filas específicas.
9.4.3 Insertar cursor
InsertCursor se utiliza para insertar nuevos registros en una clase de entidad, un archivo de formas o 
una tabla. InsertCursor devuelve un objeto de enumeración, es decir, una fila en una tabla.
Programación ArcGIS 165
datos de entrada ="O:\\Libro\\Código\\9\\chp9Data\\bookSampleData.gdb\\school"
# cree el cursor de inserción y enumere los atributos que deben completarse 
con valores
cursor = arcpy.da.InsertCursor(inputdata, ["ESCUELA_NAM"," FORMA@XY "])
"""
Cree un nuevo registro con la propiedad "NOMBRE" rellenado con el 
valor "NewSchool" y las coordenadas xy rellenadas con 
(1847395.83394, 772277.97643)
"""
nueva_fila = ["Nueva escuela", (1847395.83394, 772277.97643)] 
cursor.insertRow(nueva_fila)
# eliminar cursor para eliminar bloqueos en los datos 
delcursor
CÓDIGO 9.10
Insertar ejemplo de cursor.
Práctica práctica 9.7: Inserta filas en un Shapefile usando el InsertCursor
1. Abra la tabla de atributos de “school.shp” y cuente el número de 
registros.
2. Abra una ventana de Python en ArcMap y escriba Código 9.10.
3. Verifique la nueva fila agregada a los datos "school.shp".
9.4.4 NúmPy
Como una característica nueva en ArcMap 10.1+, los módulos de acceso a datos ofrecen 
funciones para permitir la transformación entre matrices de datos y clases o tablas de 
características. Dado que la biblioteca NumPy tiene capacidades poderosas para manejar 
matrices, la función relacionada de ArcPy se desarrolla en base a NumPy. Con arcpy. 
NumPyArrayToFeatureClass, arcpy.NumPyArrayToTable y arcpy. Con las funciones 
TableToNumPyArray, los usuarios pueden transformar rápidamente los valores que están 
organizados en una matriz en una clase de entidad o tabla, y viceversa.
Sin usar la función NumPy en el módulo de acceso a datos, incluya muchos más pasos 
para crear una clase de entidad de puntos para que el rendimiento sea mucho menor 
(Código 9.11).
Por el contrario, crear la clase de entidad con NumPy requiere solo un paso. 
La función arcpy.da.NumPyArrayToFeatureClass en realidad crea una clase de 
entidad e inserta dos registros dentro.
Las manos en
NumPyArrayToFeatureClass
Práctica 9.8: Crear una clase de entidad usando
1. Abra la ventana de Python en ArcMap y ejecute el Código 9.12 para crear 
una clase de entidad usando las funciones NumPy en el módulo de acceso 
a datos.
166Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
importararcpy
importarentumecido
# matriz de entrada
matriz = numpy.array([(1,(471316.3835861763, 5000488.782036674)),
(2, (470402.49348005146, 5000049.216449278))], numpy.dtype([('campo 
de id', numpy.int32),('XY','<f8',2)]))
# crea la clase de entidad con el campo XY en la matriz hazaña = 
arcpy.CreateFeatureclass_management
("O:\\Libro\\Código\\9\\chp9Data\\Default.gdb", "out2", "POINT") cursor = 
arcpy.da.InsertCursor(hazaña, [" FORMA@XY "])
porienformación:
nueva_fila = [i[1]]
cursor.insertRow(nueva_fila) del
cursor
CÓDIGO 9.11
Agregue varios registros nuevos a la clase de entidad mediante InsertCursor.
importararcpy
importarentumecido
salida ="O:\\Libro\\Código\\9\\chp9Data\\Default.gdb\\out"
# matriz de entrada
matriz = numpy.array([(1,(471316.3835861763, 5000488.782036674)),
(2, (470402.49348005146, 5000049.216449278))], numpy.dtype([('campo 
de id', numpy.int32),('XY','<f8',2)]))
# crea la clase de entidad con el campo XY en la matriz 
arcpy.da.NumPyArrayToFeatureClass(matriz, salida, ['XY'])
CÓDIGO 9.12
Agregue varios registros nuevos a la clase de entidad mediante NumPyArrayToFeatureClass.
2. Ejecute también el Código 9.11 en la ventana de Python en ArcMap y 
compare el tiempo de ejecución con y sin el uso de numpy: arcpy. 
da.NumPyArrayToFeatureClass tiene un rendimiento mucho mejor.
9.5 Describir y enumerar objetos
9.5.1 Describir
Describa una función utilizada para leer propiedades de datos devolviendo un objeto de 
propiedad. Dependiendo de los argumentos pasados a los métodos, el objeto devuelto 
podría ser
• Tipos de datos (Shapefile, cobertura, conjuntos de datos de red, etc.)
• Tipo de geometría (punto, polígono, línea, etc.)
Programación ArcGIS 167
datos ="O:\\Libro\\Código\\9\\chp9Data\\bookSampleData.gdb\\railway" dscb = 
arcpy.Describe(datos)
sidscb.shapeType =="Polígono":
impresión"Soy polígono" elif
dscb.shapeType =="Polilínea":
impresión"Soy polilinea"
más:
impresión"No soy ni polilínea ni polígono"
CÓDIGO 9.13
Describir el ejemplo de función.
• Referencia espacial
• Alcance de las características
• Ruta y así sucesivamente
Práctica práctica 9.9: comprobar las propiedades de una clase de entidad
1. Ejecute el Código 9.13 en la ventana de Python de ArcMap y compruebe el resultado. 
¿Cuál es el tipo de forma de la clase de entidad de entrada?
2. Reemplace el parámetro Describir con otro archivo de forma que tenga 
diferentes tipos geométricos y vea cómo cambian los resultados al ejecutarlo 
nuevamente.
9.5.2 Lista
ArcPy proporciona funciones para enumerar todos los datos en un espacio de trabajo particular 
o enumerar la información correspondiente en los datos. ListFields son funciones de uso 
frecuente en ArcPy para enumerar todos los campos y las propiedades asociadas de una clase 
de entidad, un archivo de formas o una tabla. El código 9.14 es un ejemplo de la función 
ListFields. El código controla las operaciones que se realizarán solo en campos específicos: 
aquellos que están en tipo "Doble" o que incluyen el nombre "Bandera".
Las funciones que enumeran datos en un espacio de trabajo (por ejemplo, ListDatasets, 
ListFeatureClasses, ListFiles, ListRasters, ListTables) son muy útiles para ayudar al 
procesamiento por lotes. Por ejemplo, para realizar unanálisis de búfer para múltiples
importararcpy
# enumerar el campo de los datos "roads.shp" en la carpeta "ArcGISdata" listas de 
campos = arcpy.ListFields("O:\\Libro\\Código\\9\\chp9Data\\ bookSampleData.gdb\
\roads")
# observar cada campo en la lista de retorno por
campoenlistas de campos:
# imprimir la propiedad del campo, su nombre, escala y tipo impresión
campo.nombre,campo.escala,campo.tipo
CÓDIGO 9.14
Ejemplo de ListFields.
168Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
archivos de forma de polilínea en un espacio de trabajo, enumere todos los archivos de forma de 
polilínea con el método ListFeatureClasses, luego use un ciclo para recorrer cada archivo de forma, 
realizando un análisis de búfer usando el método Buffer_analysis.
Práctica práctica 9.10: Realizar análisis de zona de influencia para cada clase de entidad de polilínea 
en un espacio de trabajo
1. Copie los datos deCapítulo 9a su espacio de trabajo (p. ej., 'C:\\ 
sampledata'), o use cualquier archivo de forma que pueda tener y 
colóquelo en su espacio de trabajo.
2. Ejecute el Código 9.15 y verifique la consola de salida para responder¿Cuántas 
entidades de polilínea tiene en el espacio de trabajo??
3. Cambie el código e implemente un análisis de zona de influencia para cada clase de entidad 
de punto dentro de 10 millas.
La función Caminar en el módulo de acceso a datos puede ayudar a enumerar todos 
los datos en el área de trabajo o en su subárea de trabajo en jerarquía. Por ejemplo, hay 
un archivo de forma, un archivo .png, una geodatabase "Default.gdb" y una carpeta 
"temp" en un espacio de trabajo específico "sampledata". Esta función enumerará todos 
los archivos en "sampledata", las clases de entidad en "Default.gdb" y los archivos en 
"temp". La función Caminar es mucho más rápida que las funciones de lista tradicionales. 
El código 9.16 es un código de muestra de la función Caminar yFigura 9.8muestra sus 
resultados.
importararcpy
arcpy.env.espacio de trabajo ="O:\\Libro\\Código\\9\\chp9Data"
# obtener la lista de todas las clases de entidad de polilínea fcList = 
arcpy.ListFeatureClasses('*','Polilínea')
# imprime la lista de clases de características una a la vez por
f.c.enfcLista:
impresión'-----Realizar análisis de búfer para Polyline:', fc inputFCName 
= fc[0:-4]# deshacerse de '.shp' salidaFCNombre = entradaFCNombre +
'_buffer_10Metro'+'.shp' arcpy.Buffer_analysis(fc, outputFCName,'10 
metros')
CÓDIGO 9.15
Enumere todas las clases de entidad de polilínea y realice un análisis de zona de influencia en ellas.
espacio de trabajo ="O:\\Libro\\Código\\9\\chp9Data"
pordirpath, dirnames, nombres de archivosenarcp.da.Walk(espacio de trabajo):
impresión"------------"
impresióncamino de tierra;
impresiónnombres de dir;
impresiónnombres de archivo;
CÓDIGO 9.16
Enumere los archivos usando la función arcpy.da.Walk.
Programación ArcGIS 169
FIGURA 9.8
Resultados de la función arcpy.da.Walk.
9.6 Manipulación de objetos complejos
Además de los objetos simples de uso común, como cadenas (p. ej., ruta de datos) o 
números (p. ej., distancia de búfer), ArcPy ofrece clases para representar objetos 
complejos (p. ej., referencia espacial y campo de atributos).
Un objeto complejo típico es ValueTable. Muchas ArcTools incluyen este objeto para 
permitir la entrada con múltiples valores. Por ejemplo, la herramienta Unión utiliza 
ValueTable como un parámetro de entrada (Figura 9.9). En consecuencia, el script usa 
ValueTable para crear el parámetro de entrada correspondiente.
Otro objeto complejo popular, el campo, describe el campo en la tabla de atributos de una 
clase de entidad, un archivo de forma y una tabla (Código 9.17).
Mientras tanto, ArcPy también proporciona las clases para manipular objetos geométricos. La 
información de geometría generalmente se almacena en clases de entidades, capas de entidades o 
conjuntos de datos. Acceder a la geometría directamente no es común cuando se usa
FIGURA 9.9
Realice la unión con ArcMap y secuencias de comandos de python.
170Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
importararcpy
FC ="O:\\Libro\\Código\\9\\chp9Data\\libroSampleData.gdb\\carreteras" desc 
= arcpy.Describe(fc)
# obtener una lista de objetos de campo del objeto descrito campos = 
desc.campos
porcampoencampos:
# manipular el objeto de campo e imprimir la propiedad de cada campo impresión
nombre del campo
impresióncampo.aliasName
impresiónTipo de campo
sicampo.tipo =="Doble":
impresióncampo.escala
CÓDIGO 9.17
Acceder a las propiedades de un objeto de campo.
herramienta de geoprocesamiento para el análisis. A veces, sin embargo, solo se necesita 
información de ubicación, como la creación de puntos de muestra y una distancia de zona de 
influencia. El uso de objetos geométricos puede ahorrar tiempo en la creación de clases de 
entidades que realmente no persisten. ArcPy ofrece varios tipos de objetos geométricos:
• Punto: un solo punto, que es la unidad básica para todos los demás tipos de geometría, no se 
puede usar directamente como entrada en funciones de geoprocesamiento
• Geometría: un tipo general
• Multipunto: una entidad geométrica con múltiples puntos, que consta de 
Punto(s)
• PointGeometry: una entidad geométrica con un solo punto, que consta de 
Point
• Polilínea: una entidad de geometría de línea, que consta de Punto(s)
• Polígono: una entidad de geometría poligonal, que consta de Punto(s)
El código 9.18 presenta un análisis de zona de influencia con geometría como entrada.
Práctica práctica 9.11: Manipulación de objetos de referencia espacial
# crear un punto
punto = arcpy.Punto(471316.38358618, 5000448)
# crear la interfaz de geometría del punto pointgeom = 
arcpy.PointGeometry(punto)
# crear geometría de salida 
outgeom = arcpy.Geometría()
# calcular el búfer de la geometría del punto de creación 
arcpy.Buffer_analysis(pointgeom,outgeom,"5000 metros")
CÓDIGO 9.18
Ejemplo de uso de objetos geométricos para realizar análisis de zonas de influencia.
Programación ArcGIS 171
# usa el nombre del sistema de coordenadas
refEspacial = arcpy.SpatialReference(“Hawaii Albers Equal Area Conic”)
# o use un archivo de proyección (.prj)
sr = arcpy.SpatialReference(“C:\\coordsystems\\NAD 1983.prj”)
CÓDIGO 9.19
Crear objeto SpatialReference.
1. Cree el objeto usando una cadena como ruta a un archivo .prj o usando una cadena 
con el nombre de la referencia espacial (Código 9.19). SpatialReference es una clase 
de ArcPy.
2. Acceder a la propiedad del objeto de referencia espacial (Código 9.20).
3. Cree una clase de entidad en la geodatabase utilizando la referencia espacial creada 
(Código 9.21).
4. Cree una clase de entidad en la geodatabase utilizando la referencia espacial de 
otro conjunto de datos (Código 9.22). La función Describe se utilizará para 
obtener la información de referencia espacial de los datos.
impresiónref.espacial.nombre
impresiónref.espacial.XYTolerancia 
impresiónref.espacial.metrosPorUnidad 
impresiónrefespacial.GCS
CÓDIGO 9.20
Acceda a las propiedades de un objeto SpatialReference.
importararcpy
arcpy.env.espacio de trabajo = ("O:\\Libro\\Código\\9\\chp9Data")
# usa el nombre del sistema de coordenadas
refEspacial = arcpy.ReferenciaEspacial("Hawaii Albers Equal Area Conic")
# crea el FDS usando la referencia espacial creada desde arcpy. Método 
SpatialReference()
arcpy.CreateFeatureDataset_management
('O:\\Libro\\Código\\9\\chp9Data\\Default.gdb','resultados', referencia espacial)
CÓDIGO 9.21
Cree una clase de entidad con una referencia espacial.
importararcpy
arcpy.env.espacio de trabajo = ("O:\\Libro\\Código\\9\\chp9Data") 
desc = arcpy.Describe('escuela.shp') refEspacial = 
desc.ReferenciaEspacial
# crear el FDS usando el objeto SR(SpatialReference) del objeto descrito 
arcpy.CreateFeatureDataset_management('O:\\Libro\\Código\\9\\chp9Data\\ 
Default.gdb','resultados', referencia espacial)
CÓDIGO 9.22
Cree una clase de entidad con la referencia espacial de otros datos.
172Introduccióna la Programación GIS y Fundamentos con Python y ArcGIS®
FIGURA 9.10
Funciones en el módulo arcpy.mapping.
9.7 Automatización de la producción de mapas
La manipulación y el análisis de datos se automatizan a través de secuencias de comandos de 
Python y ArcPy, mientras que los procesos de mapeo involucran interacciones del usuario en la 
interfaz o mediante secuencias de comandos. ArcPy incluye un módulo de mapeo, cuyas 
funciones principales se pueden dividir en dos partes: exportar/imprimir mapas y administrar 
documentos y capas.Figura 9.10muestra las funciones en el módulo arcpy.mapping.
El código 9.23 representa el proceso de creación de un mapa para una clase de entidad 
utilizando el estilo de capa predefinido. El proceso incluye la apertura de archivos y capas, 
el cambio de estilo de capa y la revisión de la ubicación y el contenido de los elementos 
del mapa. El código se generaliza a partir del script de un ArcTool denominado “CCMap 
Generator” (Teampython 2013). El script está abierto y se puede descargar desde la 
comunidad de Análisis y geoprocesamiento a través del sitio web del centro de recursos 
de ArcGIS.http://resources.arcgis.com/en/communities/analysis/.
9.8 Creación de ArcTools a partir de secuencias de comandos
El marco de geoprocesamiento de ArcMap permite a los usuarios crear ArcTools personalizados 
a partir de los scripts de Python desarrollados. Al configurar los scripts como ArcTools, los 
usuarios pueden configurar los parámetros de entrada y ejecutar las funciones a través de una 
interfaz gráfica. Esto hace que la función definida por el usuario sea más
http://resources.arcgis.com/en/communities/analysis/
Programación ArcGIS 173
# 
ab
ri
r e
l d
oc
um
en
to
 d
e 
m
ap
a,
 q
ue
 e
s 
el
 a
rc
hi
vo
 *
.m
xd
 m
xd
 =
 
ar
cp
y.
m
ap
pi
ng
.M
ap
D
oc
um
en
t(
'C
CM
ap
D
oc
Te
m
pl
at
e.
m
xd
')
# 
en
um
er
ar
 e
l m
ar
co
 d
e 
da
to
s 
en
 e
l d
oc
um
en
to
 d
e 
m
ap
a 
- d
fs
 e
s 
el
 p
ri
m
er
 m
ar
co
 d
e 
da
to
s 
en
 e
l d
oc
um
en
to
 d
fs
 
= 
ar
cp
y.
m
ap
pi
ng
.L
is
tD
at
aF
ra
m
es
(m
xd
)[0
]
# 
cr
ea
r u
na
 c
ap
a 
a 
pa
rt
ir
 d
el
 c
on
ju
nt
o 
de
 d
at
os
 (p
. e
j.,
 u
na
 c
la
se
 d
e 
en
ti
da
d)
 a
 la
 q
ue
 s
e 
di
se
ña
rá
 y
 m
ap
ea
rá
 ly
r 
= 
ar
cp
y.
m
ap
pi
ng
.L
ay
er
(c
la
se
 d
e 
ca
ra
ct
er
ís
ti
ca
)
# 
ab
ri
r e
l a
rc
hi
vo
 d
e 
es
ti
lo
 d
e 
sí
m
bo
lo
 *
.ly
r
sí
m
bo
lo
ly
rs
 =
 a
rc
py
.m
ap
pi
ng
.L
ay
er
('C
CM
ap
Sy
m
bo
lo
gy
Te
m
pl
at
e.
ly
r'
)
# 
ob
te
ne
r 
la
 p
ri
m
er
a 
ca
pa
 c
on
 n
om
br
e 
qu
e 
co
nt
ie
ne
 la
 c
ad
en
a 
"p
ru
eb
a"
 d
en
tr
o 
de
l a
rc
hi
vo
 *
.ly
r 
sí
m
bo
lo
ly
r =
 a
rc
py
.m
ap
pi
ng
.L
is
tL
ay
er
s(
si
m
bó
lic
ol
yr
s,
 ('
*p
ru
eb
a*
'))
[0
]
# 
ca
m
bi
ar
 e
l e
st
ilo
 d
e 
sí
m
bo
lo
 d
e 
la
 c
la
se
 d
e 
en
ti
da
d 
ly
r e
n 
el
 m
ar
co
 d
e 
da
to
s 
df
s 
al
 e
st
ilo
 p
re
de
fin
id
o 
sy
m
bo
lly
r 
ar
cp
y.
m
ap
pi
ng
.U
pd
at
eL
ay
er
(d
fs
, l
yr
, s
ym
bo
lly
r,
Ve
rd
ad
er
o)
# 
ag
re
gu
e 
la
 c
la
se
 d
e 
en
ti
da
d 
co
n 
el
 e
st
ilo
 d
e 
sí
m
bo
lo
 a
ct
ua
liz
ad
o 
en
 e
l m
ar
co
 d
e 
da
to
s 
df
s 
ar
cp
y.
m
ap
pi
ng
.A
dd
La
ye
r(
df
s,
 ly
r)
# 
es
ta
bl
ec
er
 la
 u
bi
ca
ci
ón
 y
 e
l c
on
te
ni
do
 d
el
 p
ri
m
er
 e
le
m
en
to
 d
el
 m
ap
a 
(p
. e
j.,
 c
ua
dr
o 
de
 te
xt
o)
 d
en
tr
o 
de
l d
oc
um
en
to
 d
e 
m
ap
a 
m
xd
 e
lm
 =
 a
rc
py
.m
ap
pi
ng
.L
is
tL
ay
ou
tE
le
m
en
ts
(m
xd
,'T
EX
TO
_E
LE
M
EN
TO
','
pr
ue
ba
')[
0]
 e
lm
.e
le
m
en
tP
os
it
io
nY
 =
 -1
ol
m
o.
te
xt
o 
="
es
te
 e
s 
un
 e
le
m
en
to
 d
e 
m
ap
a 
de
 
pr
ue
ba
" 
el
m
.e
le
m
en
tP
os
it
io
nX
 =
 1
5
# 
ex
po
rt
ar
 e
l m
ap
a 
us
an
do
 re
so
lu
ci
ón
 e
n 
30
0 
dp
i 
ar
cp
y.
m
ap
pi
ng
.E
xp
or
tT
oP
D
F(
m
xd
, o
ut
_m
ap
, r
es
ol
uc
ió
n 
= 
30
0)
CÓ
D
IG
O
 9
.2
3
H
ac
er
 m
ap
as
 c
on
 e
st
ilo
 d
e 
sí
m
bo
lo
 p
re
de
fin
id
o 
au
to
m
át
ic
am
en
te
.
174 Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
4. Entrada básica
información, como
nombre, etiqueta, etc.
1. Crea un
caja de herramientas
2. Crea un
conjunto de herramientas
5. Especifique el guión
ruta de archivo
6. Especificar
parámetros
3. Agregar guión
FIGURA 9.11
Pasos generales para agregar scripts como herramientas.
fácil de usar y compartible, así como más accesible para las personas que no saben cómo 
ejecutar un script independiente. Además, la herramienta personalizada también se 
puede incorporar a ModelBuilder para integrarse con otras herramientas para 
implementar procesos de análisis más avanzados.
ArcPy proporciona varias funciones de obtención y configuración de parámetros para que las secuencias de 
comandos de Python personalizadas acepten la entrada del usuario. Las funciones más típicas son las 
siguientes:
• GetParameter: Obtiene el valor del parámetro especificado de la interfaz 
como un objeto (por ejemplo, SpatialReference)
• GetParameterAsText: obtiene el valor del parámetro especificado de la interfaz 
como una cadena
• GeoParameterValue: Devuelve el valor predeterminado del parámetro 
especificado para la herramienta
• SetParameter: establece una propiedad de parámetro específica utilizando un objeto
• SetParameterAsText: Establece una propiedad de parámetro específica usando una 
Cadena
Los pasos para agregar scripts como herramienta en ArcToolBox se muestran en 
Figura 9.11.
Práctica práctica 9.12: compilar ArcTools a partir de secuencias de comandos
1. Antes de crear ArcTool, copie el Código 9.24 y guárdelo como un archivo *.py.
importararcpy
"""
El siguiente es el script de la herramienta de zona de influencia, donde el 
primer argumento es la función de entrada, el segundo argumento es la 
función de salida y el tercer argumento es la distancia de zona de influencia
"""
inputFC = arcpy.GetParameterAsText(0) outputFC = 
arcpy.GetParameterAsText(1) bufferDist = 
arcpy.GetParameterAsText(3)
# realizar análisis de búfer arcpy.Buffer_analysis(FC de entrada, FC 
de salida, distancia de búfer)
CÓDIGO 9.24
Un script con funciones GetParameter para obtener información de la interfaz de ArcTool.
Programación ArcGIS 175
2. Abra 'Catálogo' en ArcMap, haga clic en 'Caja de herramientas', haga clic con el botón 
derecho en "Mis cajas de herramientas" y seleccione "Nuevo" para crear una nueva caja de 
herramientas (Figura 9.12). Cambie "ToolBox.tbx" a un nombre significativo, como 
"MyGeoProcessor.tbx".
3. Agregue el conjunto de herramientas haciendo clic con el botón derecho y seleccione "Nuevo" -> Conjunto de herramientas (
Figura 9.13). Cambie el nombre de "conjunto de herramientas", como "Búfer".
4. Luego, haga clic derecho en "Búfer" y seleccione "Agregar" -> "Script" (Figura 9.14).
Especifique (1) información básica para la herramienta, como nombre, etiqueta, 
descripciones, etc., (2) la ruta del archivo de script y (3) parámetros de entrada y 
salida, incluidos tipos y nombres, etc. Haga clic en "Finalizar" para complete la 
creación de su ArcTool personalizado (Figura 9.15).
5. Ejecute la herramienta recién creada y vea qué sucede.
FIGURA 9.12
Agregue ArcToolBox.
FIGURA 9.13
Agregue ArcToolset.
176Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
FIGURA 9.14
Agregue la secuencia de comandos de Python como ArcTool.
FIGURA 9.15
Configure la propiedad de la herramienta, la ruta del script y el parámetro de entrada.
9.9 Manejo de errores y mensajes
Los mensajes informativos ayudan a los usuarios a realizar un seguimiento del estado de ejecución del 
script. La interfaz de ArcTools normalmente devuelve tres tipos de mensajes con los siguientes 
símbolos:
Mensajes informativos durante la ejecución delscript
Mensaje de error cuando surge un problema
Mensajes de advertencia
• El método arcpy.GetMessage() puede devolver los mensajes de geoprocesamiento. 
De forma predeterminada, sin ningún argumento, obtendrá todo tipo de 
mensajes. Usando 0, 1 o 2 como argumento, obtendrá la cadena del error de 
información o los mensajes de ID de advertencia por separado:
Programación ArcGIS 177
FIGURA 9.16
Resultados de ejecutar la herramienta de script con mensajes agregados.
• GetMessages(): Todos los mensajes
• GetMessages(0): Nivel de gravedad 0 - Solo mensajes informativos
• GetMessages(1): nivel de gravedad 1: solo mensajes de advertencia
• GetMessages(2): nivel de gravedad 2: solo mensajes de error
El método arcpy.AddMessage() se puede utilizar para crear mensajes de 
geoprocesamiento (nivel de gravedad = 0) para sus secuencias de comandos; el método 
arcpy.AddWarning() se puede usar para crear mensajes de advertencia (nivel de gravedad 
= 1) para sus scripts; y el método arcpy.AddError() se puede usar para crear mensajes de 
error (nivel de gravedad = 2) para sus scripts. Como se muestra enFigura 9.16, los 
mensajes entre “Hora de inicio: Mar…” y “Tuvo éxito en…” son los que se agregan usando 
el método AddMessage().
Práctica práctica 9.13: Agregar mensaje en la herramienta de secuencia de comandos personalizada
1. Cree un script de Python con Code 9.25 y luego agréguelo como ArcTool.
2. Use la herramienta para probar el análisis del búfer y verifique la salida.
9.10 Documentos externos y recursos de video
El documento de ayuda de escritorio de ArcGIS y el documento de ayuda en línea de Esri (Figura 9.1) 
debe ser el primer lugar para verificar la sintaxis y los códigos de muestra de las clases, funciones y 
módulos de ArcPy. Al buscar en línea, también podemos encontrar buenos ejemplos de código para 
muchas funciones de geoprocesamiento.
Traducido del inglés al español - www.onlinedoctranslator.com
https://www.onlinedoctranslator.com/es/?utm_source=onlinedoctranslator&utm_medium=pdf&utm_campaign=attribution
178Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
importararcpy
"""
El siguiente es el script de la herramienta de zona de influencia, donde el primer 
argumento es la función de entrada, el segundo argumento es la función de salida y 
el tercer argumento es la distancia de zona de influencia
"""
inputFC = arcpy.GetParameterAsText(0) arcpy.AddMessage('-------
Característica de entrada: '+ inputFC) outputFC = 
arcpy.GetParameterAsText(1)
arcpy.AddMessage('-------Característica de salida: '+ salidaFC) 
bufferDist = arcpy.GetParameterAsText(2)
arcpy.AddMessage('-------Distancia de búfer: '+ distanciabúfer)
# realizar análisis de búfer arcpy.Buffer_analysis(inputFC, 
outputFC, bufferDist) arcpy.AddMessage("Terminado con éxito")
CÓDIGO 9.25
Ejemplos de AddMessage.
Los siguientes recursos también podrían proporcionar la información desde otra 
perspectiva:
• Busque “Uso de Python en ArcGIS Desktop” en YouTube.
• Esri ofrece cursos gratuitos de Campus Virtual utilizando Python en 
diferentes versiones de ArcGIS Desktop, que se pueden encontrar 
buscando "Python" en el siguiente enlacehttp://training.esri.com/gateway/
index. cfm?fa=catalog.gateway&tab=0.
• ArcCafe: un blog, desarrollado y mantenido por los equipos de geoprocesamiento y análisis 
de Esri, que presenta secuencias de comandos de Python utilizadas para resolver algunas 
tareas comunes de geoprocesamiento.
• Esri suele proporcionar secciones para presentar el uso de Python y 
ArcPy en su conferencia anual de usuarios. Estos videos se pueden 
encontrar buscando "python" o "ArcPy" en el enlacehttp://
video.esri.com/channel/2/events/series.
9.11 Implementación de cálculos de relaciones 
espaciales mediante ArcGIS
Práctica práctica 9.14: Calcule el centroide, el perímetro y el área de polígonos 
usando arcpy.
Busque los datos "states.shp" y ejecute el Código 9.26 en la ventana ArcMap 
Python. Tenga en cuenta que se deben agregar nuevos campos en la tabla de 
atributos antes del cálculo para registrar los resultados (Figura 9.17).
http://training.esri.com/gateway/index.cfm?fa=catalog.gateway&tab=0
http://training.esri.com/gateway/index.cfm?fa=catalog.gateway&tab=0
http://video.esri.com/channel/2/events/series
http://video.esri.com/channel/2/events/series
Programación ArcGIS 179
# 
es
ta
bl
ec
er
 e
l e
sp
ac
io
 d
e 
tr
ab
aj
o
ar
cp
y.
en
v.
es
pa
ci
o 
de
 tr
ab
aj
o 
="
O
:\\
Li
br
o\
\C
ód
ig
o\
\9
\\
ch
p9
D
at
a"
""
"
Ag
re
gu
e 
lo
s 
ca
m
po
s 
"c
en
tX
",
 "
ce
nt
Y"
, "
po
ly
Ar
ea
" 
y 
"p
ol
yP
er
i"
 p
ar
a 
re
gi
st
ra
r l
os
 r
es
ul
ta
do
s 
ca
lc
ul
ad
os
. "
D
O
BL
E"
 e
s 
el
 ti
po
 d
e 
va
lo
r,
 2
0 
es
 la
 p
re
ci
si
ón
 d
el
 ti
po
 d
ob
le
 y
 1
0 
es
 la
 e
sc
al
a.
""
"
ar
cp
y.
Ad
dF
ie
ld
_m
an
ag
em
en
t(
"e
st
ad
os
.s
hp
",
"c
en
tX
",
"D
O
BL
E"
,2
0,
10
) 
ar
cp
y.
Ad
dF
ie
ld
_m
an
ag
em
en
t(
"e
st
ad
os
.s
hp
",
"c
en
tY
",
"D
O
BL
E"
,2
0,
10
) 
ar
cp
y.
Ad
dF
ie
ld
_m
an
ag
em
en
t(
"e
st
ad
os
.s
hp
",
"á
re
a 
po
li"
,"
D
O
BL
E"
,2
0,
6)
 
ar
cp
y.
Ad
dF
ie
ld
_m
an
ag
em
en
t(
"e
st
ad
os
.s
hp
",
"p
ol
iP
er
i"
,"
D
O
BL
E"
,2
0,
6)
""
"
Ca
lc
ul
e 
el
 c
en
tr
oi
de
, e
l á
re
a 
y 
el
 p
er
ím
et
ro
 c
on
 la
 h
er
ra
m
ie
nt
a 
Ca
lc
ul
at
eF
ie
ld
_m
an
ag
em
en
t.
 "
PY
TH
O
N
_9
.3
"
si
gn
ifi
ca
 q
ue
 la
 e
xp
re
si
ón
 d
e 
cá
lc
ul
o 
"!
SH
AP
E.
CE
N
TR
O
ID
.X
" 
es
tá
 e
n 
la
 s
in
ta
xi
s 
de
 P
yt
ho
n 
9.
3.
""
"
ar
cp
y.
Ca
lc
ul
at
eF
ie
ld
_m
an
ag
em
en
t(
"e
st
ad
os
.s
hp
",
"c
en
tX
",
"!
FO
RM
A.
CE
N
TR
O
ID
E.
X!
",
"P
YT
H
O
N
_9
.3
")
 
ar
cp
y.
Ca
lc
ul
at
eF
ie
ld
_m
an
ag
em
en
t(
"e
st
ad
os
.s
hp
",
"c
en
tY
",
"!
FO
RM
A.
CE
N
TR
O
ID
E.
Y!
",
"P
YT
H
O
N
_9
.3
")
 
ar
cp
y.
Ca
lc
ul
at
eF
ie
ld
_m
an
ag
em
en
t(
"e
st
ad
os
.s
hp
",
"á
re
a 
po
li"
,"
!Á
RE
A.
D
E.
FO
RM
A!
",
"P
YT
H
O
N
_9
.3
")
 
ar
cp
y.
Ca
lc
ul
at
eF
ie
ld
_m
an
ag
em
en
t(
"e
st
ad
os
.s
hp
",
"p
ol
iP
er
i"
,"
!F
O
RM
A.
LO
N
G
IT
U
D
!"
,"
PY
TH
O
N
_9
.3
")
CÓ
D
IG
O
 9
.2
6
Ca
lc
ul
a 
el
 c
en
tr
oi
de
, e
l p
er
ím
et
ro
 y
 e
l á
re
a 
de
 lo
s 
po
líg
on
os
 u
sa
nd
o 
ar
cp
y.
180Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
FIGURA 9.17
Resultado del Código 9.26.
Práctica práctica 9.15: Selección de objetos según la relación espacial (línea de 
intersección y punto en el polígono) usando arcpy.
1. Busque los dos archivos de forma "interestatales" y "ferrocarril" en el disco y 
seleccione las carreteras interestatales que se cruzan con los ferrocarriles. La 
selección se llevará a cabo en las características "interestatales" en función de su 
relación espacial con la capa "ferroviaria". Ejecute el Código 9.27 en la ventana de 
Python de ArcMap yFigura 9.18muestra el resultado.
2. Seleccione las estaciones de tren (en “amtk_sta.shp”) en Virginia. Ejecutar código
9.28 en la ventana de Python de ArcMap y vea el resultado (Figura 9.19).
9.12 Resumen
Este capítulo presenta la programación dentro de ArcGIS utilizando secuencias de comandos de 
Python y el paquete ArcPy. Este capítulo introduce
• Marco de geoprocesamiento de Esri y ArcPy.
• La capacidad y sintaxis de las funciones, clases y módulos de ArcPy.
• ¿Cómo crear flujos de trabajo de análisis simples o complejos con ArcPy?
• ¿Cómo manipular datos vectoriales u objetos a través de ArcPy?
Programación ArcGIS 181
ar
cp
y.
en
v.
es
pa
ci
o 
de
 tr
ab
aj
o 
="
O
:\\
Li
br
o\
\C
ód
ig
o\
\9
\\
ch
p9
D
at
a"
""
"
"M
ak
eF
ea
tu
re
La
ye
r_
m
an
ag
em
en
t"
 p
ue
de
 c
re
ar
 u
n 
ob
je
to
 d
e 
ca
pa
 d
e 
ca
ra
ct
er
ís
ti
ca
s 
a 
pa
rt
ir
 d
e 
la
 ru
ta
 d
e 
lo
s 
da
to
s 
de
 e
nt
ra
da
, q
uee
s 
un
a 
ca
de
na
. L
a 
se
le
cc
ió
n 
se
 re
al
iz
ar
á 
en
 la
 c
ap
a 
de
 e
nt
id
ad
es
.
""
"
ar
cp
y.
M
ak
eF
ea
tu
re
La
ye
r_
m
an
ag
em
en
t(
"i
nt
er
es
ta
ta
le
s.
sh
p"
,"
ca
rr
et
er
a"
) 
ar
cp
y.
M
ak
eF
ea
tu
re
La
ye
r_
m
an
ag
em
en
t(
"f
er
ro
ca
rr
il.
sh
p"
,"
fe
rr
oc
ar
ri
l"
)
# 
se
le
cc
io
ne
 la
s 
ca
ra
ct
er
ís
ti
ca
s 
en
 la
 c
ap
a 
in
te
re
st
at
al
, q
ue
 in
te
rs
ec
an
 c
on
 la
s 
ca
ra
ct
er
ís
ti
ca
s 
en
 la
 c
ap
a 
fe
rr
ov
ia
ri
a 
ar
cp
y.
Se
le
ct
La
ye
rB
yL
oc
at
io
n_
m
an
ag
em
en
t(
"c
ar
re
te
ra
",
"I
N
TE
RS
EC
AR
SE
",
"f
er
ro
ca
rr
il"
,s
el
ec
ci
on
_t
ip
o=
"N
U
EV
A_
SE
LE
CC
IÓ
N
")
CÓ
D
IG
O
 9
.2
7
Ca
lc
ul
ar
 in
te
rs
ec
ci
ón
 d
e 
lín
ea
s.
182Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
Ferrocarril
camino
FIGURA 9.18
Resultado de la intersección de líneas.
• ¿Cómo crear ArcTools a partir de los scripts de python?
• ¿Cómo implementar cálculos espaciales usando ArcGIS?
9.13 Asignación
• Lea la sección de ArcPy en la ayuda de escritorio de ArcGIS o la versión en línea.
• Buscar datos de una carretera o descargar datos del paquete del material del 
curso correspondiente.
• Seleccione carreteras a partir de datos de carreteras.
• Generar un buffer con 300 metros de radio para la carretera.
• Salida de la zona de influencia como una zona de contaminación del transporte.
• Agregar un campo con el nombre de “edificios” con tipo Long en los datos de la zona de 
amortiguamiento.
• Cuente el número de edificios dentro de cada zona de amortiguamiento y guárdelo en 
el nuevo campo.
• Escriba un informe para explicar cómo realizó el análisis y la 
programación.
• Comparar las diferencias de implementar cálculos espaciales utilizando 
ArcGIS y Python puro.
Programación ArcGIS 183
ar
cp
y.
en
v.
es
pa
ci
o 
de
 tr
ab
aj
o 
="
O
:\\
Li
br
o\
\C
ód
ig
o\
\9
\\
ch
p9
D
at
a"
ar
cp
y.
M
ak
eF
ea
tu
re
La
ye
r_
m
an
ag
em
en
t(
"e
st
ad
os
.s
hp
",
"m
aj
es
tu
os
o"
) 
ar
cp
y.
M
ak
eF
ea
tu
re
La
ye
r_
m
an
ag
em
en
t(
"a
m
tk
_s
ta
.s
hp
",
"e
st
ac
ió
n"
)
# 
se
le
cc
io
ne
 V
ir
gi
ni
a 
de
 la
 c
ap
a 
de
 e
st
ad
o 
pr
im
er
o
ar
cp
y.
Se
le
ct
La
ye
rB
yA
tt
ri
bu
te
_m
an
ag
em
en
t(
"m
aj
es
tu
os
o"
,"
N
U
EV
A_
SE
LE
CC
IÓ
N
",
'"
N
O
M
BR
E_
ES
TA
D
O
"=
\'V
ir
gi
ni
a\
'')
# 
lu
eg
o 
se
le
cc
io
ne
 la
s 
es
ta
ci
on
es
 d
e 
tr
en
 (p
un
to
s)
 c
om
pl
et
am
en
te
 d
en
tr
o 
de
 V
ir
gi
ni
a 
(p
ol
íg
on
o)
 a
rc
py
.S
el
ec
tL
ay
er
By
Lo
ca
ti
on
_m
an
ag
em
en
t(
"e
st
ac
ió
n"
,"
CO
M
PL
ET
AM
EN
TE
_D
EN
TR
O
",
"m
aj
es
tu
os
o"
,s
el
ec
ci
on
_t
ip
o=
"N
U
EV
A_
SE
LE
CC
IÓ
N
")
CÓ
D
IG
O
 9
.2
8
Se
le
cc
io
ne
 to
da
s 
la
s 
es
ta
ci
on
es
 d
e 
tr
en
 e
n 
Vi
rg
in
ia
.
184Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
FIGURA 9.19
Punto en el resultado del polígono.
NOTA :Todos los códigos se pueden ejecutar correctamente en ArcGIS para versiones 
de escritorio 10.2.2 a 10.3. Puede haber problemas al ejecutar el código en una 
versión más reciente de ArcGIS.
10
Algoritmo de datos ráster
Un ráster es un modelo de datos que representa fenómenos geográficos por píxeles y se 
puede crear utilizando una variedad de dispositivos y técnicas, como cámaras digitales, 
escáneres, máquinas de medición de coordenadas, perfiles sismográficos y radares 
aerotransportados. Este capítulo presenta el concepto de ráster, las principales 
categorías de datos ráster y cómo estos datos se muestran y almacenan en una 
computadora. Los métodos básicos de análisis y conversión de datos ráster se exploran 
mediante tres experiencias prácticas de ArcGIS.
10.1 Datos ráster
Con el modelo de datos ráster, los fenómenos geográficos se representan como superficies, regiones 
o segmentos. Por lo tanto, este modelo de datos se basa en la vista de campo del mundo real 
(Goodchild 1992). La vista de campo se usa ampliamente para la organización de la información en 
sistemas de análisis de imágenes para aplicaciones orientadas a los recursos y al medio ambiente. Los 
datos ráster tienen dos categorías principales: (1) datos discretos, también llamados datos temáticos o 
categóricos, tal como se emplean en mapas de suelo o uso de la tierra; y (2) datos continuos, también 
llamados datos no discretos o datos de superficie, como se emplean en los modelos de elevación 
digital (DEM), mapas de lluvia o mapas de concentración de contaminantes.
Un conjunto de datos ráster representa características geográficas en una 
cuadrícula 2D de celdas conocidas como elementos de imagen (píxeles) (Figura 
10.1). La ubicación de cada celda se define por sus números de fila y columna. 
El tamaño de celda dicta la resolución espacial de los datos. Las ubicaciones de 
las características geográficas solo están representadas por los píxeles más 
cercanos. El valor almacenado para cada celda indica el tipo de objeto, 
fenómeno o condición que se encuentra en esa ubicación en particular, y 
normalmente se da como el valor promedio para toda el área del terreno 
cubierta por el píxel. Los diferentes tipos de valores se pueden codificar como 
números enteros, números reales o letras del alfabeto. Si los números de 
código son enteros, es más probable que hagan referencia a atributos 
nominales (por ejemplo, nombres en una tabla asociada). Los diferentes 
atributos en la misma ubicación de celda se almacenan cada uno como temas o 
capas independientes. Por ejemplo, datos raster pertenecientes al tipo de 
suelo, cubierta forestal,
185
186Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
Columna #
Fila #
píxel
Valor de celda 1
1
2
1 Diferente
capas
Código Cobertura terrestre
1 Bosque
2
3
Agua corporal
Cultivo Tabla de búsqueda
FIGURA 10.1
Estructura de datos ráster.
10.2 Almacenamiento y compresión de ráster
Los datos ráster normalmente se almacenan fila por fila desde la parte superior izquierda, 
como se ilustra en Figura 10.2. Esta es la forma más sencilla de almacenar y buscar datos 
ráster. Sin embargo, un ráster, cuando se almacena en estado bruto sin compresión, se puede
(a) (b)
3
3
3
3
3
3
3
3
1
2
1
2
1
2
1
2
3
3
1
1
1
1
3
3
1
1
1
1
3
3
1
1
1
1
3
3
1
1
1
1
2
2
1
1
1
1
1
2
1
1
1
1
1
2
1
1
1
2
1
2
1
1
1
2
FIGURA 10.2
Imagen de la trama. (a) Cada píxel de la trama está codificado por color y (b) el valor de cada píxel y el orden de almacenamiento 
de píxeles.
Algoritmo de datos ráster 187
extremadamente ineficiente en términos de espacio de almacenamiento de la computadora. 
TomandoFigura 10.2a, para extraer el área amarilla, la computadora necesita extraer el área un 
píxel a la vez, siguiendo el orden de almacenamientoFigura 10.2b. Después de obtener las 
cuatro celdas amarillas en la primera fila, la computadora debe omitir las celdas restantes en la 
primera fila antes de llegar a las celdas objetivo en la segunda fila, lo que resulta en un tiempo 
de búsqueda adicional.
Hoy en día, los datos están cada vez más disponibles y tienen mayor resolución. Las 
capacidades informáticas también han mejorado. Por lo tanto, se necesitan mejores métodos 
de almacenamiento y compresión de datos. La compresión de trama reduce la cantidad de 
espacio en disco consumido por el archivo de datos, al tiempo que conserva la máxima calidad 
de los datos. Existen diferentes métodos para la compresión de datos ráster, incluida la 
codificación de longitud de ejecución, la codificación de árbol cuádruple y otros.
Para datasets ráster multicapa, la práctica normal es almacenar las capas por separado. También es 
posible almacenar toda la información de cada píxel en conjunto; sin embargo, esto requiere que se 
asigne espacio adicional inicialmentedentro de la ubicación de almacenamiento de cada píxel para las 
capas, que se pueden crear más tarde durante el análisis.
10.2.1 Codificación de longitud de ejecución
La codificación de longitud de ejecución (Pountain 1987) es una técnica de compresión 
ampliamente utilizada para datos raster. Los elementos de datos primarios son pares de 
valores o tuplas, que consisten en un valor de píxel y un recuento de repeticiones, que 
especifica el número de píxeles en la ejecución. Los datos se construyen leyendo cada fila en 
sucesión a través del ráster y creando una nueva tupla cada vez que cambia el valor del píxel o 
cuando se alcanza el final de la fila.Figura 10.3demuestra el proceso de codificación de longitud 
de ejecución. Supongamos que tenemos datos raster almacenados en un 4 por
84 84 90 90
88 93 93 93
93 93 93 93
87 87 87 94
Formación 84 84 90 90 88 93 93 93 93 93 93 93 87 87 87 94
Codificación de longitud de ejecución
Longitud de ejecución 84 2 90 2 88 1 93 7 87 3 94 1
e valor de píxel idéntico tiempo de repetición
FIGURA 10.3
Ejemplo de codificación de longitud de ejecución.
188Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
4 matriz. La computadora lo escaneará comenzando desde la parte superior izquierda y se moverá 
hacia la derecha, bajando, mientras mantiene los datos en una matriz. Luego, Run Length Coding 
procesará la cadena de píxeles en una cadena de pares (el valor de píxel idéntico y los tiempos de 
repetición de píxeles). La longitud de la cadena inicial es 16 y después de la codificación de longitud de 
ejecución, la longitud es 12. Por lo tanto, la codificación de longitud de ejecución reduce efectivamente 
el volumen de almacenamiento.
La codificación de longitud de ejecución tiene sus limitaciones. Por ejemplo, Run Length no 
guardará almacenamiento en los casos en que los valores de píxeles no se repitan con frecuencia. En 
algunos casos, como los datos DEM en un área montañosa, los píxeles vecinos siempre tienen valores 
diferentes y la codificación de longitud de ejecución puede aumentar la longitud del almacenamiento 
inicial. Sin embargo, la codificación de longitud de ejecución es muy exitosa cuando se trata de 
imágenes en blanco y negro, como un fax. En este caso, es relativamente eficiente porque la mayoría 
de los documentos enviados por fax son predominantemente espacios en blanco, con solo 
interrupciones ocasionales de negro.
10.2.2 Árbol cuádruple
La técnica de compresión de árbol cuádruple es el método de compresión más común 
aplicado a datos raster (Gosselin y Georgiadis 2000). La codificación de árbol cuádruple 
almacena la información subdividiendo una región cuadrada en cuadrantes, cada uno de 
los cuales se puede dividir en cuadrados hasta que el contenido de las celdas tenga los 
mismos valores.Figura 10.4demuestra el proceso de compresión del árbol cuádruple. 
Supongamos que los datos ráster se almacenan en una matriz de 4 por 4 (Figura 10.4a). 
Primero, el árbol cuádruple divide los datos ráster en cuatro matrices cuadradas (Figura 
10.4b). En la secuencia 0,1,2,3 (Figura 10.4b), las cuatro matrices se comprueban si el 
contenido de sus celdas tiene o no el mismo valor. Este proceso puede repetirse 
recursivamentenorteveces, hasta que las celdas dentro de un cuadrante tengan todas el 
mismo valor. Para el cuadrante 0, la secuencia es la misma con los niveles anteriores de 
procesos, y la división da como resultado otros cuatro
(a) (b) (C) (d)
89 68 85 85
89 75 85 85
89 89 85 85
89 77 85 85
11 13
10 12
01 03
00 02
89 68
89 75
89 89
89 77
1 3 3 85
0 2 2 85
Raíz
0 1 2
85
3
85
00 01 02 03 10 11 12 13
89 89 77 89 89 89 75 68
FIGURA 10.4
Proceso de árbol cuádruple. (a) valor de píxel del evaluador, (b) orden de búsqueda de los cuatro cuadrantes, 
(c) continuar dividiendo al encontrar valores no iguales dentro de cada cuadrante de (b), y (d) división final.
Algoritmo de datos ráster 189
cuadrados, 00,01,02,03. El mismo proceso ocurre en el cuadrante 1. Para los cuadrantes 2 
y 3, todas las celdas tienen el mismo valor, por lo que no es necesario dividir. Por lo tanto, 
la salida final del árbol cuádruple es comoFigura 10.4d. Llamamos a este arreglo un árbol, 
cuyos nodos corresponden a los cuadrados. Los nodos están conectados si uno de los 
cuadrados correspondientes contiene inmediatamente al otro. El nodo raíz del árbol 
corresponde a la imagen completa, los nodos de hoja corresponden a los píxeles 
individuales.
El árbol cuádruple funciona para imágenes con patrones de valores idénticos. Por cada división 
cuádruple utilizada, se necesitan cuatro elementos de almacenamiento más. Los árboles cuádruples 
son de gran interés para indexar datos espaciales, por lo que es más probable que las celdas que son 
adyacentes en el espacio tengan direcciones de índice espacial similares que en el esquema de 
ordenación de columnas o filas. Por lo tanto, los datos que están muy juntos también lo están en el 
sistema de almacenamiento. Esta función hace que los datos comprimidos de árbol cuádruple sean 
mucho más fáciles y rápidos de manipular y acceder.
10.3 Formatos de datos ráster*
El formato ráster define cómo se organizan los datos y el tipo o nivel de compresión 
correspondiente. Muchos formatos de datos aplican compresión a los datos ráster para 
que todos los valores de píxeles no se almacenen directamente. La compresión puede 
reducir el tamaño de los datos al 30 % o incluso al 3 % de su tamaño sin procesar, según 
la calidad requerida y el método utilizado. La compresión puede ser sin pérdida o con 
pérdida. Con la compresión sin pérdidas, la imagen original se puede recuperar 
exactamente. Con la compresión con pérdida, las representaciones de píxeles no se 
pueden recuperar exactamente. Para implementar la compresión, el archivo ráster debe 
incluir información principal sobre el método y los parámetros de compresión. Algunos 
formatos ráster, como TIFF, GeoTIFF, IMG y NetCDF, contienen información geográfica, 
mientras que otros, como BMP, SVG y JPEG, no.
10.3.1 TIFF
TIFF (Formato de archivo de imagen etiquetado) es un formato de imagen reconocido por 
muchos sistemas informáticos. El formato de archivo de imágenes TIFF se utiliza para 
almacenar y transferir imágenes satelitales digitales, fotografías aéreas escaneadas, modelos 
de elevación, mapas escaneados o los resultados de muchos tipos de análisis geográficos. TIFF 
admite varias opciones de compresión y mosaico para aumentar la eficiencia de la 
transferencia y utilización de imágenes. Los datos dentro de los archivos TIFF se clasifican como 
comprimidos sin pérdida o comprimidos con pérdida.
* "Formatos de archivo SIG". Wikipedia: Ráster. Fundación Wikipedia, Inc.http://en.wikipedia.org/ wiki/
GIS_file_formats#Raster.
http://en.wikipedia.org/wiki/GIS_file_formats#Raster
http://en.wikipedia.org/wiki/GIS_file_formats#Raster
190Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
10.3.2 GeoTIFF
GeoTIFF son archivos TIFF que tienen datos geográficos (o cartográficos) incrustados 
como etiquetas dentro del archivo TIFF (Ritter y Ruth 1997). A continuación, los datos 
geográficos se pueden usar para colocar la imagen en la ubicación y geometría correctas 
en la pantalla de una pantalla de información geográfica. La posible información adicional 
incluye proyección de mapas, sistemas de coordenadas, elipsoides, datums y todo lo 
demás necesario para establecer la referencia espacial exacta para el archivo. Cualquier 
sistema de información geográfica (GIS), diseño asistido por computadora (CAD), 
procesamiento de imágenes, mapeo de escritorio u otro tipo de sistemas que utilicen 
imágenes geográficas pueden leer archivos GeoTIFF creados en cualquier sistema que 
siga la especificación GeoTIFF.
10.3.3 IMG*
Los archivos IMG se producen utilizando el software de procesamiento de imágenes IMAGINE 
creado por ERDAS. Los archivos IMG pueden almacenar datos continuos y discretos, de banda 
única y multibanda. Estosarchivos utilizan la estructura de formato de archivo jerárquico (HFA) 
de ERDAS IMAGINE. Un archivo IMG almacena información básica, incluida la información del 
archivo, los puntos de control terrestre, la información del sensor y las capas ráster. Cada capa 
ráster del archivo de imagen contiene información además de sus valores de datos. La 
información contenida en la capa ráster incluye información de capa, compresión, atributos y 
estadísticas. Un archivo IMG se puede comprimir cuando se importa a ERDAS IMAGINE, que 
normalmente utiliza el método de compresión de longitud de ejecución (descrito en la Sección 
10.2.1).
10.3.4 NetCDF
NetCDF (Network Common Data Form) es un conjunto de bibliotecas de software y 
formatos de datos autodescriptivos e independientes de la máquina que admiten la 
creación, el acceso y el intercambio de datos científicos orientados a matrices (Rew y 
Davis 1990). Se usa comúnmente en aplicaciones de climatología, meteorología y 
oceanografía (p. ej., pronóstico del tiempo, cambio climático) y aplicaciones GIS. Es un 
formato de entrada/salida para muchas aplicaciones GIS, así como para el intercambio de 
datos científicos en general. NetCDF se almacena en binario en formato abierto con 
compresión opcional.
10.3.5 BMP
BMP (mapa de bits de Windows) admite archivos gráficos dentro del sistema operativo 
Microsoft Windows. Por lo general, los datos de los archivos BMP no están comprimidos, lo que 
puede resultar en archivos demasiado grandes. Las principales ventajas de este formato son su 
sencillez y amplia aceptación.
* "Archivos .img de ERDAS IMAGINE". Universidad de Purdue. ftp://ftp.ecn.purdue.edu/jshan/86/help/ 
html/appendices/erdas_imagine__img_files.htm.
Algoritmo de datos ráster 191
10.3.6 SVG
Los gráficos vectoriales escalables (SVG) son archivos basados en XML formateados para 
gráficos vectoriales 2D. Utiliza un algoritmo de compresión de datos sin pérdida y, por lo 
general, reduce los datos al 20 %–50 % del tamaño original.
10.3.7 JPEG
Los archivos JPEG (Grupo Conjunto de Expertos Fotográficos) almacenan datos en un formato 
con pérdida de compresión (en los casos más importantes). Casi todas las cámaras digitales 
pueden guardar imágenes en formato JPEG, que admite ocho bits por color para un total de 24 
bits, lo que generalmente produce archivos pequeños. Cuando la compresión utilizada no es 
alta, la calidad de la imagen no se ve tan afectada, sin embargo, los archivos JPEG pueden sufrir 
degradaciones notables cuando se editan y guardan de forma recurrente. Para las fotos 
digitales que necesitan edición repetida o cuando los pequeños artefactos son inaceptables, se 
deben usar formatos sin pérdida distintos de JPEG. Este formato también se utiliza como 
algoritmo de compresión para muchos archivos PDF que incluyen imágenes.
10.3.8 GIF
GIF (Graphic Interchange Format) es el primer formato de imagen utilizado en la 
World Wide Web. Este formato está limitado a una paleta de 8 bits o 256 colores. 
Utiliza compresión Lempel-Ziv-Welch (LZW) sin pérdidas, que se basa en tecnología 
de compresión patentada.
10.3.9 PNG
PNG (Portable Network Graphic) es un sucesor de código abierto de GIF. A diferencia de 
los 256 colores admitidos por GIF, este formato admite color verdadero (16 millones de 
colores). PNG supera a otros formatos cuando grandes áreas de colores uniformes 
forman una imagen. El formato lossless PNG es más apropiado para la edición de figuras 
y los formatos lossy, como JPEG, son mejores para la distribución final de fotos, porque 
los archivos JPEG son más pequeños que los archivos PNG.
10.4 Representación de color y reproducción de trama
10.4.1 Representación de colores
Los datos ráster se pueden mostrar como una imagen en escala de grises o en color (RGB) 
transformando los valores de los píxeles. Amapa de coloreses una tabla de búsqueda utilizada 
para traducir el valor de cada píxel en un color. Un valor de píxel dado se usa como índice en la 
tabla, por ejemplo, un valor de píxel de nueve seleccionará el noveno elemento, o celda de color
(Figura 10.5).
Una imagen en escala de grises se puede mostrar en pantallas monocromáticas 
transformando los píxeles en la intensidad del nivel de gris, que contiene un solo valor.
192Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
mapa de colores
19
18
17
dieciséis
I5
14
13
12
11
10
9 200
8
7
6
5
4
3
2
1
0
valor de píxel
1
0
0
1
0 Celda de color
0
0
0
FIGURA 10.5
Asignación de valor de píxel a escala de grises.
en el mapa de colores. La escala de grises se puede simular en una pantalla a color igualando 
los valores de rojo, verde y azul en una celda de color dada, configurando el brillo de los píxeles 
grises en la pantalla.
La mayoría de las pantallas a color se basan en el modelo de color RGB. Cada píxel de 
la pantalla se compone de tres fósforos: uno rojo, uno verde y uno azul, cada uno de los 
cuales es sensible a haces de electrones separados. Cuando los tres fósforos están 
completamente iluminados, el píxel aparece blanco para el ojo humano. Cuando los tres 
están oscuros, el píxel aparece negro. Cada valor de píxel en las partes visibles de una 
ventana se lee continuamente de la memoria de la pantalla y se busca en el mapa de 
colores. Los valores RGB en la celda de color especificada controlan la intensidad de los 
tres colores primarios y, por lo tanto, determinan el color que se muestra en ese punto de 
la pantalla (Figura 10.6).
Los datos ráster también se pueden transformar de modelo RGB a escala de grises. Las 
formas más comunes de realizar la transformación son Lustre (Jack 2011), Intensidad 
(Hoeffding 1963) y Luma (Bosch et al. 2007). El método Lustre promedia los colores más 
prominentes y menos prominentes. El método de intensidad simplemente promedia los 
valores. El método Luma es una versión más sofisticada del método promedio. También 
promedia los valores, pero forma un promedio ponderado para dar cuenta de la 
percepción humana; debido a que los seres humanos son más sensibles al verde que a 
otros colores, el verde tiene la mayor ponderación (Ecuación 10.1).Figura 10.7muestra los 
resultados de la transformación.
-max(R,GRAMO,B) + min(R,GRAMO,B)
- 2-
v′ = -R+GRAMO+B
, Método de brillo
,
-0.21×R+0.72×GRAMO+0.07×B,
método de intensidad
método de luminancia
(10.1)- 3
-
Algoritmo de datos ráster 193
m
ap
a 
de
 c
ol
or
es
R
G
RA
M
O
B
19 18 17 diec
is
éi
s
I5 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
va
lo
r d
e 
pí
xe
l
1
0
0
1
0
0
25
5
0
Ce
ld
a 
de
 c
ol
or
0
0
0
FI
G
U
RA
 1
0.
6
As
ig
na
ci
ón
 d
e 
va
lo
r d
e 
pí
xe
l a
 R
G
B 
co
n 
el
 m
ap
a 
de
 c
ol
or
es
.
194Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
Imagen original Método de brillo
método de intensidad método de luminancia
FIGURA 10.7
RGB a escala de grises. (Imagen original dehttp://www.coloringpages456.com/color-pictures/.)
losprofundidad del colormide la cantidad de información de color disponible para mostrar o 
imprimir cada píxel de una imagen digital. Debido a la naturaleza finita de la capacidad de 
almacenamiento, un número digital se almacena con un número finito de bits (dígitos binarios). 
El número de bits determina la resolución radiométrica de la imagen. Una profundidad de color 
alta conduce a más colores disponibles y, en consecuencia, a una representación de color más 
precisa. Por ejemplo, un píxel con una profundidad de un bit tiene solo dos colores posibles. Un 
píxel con una profundidad de 8 bits tiene 256 valores de color posibles, que van de 0 a 255 (es 
decir, 28–1), y un píxel con una profundidad de 24 bits tiene más de 16 millones de valores de 
color posibles, que van de 0 a 16 777 215 (es decir, 224–1). Por lo general, las profundidades de 
color varían entre 1 y 64 bits por píxel en imágenes digitales.
10.4.2 Representación ráster
Los conjuntos de datos ráster se pueden mostrar o representar en un mapa de muchas 
maneras diferentes.La representación es el proceso de mostrar los datos. La visualización del 
mapa depende tanto de los datos en sí como del método de representación elegido. Los 
métodos de representación de datos ráster comúnmente utilizados en el software GIS incluyen 
estirado, compuesto RGB, clasificado, valores únicos y color discreto.
losEstiradorenderer representa datos continuos estirándolos en las estadísticas del conjunto 
de datos ráster. Un estiramiento aumenta el contraste visual de la pantalla de trama, 
especialmente cuando la pantalla de trama aparece oscura o tiene poco contraste. Es posible 
que la imagen no contenga todo el rango de valores que puede mostrar una computadora (
Figura 10.8a,b); por lo tanto, al aplicar un estiramiento de contraste, la imagen
http://www.coloringpages456.com/color-pictures/
Algoritmo de datos ráster 195
(a) (b)
1400
1200
1000
800
600
400
200
0
0 50
valor de píxel
100 150 200 250
(C) (d)
1000
900
800
700
600
500
400
300
200
100
0
0 50
valor de píxel
100 150 200 250
FIGURA 10.8
Renderizador de estiramiento. (a) Figura original, (b) Histograma de figura original, (c) Figura estirada, 
(d) Histograma de figura estirada.
los valores podrían estirarse para utilizar este rango (Figura 10.8d). En el caso de ocho 
planos de bits, los valores se calculan en la Ecuación 10.2.
-v′ =metro×v+C
--
-metro=
28− 1
máx(v) − min(v)
(10.2)
-
--C=28− 1 −metro×máx(v)
dóndev′se refiere al valor de píxel estirado yvse refiere al valor de píxel original. Esto 
puede resultar en una imagen más nítida y algunas características pueden volverse más 
fáciles de distinguir (Figura 10.8c).
Distintos tramos producirán diferentes resultados en la visualización de trama; los 
métodos estándar incluyen desviación estándar, mínimo-máximo, ecualización de 
histograma y especificación de histograma.
losCompuesto RGBEl renderizador utiliza los mismos métodos que el renderizador 
estirado, pero permite combinar bandas como compuestos de rojo, verde y azul.
Co
nt
ar
Co
nt
ar
196Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
Los conjuntos de datos ráster multibanda, como imágenes satelitales o aéreas, generalmente 
se muestran en diferentes combinaciones de bandas usando RGB Composite.
losClasificadorenderer se utiliza con una capa ráster de una sola banda. El método 
clasificado muestra un ráster temático al agrupar los valores de las celdas en clases. Los 
fenómenos continuos como la pendiente, la distancia y la idoneidad se pueden clasificar 
en un pequeño número de clases que se pueden asignar como colores. La clasificación es 
una operación de datos espaciales utilizada junto con operaciones de selección 
anteriores. Esto puede crear un nuevo conjunto de datos o presentar una vista diferente 
de los mismos datos (por ejemplo, propiedades de visualización).
Dos renderizadores menos comunes sonValores únicosyColor discreto. losValores 
únicosrenderer se utiliza para mostrar cada valor en la capa ráster individualmente. Es 
adecuado para datos que contienen categorías discretas que representan objetos 
particulares, como un mapa temático que representa el uso o los tipos de suelo. El 
renderizador de valores únicos puede mostrar cada valor como un color aleatorio o usar 
un mapa de colores. Color discretorenderer muestra los valores en el conjunto de datos 
ráster usando un color aleatorio. Este renderizador es similar al renderizador de valores 
únicos, pero es más eficiente cuando hay una gran cantidad de valores únicos porque no 
tiene que calcular cuántos valores únicos existen. El renderizador de color discreto asigna 
un color a cada valor único hasta que alcanza el número máximo de colores elegido. El 
siguiente valor único comienza al principio del esquema de color; este proceso continúa 
hasta que cada valor único tiene un color asignado.
10.5 Análisis de trama
El análisis ráster incluye varios tipos de cálculos basados en píxeles. En esta 
sección, presentamos varios análisis de datos ráster que se realizan con frecuencia, 
incluidas operaciones de reclasificación, superposición y descriptivas.
La reclasificación es el proceso de reasignar nuevos valores de salida a un valor, 
un rango de valores o una lista de valores en un ráster. Se lleva a cabo cuando (1) se 
debe cambiar el valor de una celda, por ejemplo, en el caso de un cambio de terreno 
a lo largo del tiempo; (2) se deben agrupar varios tipos de valores; o (3) los valores 
específicos deben eliminarse del análisis. Existen varios enfoques para la 
reclasificación, como el uso de tablas de búsqueda y rangos de valores.
Usando una tabla de búsqueda, la reclasificación realiza un cambio de uno a uno. 
por ejemplo, enFigura 10.9, para realizar un análisis de hábitat, los valores de 
píxeles en un ráster de uso del suelo, que representan numerosos tipos de uso del 
suelo, deben cambiarse para representar valores de preferencia simples de alto, 
medio y bajo (p. ej., valores 1, 2 y 3). Los tipos de tierra más preferidos se reclasifican 
a valores más altos y los menos preferidos a valores más bajos. Por ejemplo, bosque 
se reclasifica a 3, pastizales a 2 y suelo residencial de baja densidad a 1.
Usando unrangos de valoresproceso, la reclasificación se lleva a cabo en un 
cambio de muchos a uno, reclasificando un rango de valores a alguna alternativa
Algoritmo de datos ráster 197
Uso del suelo
0
1
2
3
4
5
6
7
8
9
Uso del suelo
preferencia
1
2
3
FIGURA 10.9
La reclasificación de datos categóricos implica reemplazar valores individuales con nuevos valores. Por 
ejemplo, los valores de uso de la tierra se pueden reclasificar en valores de preferencia de bajo (1), medio (2) y 
alto (3).
valor y otro rango a un valor alternativo diferente. En nuestro análisis hipotético del 
hábitat, la segunda capa del modelo de idoneidad se basa en la preferencia por 
ubicaciones alejadas de las carreteras. ilustrado enFigura 10.10, se crea un mapa de 
distancia (datos continuos) a partir del tema de carreteras existente. En lugar de 
reclasificar individualmente cada uno de los miles de valores de distancia en una 
escala de preferencia de 1 a 3, los valores se pueden dividir en tres grupos. El grupo 
más lejano recibe el valor de preferencia más alto, un valor de 3, y el grupo más 
cercano, un valor de 1.
Las operaciones descriptivas también se pueden utilizar para realizar análisis de trama. Las 
operaciones incluyen valores mínimos, máximos, medios y medianos, y se pueden operar en 
una escala espacial diferente, como local, focal, zonal o global. Las operaciones locales 
funcionan en celdas ráster individuales o píxeles. Las operaciones focales funcionan en las 
celdas y sus vecinos, mientras que las operaciones globales funcionan en toda la capa. 
Finalmente, las operaciones zonales trabajan en áreas de celdas que comparten el mismo valor. 
En el software GIS, las operaciones se pueden realizar en una calculadora raster, donde están 
disponibles los cálculos matemáticos y las funciones trigonométricas.
Distancia
a las carreteras
Alto: 1784.73 Distancia
preferencia
1
2
3Bajo : 0
FIGURA 10.10
La reclasificación de datos continuos implica reemplazar un rango de valores con nuevos valores. Por ejemplo, 
un ráster que representa la distancia desde las carreteras se puede reclasificar en tres zonas de distancia.
198Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
Otras aplicaciones del análisis raster pueden ser DEMdisplay, análisis hidrológico 
(introducido enCapítulo 12), estadísticas zonales, análisis de búfer, etc.
10.6 Experiencia práctica con ArcGIS
10.6.1 Práctica práctica 10.1: Representaciones de color ráster
1.Figura 10.11amuestra un conjunto de datos de cobertura terrestre almacenado 
en la geodatabase "chp10data.gdb". El ráster se representa utilizando valores 
únicos con un mapa de color preespecificado. Observando la capa en el “Table 
of Contents” en ArcMap, cuando la etiqueta de esta capa se muestra como
Figura 10.11b, la capa debe contenerun mapa de color. Intente abrir la ventana 
de propiedades de la capa (Figura 10.11c) haciendo clic con el botón derecho en 
el nombre de la capa en la "Tabla de contenido" y seleccione "Propiedades..." y 
seleccione la pestaña "Simbología" en la ventana. El conjunto de datos ráster 
representado con color debe tener la opción de "Valores únicos", "Color 
discreto" y "Clasificado". La representación del mapa de color se aplica al 
dataset ráster con una banda.
2. Cambie el modo de reproducción de color. Como se muestra enFigura 10.12a, exporte 
los datos de cobertura terrestre. En la ventana "Exportar datos ráster" (Figura 10.12b
), seleccione "Usar renderizador", que permite que el ráster de salida use el mismo 
esquema de color, y seleccione "Forzar RGB", que transferirá el ráster de banda única 
al nuevo ráster que almacena los valores de píxeles en modo RGB.
Cuando el ráster se almacena en modo RGB, veremos tres subcapas en la 
"Tabla de contenido" (Figura 10.13) y en la pestaña "Simbología" en la ventana 
"Propiedades de capa", hay una opción de renderizador "Compuesto RGB", 
pero "Valor único", "Clasificado" y "Color discreto" ya no están disponibles.
(a) (b) (C)
FIGURA 10.11
Datos ráster representados mediante un mapa de color en ArcMap. (a) La capa ráster renderizada usando un mapa de 
color. (b) La etiqueta de la capa. (c) La ventana de propiedades.
Algoritmo de datos ráster 199
(a)
(b)
FIGURA 10.12
Pasos para exportar datos ráster en ArcMap. (a) Exportar los datos de cobertura terrestre y (b) la ventana "Exportar 
datos ráster".
10.6.2 Práctica práctica 10.2: Análisis de datos ráster: 
Encuentre el área con el rango de elevación entre 60 
y 100 y el tipo de cobertura terrestre como "bosque"
1. En chp10data.gbd, hay dos conjuntos de datos ráster "dem" y "landcover". 
Ejecute Code 10.1 en la ventana Python de ArcMap para clasificar los datos 
DEM en varios rangos de elevación (0–10, 10–30, 30–60, 60–100 y >100 
grados). El resultado se muestra enFigura 10.14.
200Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
FIGURA 10.13
Ráster mostrado en RGB.
Tenga en cuenta que la función "Reclasificar" requiere que los usuarios de 
ArcMap tengan la extensión "Spatial Analyst"; por lo tanto, verifique la licencia 
de la extensión antes de ejecutar el análisis.
La función Reclassify proporciona dos métodos para definir las clases: 
RemapRange redefine un rango de valores en un nuevo valor de clase; 
RemapValue define la relación de mapeo uno a uno, es decir, 
reemplaza un solo valor original con un solo valor nuevo.
2. El conjunto de datos de cobertura terrestre almacena los tipos de cobertura terrestre 
en detalle. Por ejemplo, “Bosque” se divide en tres subtipos: “Bosque Caducifolio”, 
“Bosque Perennifolio” y “Bosque Mixto”. Ejecute el código 10.2 en la ventana de 
Python de ArcMap para generalizar el conjunto de datos de cobertura terrestre. El 
resultado se muestra enFigura 10.15.
3. Ejecute el código 10.3 en la ventana de Python de ArcMap para superponer los conjuntos de 
datos de cobertura terrestre y DEM clasificados para encontrar el área en el bosque (valor 
de píxel del conjunto de datos de cobertura terrestre = 4) con una elevación entre 60 y 100 
(valor de píxel del conjunto de datos DEM = 100). Para este conjunto de datos específico, 
una forma de encontrar el área esperada es agregar las dos capas y encontrar los píxeles 
con el valor en 104, luego reclasificar todos los píxeles con el valor en 104 en una clase (1), y 
todos los demás píxeles en otra clase (0).Figura 10.16 muestra el resultado de la 
reclasificación.
10.6.3 Práctica práctica 10.3. Acceda a la información de atributos del 
conjunto de datos ráster y calcule el área
1. Ejecute el Código 10.4 en la ventana Python de ArcMap para calcular el área del 
conjunto de datos ráster. El conjunto de datos ráster ya debería estar proyectado.
Algoritmo de datos ráster 201
# clasificar elevaciones en clases
# establecer espacio de trabajo
arcpy.env.espacio de trabajo ="C:\\ArcGISdata\\chp10data\\chp10data.gdb"
"""
Compruebe la licencia de la extensión de analista espacial. El valor 
devuelto "disponible" significa que las funciones de esta extensión se 
pueden utilizar.
"""
arcpy.CheckExtension("espacial")
"""
Defina los datos de entrada. "Dem" es un conjunto de datos ráster de geodatabase de 
archivos almacenado en "chp10data.gdb"
"""
en Ráster ="dem"
"""
Defina las clases de valor. Los primeros dos elementos entre paréntesis [0,10,10] 
significan los valores mínimo y máximo en la clase y el tercer elemento 
significa el nuevo valor para los siguientes píxeles en la clase.
"""
rangos = arcpy.sa.RemapRange([[0,10,10],[10,30,30],[30,60,60], [60,100,100],
[100,175,175]])
"""
Ejecute la función Reclasificar según el campo "Valor" del ráster utilizando 
RemapRange y establezca los valores faltantes como "NODATA".
"""
outDEM = arcpy.sa.Reclassify(inRaster,"Valor", rangos,"SIN DATOS")
"""
Genere el resultado de la función de reclasificación como un nuevo dataset ráster 
en la geodatabase de archivos, denominado "classifiedElevation" (Figura x 
izquierda).
"""
outDEM.save("elevaciónclasificada")
CÓDIGO 10.1
Clasificar datos DEM.
2. Utilizando el conjunto de datos de cobertura terrestre clasificado que resultó de 
la práctica anterior, ejecute el Código 10.5 en la ventana de ArcMap Python para 
calcular el área de cada tipo de cobertura terrestre. El área de cada tipo de 
cobertura terrestre se puede calcular primero utilizando la proporción de los 
recuentos de píxeles de este tipo con respecto al recuento total de píxeles y 
luego multiplicar el área total del conjunto de datos ráster. En consecuencia, 
utilice el SearchCursor (verCapítulo 8) para capturar los recuentos de píxeles.
202Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
FIGURA 10.14
Resultado de reclasificar datos DEM en Código 10.1.
# generalizar los tipos de cobertura terrestre
# datos de entrada
inLandcover ="cobertura terrestre"
"""
Establezca la relación de mapeo entre valores antiguos y valores nuevos. El 
primer elemento entre paréntesis [11,1] significa el valor anterior y el segundo 
elemento significa el valor nuevo.
"""
valores = arcpy.sa.RemapValue([[11,1],[21,2],[22,2],[23,2],[24,2],[31,3],
[41,4],[42,4],[43,4],[52,5],[71,7],[81,8],[82,8],[90,9], [95 ,9]])
# ejecutar la función de reclasificación y guardar como un nuevo conjunto de 
datos "classifiedLandcover"
outLandcover = arcpy.sa.Reclassify(inLandcover,"Valor",valores) 
outLandcover.save("Cubierta terrestre clasificada")
CÓDIGO 10.2
Generalizar el conjunto de datos de cobertura terrestre.
Algoritmo de datos ráster 203
FIGURA 10.15
Resultado de reclasificar datos de tipo de cobertura terrestre en el Código 10.2.
"""
Use la calculadora ráster para agregar dos capas. Tenga en cuenta que la 
calculadora ráster puede ejecutar muchos otros cálculos de álgebra en el
conjunto de datos ráster.
"""
temp = arcpy.gp.RasterCalculator_sa("'outLandcover' + 'outDEM'", 
"superposiciónRáster")
"""
Reclasifique las capas en dos clases: 1 y 0. 1 representa el área que está en 
el bosque y tiene la elevación esperada.
"""
outReclassify = arcpy.sa.Reclassify("superposiciónRáster","Valor", arcoíris.
sa.RemapRange([[12,103,0], 
[104,104,1],[105,184,0]]), "SIN 
DATOS")
CÓDIGO 10.3
Reclasificar y encontrar áreas específicas.
204Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
FIGURA 10.16
Resultado de reclasificar datos de tipo de cobertura terrestre en el Código 10.3.
# describir la extensión espacial del conjunto de datos y calcular el 
área desc = arcpy.Describe("Cubierta terrestre clasificada") area = 
desc.ancho * desc.alto
CÓDIGO 10.4
Calcular área.
# describir la extensión espacial del conjunto de datos y calcular el 
área desc = arcpy.Describe("Cubierta terrestre clasificada") area = 
desc.ancho * desc.alto
# almacenar el recuento total de píxeles en el conjunto de datos 
recuento total = 0
# inicializaruna matriz para poner los recuentos de píxeles en cada tipo de cobertura terrestre 
cuenta = []
"""
Utilice SearchCursor para acceder a los campos Valor y Recuento. El campo 
Valor es el valor del tipo de cobertura terrestre.
"""
conarcpy.da.SearchCursor("Cubierta terrestre clasificada", ["Valor","Contar"]) como\ 
cursor:
porfilaencursor:
totalCount = totalCount + fila[1] cuenta.append({'escribe': 
fila[0],'contar':fila[1]})
# calcular e imprimir el área de cada tipo de cobertura terrestre por
elementoencuenta:
impresión'El área del tipo de cobertura terrestre {0} es: {1}'. 
formato(ele['escribe'],ele['contar']/recuentototal*área)
CÓDIGO 10.5
Calcular el área total.
Algoritmo de datos ráster 205
10.7 Resumen del capítulo
Este capítulo presenta algoritmos de procesamiento de datos ráster y los demuestra 
en ArcGIS utilizando la programación Arcpy, que incluye lo siguiente:
1. Estructura de datos ráster
2. Representación de color
3. Almacenamiento de datos ráster
4. Compresión de datos ráster
5. Formatos de datos ráster
6. Análisis de trama
7. Experiencia práctica con arcpy
PROBLEMAS
Para los datos ráster de su elección, diseñe un escenario que requiera 
reclasificación. Explique el razonamiento para la reclasificación y determine el 
propósito de las nuevas clases. Calcule el área para cada clase y use diferentes 
métodos de reproducción de color para presentar el resultado.
NOTA :Todos los códigos se pueden ejecutar con éxito en ArcGIS para versiones de 
escritorio 10.2.2 a 10.3. Puede haber un problema al ejecutar el código en una versión 
más reciente de ArcGIS.
http://taylorandfrancis.com
11
Algoritmos de datos de red
Una red es un sistema de elementos interconectados, como bordes (líneas) y cruces 
de conexión (puntos) que representan posibles rutas de un lugar a otro. Las 
personas, los recursos y los bienes tienden a viajar a lo largo de las redes: los 
automóviles y los camiones viajan por carreteras, los aviones vuelan en rutas de 
vuelo predeterminadas, el petróleo fluye por los oleoductos. Al modelar rutas de 
viaje potenciales con una red, es posible realizar análisis relacionados con el 
movimiento del petróleo, camiones u otros agentes en la red. El análisis de red más 
común es encontrar el camino más corto entre dos puntos (McCoy et al., 2001). Este 
capítulo presenta la representación de red, los algoritmos y las aplicaciones en SIG, 
y brinda experiencia práctica con ArcGIS.
11.1 Representación de la red
11.1.1 Representación básica de la red
Una red, a veces llamada grafo, es un grupo o sistema de objetos 
interconectados. Podría ser el sistema de transporte o varias 
computadoras, máquinas u operaciones interconectadas. Hay dos 
componentes esenciales en una red: bordes y nodos (Figura 11.1).
Cada punto de una red se denomina vértice o nodo. Las conexiones entre 
vértices se denominan aristas o enlaces. Matemáticamente, una red 
consiste en una colecciónVde vértices y una colecciónmide bordes cada 
bordemi∈miSe dice que une dos vértices, que se llaman sus extremos. 
Cuando hay un bordemique une vérticestuyv, se denominan adyacentey 
bordemi= (tu,v) se dice que es incidente con vérticestuyv, respectivamente. 
Por ejemplo, la red enFigura 11.2puede ser representado por lo siguiente:
• V= {v1,v2,v3,v4}
• mi= {(v1,v2), (v2,v4), (v1,v3), (v1,v4), (v3,v4)}
11.1.2 Redes dirigidas y no dirigidas
Hay dos tipos de sistemas de red: redes dirigidas y redes no dirigidas. Una 
red dirigida es una red en la que los bordes tienen direcciones,
207
208Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
Bordes
Nodos
FIGURA 11.1
Un ejemplo de elementos básicos de red.
lo que significa que no hay distinción entre los dos vértices asociados con cada borde. Por 
ejemplo,Figura 11.2es en realidad una red no dirigida. Las redes no dirigidas se utilizan 
para modelar redes en líneas aéreas, rutas de navegación y rutas de tránsito. Por 
ejemplo, una ruta de vuelo bidireccional que conecta un conjunto de ciudades se puede 
representar como un gráfico no dirigido. Las ciudades podrían definirse por los vértices y 
los bordes desordenados pueden representar rutas de vuelo de dos vías que conectan las 
ciudades.
En contraste, los bordes en una red dirigida dirigen un vértice a otro. En redes 
dirigidas, una ventajamise define por pares ordenados como <X,y> donde vérticeXes el 
origen y el vérticeyes el destino. Por ejemplo, borde <V2,V3>se dirige desdeV2aV3. El 
ejemplo de la red dirigida en Figura 11.3ase puede representar comoV= {<V1,V2>, <V3,V2>, 
<V3,V1>}. Las redes dirigidas se utilizan para modelar sistemas de carreteras, electricidad, 
teléfono, cable, alcantarillado y agua. Por ejemplo, una red de carreteras que conecta un 
conjunto de ubicaciones en una ciudad con carreteras de un solo sentido se puede 
representar como un gráfico dirigido. Las ubicaciones se pueden representar mediante 
los vértices y los bordes dirigidos pueden representar las carreteras que conectan las 
ubicaciones teniendo en cuenta el flujo de tráfico. Tenga en cuenta que definir una red 
como dirigida o no depende en gran medida del problema que está tratando de modelar.
v3mi3
v1
mi mi51 mi4
v2
mi2 v4
FIGURA 11.2
Un ejemplo de representación de red básica.
Algoritmos de datos de red 209
(a) (b)
v1 v1
v2 v3 v2 v3
FIGURA 11.3
Ejemplo de red dirigida y no dirigida. (a) Red dirigida, (b) Red no dirigida.
11.1.3 La Matriz de Adyacencia
Hay muchas formas de representar una red. Una de las formas más populares es 
utilizar una matriz de adyacencia. Una matriz de adyacencia es una matriz cuadrada 
utilizada para representar un gráfico finito. Los elementos de la matriz indican si los 
pares de vértices son adyacentes o no en el gráfico. Por ejemplo, para una red con
nortevértices, la matriz de adyacencia para esta red será unanorte×norte matriz, 
donde (i,j) es el índice de la conexión entre el vérticeiyj. Si elemento (i,j) es distinto de 
cero (es decir, "1"), significa que los vérticesiyjestán conectados, si es cero significa 
que no están conectados. Tenga en cuenta que las matrices de adyacencia no 
dirigidas son simétricas.Figura 11.4muestra la diferencia entre matrices de 
adyacencia para matrices dirigidas y no dirigidas.
11.1.4 Representación de red en SIG
La mayoría del software GIS utiliza la representación de borde de nodo para el análisis de red, 
que es una variante de la matriz de adyacencia. Representación de red de borde de nodo
(a) (b)
v1 v1
v2 v3 v2 v3
v1
0
v2
1
v3
0
v1
0
v2
1
v3
1v1
v2
v3
v1
v2
v3
0
1
0
1
0
0
1
1
0
1
1
0
FIGURA 11.4
Matriz de adyacencia de red dirigida y no dirigida. (a) Red dirigida, (b) Red no dirigida.
210Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
TABLA 11.1
Ejemplo de tabla de nodos para la red enFigura 11.2
IDENTIFICACIÓN X Y
v1
v2
v3
v4
23.2643
23.1443
23.2823
23.1442
75.1245
74.1242
75.1315
75.1286
TABLA 11.2
Ejemplo de Tabla de Enlace para la Red enFigura 11.2
IDENTIFICACIÓN Origen Destino Un camino
mi1
mi2
mi3
mi4
mi5
v1
v2
v1
v1
v3
v2
v4
v3
v4
v4
No
No
No
No
No
mantiene una tabla de nodos y una tabla de aristas, como se demuestra en 
Tablas 11.1y11.2.
• Tabla de nodos: Esta tabla contiene al menos tres campos: uno para almacenar 
un identificador único y los otros para almacenar el nodoXyYcoordenadas 
Aunque estas coordenadas pueden ser definidas por cualquier sistema de 
referencia cartesiano, las longitudes y latitudes aseguran una fácil portabilidad 
a un SIG (Rodrigue, 2016).
• Tabla de enlaces: esta tabla también contiene al menos tres campos: uno para 
almacenar un identificador único, uno para almacenar el nodo de origen y otro para 
almacenar el nodo de destino. Se puede utilizar un cuarto campo para indicar si el 
enlace es unidireccional o no.
11.2 Encontrar el camino más corto
11.2.1 Declaración del problema
En la teoría de grafos, un camino en un gráfico es una secuencia finita o infinita de aristas 
que conectan una secuencia de vérticesque, según la mayoría de las definiciones, son 
todos distintos entre sí (Bondy y Murty, 1976). Encontrar el camino más corto es uno
Algoritmos de datos de red 211
de los algoritmos de análisis de red más importantes. Se refiere a encontrar el 
camino entre dos vértices en una red que minimiza la distancia acumulada (o 
distancia ponderada) de sus bordes constituyentes. Para un problema regular de 
ruta más corta, generalmente hacemos las siguientes suposiciones:
• Los bordes pueden ser dirigidos o no dirigidos. Un camino más corto debe respetar la 
dirección de sus bordes.
• La longitud de cada borde no tiene que ser una distancia espacial. También 
podría referirse al tiempo o algún otro costo.
• Las distancias entre los nodos deben ser no negativas.
• No todos los vértices son accesibles. Si un vértice no es accesible desde 
el otro, no hay camino posible entre ellos.
11.2.2 Un enfoque de fuerza bruta para el algoritmo de ruta más corta
Un enfoque de fuerza bruta para encontrar el camino más corto entre dos vértices en una 
red se puede describir como
• Paso 1: encuentre todos los caminos posibles desde el punto de inicio hasta el punto final.
• Paso 2: Calcular la longitud de cada camino.
• Paso 3: elige el camino más corto comparando las longitudes de todos los 
caminos diferentes.
Por ejemplo, dada la red enFigura 11.5, nos gustaría encontrar el camino más 
corto desdeAa todos los demás vértices. El número de cada borde es el costo y
Tabla 11.3muestra todos los caminos posibles desdeAa los otros vértices. 
Aunque este método para encontrar el camino más corto es simple y directo, la 
complejidad de este enfoque aumenta exponencialmente con el número de 
vértices y aristas. Por ejemplo, si conectamosByC, habrá al menos dos rutas 
más desdeAami. En una aplicación de red real,
B
1 2
1
A D mi
2 2
C
FIGURA 11.5
Un ejemplo de red utilizado para ilustrar cómo encontrar el problema de la ruta más corta.
212Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
TABLA 11.3
Enfoque de fuerza bruta para resolver el problema de la ruta más corta 
(Encuentre la ruta más corta desdeAami)
Punto de destino Posibles caminos y longitud Ruta más corta
B
C
D
mi
AB: 1; ACDB: 6
CA: 2; ABDC: 5
ABD: 3; CDA: 4
ABDA: 4; ACD: 5
AB: 1
CA: 2
DAB: 2
ABDA: 4
generalmente tienen una gran cantidad de vértices y aristas (por ejemplo, un sistema de 
transporte), lo que sería muy costoso y requeriría mucho tiempo desde el punto de vista 
computacional. Por lo tanto, se necesita un algoritmo computacionalmente eficiente para 
calcular el camino más corto.
11.2.3 Algoritmo de Dijkstra
El algoritmo de Dijkstra es un algoritmo ampliamente utilizado para resolver el 
problema del camino más corto. Consta de los siguientes seis pasos. Deje que el 
nodo en el que estamos comenzando se llame el nodo inicial. Deje que la distancia 
del nodoYSea la distancia desde el nodo inicial hastaY. El algoritmo de Dijkstra 
asignará unos valores iniciales de distancia y tratará de mejorarlos paso a paso 
(Dijkstra, 1959).
• Asigne a cada nodo un valor de distancia tentativo: configúrelo en cero para el 
nodo inicial y en infinito para todos los demás nodos.
• Establecer el nodo inicial como actual. Marque todos los demás nodos como no visitados. 
Cree un conjunto de todos los nodos no visitados denominado conjunto no visitado.
• Para el nodo actual, considere todos sus vecinos no visitados y calcule 
sus distancias tentativas. Compare la distancia tentativa recién 
calculada con el valor asignado actual y asigne la más pequeña. Por 
ejemplo, si el nodo actualAestá marcado con una distancia de 6, y el 
borde que lo conecta con un vecinoBtiene longitud 2, entonces la 
distancia aB(medianteA) será 6 + 2 = 8. SiBestaba previamente marcado 
con una distancia mayor a 8, luego cámbielo a 8. De lo contrario, 
mantenga el valor actual.
• Después de considerar todos los vecinos del nodo actual, marque el 
nodo actual como visitado y elimínelo del conjunto no visitado.
Un nodo visitado nunca se volverá a comprobar.
• Si el nodo de destino ha sido marcado como visitado (al planificar una 
ruta entre dos nodos específicos) o si la distancia tentativa más 
pequeña entre los nodos en el conjunto no visitado es infinito (al 
planificar un recorrido completo; ocurre cuando no hay conexión
Algoritmos de datos de red 213
TABLA 11.4
Proceso de uso del algoritmo de Dijkstra para resolver el camino más 
corto desdeAa otros vértices (CXSignifica el costo deAaX)
Paso Punto Seleccionado CA CA CA CA CA Sendero
A
METRO
1
2
3
4
5
A
B
C
D
mi
0 ∞
1
∞
2
2
∞
∞
∞
∞
A
AB
A B C
A B C D
A B C D E
AB
C.A.
ABD
ABDE
3
3
3
∞
∞
1 2 4
entre el nodo inicial y los nodos restantes no visitados), luego deténgase. El 
algoritmo ha terminado.
• De lo contrario, seleccione el nodo no visitado que está marcado con la distancia 
tentativa más pequeña, configúrelo como el nuevo "nodo actual" y regrese al 
paso 3.
Como ejemplo, el problema mencionado en la última sección se puede resolver 
utilizando el algoritmo de Dijkstra (Tabla 11.4). El pseudocódigo del algoritmo de 
Dijkstra se muestra enTabla 11.5.
La implementación del algoritmo de Dijkstra es bastante compleja y requiere 
diferentes tipos de estructuras de datos y consideraciones elaboradas. Por lo tanto, 
los ejemplos de ArcGIS se utilizan para demostrar cómo se admite el análisis de red 
en GIS. El código fuente también está disponible en muchos paquetes de software 
de código abierto como QGIS.
TABLA 11.5
Pseudocódigo para el algoritmo de Dijkstra
Entrada: conjunto de datos de red (G), vértice inicial (A) {
NS1:
NS2:
NS3:
NS4:
NS5:
NS6:
NS7:
DK8:
DK9:
DK10:
DK11:
DK12:
DK13:
}
para cada vértice v en G:
distancia[v] = ∞
dist[A] := 0
T = el conjunto de todos los vértices en G 
mientras que T no está vacío:
s = vértices en T con menor dist[ ] 
eliminar s de T
para cada (vecino) conectado v de s:
distancia_temp = dist[s] + dist_entre(s, v)
si distancia_temp < dist(v)
dist [v] = distancia_temp. Distancia_más 
corta [v] = Distancia_temp. return 
Distancia_más corta []
214Introducción a la Programación GIS y Fundamentos con Python y ArcGIS®
11.3 Tipos de análisis de red
El análisis de red le permite resolver problemas comunes de red, como encontrar la mejor ruta 
a través de una ciudad, encontrar el vehículo o la instalación de emergencia más cercana, 
identificar un área de servicio alrededor de una ubicación, atender un conjunto de pedidos con 
una flota de vehículos o elegir el Las mejores instalaciones para abrir o cerrar. Todos estos 
problemas podrían resolverse utilizando el algoritmo de Dijkstra o sus variantes.
11.3.1 Enrutamiento
Ya sea que busque una ruta simple entre dos ubicaciones o una que visite 
varias ubicaciones, las personas generalmente intentan tomar la mejor ruta. 
Pero la “mejor ruta” puede significar diferentes cosas en diferentes situaciones. 
La mejor ruta puede ser la más rápida, la más corta o la más pintoresca, según 
elimpedanciaelegido. La mejor ruta se puede definir como la ruta que tiene la 
impedancia más baja, donde la impedancia la elige el usuario. Si la impedancia 
es el tiempo, entonces la mejor ruta es la ruta más rápida. Cualquier atributo de 
costo de red válido se puede usar como impedancia al determinar la mejor 
ruta.
11.3.2 Instalación más cercana
Encontrar el hospital más cercano a un accidente o la tienda más cercana a la dirección de la 
casa de un cliente son ejemplos de problemas de las instalaciones más cercanas. Al buscar las 
instalaciones más cercanas, puede especificar cuántas buscar y si la dirección del viaje es hacia 
ellas o alejándose de ellas mediante el software GIS. Una vez que haya encontrado las 
instalaciones más cercanas, puede mostrar la mejor ruta hacia o desde ellas, devolver el costo 
del viaje para cada ruta y mostrar las indicaciones para llegar a cada instalación. Además, 
puede especificar un límite de impedancia para Network Analyst. Por ejemplo, puede 
configurar un problema