Desenvolva, execute e gerencie blocos de anotações do Microsoft Fabric

Um notebook Microsoft Fabric é um item de código primário para o desenvolvimento de trabalhos do Apache Spark e experimentos de aprendizado de máquina. É uma superfície interativa baseada na Web usada por cientistas de dados e engenheiros de dados para escrever código, beneficiando-se de visualizações ricas e texto Markdown. Este artigo explica como desenvolver blocos de anotações com operações de célula de código e executá-las.

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 independentemente ou em grupo.

Fornecemos operações ricas para desenvolver notebooks:

• Adicionar uma célula
• Definir um idioma principal
• Usar vários idiomas
• IntelliSense estilo IDE
• Fragmentos de código
• Arrastar e soltar para inserir trechos
• Arrastar e soltar para inserir imagens
• Formatar célula de texto com botões da barra de ferramentas
• Desfazer ou refazer a operação da célula
• Mover uma célula
• Excluir uma célula
• Recolher uma entrada de célula
• Recolher uma saída de célula
• Segurança de saída de célula
• Bloquear ou congelar uma célula
• Conteúdo do caderno
• Dobragem Markdown
• Localizar e substituir

Adicionar uma célula

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

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

2. Use teclas de atalho no modo de comando. Pressione A para inserir uma célula acima da célula atual. Pressione B para inserir uma célula abaixo da célula atual.

Definir um idioma principal

Atualmente, os notebooks de malha suportam quatro idiomas Apache Spark:

• PySpark (Python)
• Apache Spark (Scala)
• SQL do Apache Spark
• SparkR

Você pode definir o idioma principal para novas células adicionadas na lista suspensa na barra de comandos superior.

Usar vários idiomas

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

Comando mágico	Idioma	Descrição
%%faísca	Python	Execute uma consulta Python no Apache Spark Context.
%%faísca	Scala	Execute uma consulta Scala no Apache Spark Context.
%%SQL	SparkSQL	Execute uma consulta SparkSQL no Apache Spark Context.
%%html	Html	Execute uma consulta HTML no Apache Spark Context.
%%espumante	R	Execute uma consulta R no Apache Spark Context.

IntelliSense estilo IDE

Os notebooks de tecido são integrados com o editor de Mônaco para trazer o IntelliSense no estilo IDE para o editor de células. Realce de sintaxe, marcador de erro e conclusão automática de código ajudam você a escrever código rapidamente e identificar problemas.

Os recursos do IntelliSense estão em diferentes níveis de maturidade para diferentes idiomas. A tabela a seguir mostra o que o Fabric suporta:

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	Sim	Sim
SparkSQL	Sim	Sim	Sim	Sim	Sim	No	Sim	Sim
SparkR	Sim	Sim	Sim	Sim	Sim	Sim	Sim	Sim

Fragmentos de código

Os blocos de anotações de malha fornecem trechos de código que ajudam você a escrever facilmente padrões de código comumente usados, como:

• Lendo dados como um Apache Spark DataFrame
• Desenhando gráficos com Matplotlib

Trechos aparecem em teclas de atalho do estilo IDE IntelliSense misturado com outras sugestões. O conteúdo do trecho de código é alinhado com a linguagem da célula de código. Você pode ver os trechos disponíveis digitando Snippet. Você também pode digitar qualquer palavra-chave para ver uma lista de trechos relevantes. Por exemplo, se você digitar ler, verá a lista de trechos para ler dados de várias fontes de dados.

Arrastar e soltar para inserir trechos

Use arrastar e soltar para ler dados do Lakehouse explorer convenientemente. Vários tipos de arquivo são suportados aqui; Você pode operar em arquivos de texto, tabelas, imagens, etc. Você pode soltar para uma célula existente ou para uma nova célula. O bloco de anotações gera o trecho de código de acordo com a visualização dos dados.

Arrastar e soltar para inserir imagens

Use o recurso de arrastar e soltar para inserir facilmente imagens do seu navegador ou computador local em uma célula de marcação.

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

Para concluir ações comuns de marcação, use os botões de formatação na barra de ferramentas da célula de texto.

Desfazer ou refazer operações de célula

Selecione Desfazer ou Refazer ou pressione Z ou Shift+Z para revogar as operações de célula mais recentes. Você pode desfazer ou refazer até 10 das últimas operações de células históricas.

