Criar, desenvolver e manter blocos de anotações Synapse

Um bloco de anotações no Azure Synapse Analytics (um bloco de anotações Synapse) é uma interface da Web para você criar arquivos que contêm código dinâmico, visualizações e texto narrativo. Os blocos de notas são um bom local para validar ideias e utilizar experiências rápidas para obter informações dos seus dados. Os notebooks também são amplamente utilizados na preparação de dados, visualização de dados, aprendizado de máquina e outros cenários de big data.

Com um caderno Sinapse, você pode:

• Comece com zero esforço de configuração.
• Ajude a manter os dados seguros com recursos de segurança corporativos integrados.
• Analise dados em formatos brutos (como CSV, TXT e JSON), formatos de arquivo processados (como Parquet, Delta Lake e ORC) e arquivos de dados tabulares SQL em relação ao Spark e SQL.
• Seja produtivo com recursos de criação aprimorados e visualização de dados integrada.

Este artigo descreve como usar blocos de anotações no Synapse Studio.

Criar um bloco de notas

Você pode criar um novo bloco de anotações ou importar um bloco de anotações existente para um espaço de trabalho Synapse a partir do Pesquisador de Objetos. Selecione o menu Desenvolver . Selecione o botão e selecione Bloco de Notas ou clique com o botão direito do + rato em Blocos de Notas e, em seguida, selecione Novo bloco de notas ou Importar. Os notebooks Synapse reconhecem arquivos IPYNB padrão do Jupyter Notebook.

Desenvolver blocos de notas

Os blocos de notas consistem em células, que são blocos individuais de código ou texto que pode executar de forma independente ou em grupo.

As seções a seguir descrevem as operações para o desenvolvimento de notebooks:

• Adicionar uma célula
• Definir um idioma principal
• Usar vários idiomas
• Usar tabelas temporárias para fazer referência a dados entre idiomas
• Usar o IntelliSense no estilo IDE
• Usar trechos de código
• Formatar células de texto usando botões da barra de ferramentas
• Desfazer ou refazer uma operação de célula
• Comentar uma célula de código
• Mover uma célula
• Copiar uma célula
• Excluir uma célula
• Recolher entrada de célula
• Recolher saída de célula
• Usar uma estrutura de tópicos do bloco de anotações

Adicionar uma célula

Existem várias formas de adicionar uma nova célula ao seu bloco de notas:

• Passe o cursor sobre o espaço entre duas células e selecione Código ou Markdown.

  

• Use teclas de atalho no modo de comando. Selecione a tecla A para inserir uma célula acima da célula atual. Selecione a tecla B para inserir uma célula abaixo da célula atual.

Definir um idioma principal

Os notebooks Synapse suportam quatro idiomas Apache Spark:

