Arcpy

29/11/2019 Introducción al tutorial de arcpy.
mapping — Ayuda | ArcGIS for Desktop
Introducción al tutorial de arcpy.mapping

ArcMap 10.3
El |
Otras versiones
10,7
10,6
10,5
10,4
10,3
Complejidad
Principiante
Requisito de datos:
Utilizar datos propios
Este tutorial lo guía a través de algunos flujos de trabajo arcpy.mapping muy comunes e introduce algunos conceptos
importantes en el camino. Su objetivo es ayudar a los usuarios que son completamente nuevos en Python scripting y
arcpy.mapping. Los pasos son lo suficientemente genéricos como para funcionar con cualquier dato y todos los niveles
de licencia.
No un:
El único requisito es que tenga un archivo de capa de características ( .lyr ) antes de comenzar el tutorial.
Los pasos a continuación presentan una descripción general de muy alto nivel de arcpy.mapping. A lo largo del
tutorial, hay enlaces a temas de ayuda detallados que proporcionan mucha más información sobre los conceptos
involucrados, y en casi todos los casos, los temas incluyen fragmentos de código de muestra adicionales.
Ventana de Python
El lugar más fácil para comenzar a aprender arcpy.mapping es en la ventana de Python . La ventana de Python es parte
del marco de ArcMap y proporciona autocompletado para que pueda leer fácilmente los nombres y el orden de los
parámetros de la función. Los pasos a continuación le muestran cómo configurar la ventana de Python para una
experiencia satisfactoria para el usuario final y también para hacer coincidir las capturas de pantalla a lo largo de este
documento.
1. Abra un nuevo documento de mapa vacío en ArcMap.