Operações de célula de desfazer suportadas:

• Inserir ou excluir célula. Você pode revogar as operações de exclusão selecionando Desfazer (o conteúdo do texto é mantido junto com a célula).
• Reordenar célula.
• Alternar parâmetro.
• Converter entre a célula de código e a célula Markdown.

Mover uma célula

Você pode arrastar da parte vazia de uma célula e soltá-la na posição desejada.

Você também pode mover a célula selecionada usando Mover para cima e Mover para baixo na faixa de opções.

Excluir uma célula

Para excluir uma célula, selecione o botão Excluir no lado direito da célula.

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

Recolher uma entrada de célula

Selecione as reticências Mais comandos (...) na barra de ferramentas da célula e Ocultar entrada para recolher a entrada da célula atual. Para expandi-lo novamente, selecione Mostrar entrada quando a célula estiver recolhida.

Recolher uma saída de célula

Selecione as reticências Mais comandos (...) na barra de ferramentas da célula e Ocultar saída para recolher a saída da célula atual. Para expandi-lo novamente, selecione Mostrar saída quando a saída da célula estiver recolhida.

Segurança de saída de célula

Usando funções de acesso a dados do OneLake (visualização), os usuários podem configurar o acesso a apenas pastas específicas em uma casa do lago durante consultas de bloco de anotações. Os usuários sem acesso a uma pasta ou tabela verão um erro não autorizado durante a execução da consulta.

Bloquear ou congelar uma célula

As operações de bloqueio e congelamento de células permitem que você torne as células somente leitura ou interrompa a execução de células de código individualmente.

Mesclar e dividir células

Você pode usar Mesclar com a célula anterior ou Mesclar com a próxima célula para mesclar células relacionadas convenientemente.

Selecionar Dividir célula ajuda a dividir instruções irrelevantes em várias células. A operação divide o código de acordo com a posição da linha do cursor.

Conteúdo do caderno

Selecionar Contornos ou Sumário apresenta o primeiro cabeçalho de marcação de qualquer célula de marcação em uma janela da barra lateral para navegação rápida. A barra lateral Contornos é redimensionável e dobrável para se ajustar à tela da melhor maneira possível. Selecione o botão Conteúdo na barra de comandos do bloco de notas para abrir ou ocultar a barra lateral.

Dobragem Markdown

A opção de dobragem de marcação permite ocultar células sob uma célula de marcação que contém um cabeçalho. A célula de markdown e suas células ocultas são tratadas da mesma forma que um conjunto de células contíguas multi-selecionadas ao executar operações celulares.

Localizar e substituir

A opção localizar e substituir pode ajudá-lo a corresponder e localizar as palavras-chave ou expressões no conteúdo do seu bloco de notas. Você também pode facilmente substituir a cadeia de caracteres de destino por uma nova cadeia de caracteres.

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 apresentados 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 deseja executar e selecione o botão Executar célula ou pressione Ctrl+Enter.

• Use teclas de atalho no modo de comando. Pressione Shift+Enter para executar a célula atual e selecionar a próxima célula. Pressione Alt+Enter para executar a célula atual e inserir uma nova célula.

Executar todas as células

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

Executar todas as células acima ou abaixo

Expanda a lista suspensa de Executar tudo e selecione Executar células acima para executar todas as células acima da corrente em sequência. Selecione Executar células abaixo para executar a célula atual e todas as células abaixo da corrente em sequência.

Cancelar todas as células em execução

Selecione Cancelar tudo para cancelar as células em execução ou as células que aguardam na fila.

Parar sessão

Parar sessão cancela as células em execução e espera e interrompe a sessão atual. Você pode reiniciar uma nova sessão selecionando a opção de execução novamente.

Execução de referência

Referência executar um bloco de anotações

Além da API de execução de referência notebookutils, você também pode usar o %run <notebook name> comando magic para fazer referência a outro bloco de anotações dentro do contexto do bloco de anotações atual. Todas as variáveis definidas no bloco de notas de referência estão disponíveis no bloco de notas atual. O %run comando magic suporta chamadas aninhadas, mas não suporta chamadas recursivas. Você receberá uma exceção se a profundidade da instrução for maior que cinco.

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

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

Referência executar um script

