ArcGIS Notebooks executa um ambiente de notebook Jupyter, que fornece um espaço de trabalho simplificado baseado em célula. Este tópico aborda os comandos e aspectos básicos do trabalho no Notebooks, incluindo atalhos e melhores práticas.
Especificar o tipo de uma célula
Há três tipos de células que você pode utilizar em um notebook. Após selecionar uma célula com o ponteiro, é possível alterar o tipo da célula utilizando a lista suspensa na barra de ferramentas.
Os seguintes são os três tipos disponíveis:
- Código—O notebook interpretará todo o conteúdo em uma célula do código na linguagem de Python. Ao escrever o código de Python, digitar algumas strings, como from ou o sinal de igual (=), solicitará ao notebook para recolorir ou destacá-las automaticamente para maior clareza. Qualquer linha de código que comece com um sinal numérico (#) será interpretada como um comentário, colorida em verde e em itálico, e não será executada como código pelo notebook.
- Remarcação—O notebook interpretará todo o conteúdo em uma célula de Remarcação na linguagem de Markdown. Este é um idioma simples para formatação rich text, utilizado em toda a Internet por clientes como GitHub. Consulte o Guia do Markdown online para uma referência ao uso do Markdown. Executar um célula de Markdown tornará o conteúdo em rich text. Quaisquer linhas que começam com um ou vários sinais numéricos (#) serão formatadas como cabeçalhos. Você também pode adicionar código HTML bruto às células de Markdown.
- NBConvert Bruto—O notebook não processará conteúdo em uma célula de NBConvert Bruto. Este tipo de célula é raramente utilizado.
Anotação:
O tipo de célula Cabeçalho também está disponível na lista suspensa. No entanto, este tipo de célula não é mais utilizados em ambientes do notebook Jupyter. Clicar nesse tipo de célula transformará a célula em uma célula Markdown e acrescentará um sinal de número (#), que indica um cabeçalho de nível superior em Markdown.
O uso de rich text e comentários de código tornará seus notebooks mais legíveis e valiosos para os usuários com quem eles são compartilhados.
Trabalhar com células
Para um notebook executar código, o código deve estar contido em uma célula. O código nas células permite a você definir variáveis e executar funções contidas em bibliotecas de Python.
Para definir uma variável, execute uma célula que contenha uma declaração de variável, incluindo um sinal de igual (=). O modelo de notebook padrão, por exemplo, é iniciado definindo uma variável gis. Se você executar uma célula contendo somente este nome de variáve , o gis, o notebook retornará a URL de seu portal do ArcGIS Online como uma saída.
Anotação:
Os comandos iPython utilizam pontos de exclamação, tal como !cd <directory>, para alterar diretórios da linha de comandos, não funcionarão no ArcGIS Notebooks. Ao contrário, utilize comandos sem pontos de exclamação, como cd <directory>.
Para executar uma função de Python, forneça a sintaxe da função e quaisquer parâmetros exigidos ou aceitos pela função. Consulte a seção Utilizar funções em uma célula abaixo para mais informações.
Você pode criar uma nova célula pressionando Shift+Enter ou clicando em Inserir no menu da barra de formatação, que oferece a opção de inserir uma nova célula acima ou abaixo da célula atual.
Opções da barra de ferramentas da célula
Você pode incluir informações adicionais sobre células individuais em um notebook utilizando as opções na barra de ferramentas da célula:
- Nenhum—Não mostra a barras de ferramentas da célula.
- Editar Metadados—Insira metadados para cada célula utilizando JSON.
- Formato de Célula Bruta—Células brutas permitem a você gavar a saída diretamente; o conteúdo destas células não é avaliado pelo notebook.
- Slideshow—Especifique como cada célula exibirá em um slideshow Útil ao apresentar o código.
- Anexos—Gerencie os anexos associados dentro de cada célula na área de trabalho do notebook.
- Tags—Crie e gerencie tags para cada célula dentro da área de trabalho do notebook.
Quando qualquer uma destas opções estiverem ativadas, uma barra aparece sobre cada célula no notebook. Somente uma opção pode estar ativada por vez, mas quaisquer informações que você adicionar à barra de ferramentas permanecem até quando desativada. Você pode alterar as opções da barra de ferramentas da célula clicando em Visualizar > Barra de Ferramentas da Célula.
Importar bibliotecas e módulos
No modelo de notebook padrão, ArcGIS Notebooks somente importa o módulo gis do ArcGIS API for Python. Normalmente, você desejará utilizar bibliotecas de Python adicionais disponíveis no tempo de execução do seu notebook. Para acessar estas bibliotecas, execute um comando import .
Consulte todas as bibliotecas de Python disponíveis no ArcGIS Notebooks
Crie uma nova célula e digite import <library>, então execute a célula.
No ArcGIS API for Python e ArcPy, e em outros casos, as bibliotecas de Python são organizadas em módulos. Para acessar as bibliotecas dentro de um módulo, declare o módulo para acessar com uma declaração from , então declare uma biblioteca utilizando uma declaração import . Por exemplo, para solicitar a biblioteca WebScene do módulo mapping no ArcGIS API for Python, execute o seguinte comando em uma célula:
from arcgis.mapping import WebSceneO ArcGIS Notebooks inclui um recurso de preenchimento automático ao executar células. Você pode utilizá-lo para ajudá-lo a encontrar as bibliotecas e os módulos necessários. Em uma célula, digite a primeira parte do comando e pressione Tab para ativar o recurso de preenchimento automático. Ele fornecerá possíveis valores que podem completar o comando.
Por exemplo, se você digitar arcgis. e então pressionar Tab, o notebook fornecerá uma lista suspensa de todos os módulos disponíveis no ArcGIS API for Python. Você pode utilizar os erros para cima e para baixo para navegar na lista; quando você encontrar a opção desejada, pressione Enter para inseri-lo em sua linha de código.
Para mais informações sobre como o ArcGIS API for Python e ArcPy funcionam em seus notebooks, consulte os seguintes tópicos:
Utilizar funções em uma célula
Para realizar análises e trabalhar com dados em notebooks, você utiliza funções do Python. As funções estão contidas em bibliotecas de Python e geralmente aceitam parâmetros de entrada para especificar como eles serão executados e em qual conteúdo eles serão executados.
A ferramenta de preenchimento automático do notebook pode ajudá-lo a encontrar funções, fornecendo uma lista suspensa do que está disponível. Para qualquer biblioteca bar, digite bar. e pressione Tab para mostrar as funções disponíveis.
Por exemplo, para visualizar as ferramentas disponíveis na biblioteca Resumir Dados do módulo arcgis.features , digite o seguinte código e pressione Tab:
features.summarize_data.A ferramenta de preenchimento automático mostrará uma lista suspensa das ferramentas disponíveis na biblioteca.
Muitas vezes, o comando em um notebook terá parâmetros exigidos ou opcionais — parâmetros que fornecem informações para executar um comando. Se a sintaxe de um comando terminar com um conjunto vazio de parênteses (()), o comando exigirá ou poderá incluir parâmetros opcionais para você adicionar.
Insira os parâmetros entre parênteses, separando vários parâmetros por vírgulas. Para visualizar uma string de parâmetros exigidos e opcionais para qualquer função, substitua seus parênteses vazios por um ponto de interrogação e execute a célula. Isto mostrará o docstring da função, que lista todos os parâmetros.
Por exemplo, todas as ferramentas disponíveis através do painel Análise de editor do notebook exigem parâmetros. A adição de uma ferramenta deste painel a uma célula irá inserir a sintaxe ArcGIS API for Python da ferramenta, terminando em parênteses vazios. Caso tente executar esta sintaxe em uma célula sem fornecer um ou mais parâmetros, a célula falhará e fornecerá uma mensagem de erro.
Se você deseja executar a ferramenta Agregar Pontos na biblioteca Resumir Dados, você localizará a ferramenta no painel Análise e adicionará a uma nova célula, ou digite a sintaxe da ferramenta da seguinte maneira:
features.summarize_data.aggregate_points()Para visualizar a lista de parâmetros da ferramenta, modifique a sintaxe da seguinte maneira e execute a célula:
features.summarize_data.aggregate_points?Isto abrirá a janela de referência docstring da ferramenta. Esta referência tem botões para expandir ou fechar a janela no canto superior direito.
Quando você estiver trabalhando em uma célula, tenha o seguinte em mente:
- Para qualquer função foo(), digite foo? e pressione Enter para mostrar a sequência de caracteres da função, que descreve a função.
- Se você iniciar uma célula com !, o conteúdo da célula executará como um comando bash no seu contêiner do notebook.
Executar uma célula
Quando você executa uma célula, seu código é executado e todas as operações são executadas. Você pode executar somente uma célula inteira, não uma subseção da célula ou uma linha específica de código. As células podem consistir em uma ou várias linhas de código.
Para executar uma célula selecionada, clique no botão Executar na barra de ferramentas ou clique em Células > Run Cells. Você também pode pressionar Ctrl + Enter para executar a célula em que está o ponteiro do mouse.
Para parar manualmente uma célula que está sendo executada, clique em Kernel > Interromper. Você também pode clicar no botão de parar quadrado na barra de ferramentas.
À esquerda de cada célula do código está um elemento In [ ] . Se a célula ainda não foi executada, ou se uma célula anteriormente executada foi apagada da sua saída, o colchete estará vazio. Enquanto a célula estiver sendo executada, ela conterá um asterisco: In [*]. Quando uma célula terminar de executar, o colchete In [ ] será preenchido com um número que indica a ordem das células que foram executadas. Pelo fato das células de um notebook poderem ser executadas em qualquer ordem e poderem ser executadas várias vezes, os números In [ ] nas células de um notebook podem não estar em ordem sequencial.
Anotação:
As células do Markdown mantêm um elemento In [ ] até que sejam executadas, ao ponto do elemento desaparecer e o conteúdo da célula se tornar rich text.
Quando uma linha de código em uma célula que você executa produz uma saída, a saída é exibida no seu notebook sob a célula executada. Ao lado da saída está um elemento Out [ ] , que corresponde ao que está no elemento In [ ] da célula correspondente.
Trabalhar com o Kernel
Quando você inicia um novo notebook, um kernel é iniciado com ele. Este Kernel executa o código que você executa no notebook. À medida que você executa células no notebook (preenchendo seus elementos In [ ]), variáveis que você definiu em células executadas são armazenadas na memória do Kernel.
Para reiniciar o Kernel do seu bloco de notas e limpar as variáveis na memória, clique em Kernel > Reiniciar. Se você deseja reiniciar o Kernel, limpe as variáveis na memória e, execute todas as células no notebook sequencialmente, clique em Kernel > Reiniciar & Executar Todos.
Ao terminar de utilizar um notebook ativamente, clique em Kernel > Fechar para fechar o Kernel do notebook e limpar todas as variáveis na memória. O Kernel deixará de ser executado, mas não apagará as saídas das células que foram executadas.