12 Uso de Python para

ArcGIS

En este capítulo, vamos a cubrir los siguientes temas:

 Introducción a ArcGIS REST API
 Hacer peticiones HTTP y analizar la respuesta con Python
 Obtención de información sobre la capa con ArcGIS REST API y Python
 Exportar un mapa con ArcGIS REST API y Python.
 Consultar un servicio de mapa con ArcGIS REST API y Python
 Geocodificación con el ESRI World servicio de geocodificación.
 Uso del FieldMAp y FieldMappings.
 Uso de un ValueTable para proporcionar entrada multi valor a una
herramienta

Introducción
En este capítulo, trataremos algunos temas que son de una naturaleza más
avanzada. Específicamente, usted aprenderá cómo acceder a la REST API de
ArcGIS utilizando el módulo de solicitudes de Python. Al hacerlo usted aprenderá
cómo obtener acceso a los datos y servicios publicados por ArcGIS Server y ArcGIS
Online. El módulo de solicitudes de Python incluye funciones que permiten que su
script pueda enviar peticiones a una URL endpoint y recibir respuestas en varios
formatos, incluyendo el popular formato JSON. Hacia el final del capítulo, tendremos
también más de un par de ArcP y varios temas, incluido el uso de los objetos
FieldMappings FieldMap y combinar conjuntos de datos y trabajando también con
ValueTables para situaciones en las que una herramienta tiene la capacidad de
aceptar múltiples entradas.
Introducción a ArcGIS REST API
Antes de adentrarnos demasiado en la codificación, usted necesita entender
algunos conceptos básicos de la REST API de ArcGIS. Usted necesita conocer
específicamente cómo construir una URL e interpretar la respuesta que se devuelve.

Preparándose
Todos los recursos y operaciones de la REST API de ArcGIS están expuestos a
través de una jerarquía de puntos finales, que analizaremos a medida que
avanzamos en el curso de este libro. Por ahora, vamos a examinar los pasos
específicos que debe comprender para poder presentar una solicitud a la API a
través de Python. En estas instrucciones aprenderá a usar el directorio de servicios
de ArcGIS SERVER para construir las solicitudes URL.

Cómo hacerlo...
Vamos a usar una instancia del servidor ArcGIS públicamente disponible para
aprender a utilizar las herramientas proporcionadas por el Directorio de Servicios
para construir una petición de URL:

1. Abra un navegador web (preferiblemente Google Chrome o Firefox).

2. Ir a http://sampleserver1.arcgisonline.com/arcgis/rest/services:

3. A continuación, necesitamos determinar el punto final conocido. Esto representa

un servidor de catálogo, que es un conjunto de operaciones que ArcGIS Server
puede realizar junto con servicios específicos. Desplácese a la demografía
|ESRI_CENSUS_USA. Este es un punto final conocido. Si nos fijamos en la barra
de direcciones de su navegador debería ver esto:

http://sampleserver1.arcgisonline.com/ArcGIS/rest/services/
Demographics/ESRI_Census_USA/MapServer.
Observe que esto sigue el patrón visto aquí:

http://<host>/<site>/rest/services/<folder>/<serviceName>/<serv
iceType>

4. Hacer clic en los diferentes enlace, observe cómo cambia el URL en la barra de
direcciones. Esta URL es muy importante porque le proporciona el contenido que
será presentado a través de una solicitud de Python:

5. A continuación, aprenderá cómo construir URLs que se pueden presentar como

solicitudes para ArcGIS REST API. Este es un paso muy importante. La sintaxis de

la solicitud incluye la ruta al recurso junto con un nombre de operación seguida por
una lista de parámetros. El nombre de operación indica el tipo de operación que se

realiza contra el recurso. Por ejemplo, puede que desee exportar un mapa a un

archivo de imagen.

6. La pregunta comienza la lista de parámetros. Cada parámetro entonces se

suministra como un conjunto de pares clave/valor separados por un signo. Toda

esta información se combina en una sola cadena de URL. Esto se ilustra en el

siguiente URL:

http://<resource-url>/<operation>?<parameter1=value1>&<paramete
r2=value2>

Por ahora, vamos a introducir la URL en la barra de direcciones del

navegador. Copiar y pegar
http://sampleserver1.arcgisonline.com/ArcGIS/rest/
services/Demographics/ESRI_Census_USA/MapServer/3/query?text=&
geometry=&geometryType=esriGeometryPoint&inSR=&spatialRel=esri
SpatialRelIntersects&relationParam=&objectIds=&where=name+%3D+
%27Bexar%27&time=&returnCountOnly=false&returnIdsOnly=false&re
turnGeometry=true&maxAllowableOffset=&outSR=&outFields=&f=json

En la barra de direcciones de su navegador. Puede que desee utilizar la versión

digital de este libro para copiar y pegar la dirección URL, en lugar de intentar escribir
esto en la barra de direcciones. Puede volver a ver esta salida:
Puede utilizar el módulo de solicitudes de Python para simplificar este proceso y
acceder a la información de respuesta directamente desde el geoprocesamiento
script. Las solicitudes módulo le permite definir la lista de parámetros como un
diccionario de Python y luego se encarga de la creación de la cadena de consulta
URL, incluida la codificación URL. Aprenderá cómo hacerlo al final de este ejercicio.

7. Los servicios del directorio contiene cuadros de diálogo que puede utilizar para
generar valores de parámetro. Usted puede encontrar enlaces a estos cuadros de
diálogo en la parte inferior de la página Servicios. En el explorador, vaya a
http://sampleserver1.arcgisonline.com/
ArcGIS/rest/services/Demographics/ESRI_Census_USA/MapServer/1

8. Vaya a la parte inferior de la página y haga clic en el enlace de consulta para

mostrar el cuadro de diálogo, como se ve en esta captura de pantalla:

9. Agregue una cláusula where, tal como se muestra en la siguiente captura de

pantalla. Establezca el retorno Campos (separados por comas) a POP2000,
POP2007 y BLKGRP. Cambiar formato: para JSON y volver Geometría: Falso. A
continuación, haga clic en Consulta (GET):

10. La consulta se ejecutará y estos resultados serán devueltos:

11. Examine la barra de direcciones de su explorador para ver la URL que se
generó:
http://sampleserver1.arcgisonline.com/ArcGIS/rest/services/
Demographics/ESRI_Census_USA/MapServer/1/query?text=&geome
try=&geometryType=esriGeometryPolygon&inSR=&spatialRel=esri
SpatialRelIntersects&relationParam=&objectIds=&where=STATE_
FIPS+%3D+%2748%27+and+CNTY_FIPS+%3D+%27021%27&time=&returnCo
unt Only=false&returnIdsOnly=false&returnGeometry=false&maxAllowabl
eOffset=&outSR=&outFields=POP2000%2CPOP2007%2CBLKGRP&f=pjson.

12. En un próximo paso, podrás aprovechar esta misma URL, enviar la solicitud, y
procesar los resultados usando Python.

¿Cómo funciona?
Los servicios de directorio de una instancia del servidor ArcGIS proporcionan una
variedad de herramientas que puede utilizar para generar solicitudes de URL y
examinar las respuestas esas peticiones de producir. En este procedimiento,
aprendió a utilizar la tarea de consulta para construir una consulta de atributos. Al
hacerlo, ha aprendido cómo se construye una petición de URL.

Hacer peticiones HTTP y analizar la

respuesta con Python

Hay una serie de módulos de Python que puede utilizar para hacer el resto de
solicitudes. ¡Realmente, hay demasiadas! Los módulos incluyen urllib2, httplib2,
pycurl, solicitudes y peticiones. Definitivamente es el mejor del grupo en mi opinión.
Es limpia y fácil de usar para repetir la interacción con RESTful APIs. Una vez que
haya hecho la solicitud, se podrá analizar la respuesta de JSON con el módulo json
Python. En este procedimiento aprenderá a hacerlo.
 Preparándose
Las solicitudes Python módulo puede ser utilizado para enviar las peticiones a un
recurso del servidor ArcGIS y procesar la respuesta devuelta. Siga estos pasos para
aprender los pasos básicos involucrados en la presentación de solicitudes y el
procesamiento de la respuesta mediante el módulo de solicitudes:

Cómo hacerlo...
Antes de comenzar, asegúrese de haber descargado e instalado el módulo de
solicitudes, utilizando el pip. Si aún no lo ha hecho, me han proporcionado las
siguientes instrucciones para instalar tanto el PIP y el módulo de solicitudes:

Este ejercicio y todas los ejercicios de este capítulo se utilizan el módulo de requests de
Python. Si usted no tiene ya este módulo instalado en tu equipo, tendrás que hacerlo en
este momento. Las solicitudes módulo se instala mediante pip, se necesita instalarlo en
su equipo antes de que el módulo de solicitudes este instalado. Las versiones posteriores
de Python 2.7.9 incluyendo (en la serie python2) y Python 3.4 incluyen pip por defecto,
por lo que puede tenerlo ya. Para poner a prueba para ver si ya pip tiene instalado, puede
introducir lo siguiente desde un indicador de DOS:PIP instalar solicitudes.

Si no tiene instalado el PIP, obtendrá un mensaje de error y deberá instalar pip

