Utveckla, köra och hantera Microsoft Fabric-notebook-filer

En Microsoft Fabric-notebook-fil är ett primärt kodobjekt för att utveckla Apache Spark-jobb och maskininlärningsexperiment. Det är en webbaserad interaktiv yta som används av dataforskare och datatekniker för att skriva kod som drar nytta av omfattande visualiseringar och Markdown-text. Den här artikeln beskriver hur du skapar anteckningsblock med kodcellsåtgärder och kör dem.

Utveckla anteckningsböcker

Notebook-filer består av celler, som är enskilda kod- eller textblock som kan köras oberoende av varandra eller som en grupp.

Vi tillhandahåller omfattande funktioner för att utveckla notebook:

• Lägga till en cell
• Ange ett primärt språk
• Använda flera språk
• IntelliSense i IDE-stil
• Kodfragment
• Dra och släpp för att infoga kodfragment
• Dra och släpp för att infoga bilder
• Formatera textcell med verktygsfältsknappar
• Ångra eller gör om celloperation
• Flytta en cell
• Ta bort en cell
• Komprimera en cellingång
• Fäll ihop en cellutdata
• Säkerhet för cellutgång
• Låsa eller frysa en cell
• Notebook-innehåll
• Markdown-hopfällning
• Hitta och ersätt

Lägga till en cell

Det finns flera sätt att lägga till en ny cell i anteckningsboken.

1. Hovra över utrymmet mellan två celler och välj Kod eller Markdown.

2. Använd genvägsnycklar i kommandoläge. Tryck på A för att infoga en cell ovanför den aktuella cellen. Tryck på B för att infoga en cell under den aktuella cellen.

Ange ett primärt språk

Fabric Notebooks stöder för närvarande fyra Apache Spark-språk:

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

Du kan ange primärt språk för nya tillagda celler från listrutan i det översta kommandofältet.

Använda flera språk

Du kan använda flera språk i en notebook-fil genom att ange kommandot language magic i början av en cell. Du kan också växla cellspråket från språkväljaren. I följande tabell visas de magiska kommandona för att växla cellspråk.

IntelliSense i IDE-stil

Fabric Notebooks är integrerade med Monaco-redigeraren för att ge IntelliSense i IDE-stil till cellredigeraren. Syntaxmarkering, felmarkör och automatiska kodkompletteringar hjälper dig att snabbt skriva kod och identifiera problem.

IntelliSense-funktionerna har olika mognadsnivåer för olika språk. Följande tabell visar vad Fabric stöder:

Förbättra Python-utveckling med Pylance

Pylance, en kraftfull och funktionsrik språkserver, är nu tillgänglig i Fabric Notebook. Pylance gör Python-utveckling enklare med smarta slutföranden, bättre felidentifiering och förbättrade kodinsikter. Viktiga förbättringar är smartare automatisk komplettering, förbättrat lambda-stöd, parameterförslag, förbättrad hovringsinformation, bättre docstring-återgivning och felmarkering. Med Pylance blir det snabbare, mer exakt och effektivare att skriva Python- och PySpark-kod.

Kodfragment

Anteckningsböcker i Fabric innehåller kodfragment som hjälper dig att enkelt skriva vanliga kodmönster, såsom:

• Läsa data som en Apache Spark-dataram
• Rita diagram med Matplotlib

Kodfragment visas i kortkommandon i IDE-stil IntelliSense blandade med andra förslag. Kodfragmentinnehållet överensstämmer med kodcellsspråket. Du kan se tillgängliga kodfragment genom att skriva kodfragment. Du kan också skriva valfritt nyckelord för att se en lista över relevanta kodfragment. Om du till exempel skriver läsa visas listan med kodfragment för att läsa data från olika datakällor.

Dra och släpp för att infoga kodfragment

Använd dra och släpp för att läsa data från Lakehouse Explorer på ett bekvämt sätt. Flera filtyper stöds här. du kan använda textfiler, tabeller, bilder osv. Du kan antingen släppa till en befintlig cell eller till en ny cell. Notebook-filen genererar ett kodfragment för att förhandsgranska data.

Dra och släpp för att infoga bilder

Använd dra och släpp för att enkelt infoga bilder från webbläsaren eller den lokala datorn till en markdown-cell.

Formatera textcell med verktygsfältsknappar

Om du vill slutföra vanliga markdown-åtgärder använder du formatknapparna i verktygsfältet i textcellen.

