Desenvolver, executar e gerenciar notebooks do Microsoft Fabric

Um notebook do Microsoft Fabric é um item de código principal para o desenvolvimento de trabalhos do Apache Spark e experimentos de aprendizado de máquina. É uma superfície interativa baseada na Web utilizada por cientistas de dados e engenheiros de dados para escrever códigos que se beneficiam de visualizações avançadas e texto Markdown. Este artigo explica como desenvolver notebooks com operações de célula de código e executá-los.

Desenvolver notebooks

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

Fornecemos operações avançadas para desenvolver notebooks:

• Adicionar uma célula
• Definir uma linguagem principal
• Usar vários idiomas
• IntelliSense de estilo IDE
• Snippets de código
• Arrastar e soltar para inserir snippets
• 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 da saída da célula
• Bloquear ou congelar uma célula
• Conteúdos do Notebook
• Dobramento de Markdown
• Encontrar e substituir

Adicionar uma célula

Há várias maneiras de adicionar uma nova célula ao notebook.

1. Passe o mouse 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 uma linguagem principal

Os notebooks do Fabric suportam atualmente quatro linguagens do Apache Spark:

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

Defina a linguagem principal para novas células adicionadas na lista suspensa na barra de comandos superior.

Usar vários idiomas

Use várias linguagens em um notebook especificando o comando magic da linguagem no início de uma célula. Também poderá alternar o idioma da célula do seletor de idioma. A tabela a seguir lista os comandos magic para alternar as linguagens de célula.

Comando magic	Idioma	Descrição
%%pyspark	Python	Execute uma consulta Python no contexto do Apache Spark.
%%spark	Scala	Execute uma consulta Scala no contexto do Apache Spark.
%%sql	SparkSQL	Execute uma consulta SparkSQL no contexto do Apache Spark.
%%html	Html	Execute uma consulta HTML no contexto do Apache Spark.
%%sparkr	R	Execute uma consulta R no contexto do Apache Spark.

IntelliSense de estilo IDE

Os notebooks do Fabric são integrados ao editor Monaco para colocar o IntelliSense de estilo IDE ao editor de célula. O realce de sintaxe, o marcador de erros e os preenchimentos de código automáticos ajudam você a codificar rapidamente e identificar problemas.

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

Languages	Realce da sintaxe	Marcador de erro de sintaxe	Conclusão de código de sintaxe	Conclusão de código de variável	Conclusão de código de função do sistema	Conclusão do código de função do usuário	Recuo Inteligente	Dobramento de código
PySpark (Python)	Sim	Sim	Sim	Sim	Sim	Sim	Sim	Sim
Spark (Scala)	Sim	Sim	Sim	Sim	Sim	Sim	Sim	Sim
SparkSQL	Sim	Sim	Sim	Sim	Sim	Não	Sim	Yes
SparkR	Sim	Sim	Sim	Sim	Sim	Sim	Sim	Sim

Snippets de código

Os notebooks do Fabric fornecem trechos de código que ajudam você a gravar facilmente os padrões de código utilizados com frequência, como:

• Fazer a leitura de dados como um DataFrame do Apache Spark
• Desenhar gráficos com o Matplotlib

Os trechos aparecem em Teclas de atalho do IntelliSense de estilo IDE misturados com outras sugestões. O conteúdo do snippet de código é alinhado com a linguagem de célula de código. Visualize os snippets disponíveis digitando Snippet. Também poderá digitar qualquer palavra-chave para visualizar uma lista de snippets relevantes. Por exemplo, se você digitar leitura, verá a lista de snippets para fazer a leitura dos dados de várias fontes de dados.

Arrastar e soltar para inserir snippets

Use o recurso de arrastar e soltar para fazer a leitura de dados do Lakehouse Explorer de forma conveniente. Vários tipos de arquivos são suportados aqui, podendo operar em arquivos de texto, tabelas, imagens, etc. É possível soltar em uma célula existente ou em uma nova célula. O notebook gera o snippet de código de acordo com a prévia dos dados.

Arrastar e soltar para inserir imagens

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

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

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

Desfazer ou refazer as operações das células

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

Operações de desfazer célula com suporte:

• Inserir ou excluir célula. É possível revogar as operações de exclusão selecionando Desfazer (o conteúdo do texto será mantido junto com a célula).
• Reordene a célula.
• Alternar parâmetro.
• Converter entre célula de código e de Markdown.

