Sviluppare, eseguire e gestire notebook di Microsoft Fabric

Un notebook Microsoft Fabric è un elemento di codice primario per lo sviluppo di processi Apache Spark ed esperimenti di apprendimento automatico. È una superficie interattiva basata sul Web usata da scienziati dei dati e ingegneri dei dati per scrivere codice che sfrutta visualizzazioni avanzate e testo Markdown. Questo articolo illustra come sviluppare notebook con operazioni sulle celle di codice ed eseguirli.

Sviluppare i notebook

I notebook sono costituiti da celle, ovvero singoli blocchi di codice o testo che possono essere eseguiti in modo indipendente o come gruppo.

Sono disponibili operazioni avanzate per lo sviluppo di notebook:

• Aggiungere una cella
• Impostare il linguaggio primario
• Usare più linguaggi
• IntelliSense di tipo IDE
• Frammenti di codice
• Trascina la selezione per inserire frammenti
• Trascina la selezione per inserire immagini
• Formattare la cella di testo con i pulsanti della barra degli strumenti
• Annulla/Ripeti operazione della cella
• Spostare una cella
• Eliminare una cella
• Comprimere l'input di una cella
• Comprimere l'output di una cella
• Sicurezza dell'output delle celle
• Bloccare una cella
• Contenuto del notebook
• Riduzione del markdown
• Trova e sostituisci

Aggiungere una cella

Esistono diversi modi per aggiungere una nuova cella al notebook.

1. Passare con il mouse sullo spazio tra due celle e selezionare Codice o Markdown.

2. Usare la combinazione di tasti in modalità comando. Premere A per inserire una cella al di sopra della cella corrente. Premere B per inserire una cella sotto la cella corrente.

Impostare il linguaggio primario

I notebook Fabric attualmente supportano quattro linguaggi Apache Spark:

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

È possibile impostare il linguaggio primario per le nuove celle aggiunte dall'elenco a discesa nella barra dei comandi superiore.

Usare più linguaggi

È possibile usare più linguaggi in un notebook specificando il comando magic per il linguaggio all'inizio di una cella. È anche possibile cambiare la lingua della cella dalla selezione della lingua. Nella tabella seguente sono elencati i comandi magic per passare da una lingua all'altra nelle celle.

Comando magic	Lingua	Descrizione
%%pyspark	Python	Eseguire una query Python sul contesto Apache Spark.
%%spark	Scala	Eseguire una query Scala sul contesto Apache Spark.
%%sql	SparkSQL	Eseguire una query SparkSQL sul contesto Apache Spark.
%%html	Html	Eseguire una query HTML sul contesto Apache Spark.
%%sparkr	R	Eseguire una query R sul contesto Apache Spark.

IntelliSense di tipo IDE

I notebook Fabric sono integrati nell'editor Monaco e consentono di aggiungere la funzionalità IntelliSense di tipo IDE all'editor di celle. L'evidenziazione della sintassi, il generatore di errori e i completamenti automatici del codice consentono di scrivere codice e identificare i problemi rapidamente.

Le funzionalità di IntelliSense hanno livelli di maturità diversi per i diversi linguaggi. La tabella seguente mostra le funzionalità supportate da Fabric:

Lingue	Evidenziazione della sintassi	Generatore di errori di sintassi	Completamento del codice della sintassi	Completamento del codice della variabile	Completamento del codice della funzione di sistema	Completamento del codice della funzione utente	Rientro automatico	Riduzione del codice
PySpark (Python)	Sì	Sì	Sì	Sì	Sì	Sì	Sì	Sì
Spark (Scala)	Sì	Sì	Sì	Sì	Sì	Sì	Sì	Sì
SparkSQL	Sì	Sì	Sì	Sì	Sì	No	Sì	Sì
SparkR	Sì	Sì	Sì	Sì	Sì	Sì	Sì	Sì

Frammenti di codice

I notebook di Fabric forniscono frammenti di codice che consentono di scrivere facilmente modelli di codice usati comunemente, come:

• Leggere dati come un dataframe Apache Spark
• Disegno di grafici con Matplotlib

