Dicas e Truques de Python no ArcGIS

TravisOrmsby

Confira o seminário de treinamento Python Tips and Tricks for ArcGIS onde @DerekNelson1 e eu mostramos dezenas de estratégias para ajudar você a automatizar tarefas repetitivas e fluxos de trabalho complexos.

Procure soluções existentes antes de começar do zero.

As chances são muito boas de que outra pessoa já tenha tido um problema semelhante e criado um módulo Python que você pode usar para ajudar a resolver a questão. 

ArcPy é para os tipos de tarefas que você faria no ArcGIS Pro.

Se você está procurando automatizar tarefas de geoprocessamento ou trabalhar com arquivos locais e bancos de dados, a biblioteca ArcPy tem funções Python que replicam as coisas que você pode fazer manualmente na interface gráfica do usuário.

O ArcGIS API for Python é para os tipos de tarefas que você faria em seu portal.

Automatizar o gerenciamento de usuários, grupos e conteúdo em seu portal ArcGIS Online ou ArcGIS Enterprise é um ótimo caso de uso para o ArcGIS API for Python. A API Python também possui ferramentas para criar um Spatially Enabled DataFrame a partir de dados locais ou serviços de feição. Esta é uma extensão de um Pandas DataFrame, então vem com todo o poder da manipulação tabular de dados do Pandas junto com propriedades espaciais e métodos para lidar com dados geográficos.

Notebooks são ótimos para ensino, compartilhamento e narrativa com código.

A capacidade de dividir o código em células, adicionar markdown para explicar o código e incluir a saída no notebook os torna ferramentas poderosas para ajudar a iterar seu código e ajudar outros a entender o contexto e a importância do trabalho representado no notebook.

Um IDE tem ferramentas poderosas para facilitar a escrita de código.

Um ambiente de desenvolvimento integrado como PyCharm ou VS Code inclui ferramentas sofisticadas de depuração, detecção de erros e avisos, linting automatizado e ferramentas úteis de autocompletar código para facilitar a escrita de muito código. Está se tornando comum até mesmo que IDEs integrem assistentes de código AI para acelerar ainda mais o desenvolvimento.

Gerenciar um ambiente Python é difícil. Espere encontrar desafios.

Cada módulo em um ambiente Python precisa ser compatível com todos os outros módulos do ambiente. Pode ser fácil quebrar seu ambiente acidentalmente de maneiras sutis.

Use o ambiente Python padrão do ArcGIS Pro para minimizar desafios.

Felizmente, o ambiente arcgispro-py3 que vem com o ArcGIS Pro tem um conjunto de pacotes selecionados por desenvolvedores Esri que contém as bibliotecas que você precisará para a grande maioria das tarefas GIS. Como você não pode alterar este ambiente padrão, sempre terá pelo menos um ambiente Python funcional se estiver trabalhando com ArcGIS Pro.

Clone o ambiente padrão para criar um ambiente personalizado.

Para aqueles casos em que você precisa de bibliotecas adicionais que não estão incluídas no arcgispro-py3, você pode clonar o ambiente padrão e adicionar essas bibliotecas pelo Gerenciador de Pacotes na aba Projeto do ArcGIS Pro. Você tem acesso a milhares de bibliotecas Python através do conda que pode instalar pela interface.

Use conda para gerenciamento avançado do ambiente. Evite pip se possível.

Algumas tarefas avançadas requerem gerenciamento mais complexo do ambiente do que pode ser feito pela interface do ArcGIS Pro. Você pode acessar conda pelo prompt de comando para essas tarefas, como especificar um canal particular para obter um pacote ou exportar seu ambiente como arquivo texto. Embora seja possível instalar pacotes com pip, você corre o risco de instalar pacotes incompatíveis, porque pip não resolve completamente todas as dependências em seu ambiente. Às vezes é necessário usar pip se um pacote requerido não estiver disponível em nenhum canal conda, mas é melhor evitar usá-lo se possível.