Mover uma célula

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

Também é possível utilizar Mover para cima e Mover para baixo na faixa de opções para mover a célula selecionada.

Excluir uma célula

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

Também poderá 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 elipses Mais comandos (...) na barra de ferramentas da célula e Ocultar entrada para recolher a entrada da célula atual. Para expandi-la novamente, selecione Mostrar entrada enquanto a célula estiver recolhida.

Recolher uma saída de célula

Selecione as elipses Mais comandos (...) na barra de ferramentas da célula e Ocultar entrada para recolher a saída da célula atual. Para expandi-la novamente, selecione Mostrar saída enquanto a saída da célula estiver recolhida.

Segurança da saída da célula

Usando as funções de acesso a dados OneLake (Preview), os usuários podem configurar o acesso a apenas pastas específicas em um lakehouse durante consultas de notebook. Os usuários sem acesso a uma pasta ou tabela verão um erro de autorização negada durante a execução da consulta.

Bloquear ou congelar uma célula

As operações de bloqueio e congelamento de células permitem fazer com que as células sejam somente leitura ou impedir que as células de código sejam executadas em uma pessoa.

Mesclar e dividir células

Use a Mesclagem com células anteriores ou Mesclagem com a próxima célula para mesclar células relacionadas convenientemente.

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

Conteúdos do Notebook

Selecionar Estruturas do Código ou Sumário apresenta o primeiro cabeçalho de markdown de qualquer célula de markdown em uma janela de barra lateral para navegação rápida. A barra lateral de Estruturas do Códigos é redimensionável e recolhível para se ajustar à tela da melhor maneira possível. Selecione o botão Conteúdos na barra de comandos do notebook para abrir ou ocultar a barra lateral.

Dobramento de markdown

A opção de dobramento do markdown permite ocultar células sob uma célula de markdown que contenha um título. A célula de markdown e suas células ocultas são tratadas da mesma forma que um conjunto de células contíguas multisselecionadas ao realizar operações de célula.

Localizar e substituir

A opção localizar e substituir pode ajudá-lo a corresponder e localizar as palavras-chave ou expressão no conteúdo do notebook. Também poderá substituir facilmente a cadeia de caracteres de destino por uma nova cadeia de caracteres.

Executar notebooks

Você pode executar as células de código em seu notebook individualmente ou todas de uma vez. O status e o progresso de cada célula são exibidos no notebook.

Executar uma célula

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

• Passe o mouse sobre a célula a ser executada 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 notebook atual em sequência.

Executar todas as células acima ou abaixo

Expanda a lista suspensa do Executar tudo e selecione Executar células acima para executar todas as células acima da atual em sequência. Selecione Executar células abaixo para executar a célula atual e todas as células abaixo da atual 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 aguardando na fila.

Interromper a sessão

Interromper sessão cancela as células em execução e em espera e interrompe a sessão atual. É possível reiniciar uma nova sessão selecionando a opção de Executar novamente.

Execução de referência

Execução de referência de um notebook

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 notebook no contexto do notebook atual. Todas as variáveis definidas no bloco de anotações de referência estão disponíveis no notebook atual. O comando magic %run dá suporte a chamadas aninhadas, mas não dá suporte a chamadas recursivas. Você receberá uma exceção se a profundidade da declaração for maior que cinco.

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

A referência do Notebook funciona tanto no modo interativo quanto no pipeline.

Execução de referência de um script

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

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

Para opções:

• -b/--builtin: essa 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: Essa opção garante que o comando sempre use os recursos internos do notebook atual, mesmo que este seja referenciado por outros notebooks.

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 caso de execução aninhado:

• Vamos supor que existam dois notebooks.
  • Notebook1: contém script_file1.py em seus recursos internos
  • Notebook2: contém script_file2.py em seus recursos internos
• Vamos usar o trabalho em Notebook1 como um notebook raiz com o conteúdo: %run Notebook2.
• Em Notebook2, a instrução de uso é:
  • Para executar script_file1.py em Notebook1 (o notebook raiz), o código seria: %run -b script_file1.py
  • Para executar script_file2.py em Notebook2 (o notebook atual), o código seria: %run -b -c script_file2.py

Gerenciador de variáveis