Ångra eller göra om celloperationer

Välj Ångra eller Gör om eller tryck på Z eller Skift+Z för att återkalla de senaste cellåtgärderna. Du kan ångra eller göra om upp till 10 av de senaste historiska celloperationerna.

Stödda cellåtgärder som kan ångras:

• Infoga eller ta bort cell. Du kan återkalla de borttagna åtgärderna genom att välja Ångra (textinnehållet sparas tillsammans med cellen).
• Ändra ordning på cellen.
• Växla inställning.
• Konvertera mellan kodcell och Markdown-cell.

Flytta en cell

Du kan dra från den tomma delen av en cell och släppa den till önskad position.

Du kan också flytta den markerade cellen med Flytta upp och Flytta ned i menyfliksområdet.

Ta bort en cell

Om du vill ta bort en cell väljer du knappen Ta bort till höger i cellen.

Du kan också använda genvägsnycklar i kommandoläge. Tryck på Skift+D för att ta bort den aktuella cellen.

Fäll ihop en cellinmatning

Välj ellipserna Fler kommandon (...) i cellverktygsfältet och Dölj indata för att dölja den aktuella cellens indata. Om du vill expandera den igen väljer du Visa indata när cellen är komprimerad.

Fäll ihop en cellutdata

Välj ellipserna Fler kommandon (...) i cellverktygsfältet och Dölj utdata för att dölja den aktuella cellens utdata. Om du vill expandera den igen väljer du Visa utdata när cellutdata är kollapsat.

Säkerhet för cellutdata

Du kan använda OneLake-dataåtkomstroller (förhandsversion) för att konfigurera åtkomst till endast specifika mappar i ett lakehouse under notebook-frågor. Användare utan åtkomst till en mapp eller tabell ser ett behörighetsfel när de försöker köra en fråga.

Låsa eller frysa en cell

Med åtgärderna lås och frysa celler kan du göra celler skrivskyddade eller hindra att kodceller körs på individuell basis.

Sammanfoga och dela celler

Du kan använda Sammanfogning med föregående cell eller Sammanfoga med nästa cell för att sammanfoga relaterade celler på ett bekvämt sätt.

Att välja Dela cell hjälper dig att dela upp irrelevanta uttalanden i flera celler. Åtgärden delar upp koden enligt markörens radposition.

Notebook-innehåll

Om du väljer Dispositioner eller Innehållsförteckning visas den första markdown-rubriken i en markdown-cell i ett sidofältsfönster för snabb navigering. Sidopanelen Outlines är ändringsbar och fällbar för att passa skärmen på bästa möjliga sätt. Välj knappen Innehåll i anteckningsbokens kommandofält för att öppna eller dölja sidofältet.

Markdown-sammanfällning

Med vikningsalternativet markdown kan du dölja celler under en markdown-cell som innehåller en rubrik. Markdown-cellen och dess dolda celler behandlas på samma sätt som en uppsättning av sammanhängande multi-valda celler vid utförande av celloperationer.

Hitta och ersätt

Alternativet sök och ersätt kan hjälpa dig att matcha och hitta nyckelorden eller uttrycket i notebook-innehållet. Du kan också enkelt ersätta målsträngen med en ny sträng.

Inlinjekodkomplettering med Copilot (förhandsversion)

Kodkomplettering med Copilot är en AI-baserad funktion som hjälper dig att skriva Python-kod snabbare och effektivare i Fabric Notebooks. Den här funktionen innehåller intelligenta, sammanhangsmedvetna kodförslag när du skriver kod. Det minskar repetitiva uppgifter, minimerar syntaxfel och påskyndar utvecklingen genom att integrera sömlöst i notebook-arbetsflödet.

Viktiga fördelar

• AI-drivna slutföranden: Genererar förslag baserat på notebook-filens kontext med hjälp av en modell som tränats på miljontals kodrader.
• Ökar produktiviteten: Hjälper till att skriva komplexa funktioner, minskar repetitiv kodning och påskyndar utforskningen av okända bibliotek.
• Minskar fel: Minimerar stavfel och syntaxmisstag med intelligenta, kontextmedvetna slutföranden.
• Minimal konfiguration: Inbyggd i Fabric Notebooks och kräver ingen installation. Du kan bara aktivera den och börja koda.

Så här fungerar det

Aktivera integrerade kodförslag med hjälp av knappen längst ned i anteckningsboken.