• PySpark (Python)
• Apache Spark (Scala)
• SQL do Apache Spark
• .NET para Apache Spark (C#)
• Faísca (R)

Você pode definir o idioma principal para as células recém-adicionadas na lista suspensa Idioma na barra de comandos superior.

Usar vários idiomas

Você pode usar vários idiomas em um bloco de anotações especificando o comando mágico de idioma correto no início de uma célula. A tabela a seguir lista os comandos mágicos para alternar os idiomas das células.

Comando mágico	Idioma	Description
%%pyspark	Python	Execute uma consulta Python contra SparkContext.
%%spark	Scala	Execute uma consulta Scala em relação ao SparkContext.
%%sql	SQL do Apache Spark	Execute uma consulta do Spark SQL em relação ao SparkContext.
%%csharp	.NET para Spark C#	Execute uma consulta .NET para Spark C# em relação ao SparkContext.
%%sparkr	R	Execute uma consulta R em relação a SparkContext.

A imagem a seguir mostra um exemplo de como você pode escrever uma consulta PySpark usando o %%pyspark comando magic ou uma consulta Spark SQL usando o %%sql comando magic em um bloco de anotações Spark (Scala). O idioma principal do bloco de anotações está definido como PySpark.

Usar tabelas temporárias para fazer referência a dados entre idiomas

Não é possível fazer referência a dados ou variáveis diretamente em diferentes idiomas em um bloco de anotações Synapse. No Spark, você pode fazer referência a uma tabela temporária entre idiomas. Aqui está um exemplo de como ler um DataFrame Scala no PySpark e no Spark SQL usando uma tabela temporária do Spark como solução alternativa:

1. Na célula 1, leia um DataFrame de um conector de pool SQL usando Scala e crie uma tabela temporária:

   %%spark
   val scalaDataFrame = spark.read.sqlanalytics("mySQLPoolDatabase.dbo.mySQLPoolTable")
   scalaDataFrame.createOrReplaceTempView( "mydataframetable" )
   

2. Na célula 2, consulte os dados usando o Spark SQL:

   %%sql
   SELECT * FROM mydataframetable
   

3. Na célula 3, use os dados no PySpark:

   %%pyspark
   myNewPythonDataFrame = spark.sql("SELECT * FROM mydataframetable")
   

Usar o IntelliSense no estilo IDE

Os notebooks Synapse são integrados com o editor de Mônaco para trazer o IntelliSense no estilo IDE para o editor de células. Os recursos de realce de sintaxe, marcador de erro e autocompletar código ajudam você a escrever código e identificar problemas mais rapidamente.

Os recursos do IntelliSense estão em diferentes níveis de maturidade para diferentes idiomas. Use a tabela a seguir para ver o que é suportado.

Idiomas	Realce da sintaxe	Marcador de erro de sintaxe	Preenchimento de código de sintaxe	Conclusão de código variável	Autocompletar código da função do sistema	Conclusão de código da função do usuário	Recuo inteligente	Dobragem de código
PySpark (Python)	Sim	Sim	Sim	Sim	Sim	Sim	Sim	Sim
Apache Spark (Scala)	Sim	Sim	Sim	Sim	Sim	Sim	No	Sim
SQL do Apache Spark	Sim	Sim	Sim	Sim	Sim	No	No	Não
.NET para Spark (C#)	Sim	Sim	Sim	Sim	Sim	Sim	Sim	Sim

Uma sessão ativa do Spark é necessária para se beneficiar da conclusão de código variável, da conclusão do código da função do sistema e do autocompletar de código da função do usuário para .NET for Spark (C#).

Usar trechos de código

Os blocos de anotações Synapse fornecem trechos de código que facilitam a inserção de padrões de código comumente usados. Esses padrões incluem configurar sua sessão do Spark, ler dados como um DataFrame do Spark e desenhar gráficos usando Matplotlib.

Trechos aparecem em teclas de atalho do IntelliSense no estilo IDE misturados com outras sugestões. O conteúdo dos trechos de código está alinhado com a linguagem da célula de código. Você pode ver os trechos disponíveis inserindo o trecho ou qualquer palavra-chave que apareça no título do trecho no editor de célula de código. Por exemplo, inserindo leitura, você pode ver a lista de trechos para ler dados de várias fontes de dados.

Formatar células de texto usando botões da barra de ferramentas

Você pode usar os botões de formatação na barra de ferramentas da célula de texto para executar ações comuns de Markdown. Essas ações incluem colocar o texto em negrito, colocar o texto em itálico, criar parágrafos e títulos por meio de um menu suspenso, inserir código, inserir uma lista não ordenada, inserir uma lista ordenada, inserir um hiperlink e inserir uma imagem de uma URL.

Desfazer ou refazer uma operação de célula

Para revogar as operações de célula mais recentes, selecione o botão Desfazer ou Refazer ou selecione a tecla Z ou Shift+Z. Agora você pode desfazer ou refazer até 10 operações de células históricas.

As operações de célula suportadas incluem:

• Inserir ou excluir uma célula. Você pode revogar operações de exclusão selecionando Desfazer. Esta ação mantém o conteúdo do texto junto com a célula.
• Reordenar as células.
• Ative ou desative uma célula de parâmetro.
• Converter entre uma célula de código e uma célula de Markdown.

Comentar uma célula de código

1. Selecione o botão Comentários na barra de ferramentas do bloco de anotações para abrir o painel Comentários .

   

2. Selecione o código na célula de código, selecione Novo no painel Comentários , adicione comentários e, em seguida, selecione o botão Publicar comentário .

   

3. Se necessário, você pode executar as ações Editar comentário, Resolver thread e Excluir thread selecionando Mais reticências (...) ao lado do comentário.

   

Mover uma célula

Para mover uma célula, selecione o lado esquerdo da célula e arraste-a para a posição desejada.

Copiar uma célula

Para copiar uma célula, primeiro crie uma nova célula e, em seguida, selecione todo o texto na célula original, copie o texto e cole o texto na nova célula. Quando a célula está no modo de edição, os atalhos de teclado tradicionais para selecionar todo o texto são limitados à célula.

Excluir uma célula

Para excluir uma célula, selecione o botão Excluir à direita da célula.

Você também pode usar teclas de atalho no modo de comando. Selecione Shift+D para excluir a célula atual.

Recolher entrada de célula

Para recolher a entrada da célula atual, selecione as reticências Mais comandos (...) na barra de ferramentas da célula e, em seguida, selecione Ocultar entrada. Para expandir a entrada, selecione Mostrar entrada enquanto a célula está recolhida.

Recolher saída de célula

Para recolher a saída da célula atual, selecione Mais reticências de comandos (...) na barra de ferramentas da célula e, em seguida, selecione Ocultar saída. Para expandir a saída, selecione Mostrar saída enquanto a saída da célula estiver oculta.

Usar uma estrutura de tópicos do bloco de anotações

O contorno (índice) apresenta o primeiro cabeçalho Markdown de qualquer célula Markdown em uma janela da barra lateral para navegação rápida. A barra lateral de contorno é redimensionável e dobrável para se ajustar à tela da melhor maneira possível. Para abrir ou ocultar a barra lateral, selecione o botão Contorno na barra de comandos do bloco de notas.

Executar um bloco de notas

Pode executar as células de código no seu bloco de notas individualmente ou todas de uma só vez. O estado e o progresso de cada célula aparecem no bloco de notas.

Executar uma célula

Há várias maneiras de executar o código em uma célula:

• Passe o cursor sobre a célula que pretende executar e, em seguida, selecione o botão Executar célula ou selecione Ctrl+Enter.

  

• Use teclas de atalho no modo de comando. Selecione Shift+Enter para executar a célula atual e selecione a célula abaixo dela. Selecione Alt+Enter para executar a célula atual e inserir uma nova célula abaixo dela.

Executar todas as células

Para executar todas as células do bloco de anotações atual em sequência, selecione o botão Executar tudo .

Executar todas as células acima ou abaixo

Para executar todas as células acima da célula atual em sequência, expanda a lista suspensa do botão Executar tudo e selecione Executar células acima. Selecione Executar células abaixo para executar todas as células abaixo da atual em sequência.

Cancelar todas as células em execução

Para cancelar as células em execução ou as células que aguardam na fila, selecione o botão Cancelar tudo .

Referenciar um bloco de notas

Para fazer referência a outro bloco de anotações dentro do contexto do bloco de anotações atual, use o %run <notebook path> comando magic. Todas as variáveis definidas no bloco de notas de referência estão disponíveis no bloco de notas atual.

Eis um exemplo:

%run /<path>/Notebook1 { "parameterInt": 1, "parameterFloat": 2.5, "parameterBool": true, "parameterString": "abc" }

A referência do bloco de anotações funciona no modo interativo e nos pipelines.

O %run comando magic tem estas limitações:

• O comando suporta chamadas aninhadas, mas não chamadas recursivas.
• O comando suporta passar um caminho absoluto ou nome de bloco de anotações apenas como um parâmetro. Não suporta caminhos relativos.
• Atualmente, o comando suporta apenas quatro tipos de valor de parâmetro: int, float, boole string. Não suporta operações de substituição variáveis.
• Os cadernos referenciados devem ser publicados. Você precisa publicar os blocos de anotações para fazer referência a eles, a menos que selecione a opção para habilitar uma referência de bloco de anotações não publicada. O Synapse Studio não reconhece os cadernos inéditos do repositório Git.
• Os blocos de notas referenciados não suportam profundidades de instrução superiores a cinco.

Usar o explorador de variáveis

Um bloco de anotações Synapse fornece um explorador de variáveis interno na forma de uma tabela que lista variáveis na sessão atual do Spark para células PySpark (Python). A tabela inclui colunas para nome, tipo, comprimento e valor da variável. Mais variáveis aparecem automaticamente à medida que são definidas nas células de código. A seleção de cada cabeçalho de coluna classifica as variáveis na tabela.

Para abrir ou ocultar o explorador de variáveis, selecione o botão Variáveis na barra de comandos do bloco de notas.

Usar o indicador de status da célula

Um status passo a passo de uma execução de célula aparece abaixo da célula para ajudá-lo a ver seu progresso atual. Depois que a execução da célula terminar, um resumo com a duração total e a hora de término aparecerá e permanecerá lá para referência futura.

Usar o indicador de progresso do Spark

Um notebook Synapse é puramente baseado em Spark. As células de código são executadas no pool do Apache Spark sem servidor remotamente. Um indicador de progresso do trabalho do Spark com uma barra de progresso em tempo real ajuda você a entender o status da execução do trabalho.

O número de tarefas para cada trabalho ou estágio ajuda a identificar o nível paralelo do seu trabalho do Spark. Você também pode aprofundar a interface do usuário do Spark de um trabalho (ou estágio) específico selecionando o link no nome do trabalho (ou palco).

Configurar uma sessão do Spark

No painel Configurar sessão, que você pode encontrar selecionando o ícone de engrenagem na parte superior do bloco de anotações, você pode especificar a duração do tempo limite, o número de executores e o tamanho dos executores a serem fornecidos à sessão atual do Spark. Reinicie a sessão do Spark para que as alterações de configuração entrem em vigor. Todas as variáveis do bloco de anotações armazenadas em cache são limpas.

Você também pode criar uma configuração a partir da configuração do Apache Spark ou selecionar uma configuração existente. Para obter detalhes, consulte Gerenciar configuração do Apache Spark.

Comando Magic para configurar uma sessão do Spark

Você também pode especificar as configurações da sessão do Spark através do comando %%configuremagic. Para que as configurações entrem em vigor, reinicie a sessão do Spark.

Recomendamos que execute %%configure no início do seu bloco de notas. Aqui está um exemplo. Para obter a lista completa de parâmetros válidos, consulte as informações do Livy no GitHub.

%%configure
{
    //You can get a list of valid parameters to configure the session from https://github.com/cloudera/livy#request-body.
    "driverMemory":"28g", // Recommended values: ["28g", "56g", "112g", "224g", "400g", "472g"]
    "driverCores":4, // Recommended values: [4, 8, 16, 32, 64, 80]
    "executorMemory":"28g",
    "executorCores":4, 
    "jars":["abfs[s]://<file_system>@<account_name>.dfs.core.windows.net/<path>/myjar.jar","wasb[s]://<containername>@<accountname>.blob.core.windows.net/<path>/myjar1.jar"],
    "conf":{
    //Example of a standard Spark property. To find more available properties, go to https://spark.apache.org/docs/latest/configuration.html#application-properties.
        "spark.driver.maxResultSize":"10g",
    //Example of a customized property. You can specify the count of lines that Spark SQL returns by configuring "livy.rsc.sql.num-rows".
        "livy.rsc.sql.num-rows":"3000" 
    }
}

Aqui estão algumas considerações para o %%configure comando magic:

• Recomendamos que você use o mesmo valor para driverMemory e executorMemory em %%configure. Também recomendamos isso driverCores e executorCores temos o mesmo valor.
• Você pode usar %%configure em pipelines Synapse, mas se você não defini-lo na primeira célula de código, a execução do pipeline falhará porque não pode reiniciar a sessão.
• O %%configure comando usado em mssparkutils.notebook.run é ignorado, mas o comando usado em %run <notebook> continua a ser executado.
• Você deve usar as propriedades de configuração padrão do "conf" Spark no corpo. Não suportamos referências de primeiro nível para as propriedades de configuração do Spark.
• Algumas propriedades especiais do Spark não terão efeito no "conf" corpo, incluindo "spark.driver.cores", "spark.executor.cores", "spark.driver.memory", "spark.executor.memory", e "spark.executor.instances".

Configuração de sessão parametrizada a partir de um pipeline

Você pode usar a %%configure configuração de sessão parametrizada para substituir valores no comando magic por parâmetros pipeline run (atividade do notebook). Ao preparar uma %%configure célula de código, você pode substituir valores padrão usando um objeto como este:

{
      "activityParameterName": "parameterNameInPipelineNotebookActivity",
      "defaultValue": "defaultValueIfNoParameterFromPipelineNotebookActivity"
} 

O exemplo a seguir mostra valores padrão de 4 e "2000", que também são configuráveis:

%%configure  

{ 
    "driverCores": 
    { 
        "activityParameterName": "driverCoresFromNotebookActivity", 
        "defaultValue": 4 
    }, 
    "conf": 
    { 
        "livy.rsc.sql.num-rows": 
        { 
            "activityParameterName": "rows", 
            "defaultValue": "2000" 
        } 
    } 
} 

O bloco de anotações usa o valor padrão se você executar o bloco de anotações no modo interativo diretamente ou se a atividade do bloco de anotações de pipeline não fornecer um parâmetro que corresponda ao "activityParameterName".

Durante o modo de execução do pipeline, você pode usar a guia Configurações para definir as configurações de uma atividade do bloco de anotações do pipeline.

Se você quiser alterar a configuração da sessão, o nome do parâmetro de atividade do bloco de anotações de pipeline deve ser o mesmo que activityParameterName no bloco de anotações. Neste exemplo, durante uma execução de pipeline, 8 substitui driverCores em %%configuree 4000 substitui livy.rsc.sql.num-rows.

Se uma execução de pipeline falhar depois de usar o %%configure comando magic, você poderá obter mais informações de erro executando a %%configure célula mágica no modo interativo do bloco de anotações.

Trazer dados para um bloco de notas

Você pode carregar dados do Azure Data Lake Storage Gen 2, do Armazenamento de Blobs do Azure e dos pools SQL, conforme mostrado nos exemplos de código a seguir.

Ler um arquivo CSV do Azure Data Lake Storage Gen2 como um Spark DataFrame

from pyspark.sql import SparkSession
from pyspark.sql.types import *
account_name = "Your account name"
container_name = "Your container name"
relative_path = "Your path"
adls_path = 'abfss://%s@%s.dfs.core.windows.net/%s' % (container_name, account_name, relative_path)

df1 = spark.read.option('header', 'true') \
                .option('delimiter', ',') \
                .csv(adls_path + '/Testfile.csv')

Ler um arquivo CSV do Armazenamento de Blobs do Azure como um DataFrame do Spark

from pyspark.sql import SparkSession

# Azure storage access info
blob_account_name = 'Your account name' # replace with your blob name
blob_container_name = 'Your container name' # replace with your container name
blob_relative_path = 'Your path' # replace with your relative folder path
linked_service_name = 'Your linked service name' # replace with your linked service name

blob_sas_token = mssparkutils.credentials.getConnectionStringOrCreds(linked_service_name)

# Allow Spark to access from Azure Blob Storage remotely

wasb_path = 'wasbs://%s@%s.blob.core.windows.net/%s' % (blob_container_name, blob_account_name, blob_relative_path)

spark.conf.set('fs.azure.sas.%s.%s.blob.core.windows.net' % (blob_container_name, blob_account_name), blob_sas_token)
print('Remote blob path: ' + wasb_path)

df = spark.read.option("header", "true") \
            .option("delimiter","|") \
            .schema(schema) \
            .csv(wasbs_path)

Ler dados da conta de armazenamento principal

Você pode acessar dados na conta de armazenamento principal diretamente. Não há necessidade de fornecer as chaves secretas. No Data Explorer, clique com o botão direito do mouse em um arquivo e selecione Novo bloco de anotações para ver um novo bloco de anotações com um extrator de dados gerado automaticamente.

Usar widgets IPython

Widgets são objetos Python agitados que têm uma representação no navegador, geralmente como um controle como um controle deslizante ou caixa de texto. Os widgets IPython funcionam apenas em ambientes Python. No momento, eles não são suportados em outros idiomas (por exemplo, Scala, SQL ou C#).

Etapas para usar widgets IPython

1. Importe o ipywidgets módulo para usar a estrutura Jupyter Widgets:

   import ipywidgets as widgets
   

2. Use a função de nível display superior para renderizar um widget ou deixe uma expressão de widget tipo na última linha da célula de código:

   slider = widgets.IntSlider()
   display(slider)
   

   slider = widgets.IntSlider()
   slider
   

3. Execute a célula. O widget aparece na área de saída.

   

Você pode usar várias display() chamadas para renderizar a mesma instância de widget várias vezes, mas elas permanecem sincronizadas entre si:

slider = widgets.IntSlider()
display(slider)
display(slider)

Para renderizar dois widgets independentes um do outro, crie duas instâncias de widget:

slider1 = widgets.IntSlider()
slider2 = widgets.IntSlider()
display(slider1)
display(slider2)

Widgets suportados

Tipo de widget	Widgets
Numérico	IntSlider, FloatSlider, , IntRangeSliderFloatLogSlider, FloatRangeSlider, IntProgress, FloatProgress, BoundedIntTextBoundedFloatTextIntTextFloatText
Boolean	ToggleButton, Checkbox, Valid
Seleção	Dropdown, RadioButtons, Select, SelectionSlider, SelectionRangeSlider, ToggleButtons, SelectMultiple
String	Text, Text area, Combobox, , Password, HTMLLabel, HTML Math, Image,Button
Reproduzir (animação)	Date picker, Color picker, Controller
Contentor/Layout	Box, HBox, VBox, GridBox, Accordion, Tabs, Stacked

Limitações conhecidas

• A tabela a seguir lista widgets que não são suportados no momento, juntamente com soluções alternativas:

  Caraterística	Solução
  Output Widget	Em vez disso, você pode usar a print() função para escrever texto no stdout.
  widgets.jslink()	Você pode usar a widgets.link() função para vincular dois widgets semelhantes.
  FileUpload Widget	Nenhum disponível.

• A função global display que o Azure Synapse Analytics fornece não suporta a exibição de vários widgets em uma chamada (ou seja, display(a, b)). Esse comportamento é diferente da função IPython display .

• Se você fechar um bloco de anotações que contém um widget IPython, não poderá visualizar ou interagir com o widget até executar a célula correspondente novamente.

Guardar blocos de notas

Pode guardar um único bloco de notas ou todos os blocos de notas na sua área de trabalho:

• Para salvar as alterações feitas em um único bloco de anotações, selecione o botão Publicar na barra de comandos do bloco de anotações.

  

• Para salvar todos os blocos de anotações em seu espaço de trabalho, selecione o botão Publicar tudo na barra de comandos do espaço de trabalho.

  

No painel Propriedades do bloco de anotações, você pode configurar se deseja incluir a saída da célula ao salvar.

Use comandos mágicos

Você pode usar comandos mágicos Jupyter familiares em notebooks Synapse. Analise as seguintes listas de comandos mágicos atualmente disponíveis. Conte-nos seus casos de uso no GitHub para que possamos continuar a criar mais comandos mágicos para atender às suas necessidades.

Comandos mágicos disponíveis para linhas:

%lsmagic, %time, %timeit, %history, %run, %load

Comandos mágicos disponíveis para células:

%%time, %%timeit, , %%capture, %%writefile, %%pyspark%%sql, %%spark, %%csharp%%html,%%configure

Fazer referência a um bloco de notas não publicado

Fazer referência a um bloco de anotações não publicado é útil quando você deseja depurar localmente. Quando você habilita esse recurso, uma execução de bloco de anotações busca o conteúdo atual no cache da Web. Se você executar uma célula que inclua uma instrução de bloco de anotações de referência, fará referência aos blocos de anotações de apresentação no navegador de bloco de anotações atual em vez de uma versão salva em um cluster. Outros blocos de anotações podem fazer referência às alterações no editor do bloco de anotações sem exigir que você publique (modo ao vivo) ou confirme (modo Git) as alterações. Usando essa abordagem, você pode evitar a poluição de bibliotecas comuns durante o processo de desenvolvimento ou depuração.

Você pode habilitar a referência a um bloco de anotações não publicado marcando a caixa de seleção apropriada no painel Propriedades .

A tabela a seguir compara casos. Embora %run e mssparkutils.notebook.run tenham o mesmo comportamento aqui, a tabela usa %run como exemplo.

Incidente	Desativar	Ativar
Modo ao vivo
Nb1 (publicado) %run Nb1	Executar a versão publicada do Nb1	Executar a versão publicada do Nb1
Nb1 (novo) %run Nb1	Erro	Executar novo Nb1
Nb1 (publicado anteriormente, editado) %run Nb1	Executar a versão publicada do Nb1	Executar versão editada do Nb1
Modo Git
Nb1 (publicado) %run Nb1	Executar a versão publicada do Nb1	Executar a versão publicada do Nb1
Nb1 (novo) %run Nb1	Erro	Executar novo Nb1
Nb1 (não publicado, autorizado) %run Nb1	Erro	Executar Nb1 confirmado
Nb1 (publicado anteriormente, autorizado) %run Nb1	Executar a versão publicada do Nb1	Executar a versão confirmada do Nb1
Nb1 (publicado anteriormente, novo na ramificação atual) %run Nb1	Executar a versão publicada do Nb1	Executar novo Nb1
Nb1 (não publicado, previamente autorizado, editado) %run Nb1	Erro	Executar versão editada do Nb1
Nb1 (previamente publicado e autorizado, editado) %run Nb1	Executar a versão publicada do Nb1	Executar versão editada do Nb1

Em resumo:

• Se você desativar a referência a um bloco de anotações não publicado, execute sempre a versão publicada .
• Se você habilitar a referência a um bloco de anotações não publicado, a execução de referência sempre adotará a versão atual do bloco de anotações que aparece na UX do notebook.

Gerenciar sessões ativas

Pode reutilizar as suas sessões de bloco de notas sem ter de iniciar novas. Nos blocos de anotações Synapse, você pode gerenciar suas sessões ativas em uma única lista. Para abrir a lista, selecione as reticências (...) e, em seguida, selecione Gerir sessões.

O painel Sessões ativas lista todas as sessões no espaço de trabalho atual que você iniciou a partir de um bloco de anotações. A lista mostra as informações da sessão e os blocos de anotações correspondentes. As ações Desanexar com bloco de anotações, Parar a sessão e Exibir no monitoramento estão disponíveis aqui. Além disso, pode ligar o bloco de notas selecionado a uma sessão ativa iniciada a partir de outro bloco de notas. A sessão é então separada do bloco de notas anterior (se não estiver inativo) e anexada ao atual.

Usar logs do Python em um bloco de anotações

Você pode encontrar logs Python e definir diferentes níveis e formatos de log usando o seguinte código de exemplo:

import logging

# Customize the logging format for all loggers
FORMAT = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
formatter = logging.Formatter(fmt=FORMAT)
for handler in logging.getLogger().handlers:
    handler.setFormatter(formatter)

# Customize the log level for all loggers
logging.getLogger().setLevel(logging.INFO)

# Customize the log level for a specific logger
customizedLogger = logging.getLogger('customized')
customizedLogger.setLevel(logging.WARNING)

# Logger that uses the default global log level
defaultLogger = logging.getLogger('default')
defaultLogger.debug("default debug message")
defaultLogger.info("default info message")
defaultLogger.warning("default warning message")
defaultLogger.error("default error message")
defaultLogger.critical("default critical message")

# Logger that uses the customized log level
customizedLogger.debug("customized debug message")
customizedLogger.info("customized info message")
customizedLogger.warning("customized warning message")
customizedLogger.error("customized error message")
customizedLogger.critical("customized critical message")

Ver o histórico de comandos de entrada

Os blocos de anotações Synapse suportam o comando %history magic para imprimir o histórico de comandos de entrada para a sessão atual. O %history comando magic é semelhante ao comando padrão Jupyter IPython e funciona para vários contextos de linguagem em um notebook.

%history [-n] [range [range ...]]

No código anterior, -n é o número de execução de impressão. O range valor pode ser:

• N: Imprima o Nth código da célula executada.
• M-N: Imprima o Mth código da célula para a Nth célula executada.

Por exemplo, para imprimir o histórico de entrada da primeira para a segunda célula executada, use %history -n 1-2.

Integrar um bloco de notas

Adicionar um bloco de anotações a um pipeline

Para adicionar um bloco de anotações a um pipeline existente ou criar um novo pipeline, selecione o botão Adicionar ao pipeline no canto superior direito.

Designar uma célula de parâmetro

Para parametrizar o seu bloco de notas, selecione as reticências (...) para aceder a mais comandos na barra de ferramentas da célula. Em seguida, selecione Alternar célula de parâmetro para designar a célula como a célula de parâmetro.

O Azure Data Factory procura a célula de parâmetro e trata essa célula como o padrão para os parâmetros passados no momento da execução. O mecanismo de execução adiciona uma nova célula abaixo da célula de parâmetro com parâmetros de entrada para substituir os valores padrão.

Atribuir valores de parâmetros de um pipeline

Depois de criar um bloco de anotações com parâmetros, você pode executá-lo a partir de um pipeline usando uma atividade de bloco de anotações Synapse. Depois de adicionar a atividade à tela do pipeline, você pode definir os valores dos parâmetros na seção Parâmetros básicos da guia Configurações .

Ao atribuir valores de parâmetro, você pode usar a linguagem de expressão de pipeline ou variáveis de sistema.

Usar teclas de atalho

Semelhante aos Jupyter Notebooks, os notebooks Synapse têm uma interface de usuário modal. O teclado faz coisas diferentes, dependendo do modo em que a célula do notebook está. Os blocos de anotações Synapse suportam os dois modos a seguir para uma célula de código:

• Modo de comando: uma célula está no modo de comando quando nenhum cursor de texto está solicitando que você digite. Quando uma célula está no modo de comando, você pode editar o bloco de anotações como um todo, mas não digitar em células individuais. Entre no modo de comando selecionando a tecla Esc ou usando o mouse para selecionar fora da área do editor de uma célula.

  

• Modo de edição: quando uma célula está no modo de edição, um cursor de texto solicita que você digite a célula. Entre no modo de edição selecionando a tecla Enter ou usando o mouse para selecionar a área do editor de uma célula.

  

Teclas de atalho no modo de comando

Ação	Atalho do bloco de anotações Synapse
Execute a célula atual e selecione abaixo	Shift+Enter
Execute a célula atual e insira abaixo	Alt+Enter
Executar célula atual	Ctrl+Enter
Selecionar célula acima	Cima
Selecione a célula abaixo	Baixo
Selecionar célula anterior	K
Selecionar célula seguinte	J
Inserir célula acima	A
Inserir célula abaixo	N
Excluir células selecionadas	Shift+D
Mudar para o modo de edição	Enter

Teclas de atalho no modo de edição

Ação	Atalho do bloco de anotações Synapse
Mover o cursor para cima	Cima
Mover o cursor para baixo	Baixo
Anular	Ctrl+Z
Refazer	Ctrl+Y
Comentar/Descomentar	Ctrl+/
Excluir palavra antes	Ctrl+Backspace
Eliminar palavra após	Ctrl+Excluir
Ir para o início da célula	Ctrl+Home
Ir para o fim da célula	Ctrl+End
Vá uma palavra para a esquerda	Ctrl+Esquerda
Vá uma palavra certa	Ctrl+Direita
Selecionar tudo	Ctrl+A
Recuo	Ctrl+]
Recuo	Ctrl+[
Mudar para o modo de comando	Esc

Conteúdos relacionados

• Cadernos de amostra de sinapse
• Guia de início rápido: criar um pool do Apache Spark no Azure Synapse Analytics usando ferramentas da Web
• O que é o Apache Spark no Azure Synapse Analytics?
• Utilizar .NET para Apache Spark com o Azure Synapse Analytics
• Documentação do .NET para Apache Spark
• Documentação do Azure Synapse Analytics