I frammenti di codice vengono visualizzati nei tasti di scelta rapida di IntelliSense di stile IDE in combinazione con altri suggerimenti. Il contenuto del frammento di codice è allineato alla lingua della cella del codice. È possibile visualizzare frammenti di codice disponibili digitando Snippet. È anche possibile digitare qualsiasi parola chiave per visualizzare un elenco di frammenti di codice pertinenti. Ad esempio, se si digita leggi si visualizza l'elenco dei frammenti di codice per leggere i dati da varie origini dati.

Trascina la selezione per inserire frammenti

Usare Trascina la selezione per leggere i dati da Lakehouse Explorer in modo pratico. Qui sono supportati più tipi di file; è possibile operare su file di testo, tabelle, immagini e così via. È possibile passare a una cella esistente o a una nuova cella. Il notebook genera il frammento di codice di conseguenza per visualizzare in anteprima i dati.

Trascina la selezione per inserire immagini

Usare la funzione Trascina la selezione per inserire facilmente immagini in una cella markdown o in un computer locale.

Formattare la cella di testo con i pulsanti della barra degli strumenti

Per completare le azioni di markdown comuni, è possibile usare i pulsanti di formato nella barra degli strumenti delle celle di testo.

Annullare o ripetere le operazioni delle celle

Selezionare Annulla o Ripeti, oppure premere Z o Maiusc+Z per revocare l'operazione più recente sulle celle. È possibile annullare o ripetere le ultime 10 operazioni cronologiche sulle celle.

Annullamenti delle operazioni sulle celle supportati:

• Inserire o eliminare una cella. È possibile revocare le operazioni di eliminazione selezionando Annulla (il contenuto di testo viene mantenuto insieme alla cella).
• Riordina cella.
• Attiva/Disattiva parametro.
• Converti tra cella Codice e cella Markdown.

Spostare una cella

È possibile trascinarle dalla parte vuota di una cella e rilasciarle nella posizione desiderata.

È anche possibile spostare la cella selezionata usando Sposta su e Sposta giù sulla barra multifunzione.

Eliminare una cella

Per eliminare una cella, selezionare il pulsante Elimina a destra della cella.

È anche possibile usare la combinazione di tasti in modalità comando. Premere Maiusc+D per eliminare la cella corrente.

Comprimere l'input di una cella

Selezionare i puntini di sospensione Altri comandi (...) nella barra degli strumenti della cella e Nascondi input per comprimere l'input della cella corrente. Per espanderlo di nuovo, selezionare l'opzione Mostra input quando la cella è compressa.

Comprimere l'output di una cella

Selezionare i puntini di sospensione Altri comandi (...) nella barra degli strumenti della cella e Nascondi output per comprimere l'output della cella corrente. Per espanderlo di nuovo, selezionare l'opzione Mostra output quando l'output della cella è compresso.

Sicurezza dell'output delle celle

Usando i ruoli di accesso ai dati di OneLake (anteprima) gli utenti possono configurare l'accesso solo a cartelle specifiche in un lakehouse durante le query dei notebook. Gli utenti senza accesso a una cartella o a una tabella visualizzeranno un errore non autorizzato durante l'esecuzione della query.

Bloccare una cella

Le operazioni di blocco delle celle consentono di rendere le celle di sola lettura o arrestare l'esecuzione delle celle di codice su base individuale.

Unire e dividere le celle

È possibile usare Unisci con la cella precedente o Unisci con la cella successiva per unire le celle correlate in modo pratico.

La selezione di Dividi cella consente di dividere le istruzioni irrilevanti in più celle. L'operazione divide il codice in base alla posizione della riga del cursore.

Contenuto del notebook

La selezione di Strutture o Sommario presenta la prima intestazione markdown di qualsiasi cella markdown in una finestra della barra laterale, ai fini della navigazione rapida. La barra laterale Strutture è ridimensionabile e comprimibile, per adattarsi allo schermo nel miglior modo possibile. Selezionare il pulsante Sommario nella barra dei comandi del notebook per aprire o nascondere la barra laterale.

Riduzione del markdown