När du skriver visas förslag i ljusgrå text, tryck på fliken för att acceptera eller ändra. Förslag är baserade på tidigare anteckningsboksceller.

Aktuella begränsningar

• Copilot Inline Code Completion stöder för närvarande Python-språk och använder kontext från tidigare celler och Lakehouse-scheman.
• Förslag tar hänsyn till data från Lakehouse-scheman.
• Endast en delmängd av schemaelement används när det finns många tabeller eller kolumner.
• Dynamiskt skapade tabeller (via Spark) identifieras inte i realtid.

Kör notebooks

Du kan köra kodcellerna i anteckningsboken individuellt eller på en gång. Status och förlopp för varje cell visas i notebook-filen.

Kör en cell

Det finns flera sätt att köra koden i en cell.

• Hovra över cellen som du vill köra och välj knappen Kör cell eller tryck på Ctrl+Retur.

• Använd genvägsnycklar i kommandoläge. Tryck på Skift+Retur för att köra den aktuella cellen och markera nästa cell. Tryck på Alt+Retur för att köra den aktuella cellen och infoga en ny cell.

Kör alla celler

Välj knappen Kör alla för att köra alla celler i den aktuella notebook-filen i följd.

Kör alla celler ovan eller nedan

Expandera listrutan från Kör alla och välj sedan Kör celler ovan för att köra alla celler ovanför den aktuella i sekvensen. Välj Kör celler nedan för att köra den aktuella cellen och alla celler nedanför den i följd.

Avbryt alla körande celler

Välj Avbryt alla för att avbryta celler som körs eller som väntar i kön.

Avsluta session

Stoppa sessionen avbryter de körande och väntande cellerna och stoppar den pågående sessionen. Du kan starta om en helt ny session genom att välja körningsalternativet igen.

Referenskörning

Referenskör en Notebook

Förutom referenskörnings-API:et för notebookutils kan du också använda magikommando för att referera till en annan anteckningsbok inom den aktuella anteckningsbokens kontext. Alla variabler som definierats i referensanteckningsboken är tillgängliga i den aktuella notebook-filen. Det %run magiska kommandot stöder kapslade anrop men stöder inte rekursiva anrop. Du får ett undantag om instruktionsdjupet är större än fem.

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

Notebook-referensen fungerar i både interaktivt läge och i pipeline-läge.

Reference kör ett skript

Med %run kommandot kan du också köra Python- eller SQL-filer som lagras i notebook-filens inbyggda resurser, så att du enkelt kan köra källkodsfilerna i notebook-filen.

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

För alternativ:

• -b/--builtin: Det här alternativet anger att kommandot hittar och kör den angivna skriptfilen från notebook-filens inbyggda resurser.
• -c/--current: Det här alternativet säkerställer att kommandot alltid använder den aktuella notebook-filens inbyggda resurser, även om den aktuella notebook-filen refereras av andra notebook-filer.

Exempel:

• Så här kör du script_file.py från de inbyggda resurserna: %run -b script_file.py

• Så här kör du script_file.sql från de inbyggda resurserna: %run -b script_file.sql

• Så här kör du script_file.py från de inbyggda resurserna med specifika variabler: %run -b script_file.py { "parameterInt": 1, "parameterFloat": 2.5, "parameterBool": true, "parameterString": "abc" }

Användningsexempel för nästlat testfall:

• Anta att vi har två anteckningsböcker.
  • Notebook1: Innehåller script_file1.py i de inbyggda resurserna
  • Notebook2: Innehåller script_file2.py i sina inbyggda resurser
• Nu ska vi använda Notebook1 som huvudanteckningsbok med innehållet: %run Notebook2.
• I Notebook2 är användningsinstruktionen:
  • Om du vill köra script_file1.py i Notebook1(rotanteckningsboken) skulle koden vara: %run -b script_file1.py
  • Om du vill köra script_file2.py i Notebook2(den aktuella notebook-filen) skulle koden vara: %run -b -c script_file2.py

Variabelutforskaren

Fabric-notebooks har en inbyggd variabelexplorator som visar en lista över variablernas namn, typ, längd och värde i den aktuella Spark-sessionen för Python-celler i PySpark. Fler variabler visas automatiskt när de definieras i kodcellerna. Om du klickar på varje kolumnrubrik sorteras variablerna i tabellen.