(Https://pip.pypa.io/en/latest/instalar.html). Una vez instalado, puede descargar e instalar
el módulo de solicitudes mediante el comando de instalación anterior.

1. Abra IDLE(u otro entorno de desarrollo Python) y seleccione Archivo | Nueva

ventana. Guarde el archivo con el nombre: C:\ArcpyBook\Ch12\ReqJSON.py.

2. Importar los modulos requests y json: import requests import json

3. Crear una nueva variable que contiene una dirección URL a una lista de servicios
ofrecidos por ArcGIS Online. Esta dirección URL contiene un formato de salida de
pjson, un formato JSON contenida en un amplio formato para facilitar la legibilidad.

import requests import json agisurl =

http://server.arcgisonline.com/arcgis/rest/ services?f=pjson
4. Utilice el método get () en el módulo de solicitudes para enviar una petición
HTTP a ArcGIS API REST. Podrá almacenar la respuesta en una variable
denominada r:
import requests
import json
agisurl = "http://server.arcgisonline.com/arcgis/rest/
services?f=pjson"

r = requests.get(agisurl)

5. Ahora vamos a imprimir la respuesta que se devuelve

import requests
import json
agisurl = "http://server.arcgisonline.com/arcgis/rest/ services?f=pjson"
r = requests.get(agisurl)
print(r.text)
6. Guardar script

7. Ejecutar el script y verá la siguiente salida. Esta es la respuesta de JSON

que ha sido devuelto por el ArcGIS REST API
8. Utilice el formato json. Este método sirve para analizar el JSON devuelta en
un objeto de diccionario de Python. Vaya por delante y quite la anterior
instrucción print asi:

import requests import json

agisurl = "http://server.arcgisonline.com/arcgis/rest/ services?f=pjson"
r = requests.get(agisurl)
decoded = json.loads(r.text)
print(decoded)

9. Puede comprobar su trabajo examinando el:

C:\ArcpyBook\code\Ch12\ReqJSON.py

10. Guardar y ejecutar el script para ver la salida. Las cargas() método ha
convertido la salida json en un diccionario de Python:
{u'folders': [u'Canvas', u'Demographics', u'Elevation', u'Ocean', u'Reference',
u'Specialty', u'Utilities'], u'services': [{u'type': u'MapServer', u'name':
u'ESRI_Imagery_World_2D'}, {u'type': u'MapServer', u'name':
u'ESRI_StreetMap_World_2D'}, {u'type': u'GlobeServer', u'name':
u'I3_Imagery_Prime_World'}, {u'type':
 u'GlobeServer', u'name': u'NASA_CloudCover_World'}, {u'type':
u'MapServer', u'name': u'NatGeo_World_Map'},
{u'type': u'MapServer', u'name': u'NGS_Topo_US_2D'},
{u'type': u'MapServer', u'name': u'Ocean_Basemap'},
{u'type': u'MapServer', u'name': u'USA_Topo_Maps'},
{u'type': u'MapServer', u'name': u'World_Imagery'},
{u'type': u'MapServer', u'name': u'World_Physical_Map'},
{u'type': u'MapServer', u'name': u'World_Shaded_Relief'},
{u'type': u'MapServer', u'name': u'World_Street_Map'},
{u'type': u'MapServer', u'name': u'World_Terrain_Base'},
{u'type': u'MapServer', u'name': u'World_Topo_Map'}], u'currentVersion': 10.2}

Cómo funciona…
En esta procedimiento sencillo, aprendió a utilizar el módulo Python requests
para enviar una solicitud a una instancia del servidor ArcGIS mediante el método
quests.get (), y, a continuación, procesar la respuesta del servidor. El método
json.loads () se utilizó para convertir la respuesta a un diccionario de Python para
agilizar el procesamiento de objetos. La respuesta contiene datos básicos acerca
de la instancia del servidor ArcGIS, incluyendo carpetas, servicios y versiones.
Veremos ejemplos más complejos en los próximos procedimientos.

Obtención de información sobre la capa con

ArcGIS

REST API y Python

Un mapa de recursos de servicio contiene los conjuntos de datos que pueden incluir
tablas o capas. Contiene información básica acerca de un servicio, incluyendo
características capas, tablas y descripciones de servicios. En este procedimiento
aprenderá a devolver información de capa de un mapa de servicio, usando Python
y ArcGIS REST API.
Preparándose
Para obtener información sobre una capa de un mapa específico servicio, deberá
hacer referencia al número de índice que está asociado con la capa. Cuando
examine la página de directorio de servicios para un servicio, encontrará una lista
de las capas que forman parte del mapa servicio junto con números de índice para
cada capa. Los números de los índices se usan en lugar del nombre de la capa
cuando soliciten información acerca de una capa. Como hemos hecho en el pasado
con pocos procedimientos, usaremos el módulo Python requests para realizar la
solicitud y procesar la respuesta.

Cómo hacerlo...
Siga estos pasos para saber cómo obtener información sobre una capa de un
servicio de mapa:

1. En IDLE o en otro entorno de desarrollo de Python, crear un nuevo script de

python llamado GetLayerInformation.py y guárdelo en la carpeta
C:\carpeta\ArcpyBook Ch12
2. Importar los módulos requests y json:

import requests import json

3. Crear la siguiente variable agisurl. Esto servirá como la base de la URL que hace
referencia a una capa específica en el ESRI_CENSUS mapa de servicio de
EE.UU. Aquí, nos estamos refiriendo a una capa con un número de índice igual
a 1. Además, incluyen un formato de salida de pjson

import requests import json agisurl =

http://sampleserver1.arcgisonline.com/ArcGIS/rest/
services/Demographics/ESRI_Census_USA/MapServer/1?f=pjson

4. Crear una variable payload. Esta variable mantendrá un objeto de diccionario

de Python que contiene los parámetros que serán pasados como parte de la
solicitud. Vamos a incluir una cláusula where y establecer algunas otras
propiedades:
import requests import json
agisurl = "http://sampleserver1.arcgisonline.com/ArcGIS/rest/
services/Demographics/ESRI_Census_USA/MapServer/1" payload = { 'where':
'STATE_FIPS = \'48\' and CNTY_FIPS =
\'021\'','returnCountyOnly': 'false',
'returnIdsOnly': 'false', 'returnGeometry': 'false',
'f': 'pjson'}

5. Llame la requests.get () método y pasar la variable agisurl. La respuesta se

almacena en una variable denominada r:

import requests import json

agisurl = http://sampleserver1.arcgisonline.com/ArcGIS/rest/
services/Demographics/ESRI_Census_USA/MapServer/1?f=pjson payload = {
'where': 'STATE_FIPS = \'48\' and CNTY_FIPS =
\'021\'','returnCountyOnly': 'false', \ 'returnIdsOnly': 'false', 'returnGeometry': 'false', \
'f': 'pjson'} r = requests.get(agisurl, params=payload)

6. Convertir el formato JSON para un diccionario de Python:

r = requests.get(agisurl, params=payload)
decoded = json.loads(r.text)

7. Imprimir el nombre, extensión geográfica, y campos de la capa

r = requests.get(agisurl, params=payload), decoded = json.loads(r.text)
print("The layer name is: " + decoded['name'])
print("The xmin: " + str(decoded['extent']['xmin']))
print("The xmax: " + str(decoded['extent']['xmax']))
print("The ymin: " + str(decoded['extent']['ymin']))
print("The ymax: " + str(decoded['extent']['ymax']))
print("The fields in this layer: ")
for rslt in decoded['fields']:
print(rslt['name'])

8. Puede comprobar su trabajo examinando el archivo de solución

C:\ArcpyBook\code\Ch12\ GetLayerInformation.py
9. Guardar el script y ejecutarlo para ver esta salida:
Cómo funciona…
En este procedimiento, pasamos una referencia a una dirección URL que contiene
la ruta de acceso a una capa específica dentro de un servicio de mapas. La capa
se especifica mediante el uso de un número de índice (1, en este caso). Esta URL
se pasa al método requests.get Python ().La respuesta fue devuelto en formato
JSON y luego nos convertido esto en un diccionario de Python. El diccionario incluye
los pares clave/valor para el nombre, extensión y campos de la capa. Esa
información se imprime en la consola.

Exportar un mapa con ArcGIS REST API

y Python

El ArcGIS REST API tiene un amplio conjunto de operaciones que puede utilizar al
solicitar información de una instancia del servidor de ArcGIS. Por ejemplo, puede
exportar los mapas, capas, consulta geocodificar direcciones, y mucho más. En este
procedimiento naprenderá a exportar un mapa a partir de un mapa de imagen
pública.
Preparándose
La operación de exportación puede ser utilizada para crear la imagen de un mapa
de un mapa de servicio. La respuesta a esta solicitud incluye la URL de la imagen,
la anchura, la altura, el alcance y la escala. En esta receta, podrá utilizar la operación
de exportación para exportar un mapa como un archivo de imagen.
Cómo hacerlo...
1. En el entorno de desarrollo de Python, crear un nuevo script, guardar como:
C:\ArcpyBook\Ch12\ExportMapToImage.py.
2. Importe los modulos requests y json
import requests
import json
3. Crear una nueva variable llamada agisurl, asigne la dirección URL y la operación
de exportación, tal y como se muestra aquí:
import requests
import json
agisurl = http://sampleserver1.arcgisonline.com/ArcGIS/rest/
services/Specialty/ESRI_StateCityHighway_USA/MapServer/export
4. Crear un nuevo objeto de diccionario que contendrá los pares clave / valor
que ayudan a definir la cadena de consulta. Estos son los parámetros que se
pasarán a la operación de exportación:
import requests
import json
agisurl = "http://sampleserver1.arcgisonline.com/ArcGIS/rest/
services/Specialty/ESRI_StateCityHighway_USA/MapServer/export"
payload = { 'bbox':'-115.8,30.4, 85.5,50.5',
'size':'800,600',
'imageSR': '102004',
'format':'gif',
'transparent':'false',
'f': 'pjson'}

5. Llame al método requests.get (), pasando la URL y el diccionario de Python de

parámetros. La respuesta se almacena en una variable llamada r:
import requests
import json
agisurl = "http://sampleserver1.arcgisonline.com/ArcGIS/rest/services/
Specialty/ESRI_StateCityHighway_USA/MapServer/export"
payload = { 'bbox':'-115.8,30.4, 85.5,50.5',
'size':'800,600', '
imageSR': '102004',
'format':'gif',
'transparent':'false',
 'f': 'pjson'}
r = requests.get(agisurl, params=payload)

6. Imprimir el contenido del objeto de respuesta.

