Criar, desenvolver e manter blocos de notas do Synapse no Azure Synapse Analytics

  • Artigo

Um bloco de notas do Synapse é uma interface Web para criar ficheiros que contenham 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 blocos de notas também são amplamente utilizados na preparação de dados, visualização de dados, machine learning e outros cenários de Macrodados.

Com um bloco de notas do Synapse, pode:

  • Introdução ao esforço de configuração zero.
  • Mantenha os dados seguros com as funcionalidades de segurança empresarial incorporadas.
  • Analisar dados em formatos não processados (CSV, txt, JSON, etc.), formatos de ficheiro processados (parquet, Delta Lake, ORC, etc.) e ficheiros de dados tabulares SQL no Spark e SQL.
  • Seja produtivo com capacidades de criação melhoradas e visualização de dados incorporada.

Este artigo descreve como utilizar blocos de notas no Synapse Studio.

Criar um bloco de notas

Existem duas formas de criar um bloco de notas. Pode criar um novo bloco de notas ou importar um bloco de notas existente para uma área de trabalho do Synapse a partir do Object Explorer. Os blocos de notas do Synapse reconhecem ficheiros IPYNB padrão Jupyter Notebook.

Captura de ecrã a mostrar a criação de blocos de notas novos ou de importação

Desenvolver blocos de notas

Os blocos de notas consistem em células, que são blocos individuais de código ou texto que podem ser executados de forma independente ou como um grupo.

Fornecemos operações avançadas para desenvolver blocos de notas:

Nota

Nos blocos de notas, existe uma SparkSession criada automaticamente para si, armazenada numa variável chamada spark. Também existe uma variável para SparkContext denominada sc. Os utilizadores podem aceder diretamente a estas variáveis e não devem alterar os valores destas variáveis.

Adicionar uma célula

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

  1. Paire o cursor sobre o espaço entre duas células e selecione Código ou Markdown. Captura de ecrã do botão add-azure-notebook-cell-with-cell

  2. Utilize as teclas de atalho aznb no modo de comando. Prima A para inserir uma célula acima da célula atual. Prima B para inserir uma célula abaixo da célula atual.

Definir um idioma primário

Os blocos de notas do Synapse suportam quatro idiomas do Apache Spark:

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

Pode definir o idioma primário para novas células adicionadas a partir da lista pendente na barra de comandos superior.

Captura de ecrã a mostrar default-synapse-language

Utilizar vários idiomas

Pode utilizar vários idiomas num bloco de notas ao especificar o comando magic de linguagem correto no início de uma célula. A tabela seguinte lista os comandos mágicos para mudar de idiomas de células.

Comando magic Linguagem Description
%%pyspark Python Execute uma consulta Python no Contexto do Spark.
%%spark Scala Execute uma consulta Scala no Contexto do Spark.
%%sql SparkSQL Execute uma consulta SparkSQL no Contexto do Spark.
%%csharp .NET para Spark C# Execute uma consulta .NET para Spark C# no Contexto do Spark.
%%sparkr R Execute uma consulta R no Contexto do Spark.

A imagem seguinte é um exemplo de como pode escrever uma consulta PySpark com o comando magic %%pyspark ou uma consulta SparkSQL com o comando magic %%sql num bloco de notas do Spark(Scala ). Repare que o idioma principal do bloco de notas está definido como pySpark.

Captura de ecrã a mostrar os comandos mágicos do Synapse Spark

Utilizar tabelas temporárias para referenciar dados entre idiomas

Não pode referenciar dados ou variáveis diretamente em diferentes idiomas num bloco de notas do Synapse. No Spark, uma tabela temporária pode ser referenciada entre idiomas. Eis um exemplo de como ler um Scala DataFrame no PySpark e SparkSQL utilizar uma tabela temporária do Spark como solução.

  1. Na Célula 1, leia um DataFrame a partir de um conector do conjunto de SQL com o 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 com o SQL do Spark.

    %%sql