O %run comando também permite que você execute arquivos Python ou SQL que são armazenados nos recursos internos do notebook, para que você possa executar seus arquivos de código-fonte no notebook convenientemente.

%run [-b/--builtin -c/--current] [script_file.py/.sql] [variables ...]

Para opções:

• -b/--builtin: Esta opção indica que o comando localizará e executará o arquivo de script especificado a partir dos recursos internos do bloco de anotações.
• -c/--current: Esta opção garante que o comando utiliza sempre os recursos incorporados do bloco de notas atual, mesmo que o bloco de notas atual seja referenciado por outros blocos de notas.

Exemplos:

• Para executar script_file.py a partir dos recursos internos: %run -b script_file.py

• Para executar script_file.sql a partir dos recursos internos: %run -b script_file.sql

• Para executar script_file.py a partir dos recursos internos com variáveis específicas: %run -b script_file.py { "parameterInt": 1, "parameterFloat": 2.5, "parameterBool": true, "parameterString": "abc" }

Exemplo de uso para maiúsculas e minúsculas aninhadas:

• Suponhamos que temos dois cadernos.
  • Notebook1: Contém script_file1.py em seus recursos internos
  • Notebook2: contém script_file2.py em seus recursos internos
• Vamos usar o Notebook1 como um bloco de anotações raiz com o conteúdo: %run Notebook2.
• Em seguida, no Notebook2 a instrução de uso é:
  • Para executar script_file1.py no Notebook1 (o bloco de anotações raiz), o código seria: %run -b script_file1.py
  • Para executar script_file2.py no Notebook2 (o Bloco de Anotações atual), o código seria: %run -b -c script_file2.py

Explorador de variáveis

Os blocos de anotações de malha fornecem um explorador de variáveis interno que exibe a lista de nome, tipo, comprimento e valor das variáveis na sessão atual do Spark para células PySpark (Python). Mais variáveis aparecem automaticamente à medida que são definidas nas células de código. Clicar em cada cabeçalho de coluna classifica as variáveis na tabela.

Para abrir ou ocultar o explorador de variáveis, selecione Variáveis na Vista do friso do bloco de notas.

Indicador de estado da célula

Um status de execução de célula passo a passo é exibido abaixo da célula para ajudá-lo a ver seu progresso atual. Quando a execução da célula estiver concluída, um resumo de execução com a duração total e a hora de término aparecerá e será armazenado lá para referência futura.

Indicador de trabalho Apache Spark em linha

O notebook Fabric é baseado no Apache Spark. As células de código são executadas no cluster Apache Spark remotamente. Um indicador de progresso de trabalho do Spark é fornecido com uma barra de progresso em tempo real que aparece para ajudá-lo a entender o status de execução do trabalho. O número de tarefas por cada trabalho ou estágio ajuda você 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 palco) específico selecionando o link no nome do trabalho (ou palco).

Você também pode encontrar o log em tempo real no nível da célula ao lado do indicador de progresso, e o Diagnóstico pode fornecer sugestões úteis para ajudar a refinar e depurar o código.

Em Mais ações, você pode navegar facilmente até a página de detalhes do aplicativo Spark e a página da interface do usuário da Web do Spark.

Redação de segredos

Para evitar que as credenciais sejam vazadas acidentalmente ao executar blocos de anotações, os blocos de anotações de malha oferecem suporte à redação secreta para substituir os valores secretos exibidos na saída da célula pelo [REDACTED]. A redação secreta é aplicável para Python, Scala e R.

Comandos mágicos num bloco de notas

Comandos mágicos integrados

Você pode usar comandos mágicos Ipython familiares em blocos de anotações Fabric. Analise a seguinte lista de comandos mágicos atualmente disponíveis.

Comandos mágicos de linha disponíveis: %lsmagic, %time, %timeit, %history, %run, %load, %alias, %alias_magic, %autoawait, %autocall, %automagic, %bookmark, %cd, %colors, %dhist, %dirs, %doctest_mode, %killbgscripts, %load_ext, %logoff, %logon, %logstart, %logstate, %logstop, %magic, %matplotlib, %page, %pastebin, %pdef, %pfile, %pinfo, %pinfo2, %popd, %pprint, %precision, %prun, %psearch, %psource, %pushd, %pwd, %pycat, %quickref, % rehashx, %reload_ext, %reset, %reset_selective, %sx, %system, %tb, %unalias, %unload_ext, %who, %who_ls, %who's, %xdel, %xmode.