Esteja ciente das dependências e licenças dos pacotes/bibliotecas listadas no Gerenciador de Pacotes.

O Gerenciador de Pacotes ajudará você a identificar dependências para todas as suas bibliotecas instaladas. Ele também vincula à licença para quaisquer pacotes disponíveis para instalação, assim você pode ter certeza que os requisitos da licença são compatíveis com seu caso de uso.

Enviar para janela Python/Notebook.

Você pode arrastar e soltar uma ferramenta do painel Geoprocessing na janela Python para obter a sintaxe correta da ferramenta. Em versões recentes do ArcGIS Pro, você também pode arrastá-la para um ArcGIS Notebook.

Aproveite recursos existentes como modelos ModelBuilder.

Se você já tem um modelo que executa uma tarefa, não precisa reescrevê-lo do zero para usar em um script Python. Você pode chamar o modelo como uma ferramenta geoprocessamento em seu script. Você também tem a opção de fazer o ArcGIS Pro exportar seu modelo como código Python.

Verifique se arquivos e classes de feição existem antes de executar código sobre eles.

A função Exists testará se um objeto de dados particular realmente existe ou não. Se não existir, você pode pular a execução de parte do código. Estratégias para retornos antecipados ajudam seu código a rodar mais rápido.

Verifique se linhas/valores existem antes da execução.

Mesmo se um objeto de dados existir, ele pode estar vazio. Você pode usar a função GetCount para identificar se uma tabela está vazia e pular a execução do código nesse caso.

Parametrize elementos do modelo para permitir entrada do usuário.

Modelos com parâmetros são mais fáceis de incorporar em um script porque você pode programaticamente inserir diferentes valores de entrada para seus parâmetros.

Copie Comando Python da interface gráfica do usuário no ArcGIS Pro.

Quando você abre uma ferramenta no painel Geoprocessing, há uma pequena seta apontando para cima ao lado do botão Executar. Uma das opções é Copiar Comando Python. Isso copiará um trecho Python que representa os parâmetros necessários para replicar os parâmetros que você preencheu na interface do usuário. Esta é nossa dica mais impactante para usuários familiarizados com tarefas geoprocessamento no ArcGIS Pro mas novos em Python. Você pode ver a correspondência entre os parâmetros escolhidos na interface familiar e os valores passados como argumentos à função Python. Além disso, além de obter uma cópia do comando Python pelo painel Geoprocessing, você também pode clicar com o botão direito em qualquer item no Histórico Geoprocessing e obter o mesmo trecho.

Use Copiar Caminho na interface ArcGIS Pro.

Caminhos de arquivo são difíceis de digitar e é fácil cometer erros. No painel Catálogo do ArcGIS Pro, você pode clicar com o botão direito em um objeto de dados e Copiar Caminho para não precisar digitá-lo. 

Verifique regularmente se seu código está retornando resultados esperados enquanto constrói.

Você não quer passar horas escrevendo código sem verificar se ele realmente funciona. Quanto mais código escrever entre testes, mais código terá que verificar por bugs quando inevitavelmente falhar. Verificações frequentes podem ajudar a identificar códigos problemáticos cedo.

Seaborn é ótimo para gráficos/chartas.

Visualizações gráficas podem ajudar você (e outras pessoas) a entender melhor seus dados. Seaborn é uma boa biblioteca para criar essas visualizações e quando executada em notebook, você vê a saída diretamente junto ao seu código.

 

import seaborn as sns

# Dicionário de valores
cryptid_data = {
    "Lochness Monster":LochnessMonsterCount, 
    "Chupacabra":ChupacabraCount, 
    "Bigfoot":BigfootCount
}

# Gráfico de barras a partir do dicionário
cryptid_plot = sns.barplot(
    x=list(cryptid_data.keys()), 
    y=list(cryptid_data.values())
)

 

Nunca coloque credenciais de login em seu código.

Isto é um enorme risco à segurança. O ArcGIS API for Python permite aproveitar as credenciais de login do seu ambiente se estiver trabalhando no ArcGIS Pro, Notebook Server ou ArcGIS Online