L'opzione di riduzione markdown consente di nascondere le celle in una cella markdown che contiene un'intestazione. La cella markdown e le relative celle nascoste vengono considerate uguali a un insieme di celle multi-selezionate contigue durante l'esecuzione di operazioni di cella.

Trova e sostituisci

L'opzione trova e sostituisci aiuta a individuare le parole chiave o l'espressione all'interno del contenuto del notebook. È anche possibile sostituire facilmente la stringa di destinazione con una nuova stringa.

Eseguire notebook

È possibile eseguire le celle di codice nel notebook singolarmente o tutte insieme. Lo stato e l'avanzamento di ogni cella sono visualizzati nel notebook.

Eseguire una cella

Esistono diversi modi per eseguire il codice in una cella.

• Passare con il puntatore del mouse sulla cella che si desidera eseguire e selezionare il pulsante Esegui cella oppure premere CTRL + INVIO.

• Usare la combinazione di tasti in modalità comando. Premere Maiusc+Invio per eseguire la cella attiva e selezionare la cella successiva. Premere Alt+Invio per eseguire la cella attiva e inserire una nuova cella.

Eseguire tutte le celle

Selezionare il pulsante Esegui tutte per eseguire tutte le celle del notebook corrente in sequenza.

Eseguire tutte le celle al di sopra o al di sotto

Espandere l'elenco a discesa dal pulsante Esegui tutto, quindi selezionare Esegui celle sopra per eseguire tutte le celle sopra la sequenza corrente. Selezionare Esegui celle sotto per eseguire la cella attiva e tutte le celle sotto quella attiva in sequenza.

Annulla tutte le celle in esecuzione

Selezionare Annulla tutto per annullare le celle in esecuzione o le celle in attesa nella coda.

Arresta sessione

Arresta sessione annulla le celle in esecuzione e in attesa e arresta la sessione corrente. È possibile riavviare una nuova sessione selezionando nuovamente l'opzione Esegui.

Esecuzione di riferimento

Esecuzione di riferimento di un Notebook

Oltre all'API di esecuzione notebookutils, è anche possibile usare il %run <notebook name> comando magic per fare riferimento a un altro notebook all'interno del contesto del notebook corrente. Tutte le variabili definite nel notebook di riferimento sono disponibili nel notebook corrente. Il comando magic %run supporta le chiamate annidate, ma non quelle ricorsive. Si riceve un'eccezione se la profondità dell'istruzione è maggiore di cinque.

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

Le informazioni di riferimento sui notebook funzionano sia in modalità interattiva che nella pipeline.

Esecuzione di riferimento di uno script

Il comando %run consente anche di eseguire file Python o SQL archiviati nelle risorse predefinite del notebook, in modo da eseguire facilmente i file di codice sorgente nel notebook.

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

Per le opzioni:

• -b/--builtin: questa opzione indica che il comando troverà ed eseguirà il file di script specificato dalle risorse predefinite del notebook.
• -c/--current: questa opzione garantisce che il comando usi sempre le risorse predefinite del notebook corrente, anche se il notebook corrente fa riferimento ad altri notebook.

Esempi:

• Per eseguire script_file.py dalle risorse predefinite: %run -b script_file.py

• Per eseguire script_file.sql dalle risorse predefinite: %run -b script_file.sql

• Per eseguire script_file.py dalle risorse predefinite con variabili specifiche: %run -b script_file.py { "parameterInt": 1, "parameterFloat": 2.5, "parameterBool": true, "parameterString": "abc" }

Esempio di utilizzo per il caso di esecuzione annidata:

• Si supponga di avere due notebook.
  • Notebook1: contiene script_file1.py nelle risorse predefinite
  • Notebook2: contiene script_file2.py nelle risorse predefinite
• Usiamo Notebook1 come notebook radice con il contenuto: %run Notebook2.
• Poi, in Notebook2 l'istruzione di utilizzo sono:
  • Per eseguire script_file1.py in Notebook1 (notebook radice) il codice sarà: %run -b script_file1.py
  • Per eseguire script_file2.py in Notebook2 (notebook corrente), il codice sarà: %run -b -c script_file2.py

Esplora variabili