För att öppna eller dölja variabelutforskaren, välj Variabler under fliken Visa i menyfliksområdet.

Indikator för cellstatus

En steg-för-steg-status för cellkörning visas under cellen för att hjälpa dig se dess aktuella framsteg. När körningen av cellen är klar visas en körningssammanfattning med den totala varaktigheten och sluttiden, och lagras där för framtida referens.

Indikator för sessionsstatus

Tidsgränskonfiguration för sessioner

I det nedre vänstra hörnet kan du välja sessionsstatus för att få mer information om den aktuella sessionen:

I popup-fönstret finns det ett alternativ för att återställa tidsgränsen till x minuter eller timmar.

Välj hur länge du vill ha en oavbruten session och tryck på Tillämpa. Tidsgränsen för sessionen återställs med det nya värdet och du kan fortsätta som vanligt!

Du kan också ange timeout enligt beskrivningen i:

• Administrationsinställningar för datateknik för arbetsytor i Microsoft Fabric
• Magiskt kommando för Spark-sessionskonfiguration

Håll dig inloggad: Om du ser dialogrutan Håll dig inloggad under inloggning väljer du Ja för att inaktivera tidsgränsen för den inaktiva sessionen för den aktuella sessionen.

Begär en principändring: Om du behöver en längre sessionsvaraktighet ber du klientadministratören att förlänga tidsgränsen för inaktiva sessioner. De kan göra detta genom att gå till Organisationsinställningar > Säkerhet och tidsgräns för inaktiv session > i Administrationscenter för Microsoft 365.

Hur påverkar tidsgränsen för ABT- och inaktiva sessioner tidskrävande körningar av Fabric Notebook?

Om din klientorganisation använder aktivitetsbaserad timeout (ABT) kan långvariga interaktiva jobb i Fabric Notebooks påverkas av Microsoft 365:s policy för avbrott vid inaktiva sessioner. Den här säkerhetsfunktionen är utformad för att logga ut användare på inaktiva, icke-hanterade enheter, även om ett notebook-jobb fortfarande körs. Aktiviteten i andra Microsoft 365-appar kan hålla sessionen vid liv, men inaktiva enheter loggas ut avsiktligt.

Varför loggas användarna ut även när ett notebook-jobb fortfarande körs?

Tidsgränsen för inaktiv session prioriterar säkerheten genom att avsluta sessioner på inaktiva enheter för att förhindra obehörig åtkomst. Även när en notebook-körning pågår avslutas sessionen om enheten inte visar någon aktivitet. Att hålla sessioner öppna på inaktiva enheter skulle äventyra säkerheten, vilket är anledningen till att det aktuella beteendet tillämpas.

Integrerad Apache Spark-jobbindikator

Notebooks är Apache Spark-baserade. Kodceller körs på Apache Spark-klustret via fjärranslutning. En förloppsindikator för Spark-jobb tillhandahålls med en realtidsprogressbar som verkar hjälpa dig att förstå statusen för jobbexekvering. Antalet uppgifter per jobb eller fas hjälper dig att identifiera den parallella nivån för ditt Spark-jobb. Du kan också öka detaljnivån för Spark-användargränssnittet för ett visst jobb (eller fas) genom att välja länken för jobbets (eller fasens) namn.

Du hittar även realtidsloggen på cellnivå bredvid förloppsindikatorn, och Diagnostik kan ge dig användbara förslag som hjälper dig att förfina och felsöka koden.

I Fler åtgärder kan du enkelt navigera till sidan med Spark-programinformation och spark-webbgränssnittssidan .

Hemlig redigering

För att förhindra att autentiseringsuppgifter av misstag läcker när notebook-filer körs stöder Fabric-notebook-filer hemlig redigering för att ersätta de hemliga värden som visas i cellutdata med [REDACTED]. Hemlig redigering gäller för Python, Scala och R.

Magiska kommandon i en anteckningsbok

Inbyggda specialkommandon

Du kan använda välbekanta magiska Ipython-kommandon i Fabric Notebooks. Granska följande lista över tillgängliga magiska kommandon.

Tillgängliga radmagikommandon: %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.

Notebook-filen Fabric stöder även de förbättrade bibliotekshanteringskommandona %pip och %conda. Mer information om användning finns i Hantera Apache Spark-bibliotek i Microsoft Fabric.