Notebook. Você também pode usar perfis, que utilizam as ferramentas de gerenciamento de segredos do seu sistema operacional, ou PKI que usa certificados de segurança. Confira a documentação Trabalhando com diferentes esquemas de autenticação para mais detalhes.<\/P>

Notebooks possuem saída rica que pode incluir imagens, hyperlinks e texto formatado.<\/STRONG><\/P>Isso é parte do que torna um notebook tão ótimo para ensino e compartilhamento. A saída rica ajuda as pessoas a entenderem melhor os resultados do trabalho que você fez no seu código.<\/P>Use parâmetros adicionais para refinar sua busca na ArcGIS API for Python.<\/STRONG><\/P>O método search do ContentManager pode buscar por categorias ou item_type ou por uma consulta em vários campos. Você pode ver alguns exemplos de consultas neste artigo da base de conhecimento.<\/P>Atribua nomes significativos às variáveis dos objetos com os quais você trabalha.<\/STRONG><\/P>Atribuir nomes às variáveis permitirá que você utilize os valores que criar. Dar nomes significativos ajudará você a entender o que esses valores representam. <\/P> <\/P>x = 2405<\/code><\/pre> <\/P>Não significa realmente nada.<\/P> <\/P>population = 2405<\/code><\/pre> <\/P>Fornece o contexto relevante para o valor dentro do script.<\/P>Esteja ciente do tipo específico de objeto com o qual está trabalhando.<\/STRONG><\/P>Diferentes objetos têm propriedades e métodos diferentes. É fácil se confundir com tipos semelhantes de objetos, como FeatureLayerCollection, FeatureLayer e FeatureSet. Use verificação de tipo para confirmar com o que você está trabalhando, e a documentação para verificar o que pode fazer com um objeto específico.<\/P>Pesquise 22arcpy <coisa que você está tentando fazer>22.<\/STRONG><\/P>Motores de busca como Google e Bing quase sempre retornam a documentação correta nos primeiros resultados da pesquisa. Resultados da Esri Community e Stack Exchange também tendem a ser recursos valiosos porque vêm de pessoas fazendo perguntas. Há uma grande chance de que alguém já tenha feito a mesma pergunta que você tem, e você pode ver o que funcionou para eles.<\/P>A documentação é sua melhor amiga<\/STRONG><\/P>Ninguém lembra de tudo isso. A habilidade mais importante que você pode cultivar é familiaridade com a documentação. Use o código de exemplo para ver como diferentes funções e objetos funcionam.<\/P>Use argumentos keyword em vez de apenas argumentos posicionais.<\/STRONG><\/P>Usar keywords ao chamar funções, em vez de depender apenas da ordem dos argumentos, torna seu código mais legível. Permite pular alguns parâmetros opcionais e torna mais óbvio para quem ler seu código depois para que servem os diferentes valores.<\/P>Utilize help() ou ?<\/STRONG><\/P>Passe um objeto para a função help para acessar a documentação dessa função sem precisar sair do seu ambiente de desenvolvimento. Isso reduz o custo cognitivo da troca de contexto e facilita voltar a escrever código. Em um ambiente notebook, você também pode adicionar um ? a um objeto para obter documentação formatada agradavelmente.<\/P>Use listas e loops para processar dados em lote.<\/STRONG><\/P>ArcPy possui várias funções de lista como ListWorkspaces ou ListFiles que geram automaticamente listas de objetos de dados. Uma vez que você tem uma lista, pode iterar sobre todos os itens dessa lista para realizar alguma tarefa.<\/P> <\/P># Defina o workspace
arcpy.env.workspace = r"C:\Input_Data"

# Liste todas as file geodatabases nesse workspace
fgdbs = arcpy.ListWorkspaces(workspace_type="FileGDB")