Os notebooks do Fabric fornecem um gerenciador de variáveis incorporado que exibe a lista de nomes de variáveis, tipo, comprimento e valor na atual sessão Spark para células (Python) PySpark. Mais variáveis são mostradas 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 gerenciador de variáveis, selecione Variáveis na faixa de opções do notebook Exibir.

Indicador de status de 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. Após a conclusão da execução da célula, um resumo da execução com a duração total e a hora de término é exibido e armazenado para referência futura.

Indicador de trabalho embutido do Apache Spark

O Notebook do Fabric é baseado no Apache Spark. As células do código são executadas remotamente no cluster do Apache Spark. Um indicador de progresso do 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 a identificar o nível paralelo do seu trabalho do Spark. Você também pode analisar mais detalhadamente a interface do usuário do Spark de um trabalho (ou estágio) específico por meio da seleção do link no nome do trabalho (ou estágio).

Também é possível encontrar o Registo em tempo real do nível da célula junto ao 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 para a página Detalhes do aplicativo do Spark e para a página Interface do usuário do Spark na Web.

Redação de segredo

Para evitar que as credenciais vazem acidentalmente durante a execução de notebooks, os notebooks do Fabric dão suporte à Redação secreta para substituir os valores secretos exibidos na saída da célula por [REDACTED]. A redação secreta é aplicável para Python, Scala, e R.

Comandos magic em um notebook

Comandos magic internos

É possível utilizar os comandos magic conhecidos do Ipython nos notebooks do Fabric. Confira a lista a seguir de comandos magic disponíveis no momento.

Comandos magics 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, %whos, %xdel, %xmode.

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

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

Comandos magic personalizados

Também é possível criar mais comandos magic personalizados para atender às suas necessidades específicas. Veja um exemplo:

1. Criar um notebook com o nome "MyLakehouseModule".

   

2. Em outro notebook, faça referência à “MyLakehouseModule” e seus comandos magic. Esse processo é como você poderá organizar convenientemente seu projeto com notebooks que usam idiomas diferentes.

   

Widgets de IPython

Os widgets do IPython são objetos do Python com eventos que têm uma representação no navegador. É possível utilizar os Widgets IPython como controles de baixo código (por exemplo, controle deslizante ou caixa de texto) no seu notebook tal como o notebook Jupyter. Atualmente, ele só funciona em um contexto do Python.

Para usar o Widgets de IPython

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

   import ipywidgets as widgets
   

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

   slider = widgets.IntSlider()
   display(slider)
   

3. Execute a célula. O widget será 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, crie duas instâncias de widget:

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

   

Widgets com suporte

Tipo de widgets	Widgets
Widgets numéricos	IntSlider, FloatSlider, FloatLogSlider, IntRangeSlider, FloatRangeSlider, IntProgress, FloatProgress, BoundedIntText, BoundedFloatText, IntText, FloatText
Widgets boolianas	ToggleButton, Checkbox, Valid
Widgets de seleção	Dropdown, RadioButtons, Select, SelectionSlider, SelectionRangeSlider, ToggleButtons, SelectMultiple
Widgets de cadeia de caracteres	Texto, Área de texto, Combobox, Senha, Rótulo, HTML, HTML Math, Imagem, Botão
Widgets de reprodução (animação)	Seletor de data, Seletor de cor, Controlador
Widgets de contêiner ou de layout	Box, HBox, VBox, GridBox, Accordion, Tabs, Stacked

Limitações conhecidas

• Ainda não há suporte para as seguintes ofertas. As seguintes soluções alternativas estão disponíveis:

  Funcionalidade	Solução alternativa
  Widget Saída	Em vez disso, é possível utilizar a função print() para escrever texto no stdout.
  widgets.jslink()	É possível utilizar a função widgets.link() para vincular dois widgets semelhantes.
  Widget FileUpload	Ainda não há suporte.

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

• Caso feche um notebook que contenha um widget IPython, não poderá conferir ou interagir com ele até executar a célula correspondente novamente.

• Não há suporte para a função de interação (ipywidgets.interact).

Integrar um notebook

Designar uma célula de parâmetros

Para parametrizar o notebook, selecione as elipses (...) 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âmetros é utilizada para integrar um notebook em um pipeline. A atividade do pipeline procura a célula de parâmetros e trata essa célula como 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