Tillgängliga cell magikommandon: %%time, %%timeit, %%capture, %%writefile, %%sql, %%pyspark, %%spark, %%csharp, %%configure, %%html, %%bash, %%markdown, %%perl, %%script, %%sh.

Anpassade magiska kommandon

Du kan också skapa fler anpassade magiska kommandon för att uppfylla dina specifika behov. Här är ett exempel:

1. Skapa en notebook-fil med namnet "MyLakehouseModule".

   

2. I en annan notebook-fil refererar du till "MyLakehouseModule" och dess magiska kommandon. Den här processen är hur du enkelt kan organisera projektet med notebook-filer som använder olika språk.

   

IPython Widgets

IPython Widgets är händelserika Python-objekt som har en representation i webbläsaren. Du kan använda IPython Widgets som kontroller med låg kod (till exempel skjutreglage eller textruta) i anteckningsboken, precis som Jupyter Notebook. För närvarande fungerar den bara i en Python-kontext.

Så här använder du IPython Widgets

1. Importera modulen ipywidgets först för att använda Jupyter Widget-ramverket.

   import ipywidgets as widgets
   

2. Använd visningsfunktionen på den översta nivån för att återge en widget eller lämna ett uttryck av widgettyp på den sista raden i kodcellen.

   slider = widgets.IntSlider()
   display(slider)
   

3. Kör cellen. Widgeten visas i utdataområdet.

   slider = widgets.IntSlider()
   display(slider)
   

   

4. Använd flera display() -anrop för att återge samma widgetinstans flera gånger. De är fortfarande synkroniserade med varandra.

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

   

5. Om du vill återge två widgetar oberoende av varandra skapar du två widgetinstanser:

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

   

Widgetar som stöds

Kända begränsningar

• Följande widgetar stöds inte än. Följande lösningar är tillgängliga:

  Funktionalitet	Lösning
  Widget för utdata	Du kan använda funktionen print() i stället för att skriva text till stdout.
  widgets.jslink()	Du kan använda funktionen widgets.link() för att länka två liknande widgetar.
  FileUpload-widget	Stöds inte ännu.

• Den globala visningsfunktionen Fabric stöder inte visning av flera widgetar i ett anrop (till exempel display(a, b)). Det här beteendet skiljer sig från IPython-visningsfunktionen.

• Om du stänger en notebook-fil som innehåller en IPython-widget kan du inte se eller interagera med den förrän du kör motsvarande cell igen.

• Funktionen interact (ipywidgets.interact) stöds inte.

Integrera en anteckningsbok

Utse en parametercell

Om du vill parametrisera anteckningsboken väljer du ellipserna (...) för att komma åt fler kommandon i cellverktygsfältet. Välj sedan Växla parametercell för att ange cellen som en parametercell.

Parametercellen är användbar för att integrera en notebook i en pipeline. Pipelineaktivitet söker efter den cell som innehåller parametrarna och behandlar denna cell som standardcell för de parametrar som anges vid körningstillfället. Körningsmotorn lägger till en ny cell under parametercellen med indataparametrar för att skriva över standardvärdena.

Tilldela värden till parametrar från en pipeline

När du har skapat en notebook-fil med parametrar kan du köra den från en pipeline med aktiviteten Fabric Notebook. När du har lagt till aktiviteten i pipelinearbetsytan kan du ange parametrarnas värden under avsnittet Basparametrar på fliken Inställningar .

När du tilldelar parametervärden kan du använda språket för pipelineuttryck eller funktioner och variabler.

Notebook-parametrar stöder enkla typer som int, float, booloch string. Komplexa typer som list och dict stöds ännu inte. Om du vill skicka en komplex typ kan du överväga att serialisera den till ett strängformat (till exempel JSON) och sedan deserialisera den i notebook-filen. Följande exempel visar hur du skickar en JSON-sträng från pipeline till notebook-fil och deserialiserar den:

Följande Python-kod visar hur du deserialiserar JSON-strängen till en Python-ordlista:

import json

# Deserialize the JSON string into a Python dictionary
params = json.loads(json_string)

# Access the individual parameters
param1 = params.get("param1")
param2 = params.get("param2")

Kontrollera att parameternamnet i parameterkodcellen matchar parameternamnet i pipelinen.

Magiskt kommando för Spark-sessionskonfiguration