# Execute o modelo para cada file geodatabase no workspace
for gdb in fgdbs:
arcpy.PythonTipsandTricksatbx.Model1(Database=gdb)<\/code><\/pre> <\/P>Agende tarefas periódicas<\/STRONG><\/P>Se um processo precisa ser executado todo mês, semana ou até mesmo a cada minuto, você pode agendar essa tarefa. Ferramentas locais podem ser agendadas pela interface do ArcGIS Pro. Você também pode agendar notebooks rodando no ArcGIS Notebook Server ou no ArcGIS Online.<\/P>Defina variáveis ambientais para controlar como as ferramentas de geoprocessamento arcpy funcionam<\/STRONG><\/P>Se precisar definir um workspace, garantir que saídas possam ser sobrescritas, especificar uma referência espacial de saída ou qualquer outra variável ambiental de geoprocessamento, você pode declará-las usando a classe env no ArcPy. Nem toda ferramenta respeita todas as variáveis ambientais, então certifique-se de verificar a documentação específica daquela ferramenta para ver quais ambientes ela suporta.<\/P>Use variáveis para caminhos de arquivos, não codifique-os diretamente nos parâmetros das funções.<\/STRONG><\/P>Caminhos de arquivos são longos, difíceis de ler e frequentemente não refletem o propósito ou significado dos dados que representam. Ao atribuí-los a nomes de variáveis, você pode simplificar a referência aos dados naquele caminho e dar aos dados um nome que forneça o contexto adequado.<\/P>Use a função Describe para obter informações sobre um elemento de dado.<\/STRONG><\/P>No interface do usuário, se quiser saber sobre um elemento de dado, geralmente pode clicar com o botão direito e selecionar Propriedades. Em um script, não é possível clicar com o botão direito em nada. A função Describe pode criar um objeto que contém todas as propriedades daquele elemento de dado. Você pode acessar essas propriedades e usá-las em seu script. <\/P> <\/P>import pandas as pd
import arcpy

# Ferramentas ArcPy respeitam o ambiente workspace, mas pandas não
# Use Describe para extrair o caminho completo do arquivo de um elemento
arcpy.env.workspace = r"C:\Data"
delays = "AA_delays_jan_2023.csv"
desc = arcpy.Describe(delays)
delays_df = pd.read_csv(desc.catalogPath)<\/code><\/pre> <\/P>Use a biblioteca pandas para manipulação de dados tabulares.<\/STRONG><\/P>Puxar tabelas ou classes de feição para um DataFrame pandas permite usar as poderosas ferramentas dessa biblioteca para limpar, resumir, agrupar e agregar seus dados (e mais!). A extensão Spatially Enabled DataFrame ao pandas criada pela ArcGIS API for Python permite combinar as ferramentas padrão do pandas com funcionalidades espaciais adicionais para dados geográficos.<\/P> <\/P>delays_df.fillna(0, inplace=True)
airport_group = delays_df.groupby(['ORIGIN_AIRPORT_SEQ_ID'])
delays_by_airport_df = airport_group.agg({'WEATHER_DELAY': 'mean'})<\/code><\/pre> <\/P>Junte dados não espaciais aos dados espaciais para aproveitar as ferramentas de análise espacial.<\/STRONG><\/P>Conjuntos de dados com os quais você trabalha frequentemente serão implicitamente espaciais, mas podem não ter geometria real. Por exemplo, dados sobre uma localização conhecida ou dados com endereços em vez de coordenadas. Você pode incorporar esses conjuntos em sua análise espacial se puder juntá-los com geometrias dessas localizações usando ferramentas como Join, Spatial Join ou Geocoding. Se tiver um Spatially Enabled DataFrame, pode usar a função merge do pandas para juntar dados espaciais e não espaciais em um novo Spatially Enabled DataFrame.<\/P> <\/P>airports_sdf = pd.DataFrame.spatial.from_featureclass(airports_fc)
airport_delays_sdf = airports_sdf.merge(
right=delays_by_airport_df,
how='inner',
left_on='AIRPORT_SEQ_ID',
right_on='ORIGIN_AIRPORT_SEQ_ID'
)<\/code>
 <\/>\n22Spatially Enabled DataFrames22 podem ser entradas para muitas ferramentas de geoprocessamento.<\/>\n22Enquanto um DataFrame ne3o e9 uma classe de feie7e3o, vocea pode trate1-lo como tal para propf3sitos de muitas ferramentas. Isso e9 fatil porque vocea ne3o precisa exportar o DataFrame para um novo formato apenas para fazer algum processamento adicional.22<\/>\n <\/>\n