I notebook di Fabric comprendono un'opzione predefinita Esplora variabili che consente di visualizzare l'elenco con il nome, il tipo, la lunghezza e il valore delle variabili nella sessione corrente di Spark per le celle PySpark (Python). Altre variabili vengono visualizzate automaticamente man mano che vengono definite nelle celle di codice. Facendo clic su ogni intestazione di colonna si ordinano le variabili contenute nella tabella.

Per aprire o nascondere Esplora variabili, selezionare Variabili nella visualizzazione della barra multifunzione del notebook.

Indicatore di stato delle celle

Sotto la cella viene visualizzato il relativo stato di esecuzione dettagliato, che indica lo stato di avanzamento corrente. Al termine dell'esecuzione della cella, appare un riepilogo dell'esecuzione con la durata totale e l'ora di fine, informazioni che verranno conservate per riferimento futuro.

Indicatore del processo Apache Spark inline

Il notebook di Fabric è basato su Apache Spark. Le celle di codice vengono eseguite nel pool di Apache Spark in modalità cluster. Viene fornito un indicatore di stato del processo Spark con una barra di avanzamento in tempo reale che consente di comprendere lo stato di esecuzione del processo. Il numero di attività per ogni processo o fase consente di identificare il livello parallelo del processo Spark. È anche possibile eseguire un'analisi più approfondita dell'interfaccia utente Spark di uno specifico processo (o fase) selezionando il collegamento al nome del processo (o della fase).

È anche possibile trovare il log in tempo reale a livello di cella accanto all'indicatore di stato e la Diagnostica può fornire suggerimenti utili per perfezionare ed eseguire il debug del codice.

In Altre azioni, è possibile passare facilmente alla pagina dei dettagli dell'applicazione Spark e alla pagina dell'interfaccia utente Web Spark.

Offuscamento di segreti

Per evitare che le credenziali vengano accidentalmente perse durante l'esecuzione dei notebook, i notebook di Fabric supportano l'offuscamento di segreti per sostituire i valori dei segreti visualizzati nell'output della cella con [REDACTED]. L'offuscamento dei segreti è applicabile per Python, Scala e R.

Comandi magic in un notebook

Comandi magic predefiniti

È possibile usare i comandi magic noti di Ipython nei notebook di Fabric. Esaminare l'elenco seguente di comandi magic attualmente disponibili.

Comandi magic della riga disponibili: %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.

Il notebook di Fabric supporta anche i comandi di gestione delle librerie migliorati %pip e %conda. Per altre informazioni sull'utilizzo, vedere Gestire le librerie Apache Spark in Microsoft Fabric.

Comandi magic delle celle disponibili: %%time, %%timeit, %%capture, %%writefile, %%sql, %%pyspark, %%spark, %%csharp, %%configure, %%html, %%bash, %%markdown, %%perl, %%script, %%sh.

Comandi magic personalizzati

È anche possibile creare comandi magic più personalizzati per soddisfare esigenze specifiche. Ecco un esempio:

1. Creare un notebook con il nome "MyLakehouseModule".

   

2. In un altro notebook, fare riferimento a "MyLakehouseModule" e ai relativi comandi magic. Questo processo consente di organizzare facilmente il progetto con notebook che usano linguaggi diversi.

   

Widget IPython

IPython Widgets sono oggetti Python con evento che hanno una rappresentazione nel browser. È possibile usare i widget IPython come controlli a basso codice (ad esempio, dispositivo di scorrimento o casella di testo) nel notebook, proprio come il Jupyter Notebook. Attualmente funziona solo in un contesto Python.

Per usare i widget IPython

1. Prima di usare il framework Widget Jupyter, importare il modulo ipywidgets.

   import ipywidgets as widgets
   

2. Usare la funzione visualizza di primo livello per eseguire il rendering di un widget o lasciare un'espressione di tipo widget nell'ultima cella della riga di codice.

   slider = widgets.IntSlider()
   display(slider)
   

3. Eseguire la cella. Il widget viene visualizzato nell'area di output.

   slider = widgets.IntSlider()
   display(slider)
   

   