Du kan anpassa Spark-sessionen med det magiska kommandot %%configure. Fabric notebook stöder anpassade virtuella kärnor, minne för drivern och exekveraren, Apache Spark-egenskaper, monteringspunkter, pool och standard Lakehouse för notebook-sessionen. De kan användas i både interaktiva anteckningsbok- och pipeline-anteckningsboksaktiviteter. Vi rekommenderar att du kör kommandot %%configure i början av anteckningsboken, eller så måste du starta om Spark-sessionen för att inställningarna ska börja gälla.

%%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"]
    "driverCores": 4, // Recommended values: [4, 8, 16, 32, 64]
    "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>"
}

Du kan också använda %%configure magikommando för att dynamiskt mata in konfigurationsvärden från Variabelbiblioteket i din notebook.

%%configure
{
  "defaultLakehouse": {
    "name": {
      "variableName": "$(/**/myVL/LHname)" 
    },
    "id": {
      "variableName": "$(/**/myVL/LHid)"
    },
    "workspaceId": "<(optional) workspace-id-that-contains-the-lakehouse>"
  }
}

I det här exemplet:

• myVL är namnet på ditt variabelbibliotek.
• LHname och LHid är variabelnycklar som definierats i biblioteket.
• Dessa värden matchas vid körning beroende på den aktiva miljön (till exempel Dev, Test, Prod).

På så sätt kan du växla konfigurationer som standard lakehouse utan att ändra din notebook-kod.

Parameteriserad sessionskonfiguration från en pipeline

Med en parametriserad sessionskonfiguration kan du ersätta värdet i %%configure magic med parametrarna för pipelinekörningens notebook-aktivitet. När du förbereder %%configure code cell kan du åsidosätta standardvärden (även konfigurerbara, 4 och "2000" i exemplet nedan) med ett objekt som det här:

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

%%configure  

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

En notebook-fil använder standardvärdet om du kör en notebook-fil i interaktivt läge direkt eller om pipelinens notebook-aktivitet inte ger någon parameter som matchar "activityParameterName".

Du kan konfigurera inställningar för notebook-aktiviteter i pipeline-körningar på följande sätt:

Om du vill ändra sessionskonfigurationen bör parameternamnet för pipeline-notebook-aktivitet vara samma som parameterName i anteckningsboken. I det här exemplet på att köra en pipeline ersätts driverCores i %%configure med 8 och livy.rsc.sql.num-rows med 4000.

Python-loggning i en notebook

Du hittar Python-loggar och anger olika loggnivåer och format som exempelkoden som visas här:

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

Visa historiken för indatakommandon

Fabric Notebook har stöd för magiskt kommando %history för att skriva ut indatakommandohistorik som exekverades i den aktuella sessionen, jämfört med standardkommandot i Jupyter Ipython där %history kan användas i kontext för flera språk i notebook.

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

För alternativ:

• -n: Använd exekveringsnumret.

Där intervallet kan vara:

• N: Skriv ut koden för den N-te körda cellen.
• M-N: Skriv ut kod från M:e cellen till N:e cellen.

Exempel:

• Skriv ut indatahistorik från 1:a till 2:a utförd cell: %history -n 1-2

Snabbtangenter

På samma sätt som Jupyter Notebooks har Fabric Notebooks ett modalt användargränssnitt. Tangentbordet gör olika saker beroende på vilket läge notebook-cellen befinner sig i. Anteckningsböcker stöder följande två lägen för en given kodcell: kommandoläge och redigeringsläge.

• En cell är i kommandoläge när det inte finns någon textmarkör som uppmanar dig att skriva. När en cell är i kommandoläge kan du redigera anteckningsboken som helhet men inte skriva in i enskilda celler. Ange kommandoläge genom att trycka på ESC eller använda musen för att välja utanför en cells redigeringsområde.

  

• Redigeringsläget kan anges från en textmarkör som uppmanar dig att skriva i redigeringsområdet. När en cell är i redigeringsläge kan du skriva in i cellen. Ange Redigeringsläge genom att trycka på Retur eller använda musen för att markera en cells redigeringsområde.

  

Genvägsnycklar i kommandoläge

Kortkommandon i redigeringsläge

Med hjälp av följande genvägar för tangenttryckning kan du enkelt navigera och köra kod i Fabric Notebooks när du är i redigeringsläge.

Om du vill hitta alla genvägsnycklar väljer du Visa i notebook-menyfliksområdet och väljer sedan Nyckelbindningar.

Relaterat innehåll

• Notebookvisualisering
• Introduktion av Fabric NotebookUtils