# Junte espacialmente um DataFrame a uma classe de feie7e3o
arcpy.analysis.SpatialJoin(
airport_delays_sdf,
climate_data,
delays_by_airport_weather,
match_option=22CLOSEST22
)<\/>\n<\/>\n <\/>\n22Use varie1veis para tornar ele mais fácil encadear ferramentas de geoprocessamento juntas.<\/STRONG><\/P>Em análises complexas, você frequentemente quer pegar a saída de uma ferramenta e passá-la como entrada para outra ferramenta. Variáveis tornam mais fácil escrever código flexível, porque você pode mudar o valor da variável sem precisar alterar todo o código da ferramenta de geoprocessamento que você escreveu. <\/P> <\/P># Juntar espacialmente um DataFrame a uma classe de feição
arcpy.analysis.SpatialJoin(
airport_delays_sdf,
climate_data,
delays_by_airport_weather,
match_option="CLOSEST"
)

# Passar a saída do Spatial Join como entrada para GLR
arcpy.GeneralizedLinearRegression_stats(
in_features=delays_by_airport_weather,
dependent_variable="WEATHER_DELAY",
explanatory_variables= ["Mean_T_f_01_Jan", "Mean_mmPr_01_Jan"],
model_type="CONTINUOUS",
output_features="delay_climate_glr",
)<\/code><\/pre> <\/P>Use variáveis para facilitar iterar\/experimentar com valores de parâmetros.<\/STRONG><\/P>Frequentemente, em uma tarefa complexa, você vai querer tentar diferentes valores para alguns dos parâmetros. Ou vai querer tornar esses parâmetros definidos pelo usuário para que o script possa lidar com entradas diferentes dos usuários. Codificar os valores diretamente nos parâmetros torna isso mais difícil. Atribuir variáveis a esses valores e movê-los para fora da chamada da função torna isso mais fácil.<\/P> <\/P># Mover valores para fora da chamada da função
dependent_variable = "WEATHER_DELAY"
explanatory_variables = [
"Mean_T_f_01_Jan",
"Mean_mmPr_01_Jan"
]