SELECT * FROM mydataframetable

  3. Na Célula 3, utilize os dados no PySpark.

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

IntelliSense estilo IDE

Os blocos de notas do Synapse estão integrados com o editor do Mónaco para levar o IntelliSense ao editor de células ao estilo IDE. O realce da sintaxe, o marcador de erros e as conclusões automáticas de código ajudam-no a escrever código e a identificar problemas mais rapidamente.

As funcionalidades do IntelliSense estão em diferentes níveis de maturidade para diferentes idiomas. Utilize a tabela seguinte para ver o que é suportado.

Idiomas Realce da Sintaxe Marcador de Erro de Sintaxe Conclusão do Código de Sintaxe Conclusão do Código Variável Conclusão do Código da Função do Sistema Conclusão do Código da Função de Utilizador Avanço Inteligente Dobragem de Código
PySpark (Python) Yes Yes Yes Yes Yes Yes Yes Yes
Apache Spark (Scala) Yes Yes Yes Yes Yes Yes - Yes
SparkSQL Yes Yes Yes Yes Yes - - -
.NET para Spark (C#) Yes Yes Yes Yes Yes Yes Yes Yes

Nota

É necessária uma sessão ativa do Spark para beneficiar a Conclusão do Código Variável, a Conclusão do Código da Função do Sistema, a Conclusão do Código de Função do Utilizador para .NET para Spark (C#).

Fragmentos de Código

Os blocos de notas do Synapse fornecem fragmentos de código que facilitam a introdução de padrões de código utilizados comuns, como configurar a sessão do Spark, ler dados como um DataFrame do Apache Spark ou desenhar gráficos com matplotlib, etc.

Os fragmentos são apresentados em Teclas de atalho do estilo IDE IntelliSense , misturados com outras sugestões. Os fragmentos de código alinham-se com a linguagem da célula de código. Pode ver fragmentos disponíveis ao escrever Fragmento ou quaisquer palavras-chave apresentadas no título do fragmento no editor de células de código. Por exemplo, ao escrever como lido , pode ver a lista de fragmentos para ler dados de várias origens de dados.

GIF animado de fragmentos de código do Synapse

Formatar célula de texto com botões da barra de ferramentas

Pode utilizar os botões de formatação na barra de ferramentas das células de texto para realizar ações de markdown comuns. Inclui texto a negrito, itálico de texto, parágrafos/cabeçalhos através de uma lista pendente, inserção de código, inserção de lista não ordenada, inserção de lista ordenada, inserção de hiperligação e inserção de imagem a partir do URL.

Captura de ecrã da barra de ferramentas de células de texto do Synapse

Anular/Refazer operação de célula

Selecione o botão Anular / Refazer ou prima Z / Shift+Z para revogar as operações de células mais recentes. Agora, pode anular/refazer até às 10 operações de células históricas mais recentes.

Captura de ecrã a mostrar o Synapse a anular células do aznb

Operações de anulação de célula suportadas:

  • Inserir/Eliminar célula: pode revogar as operações de eliminação ao selecionar Anular, o conteúdo do texto é mantido juntamente com a célula.
  • Reordenar célula.
  • Ativar/desativar parâmetro.
  • Converter entre a célula Code e a célula Markdown.

Nota

As operações de texto na célula e as operações de comentários de células de código não são anuláveis. Agora, pode anular/refazer até às 10 operações de células históricas mais recentes.

Comentar células de código

  1. Selecione o botão Comentários na barra de ferramentas do bloco de notas para abrir o painel Comentários .

    Captura de ecrã do botão de comentário do Synapse

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

    Captura de ecrã do novo comentário do Synapse

  3. Pode efetuar Editar comentário, Resolver tópico ou Eliminar tópico ao clicar no botão Mais para além do seu comentário.

    Captura de ecrã do comentário de edição do Synapse

Mover uma célula

Clique no lado esquerdo de uma célula e arraste-a para a posição pretendida. GIF animado de células de movimentação do Synapse

Eliminar uma célula

Para eliminar uma célula, selecione o botão eliminar na mão direita da célula.

Também pode utilizar teclas de atalho no modo de comando. Prima Shift+D para eliminar a célula atual.

Captura de ecrã a mostrar azure-notebook-delete-a-cell

Fechar uma entrada de célula

Selecione as reticências de comandos Mais (...) na barra de ferramentas da célula e Ocultar entrada para fechar a entrada da célula atual. Para expandi-la, selecione a opção Mostrar entrada enquanto a célula está fechada.

GIF animado de azure-notebook-collapse-cell-input

Fechar uma saída de célula

Selecione as reticências de Comandos Mais (...) na barra de ferramentas da célula e Ocultar saída para fechar a saída da célula atual. Para expandi-la, selecione Mostrar saída enquanto a saída da célula está oculta.

GIF animado de azure-notebook-collapse-cell-output

Destaque do bloco de notas

Os Destaques (Índice) apresentam o primeiro cabeçalho markdown de qualquer célula de markdown numa janela da barra lateral para uma navegação rápida. A barra lateral Destaques é redimensionável e minimizável para se ajustar ao ecrã das melhores formas possíveis. Pode selecionar o botão Destaques na barra de comandos do bloco de notas para abrir ou ocultar a barra lateral

Captura de ecrã a mostrar azure-notebook-outline

Executar blocos 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 são representados no bloco de notas.

Executar uma célula

Existem várias formas de executar o código numa célula.

  1. Paire o cursor sobre a célula que pretende executar e selecione o botão Executar Célula ou prima Ctrl+Enter.

    Captura de ecrã a mostrar run-cell-1

  2. Utilize teclas de atalho no modo de comando. Prima Shift+Enter para executar a célula atual e selecione a célula abaixo. Prima Alt+Enter para executar a célula atual e inserir uma nova célula abaixo.

Executar todas as células

Selecione o botão Executar Tudo para executar todas as células no bloco de notas atual em sequência.

Captura de ecrã a mostrar a execução de todas as células

Executar todas as células acima ou abaixo

Expanda a lista pendente a partir do botão Executar tudo e, em seguida, selecione Executar células acima para executar todas as células acima da atual em sequência. Selecione Executar células abaixo para executar todas as células abaixo da atual em sequência.

Captura de ecrã a mostrar azure-notebook-run-cells-above-or-below

Cancelar todas as células em execução

Selecione o botão Cancelar Tudo para cancelar as células ou células em execução que aguardam na fila. Captura de ecrã de azure-notebook-cancel-all-cells

Referência do bloco de notas

Pode utilizar o %run <notebook path> comando magic para referenciar outro bloco de notas no contexto do bloco de notas atual. Todas as variáveis definidas no bloco de notas de referência estão disponíveis no bloco de notas atual. %run O comando magic suporta chamadas aninhadas, mas não suporta chamadas recursivas. Receberá uma exceção se a profundidade da instrução for superior a cinco.

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

A referência do bloco de notas funciona no modo interativo e no pipeline do Synapse.

Nota

  • %run Atualmente, o comando só suporta a passagem de um caminho absoluto ou nome do bloco de notas apenas como parâmetro. O caminho relativo não é suportado.
  • %run Atualmente, o comando só suporta 4 tipos de valores de parâmetros: int, float, bool, string, a operação de substituição variável não é suportada.
  • Os blocos de notas referenciados têm de ser publicados. Tem de publicar os blocos de notas para os referenciar, a menos que a opção Referência não publicada esteja ativada. Synapse Studio não reconhece os blocos de notas não publicados do repositório git.
  • Os blocos de notas referenciados não suportam a instrução de que a profundidade é superior a cinco.

Explorador de variáveis

O bloco de notas do Synapse fornece um explorador de variáveis incorporado para que possa ver a lista do nome, tipo, comprimento e valor das variáveis na sessão atual do Spark para células do PySpark (Python). Mais variáveis são apresentadas automaticamente à medida que são definidas nas células de código. Clicar em cada cabeçalho de coluna ordena as variáveis na tabela.

Pode selecionar o botão Variáveis na barra de comandos do bloco de notas para abrir ou ocultar o explorador de variáveis.

Captura de ecrã do azure-notebook-variable-explorer

Nota

O explorador de variáveis só suporta python.

Indicador de estado da célula

É apresentado um estado de execução de células passo a passo abaixo da célula para o ajudar a ver o progresso atual. Assim que a execução da célula estiver concluída, é apresentado um resumo de execução com a duração total e a hora de fim e mantido lá para referência futura.

Captura de ecrã do estado da célula

Indicador de progresso do Spark

O bloco de notas do Synapse baseia-se puramente no Spark. As células de código são executadas remotamente no conjunto do Apache Spark sem servidor. É fornecido um indicador de progresso da tarefa do Spark com uma barra de progresso em tempo real para o ajudar a compreender o estado de execução da tarefa. O número de tarefas por cada tarefa ou fase ajuda-o a identificar o nível paralelo da tarefa do Spark. Também pode aprofundar a IU do Spark de uma tarefa (ou fase) específica através da seleção da ligação no nome da tarefa (ou fase).

Captura de ecrã do spark-progress-indicator

Configuração da sessão do Spark

Pode especificar a duração do tempo limite, o número e o tamanho dos executores a atribuir à sessão atual do Spark em Configurar sessão. Reinicie a sessão do Spark para que as alterações de configuração entrem em vigor. Todas as variáveis de blocos de notas em cache são desmarcadas.

Também pode criar uma configuração a partir da configuração do Apache Spark ou selecionar uma configuração existente. Para obter detalhes, veja Gestão de Configuração do Apache Spark.

Captura de ecrã da gestão de sessões

Comando magic da configuração da sessão do Spark

Também pode especificar as definições de sessão do Spark através de um comando mágico %%configure. A sessão do Spark tem de ser reiniciada para tornar as definições em vigor. Recomendamos que execute o %%configure no início do seu bloco de notas. Eis um exemplo, veja para obter uma https://github.com/cloudera/livy#request-body lista completa de parâmetros válidos.

%%configure
{
    //You can get a list of valid parameters to config 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 standard spark property, to find more available properties please visit:https://spark.apache.org/docs/latest/configuration.html#application-properties.
        "spark.driver.maxResultSize":"10g",
    //Example of customized property, you can specify count of lines that Spark SQL returns by configuring "livy.rsc.sql.num-rows".
        "livy.rsc.sql.num-rows":"3000" 
    }
}

Nota

  • Recomenda-se que "DriverMemory" e "ExecutorMemory" definam o mesmo valor em %%configure, assim como "driverCores" e "executorCores".
  • Pode utilizar %%configure em pipelines do Synapse, mas se não estiver definido na primeira célula de código, a execução do pipeline falhará porque não é possível reiniciar a sessão.
  • A %%configure utilizada em mssparkutils.notebook.run vai ser ignorada, mas a utilização no bloco de notas %run continuará a ser executada.
  • As propriedades de configuração padrão do Spark têm de ser utilizadas no corpo "conf". Não suportamos referência de primeiro nível para as propriedades de configuração do Spark.
  • Algumas propriedades especiais do spark, incluindo "spark.driver.cores", "spark.executor.cores", "spark.driver.memory", "spark.executor.memory", "spark.executor.instances" não entrarão em vigor no corpo "conf".

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

A configuração da sessão parametrizada permite-lhe substituir o valor em %%configure magic por parâmetros Execução de pipeline (atividade do Bloco de Notas). Ao preparar %%configure a célula de código, pode substituir os valores predefinidos (também configuráveis, 4 e "2000" no exemplo abaixo) com um objeto como este:

{
      "activityParameterName": "paramterNameInPipelineNotebookActivity",
      "defaultValue": "defaultValueIfNoParamterFromPipelineNotebookActivity"
} 

%%configure  

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

O bloco de notas utiliza o valor predefinido se executar um bloco de notas diretamente no modo interativo ou nenhum parâmetro que corresponda a "activityParameterName" for fornecido a partir da atividade do Bloco de Notas de Pipeline.

Durante o modo de execução do pipeline, pode configurar as definições de atividade do Bloco de Notas de pipeline como abaixo: Captura de ecrã da configuração da sessão parametrizada

Se quiser alterar a configuração da sessão, o nome dos parâmetros de atividade do bloco de notas do pipeline deve ser o mesmo que activityParameterName no bloco de notas. Ao executar este pipeline, neste exemplo, os driverCores em %%configure serão substituídos por 8 e livy.rsc.sql.num-rows será substituído por 4000.

Nota

Se o pipeline de execução falhar devido à utilização deste novo magic %%configure, pode verificar mais informações de erro ao executar %%configure a célula mágica no modo interativo do bloco de notas.

Trazer dados para um bloco de notas

Pode carregar dados de Armazenamento de Blobs do Azure, Azure Data Lake Store Gen2 e conjunto de SQL, conforme mostrado nos exemplos de código abaixo.

Ler um CSV do Azure Data Lake Store Gen2 como um DataFrame do Spark

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 CSV a partir de 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 Blob 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 primária

Pode aceder diretamente aos dados na conta de armazenamento primária. Não é necessário fornecer as chaves secretas. No Data Explorer, clique com o botão direito do rato num ficheiro e selecione Novo bloco de notas para ver um novo bloco de notas com extrator de dados gerado automaticamente.

Captura de ecrã de dados para célula

IPython Widgets

Os Widgets são objetos Python com eventos que têm uma representação no browser, muitas vezes como um controlo como um controlo de deslize, caixa de texto, etc. Os Widgets IPython só funcionam no ambiente python, não são suportados noutros idiomas (por exemplo, Scala, SQL, C#) ainda.

Para utilizar o Widget IPython

  1. Primeiro, tem de importar ipywidgets o módulo para utilizar a arquitetura Widget do Jupyter.

    import ipywidgets as widgets

  2. Pode utilizar a função de nível display superior para compor um widget ou deixar uma expressão do tipo widget na última linha de célula de código.

    slider = widgets.IntSlider()
display(slider)

    slider = widgets.IntSlider()
slider

  3. Execute a célula, o widget é apresentado na área de saída.

    Captura de ecrã do controlo de deslize de widgets ipython

  4. Pode utilizar várias chamadas display() para compor a mesma instância de widget várias vezes, mas estas permanecem sincronizadas umas com as outras.

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

    Captura de ecrã dos controlos de deslize de widgets ipython

  5. Para compor dois widgets independentemente uns dos outros, crie duas instâncias de widget:

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

Widgets suportados

Tipo de Widgets Widgets
Widgets numéricos IntSlider, FloatSlider, FloatLogSlider, IntRangeSlider, FloatRangeSlider, IntProgress, FloatProgress, BoundedIntText, BoundedFloatText, IntText, FloatText
Widgets booleanos Botão de Alternar, Caixa de Verificação, Válido
Widgets de seleção Menu pendente, RadioButtons, Select, SelectionSlider, SelectionRangeSlider, ToggleButtons, SelectMultiple
Widgets de Cadeia Texto, Área de texto, Caixa de Combinação, Palavra-passe, Etiqueta, HTML, Html Matemática, Imagem, Botão
Widgets de Reprodução (Animação) Seletor de datas, Selecionador de cores, Controlador
Widgets de Contentor/Esquema Box, HBox, VBox, GridBox, Accordion, Tabs, Stacked

Limitações conhecidas

  1. Os seguintes widgets ainda não são suportados. Pode seguir a solução correspondente como abaixo:

    Funcionalidade Solução
    Output widget Em vez disso, pode utilizar print() a função para escrever texto em stdout.
    widgets.jslink() Pode utilizar widgets.link() a função para ligar dois widgets semelhantes.
    FileUpload widget Ainda não é suportado.

  2. A função global display fornecida pelo Synapse não suporta a apresentação de vários widgets numa chamada (ou seja, display(a, b)), que é diferente da função IPython display .

  3. Se fechar um bloco de notas que contém o Widget IPython, não poderá ver ou interagir com o mesmo até executar novamente a célula correspondente.

Guardar blocos de notas

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

  1. Para guardar as alterações efetuadas num único bloco de notas, selecione o botão Publicar na barra de comandos do bloco de notas.

    Captura de ecrã do bloco de notas de publicação

  2. Para guardar todos os blocos de notas na área de trabalho, selecione o botão Publicar tudo na barra de comandos da área de trabalho.

    Captura de ecrã a mostrar publish-all

Nas propriedades do bloco de notas, pode configurar se pretende incluir a saída da célula ao guardar.

Captura de ecrã de notebook-properties

Comandos magic

Pode utilizar comandos mágicos do Jupyter familiares nos blocos de notas do Synapse. Reveja a seguinte lista como os comandos mágicos atuais disponíveis. Conte-nos os seus casos de utilização no GitHub para que possamos continuar a criar mais comandos mágicos para satisfazer as suas necessidades.

Nota

Só são suportados os seguintes comandos magic no pipeline do Synapse: %%pyspark, %%spark, %%csharp, %%sql.

Magias de linha disponíveis: %lsmagic, %time, %timeit, %history, %run, %load

Magics de células disponíveis: %%time, %%timeit, %%capture, %%writefile, %%sql, %%pyspark, %%spark, %%csharp, %%html, %%configure

Referência de bloco de notas não publicado

O bloco de notas não publicado de referência é útil quando pretende depurar "localmente", ao ativar esta funcionalidade, a execução do bloco de notas obtém o conteúdo atual na cache Web. Se executar uma célula que inclua uma instrução de blocos de notas de referência, referencia os blocos de notas de apresentação no browser do bloco de notas atual em vez de uma versão guardada no cluster, o que significa que as alterações no editor de blocos de notas podem ser referenciadas imediatamente por outros blocos de notas sem terem de ser publicados (Modo dinâmico) ou consolidados( Modo Git), ao tirar partido desta abordagem, pode evitar facilmente que bibliotecas comuns sejam poluídas durante o processo de desenvolvimento ou depuração.

Pode ativar o bloco de notas Não Publicado de Referência no painel Propriedades:

Captura de ecrã a mostrar a referência do bloco de notas

Para comparação de casos diferentes, verifique a tabela abaixo:

Repare que %run e mssparkutils.notebook.run têm o mesmo comportamento aqui. %run Utilizamos aqui como exemplo.

Caso Desativar Ativar
Modo Em Direto
- 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 a 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, consolidado)
%run Nb1		 Erro Executar Nb1 consolidado
- Nb1 (publicado anteriormente, consolidado)
%run Nb1		 Executar a versão publicada do Nb1 Executar a versão consolidada do Nb1
- Nb1 (publicado anteriormente, novo no ramo atual)
%run Nb1		 Executar a versão publicada do Nb1 Executar novo Nb1
- Nb1 (Não publicado, anteriormente consolidado, editado)
%run Nb1		 Erro Executar a versão editada do Nb1
- Nb1 (anteriormente publicado e consolidado, editado)
%run Nb1		 Executar a versão publicada do Nb1 Executar a versão editada do Nb1

Conclusão

  • Se estiver desativado, execute sempre a versão publicada .
  • Se estiver ativada, a prioridade é: editada/nova > publicação consolidada > .

Gestão de sessões ativas

Pode reutilizar as suas sessões de blocos de notas de forma conveniente agora sem ter de começar as novas. Agora, o bloco de notas do Synapse suporta a gestão das suas sessões ativas na lista Gerir sessões . Pode ver todas as sessões na área de trabalho atual iniciadas por si a partir do bloco de notas.

Captura de ecrã a mostrar notebook-manage-sessions

Nas sessões Ativas, pode ver as informações da sessão e o bloco de notas correspondente que está atualmente anexado à sessão. Pode utilizar Desencaixar com o bloco de notas, Parar a sessão e Ver na monitorização a partir daqui. Além disso, pode ligar facilmente o seu bloco de notas selecionado a uma sessão ativa na lista iniciada a partir de outro bloco de notas, a sessão é desanexada do bloco de notas anterior (se não estiver inativa) e, em seguida, anexar à atual.

Captura de ecrã de notebook-sessions-list

Registo do Python no Bloco de Notas

Pode encontrar registos do Python e definir diferentes níveis de registo e formato ao seguir o código de exemplo abaixo:

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 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 use 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 use 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")

Integrar um bloco de notas

Adicionar um bloco de notas a um pipeline

Selecione o botão Adicionar ao pipeline no canto superior direito para adicionar um bloco de notas a um pipeline existente ou criar um novo pipeline.

Captura de ecrã de Adicionar bloco de notas ao pipeline

Designar uma célula de parâmetros

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âmetros.

Captura de ecrã a mostrar azure-notebook-toggle-parameter

Azure Data Factory procura a célula de parâmetros e trata esta célula como predefinições para os parâmetros transmitidos no momento da execução. O motor de execução adiciona uma nova célula abaixo da célula de parâmetros com parâmetros de entrada para substituir os valores predefinidos.

Atribuir valores de parâmetros a partir de um pipeline

Depois de criar um bloco de notas com parâmetros, pode executá-lo a partir de um pipeline com a atividade do Bloco de Notas do Synapse. Depois de adicionar a atividade à tela do pipeline, poderá definir os valores dos parâmetros na secção Parâmetros base no separador Definições .

Captura de ecrã a mostrar Atribuir um parâmetro

Ao atribuir valores de parâmetros, pode utilizar a linguagem de expressão de pipeline ou as variáveis de sistema.

Teclas de atalho

À semelhança do Jupyter Notebooks, os blocos de notas do Synapse têm uma interface de utilizador modal. O teclado faz coisas diferentes consoante o modo em que a célula do bloco de notas se encontra. Os blocos de notas do Synapse suportam os dois modos seguintes para uma determinada célula de código: modo de comando e modo de edição.

  1. Uma célula está no modo de comando quando não existe nenhum cursor de texto a pedir-lhe para escrever. Quando uma célula está no Modo de comando, pode editar o bloco de notas como um todo, mas não escrever em células individuais. Introduza o modo de comando premindo ESC ou utilizando o rato para selecionar fora da área de editor de uma célula.

    Captura de ecrã do modo de comando

  2. O modo de edição é indicado por um cursor de texto que lhe pede para escrever na área do editor. Quando uma célula está no modo de edição, pode escrever na célula. Introduza o modo de edição premindo Enter ou utilizando o rato para selecionar na área de editor de uma célula.

    Captura de ecrã do modo de edição

Teclas de atalho no modo de comando

Ação Atalhos do bloco de notas do 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 B
Eliminar células selecionadas Shift+D
Mudar para o modo de edição ENTER

Teclas de atalho no modo de edição

Com os seguintes atalhos de batimentos de teclas, pode navegar e executar código mais facilmente nos blocos de notas do Synapse no modo Editar.

Ação Atalhos do bloco de notas do Synapse
Mover o cursor para cima Cima
Mover o cursor para baixo Baixo
Anular Ctrl +Z
Refazer Ctrl + Y
Comentário/Comentário Ctrl + /
Eliminar palavra antes Ctrl + Tecla de Retrocesso
Eliminar palavra após Ctrl + Eliminar
Ir para início da célula Ctrl + Home
Ir para o fim da célula Ctrl + End
Ir uma palavra para a esquerda Ctrl + Esquerda
Ir uma palavra para a direita Ctrl + Direita
Selecionar tudo Ctrl +A
Avançar Ctrl +]
Dedent Ctrl + [
Mudar para o modo de comando Esc

Passos seguintes