O Fabric notebook também suporta os comandos aprimorados de gerenciamento de biblioteca %pip e %conda. Para obter mais informações sobre o uso, consulte Gerenciar bibliotecas do Apache Spark no Microsoft Fabric.

Comandos mágicos de célula disponíveis: %%time, %%timeit, %%capture, %%writefile, %%sql, %%pyspark, %%spark, %%csharp, %%configure, %%html, %%bash, %%markdown, %%perl, %%script, %%sh.

Comandos mágicos personalizados

Você também pode criar mais comandos mágicos personalizados para atender às suas necessidades específicas. Eis um exemplo:

1. Crie um bloco de anotações com o nome "MyLakehouseModule".

   

2. Em outro notebook, faça referência ao "MyLakehouseModule" e seus comandos mágicos. Este processo é como você pode organizar convenientemente seu projeto com blocos de anotações que usam diferentes idiomas.

   

IPython Widgets

IPython Widgets são objetos Python agitados que têm uma representação no navegador. Você pode usar IPython Widgets como controles low-code (por exemplo, controle deslizante ou caixa de texto) em seu bloco de anotações, assim como o bloco de anotações Jupyter. Atualmente ele só funciona em um contexto Python.

Para usar IPython Widgets

1. Importe o módulo ipywidgets primeiro para usar a estrutura Jupyter Widget.

   import ipywidgets as widgets
   

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

   slider = widgets.IntSlider()
   display(slider)
   

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

   slider = widgets.IntSlider()
   display(slider)
   

   

4. Use várias chamadas display() para renderizar a mesma instância de widget várias vezes. Eles permanecem em sincronia uns com os outros.

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

   

5. 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 widgets	Widgets
Widgets numéricos	IntSlider, FloatSlider, FloatLogSlider, IntRangeSlider, FloatRangeSlider, IntProgress, FloatProgress, BoundedIntText, BoundedFloatText, IntText, FloatText
Widgets booleanos	ToggleButton, Checkbox, Válido
Widgets de seleção	Lista suspensa, RadioButtons, Select, SelectionSlider, SelectionRangeSlider, ToggleButtons, SelectMultiple
Widgets de cadeia de caracteres	Texto, Área de texto, Caixa de combinação, Senha, Rótulo, HTML, HTML Matemática, Imagem, Botão
Reproduzir widgets (animação)	Seletor de data, Seletor de cores, Controlador
Widgets de contêiner ou layout	Caixa, HBox, VBox, GridBox, Acordeão, Separadores, Empilhado

Limitações conhecidas

• Os widgets a seguir ainda não são suportados. As seguintes soluções alternativas estão disponíveis:

  Funcionalidade	Solução
  Widget de saída	Você pode usar a função print() em vez disso para escrever texto no stdout.
  widgets.jslink()	Você pode usar a função widgets.link() para vincular dois widgets semelhantes.
  Widget FileUpload	Ainda não suportado.

• A função de exibição global do Fabric não suporta a exibição de vários widgets em uma chamada (por exemplo, display(a, b)). Esse comportamento é diferente da função de exibição IPython.

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

• A função interact (ipywidgets.interact) não é suportada.

Integrar um bloco de notas

Designar uma célula de parâmetros

Para parametrizar seu bloco de anotações, selecione as reticências (...) para acessar os comandos Mais 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.

A célula de parâmetro é útil para integrar um bloco de anotações em um pipeline. A atividade do pipeline procura a célula de parâmetros e trata essa célula como o padrão para os parâmetros passados no tempo de execução. O mecanismo de execução adiciona uma nova célula abaixo da célula de parâmetros 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 com a atividade do bloco de anotações de malha. 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 funções e variáveis.

Comando mágico de configuração da sessão Spark

Pode personalizar a sua sessão do Spark com o comando magic %%configure. O notebook de malha suporta vCores personalizados, memória do driver e do executor, propriedades do Apache Spark, pontos de montagem, pool e o lakehouse padrão da sessão do notebook. Eles podem ser usados em atividades de caderno interativo e de caderno de pipeline. Recomendamos que execute o comando %%configure no início do seu bloco de notas ou tem de reiniciar a sessão do Spark para que as definições entrem em vigor.