arcpy.GeneralizedLinearRegression_stats(
in_features=delays_by_airport_weather,
dependent_variable=dependent_variable,
explanatory_variables=explanatory_variables,
model_type="CONTINUOUS",
output_features=delay_climate_glr
)<\/code><\/pre> <\/P>Aprenda os atalhos de produtividade do seu ambiente de desenvolvimento<\/STRONG><\/P>Você provavelmente está familiarizado com ferramentas como ctrl+c para copiar ou ctrl+z para desfazer. Diferentes ambientes de desenvolvimento também têm seus próprios atalhos de teclado e macros que permitem ser mais produtivo. Pode levar algum tempo para aprender esses atalhos, mas quanto mais código você escrever, mais tempo economizará no final ao aprendê-los. Em um ambiente de notebook, você pode clicar na paleta de comandos no lado direito da barra de ferramentas para ver todos os atalhos.<\/P>Quando você receber um erro frustrante, afaste-se por um tempo.<\/STRONG><\/P>De longe, a melhor estratégia de depuração é uma pausa. Faça uma caminhada. Beba água. Trabalhe em outra coisa. Vá dormir. Quando você voltar ao problema, frequentemente terá uma perspectiva diferente que permite superar a questão. Se você estiver ficando irritado ou frustrado, sabe que é hora de fazer uma pausa.<\/P>Consiga um parceiro para ajudar você.<\/STRONG><\/P>A segunda estratégia de depuração mais valiosa é pedir ajuda. Passe algum tempo tentando resolver o problema sozinho primeiro, mas não guarde o problema só para você para sempre. Às vezes, um parceiro pode identificar um problema muito rapidamente que você não viu. E quando seu parceiro tiver um problema, ele pode vir até você para pedir ajuda.<\/P>Comece pelo final da mensagem de erro.<\/STRONG><\/P>Uma mensagem de erro não é um romance. Não a leia do começo ao fim por diversão. É um romance policial. Vá direto ao final para descobrir o culpado. As últimas linhas em uma mensagem de erro provavelmente serão as mais úteis.<\/P>Sucesso na depuração significa obter um erro diferente do anterior.<\/STRONG><\/P>Esta é uma dica chave para gerenciar seu estado emocional durante uma sessão de depuração. Se você conceber sucesso como deixar seu código perfeito, nunca vencerá. Porque código que faz algo interessante está sempre imperfeito. Mas se você pensar no sucesso como avançar incrementalmente rumo à perfeição, experimentará muitas vitórias ao longo do caminho. <\/P>Use declarações print para verificar valores e tipos de dados.<\/STRONG><\/P>Variáveis Python podem mudar valores e até tipos de dados. Isso as torna extremamente flexíveis, mas essa flexibilidade também é a fonte de muitos erros. A maneira mais simples de verificar se uma variável tem o valor ou tipo correto é imprimi-la.<\/P> <\/P># Imprimir o valor da csv_list para garantir que está correto
arcpy.env.workspace = r"C:\LTS"
csv_list = arcpy.ListFiles("*.csv")
print(csv_list)<\/code><\/pre> <\/P>Caminhos incorretos de arquivos são uma fonte frequente de erro.<\/STRONG><\/P>Copiar e colar caminhos de arquivos pode ajudar com problemas associados a digitação errada dos caminhos. Mas você ainda pode copiar o caminho errado. Ou alguém usando seu script pode não ter os dados no mesmo caminho que você codificou no script. Se houver um problema ao acessar ou carregar dados, o caminho do arquivo deve ser uma das primeiras coisas que você verifica.<\/P>Erros de digitação são outra fonte frequente de erro.<\/STRONG><\/P>Uma coisa engraçada sobre o cérebro humano é que você sabe o que quis digitar, então vê o que quis digitar, não o que realmente digitou. Caminhos de arquivos, nomes longos de funções ou caracteres especiais são fontes comuns de erros de digitação. Encontrar erros de digitação é um ótimo caso para ter um parceiro ajudando você, porque ele só vê o que você realmente digitou.<\/P>A conclusão automática pode ajudar a evitar erros de digitação.<\/STRONG><\/P>Um IDE tem ferramentas sofisticadas de conclusão automática que podem ajudar a encontrar a função ou nome do parâmetro correto. Isso não só economiza tempo ao usar muito a auto-completação, como também reduz drasticamente o risco de digitar o valor errado. Essas ferramentas de conclusão automática são uma das primeiras coisas que você deve praticar para aproveitar ao máximo seu ambiente de desenvolvimento.<\/P>Python complementa sua expertise no assunto. Não a substitui.<\/STRONG><\/P>Código perfeito que roda sem erro e resolve o problema errado não vale nada. Sua expertise em climatologia, demografia, transporte ou qualquer outro domínio que use dados espaciais importa imensamente. Python é uma ferramenta extra que você pode usar para multiplicar o valor dessa expertise.<\/P>Recursos adicionais<\/STRONG><\/P>Para treinamento adicional em Python, confira o curso Creating Python Scripts for ArcGIS da Esri: https:\/\/go.esri.com\/python-course<\/A>.<\/SPAN><\/SPAN><\/LI>Faça perguntas e responda na Esri Communities para Python\ArcPy<\/A> e na ArcGIS API for Python<\/A>.
(em inglês)
(em inglês)
(em inglês)
(em inglês)
(em inglês)
(em inglês)
(em inglês)
(em inglês)