4. Usare più chiamate display() per eseguire più volte il rendering della stessa istanza del widget. Rimangono sincronizzati tra loro.

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

   

5. Per eseguire il rendering di due widget indipendenti l'uno dall'altro, creare due istanze del widget:

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

   

Widget supportati

Tipo di widget	Widget
Widget numerici	IntSlider, FloatSlider, FloatLogSlider, IntRangeSlider, FloatRangeSlider, IntProgress, FloatProgress, BoundedIntText, BoundedFloatText, IntText, FloatText
Widget booleani	ToggleButton, Checkbox, Valid
Widget di selezione	Dropdown, RadioButtons, Select, SelectionSlider, SelectionRangeSlider, ToggleButtons, SelectMultiple
Widget stringa	Testo, Area di testo, Combobox, Password, Etichetta, HTML, Matematica HTML, Immagine, Pulsante
Widget di riproduzione (animazione)	Selezione data, Selezione colori, Controller
Widget contenitore o layout	Box, HBox, VBox, GridBox, Accordion, Schede, Impilato

Limitazioni note

• I widget seguenti non sono ancora supportati. Sono disponibili le seguenti soluzioni alternative:

  Funzionalità	Soluzione alternativa
  Widget di output	È invece possibile usare la funzione print() per scrivere testo in stdout.
  widgets.jslink()	È possibile usare la funzione widgets.link() per collegare due widget simili.
  Widget FileUpload	Non ancora supportato.

• La funzione display globale di Fabric non supporta la visualizzazione di più widget in una chiamata ( ad esempio, display(a, b)). Questo comportamento è diverso dalla funzione display di IPython.

• Se si chiude un notebook che contiene un widget IPython, non sarà possibile vedere o interagire con esso fino a quando non si esegue di nuovo la cella corrispondente.

• La funzione interact (ipywidgets.interact) non è supportata.

Integrare un notebook

Designare una cella di parametri

Per parametrizzare il notebook, selezionare i puntini di sospensione (...) per accedere ai comandi Altro nella barra degli strumenti della cella. Selezionare quindi Attiva/Disattiva la cella di parametri per designare la cella come cella di parametri.

La cella del parametro è utile per l'integrazione di un notebook in una pipeline. L'attività della pipeline cerca la cella di parametri e tratta questa cella come valore predefinito per i parametri passati in fase di esecuzione. Il motore di esecuzione aggiunge una nuova cella sotto la cella dei parametri con parametri di input per sovrascrivere i valori predefiniti.

Assegnare i valori dei parametri da una pipeline

Dopo aver creato un notebook con parametri, è possibile eseguirlo da una pipeline con l'attività del notebook di Fabric. Dopo aver aggiunto l'attività all'area di lavoro della pipeline, è possibile impostare i valori dei parametri nella sezione Parametri di base della scheda Impostazioni.

Quando si assegnano i valori dei parametri, è possibile usare il linguaggio delle espressioni della pipeline o le funzioni e variabili.

Comando magic di configurazione della sessione Spark

È possibile personalizzare la sessione di Spark con il comando magic %%configure. Il notebook di Fabric supporta vCore personalizzati, memoria del driver ed executor, proprietà di Apache Spark, punti di montaggio, pool e il lakehouse predefinito della sessione del notebook. Possono essere usati nelle attività del notebook interattive e della pipeline. È consigliabile eseguire il comando %%configure all'inizio del notebook, oppure riavviare la sessione Spark per rendere effettive le impostazioni.

%%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>"
}

Configurazione della sessione con parametri da una pipeline