import requests
import json
agisurl = "http://sampleserver1.arcgisonline.com/ArcGIS/rest/
services/Specialty/ESRI_StateCityHighway_USA/MapServer/export"
payload = { 'bbox':'-115.8,30.4, 85.5,50.5',
'size':'800,600',
'imageSR': '102004',
'format':'gif',
'transparent':'false',
'f': 'pjson'}
r = requests.get(agisurl, params=payload)
print(r.text
7. Puede comprobar su trabajo examinando el C:\ArcpyBook\code\Ch12\.py
ExportMapToImage archivo de solución.
8. Guardar y ejecutar el script para ver una salida similar a esta:

9. Copiar y pegar la dirección URL del archivo .gif que se generó en la barra de
direcciones del navegador y, a continuación, haga clic en volver en su teclado
para ver el archivo:
Cómo funciona…
La operación de exportación en el ArcGIS API REST puede utilizarse para exportar
un archivo de imagen de un servicio de mapa. Si examina
http://sampleserver1.arcgisonline.com/ArcGIS/rest/
servicios/Especialidades/ESRI_StateCityHighway_EE.UU/MapServer/export, que
hemos utilizado para generar la imagen del mapa en este procedimiento, verá el
término exportar al final de la URL. Esto es lo que desencadena la ejecución de la
operación de exportación. Además, se anexa un cuadro delimitador (mapa),
tamaño, punto de referencia espacial para la imagen y el formato a través de la
variable de carga útil. La solicitud se envía al servidor a través del método
requests.get () que acepta tanto la variable de URL y la carga útil
Consultar un servicio de mapa con ArcGIS

REST API y Python

La operación de query en el ArcGIS API REST realiza una consulta en un servicio

de mapa y devuelve un conjunto de características. El conjunto de características
incluye valores para los campos solicitados por el usuario y también puede devolver
la geometría, si se solicita.
Preparándose
En este procedimiento, se construirá en el primer paso, en el que se genera una
URL mediante el cuadro de diálogo Página de Servicios ArcGIS para generar los
resultados. En este procedimiento, se utilizará la página Servicios del servidor
ArcGIS de cuadro de diálogo para generar una petición de URL que consultado un
mapa de capa de servicio y los resultados devueltos. Ustedes recordarán que la
URL es: http://sampleserver1.
arcgisonline.com/ArcGIS/rest/services/Demographics/ESRI_Census_USA/
MapServer/1/query?text=&geometry=&geometryType=esriGeometryPolygon&in
SR=&spatialRel=esriSpatialRelIntersects&relationParam=&objectIds=&whe
re=STATE_FIPS+%3D+%2748%27+and+CNTY_FIPS+%3D+%27021%27&time=&returnCo
untOnly=false&returnIdsOnly=false&returnGeometry=false&maxAllowableOf
fset=&outSR=&outFields=POP2000%2CPOP2007%2CBLKGRP&f=pjson.
Ahora, vamos a aprender a presentar esta solicitud usando Python

Cómo hacerlo...
1. En IDLE o en otro entorno de desarrollo de Python, crear un nuevo script de
python llamado QueryMapService.py y guárdelo en la carpeta
C:\carpeta\ArcpyBook Ch12.
2. En el explorador, vaya a http://resources.arcgis.com/en/help/ arcgis-rest-
api/index.html#//02r3000000p1000000. . Esta es la página del REST API para la
operación de consulta contra una capa de un mapa de servicio. A medida que
se desplaza hacia abajo en la página de ayuda, usted debería ver los mismos
 parámetros que se generaron utilizando el cuadro de diálogo, tales como
geometry, geometryType, spatialRel inSR, where, y otros.
3. En tu script importa los modulos requests y json

import requests
import json
4. Crear la siguiente variable agisurl. Esto servirá como la base de la URL que hace
referencia a la operación de consulta en el grupo de capas census block
(identificado por un identificador de 1 en la URL) en el servicio de mapas
ESRI_Census_USA:

import requests
import json
agisurl = http://sampleserver1.arcgisonline.com/ArcGIS/rest/services
/Demographics/ESRI_Census_USA/MapServer/1/query
5. Ahora, cree un objeto de diccionario de Python, como se muestra en el siguiente
código. Vamos a dejar de lado algunos de los parámetros que no están definidas
o utilizado en el cuadro de diálogo. Sólo estamos creando un atributo consulta
en esta instancia a fin de que todos los parámetros de geometría pueden ser
eliminados.

import requests
import json
agisurl = "http://sampleserver1.arcgisonline.com/ArcGIS/rest/
services/Demographics/ESRI_Census_USA/MapServer/1/query"
payload = { 'where':'STATE_FIPS = \'48\' and CNTY_FIPS =
\'021\'','returnCountOnly':'false',
'returnIdsOnly': 'false', 'returnGeometry':'false',
'outFields':'POP2000,POP2007,BLKGRP',
'f': 'pjson'}
6. El método requests.get () puede aceptar un objeto de diccionario Python como
el segundo parámetro. Este diccionario define el conjunto de pares clave / valor
que ayudan a definir la cadena de consulta. Añadir el método requests.get ()

import requests
import json
agisurl = "http://sampleserver1.arcgisonline.com/ArcGIS/rest/
services/Demographics/ESRI_Census_USA/MapServer/1/query"
payload = { 'where':'STATE_FIPS = \'48\' and CNTY_FIPS =
\'021\'','returnCountOnly':'false', \
'returnIdsOnly': 'false', 'returnGeometry':'false', \
'outFields':'POP2000,POP2007,BLKGRP', \
 'f': 'pjson'}
r = requests.get(agisurl, params=payload)
7. Incluir una instrucción print para imprimir la respuesta que se devuelve.

import requests, json

agisurl = "http://sampleserver1.arcgisonline.com/ArcGIS/rest/
services/Demographics/ESRI_Census_USA/MapServer/1/query"
payload = { 'where':'STATE_FIPS = \'48\' and CNTY_FIPS =
\'021\'','returnCountOnly':'false', \
'returnIdsOnly': 'false', 'returnGeometry':'false', \
'outFields':'POP2000,POP2007,BLKGRP', \
'f': 'pjson'}
r = requests.get(agisurl, params=payload)
print(r.text)
8. Guardar el script y ejecútelo para ver esta salida:

9. Ahora, convertir este objeto JSON a un diccionario de Python. Además, comente

la instrucción print que agregó en el paso anterior:

r = requests.get(agisurl, params=payload)
#print(r.text)
decoded = json.loads(r.text)
10. El diccionario de objetos Python devuelto por los json.loads () contendrá el
contenido del objeto JSON. A continuación, puede eliminar de los elementos de
datos individuales fuera del diccionario. En este caso, queremos sacar los
atributos de cada una de las característica que se devuelve (BLKGRP, POP
POP2007 y2000). Podemos hacerlo utilizando el siguiente código, que tendrás
que añadir a su script:

r = requests.get(agisurl, params=payload)
#print(r.text)
decoded = json.loads(r.text)
for rslt in decoded['features']:
print("Block Group: " + str(rslt['attributes']['BLKGRP']))
print("Population 2000: " + str(rslt['attributes']['POP2000']))
print("Population 2007: " + str(rslt['attributes']['POP2007']))

11. Puede comprobar su trabajo examinando el archivo de solución

C:\ArcpyBook\code\Ch12\.py QueryMapService
12. Guardar y ejecutar el script para ver estos resultados:

Cómo funciona…
La operación de consulta en el resto de ArcGIS API se puede utilizar para realizar
consultas espaciales y atributo contra una capa de un servicio de mapas en ArcGIS
Server. Se utilizó el método requests.get () para realizar una consulta de atributos
contra la capa del census block groups. Hemos incluido varios parámetros,
incluyendo una cláusula where que devolverá sólo los registros en los que el
ST_código FIPS es 48 y el código FIPS Cnty_021 (el condado de Bexar, Texas). El
objeto Response se convirtió entonces a un diccionario de Python y hemos incluido
un bucle for para iterar a través de todos los registros devueltos e imprimir el bloque
nombre de grupo, y de la población para los años 2000 y 2007.

Geocodificación con el Servicio Mundial de codificación

geográfica Esri

El servicio de codificación geográfica Mundial Esri se puede utilizar para encontrar

direcciones y lugares en los países compatibles. Este servicio contiene ambas
operaciones gratuitas o de pago. La operación de búsqueda, que encuentra una
dirección por solicitud, siempre es un servicio gratuito. La operación
geocodeAddresses acepta una lista de direcciones de geocodificación y es sólo un
servicio de pago. Las otras operaciones pueden ser gratuito o de pago. Si usted
está usando las operaciones en una capacidad temporal, son libres. Temporal
significa simplemente que no va a almacenar los resultados para su uso posterior.
Si este es el caso, entonces se trata de un servicio de pago. En este procedimiento,
que va a utilizar el servicio de codificación geográfica Esri Mundial de la
geocodificación de una dirección.

Preparándose
La operación find de REST API de ArcGIS puede ser usado para encontrar las
coordenadas geográficas de una sola dirección. Como lo hemos hecho en los
últimos procedimientos, vamos a utilizar el módulo requests de Python para hacer
el proceso de solicitud y la respuesta.

Cómo hacerlo...
1. En IDLE o en otro entorno de desarrollo de Python, crear un nuevo script de
python llamado GeocodeAddress.py y guárdelo en la carpeta
C:\carpeta\ArcpyBook Ch12.

2. Importe los modulos requests y json

 import requests
import json
3. Crear la siguiente variable agisurl. Este apuntará al servicio de codificación
geográfica Esri Mundial y la operación de búsqueda para un servicio particular.
También, definir un diccionario de Python que llevará a cabo la dirección de que
se presenten y el formato de salida. Puede cambiar la dirección, si lo desea:
import requests
import json
agisurl = "http://geocode.arcgis.com/arcgis/rest/services/World/ GeocodeServer/find"
payload = { 'text': '1202 Sand Wedge, San Antonio, TX, 78258','f':'pjson'}

4. Llamar al método requests.get () y pasar la URL y parámetros. La respuesta se

almacena en una variable llamada r. A continuación, convertir el objeto JSON
devuelto a un diccionario de Python:

import requests
import json
agisurl = "http://geocode.arcgis.com/arcgis/rest/services/World/
GeocodeServer/find"
payload = { 'text': '1202 Sand Wedge, San Antonio, TX, 78258','f':'pjson'}
r = requests.get(agisurl, params=payload)
decoded = json.loads(r.text)
5. Imprimir algunos de los resultados:

import requests
import json
agisurl = "http://geocode.arcgis.com/arcgis/rest/services/World/ GeocodeServer/find"
payload = { 'text': '1202 Sand Wedge, San Antonio, TX, 78258','f':'pjson'}
r = requests.get(agisurl, params=payload)
decoded = json.loads(r.text)

print("The geocoded address: " + decoded['locations'][0]['name'])

print("The longitude: " + str(decoded['locations'][0]['feature'] ['geometry']['x']))
print("The lattitude: " + str(decoded['locations'][0]['feature'] ['geometry']['y']))
print("The geocode score: " + str(decoded['locations'][0]['feature']['attributes'] ['Score']))
print("The address type: " + str(decoded['locations'][0]['feature']['attributes']
['Addr_Type']))

6. Puede comprobar su trabajo examinando el archivo de solución

C:\ArcpyBook\code\Ch12\.py QueryMapService
7. Guardar el script y ejecútalo para ver la siguiente salida:
 The geocoded address: 1202 Sand Wedge, San Antonio, Texas, 78258
The longitude: -98.4744442811
The lattitude: 29.6618639681
The geocode score: 100
The address type: PointAddress

Cómo funciona…
La operación de búsqueda en el ArcGIS API REST puede ser utilizada para realizar
las operaciones de geocodificación de una sola dirección. Como lo hemos hecho en
los últimos procedimientos, se utilizó el método requests.get Python () para
presentar una solicitud de operación (encontrar, en este caso) a lo largo de
parámetros que incluyen la dirección que se debe geocodificar. La respuesta que
se había devuelto incluye la latitud y la longitud de la dirección geocodificada, la
puntuación y el tipo de dirección.

Utilizando FieldMap y FieldMappings

Hasta este punto en el capítulo, hemos visto cómo utilizar Python con ArcGIS API
REST para acceder a los servicios de ArcGIS Server. Ahora, vamos a cambiar las
marchas y volver a entrar en el módulo ArcPy y discutir las clases FieldMap y
FieldMappings.

Preparándose
Una operación de SIG común es combinar varios conjuntos de datos dispares en
un solo conjunto de datos de un área mayor. A menudo, los campos de las bases
de datos que se combinarán serán las mismas y no habrá ningún problema. Sin
embargo, habrá momentos en los campos de los diferentes conjuntos de datos no
coinciden. En este caso, deberá asignar la relación entre los campos en un conjunto
de datos a los campos en otro conjunto de datos.
 ArcGIS Tools
FieldMap FieldMappings
(Merge)

El diagrama anterior muestra la relación entre las diversas clases que son ArcPy se
utiliza para definir la asignación de campos. Un objeto FieldMap contiene una
definición de campo y una lista de campos de entrada de una o más tablas o clases
de características que proporcionan los valores para el campo. Cada objeto que
cree FieldMap se agrega a un objeto FieldMappings, que sirve como un contenedor
para estos objetos. Por último, el objeto FieldMappings puede entonces ser enviada
como entrada a diversas herramientas de geoprocesamiento, tales como la
herramienta de combinación.

Cómo hacerlo...
En este ejercicio, aprenderá como utilizar los objetos de FieldMappings y FieldMap:

1. En IDLE o en otro entorno de desarrollo de Python, crear un nuevo script de

python llamado GeocodeAddress.py y guárdelo en la carpeta
C:\carpeta\ArcpyBook Ch12.

2. Importe arcpy
import arcpy
3. Establezca la variable de entorno de trabajo y una variable que apunte a la clase
de función de salida:

arcpy.env.workspace = r"c:\ArcpyBook\data"
outFeatureClass = r"c:\ArcpyBook\data\AllTracts.shp"
4. Crear un objeto FieldMappings y tres objetos FieldMap. Los objetos FieldMap
tendrá referencias a campos para un Estado Federal Information Processing
Standard (FIPS), condado de código código FIPS y una zona:

arcpy.env.workspace = r"c:\ArcyBook\data"
outFeatureClass = r"c:\ArcpyBook\data\AllTracts.shp"
fieldmappings = arcpy.FieldMappings()
fldmap_STFIPS = arcpy.FieldMap()
fldmap_COFIPS = arcpy.FieldMap()
fldmap_TRACT = arcpy.FieldMap()

5. Obtener una lista de todas las clases de características de polígono del condado
en el área de trabajo actual. Cada clase de entidad County tiene un campo
llamado STFID, que contiene el código de estado FIPS, condado código FIPS, y
un sitio para cada característica. Esta información se almacena como una larga
cadena (48491020301, por ejemplo), donde los dos primeros caracteres son el
código de estado, el tercero a quinto caracteres son el código del condado, y los
caracteres restantes son las vías. Como parte de la operación de fusión, vamos
a tirar de cada uno de los elementos individuales y guardarlos en distintos
campos:

fieldmappings = arcpy.FieldMappings()
fieldmap_STFIPS = arcpy.FieldMap ()
fieldmap_COFIPS = arcpy.FieldMap ()
fieldmap_TRACT = arcpy.FieldMap ()
#List all feature classes that start with 'County' and type Polygon
fclss = arcpy.ListFeatureClasses("County*", "Polygon")
6. Crear un objeto ValueTable para mantener las clases de entidad que se van a
fusionar. ValueTable funciona como un contenedor de objetos. Contendrá la
información de asignación para cada una de las clases de características en el
área de trabajo. Toda la información se extrae de un único campo (STFID), pero
tenemos que crear campos de entrada separadas para FieldMap
STFIPS, COFIPS y tracto:

fclss = arcpy.ListFeatureClasses("County*", "Polygon")

vTab = arcpy.ValueTable()
for fc in fclss:
fieldmappings.addTable(fc)
 fldmap_STFIPS.addInputField(fc, "STFID")
fldmap_COFIPS.addInputField(fc, "STFID")
fldmap_TRACT.addInputField(fc, "STFID")
vTab.addRow(fc)

7. Agrega el contenido del campo STFIPS. Utilizamos la startTextPosition() para

sacar los dos primeros caracteres de la columna STFID. La primera posición es
0, por lo que necesitamos utilizar setStartTextPosition(x,0). En este paso,
también podemos definir el campo de salida para el objeto FieldMap STFIPS, el
nombre del campo, y definir el nombre del campo de salida:

vTab = arcpy.ValueTable()
for fc in fclss:
fieldmappings.addTable(fc)
fldmap_STFIPS.addInputField(fc, "STFID")
fldmap_COFIPS.addInputField(fc, "STFID")
fldmap_TRACT.addInputField(fc, "STFID")
vTab.addRow(fc)
# STFIPS field
for x in range(0, fldmap_STFIPS.inputFieldCount):
fldmap_STFIPS.setStartTextPosition(x, 0)
fldmap_STFIPS.setEndTextPosition(x, 1)
fld_STFIPS = fldmap_STFIPS.outputField
fld_STFIPS.name = "STFIPS"
fldmap_STFIPS.outputField = fld_STFIPS
8. Añadir contenido para el campo COFIPS. La posición de estos tres caracteres
es 2-4 de la cadena se retiró de la columna de la STFID:
# STFIPS field
for x in range(0, fldmap_STFIPS.inputFieldCount):
fldmap_STFIPS.setStartTextPosition(x, 0)
fldmap_STFIPS.setEndTextPosition(x, 1)
fld_STFIPS = fldmap_STFIPS.outputField
fld_STFIPS.name = "STFIPS"
fldmap_STFIPS.outputField = fld_STFIPS
# COFIPS field
for x in range(0, fldmap_COFIPS.inputFieldCount):
fldmap_COFIPS.setStartTextPosition(x, 2)
fldmap_COFIPS.setEndTextPosition(x, 4)
fld_COFIPS = fldmap_COFIPS.outputField
fld_COFIPS.name = "COFIPS"
fldmap_COFIPS.outputField = fld_COFIPS

9. Añadir contenido para el campo TRACT

 # COFIPS field
for x in range(0, fldmap_COFIPS.inputFieldCount):
fldmap_COFIPS.setStartTextPosition(x, 2)
fldmap_COFIPS.setEndTextPosition(x, 4)
fld_COFIPS = fldmap_COFIPS.outputField
fld_STFIPS.name = "COFIPS"
fldmap_COFIPS.outputField = fld_COFIPS
# TRACT field
for x in range(0, fldmap_TRACT.inputFieldCount):
fldmap_TRACT.setStartTextPosition(x, 5)
fldmap_TRACT.setEndTextPosition(x, 12)
fld_TRACT = fldmap_TRACT.outputField
fld_TRACT.name = "TRACT"
fldmap_TRACT.outputField = fld_TRACT

10. Agregar el FieldMap objetos al objeto FieldMappings:

for x in range(0, fldmap_TRACT.inputFieldCount):
fldmap_TRACT.setStartTextPosition(x, 5)
fldmap_TRACT.setEndTextPosition(x, 12)
fld_TRACT = fldmap_TRACT.outputField
fld_TRACT.name = "TRACT"
fldmap_TRACT.outputField = fld_TRACT
#Add fieldmaps into the fieldmappings objec
fieldmappings.addFieldMap(fldmap_STFIPS)
fieldmappings.addFieldMap(fldmap_COFIPS)
fieldmappings.addFieldMap(fldmap_TRACT)

11. Ejecutar la herramienta de mezcla, que pasa en el VTAB, clase de entidad de

salida, y FieldMappings objeto

#Add fieldmaps into the fieldmappings objec

fieldmappings.addFieldMap(fldmap_STFIPS)
fieldmappings.addFieldMap(fldmap_COFIPS)
fieldmappings.addFieldMap(fldmap_TRACT)

arcpy.Merge_management(vTab, outFeatureClass,fieldmappings)
print("Merge completed")

12. Toda la secuencia de comandos debe aparecer como sigue:

import arcpy
Arcpy.env.workspace = r"c:\ArcyBook\data"
outFeatureClass = r"c:\ArcpyBook\data\AllTracts.shp"

fieldmappings = arcpy.FieldMappings()
fldmap_STFIPS = arcpy.FieldMap()
fldmap_COFIPS = arcpy.FieldMap()
fldmap_TRACT = arcpy.FieldMap()

#List all feature classes that start with 'County' and type Polygon
fclss = arcpy.ListFeatureClasses("County*", "Polygon")

vTab = arcpy.ValueTable()
for fc in fclss:
fieldmappings.addTable(fc)
fldmap_STFIPS.addInputField(fc, "STFID")

fldmap_COFIPS.addInputField(fc, "STFID")
fldmap_TRACT.addInputField(fc, "STFID")
vTab.addRow(fc)

# STFIPS field
for x in range(0, fldmap_STFIPS.inputFieldCount):
fldmap_STFIPS.setStartTextPosition(x, 0)
fldmap_STFIPS.setEndTextPosition(x, 1)

fld_STFIPS = fldmap_STFIPS.outputField
fld_STFIPS.name = "STFIPS"
fldmap_STFIPS.outputField = fld_STFIPS

# COFIPS field
for x in range(0, fldmap_COFIPS.inputFieldCount):
fldmap_COFIPS.setStartTextPosition(x, 2)
fldmap_COFIPS.setEndTextPosition(x, 4)

fld_COFIPS = fldmap_COFIPS.outputField
fld_COFIPS.name = "COFIPS"
fldmap_COFIPS.outputField = fld_COFIPS

# TRACT field
for x in range(0, fldmap_TRACT.inputFieldCount):
fldmap_TRACT.setStartTextPosition(x, 5)
 fldmap_TRACT.setEndTextPosition(x, 12)

fld_TRACT = fldmap_TRACT.outputField
fld_TRACT.name = "TRACT"
fldmap_TRACT.outputField = fld_TRACT

#Add fieldmaps into the fieldmappings objec

fieldmappings.addFieldMap(fldmap_STFIPS)
fieldmappings.addFieldMap(fldmap_COFIPS)
fieldmappings.addFieldMap(fldmap_TRACT)

arcpy.Merge_management(vTab, outFeatureClass,fieldmappings)
print("Merge completed")

13. Puede comprobar su trabajo examinando el archivo de solución

C:\ArcpyBook\code\Ch12\.py QueryMapService
14. Guardar el script y ejecútalo
15. En ArcMap, agregue el archivo All_Tracts.shp que fue creado como resultado
de la secuencia de comandos. Debería ver un conjunto combinado de los
condados y si se abre la tabla de atributos, podrás ver los nuevos campos que
se crearon, así como los campos originales:

16. En la vista de datos para el All Tracts.shapefile, hora debería ver una sola capa
de polígonos combinadas, como se ve en la captura de pantalla siguiente:
Cómo funciona…
Los objetos FieldMap y FieldMappings en el módulo ArcPy junto con la herramienta
de combinación, pueden ser utilizados para operaciones de SIG que necesitan para
combinar conjuntos de datos que tienen campos que no coinciden. El objeto field
map también puede utilizarse cuando se necesita sacar una secuencia contigua de
valores de cadena a partir de un conjunto de valores de cadena larga. En esta
receta, aprendió a utilizar el objeto FieldMap para tirar el estado, condado y la
información del censo de un solo campo. Hemos creado objetos FieldMap
individuales para mantener esta información y, luego, agregarlos a un objeto
FieldMappings que pasó luego en la herramienta de combinación para crear una
capa nueva, que contiene tres campos que contienen esta información.
Utilizando un ValueTable para proporcionar a una
herramienta de entrada

de multivalores

Muchas herramientas de geoprocesamiento tienen parámetros de entrada que

aceptan más de un valor. Por ejemplo, la herramienta multring buffer acepta varias
distancias de separación, la herramienta de borrado de campo acepta varios
campos que se pueden eliminar, y hay muchos otros ejemplos. En este
procedimiento, usted aprenderá cómo crear un objeto ValueTable que sirve como
una herramienta de entrada de multivalores.

Preparándose
Existen tres maneras de especificar un parámetro multivalores: como una lista de
Python, una cadena con cada valor separado por un punto y coma, o un objeto
ValueTable ArcPy. En este procedimiento, vamos a echar un vistazo a cómo
especificar parámetros de entrada mutlivalue mediante ValueTable.

Cómo hacerlo...
Siga estos pasos para aprender a utilizar un ValueTable para enviar múltiples
valores a una herramienta:

1. Abra inactivo (o su entorno de desarrollo Python favorito) y crear un nuevo script

llamado ValueTable.py.
2. Importar Arcpy y establecer el espacio de trabajo:
import arcpy
arcpy.env.workspace = r"c:\ArcyBook\data"

3. Crear un nuevo objeto ValueTable:

import arcpy
arcpy.env.workspace = r"c:\ArcyBook\data"
vTab = arcpy.ValueTable()
4. Crear tres filas de la tabla y asignarles distancias de 5, 10 y 20:

vTab = arcpy.ValueTable()
vTab.setRow(0, "5")
vTab.setRow(1, "10")
vTab.setRow(2, "20")
5. Definir variables para las unidades de la clase de entidad de entrada, la clase de
entidad de salida, distancia, y de amortiguamiento. La variable distancia (dist) se
crea como una referencia a la ValueTable, que ya ha creado:

vTab = arcpy.ValueTable()
vTab.setRow(0, "5")
vTab.setRow(1, "10")
vTab.setRow(2, "20")

inFeature = 'Hospitals.shp'
outFeature = 'HospitalMBuff.shp'
dist = vTab
bufferUnit = "meters"

6. Llamar la herramienta MultipleRingBuffer y pasar las variables como parámetros:

inFeature = 'Hospitals.shp'
outFeature = 'HospitalMBuff.shp'
dist = vTab
bufferUnit = "meters"

arcpy.MultipleRingBuffer_analysis(inFeature,
outFeature, dist, bufferUnit, '', 'ALL')
print("Multi-Ring Buffer Complete")

7. Puede comprobar su trabajo examinando el archivo de solución de ValueTable

C:\ArcpyBook\code\Ch12\.py

8. Guardar y ejecutar el script. Examine la salida para ver los múltiples anillos de
búfer.
Como hacerlo…
ValueTable es una sencilla tabla virtual que se puede utilizar como entrada a
herramientas que acepta varios valores. En este procedimiento, hemos creado un
objeto ValueTable, añadió tres valores, y a continuación, se pasa este objeto en la
herramienta MultipleRingBuffer. La herramienta MultipleRingBuffer utiliza esta
información para crear nuevas capas de polígono basado en el búfer ValueTable
distancias proporcionados en el objeto.
 B Cinco procedimientos de
Python
Que cada programador de SIG
Debe de conocer
En este capítulo, trataremos los siguientes temas:

 Lectura de datos desde un archivo de texto delimitado

 Envío de e-mails
 Recuperando archivos desde un servidor FTP
 Creación de archivos ZIP
 Lectura de archivos XML

Introducción
En este capítulo, aprenderá a escribir scripts que realizan tareas de propósito
general con Python. Tareas, tales como lectura y escritura de archivos de texto
delimitados, envío de e-mails, interactuar con servidores FTP, crear archivos .zip,
y la lectura y escritura de archivos XML y JSON, son comunes. Cada programador
SIG debe saber cómo escribir secuencias de comandos Python que incorporar
estas funcionalidades.

Lectura de datos desde un archivo de texto delimitado

Manejo de archivos con Python es un tema muy importante para los programadores
de SIG. Archivos de texto han sido utilizados como formato de intercambio para el
intercambio de datos entre sistemas. Son simples, multiplataforma, y fácil de
procesar. Comma y archivos de texto delimitados por tabulaciones, son algunos de
los formatos más utilizados para los archivos de texto, por lo que echaremos un
vistazo a la extensa Python herramientas disponibles para procesar estos archivos.
Una tarea común para los programadores de SIG es para leer archivos de texto
delimitado por comas que contenga las coordenadas x e y, junto con otra
información de atributos. A continuación, esta información se convierte en formatos
de datos GIS, como shapefiles o geodatabases.

Preparándose
Para utilizar la funcionalidad de procesamiento de archivos integrado de Python,
primero debe abrir el archivo. Una vez abiertos, los datos dentro del archivo se
procesa utilizando funciones proporcionadas por Python, y, finalmente, se cierra el
archivo.

Siempre recuerde que debe cerrar el archivo cuando haya terminado. Python
no significa necesariamente cerrar los archivos para usted, por lo que es
posible que usted podría quedarse sin recursos o sobrescribir alguna cosa.
Además, algunas plataformas de sistemas operativos no lo dejaran abrir el
mismo archivo al mismo tiempo para acceso de sólo lectura y fines de escritura.

En este procedimiento aprenderá a abrir, leer y procesar un archivo de texto

delimitado por comas.

Cómo hacerlo
Siga estos pasos para crear un script de Python que lee un archivo de texto
delimitado por comas:

1. En su C:\carpeta\datos ArcpyBook, encontrará un archivo llamado N_America.

A2007275.txt. Abra este archivo en un editor de texto. Debería aparecer como
sigue:

18.102,-94.353,310.7,1.3,1.1,10/02/2007,0420,T,72
19.300,-89.925,313.6,1.1,1.0,10/02/2007,0420,T,82
19.310,-89.927,309.9,1.1,1.0,10/02/2007,0420,T,68
26.888,-101.421,307.3,2.7,1.6,10/02/2007,0425,T,53
 26.879,-101.425,306.4,2.7,1.6,10/02/2007,0425,T,45
36.915,-97.132,342.4,1.0,1.0,10/02/2007,0425,T,100

Este archivo contiene datos relacionados con los incidentes de incendios

forestales que era derivada de un sensor de satélite desde un solo día en
2007. Cada fila contiene información de latitud y longitud para el fuego a lo
largo con información adicional, incluyendo la fecha y hora, por satélite tipo,
valor de confianza, y otros detalles. En este procedimiento, que está va a
mover solamente la latitud, la longitud y valor de la confianza. El primer
elemento contiene la latitud, la segunda contiene longitud, y el valor final
contiene el valor de la confianza.

2. Abra IDLE y cree un archivo llamado C:\ArcpyBook\Appendix2\

ReadDelimitedTextFile.py.

3. Utilice la función open() de Python para abrir el archivo para lectura:

f=open("c:/ArcpyBook/data/N_America.A2007275.txt','r')
4. Agregar un bucle for para iterar todas las filas:
for fire in f:
5. Utilice la función split () para dividir los valores en una lista, usando una coma
como delimitador. La lista se asigna a una variable llamada lstValues.
Asegúrese de que usted identifique esta línea de código dentro del bucle for
que acaba de crear
lstValues = fire.split(",")

6. Utilizando los valores de los índices que hacen referencia a la latitud, la

longitud y valores de confianza, crear nuevas variables:
latitude = float(lstValues[0])
longitude = float(lstValues[1])
confid = int(lstValues[8])

7. Imprimir los valores de cada una de ellas con la instrucción print:

print("The latitude is: " + str(latitude) + " The longitude is: " + str(longitude) + " The
confidence value is: " + str(confid))
 8. Cerrar el archivo:

f.close()

9. Todo el script debe aparecer como sigue:

F=open('c:/ArcpyBook/data/N_America.A2007275.txt'
,'r')

for fire in f:

lstValues = fire.split(',')

latitude = float(lstValues[0])

longitude = float(lstValues[1])

confid = int(lstValues[8])

print("The latitude is: " + str(latitude) + " The

longitude is: " + str(longitude) + " The confidence
value is: " + str(confid))

f.close()

10. Puede comprobar su trabajo examinando el

C:\ArcpyBook\code\Appendix2\ ReadDelimitedTextFile.py solution file.

11. Guardar y ejecutar el script. Debería ver la siguiente salida:

The latitude is: 18.102 The longitude is: -94.353 The confidence value is: 72
The latitude is: 19.3 The longitude is: -89.925 The confidence value is: 82
The latitude is: 19.31 The longitude is: -89.927 The confidence value is: 68
The latitude is: 26.888 The longitude is: -101.421 The confidence value is: 53
The latitude is: 26.879 The longitude is: -101.425 The confidence value is: 45
The latitude is: 36.915 The longitude is: -97.132 The confidence value is: 100

Cómo funciona...
Python's open() crea un objeto file, que sirve como un vínculo a un archivo que
resida en su ordenador. Usted debe llamar a la función open() sobre un archivo
antes de leer o escribir datos en un archivo. El primer parámetro de la función open()
es la ruta de acceso al archivo que desea abrir. El segundo parámetro de la función
open() corresponde a un modo, que normalmente es de lectura (r), escritura (w), o
añadir (a). Un valor de r indica que le gustaría abrir el archivo para operaciones de
sólo lectura, mientras que un valor de w indica que le gustaría abrir el archivo para
operaciones de escritura. Si el archivo se abre en modo de escritura ya existe, se
sobrescribirán los datos existentes en el archivo, así que debe tener cuidado al
utilizar este modo. Append (a) el modo de abrir un archivo para operaciones de
escritura, pero, en lugar de sobrescribir todos los datos, añadir datos al final del
archivo. Así, en esta receta, hemos abierto la N_America.A2007275.txt que se
encuentra en modo de sólo lectura. Dentro del bucle for, que se utiliza para recorrer
cada uno de los valores en el archivo de texto una línea a la vez, la función split()
se utiliza para crear un objeto de lista a partir de una línea de texto que está
delimitado de alguna manera. Nuestro archivo está delimitado por comas, así que
podemos usar split(","). También puede dividir basados en otros delimitadores como
tabulaciones, espacios o cualquier otro delimitador. Este nuevo objeto de lista
creada por split() se almacena en una variable denominada lstValues. Esta variable
contiene los valores de cada uno de los incendios forestales. Esto se muestra en la
siguiente captura de pantalla. Usted notará que la latitud se encuentra en la primera
posición, longitud está situado en la segunda posición, y así sucesivamente. Las
listas se basan en cero:

Utilizando los valores de índice (que hace referencia a la latitud, la longitud y valores
de confianza), debemos crear nuevas variables llamado latitud, longitud y confid.
Por último, podemos imprimir cada uno de los valores.

Una forma más sólida de geoprocesamiento script podría escribir esta información
en una clase de función utilizando un objeto InsertCursor. Realmente lo hicimos esto
en proceso anterior en Capítulo 8, Usando el módulo de acceso a datos ArcPy con
clases de características y tablas.

Sería posible utilizar los readlines () para leer todo el contenido del archivo en una
lista de Python, que luego podría ser iterado. Cada fila del archivo de texto será de
un valor único en la lista. Dado que esta función lee todo el archivo en una lista, es
necesario utilizar este método con precaución, ya que los archivos grandes pueden
causar problemas de rendimiento significativas.

Hay más...
Similar a las instancias de lectura de archivos, existen varios métodos que puede
utilizar para escribir datos en un archivo. La función write () es probablemente el
más fácil de usar. Toma un único argumento de cadena y lo escribe en un archivo.
La writelines () puede ser usada para escribir el contenido de una estructura de la
lista a un archivo. Antes de escribir datos en un archivo de texto, tendrá que abrir el
archivo en modo escritura o anexar.

Envío de e-mails
Habrá ocasiones en que necesite enviar un e-mail desde un script de Python. Un
ejemplo de esto podría ser una alerta para la culminación exitosa o errores
incurridos en una larga operación de geoprocesamiento. Sobre éstas y otras
ocasiones, enviando un e-mail puede ser útil.

Preparándose
El envío de un e-mail a través de un script de Python requerirá que usted tenga
acceso a un servidor de correo. Este puede ser un servicio de correo electrónico
público, tales como Yahoo, Gmail o otros. También puede utilizar servidores de
correo saliente que está configurado con aplicaciones como Microsoft Outlook. En
cualquier caso, necesitará saber el nombre del host y el puerto del servidor de
correo electrónico. El modulo smtplib Python es utilizado para crear conexiones con
el servidor de correo y enviar e-mails. El módulo de correo electrónico Python
contiene una clase de mensaje que representa mensajes de correo electrónico.
Cada mensaje contiene los encabezados y un cuerpo. Esta clase no se puede
utilizar para enviar mensajes de correo electrónico, sólo se ocupa de la
representación de objetos. En este procedimiento, usted aprenderá cómo utilizar la
clase SMTP para enviar correos electrónicos que contienen un archivo adjunto a
través de su escritura. La clase de mensaje puede analizar una secuencia de
caracteres o un archivo que contiene un correo electrónico utilizando ya sea el ()
funciones message_from_file () o message_from_string. Ambos crearán un nuevo
objeto del mensaje. El cuerpo del mensaje puede ser obtenida llamando
Message.getpayload ().

Estamos utilizando el servicio de correo de Google para este ejercicio. Si ya

tiene una cuenta de Gmail, entonces simplemente proporcionar su nombre de
usuario y contraseña según los valores de estas variables. Si no tienes una
cuenta de Gmail, tendrás que crear uno o utilizar un servicio de correo
diferente para completar este ejercicio. Las cuentas de Gmail son gratuitos.
Google puede bloquear los intentos de enviar un e-mail a través de
secuencias de comandos, por lo que ser conscientes de que esto no funcione
como se espera si está utilizando Gmail.

Cómo hacerlo...
Siga estos pasos para crear un script que puede enviar e-mails:

1. Abra IDLE y cree un archivo llamado

C:\ArcpyBook\Apéndice2\SendEmail.py.
2. A fin de enviar e-mails con archivos adjuntos, vas a necesitar importar el
módulo smtplib junto con el módulo de os, y varias clases del módulo de
correo electrónico. Agregue las siguientes declaraciones de importación a
su script:
import smtplib
from email.MIMEMultipart import MIMEMultipart
from email.MIMEBase import MIMEBase
from email.MIMEText import MIMEText
from email import Encoders
import os
3. Crear las siguientes variables y asignar su nombre de usuario y contraseña
de Gmail como los valores. Tenga en cuenta que este método de envío por
 correo electrónico desde el script de Python puede invitar a los problemas,
ya que requiere que incluya su nombre de usuario y contraseña:
gmail_user = "<username>"
gmail_pwd = "<password>"

Tenga en cuenta que la inclusión de un nombre de usuario de correo

electrónico y contraseña en una secuencia de comandos no es segura
para que no desee incluir estos en una secuencia de comandos de
producción. Hay formas de encriptación de éstos valores, sino que está
más allá del alcance de este procedimiento

4. Crear una nueva función llamada Python mail(). Esta función acepta cuatro
parámetros: Para, Asunto, texto y adjuntar. Cada uno de estos parámetros
debe explicarse por sí mismo. Crear un nuevo objeto MimeMultipart y signar la
De, Para y Asunto claves. También puede adjuntar el texto del e-mail a este
nuevo objeto usando MIMEMultipart msg.attach():

def mail(to, subject, text, attach):

msg = MIMEMultipart()

msg['From'] = gmail_user

msg['To'] = to

msg['Subject'] = subject

msg.attach(MIMEText(text))

5. Adjunte el archivo a la dirección de e-mail:

part = MIMEBase('application', 'octet-stream')

part.set_payload(open(attach, 'rb').read())
Encoders.encode_base64(part)
part.add_header('Content-Disposition',
'attachment; filename="%s"' % os.path.basename(attach))
msg.attach(part)
 6. Crear un nuevo objeto SMTP que hace referencia al servicio de correo de
Google, pasa el nombre de usuario y contraseña para conectarse a los
servicios de correo electrónico, envía el correo electrónico, y cierra la conexión:

mailServer = smtplib.SMTP("smtp.gmail.com", 587)

mailServer.ehlo()
mailServer.starttls()
mailServer.ehlo()
mailServer.login(gmail_user, gmail_pwd)
mailServer.sendmail(gmail_user, to, msg.as_string())
mailServer.close()

7. Llame a la función mail(), pasando el destinatario del e-mail, un asunto para

el correo electrónico, el texto del correo electrónico y el archivo adjunto.

mail("<email to send to>",

"Hello from python!",
"This is an email sent with python",
"c:/ArcpyBook/data/bc_pop1996.csv")

8. Toda la secuencia de comandos debe aparecer como sigue: importar

smtplib

import smtplib
from email.MIMEMultipart import MIMEMultipart
from email.MIMEBase import MIMEBase
from email.MIMEText import MIMEText
from email import Encoders
import os

gmail_user = "<janediazlop>"
gmail_pwd = "<yesenialop>"

def mail(to, subject, text, attach):

msg = MIMEMultipart()

msg['From'] = gmail_user
msg['To'] = to
msg['Subject'] = subject
 msg.attach(MIMEText(text))

part = MIMEBase('application', 'octet-stream')

part.set_payload(open(attach,'rb').read())
Encoders.encode_base64(part)
part.add_header('Content-Disposition','attachment; filename="%s"' %
os.path.basename(attach))
msg.attach(part)

mailServer = smtplib.SMTP("smtp.gmail.com", 587)

mailServer.ehlo()
mailServer.starttls()
mailServer.ehlo()
mailServer.login(gmail_user, gmail_pwd)
mailServer.sendmail(gmail_user, to, msg.as_string())
mailServer.close()

mail("<janediazlop@gmail.com>","Hello from python!","This is an email sent with

python","C:/ArcpyBook/data/bc_pop1996.csv")

9. Puede comprobar su trabajo examinando el

C:\ArcpyBook\código\Apéndice2\ SendEmail.py archivo de solución.

10. Guardar y ejecutar el script. Para las pruebas, he usado mi cuenta de

Yahoo, como el destinatario. Usted notará que a mi bandeja de entrada tiene
un nuevo mensaje desde mi cuenta de Gmail; además, observe el archivo
adjunto:

Cómo funciona...
El primer parámetro que se pasa a la función mail() es la dirección de correo
electrónico que recibirá el correo electrónico. Esto puede ser cualquier dirección de
correo electrónico válida, pero usted desea proporcionar una cuenta de correo
electrónico que usted realmente puede controlar, de modo que puede asegurarse
de que su script se ejecuta correctamente. El segundo parámetro es sólo la línea
de asunto del correo electrónico. El tercer parámetro es el texto. El último parámetro
es el nombre de un archivo que se adjunta al correo electrónico. Aquí, simplemente
he definido que el bc_pop1996.csv debe estar conectado. Puede utilizar cualquier
archivo que tiene acceso, pero puede que sólo desee utilizar este archivo para
realizar pruebas. Entonces creamos un nuevo objeto MIMEMultipart dentro de la
función mail() y asignar la De, Para y Asunto claves. También puede adjuntar el
texto del e-mail a este nuevo objeto usando MIMEMultipart msg.attach(). El
bc_pop1996.csv se adjunta a un mensaje de correo electrónico usando un objeto
MIMEBase y adjunto a la dirección de e-mail usando msg.attach(parte).

En este punto, hemos examinado cómo un correo electrónico de texto básico puede
ser enviado. Sin embargo, queremos enviar un mensaje de correo electrónico más
complejo que contiene texto y un archivo adjunto. Esto requiere el uso de mensajes
MIME, que proporcionan la funcionalidad para gestionar e-mails multipart.
Mensajes MIME necesitan límites entre varias partes de un e-mail junto con
encabezados adicionales para especificar el contenido que se envía. La clase
MIMEBase es una subclase abstracta de mensaje y permite que este tipo de un
correo electrónico que se enviará. Dado que es una clase abstracta, no se puede
crear instancias reales de esta clase. En su lugar, utiliza una de las subclases, como
MimeText. El último paso de la función mail () es crear un nuevo objeto de SMTP
que hace referencia al servicio de correo de Google, pasa el nombre de usuario y
contraseña para poder conectarse a los servicios de correo, envía el correo
electrónico, y luego cierra la conexión.

Recuperando archivos desde un servidor FTP

Recuperar archivos desde un servidor FTP para su procesamiento es una operación
muy común para los programadores y los SIG se pueden automatizar con un script
de Python.
Preparándose
Conectarse a un servidor FTP y descargar un archivo se realiza mediante el módulo
ftplib. Una conexión a un servidor FTP se crea a través de la FTP, que acepta un
objeto host, nombre de usuario y contraseña para crear la conexión. Una vez que la
conexión se ha abierto, a continuación, puede buscar y descargar archivos.

En este procedimiento, se conectará a la National Interagency Fire Center incidente

sitio FTP y descargar un archivo PDF de un reguero de pólvora en Colorado. Antes
de ejecutar el siguiente script, tendrá que crear un nombre de usuario/contraseña
a través de http://is.nwcg.gov/data_nifcftp.html.

Como hacerlo…
Siga estos pasos para crear un script que se conecta a un servidor FTP y descarga
un archivo:

1. Abrir IDLE y crear un archivo llamado C:\ArcpyBook\Appendix2\ftp.py.

2. Estaremos conectando a un servidor FTP en el NIFC. Visite su sitio web en

http://gis.nwcg.gov/data_nifcftp.html para más información.

3. Importe el ftplib, os, y socket módulos:

import ftplib
import os
import socket
4. Agregue las siguientes variables que defina la URL, directorio y nombre de
archivo:

HOST = 'ftp.nifc.gov'
USER = '<your username here>'
PASSW = '<your password here>'
DIRN = '/Incident_Specific_Data/2012
HISTORIC/ROCKY_MTN/Arapaho/GIS/20120629'
FILE = '20120629_0600_Arapaho_PIO_0629_8x11_land.pdf'
5. Agregue el siguiente bloque de código para crear una conexión. Si hay un error
de conexión, se generará un mensaje. Si la conexión fue exitosa, un mensaje de
éxito será impresas:
 try:
f = ftplib.FTP(HOST,USER,PASS)
except (socket.error, socket.gaierror), e:
print('ERROR: cannot reach "% s "' % HOST)
print('*** Connected to host "%s"' % HOST)

6. Agregue el siguiente bloque de código para iniciar sesión de forma anónima en

el servidor:

try:
f.login()
except ftplib.error_perm:
print('ERROR: cannot login')
f.quit()
print('*** Logged in ')

7. Agregue el siguiente bloque de código para cambiar al directorio especificado en

nuestro DIRN
try:
f.cwd(DIRN)
except ftplib.error_perm:
print('ERROR: cannot CD to "%s"' % DIRN)
f.quit()
print('*** Changed to "%s" folder' % DIRN)

8. Use la FTP.retrbinary() función para recuperar el archivo PDF:

try:
f.retrbinary('RETR %s' % FILE,
open(FILE, 'wb').write)
except ftplib.error_perm:
print('ERROR: cannot read file "%s"' % FILE)
os.unlink(FILE)
else:
print('*** Downloaded "%s" to CWD' % FILE)

9. Asegúrese de desconectar del servidor:

f.quit()
10. Toda la secuencia de comandos debe aparecer como sigue:
import ftplib
import os
import socket

HOST = 'ftp.nifc.gov'
USER = '<your username here>'
PASSW = '<your password here>'
 DIRN = '/Incident_Specific_Data/2012
HISTORIC/ROCKY_MTN/Arapaho/GIS/20120629'
FILE = '20120629_0600_Arapaho_PIO_0629_8x11_land.pdf'

try:
f = ftplib.FTP(HOST,USER,PASSW)
except (socket.error, socket.gaierror), e:
print('ERROR: cannot reach "%s"' % HOST)
print('*** Connected to host "%s"' % HOST)

try:
f.login()
except ftplib.error_perm:
print('ERROR: cannot login')
f.quit()
print('*** Logged in ')

try:
f.cwd(DIRN)
except ftplib.error_perm:
print('ERROR: cannot CD to "%s"' % DIRN)
f.quit()
print('*** Changed to "%s" folder' % DIRN)
try:
f.retrbinary('RETR %s' % FILE,
open(FILE, 'wb').write)
except ftplib.error_perm:
print('ERROR: cannot read file "%s"' % FILE)
os.unlink(FILE)
else:
print('*** Downloaded "%s" to CWD' % FILE)
f.quit()

11. Puede comprobar su trabajo examinando el

C:\ArcpyBook\code\Appendix2\ftp. Py archivo de solución.
12. Guardar y ejecutar el script. Si todo va bien, debería ver la siguiente salida:
*** Connected to host "ftp.nifc.gov"
*** Logged in as "anonymous"
*** Changed to
"'/Incident_Specific_Data/2012HISTORIC/ROCKY_MTN/Arapaho/GIS/20
120629'" folder
***Downloaded "'20120629_0600_Arapaho_PIO_0629_8x11_land.pdf "
to CWD
13. Compruebe su C:\ArcpyBook\Appendix2 directorio para el archivo. De forma
predeterminada, FTP descargar archivos en el directorio de trabajo actual.

Cómo funciona…
Para conectarse a un servidor FTP, necesita conocer la dirección URL. Usted
también necesita saber el directorio y nombre de archivo para el archivo que se
descargará. En este script, hemos codifica esta información, por lo que puede
centrarse en la aplicación de las funcionalidades específicas de FTP. Utilizando esta
información, a continuación, creamos una conexión con el servidor FTP del NIFC.
Esto se realiza mediante el ftplib.FTP (), que acepta una dirección URL para el host.

Tenga en cuenta que necesitará para obtener un nombre de usuario y contraseña

para iniciar sesión y descargar los datos. Una vez iniciada la sesión, a continuación,
la secuencia de comandos cambia de directorio desde el directorio raíz del servidor
FTP a la ruta de acceso definida en la variable DIRN. Esto se logra con la
cwd(<ruta>) Función. El archivo PDF se ha recuperado utilizando la retrbinary().
Por último, deberá cerrar la conexión con el servidor FTP cuando termines. Esto se
realiza con el método Quit().

Aún hay más...

Hay un número de métodos relacionados con FTP adicional que puede utilizar para
realizar diferentes acciones. Generalmente, estos pueden dividirse en las
operaciones a nivel de directorio y las operaciones a nivel de archivo. Nivel de
directorio métodos incluyen el método dir() para obtener una lista de los archivos
de un directorio, mkd() para crear un nuevo directorio, pwd() para obtener el
directorio de trabajo actual, y cwd() para cambiar el directorio actual. Tenga en
cuenta que las acciones que intentan llevar a cabo mediante el script será
gobernada por los privilegios asignados a su cuenta, por lo que no puede ser capaz
de ejecutar correctamente cada método que menciono.

El módulo ftplib también incluye varios métodos para trabajar con archivos. Puede
cargar y descargar archivos en un archivo binario o texto sin formato. retrbinary()y
storbinary()métodos se utilizan para recuperar y almacenar archivos binarios,
respectivamente. archivos de texto pueden ser recuperados y almacenados usando
retrlines() y storlines().

Hay varios otros métodos en la clase ftp que usted debe conocer. La eliminación de
un archivo puede realizarse con el método delete(), al cambiar el nombre de un
archivo puede realizarse con rename(). También puede enviar comandos al servidor
FTP mediante el método sendcmd().

Crear archivos ZIP

GIS requiere a menudo el uso de archivos de gran tamaño que será comprimido en
formato .zip para facilitar el intercambio. Python incluye un módulo que pueda utilizar
para descomprimir y comprimir archivos en este formato.

Preparándose
ZIP es un formato de compresión y archivo común y es implementado en Python a
través del módulo de archivo zip. La clase ZipFile se puede utilizar para crear, leer,
y escribir archivos .zip. A crear un nuevo archivo .zip, sólo tiene que proporcionar el
nombre de archivo junto con un modo tan w, lo que indica que desea escribir datos
en el archivo. En el siguiente ejemplo de código, estamos creando un .zip archivo
llamado datafile.zip. El segundo parámetro, w, indica que se creará un nuevo
archivo. Un nuevo archivo será creado o un archivo existente con el mismo nombre
se truncará en la escritura modo. Un parámetro de compresión opcional también se
puede utilizar cuando se crea el archivo. Este valor se puede establecer en
cualquiera ZIP_STORED o ZIP_DEFLATED:

zipfile.ZipFile('dataFile.zip', 'w',zipfile.ZIP_STORED)

En este ejercicio, va a utilizar Python para crear el archivo, agregar archivos y aplicar
compresión en un archivo .zip. Podrá archivar todos los archivos ubicados en la
carpeta C:\ArcpyBook\directorio de datos.

Cómo hacerlo...
Siga estos pasos para aprender a crear un script que genera un archivo .zip:
1. Abrir IDLE y crear un script llamado C: \ ArcPy libro \ Apéndice 2 \ Crear
Zipfile.py
2. Importe los módulos zipfile y sistema operativo:

import os

import zipfile

3.Crear un nuevo archivo .zip llamado shapefiles.zip en modo de escritura y añadir

un parámetro de compresión:

zfile = zipfile.ZipFile("shapefiles.zip", "w", zipfile.ZIP_STORED)

4. A continuación, vamos a utilizar la función os.listdir () para crear una lista de

archivos en el directorio de datos:

files = os.listdir("c:/ArcpyBook/data")

5. A través de una lista de todos los archivos y escribir en el archivo .zip si el

archivo termina con shp, DBF, o shx:

for f in files:
if f.endswith("shp") or f.endswith("dbf") or
f.endswith("shx"):
zfile.write("C:/ArcpyBook/data/" + f)
6. Imprimir una lista de todos los archivos que se han añadido al archivo ZIP. Puede
utilizar la función ZipFile.namelist() para crear una lista de archivos en el archivo.

for f in zfile.namelist():
print "Added %s" % f
7. Cierre el archivo .zip:

zfile.close ()
8. Toda la secuencia de comandos debe aparecer como sigue:
import os
import zipfile
#create the zip file
zfile = zipfile.ZipFile("shapefiles.zip", "w", zipfile.ZIP_STORED)
files = os.listdir("c:/ArcpyBook/data")

for f in files:
if f.endswith("shp") or f.endswith("dbf") or
f.endswith("shx"):
 zfile.write("C:/ArcpyBook/data/" + f)
#list files in the archive
for f in zfile.namelist():
print("Added %s" % f)
zfile.close()

9. Puede comprobar su trabajo examinando el C:\ArcpyBook\code\Appendix2\

CreateZipfile_Step1.py Archivo de solución.

10. Guardar y ejecutar el script. Debería ver la siguiente salida:

Added ArcpyBook/data/Burglaries_2009.dbf
Added ArcpyBook/data/Burglaries_2009.shp
Added ArcpyBook/data/Burglaries_2009.shx
Added ArcpyBook/data/Streams.dbf
Added ArcpyBook/data/Streams.shp
Added ArcpyBook/data/Streams.shx
11. En el Explorador de Windows, usted debería ser capaz de ver el archivo .zip de
salida, como se muestra en la siguiente captura de pantalla. Observe el tamaño del
archivo. Este archivo se creó sin compresión:

12. Ahora, vamos a crear una versión comprimida del archivo .zip para ver la
diferencia. Hacer los siguientes cambios en la línea de código que crea el archivo
.zip:

zfile = zipfile.ZipFile("shapefiles2.zip", "w", zipfile.ZIP_DEFLATED)

13. Puede comprobar su trabajo examinando el directorio C: \ ArcpyBook \ code \

Apéndice 2 \CreateZipfile_Step2.py archivo de solución.

14. Guarde y vuelva a ejecutar la secuencia de comandos.

15. Ven a ver el tamaño del nuevo archivo shapefiles2.zip que acaba de crear. Nota
la disminución del tamaño del archivo debido a la compresión:
Cómo funciona…
En este procedimiento, se ha creado un nuevo archivo .zip llamado shapefiles.zip
en modo de escritura. En la primera iteración de este script, usted no comprimir el
contenido del archivo. Sin embargo, en la segunda iteración, lo hicieron mediante la
deflación de parámetro que se pasa en el constructor del objeto ZipFile. A
continuación, el script obtiene una lista de los archivos en el directorio de datos y en
bucle a través de cada uno de los archivos. Cada archivo tiene una extensión .shp
y .dbf o .shx se escribe a continuación el archivo utilizando la función write().
Finalmente, los nombres de cada uno de los archivos escritos en el archivo se
imprime en la pantalla.

Aún hay más...

El contenido de un archivo almacenado en un archivo ZIP se puede leer mediante

el método read(). El archivo debe estar abierto en modo de lectura y, a continuación,
puede llamar al método read() pasando un parámetro que representa el nombre del
archivo que debe ser leído. El contenido del archivo puede ser impreso a la pantalla,
escrito a otro archivo, o almacenarse como una lista o diccionario variable.

La lectura de archivos XML

Los archivos XML se han diseñado como una manera de transportar y almacenar
datos. Éstos son independientes de la plataforma, ya que los datos se almacenan
en un archivo de texto sin formato. Aunque similar a HTML, XML se diferencia de
HTML desde la ex está diseñado para propósitos de presentación, mientras que los
datos XML se ha diseñado para los datos. Los archivos XML se utilizan a veces
como un formato de intercambio de datos SIG que va entre diferentes sistemas de
software.
Preparándose…
Los documentos XML tienen una estructura de árbol que está compuesta de un
elemento raíz, los elementos secundarios y los atributos del elemento. Los
elementos son también llamados nodos. Todos los archivos XML contienen un
elemento raíz. Este elemento raíz es el padre de todos los demás elementos o
nodos secundarios. En el ejemplo de código siguiente se muestra la estructura de
un documento XML. A diferencia de los archivos HTML, los archivos XML son
sensibles a mayúsculas:

<root>
<child att="value">
<subchild>.....</subchild>
</child>
</root>
Python proporciona varios módulos de programación que puede utilizar
para procesar archivos XML. El módulo que se utilice debe ser determinado
por el módulo que es adecuado para el trabajo. No trate de forzar un único
módulo para hacerlo todo. Cada módulo tiene funciones específicas que
son buenos para realizar.
En este procedimiento, usted aprenderá cómo leer datos de un archivo XML que
utilizan los nodos y atributos de los elementos que forman parte del documento.

Hay una serie de formas en que se puede acceder a los nodos dentro de un
documento XML. Quizás el

forma más fácil de hacerlo es encontrar nodos por nombre de la etiqueta y luego a
través de pie del árbol que contiene una lista de los nodos secundarios. Antes de
hacerlo, tendrá que analizar el documento XML con la minidom.parse () método.
Una vez analizado, a continuación, puede utilizar los atribuyen a childNodes
obtener una lista de todos los nodos secundarios a partir de la raíz del árbol. Por
último, se puede buscar en los nodos por los nombres de etiqueta con la función
getElementsByTagName (tag), que acepta un nombre de etiqueta como un
argumento. Esto devolverá una lista de todos los nodos secundarios que se asocian
con la etiqueta.
También puede determinar si un nodo contiene un atributo llamando hasAttribute
(name), que devolverá un valor de verdadero / falso. Una vez que haya determinado
que existe un atributo, una llamada getAttribute a (name) va a obtener el valor del
atributo.

En este ejercicio, vamos a analizar un archivo XML y extraer los valores asociados
a una determinada elemento (nodo) y el atributo. Vamos a cargar un archivo XML
que contiene los datos de incendios forestales. En este archivo, vamos a buscar la
<incendio> nodo y el atributo de dirección para cada uno de estos nodos. Las
direcciones se imprimirán.

Cómo hacerlo…

1. Abrir IDLE y crear un script llamado

C:\ArcpyBook\Apéndice2\XMLAccessElementAttribute.py.

2. La WitchFireResidenceDestroyed.xml se utilizará. El archivo se encuentra en

C:\carpeta\ArcpyBook Apéndice2. Puede ver una muestra de su contenido, tal
como sigue:

<fires>
<fire address="11389 Pajaro Way" city="San Diego"
state="CA" zip="92127" country="USA" latitude="33.037187"
longitude="-117.082299" />
<fire address="18157 Valladares Dr" city="San Diego"
state="CA" zip="92127" country="USA" latitude="33.039406"
longitude="-117.076344" />
<fire address="11691 Agreste Pl" city="San Diego"
state="CA" zip="92127" country="USA" latitude="33.036575"
longitude="-117.077702" />
<fire address="18055 Polvera Way" city="San Diego"
state="CA" zip="92128" country="USA" latitude="33.044726"
longitude="-117.057649" />
</fires>
3. Importar desde xml minidom.dom:
from xml.dom import minidom
4. Analizar el archivo XML:
xmldoc = minidom.parse("WitchFireResidenceDestroyed.xml")

5. Generar una lista de los nodos del archivo XML:

childNodes = xmldoc.childNodes

6. Generar una lista de todos los <fire> nodos:

eList = childNodes[0].getElementsByTagName("fire")

7. Recorrer a través de la lista de elementos, la prueba de la existencia del atributo

de dirección e imprimir el valor del atributo, si existe:

for e in eList:
if e.hasAttribute("address"):
print(e.getAttribute("address"))

8. Puede verificar su trabajo examinando el directorio C: \ ArcpyBook \ code \

Apéndice 2 \ XMLAccessElementAttribute.py archivo de solución.

9. Guardar y ejecuta el script. Debería ver el siguiente resultado:

11389 Pajaro Way

18157 Valladares Dr

11691 Agreste Pl

18055 Polvera Way

18829 Bernardo Trails Dr

18189 Chretien Ct

17837 Corazon Pl

18187 Valladares Dr

18658 Locksley St

18560 Lancashire Way

Cómo funciona…

Cargar un documento XML en su script es probablemente lo más básico que se

puede hacer con archivos XML. Puede utilizar el módulo xml.dom para hacer esto
mediante el uso del objeto minidom. El minidom objeto tiene un método llamado
parse(), que acepta una ruta de acceso a un documento XML y crea un modelo de
objetos de documento (DOM) objeto del árbol WitchFireResidenceDestroyed.xml.

La propiedad ChildNodes del árbol DOM genera una lista de todos los nodos del
archivo XML. A continuación, puede tener acceso a cada uno de los nodos mediante
el método getElementsByTagName(). El paso final es recorrer cada uno de los
nodos <fire> eList contenida dentro de la variable. Para cada nodo, podemos
controlar la dirección con el atributo hasAttribute(), método y, si existe, llamamos
la getAttribute() e imprimir la dirección de la pantalla.

Aún hay más...

Habrá momentos en los que tendrás que buscar un documento XML para una
determinada cadena de texto. Esto requiere el uso de XML.parsers.expat módulo.
Necesitará definir una búsqueda clase derivada de la clase expat básico y, a
continuación, crear un objeto de esta clase. Una vez creado, puede llamar al método
parse() en el objeto Search para buscar datos. Por último, a continuación, puede
buscar los nodos por nombres de etiquetas con la función
getElementsByTagName(tag), que acepta un nombre de etiqueta como un
argumento. Esto devolverá una lista de todos los nodos secundarios que están
asociados con la etiqueta.