%%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 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",
        "spark.log.level": "ALL"
    },
    "defaultLakehouse": {  // This overwrites the default lakehouse for current session
        "name": "<lakehouse-name>",
        "id": "<(optional) lakehouse-id>",
        "workspaceId": "<(optional) workspace-id-that-contains-the-lakehouse>" // Add workspace ID if it's from another workspace
    },
    "mountPoints": [
        {
            "mountPoint": "/myMountPoint",
            "source": "abfs[s]://<file_system>@<account_name>.dfs.core.windows.net/<path>"
        },
        {
            "mountPoint": "/myMountPoint1",
            "source": "abfs[s]://<file_system>@<account_name>.dfs.core.windows.net/<path1>"
        },
    ],
    "environment": {
        "id": "<environment-id>",
        "name": "<environment-name>"
    },
    "sessionTimeoutInSeconds": 1200,
    "useStarterPool": false,  // Set to true to force using starter pool
    "useWorkspacePool": "<workspace-pool-name>"
}

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

A configuração de sessão parametrizada permite substituir o valor em %%configure magic pelos parâmetros de atividade do bloco de anotações de execução de pipeline. Ao preparar %%configure célula de código, você pode substituir valores padrão (também configuráveis, 4 e "2000" no exemplo abaixo) por um objeto como este:

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

%%configure  

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

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

Durante uma execução de pipeline, você pode definir as configurações de atividade do bloco de anotações de pipeline da seguinte maneira:

Se você quiser alterar a configuração da sessão, o nome dos parâmetros de atividade do bloco de anotações de pipeline deve ser o mesmo que parameterName no bloco de anotações. Neste exemplo de execução de um pipeline, driverCores em %%configure são substituídos por 8 e livy.rsc.sql.num-rows são substituídos por 4000.

Registro em Python em um bloco de anotações

Você pode encontrar logs Python e definir diferentes níveis de log e formato como o código de exemplo mostrado aqui:

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

Ver o histórico de comandos de entrada

O bloco de anotações de malha suporta o comando %history magic para imprimir o histórico de comandos de entrada executado na sessão atual, comparando com o comando padrão Jupyter Ipython que %history funciona para o contexto de vários idiomas no notebook.

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

Para opções:

• -n: Imprimir o número de execução.

Onde o intervalo pode ser:

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

Exemplo:

• Imprimir o histórico de entrada da 1ª à 2ª célula executada: %history -n 1-2

Teclas de atalho

Semelhante aos Jupyter Notebooks, os notebooks Fabric 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 de malha suportam os dois modos a seguir para uma determinada célula de código: modo de comando e modo de edição.

• Uma célula está no modo de comando quando não há nenhum cursor de texto 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 pressionando ESC ou usando o mouse para selecionar fora da área do editor de uma célula.

  

• O modo de edição pode ser indicado a partir de um cursor de texto que solicita que você digite na área do editor. Quando uma célula está no modo de edição, você pode digitar na célula. Entre no modo de edição pressionando Enter ou usando o mouse para selecionar a área do editor de uma célula.

  

Teclas de atalho no modo de comando

Ação	Atalhos do bloco de notas
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	Turno + D
Mudar para o modo de edição	Enter

Teclas de atalho no modo de edição

Usando os seguintes atalhos de pressionamento de teclas, você pode navegar e executar código facilmente em blocos de anotações de malha quando estiver no modo de edição.

Ação	Atalhos do bloco de notas
Mover o cursor para cima	Cima
Mover o cursor para baixo	Baixo
Anular	Ctrl + Z
Refazer	Ctrl + Y
Comentar ou Cancelar comentário	Ctrl + / Comentário: Ctrl + K + C Sem comentários: Ctrl + K + U
Excluir palavra antes	Ctrl + Backspace
Eliminar palavra após	Ctrl + Excluir
Ir para o início da célula	Ctrl + Início
Ir para o fim da célula	Ctrl + Fim
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

Para localizar todas as teclas de atalho, selecione Ver no friso do bloco de notas e, em seguida, selecione Ligações de teclas.

Conteúdos relacionados

• Visualização do bloco de notas
• Introdução do Fabric NotebookUtils