2. Haga clic en Geoprocesamiento> Python .
Si es la primera vez que abre la ventana de Python , aparece flotando sobre la aplicación. Los siguientes pasos
son acoplar la ventana de Python y modificar la ubicación de la ayuda.
3. Haga clic en la barra de título de la ventana de Python y mantenga presionado el botón izquierdo del mouse.
4. Arrastre la ventana de Python al ancla de acoplamiento ubicada en la parte inferior de la aplicación ArcMap y
suelte el botón.
5. Haga clic en el panel de código (con los >>> caracteres) del pitón ventana. Debería ver que aparece texto de
ayuda en el panel de ayuda a la derecha.
6. Haga clic con el botón derecho en el panel de código y elija Colocación de ayuda> Inferior . Ahora la ayuda
debería aparecer debajo del panel de código. Es posible que deba ajustar el divisor entre los dos paneles para
que haya suficiente espacio para escribir código y ver la ayuda.
7. Ahora escriba la siguiente declaración (tenga cuidado, Python distingue entre mayúsculas y minúsculas):
>>> arcpy.mapping.ExportToPDF(
https://desktop.arcgis.com/es/arcmap/10.3/analyze/arcpy-mapping/getting-started-with-arcpy-mapping-tutorial.htm 1/8
29/11/2019 Introducción al tutorial de arcpy.mapping — Ayuda | ArcGIS for Desktop
La ventana de Python debería ser similar al gráfico a continuación. Se resalta el primer parámetro requerido,
llamado map_document . Si ingresa una coma, el segundo parámetro queda resaltado. Solo hay dos parámetros
obligatorios: map_document y out_pdf . Los parámetros opcionales están entre corchetes: {} .
8. Haga clic derecho en el panel de código y haga clic en Borrar todo para borrar el panel de código.
Hacer referencia a un documento de mapa existente

Normalmente, una de las primeras operaciones que realiza con un script arcpy.mapping es hacer referencia a un
documento de mapa existente ( .mxd ) o un archivo de capa ( .lyr ) con el que desea hacer algo. En esta sección, hará
referencia a un documento de mapa.
Hay dos formas de hacer referencia a un documento de mapa. El primero es hacer referencia a él en el disco
proporcionando una ruta al archivo .mxd. Si está creando un script que se ejecutará fuera del entorno de ArcGIS, debe
hacer referencia a un documento de mapa utilizando su ruta. La segunda forma es hacer referencia al documento de
mapa que está cargado actualmente en la aplicación ArcMap (en este caso, su untitled.mxd). Al trabajar en la ventana
de Python dentro de ArcMap, es conveniente hacer referencia al documento de mapa cargado actualmente porque los
cambios realizados en él se pueden ver directamente en la aplicación. Los siguientes pasos harán referencia al
documento de mapa actualmente cargado en ArcMap.
1. En la ventana de Python , escriba lo siguiente y presione ENTRAR cuando haya terminado:
>>> mxd = arcpy.mapping.MapDocument("CURRENT")
La función MapDocument devuelve una referencia de objeto MapDocument a una variable llamada mxd . La
cadena CURRENT es una palabra clave utilizada para hacer referencia al documento de mapa cargado
actualmente. En lugar de ACTUAL , aquí es donde también podría proporcionar una ruta al documento de mapa.
2. En la ventana de Python , escriba lo siguiente:
>>> mxd.
Después de escribir el punto, debería ver una larga lista de métodos y propiedades disponibles para el objeto
MapDocument .
>>> mxd.author = "YOUR NAME GOES HERE"
El objeto MapDocument tiene una propiedad llamada autor . Simplemente establece su valor en una cadena.
4. En ArcMap, haga clic en Archivo> Propiedades del documento de mapa .
Debería ver que la propiedad del autor está establecida en su cadena. Acaba de interactuar directamente con el
objeto MapDocument a través de la variable llamada mxd. Hay muchos otros métodos y propiedades en el
objeto MapDocument . Ahora guardará sus cambios.
5. Haga clic en Cancelar cuando haya terminado con el cuadro de diálogo Propiedades del documento de mapa .
>>> mxd.save()
Debido a que es un documento de mapa no guardado, aparece un cuadro de diálogo que le solicita que
proporcione una ruta y un nombre de archivo. El método save () no tiene ningún parámetro, pero debido a que
es un método, aún debe incluir los paréntesis de apertura / cierre. De manera realista, trabajaría con un
documento de mapa ya existente y no necesitaría lidiar con un cuadro de diálogo emergente para guardar. Para
verificar la ubicación del lugar donde se guardó el documento de mapa, intente lo siguiente:
>>> print mxd.filePath
Debería ver la ruta impresa en el panel de código:
Agregar un archivo de capa al documento de mapa

Ahora que tiene una referencia a un documento de mapa, lo siguiente que hará es agregar un archivo de capa ( .lyr ) al
documento de mapa. Esto se puede hacer con la función AddCayer arcpy.mapping .
>>> arcpy.mapping.AddLayer(
El autocompletado muestra que hay dos parámetros necesarios. El primero es una referencia a un marco de
datos en un documento de mapa. El segundo es una referencia a la capa que desea agregar. Esto puede ser una
capa en un documento de mapa o un archivo de capa. El tercer parámetro es opcional y controla la colocación
de la capa en la tabla de contenido. Debido a que es la primera y única capa, ignorará el tercer parámetro e irá
con su valor predeterminado.
Antes de poder agregar la capa, debe hacer referencia a los objetos apropiados. Primero, hará referencia al
marco de datos.
2. En la ventana de Python , retroceda para eliminar la función AddLayer , escriba lo siguiente y presione ENTRAR
cuando haya terminado:
>>> df = arcpy.mapping.ListDataFrames(mxd, "Layers")[0]
La función ListDataFrames requiere una referencia a un documento de mapa y, opcionalmente, un filtro

comodín. Está proporcionando el nombre completo del marco de datos para buscar. También podría haber
escrito algo como "lay *" .
Todas las funciones de ArcPy List devuelven objetos de Python List. Los elementos devueltos en la lista están
basados en cero, lo que significa que el primer elemento de la lista tiene un valor de índice de 0 y el segundo es
1, hasta n-1. Como desea que la variable df haga referencia a un objeto DataFrame y no a un objeto de la lista
de Python, debe agregar un número de índice después de la función. Agregar un [0] al final de la función
devuelve el primer marco de datos en la lista. En su caso, es el único marco de datos en la lista. Si nombra de
forma exclusiva sus marcos de datos dentro del documento de mapa y utiliza el valor comodín apropiado para
aislar el elemento, siempre debe devolver una lista con solo un elemento e índice [0]trabajará. Si tiene dos
marcos de datos en un documento de mapa y desea hacer referencia al segundo marco de datos sin usar un
valor comodín , necesitaría usar un [1] al final de la función, por ejemplo, df2 = arcpy.mapping.ListDataFrames
(mxd) [1] .
A continuación, debe hacer referencia a un archivo de capa antes de poder usar la función AddLayer . El proceso
de hacer referencia a un archivo de capa es idéntico a hacer referencia a un documento de mapa al
proporcionar una ruta completa al .mxd, excepto que utiliza la función de capa en lugar de la función
MapDocument .
No un:
Para los siguientes pasos, debe ubicar un archivo de capa existente. Si no tiene uno, deberá crear uno.
3. En la ventana de Python , escriba lo siguiente y presione ENTRAR cuando haya terminado. La ruta que
proporcione probablemente será diferente al ejemplo a continuación.
>>> lyrFile = arcpy.mapping.Layer(r"C:\Project\data\Rivers.lyr")
En el paso anterior, se creó una referencia a un archivo de capa existente, y esa referencia se almacena en una
variable llamada lyrFile .
Observe cómo la ruta tiene una pequeña r colocada frente a la cadena. Este es un personaje especial en Python
que significa raw . Significa interpretar la cadena como es e ignorar cualquier otro carácter especial dentro de la
cadena. Se usó la pequeña r porque la ruta tiene barras invertidas dentro de la cadena. Las barras invertidas en
Python también son caracteres especiales. Por ejemplo, \ t dentro de una cadena se convierte en una pestaña y \
n se convierte en una nueva línea. En el ejemplo anterior, no desea que se usen caracteres especiales; quieres la
cadena literal sin procesar. Hay otras dos formas equivalentes de escribir la misma ruta en Python. Primero, use
barras diagonales (por ejemplo, "C: /Project/States.lyr") Python no intenta interpretar barras diagonales, y son un
estándar multiplataforma. En segundo lugar, utilice barras invertidas dobles (por ejemplo, "C: \\ Project \\
Lakes.lyr" ). La primera barra invertida cancela la segunda. Es importante recordar la pequeña técnica r porque
cuando copia las rutas del sistema en una plataforma Windows, se incluyen barras invertidas.
Se han creado todas las referencias variables necesarias. A continuación, la función AddLayer se usará para
agregar su archivo de capa al documento de mapa actual.
>>> arcpy.mapping.AddLayer(df, lyrFile)
Su capa debería haberse agregado a la tabla de contenido y vista de datos y su ventana de Python debería ser
similar al gráfico a continuación:
Exportar un documento de mapa a PDF

Exportar un documento de mapa a PDF es increíblemente fácil y solo requiere una sola línea de código. Ya viste la
sintaxis de la función ExportToPDF cerca del comienzo del tutorial. Ahora completará la sintaxis.
>>> arcpy.mapping.ExportToPDF(mxd, r"C:\Project\Doc1.pdf")
Hay muchos parámetros que coinciden con la misma configuración disponible en ArcMap. Solo se requieren
dos parámetros: map_document y out_pdf .
Se debería haber creado un documento PDF en la ubicación que especificó, y la ventana de Python debería ser
Haga referencia a una capa utilizando la función ListLayers, cambie las

propiedades de la capa
Hay muchas propiedades y métodos disponibles para trabajar con capas en un documento de mapa. Anteriormente
agregó una capa a un documento de mapa desde un archivo de capa. La variable que creó llamada lyrFile hace
referencia a la capa agregada al documento de mapa. Con esta variable, puede modificar algunas de las propiedades
de la capa que agregó.
>>> lyrFile.
Después de ingresar el punto, observe todas las diferentes propiedades y métodos en el objeto Layer . Con la
variable lyrFile , podría cambiar estas propiedades en el documento de mapa y, cuando llame al método save () ,
guardaría los cambios en el archivo de capa ( .lyr ) en el disco.
No todas las propiedades de capa posibles están disponibles en el objeto Capa , solo aquellas que son más
comunes para escenarios de automatización de mapas. Se pueden modificar muchas más propiedades creando
esas propiedades en un archivo de capa y utilizando la función arcpy.mapping UpdateLayer .
No siempre va a agregar archivos de capa. La mayoría de las veces, su documento de mapa ya tendrá capas
existentes. En estos próximos pasos, volverá a hacer referencia a la capa como si ya estuviera en el documento
de mapa. Hacer referencia a una capa en un documento de mapa es muy similar a hacer referencia a un marco
de datos.
2. En la ventana de Python , retroceda sobre el texto actual, escriba lo siguiente y presione ENTRAR :
>>> lyr = arcpy.mapping.ListLayers(mxd)[0]
La función ListLayers requiere que proporcione una referencia de documento de mapa. Tiene dos parámetros
adicionales: uno para realizar una búsqueda con comodines y el segundo para especificar un marco de datos.
Debido a que solo tiene una capa y un marco de datos, no es necesario proporcionar los otros parámetros.
Nuevamente, el valor del índice [0] se requiere al final de la instrucción para que se devuelva un objeto de capa
en lugar de un objeto de lista de Python.
Con la nueva variable lyr , actualizará algunas propiedades de capa.
3. En la ventana de Python , escriba las dos líneas siguientes y presione ENTRAR después de cada una:
>>> lyr.name = "Some New Name"

>>> lyr.visible = False
No verá un cambio de inmediato. No todos los cambios de propiedad o métodos actualizan automáticamente la
aplicación. Esto es así por diseño, por lo que la aplicación no tiene que actualizarse constantemente. Al usar
CURRENT para hacer referencia al documento de mapa actualmente cargado dentro de ArcMap, a veces
necesita actualizar la tabla de contenido o la vista activa (vista de datos o vista de diseño).
>>> arcpy.RefreshTOC()
>>> arcpy.RefreshActiveView()
La tabla de contenido y la vista de datos se actualizan.
No un:
Si ejecuta scripts independientes fuera de ArcMap, estas funciones adicionales no son necesarias.
Su ventana de Python debería ser similar al gráfico a continuación:
Cambiar la extensión del marco de datos

En esta sección, cambiará la extensión del marco de datos para que coincida con la extensión de las características
seleccionadas. En un script, esto normalmente se haría usando una función como SelectlayerByAttribute . Para
simplificar la experiencia, seleccionará gráficamente algunas características. Primero deberá volver a activar la
visibilidad de su capa con Python.
1. En la ventana de Python , escriba las siguientes tres líneas, presione ENTRAR después de cada una:
>>> lyr.visible = True

>>> arcpy.RefreshTOC()
>>> arcpy.RefreshActiveView()
2. En ArcMap, seleccione gráficamente una o más entidades en su capa.

A continuación, creará una variable que almacena la extensión de las características seleccionadas y aplicará esa
extensión al parámetro de extensión para el objeto DataFrame al que ya ha hecho referencia.
>>> lyrExtent = lyr.getSelectedExtent()

>>> df.extent = lyrExtent
Exportar un documento de mapa a PDF (nuevamente)

Vas a exportar a PDF nuevamente. Esta vez está creando un segundo documento PDF que eventualmente se agregará a
un nuevo documento junto con el primer documento.
>>> arcpy.mapping.ExportToPDF(mxd, r"C:\Project\Doc2.pdf")
Cree un nuevo documento PDF y agregue sus dos páginas

El módulo arcpy.mapping contiene algunas funciones de gestión de documentos PDF que son perfectas para crear
documentos de varias páginas. Los libros de mapas completos, por ejemplo, a menudo incluyen páginas además de las
páginas de mapas de referencia estándar generadas por las páginas controladas por datos . El uso de arcpy.mapping
es un paso necesario para construir libros de mapas completos .
Esta parte del tutorial simulará la creación de un informe de varias páginas. Primero creará un nuevo documento PDF y
luego agregará los PDF que creó en los pasos anteriores. Imagine que esos documentos PDF son simplemente los
documentos individuales que forman un libro de mapas. Quizás Doc1.pdf podría ser un PDF de varias páginas que
represente una página de título, una tabla de contenido, etc. El segundo documento PDF podría ser el resultado de
exportar todas sus páginas de mapas de páginas controladas por datos a un solo PDF de varias páginas.
El primer paso es crear un nuevo documento PDF.
>>> PDFdoc = arcpy.mapping.PDFDocumentCreate(r"C:\Project\Final.pdf")
Una variable llamada PDFdoc hace referencia a un objeto PDFDocument en la memoria. No existirá en el disco
hasta que guarde y cierre el documento.
Los siguientes pasos son agregar las páginas apropiadas.
2. En la ventana de Python , escriba las siguientes tres líneas, presione ENTRAR después de cada una:
>>> PDFdoc.appendPages(r"C:\Project\Doc1.pdf")
>>> PDFdoc.appendPages(r"C:\Project\Doc2.pdf")
>>> PDFdoc.saveAndClose()
Las dos primeras líneas agregan cada PDF al documento PDF recién creado. La última línea es la que confirma
los cambios y crea el PDF final en el disco.
Se debería haber creado un documento PDF en la ubicación que especificó, y la ventana de Python debería ser
Temas relacionados
Introducción a arcpy.mapping
Pautas para arcpy.mapping
Ha completado un flujo de trabajo muy simple pero común utilizando arcpy.mapping. Los siguientes pasos son aplicar
estos flujos de trabajo contra sus propios documentos de mapa y capas. También tómese un tiempo y profundice en
los temas de ayuda de arcpy.mapping. Hay cientos de pequeñas muestras de código al final de cada tema que se
pueden copiar y pegar fácilmente en la ventana de Python . También realice una búsqueda dentro del Centro de
recursos en arcpy.mapping para encontrar aplicaciones más avanzadas de arcpy.mapping.
29/11/2019 Pautas para arcpy.mapping — Ayuda | ArcGIS for Desktop
Pautas para arcpy.mapping

ArcMap 10.3
El |
Otras versiones
10,7
10,6
10,5
10,4
10,3
Esta sección destaca algunas pautas importantes para trabajar con el módulo arcpy.mapping. También proporciona
información sobre el diseño de la API arcpy.mapping y sugiere algunas estrategias para diferentes escenarios.
Debe funcionar con documentos de mapa o archivos de capa existentes

El módulo arcpy.mapping fue diseñado para que pueda usarse para modificar elementos existentes dentro de
documentos de mapa ( .mxd ) o archivos de capa ( .lyr ) ya existentes . En otras palabras, ayuda con la automatización
de las funciones existentes, pero no se puede usar para crear nuevos objetos. No fue diseñado para ser un reemplazo
completo de ArcObjects o un intento de crear una función, método o propiedad para cada botón, cuadro de diálogo,
opción de menú o elemento de contexto concebible en la interfaz de ArcMap (eso es lo que proporciona ArcObjects).
Debe crear cuidadosamente un documento de mapa o archivo de capa usando ArcMap con anticipación con todos los
elementos apropiados y luego usar arcpy.mapping para manipular su contenido.
Los siguientes son solo algunos ejemplos simples de cómo se puede usar arcpy.mapping:
Reemplazar la fuente de datos de una capa.

Itere a través de una serie de extensiones de marco de datos, encuentre y reemplace valores de texto y exporte
el diseño de página a PDF.
Cree un libro de mapas completo agregando documentos PDF en un producto final.
No un:
Es posible realizar cambios en documentos de mapas o archivos de capa existentes y luego guardar los
cambios en un nuevo archivo utilizando el método saveACopy en los objetos MapDocument o Layer .
Haga referencia a un documento de mapa en el disco o use la palabra

clave ACTUAL dentro de ArcMap
Hay dos formas diferentes de crear un objeto MapDocument utilizando la función MapDocument . El primer método, y
el más recomendado, es proporcionar una ruta del sistema a la ubicación del documento de mapa ( .mxd ) en el disco.
Esta técnica es más versátil porque un script se puede ejecutar fuera de una aplicación ArcGIS. Hacer referencia a un
documento de mapa específico en el disco proporciona más control en términos de cómo se ejecutará el script porque
un script determinado puede no funcionar en todos los documentos de mapa.
La segunda técnica es usar la palabra clave CURRENT como parámetro de entrada para la función MapDocument. Esta
técnica solo funciona desde una aplicación ArcMap porque el objeto MapDocument hace referencia al documento de
mapa que está cargado actualmente en la aplicación ArcMap. Usar CURRENT es muy útil cuando se prueban y
aprenden rápidamente las capacidades de scripting y la sintaxis de comandos dentro de la ventana de Python . Puede
comenzar aprendiendo la sintaxis en la ventana de Python , luego comenzar a pegar esas líneas de código en un script
más permanente guardado en el disco.
https://desktop.arcgis.com/es/arcmap/10.3/analyze/arcpy-mapping/guidelinesforarcpymapping.htm 1/3
Las herramientas de script que usan la palabra clave ACTUAL deben ejecutarse desde ArcMap (ya sea desde un menú
personalizado o desde la ventana Catálogo ). Las herramientas de script que usan CURRENT no se ejecutarán
correctamente si se ejecutan desde la aplicación ArcCatalog. Por este mismo motivo, si una herramienta de secuencia
de comandos tiene una secuencia de comandos de validación que incluye una referencia a ACTUAL, puede producirse
un error si intenta editar la secuencia de comandos de validación desde ArcCatalog. Asegúrese de editar el código de
validación de la herramienta de secuencia de comandos desde la ventana Catálogo de ArcMap.
Para utilizar la palabra clave ACTUAL dentro de una herramienta de secuencia de comandos, el procesamiento en
segundo plano debe estar deshabilitado. El procesamiento en segundo plano ejecuta todos los scripts como si se
estuvieran ejecutando como scripts independientes fuera de una aplicación ArcGIS, y por esta razón, CURRENT no
funcionará con el procesamiento en segundo plano habilitado. Hay una nueva opción de herramienta de secuencia de
comandos llamada Ejecutar siempre en primer plano que garantiza que una herramienta de secuencia de comandos se
ejecutará en primer plano, incluso si el procesamiento en segundo plano está habilitado.
Agregar capas y trabajar con documentos de mapa de plantilla

Como se mencionó en la sección anterior, arcpy.mapping no le permite crear completamente nuevos documentos de
mapa. Por diseño, tampoco proporciona la capacidad de cambiar el tamaño o la orientación de la página de un
documento de mapa existente. La solución es fácil. Cree documentos de mapa de plantilla con todos los elementos
apropiados, tamaños de página, orientaciones, etc. con anticipación, luego use arcpy.mapping para manipular los
contenidos.
Un escenario común es crear un documento de mapa de plantilla sin capas, luego usar las funciones arcpy.mapping
AddLayer , AddLayerToGroup o InsertLayer para agregar capas al documento de mapa. Si un elemento de leyenda se
crea previamente para agregar automáticamente nuevos elementos a la leyenda, los elementos de leyenda aparecerán
automáticamente.
Otro escenario común involucra libros de mapas con páginas enfrentadas. Las páginas izquierda y derecha incluyen
diferentes desplazamientos para hacer espacio para el enlace. Este escenario incluye tener dos documentos de mapa:
uno para las páginas de la izquierda y otro para las páginas de la derecha. La lógica de scripts Arcpy.mapping se utiliza
para reunir todas las páginas individuales en un PDF de varias páginas de salida final. Consulte Crear un libro de mapas
con páginas enfrentadas que cubra este escenario en detalle e incluya un código de muestra arcpy.mapping.
Crea todos los objetos con un nombre único

Para hacer referencia fácilmente a un elemento del mapa, por ejemplo, un marco de datos, capa, elemento de diseño o
tabla para que pueda accederse y modificarse, el elemento del mapa debe tener un nombre único. Muchas de las
funciones de la lista arcpy.mapping, por ejemplo, ListDataFrames , ListLayers , ListLayoutElements y ListTableViews.:
Tiene un parámetro comodín que le permite filtrar en la propiedad de nombre. Estas funciones de lista siempre
devuelven un objeto de lista de Python. Para hacer referencia a un elemento del mapa de la lista de Python, puede
recorrer la lista mediante un bucle o puede agregar un número de índice al final de la función. Si usa el comodín y
especifica un nombre único, la lista de Python resultante siempre tendrá un elemento, y se puede hacer referencia a
ella utilizando un valor de índice de 0.
mxd = arcpy.mapping.MapDocument("CURRENT")
riverLyr = arcpy.mapping.ListLayers(mxd, "Rivers")[0]
titleTxt = arcpy.mapping.ListLayoutElements(mxd, "TEXT_ELEMENT", "title")[0]
Los elementos de diseño de página tienen una propiedad separada llamada Nombre del elemento . Esto se puede
configurar en la pestaña Tamaño y Posición dentro del cuadro de diálogo Propiedades del elemento .
Los marcos de datos, las capas y las tablas no tienen una propiedad de nombre separada como con los elementos de
diseño de página. Su nombre se basa en la etiqueta que se ve en la tabla de contenido. Idealmente, todos los marcos
de datos, capas y tablas dentro de un solo documento de mapa recibirían un nombre único. Si hay casos en los que
necesita tener nombres duplicados pero necesita poder aislar un elemento de otro, deberá crear el documento de
mapa para que pueda distinguirse utilizando otras propiedades.
El siguiente código muestra un ejemplo de cómo las capas con el mismo nombre ' Calles ' en el mismo marco de datos
' Mapas del condado ' pueden aislarse aún más utilizando la propiedad de descripción del objeto Capa .
mxd = arcpy.mapping.MapDocument("C:/Project/Project.mxd")
df = arcpy.mapping.ListDataFrames(mxd, "County Maps")[0]
for lyr in arcpy.mapping.ListLayers(mxd):

if lyr.name == "Streets":
if lyr.description == "1:10000":
lyr.visible = True
if lyr.description == "1:100000":
lyr.visible = False
Cree elementos de diseño adicionales y muévalos dentro y fuera del

diseño de página cuando sea necesario
Puede haber una situación en la que está creando una serie de mapas y hay algunas páginas que tienen elementos de
mapa adicionales, por ejemplo, un marco de datos adicional, una imagen adicional o elementos de texto, y así
sucesivamente. En lugar de crear documentos de mapa separados solo para esos escenarios, puede crear un solo
documento de mapa con todos los elementos de diseño posibles, luego usar la lógica de script arcpy.mapping para
mover los elementos dentro y fuera de la página según sea necesario. Si un elemento se mueve fuera del límite del
diseño de página, no se imprimirá ni exportará.
En el siguiente ejemplo, el diseño resultante mostrará una barra de escala de estilo diferente según la escala del marco
de datos actual. Si la escala es mayor que 1: 25,000, las unidades de la barra de escala estarán en metros. Si la escala es
menor o igual a 1: 25,000, las unidades de la barra de escala estarán en kilómetros.
mxd = arcpy.mapping.MapDocument("C:/Project/Project.mxd")
m_scale = arcpy.mapping.ListLayoutElements(mxd, "MAPSURROUND_ELEMENT", "m scale bar")[0]
km_scale = arcpy.mapping.ListLayoutElements(mxd, "MAPSURROUND_ELEMENT", "km scale bar")[0]
df = arcpy.mapping.ListDataFrames(mxd, "Main DF")[0]
if df.scale < 25000:
m_scale.elementPositionX = 5 #on the page
km_scale.elementPostitionX = 15 #off the page
else:
m_scale.elementPositionX = 15 #off the page
km_scale.elementPostitionX = 5 #on the page
Temas relacionados
Introducción a arcpy.mapping
Introducción al tutorial de arcpy.mapping
29/11/2019 Lista alfabética de clases arcpy.mapping — Ayuda | ArcGIS for Desktop
Lista alfabética de clases arcpy.mapping

ArcMap 10.3
El |
Otras versiones
10,7
10,6
10,5
10,4
10,3
Las clases arcpy.mapping proporcionan acceso a varios métodos y propiedades para los diferentes tipos de objetos
encontrados en un documento de mapa ( .mxd ) o un archivo de capa ( .lyr ). Este documento está destinado a servir
como referencia rápida. Para obtener información más específica, use los enlaces para saltar a las páginas de ayuda
individuales.
clases arcpy.mapping
DataDrivenPages
Métodos
exportToPDF (out_pdf, {page_range_type}, {page_range_string}, {multiple_files}, {resolution},
{image_quality}, {image_quality}, {compress_vectors}, {image_compression}, {picture_symbol},
{convert_markers}, {embed_fonts}, {layers_attributes }, {georef_info}, {jpeg_compression_quality},
{show_selection_symbology})
getPageIDFromName (page_name)
printPages ({printer_name}, {page_range_type}, {page_range_string}, {out_print_file},
{show_selection_symbology})
refrescar()
Propiedades
currentPageID —Read / Write; Largo
dataFrame : solo lectura ; Objeto DataFrame
indexLayer : solo lectura ; Objeto de capa
pageCount : solo lectura ; Largo
pageNameField : solo lectura ; Objeto de campo GP
pageRow : solo lectura ; Objeto GP Row
páginas seleccionadas : solo lectura; Lista de Python de números de índice
Marco de datos
Métodos
panToExtent (extensión)
zoomToSelectedFeatures ()
Propiedades
créditos —Leer / Escribir; Cuerda
descripción —Leer / Escribir; Cuerda
displayUnits —Read / Write; Cuerda
elementHeight: lectura / escritura; Doble
elementPositionX —Leer / escribir; Doble
elementPositionY —Leer / Escribir; Doble
elementWidth —Leer / escribir; Cuerda
extensión —Leer / Escribir; Objeto GP Extent
Transformaciones geográficas: lectura / escritura; Lista de cadenas de Python
mapUnits : solo lectura ; Cuerda
nombre —Leer / Escribir; Cuerda
https://desktop.arcgis.com/es/arcmap/10.3/analyze/arcpy-mapping/alphabeticallistofclasses.htm 1/6
referenceScale —Leer / Escribir; Doble

rotación —Leer / Escribir; Doble
escala —Leer / Escribir; Doble
referencia espacial: lectura / escritura; Objeto de referencia espacial GP
tiempo : solo lectura; Objeto DataFrameTime
tipo : solo lectura; Cuerda
DataFrameTime
Métodos
resetTimeExtent ()
Propiedades
currentTime: lectura / escritura; Objeto de fecha y hora de Python
endTime —Leer / Escribir; Objeto de fecha y hora de Python
startTime —Leer / Escribir; Objeto de fecha y hora de Python
timeStepInterval : solo lectura ; Objeto timedelta de Python
timeWindow —Leer / Escribir; Doble
timeWindowUnits —Read / Write; Cuerda
GraduadoColoresSimbología
Métodos
reclasificar()
Propiedades
classBreakDescriptions —Read / Write; Lista de cadenas de Python
classBreakLabels —Leer / Escribir; Lista de cadenas de Python
classBreakValues —Read / Write; Lista de cadenas de Python
normalización —Leer / Escribir; Cuerda
numClasses —Leer / Escribir; Largo
valueField: lectura / escritura; Cuerda
Graduado Símbolos Simbología
Métodos
reclasificar()
Propiedades
GraphicElement
Métodos
clon ({sufijo})
borrar()
Propiedades
isGroup : solo lectura; Booleano
LabelClass
Propiedades
className —Leer / Escribir; Cuerda
expresión —Leer / Escribir; Cuerda
showClassLabels —Leer / Escribir; Booleano
SQLQuery —Leer / Escribir; Cuerda
Capa
Métodos
findAndReplaceWorkspacePath (find_workspace_path, replace_workspace_path, {validar})
getExtent ({symbolized_extent})
getSelectedExtent ({symbolized_extent})
getSelectionSet ()
replaceDataSource (workspace_path, workspace_type, dataset_name, {validate})
salvar()
saveACopy (nombre_archivo, {versión})
setSelectionSet (método, oidList)
apoyos (propiedad de capa)
updateLayerFromJSON (json_layer_definition)
Propiedades
brillo —Leer / Escribir; Largo
contraste —Leer / Escribir; Largo
créditos —Leer / Escribir; Cuerda
datasetName : solo lectura ; Cuerda
dataSource : solo lectura ; Cuerda
definitionQuery —Leer / escribir; Cuerda
isBroken : solo lectura ; Booleano
isFeatureLayer : solo lectura ; Booleano
isGroupLayer : solo lectura ; Booleano
isNetworkAnalystLayer : solo lectura ; Booleano
isRasterizingLayer : solo lectura ; Booleano
isRasterLayer : solo lectura ; Booleano
isServiceLayer —Lee -only; Booleano
labelClasses —Leer / Escribir; Lista de objetos LabelClass
longName : solo lectura ; Cuerda
maxScale: lectura / escritura; Doble
minScale —Leer / Escribir; Doble
serviceProperties : solo lectura ; Diccionario de conjuntos de propiedades
showLabels —Leer / Escribir; Booleano
simbología : solo lectura; Objeto de simbología de capa
symbologyType : solo lectura; Cuerda
tiempo : solo lectura; Objeto de tiempo de capa
transparencia: lectura / escritura; Largo
visible —Leer / Escribir; Booleano
workspacePath : solo lectura; Cuerda
LayerTime
Propiedades
ahorro de luz diurna : solo lectura; Booleano
displayDataCumulatively : solo lectura ; Booleano
endTime : solo lectura; Objeto de fecha y hora de Python
endTimeField : solo lectura ; Cuerda
isTimeEnabled : solo lectura ; Booleano
startTime : solo lectura; Objeto de fecha y hora de Python
startTimeField : solo lectura; Cuerda
timeFormat : solo lectura ; Cuerda
timeOffset : solo lectura ; Objeto timedelta de Python
timeStepInterval : solo lectura ; Objeto timedelta de Python
timeZone : solo lectura ; Cuerda
LegendElement
Métodos
ajustarColumnCount (column_count)
listLegendItemLayers ()
removeItem (legend_item_layer, {index})
updateItem (legend_item_layer, {legend_item_style_item}, {preserve_item_sizes}, {use_visible_extent},
{show_feature_count}, {use_ddp_extent}, {index})
Propiedades
autoAdd —Leer / Escribir; Booleano
isOverflowing : solo lectura ; Booleano
artículos : solo lectura; Lista de cadenas de Python
parentDataFrameName : solo lectura ; Cuerda
título —Leer / Escribir; Cuerda
MapDocument
Métodos
deleteThumbnail ()
findAndReplaceWorkspacePaths (find_workspace_path, replace_workspace_path, {validar})
makeThumbnail ()
replaceWorkspaces (old_workspace_path, old_workspace_type, new_workspace_path,
new_workspace_type, {validar})
salvar()
saveACopy (nombre_archivo, {versión})
Propiedades
activeDataFrame : solo lectura ; Objeto DataFrame
activeView: lectura / escritura; Cuerda
autor —Leer / Escribir; Cuerda
créditos : solo lectura; Cuerda
dataDrivenPages : solo lectura ; Objeto DataDrivenPages
dateExported : solo lectura ; Objeto de fecha y hora de Python
datePrinted : solo lectura ; Objeto de fecha y hora de Python
dateSaved : solo lectura ; Objeto de fecha y hora de Python
filePath : solo lectura; Cuerda
hyperlinkBase —Leer / Escribir; Cuerda
isDDPEnabled : solo lectura ; Booleano
pageSize : solo lectura; Python llamado tupla
relativePaths —Leer / escribir; Booleano
resumen —Leer / Escribir; Cuerda
etiquetas —Leer / Escribir; Cuerda
título —Leer / Escribir; Cuerda
MapsurroundElement
Propiedades
parentDataFrameName : solo lectura ; Cuerda
PDFDocument
Métodos
appendPages (pdf_path, {input_pdf_password})
attachFile (ruta_archivo, {descripción})

deletePages (page_range)
insertPages (pdf_path, {before_page_number}, {input_pdf_password})
guardar y cerrar()
updateDocProperties ({pdf_title}, {pdf_author}, {pdf_subject}, {pdf_keywords}, {pdf_open_view},
{pdf_layout})
updateDocSecurity ({new_master_password}, {new_user_password}, {cifrado}, {permisos})
Propiedades :
pageCount : solo lectura ; Largo
PictureElement
Propiedades
sourceImage —Leer / Escribir; Cuerda
RasterClassifiedSymbology
Métodos
reclasificar()
Propiedades
excludedValues —Leer / escribir; Cuerda
StyleItem
Propiedades
itemName : solo lectura ; Cuerda
itemCategory : solo lectura ; Cuerda
styleFolderName —Leer solo; Cuerda
TableView
Métodos
findAndReplaceWorkspacePath (find_workspace_path, replace_workspace_path, {validar})
getSelectionSet ()
replaceDataSource (workspace_path, workspace_type, dataset_name, {validate})
setSelectionSet (método, oidList)
Propiedades
datasetName : solo lectura ; Cuerda
dataSource : solo lectura ; Cuerda
definitionQuery —Leer / escribir; Cuerda
isBroken : solo lectura ; Booleano
workspacePath : solo lectura; Cuerda
TextElement
Métodos
clon ({sufijo})
borrar()
Propiedades

fontSize —Leer / Escribir; Doble
texto —Leer / Escribir; Cuerda
UniqueValuesSymbology
Métodos
addAllValues ()
Propiedades
classDescriptions —Leer / Escribir; Lista de cadenas de Python
classLabels —Leer / Escribir; Lista de cadenas de Python
classValues —Leer / Escribir; Lista de cadenas de Python
showOtherValues —Leer / Escribir; Booleano
29/11/2019 Lista alfabética de funciones arcpy.mapping — Ayuda | ArcGIS for Desktop
Lista alfabética de funciones arcpy.mapping

ArcMap 10.3
El |
Otras versiones
10.7
10.6
10.5
10.4
10.3
La siguiente es una lista de cada una de las funciones arcpy.mapping junto con sus parámetros de entrada requeridos y
opcionales. Este documento está destinado a servir como referencia rápida. Para obtener información más específica
sobre cada parámetro (tipo de datos, valor predeterminado, etc.), haga clic en el enlace correspondiente.
funciones arcpy.mapping
AddLayer (data_frame, add_layer, {add_position})
AddLayerToGroup (data_frame, target_group_layer, add_layer, {add_position})
AddTableView (data_frame, add_table)
AnalyzeForMSD (map_document)
AnalyzeForSD (sddraft)
ConvertToMSD (map_document, out_msd, {data_frame}, {msd_anti_aliasing}, {msd_text_anti_aliasing})
ConvertWebMapToMapDocument (webmap_json, {template_mxd}, {notes_gdb}, {extra_conversion_options})
CreateGISServerConnectionFile (connection_type, out_folder_path, out_name, server_url, server_type,

{use_arcgis_desktop_staging_folder}, {staging_folder_path}, {username}, {password}, {save_username_password})
CreateMapSDDraft (map_document, out_sddraft, service_name, {server_type}, {connection_file_path},

{copy_data_to_server}, {folder_name}, {summary}, {tags})
DeleteMapService (connection_url_or_name, server, service_name, {folder_name}, {connection_username},

{connection_password}, {connection_domain})
ExportReport (report_source, report_layout_file, output_file, {dataset_option}, {report_title}, {starting_page_number},

{page_range}, {report_definition_query}, {medida}, {field_map})
ExportToAI (map_document, out_ai, {data_frame}, {df_export_width}, {df_export_height}, {resolution}, {image_quality},

{colorspace}, {picture_symbol}, {convert_markers})
ExportToBMP (map_document, out_bmp, {data_frame}, {df_export_width}, {df_export_height}, {resolution}, {world_file},

{color_mode}, {rle_compression})
ExportToEMF (map_document, out_emf, {data_frame}, {df_export_width}, {df_export_height}, {resolution},

{image_quality}, {description}, {picture_symbol}, {convert_markers})
ExportToEPS (map_document, out_eps, {data_frame}, {df_export_width}, {df_export_height}, {resolution},

{image_quality}, {colorspace}, {ps_lang_level}, {image_compression}, {picture_symbol}, {convert_markers}, {embed_fon}
{jpeg_compression_quality})
ExportToGIF (map_document, out_gif, {data_frame}, {df_export_width}, {df_export_height}, {resolution}, {world_file},

{color_mode}, {gif_compression}, {background_color}, {transparent_color}, {imagen entrelazada})
https://desktop.arcgis.com/es/arcmap/10.3/analyze/arcpy-mapping/alphabeticallistoffunctions.htm 1/2
29/11/2019 Lista alfabética de funciones arcpy.mapping — Ayuda | ArcGIS for Desktop
ExportToJPEG (map_document, out_jpeg, {data_frame}, {df_export_width}, {df_export_height}, {resolution}, {world_file},

{color_mode}, {jpeg_quality}, {progresivo})
ExportToPDF (map_document, out_pdf, {data_frame}, {df_export_width}, {df_export_height}, {resolution},

{image_quality}, {colorspace}, {compress_vectors}, {image_compression}, {picture_symbol}, {convert_markers},
{embed_fonts} {layers_attributes}, {georef_info}, {jpeg_compression_quality})
ExportToPNG (map_document, out_png, {data_frame}, {df_export_width}, {df_export_height}, {resolution}, {world_file},

{color_mode}, {background_color}, {transparent_color}, {interlaced})
ExportToSVG (map_document, out_svg, {data_frame}, {df_export_width}, {df_export_height}, {resolution},

{image_quality}, {compress_document}, {picture_symbol}, {convert_markers}, {embed_fonts})
ExportToTIFF (map_document, out_tiff, {data_frame}, {df_export_width}, {df_export_height}, {resolution}, {world_file},

{color_mode}, {tiff_compression}, {geoTIFF_tags})
InsertLayer (data_frame, reference_layer, insert_layer, {insert_position})
Capa (lyr_file_path)
ListBookmarks (map_document, {comodín}, {data_frame})
ListBrokenDataSources (map_document_or_layer)
ListDataFrames (map_document, {comodín})
ListLayers (map_document_or_layer, {wildcard}, {data_frame})
ListLayoutElements (map_document, {element_type}, {wildcard})
ListMapServices (connection_url_or_name, servidor, {connection_username}, {connection_password},

{connection_domain})
ListPrinterNames ()
ListStyleItems (style_file_path, style_folder_name, {comodín})
ListTableViews (map_document, {wildcard}, {data_frame})
MapDocument (mxd_path)
MoveLayer (data_frame, reference_layer, move_layer, {insert_position})
PDFDocumentCreate (pdf_path)
PDFDocumentOpen (pdf_path, {user_password}, {master_password})
PrintMap (map_document, {printer_name}, {data_frame}, {out_print_file}, {image_quality})
PublishMSDToServer (msd_path, connection_url_or_name, server, service_name, {folder_name}, {service_capabilities},

{connection_username}, {connection_password}, {connection_domain})
RemoveLayer (data_frame, remove_layer)
RemoveTableView (data_frame, remove_table)
TableView (table_view_data_source)
UpdateLayer (data_frame, update_layer, source_layer, {symbology_only})
UpdateLayerTime (data_frame, update_layer, source_layer)
https://desktop.arcgis.com/es/arcmap/10.3/analyze/arcpy-mapping/alphabeticallistoffunctions.htm 2/2
29/11/2019 Lista alfabética de constantes arcpy.mapping — Ayuda | ArcGIS for Desktop
Lista alfabética de constantes arcpy.mapping

ArcMap 10.3
El |
Otras versiones
10.7
10.6
10.5
10.4
10.3
A continuación se muestra una lista de constantes de parámetros arcpy.mapping. Muchos de estos parámetros se usan
con múltiples funciones y / o métodos de arcpy.mapping. La mayoría de estos parámetros son opcionales (los que
están entre corchetes ({})) y, cuando corresponde, los valores predeterminados se indican junto al valor. Este
documento está destinado a servir como referencia rápida. Para obtener información más específica sobre el
significado de los valores de los parámetros, consulte la documentación de la función o el método utilizando los
enlaces que se encuentran junto al nombre del parámetro.
constantes arcpy.mapping
{add_position}: utilizado por AddLayer y AddLayerToGroup .
"AUTO_ARRANGE" -Default
"FONDO"
"PARTE SUPERIOR"
{colorspace}: utilizado por DataDrivenPages.exportToPDF , ExportToAI , ExportToEPS y ExportToPDF .
"CMYK"
"RGB": predeterminado
{color_mode}: utilizado por ExportToBMP , ExportToGIF , ExportToJPEG , ExportToPNG y ExportToTIFF .
"1-BIT_MONOCHROME_MASK"
"1-BIT_MONOCHROME_THRESHOLD"
"24-BIT_TRUE_COLOR": predeterminado para todas las funciones excepto ExportToGIF
"8-BIT_GRAYSCALE": predeterminado para ExportToGIF
"8-BIT_PALETTE"
connection_type— Usado por CreateGISServerConnectionFile .
"ADMINISTER_GIS_SERVICES"
"PUBLISH_GIS_SERVICES"
"USE_GIS_SERVICES"
{dataset_option}: utilizado por ExportReport .
"TODOS"
"DEFINITION_QUERY"
https://desktop.arcgis.com/es/arcmap/10.3/analyze/arcpy-mapping/constantslist.htm 1/6
"GRADO"
"SELECCIONADO"
"USE_RLF" -Default
displayUnits: una propiedad del objeto DataFrame .
"Centímetros"
"Grados decimales"
"Decimales GradosMinutos"
"DecimalDegreesSeconds"
"Decímetros"
"Pies"
"Pulgadas"
"Kilómetros"
"Metros"
"MGRS"
"Miles"
"Milímetros"
"Millas náuticas"
"Puntos"
"Desconocido"
"USNationalGrid"
"UTM"
"Yardas"
{element_type}: utilizado por ListLayoutElements .
"DATAFRAME_ELEMENT"
"GRAPHIC_ELEMENT"
"LEGEND_ELEMENT"
"MAPSURROUND_ELEMENT"
"PICTURE_ELEMENT"
"TEXT_ELEMENT"
{cifrado}: utilizado por PDFDocument.updateDocSecurity .
"AES_V1"
"AES_V2"
"RC4": predeterminado
{gif_compression}: utilizado por ExportToGIF .
"LZW"
"NINGUNO": predeterminado
"RLE"
{image_compression}: utilizado por DataDrivenPages.exportToPDF , ExportToEPS y ExportToPDF .
"ADAPTATIVO": predeterminado
"DESINFLAR"
"JPEG"
"LZW"
"NINGUNA"
"RLE"
{image_quality}: utilizado por DataDrivenPages.exportToPDF , ExportToAI , ExportToEMF , ExportToEPS , ExportToPDF ,

ExportToSVG e PrintMap .
"MEJOR": predeterminado
"MEJOR"
"MÁS RÁPIDO"
"LO MÁS RÁPIDO"
"NORMAL"
{insert_position}: utilizado por InsertLayer y MoveLayer .
"DESPUÉS"
"ANTES": predeterminado
{layers_attributes}: utilizado por DataDrivenPages.exportToPDF y ExportToPDF .
"LAYERS_AND_ATTRIBUTES"
"LAYERS_ONLY" -Default
"NINGUNA"
{layer_property}: utilizado por Layer.supports .
"BRILLO"
"CONTRASTE"
"CRÉDITOS"
"DATASETNAME"
"FUENTE DE DATOS"
"DEFINITIONQUERY"
"DESCRIPCIÓN"
"CLASES DE ETIQUETAS"
"NOMBRE LARGO"
"MAXSCALE"
"MINSCALE"
"NOMBRE"
"PROPIEDADES DEL SERVICIO"
"SHOWLABELS"
"SIMBOLOGÍA"
"TIPO DE SIMBOLOGÍA"
"HORA"
"TRANSPARENCIA"
"VISIBLE"
"TRABAJO ESPACIO DE TRABAJO"
{msd_anti_aliasing}: utilizado por ConvertToMSD .
"MEJOR"
"RÁPIDO"
"LO MÁS RÁPIDO"
"NORMAL"
{msd_text_anti_aliasing}: utilizado por ConvertToMSD .
"FUERZA": predeterminado
"NINGUNA"
"NORMAL"
{multiple_files}: utilizado por PDFDocument.exportToPDF .
"PDF_MULTIPLE_FILES_PAGE_INDEX"
"PDF_MULTIPLE_FILES_PAGE_NAME"
"PDF_SINGLE_PAGE" -Default
{page_range_type}: utilizado por DataDrivenPages.exportToPDF y DataDrivenPages.printPages .
"TODOS": predeterminado
"CORRIENTE"
"DISTANCIA"
"SELECCIONADO"
{pdf_layout}: utilizado por PDFDocument.updateDocProperties .
"DONT_CARE"
"UNA COLUMNA"
"SINGLE_PAGE" -Default
"TWO_COLUMN_LEFT"
"TWO_COLUMN_RIGHT"
"TWO_PAGE_LEFT"
"TWO_PAGE_RIGHT"
{pdf_open_view}: utilizado por PDFDocument.updateDocProperties .
"ADJUNTO ARCHIVO"
"PANTALLA COMPLETA"
"CAPAS"
"USE_BOOKMARKS"
"USE_NONE"
"USE_THUMBS" -default
"VIEWER_DEFAULT"
{permisos}: utilizado por PDFDocument.updateDocSecurity .
"TODOS": predeterminado
"ALL_MASTER"
"DUPDO"
"DOC_ASSEMBLY"
"EDITAR"
"EDITAR_NOTAS"
"FILL_AND_SIGN"
"HIGH_PRINT"
"ABIERTO"
"IMPRESIÓN"
"SEGURO"
{picture_symbol}: utilizado por DataDrivenPages.exportToPDF , ExportToAI , ExportToEMF , ExportToEPS , ExportToPDF

y ExportToSVG .
"RASTERIZE_BITMAP" -Default
"RASTERIZAR_ IMAGEN"
"VECTORIZE_BITMAP"
{ps_lang_level}: utilizado por ExportToEPS .
2
3: predeterminado
{record_set}: utilizado por ExportReport .
"TODOS"
"SELECCIONADO"
"USE_RLF" -Default
{rle_compression}: utilizado por ExportToBMP .
"RLE"
{save_username_password}: utilizado por CreateGISServerConnectionFile .
"DO_NOT_SAVE_USERNAME" -Default
"SAVE_USERNAME" -Default
{service_capabilities}: utilizado por PublishMSDToServer .
"MAPEO": predeterminado
"KML"
"WCS"
"WFS"
"WMS"
{tipo_servidor}: utilizado por CreateGISServerConnectionFile .
"ARCGIS_SERVER" -Default
"SPATIAL_DATA_SERVER"
{tipo_servidor}: utilizado por CreateMapSDDraft .
"ARCGIS_SERVER" -Default
"FROM_CONNECTION_FILE"
"MY_HOSTED_SERVICES"
"SPATIAL_DATA_SERVER"
symbologyType: una propiedad del objeto Layer .
"COLORES GRADUADOS"
"GRADUATED_SYMBOLS"
"OTRO"
"RASTER_CLASIFICADO"
"VALORES ÚNICOS"
{tiff_compression}: utilizado por ExportToTIFF .
"DESINFLAR"
"JPEG"
"LZW"
"PACK_BITS"
timeWindowUnits: una propiedad de DataFrameTime .
"siglos"
"décadas"
"dias"
"horas"
"milisegundos"
"minutos"
"meses"
"segundos"
"desconocido"
"semanas"
"años"
{versión}: utilizado por Layer.saveACopy y MapDocument.saveACopy .
"10.1": predeterminado
"10.0"
"8.3"
"9.0 / 9.1"
"9.2"
"9.3"
{workspace_type}: utilizado por Layer.replaceDataSource , MapDocument.replaceWorkspacePaths y

TableView.replaceDataSource .
"ACCESS_WORKSPACE"
"ARCINFO_WORKSPACE"
"CAD_WORKSPACE"
"EXCEL_WORKSPACE"
"FILEGDB_WORKSPACE"
"NINGUNA"
"OLEDB_WORKSPACE"
"PCCOVERAGE_WORKSPACE"
"RASTER_WORKSPACE"
"SDE_WORKSPACE"
"SHAPEFILE_WORKSPACE"
"TEXT_WORKSPACE"
"TIN_WORKSPACE"
"VPF_WORKSPACE"
29/11/2019 Actualización y reparación de orígenes de datos con arcpy.mapping — Ayuda | ArcGIS for Desktop
Actualización y reparación de fuentes de datos con arcpy.mapping

ArcMap 10.3
El |
Otras versiones
10.7
10.6
10.5
10.4
10.3
Existen numerosas razones por las cuales las fuentes de datos deben repararse o redirigirse a diferentes ubicaciones. La idea de hacer estos cambios manualmente en cada
documento de mapa afectado puede ser abrumadora. Los métodos están disponibles con el entorno de secuencias de comandos arcpy.mapping que permiten automatizar estos
cambios sin siquiera tener que abrir un documento de mapa. Usted tiene el control de actualizar las fuentes de datos para capas individuales, o puede actualizar todas las capas a
la vez que tienen un espacio de trabajo común. Hay breves debates disponibles con el tema de ayuda de cada método, pero este documento tiene la intención de resumirlos y
compararlos a todos.
Básicamente, existen dos tipos diferentes de métodos que funcionan en las clases MapDocument , Layer y TableView . Los nombres de los métodos cambian ligeramente según la
clase y los parámetros disponibles.
findAndReplaceWorkspacePath o findAndReplaceWorkspacePaths le permite sustituir una cadena completa o parcial por una ruta de espacio de trabajo de capa o
tabla. No se puede usar si el tipo de espacio de trabajo o el nombre del conjunto de datos ha cambiado. Es ideal para escenarios donde las letras de unidad cambian,
cambian a rutas UNC, actualizan la información del archivo de conexión SDE, etc. Consulte la sección Escenarios comunes a continuación.
replaceWorkspaces o replaceDataSource le permite cambiar la ruta del espacio de trabajo, el tipo de espacio de trabajo y / o cambiar el nombre del conjunto de datos.
Las capacidades de estos métodos se superponen; por lo tanto, hay varias formas de actualizar el espacio de trabajo o el conjunto de datos de una capa o tabla. El propósito de
este documento es discutir todos los métodos y sugerir las mejores prácticas para muchos escenarios comunes.
Se proporcionan varias definiciones para resumir los términos que se utilizan en este documento:
Un espacio de trabajo es un contenedor de datos. Un espacio de trabajo puede ser una carpeta que contiene elementos como archivos de forma, archivos CAD o rásteres,
o puede ser una cobertura de ArcInfo Workstation, geodatabase personal, geodatabase de archivos, conexión a SDE, etc.
Una ruta de espacio de trabajo es la ruta del sistema al espacio de trabajo. En el caso de los datos basados en archivos (por ejemplo, CAD, archivos de forma, rásteres),
incluye el nombre de la carpeta que contiene los datos. Con las geodatabases basadas en archivos, incluye el nombre de la geodatabase. Las rutas del espacio de trabajo
SDE están definidas por la ruta del sistema al archivo de conexión SDE.
Un tipo de espacio de trabajo es un formato de modelo de datos compatible con ArcGIS. Por ejemplo, shapefile, geodatabase personal, geodatabase de archivos, CAD,
SDE, etc.
Un conjunto de datos es la clase de entidad o tabla que se encuentra en un espacio de trabajo. Cuando se requiere un nombre de conjunto de datos, es el nombre del
objeto en el espacio de trabajo, no la forma en que aparece en la tabla de contenido de un documento de mapa.
Una fuente de datos para una capa o tabla es la combinación del espacio de trabajo y el conjunto de datos.
Métodos para actualizar y corregir fuentes de datos.

MapDocument.findAndReplaceWorkspacePaths (find_workspace_path, replace_workspace_path, {validar})
El método findAndReplaceWorkspacePaths en el objeto MapDocument está destinado a realizar una búsqueda y reemplazo global de rutas de espacio de trabajo
para todas las capas y tablas en un documento de mapa que comparten esa ruta de espacio de trabajo. Este método se puede usar para reemplazar la ruta a varios
tipos de espacio de trabajo a la vez (por ejemplo, archivos CAD, archivos de forma y geodatabases de archivos).
MapDocument.replaceWorkspaces (old_workspace_path, old_workspace_type, new_workspace_path, new_workspace_type, {validar})
El método replaceWorkspaces en el objeto MapDocument es similar al método findAndReplaceWorkspacePaths pero también le permite cambiar de un tipo de
espacio de trabajo a otro (por ejemplo, geodatabase personal a geodatabase de archivos). Generalmente, este método funciona en un tipo de espacio de trabajo a la
vez. Si necesita reemplazar más de un tipo de espacio de trabajo, use el método varias veces para cada tipo de espacio de trabajo. Consulte la sección "Notas
generales de uso" a continuación para conocer otros usos alternativos.
Layer.findAndReplaceWorkspacePath (find_workspace_path, replace_workspace_path, {validar})
El método findAndReplaceWorkspacePath en el objeto Layer está destinado a realizar una búsqueda y reemplazo de la ruta del espacio de trabajo para una sola capa
en un documento de mapa o un archivo de capa.
Layer.replaceDataSource (workspace_path, workspace_type, dataset_name, {validate})
El método replaceDataSource en el objeto Layer es similar al método findAndReplaceWorkspacePath , pero además de poder cambiar un tipo de espacio de trabajo,
el conjunto de datos también se puede cambiar. Este es el único método que le permite reemplazar el conjunto de datos de una capa dentro de un espacio de
trabajo. Esto es especialmente útil cuando el nombre de un conjunto de datos es diferente en el nuevo espacio de trabajo.
TableView.findAndReplaceWorkspacePath (find_workspace_path, replace_workspace_path, {validar})
El método findAndReplaceWorkspacePath en el objeto TableView está destinado a realizar una búsqueda y reemplazo de la ruta del espacio de trabajo para una sola
tabla en un documento de mapa.
TableView.replaceDataSource (workspace_path, workspace_type, dataset_name, {validate})
El método replaceDataSource en el objeto TableView es similar al método findAndReplaceWorkspacePath , pero además de poder cambiar un tipo de espacio de
trabajo, el conjunto de datos también se puede cambiar. Este es el único método que le permite reemplazar el conjunto de datos de una tabla dentro de un espacio
de trabajo. Esto es especialmente útil cuando el nombre de un conjunto de datos es diferente en el nuevo espacio de trabajo.
Notas generales de uso
La función ListBrokenDataSources () es útil para determinar qué capas o tablas están rotas en un documento de mapa o archivo de capa.
Estos métodos funcionan recursivamente a través de todas las capas y tablas. Esto significa que las tablas unidas y relacionadas también se buscan y actualizan (consulte la
sección "Limitaciones conocidas" a continuación).
Puede buscar y reemplazar todo o parte de una ruta de espacio de trabajo. Si reemplaza solo una parte de la ruta, asegúrese de que sea una cadena única. Por ejemplo,
encontrar solo una letra C y reemplazarla con una letra D para una unidad da un resultado menos predecible que encontrar r "C: \" y reemplazarla con r "D: \" .
Usar un nombre de capa para aislar una fuente de datos no es infalible porque es posible tener múltiples fuentes de datos con el mismo nombre de capa. Puede ser
necesario usar otras propiedades de capa para aislar de manera única una capa.
No incluya los nombres de conjuntos de datos de entidades de geodatabase en la ruta del espacio de trabajo. Los conjuntos de datos de entidades son parte del espacio de
trabajo. Si una clase de entidad, por ejemplo, pasa de ser una clase de entidad independiente a un conjunto de datos de entidad de geodatabase, se abrirá un documento
de mapa sin romper la capa.
Los parámetros de ruta del espacio de trabajo no deben incluir el nombre del conjunto de datos de la capa o la tabla; por lo tanto, muchos de los métodos anteriores no
funcionarán si el nombre del conjunto de datos de una capa o tabla ha cambiado. El método replaceDataSource en los objetos Layer y TableView se adapta a este escenario.
Al cambiar espacios de trabajo mediante el método replaceWorkspaces , los nombres de los conjuntos de datos deben ser idénticos. Por ejemplo, un archivo de forma
llamado Highways.shp puede redirigirse a un espacio de trabajo de geodatabase de archivos solo si el nombre del conjunto de datos en la geodatabase de archivos
también se llama Highways . Utilice el método replaceDataSource en los objetos Layer o TableView si el nombre del conjunto de datos es diferente.
Si se usa una cadena vacía ( "" ) para el parámetro old_workspace_path y "NONE" se usa para el parámetro old_workspace_type , todas las fuentes de datos se
corresponden con el nuevo espacio de trabajo. Esto le permite redirigir múltiples espacios de trabajo a un solo espacio de trabajo utilizando un único método. Solo
https://desktop.arcgis.com/es/arcmap/10.3/analyze/arcpy-mapping/updatingandfixingdatasources.htm 1/4
se puede usar una cadena vacía con la palabra clave NONE .
El parámetro opcional de validación
Este parámetro le permite probar primero para ver si el nuevo origen de datos existe antes de cambiar o reemplazar el origen de datos de una capa o tabla.
Si validar es Verdadero y la nueva fuente de datos existe y es válida, la fuente de datos original se actualizará a la nueva fuente de datos; de lo contrario, seguirá apuntando
a la fuente de datos original y no se actualizará nada.
Si validar es falso , el nuevo origen de datos no tiene que ser válido, es decir, es posible que aún no exista. Esto puede ser útil para escenarios que requieren que las fuentes
de datos se actualicen antes de que se creen los datos. Tenga en cuenta que, en estos casos, los datos aparecerían rotos en los documentos de mapa o archivos de capa
asociados.
Al usar los métodos findAndReplaceWorkspacePath o findAndReplaceWorkspacePaths , el parámetro validar se aplica al parámetro replace_workspace_path .
Cuando se utiliza el método replaceWorkspacePaths , el parámetro de validación se aplica a los parámetros new_workspace_path y new_workspace_type .
Cuando se utiliza el método replaceDataSource , el parámetro validar se aplica al parámetro dataset_name .
Trabajando con conexiones SDE
La ruta del espacio de trabajo para las conexiones SDE es la ruta al archivo de conexión SDE (.sde) . Puede proporcionar la ruta completa al archivo, o en el caso de que el
archivo de conexión aparezca en la carpeta Conexiones de base de datos , también puede usar esa cadena en la ruta, por ejemplo, find_workspace_path = r "Conexiones de
base de datos \ myConnectionFile.sde"
La información del archivo de conexión SDE utilizada en el script debe ser idéntica a la conexión SDE que se utilizó para agregar datos a un documento de mapa o archivo
de capa. Por ejemplo, puede tener dos archivos de conexión SDE idénticos en dos ubicaciones separadas. Si los datos se agregaron a un mapa usando la primera ruta del
archivo de conexión, pero usa la segunda ruta del archivo de conexión en el script, las fuentes de datos no se actualizarán como se esperaba.
La propiedad dataSource en los objetos Layer y TableView proporciona una forma de determinar la ruta que se está utilizando en el documento de mapa o archivo de
capa. Use este valor para ayudar a determinar qué ruta de archivo de conexión SDE debe usarse. Aquí hay un ejemplo:
lyr.findAndReplaceWorkspacePath(find_workspace_path=lyr.workspacePath, replace_workspace_path=r"C:\Newpath\To\SDE_ConnectionFile.sde")
Al eliminar la información de contraseña de las conexiones SDE para que ya no se conserve en un documento de mapa o archivo de capa, es necesario configurar validate =
False . Esto debe hacerse porque si intenta utilizar un archivo de conexión SDE que no conserve toda la información de conexión adecuada, la conexión obviamente fallará.
Establecer validate = False forzará el uso del nuevo archivo de conexión, y se le solicitará al usuario la información de inicio de sesión cuando abra un documento de mapa
que contenga los datos SDE.
Limitaciones conocidas
Los conjuntos de datos esquemáticos no se pueden actualizar debido a las tablas ocultas que forman parte de su diseño.
Los conjuntos de datos de NetCDF solo se pueden actualizar parcialmente. Los métodos findAndReplaceWorkspacePath y findAndReplaceWorkspacePaths funcionan pero
los métodos replaceWorkspaces o replaceDataSource no proporcionan un tipo de espacio de trabajo NetCDF .
Las conexiones del servidor de bases de datos que se conectan directamente a las bases de datos SQL Server Express actualmente no son compatibles. Como solución
alternativa, cree una conexión de base de datos espacial a la base de datos SQL Server Express y úsela en su lugar.
Las uniones y relaciones asociadas con capas ráster no se actualizarán.
Las consultas SQL no se actualizan automáticamente. Diferentes espacios de trabajo (por ejemplo, frente a geodatabase de archivos personales) utilizan diferentes sintaxis
SQL para las consultas de definición de capa, y esta sintaxis no se actualiza automáticamente. La sintaxis se puede corregir actualizando la propiedad definitionQuery del
objeto Layer . Las funciones simples de cadena Python están disponibles para realizar operaciones básicas de búsqueda y reemplazo. Algunos ejemplos son los siguientes:
Para geodatabases personales, nombres de campo aparecen entre corchetes ( [] ), mientras que las geodatabases de archivos están encerrados entre comillas ( "" ).
Los caracteres comodín para las geodatabases personales son asterisco ( * ) y signo de interrogación ( ? ), Mientras que los comodines para las geodatabases de
archivos son símbolo de porcentaje ( % ) y guión bajo ( _ ).
Las búsquedas de cadenas no distinguen entre mayúsculas y minúsculas para las geodatabases personales, pero distinguen entre mayúsculas y minúsculas para las
geodatabases de archivos.
Las geodatabases personales usan UCASE y LCASE para convertir mayúsculas y minúsculas. Las geodatabases de archivos usan SUPERIOR e INFERIOR .
Las fechas y horas en las geodatabases personales se delimitan mediante el signo de número ( # ), mientras que las geodatabases de archivos son precedidos por la
palabra fecha .
Las expresiones de etiqueta de capa tampoco se actualizan automáticamente. Estos también deberán cambiarse para admitir la sintaxis SQL adecuada. La sintaxis se puede
corregir actualizando las propiedades LabelClass SQLQuery o expresión de la capa .
Las selecciones guardadas dentro de un documento de mapa se borran cuando se actualiza el origen de datos de una capa (este también es el caso cuando se usa
Establecer origen de datos a través del cuadro de diálogo Propiedades de capa en ArcMap). Actualmente no existe una solución alternativa para esto, aparte de volver a
crear manualmente las selecciones de características del documento de mapa.
Escenarios comunes
Los datos basados en archivos se mueven a una carpeta diferente o se ubican en una unidad de red diferente
O bien, la letra de la unidad de red asignada cambia, la estructura de la carpeta para la ubicación de los datos cambia u ocurre algo más que rompe el enlace a los datos existentes
que deben actualizarse. En este escenario, se trata simplemente de redirigir las mismas fuentes de datos a la nueva ubicación de carpeta o nombre de unidad. Este escenario se
aplica a casi todas las estructuras de datos basadas en archivos, incluidos los archivos de conexión de bases de datos espaciales (por ejemplo, archivos de forma, datos CAD,
geodatabases personales y de archivos, rásteres basados en archivos).
En este escenario, los datos se ubicaron directamente debajo de la carpeta C: \ Project \ Data pero se movieron a una subcarpeta llamada Data2 . Este script actualiza un solo
documento de mapa.
import arcpy
mxd = arcpy.mapping.MapDocument(r"C:\Project\Project.mxd")
mxd.findAndReplaceWorkspacePaths(r"C:\Project\Data", r"C:\Project\Data2")
mxd.saveACopy(r"C:\Project\Project2.mxd")
del mxd
Cambiar una ruta local a una ruta UNC
En este escenario, un usuario quiere compartir documentos de mapa con otro personal que tenga acceso a la unidad del usuario y no quiere que el personal tenga que copiar los
datos en sus unidades locales para que puedan abrir el documento de mapa con éxito.
Este escenario implica cambiar una ruta del sistema local a una ruta UNC. Este script actualiza todos los documentos de mapa en una carpeta.
import arcpy, os
folderPath = r"C:\Project"
for filename in os.listdir(folderPath):
fullpath = os.path.join(folderPath, filename)
if os.path.isfile(fullpath):
basename, extension = os.path.splitext(fullpath)
if extension.lower() == ".mxd":
mxd = arcpy.mapping.MapDocument(fullpath)
mxd.findAndReplaceWorkspacePaths(r"C:\Project\Data", r"\\ComputerName\Project\Data")
mxd.save()
del mxd
Se cambian las propiedades de conexión SDE
Existen numerosas razones por las cuales esto puede suceder, tal vez se cambie el nombre del servidor y / o el número de puerto; una conexión incluye credenciales de inicio de
sesión y, por razones de seguridad, deben eliminarse; se cambia la contraseña; las conexiones cambian de una conexión de tres niveles a una conexión de dirección de dos niveles;
o desea apuntar capas a una versión diferente. Independientemente del escenario específico, al modificar las propiedades de conexión de la base de datos espacial, todo lo que
necesita hacer es pasar la ruta al archivo de conexión.
En este escenario, un usuario quiere cambiar la versión de la geodatabase para todas las capas del mapa. El usuario crea un nuevo archivo de conexión SDE y reemplaza el archivo
de conexión original con el nuevo archivo de conexión.
import arcpy
mxd = arcpy.mapping.MapDocument(r"C:\Project\Project_default.mxd")
mxd.findAndReplaceWorkspacePaths(r"C:\Project\Connection to Default.sde",
r"C:\Project\Connection to Version1.sde")
mxd.saveACopy(r"C:\Project\Project_V1.mxd")
del mxd
En este escenario, un usuario desea eliminar la información de contraseña guardada en un documento de mapa. Las fuentes de datos en el documento de mapa provienen de un
archivo de conexión SDE donde la información de contraseña se guardó con la información de conexión. Luego, el usuario creó un nuevo archivo de conexión SDE a la misma base
de datos, pero esta vez no guardó la información de la contraseña. En el siguiente script, el parámetro de validación debe establecerse en False para que la información de
contraseña se elimine correctamente. Después de ejecutar el script, un usuario deberá iniciar sesión para abrir el documento de mapa resultante.
import arcpy
mxd = arcpy.mapping.MapDocument(r"C:\Project\Project_default.mxd")
mxd.findAndReplaceWorkspacePaths(r"C:\Project\Connection with password info saved.sde",
r"C:\Project\Connection with no password info saved.sde", False)
mxd.saveACopy(r"C:\Project\Project_NP.mxd")
del mxd
Los datos se migran de un tipo de espacio de trabajo a otro tipo de espacio de trabajo
Algunos escenarios comunes implican la migración de datos, como archivos de forma y geodatabases personales, a una geodatabase de archivos o desde una geodatabase de
archivos a una conexión SDE empresarial. Debido a que los espacios de trabajo de geodatabase tienen diferencias sutiles, es importante revisar la sección "Limitaciones conocidas"
anterior para comprender mejor los elementos adicionales que pueden necesitar ser abordados.
Este escenario implica la actualización de dos espacios de trabajo diferentes en un documento de mapa. Primero, los archivos de forma se redirigen a una geodatabase de archivos
llamada Parcels.gdb . En segundo lugar, las capas de una geodatabase personal se redirigen a otra geodatabase de archivos llamada Transportation.gdb .
import arcpy
mxd.replaceWorkspaces(r"C:\Project\Data", "SHAPEFILE_WORKSPACE", r"C:\Project\Data\Parcels.gdb", "FILEGDB_WORKSPACE")
mxd.replaceWorkspaces(r"C:\Project\Data\Transportation.mdb", "ACCESS_WORKSPACE", r"C:\Project\Data\Transportation.gdb", "FILEGDB_WORKSPACE")
del mxd
Este ejemplo es idéntico al ejemplo anterior, excepto que todas las fuentes de datos se dirigen a una única geodatabase de archivos. Se pueden redirigir varios tipos de espacio de
trabajo a un solo tipo de espacio de trabajo si se usa un valor de NINGUNO en lugar del parámetro old_workspace_type .
import arcpy
mxd.replaceWorkspaces("", "NONE", r"C:\Project\Data\BackgroundData.gdb","FILEGDB_WORKSPACE")
El siguiente escenario redirige todas las capas desde una geodatabase personal a una geodatabase de archivos. También corrige las expresiones SQL para la propiedad
definitionQuery de una capa y la propiedad SQLQuery de una clase de etiqueta . Por ejemplo, las geodatabases personales tienen corchetes ( [] ) alrededor de los nombres de
campo, mientras que las geodatabases de archivos usan comillas dobles ( "" ). Los caracteres comodín también se reemplazan.
import arcpy
mxd.replaceWorkspaces(r"C:\Project\Data\Parcels.mdb", "ACCESS_WORKSPACE",
r"C:\Project\Data\Parcels.gdb", "FILEGDB_WORKSPACE")
if lyr.supports("DEFINITIONQUERY"):
lyr.definitionQuery = lyr.definitionQuery.replace("[", "\"")
lyr.definitionQuery = lyr.definitionQuery.replace("]", "\"")
lyr.definitionQuery = lyr.definitionQuery.replace("*", "%")
if lyr.supports("LABELCLASSES"):
for lblClass in lyr.labelClasses:
lblClass.SQLQuery = lblClass.SQLQuery.replace("[", "\"")
lblClass.SQLQuery = lblClass.SQLQuery.replace("]", "\"")
lblClass.SQLQuery = lblClass.SQLQuery.replace("*", "%")
del mxd
Los conjuntos de datos individuales se mueven a una nueva ubicación de carpeta
Hay escenarios en los que solo se mueven conjuntos de datos individuales y no espacios de trabajo completos. En lugar de intentar actualizar todas las capas en un documento de
mapa, a veces tiene sentido centrarse solo en los elementos individuales que se han movido.
En este escenario, una clase de entidad individual llamada MapIndex se movió de una geodatabase de archivos en una carpeta llamada Datos a una copia de la geodatabase de
archivos en una carpeta diferente llamada Datos2 .
import arcpy
if lyr.supports("DATASOURCE"):
if lyr.dataSource == r"C:\Project\Data\Parcels.gdb\MapIndex":
lyr.findAndReplaceWorkspacePath(r"Data", r"Data2")
del mxd
Los conjuntos de datos individuales se mueven dentro y fuera de un conjunto de datos de características de geodatabase
Los conjuntos de datos de características de geodatabase son parte de un espacio de trabajo y sus nombres no deben incluirse en la ruta del espacio de trabajo. Si una clase de
entidad se mueve dentro o fuera de un conjunto de datos de entidad de geodatabase dentro del mismo espacio de trabajo, no se debe hacer nada en términos de actualización
de documentos de mapas o fuentes de datos de archivos de capa. Si un conjunto de datos se mueve a un espacio de trabajo diferente, pero del mismo tipo de espacio de trabajo,
proporcione una ruta al nuevo espacio de trabajo, sin el nombre del conjunto de datos de características de la geodatabase. Si el tipo de espacio de trabajo es diferente, usar
findAndReplaceWorkspacePath en una capa no funcionará y deberá usar replaceDataSource en su lugar.
En este escenario, una clase de entidad se movió de ser independiente en una geodatabase de archivos a un conjunto de datos de entidades en otra geodatabase de archivos.
import arcpy
if lyr.dataSource == r"C:\Project\Data\Parcels.gdb\MapIndex":
lyr.findAndReplaceWorkspacePath(r"Parcels.gdb", r"Transportation.gdb")
del mxd
Se cambia el nombre de una clase de entidad
Los cambios de esquema son comunes y, a veces, se cambia el nombre de una clase de entidad. En este escenario, todas las capas que apuntan a ese conjunto de datos se
romperán necesariamente.
En este escenario, se cambió el nombre de una clase de entidad de MajorRoads a Highways , por lo tanto, rompió capas individuales en un documento de mapa o archivo de capa.
El script evaluará solo las fuentes de datos rotas utilizando la función ListBrokenDataSources () y realizará la corrección adecuada.
import arcpy
for lyr in arcpy.mapping.ListBrokenDataSources(mxd):
if lyr.dataSource == r"C:\Project\Data\Transportation.gdb\MajorRoads":
lyr.replaceDataSource(r"C:\Project\Data\Transportation.gdb", "FILEGDB_WORKSPACE", "Highways")
lyr.name = "Highways"
del mxd

Arcpy

Caricato da

Informazioni sul documento

Descrizione originale:

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Arcpy

Caricato da

Copyright:

Formati disponibili

29/11/2019 Introducción al tutorial de arcpy.

mapping — Ayuda | ArcGIS for Desktop

Introducción al tutorial de arcpy.mapping

1. Abra un nuevo documento de mapa vacío en ArcMap.

Hacer referencia a un documento de mapa existente

1. En la ventana de Python , escriba lo siguiente y presione ENTRAR cuando haya terminado:

>>> mxd = arcpy.mapping.MapDocument("CURRENT")

>>> mxd.author = "YOUR NAME GOES HERE"

>>> print mxd.filePath

Debería ver la ruta impresa en el panel de código:

Agregar un archivo de capa al documento de mapa

1. En la ventana de Python , escriba lo siguiente:

>>> df = arcpy.mapping.ListDataFrames(mxd, "Layers")[0]

La función ListDataFrames requiere una referencia a un documento de mapa y, opcionalmente, un filtro

>>> lyrFile = arcpy.mapping.Layer(r"C:\Project\data\Rivers.lyr")

>>> arcpy.mapping.AddLayer(df, lyrFile)

Exportar un documento de mapa a PDF

>>> arcpy.mapping.ExportToPDF(mxd, r"C:\Project\Doc1.pdf")

Haga referencia a una capa utilizando la función ListLayers, cambie las

1. En la ventana de Python , escriba lo siguiente:

>>> lyr = arcpy.mapping.ListLayers(mxd)[0]

>>> lyr.name = "Some New Name"

La tabla de contenido y la vista de datos se actualizan.

Su ventana de Python debería ser similar al gráfico a continuación:

Cambiar la extensión del marco de datos

>>> lyr.visible = True

2. En ArcMap, seleccione gráficamente una o más entidades en su capa.

>>> lyrExtent = lyr.getSelectedExtent()

Su ventana de Python debería ser similar al gráfico a continuación:

Exportar un documento de mapa a PDF (nuevamente)

>>> arcpy.mapping.ExportToPDF(mxd, r"C:\Project\Doc2.pdf")

Su ventana de Python debería ser similar al gráfico a continuación:

Cree un nuevo documento PDF y agregue sus dos páginas

El primer paso es crear un nuevo documento PDF.

1. En la ventana de Python , escriba lo siguiente y presione ENTRAR cuando haya terminado:

>>> PDFdoc = arcpy.mapping.PDFDocumentCreate(r"C:\Project\Final.pdf")

Pautas para arcpy.mapping

Pautas para arcpy.mapping

Debe funcionar con documentos de mapa o archivos de capa existentes

Reemplazar la fuente de datos de una capa.

Haga referencia a un documento de mapa en el disco o use la palabra

Agregar capas y trabajar con documentos de mapa de plantilla

Crea todos los objetos con un nombre único

for lyr in arcpy.mapping.ListLayers(mxd):

Cree elementos de diseño adicionales y muévalos dentro y fuera del

Introducción al tutorial de arcpy.mapping

Lista alfabética de clases arcpy.mapping

referenceScale —Leer / Escribir; Doble

Graduado Símbolos Simbología

SQLQuery —Leer / Escribir; Cuerda

attachFile (ruta_archivo, {descripción})

elementPositionX —Leer / escribir; Doble

Lista alfabética de funciones arcpy.mapping

AddLayerToGroup (data_frame, target_group_layer, add_layer, {add_position})

AddTableView (data_frame, add_table)

ConvertToMSD (map_document, out_msd, {data_frame}, {msd_anti_aliasing}, {msd_text_anti_aliasing})

ConvertWebMapToMapDocument (webmap_json, {template_mxd}, {notes_gdb}, {extra_conversion_options})

CreateGISServerConnectionFile (connection_type, out_folder_path, out_name, server_url, server_type,

CreateMapSDDraft (map_document, out_sddraft, service_name, {server_type}, {connection_file_path},

DeleteMapService (connection_url_or_name, server, service_name, {folder_name}, {connection_username},

ExportReport (report_source, report_layout_file, output_file, {dataset_option}, {report_title}, {starting_page_number},

ExportToAI (map_document, out_ai, {data_frame}, {df_export_width}, {df_export_height}, {resolution}, {image_quality},

ExportToBMP (map_document, out_bmp, {data_frame}, {df_export_width}, {df_export_height}, {resolution}, {world_file},