Após criar um notebook com parâmetros, você poderá executá-lo a partir de um pipeline com a atividade do notebook do Fabric. Após adicionar a atividade à tela do pipeline, você poderá definir os valores dos parâmetros na seção Parâmetros de base da guia Configurações.

Ao atribuir valores de parâmetro, use a linguagem de expressão de pipeline ou funções e variáveis.

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

Personalize sua sessão do Spark com o comando magic %%configure. O Notebook do Fabric oferece suporte a vCores personalizados, Memória do Driver e Executor, propriedades do Apache Spark, pontos de montagem, pool e ao lakehouse padrão da sessão de Notebook. Eles podem ser usados em atividades interativas de notebook e notebook de pipeline. É recomendável que você execute o comando %%configure no início do notebook ou reinicie a sessão do Spark para que as configuraçõ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 de um pipeline

A configuração de sessão parametrizada permite substituir o valor do magic %%configure pelos parâmetros de atividade de notebook de execução de pipeline Ao preparar a célula de código %%configure, você pode substituir os 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 notebook usa o valor padrão se você executar um notebook diretamente no modo interativo ou se a atividade do notebook do pipeline não fornecer nenhum parâmetro que corresponder a “activityParameterName”.

Durante uma execução de pipeline, defina as configurações de atividade do notebook de pipeline da seguinte maneira:

Caso deseje alterar a configuração da sessão, o nome dos parâmetros da atividade de notebook do pipeline deve ser o mesmo que parameterName no notebook. 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 log do Python em um notebook

É possível encontrar os logs do Python e definir diferentes níveis e formatos de log, 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")

Exibir o histórico de comandos de entrada

O notebook do Fabric é compatível com o comando magic %history para imprimir o histórico de comandos de entrada executado na sessão atual. Comparando com o comando padrão do Jupyter Ipython, %history funciona em contexto de várias linguagens no notebook.

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

Para opções:

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

No qual o intervalo pode ser:

• N: imprime o código da N-ésima célula executada.
• M-N: imprime o código da M-ésima à N-ésima célula executada.

Exemplo:

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

Teclas de atalho

Semelhante aos notebooks Jupyter, os notebooks Fabric têm uma interface de usuário modal. O teclado faz coisas diferentes, dependendo de em qual modo a célula do notebook está. Os notebooks do Fabric 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 Comando quando não existe um cursor de texto solicitando que você digite. Quando uma célula está no modo de comando, você pode editar o notebook como um todo, mas não pode digitar em células individuais. Insira o modo Comando pressionando ESC ou utilizando o mouse para selecionar fora da área do editor de uma célula.

  

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

  

Teclas de atalho no modo de comando

Ação	Atalhos do Notebook
Executar a célula atual e selecionar abaixo	Shift+Enter
Executar a célula atual e inserir abaixo	Alt+Enter
Executar a célula atual	Ctrl+Enter
Selecionar célula acima	Para cima
Selecionar célula abaixo	Para baixo
Selecionar célula anterior	K
Selecionar próxima célula	J
Inserir célula acima	Um
Inserir célula abaixo	B
Excluir células selecionadas	Shift + D
Mudar para o modo de edição	Enter

Teclas de atalho no modo de edição

Utilizando os seguintes atalhos de teclas, é possível navegar e executar facilmente o código nos notebooks do Fabric quando estiver no modo de edição.

Ação	Atalhos do Notebook
Mover cursor para cima	Para cima
Mover cursor para baixo	Para baixo
Desfazer	CTRL+Z
Refaz	Ctrl+Y
Comentar ou Remover marca de comentário	Ctrl+/ Comentar: Ctrl + K + C Remover marca de comentário: Ctrl + K + U
Excluir palavra anterior	Ctrl+Backspace
Excluir palavra seguinte	Ctrl+Delete
Ir para o início da célula	Ctrl+Home
Ir para o final da célula	Ctrl+End
Ir uma palavra para a esquerda	CTRL+Seta para a esquerda
Ir uma palavra para a direita	CTRL+Seta para a direita
Selecionar tudo	CTRL+A
Recuar	Ctrl +]
Desfazer recuo	Ctrl+[
Alternar para o modo de comando	Esc

Para localizar todas as teclas de atalho, selecione Exibir na faixa de opções do notebook e selecione Associação de teclas.

Conteúdo relacionado

• Visualização do Notebook
• Introdução do Fabric NotebookUtils