La configurazione della sessione con parametri consente di sostituire il valore in %%configure magic con parametri di esecuzione dell'attività del notebook della pipeline. Quando si prepara la cella di codice %%configure, è possibile eseguire l'override dei valori predefiniti (configurabili anche, 4 e "2000" nell'esempio seguente) con un oggetto simile al seguente:

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

%%configure  

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

Un notebook usa il valore predefinito se si esegue un notebook in modalità interattiva direttamente o se l'attività del notebook della pipeline non dà alcun parametro corrispondente a "activityParameterName".

Durante un'esecuzione della pipeline, è possibile configurare le impostazioni dell'attività del notebook della pipeline come indicato di seguito:

Se si desidera modificare la configurazione della sessione, il nome dei parametri dell'attività del notebook della pipeline deve essere uguale a parameterName nel notebook. In questo esempio di esecuzione di una pipeline, driverCores in %%configure vengono sostituiti da 8 e livy.rsc.sql.num-rows vengono sostituiti da 4000.

Registrazione di Python in un notebook

È possibile trovare i log Python e impostare livelli di log e formato differenti seguendo il codice di esempio qui di seguito:

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

Visualizzare la cronologia dei comandi di input

Il notebook di Fabric supporta il comando magic %history per stampare la cronologia dei comandi di input eseguita nella sessione corrente. Rispetto al comando Jupyter Ipython standard, %history è compatibile con più contesti di lingua nel notebook.

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

Per le opzioni:

• -n: numero di esecuzione di stampa.

Dove l'intervallo può essere:

• N: codice di stampa della Nth cella eseguita.
• M-N: codice di stampa dalla Mth alla Nth cella eseguita.

Esempio:

• Cronologia degli input di stampa dalla prima alla seconda cella eseguita: %history -n 1-2

Combinazioni di tasti

Analogamente a Jupyter Notebook, i notebook di Fabric hanno un'interfaccia utente modale. La tastiera esegue diverse operazioni a seconda della modalità in cui si trova la cella del notebook. I notebook di Fabric supportano le due modalità seguenti per una cella di codice specificata, ovvero la modalità di comando e la modalità di modifica.

• Una cella è in modalità di comando quando non è presente un cursore di testo che richiede di digitare. Quando una cella è in modalità di comando, è possibile modificare il notebook nel suo complesso, ma non digitare in singole celle. Immettere la modalità comando premendo ESC o usando il mouse per selezionare un punto all'esterno dell'area dell'editor di una cella.

  

• La modalità di modifica può essere indicata da un cursore di testo che richiede di digitare nell'area dell'editor. Quando una cella si trova in modalità di modifica, è possibile digitare nella cella. Per passare alla modalità di modifica, premere Invio o usare il mouse per selezionare l'area dell'editor di una cella.

  

Combinazione di tasti in modalità di comando

Azione	Tasti di scelta rapida del notebook
Eseguire la cella corrente e selezionare in basso	MAIUSC + Invio
Eseguire la cella corrente e inserire in basso	ALT + INVIO
Esegui cella corrente	Ctrl + INVIO
Selezionare la cella in alto	Freccia SU
Selezionare la cella in basso	Giù
Seleziona la cella precedente	K
Seleziona la cella successiva	J
Inserire la cella in alto	Un
Inserire la cella in basso	G
Eliminare le celle selezionate	Maiusc+D
Passare alla modalità di modifica	INVIO

Combinazione di tasti in modalità di modifica

Usando i tasti di scelta rapida seguenti, è possibile esplorare ed eseguire facilmente il codice nei notebook di Fabric in modalità di modifica.

Azione	Tasti di scelta rapida del notebook
Spostare il cursore in alto	Freccia SU
Spostare in cursore in basso	Giù
Annulla	CTRL + Z
Ripeti	CTRL + Y
Inserimento o rimozione di commenti	Ctrl + / Commentare: CTRL + K + C Rimuovere il commento: CTRL + K + U
Eliminare la parola prima	CTRL + BACKSPACE
Eliminare la parola dopo	CTRL + CANC
Andare all'inizio della cella	CTRL + Home
Andare alla fine della cella	CTRL + Fine
Andare a sinistra di una parola	CTRL + freccia sinistra
Andare a destra di una parola	CTRL + freccia destra
Seleziona tutto	CTRL + A
Impostare un rientro	Ctrl +]
Annullare l'impostazione di un rientro	CTRL + [
Passare alla modalità comandi	ESC

Per trovare tutte le combinazioni di tasti, selezionare Visualizza sulla barra multifunzione del notebook e quindi selezionare Tasti di scelta rapida.

Contenuto correlato

• Visualizzazione dei notebook
• Introduzione a Fabric NotebookUtils