Skapa, utveckla och underhålla Synapse-notebook-filer

En notebook-fil i Azure Synapse Analytics (en Synapse-notebook-fil) är ett webbgränssnitt där du kan skapa filer som innehåller livekod, visualiseringar och narrativ text. Notebook-filer är ett bra ställe att validera idéer och använda snabba experiment för att få insikter från dina data. Notebook-filer används också ofta i dataförberedelser, datavisualisering, maskininlärning och andra stordatascenarier.

Med en Synapse-anteckningsbok kan du:

• Kom igång med noll installationsarbete.
• Hjälp till att skydda data med inbyggda säkerhetsfunktioner för företag.
• Analysera data över rådataformat (till exempel CSV, TXT och JSON), bearbetade filformat (som Parquet, Delta Lake och ORC) och SQL-tabelldatafiler mot Spark och SQL.
• Var produktiv med förbättrade redigeringsfunktioner och inbyggd datavisualisering.

Den här artikeln beskriver hur du använder notebook-filer i Synapse Studio.

Skapa en notebook-fil

Du kan skapa en ny notebook-fil eller importera en befintlig anteckningsbok till en Synapse-arbetsyta från Object Explorer. Välj menyn Utveckla. + Välj knappen och välj Notebook eller högerklicka på Notebooks och välj sedan Ny anteckningsbok eller Importera. Synapse-notebook-filer känner igen IPYNB-standardfiler för Jupyter Notebook.

Utveckla notebook-filer

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

I följande avsnitt beskrivs åtgärderna för att utveckla notebook-filer:

• Lägga till en cell
• Ange ett primärt språk
• Använda flera språk
• Använda temporära tabeller för att referera till data mellan språk
• Använda IntelliSense i IDE-format
• Använda kodfragment
• Formatera textceller med hjälp av verktygsfältsknappar
• Ångra eller göra om en cellåtgärd
• Kommentera en kodcell
• Flytta en cell
• Kopiera en cell
• Ta bort en cell
• Dölj cellindata
• Dölj cellutdata
• Använda en anteckningsboksdisposition

Kommentar

I notebook-filerna skapas en SparkSession instans automatiskt åt dig och lagras i en variabel med namnet spark. Det finns också en variabel för SparkContext som heter sc. Användare kan komma åt dessa variabler direkt men bör inte ändra värdena för dessa variabler.

Lägga till en cell

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

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

  

• Använd kortkommandon i kommandoläge. Välj A-tangenten för att infoga en cell ovanför den aktuella cellen. Välj B-tangenten för att infoga en cell under den aktuella cellen.

Ange ett primärt språk

Synapse-notebook-filer stöder fyra Apache Spark-språk:

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

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

Använda flera språk

Du kan använda flera språk i en anteckningsbok genom att ange rätt språkmagikommando i början av en cell. I följande tabell visas de magiska kommandona för att växla cellspråk.

Magiskt kommando	Språk	beskrivning
%%pyspark	Python	Kör en Python-fråga mot SparkContext.
%%spark	Scala	Kör en Scala-fråga mot SparkContext.
%%sql	Spark SQL	Kör en Spark SQL-fråga mot SparkContext.
%%csharp	.NET för Spark C#	Kör en .NET för Spark C#-fråga mot SparkContext.
%%sparkr	R	Kör en R-fråga mot SparkContext.

Följande bild visar ett exempel på hur du kan skriva en PySpark-fråga med hjälp av det %%pyspark magiska kommandot eller en Spark SQL-fråga med hjälp av det %%sql magiska kommandot i en Spark-anteckningsbok (Scala). Det primära språket för notebook-filen är inställt på PySpark.

Använda temporära tabeller för att referera till data mellan språk

Du kan inte referera till data eller variabler direkt på olika språk i en Synapse-notebook-fil. I Spark kan du referera till en tillfällig tabell mellan olika språk. Här är ett exempel på hur du läser en Scala DataFrame i PySpark och Spark SQL med hjälp av en tillfällig Spark-tabell som en lösning:

1. I cell 1 läser du en DataFrame från en SQL-poolanslutning med hjälp av Scala och skapar en tillfällig tabell:

   %%spark
   val scalaDataFrame = spark.read.sqlanalytics("mySQLPoolDatabase.dbo.mySQLPoolTable")
   scalaDataFrame.createOrReplaceTempView( "mydataframetable" )
   

2. I cell 2 kör du frågor mot data med hjälp av Spark SQL:

   %%sql
   SELECT * FROM mydataframetable
   

3. I cell 3 använder du data i PySpark:

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

Använda IntelliSense i IDE-format

Synapse-notebook-filer är integrerade med Monaco-redigeraren för att ta IDE-stil IntelliSense till cellredigeraren. Funktionerna för syntaxmarkering, felmarkör och automatisk kodkomplettering hjälper dig att skriva kod och identifiera problem snabbare.

IntelliSense-funktionerna har olika mognadsnivåer för olika språk. Använd följande tabell för att se vad som stöds.

Språk	Syntaxmarkering	Syntaxfelmarkör	Slutförande av syntaxkod	Slutförande av variabelkod	Systemfunktionens kod har slutförts	Kodkomplettering av användarfunktion	Smart indrag	Koddelegering
PySpark (Python)	Ja	Ja	Ja	Ja	Ja	Ja	Ja	Ja
Spark (Scala)	Ja	Ja	Ja	Ja	Ja	Ja	No	Ja
Spark SQL	Ja	Ja	Ja	Ja	Ja	Nej	Nej	Nej
.NET för Spark (C#)	Ja	Ja	Ja	Ja	Ja	Ja	Ja	Ja

En aktiv Spark-session krävs för att dra nytta av slutförande av variabelkod, slutförande av systemfunktionskod och slutförande av användarfunktionskod för .NET för Spark (C#).

Använda kodfragment

Synapse-notebook-filer innehåller kodfragment som gör det enklare att ange vanliga kodmönster. Dessa mönster omfattar att konfigurera Spark-sessionen, läsa data som en Spark DataFrame och rita diagram med hjälp av Matplotlib.

Kodfragment visas i kortkommandon i IntelliSense i IDE-stil blandat med andra förslag. Kodfragmentens innehåll överensstämmer med kodcellsspråket. Du kan se tillgängliga kodfragment genom att ange kodfragment eller nyckelord som visas i kodfragmentets rubrik i kodcellsredigeraren. Genom att till exempel ange läs kan du se listan med kodfragment för att läsa data från olika datakällor.

Formatera textceller med hjälp av verktygsfältsknappar

Du kan använda formatknapparna i textcellens verktygsfält för att utföra vanliga Markdown-åtgärder. Dessa åtgärder omfattar att göra text fet, göra text kursiv, skapa stycken och rubriker via en nedrullningsbar meny, infoga kod, infoga en osorterad lista, infoga en ordnad lista, infoga en hyperlänk och infoga en bild från en URL.

Ångra eller göra om en cellåtgärd

Om du vill återkalla de senaste cellåtgärderna väljer du knappen Ångra eller Gör om eller väljer Z-tangenten eller Skift+Z. Nu kan du ångra eller göra om upp till 10 historiska cellåtgärder.

Cellåtgärder som stöds är:

• Infoga eller ta bort en cell. Du kan återkalla borttagningsåtgärder genom att välja Ångra. Den här åtgärden behåller textinnehållet tillsammans med cellen.
• Ordna om celler.
• Aktivera eller inaktivera en parametercell.
• Konvertera mellan en kodcell och en Markdown-cell.

Kommentar

Du kan inte ångra textåtgärder eller kommentera åtgärder i en cell.

Kommentera en kodcell

1. Välj knappen Kommentarer i anteckningsbokens verktygsfält för att öppna fönstret Kommentarer.

   

2. Välj kod i kodcellen, välj Nytt i fönstret Kommentarer , lägg till kommentarer och välj sedan knappen Publicera kommentar .

   

3. Om det behövs kan du utföra åtgärderna Redigera kommentar, Lös tråd och Ta bort tråd genom att välja ellipsen Mer (...) bredvid kommentaren.

   

Flytta en cell

Om du vill flytta en cell markerar du cellens vänstra sida och drar cellen till önskad position.

Kopiera en cell

Om du vill kopiera en cell skapar du först en ny cell, markerar sedan all text i den ursprungliga cellen, kopierar texten och klistrar in texten i den nya cellen. När cellen är i redigeringsläge begränsas traditionella kortkommandon för att markera all text till cellen.

Dricks

Synapse-notebook-filer ger också snippits av vanliga kodmönster.

Ta bort en cell

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

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

Dölj cellindata

Om du vill dölja den aktuella cellens indata markerar du ellipsen Fler kommandon (...) i cellverktygsfältet och väljer sedan Dölj indata. Om du vill expandera indata väljer du Visa indata medan cellen är komprimerad.

Dölj cellutdata

Om du vill dölja den aktuella cellens utdata markerar du ellipsen Fler kommandon (...) i cellverktygsfältet och väljer sedan Dölj utdata. Om du vill expandera utdata väljer du Visa utdata medan cellens utdata är dolda.

Använda en anteckningsboksdisposition

Dispositionen (innehållsförteckningen) visar den första Markdown-rubriken i en Markdown-cell i ett sidofältsfönster för snabb navigering. Dispositionslisten är storleksanpassad och komprimerbar för att passa skärmen på bästa möjliga sätt. Om du vill öppna eller dölja sidopanelen väljer du knappen Disposition i anteckningsbokens kommandofält.

Köra en notebook-fil

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.

Kommentar

Om du tar bort en notebook-fil avbryts inga jobb som körs automatiskt. Om du behöver avbryta ett jobb går du till monitorhubben och avbryter det manuellt.

Köra 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 sedan knappen Kör cell eller välj Ctrl+Retur.

  

• Använd kortkommandon i kommandoläge. Välj Skift+Retur för att köra den aktuella cellen och markera cellen under den. Välj Alt+Retur för att köra den aktuella cellen och infoga en ny cell under den.

Kör alla celler

Om du vill köra alla celler i den aktuella notebook-filen i följd väljer du knappen Kör alla .

Kör alla celler ovanför eller under

Om du vill köra alla celler ovanför den aktuella cellen i sekvens expanderar du listrutan för knappen Kör alla och väljer sedan Kör celler ovan. Välj Kör celler nedan för att köra alla celler under den aktuella i följd.

Avbryt alla celler som körs

Om du vill avbryta de celler som körs eller cellerna som väntar i kön väljer du knappen Avbryt alla .

Referera till en notebook-fil

Om du vill referera till en annan notebook-fil i den aktuella notebook-filens kontext använder du det %run <notebook path> magiska kommandot. Alla variabler som definierats i referensanteckningsboken är tillgängliga i den aktuella notebook-filen.

Här är ett exempel:

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

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

Det %run magiska kommandot har följande begränsningar:

• Kommandot stöder kapslade anrop men inte rekursiva anrop.
• Kommandot har stöd för att endast skicka en absolut sökväg eller ett notebook-namn som en parameter. Den stöder inte relativa sökvägar.
• Kommandot stöder för närvarande endast fyra parametervärdetyper: int, float, booloch string. Den stöder inte åtgärder för variabel ersättning.
• De refererade notebook-filerna måste publiceras. Du måste publicera anteckningsböckerna för att referera till dem, såvida du inte väljer alternativet för att aktivera en opublicerad notebook-referens. Synapse Studio känner inte igen de opublicerade notebook-filerna från Git-lagringsplatsen.
• Refererade notebook-filer stöder inte instruktionsdjup som är större än fem.

Använda variabelutforskaren

En Synapse-notebook-fil innehåller en inbyggd variabelutforskare i form av en tabell som visar variabler i den aktuella Spark-sessionen för PySpark-celler (Python). Tabellen innehåller kolumner för variabelnamn, typ, längd och värde. Fler variabler visas automatiskt när de definieras i kodcellerna. Om du väljer varje kolumnrubrik sorteras variablerna i tabellen.

Om du vill öppna eller dölja variabelutforskaren väljer du knappen Variabler i notebook-kommandofältet.

Kommentar

Variabelutforskaren stöder endast Python.

Använd indikatorn för cellstatus

En steg-för-steg-status för en cellkörning visas under cellen för att hjälpa dig att se dess aktuella förlopp. När cellkörningen är klar visas en sammanfattning med den totala varaktigheten och sluttiden och stannar där för framtida referens.

Använd Spark-förloppsindikatorn

En Synapse-notebook-fil är helt Spark-baserad. Kodceller körs på den serverlösa Apache Spark-poolen via fjärranslutning. En spark-jobbförloppsindikator med en förloppsindikator i realtid hjälper dig att förstå statusen för jobbkörningen.

Antalet uppgifter för varje 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 steg) genom att välja länken för jobbets (eller fasens) namn.

Konfigurera en Spark-session

I fönstret Konfigurera session, som du kan hitta genom att välja kugghjulsikonen överst i anteckningsboken, kan du ange tidsgränsen, antalet utförare och storleken på de utförare som ska användas i den aktuella Spark-sessionen. Starta om Spark-sessionen för att konfigurationsändringar ska börja gälla. Alla cachelagrade notebook-variabler rensas.

Du kan också skapa en konfiguration från Apache Spark-konfigurationen eller välja en befintlig konfiguration. Mer information finns i Hantera Apache Spark-konfiguration.

Magiskt kommando för att konfigurera en Spark-session

Du kan också ange Inställningar för Spark-sessioner via det magiska kommandot %%configure. Starta om Spark-sessionen om du vill att inställningarna ska börja gälla.

Vi rekommenderar att du kör %%configure i början av anteckningsboken. Här är ett exempel. Den fullständiga listan över giltiga parametrar finns i Livy-informationen på GitHub.

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

Här följer några överväganden för det %%configure magiska kommandot:

• Vi rekommenderar att du använder samma värde för driverMemory och executorMemory i %%configure. Vi rekommenderar också det driverCores och executorCores har samma värde.
• Du kan använda %%configure i Synapse-pipelines, men om du inte anger den i den första kodcellen misslyckas pipelinekörningen eftersom den inte kan starta om sessionen.
• Kommandot %%configure som används i mssparkutils.notebook.run ignoreras, men kommandot som används i %run <notebook> fortsätter att köras.
• Du måste använda standardegenskaperna för Spark-konfiguration i brödtexten "conf" . Vi stöder inte referenser på första nivån för Spark-konfigurationsegenskaperna.
• Vissa särskilda Spark-egenskaper börjar inte gälla i "conf" brödtexten, inklusive "spark.driver.cores", "spark.executor.cores", "spark.driver.memory", "spark.executor.memory"och "spark.executor.instances".

Parameteriserad sessionskonfiguration från en pipeline

Du kan använda parameteriserad sessionskonfiguration för att ersätta värden i det %%configure magiska kommandot med parametrar för pipelinekörning (notebook-aktivitet). När du förbereder en %%configure kodcell kan du åsidosätta standardvärden med hjälp av ett objekt som det här:

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

I följande exempel visas standardvärdena 4 för och "2000", som också kan konfigureras:

%%configure  

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

Notebook-filen använder standardvärdet om du kör notebook-filen i interaktivt läge direkt eller om pipelinens notebook-aktivitet inte innehåller en parameter som matchar "activityParameterName".

Under pipelinekörningsläget kan du använda fliken Inställningar för att konfigurera inställningar för en pipeline notebook-aktivitet.

Om du vill ändra sessionskonfigurationen ska namnet på pipelinens notebook-aktivitetsparameter vara samma som activityParameterName i notebook-filen. I det här exemplet ersätter under en pipelinekörning 8 i %%configureoch 4000 ersätter livy.rsc.sql.num-rows.driverCores

Om en pipelinekörning misslyckas när du har använt det %%configure magiska kommandot kan du få mer felinformation genom att köra den %%configure magiska cellen i notebook-filens interaktiva läge.

Ta data till en notebook-fil

Du kan läsa in data från Azure Data Lake Storage Gen 2, Azure Blob Storage och SQL-pooler, enligt följande kodexempel.

Läsa en CSV-fil från Azure Data Lake Storage Gen2 som en Spark DataFrame

from pyspark.sql import SparkSession
from pyspark.sql.types import *
account_name = "Your account name"
container_name = "Your container name"
relative_path = "Your path"
adls_path = 'abfss://%s@%s.dfs.core.windows.net/%s' % (container_name, account_name, relative_path)

df1 = spark.read.option('header', 'true') \
                .option('delimiter', ',') \
                .csv(adls_path + '/Testfile.csv')

Läsa en CSV-fil från Azure Blob Storage som en Spark DataFrame

from pyspark.sql import SparkSession

# Azure storage access info
blob_account_name = 'Your account name' # replace with your blob name
blob_container_name = 'Your container name' # replace with your container name
blob_relative_path = 'Your path' # replace with your relative folder path
linked_service_name = 'Your linked service name' # replace with your linked service name

blob_sas_token = mssparkutils.credentials.getConnectionStringOrCreds(linked_service_name)

# Allow Spark to access from Azure Blob Storage remotely

wasb_path = 'wasbs://%s@%s.blob.core.windows.net/%s' % (blob_container_name, blob_account_name, blob_relative_path)

spark.conf.set('fs.azure.sas.%s.%s.blob.core.windows.net' % (blob_container_name, blob_account_name), blob_sas_token)
print('Remote blob path: ' + wasb_path)

df = spark.read.option("header", "true") \
            .option("delimiter","|") \
            .schema(schema) \
            .csv(wasbs_path)

Läsa data från det primära lagringskontot

Du kan komma åt data i det primära lagringskontot direkt. Du behöver inte ange de hemliga nycklarna. Högerklicka på en fil i Datautforskaren och välj Ny anteckningsbok för att se en ny notebook-fil med en automatiskt genererad dataextraktor.

Använda IPython-widgetar

Widgetar är händelserika Python-objekt som har en representation i webbläsaren, ofta som en kontroll som ett skjutreglage eller en textruta. IPython-widgetar fungerar endast i Python-miljöer. De stöds för närvarande inte på andra språk (till exempel Scala, SQL eller C#).

Steg för att använda IPython-widgetar

1. Importera modulen ipywidgets för att använda Jupyter Widgets-ramverket:

   import ipywidgets as widgets
   

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

   slider = widgets.IntSlider()
   display(slider)
   

   slider = widgets.IntSlider()
   slider
   

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

   

Du kan använda flera display() anrop för att återge samma widgetinstans flera gånger, men de förblir synkroniserade med varandra:

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

Om du vill återge två widgetar som är oberoende av varandra skapar du två widgetinstanser:

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

Widgetar som stöds

Widgettyp	Widgetar
Numerisk	IntSlider, FloatSlider, FloatLogSlider, IntRangeSlider, FloatRangeSlider, IntProgress, , FloatProgress, BoundedIntText, BoundedFloatText, , , IntTextFloatText
Booleskt	ToggleButton, , CheckboxValid
Urval	Dropdown, RadioButtons, Select, SelectionSlider, SelectionRangeSlider, , , ToggleButtonsSelectMultiple
String	Text, Text area, Combobox, Password, Label, HTML, , HTML Math, , ImageButton
Spela upp (animering)	Date picker, , Color pickerController
Container/layout	Box, HBox, VBox, GridBox, Accordion, , , TabsStacked

Kända begränsningar

• I följande tabell visas widgetar som för närvarande inte stöds, tillsammans med lösningar:

  Funktioner	Lösning
  Output manick	Du kan använda print() funktionen i stället för att skriva text till stdout.
  widgets.jslink()	Du kan använda widgets.link() funktionen för att länka två liknande widgetar.
  FileUpload manick	Ingen är tillgänglig.

• Den globala display funktion som Azure Synapse Analytics tillhandahåller stöder inte visning av flera widgetar i ett anrop (det vill säga display(a, b)). Det här beteendet skiljer sig från IPython-funktionen display .

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

Spara notebook-filer

Du kan spara en enskild notebook-fil eller alla notebook-filer på din arbetsyta:

• Om du vill spara ändringar som du har gjort i en enda notebook-fil väljer du knappen Publicera i kommandofältet för notebook-filen.

  

• Om du vill spara alla anteckningsböcker på arbetsytan väljer du knappen Publicera alla i arbetsytans kommandofält.

  

I anteckningsbokens egenskapsfönster kan du konfigurera om cellutdata ska inkluderas när du sparar.

Använda magiska kommandon

Du kan använda välbekanta Jupyter-magiska kommandon i Synapse-notebook-filer. Granska följande listor över tillgängliga magiska kommandon. Berätta om dina användningsfall på GitHub så att vi kan fortsätta att skapa fler magiska kommandon för att uppfylla dina behov.

Kommentar

Endast följande magiska kommandon stöds i Synapse-pipelines: %%pyspark, %%spark, %%csharp, %%sql.

Tillgängliga magiska kommandon för rader:

%lsmagic, %time, %timeit, %history, , , %run%load

Tillgängliga magiska kommandon för celler:

%%time, %%timeit, %%capture, %%writefile, %%sql, %%pyspark, , %%spark, %%csharp, , %%html%%configure

Referera till en opublicerad notebook-fil

Att referera till en opublicerad notebook-fil är användbart när du vill felsöka lokalt. När du aktiverar den här funktionen hämtar en notebook-körning det aktuella innehållet i webbcachen. Om du kör en cell som innehåller en referensanteckningsbokssats refererar du till presentationsanteckningsböckerna i den aktuella notebook-webbläsaren i stället för en sparad version i ett kluster. Andra notebook-filer kan referera till ändringarna i anteckningsboksredigeraren utan att du behöver publicera ändringarna (liveläge) eller checka in ändringarna (Git-läge). Med den här metoden kan du förhindra förorening av vanliga bibliotek under utveckling eller felsökning.

Du kan aktivera referens till en opublicerad anteckningsbok genom att markera lämplig kryssruta i fönstret Egenskaper .

I följande tabell jämförs ärenden. Även om %run och mssparkutils.notebook.run har samma beteende här, används %run tabellen som exempel.

Skiftläge	Inaktivera	Aktivera
Liveläge
Nb1 (publicerad) %run Nb1	Kör publicerad version av Nb1	Kör publicerad version av Nb1
Nb1 (ny) %run Nb1	Fel	Kör ny Nb1
Nb1 (tidigare publicerad, redigerad) %run Nb1	Kör publicerad version av Nb1	Kör redigerad version av Nb1
Git-läge
Nb1 (publicerad) %run Nb1	Kör publicerad version av Nb1	Kör publicerad version av Nb1
Nb1 (ny) %run Nb1	Fel	Kör ny Nb1
Nb1 (inte publicerad, bekräftad) %run Nb1	Fel	Kör bekräftad Nb1
Nb1 (tidigare publicerad, bekräftad) %run Nb1	Kör publicerad version av Nb1	Kör den bekräftade versionen av Nb1
Nb1 (tidigare publicerad, ny i aktuell gren) %run Nb1	Kör publicerad version av Nb1	Kör ny Nb1
Nb1 (inte publicerad, tidigare bekräftad, redigerad) %run Nb1	Fel	Kör redigerad version av Nb1
Nb1 (tidigare publicerad och bekräftad, redigerad) %run Nb1	Kör publicerad version av Nb1	Kör redigerad version av Nb1

Sammanfattningsvis:

• Om du inaktiverar referens till en opublicerad notebook-fil kör du alltid den publicerade versionen.
• Om du aktiverar referenser till en opublicerad notebook-fil antar referenskörningen alltid den aktuella versionen av notebook-filen som visas i notebook-gränssnittet.

Hantera aktiva sessioner

Du kan återanvända notebook-sessioner utan att behöva starta nya. I Synapse-notebook-filer kan du hantera dina aktiva sessioner i en enda lista. Öppna listan genom att välja ellipsen (...) och sedan Hantera sessioner.

I fönstret Aktiva sessioner visas alla sessioner i den aktuella arbetsytan som du startade från en notebook-fil. Listan visar sessionsinformationen och motsvarande notebook-filer. Koppla från med notebook-filen, Stoppa sessionen och Visa i övervakningsåtgärder finns här. Du kan också ansluta den valda anteckningsboken till en aktiv session som startade från en annan notebook-fil. Sessionen kopplas sedan från den tidigare notebook-filen (om den inte är inaktiv) och kopplas till den aktuella.

Använda Python-loggar i en notebook-fil

Du hittar Python-loggar och anger olika loggnivåer och format med hjälp av följande exempelkod:

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 the 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 uses 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 uses 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

Synapse Notebooks stöder det magiska kommandot %history för att skriva ut indatakommandohistoriken för den aktuella sessionen. Det %history magiska kommandot liknar standardkommandot Jupyter IPython och fungerar för flera språkkontexter i en notebook-fil.

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

I föregående kod -n är körningsnumret för utskriften. Värdet range kan vara:

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

Om du till exempel vill skriva ut indatahistorik från den första till den andra cellen som körs använder du %history -n 1-2.

Integrera en notebook-fil

Lägga till en notebook-fil i en pipeline

Om du vill lägga till en notebook-fil i en befintlig pipeline eller skapa en ny pipeline väljer du knappen Lägg till i pipeline i det övre högra hörnet.

Ange en parametercell

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

Azure Data Factory söker efter parametercellen och behandlar den här cellen som standard för de parametrar som skickades in vid körningen. Körningsmotorn lägger till en ny cell under parametercellen med indataparametrar för att skriva över standardvärdena.

Tilldela parametrar värden från en pipeline

När du har skapat en notebook-fil med parametrar kan du köra den från en pipeline med hjälp av en Synapse Notebook-aktivitet. När du har lagt till aktiviteten i pipelinearbetsytan kan du ange parametervärdena i avsnittet Basparametrar på fliken Inställningar .

När du tilldelar parametervärden kan du använda pipelineuttrycksspråket eller systemvariablerna.

Använda kortkommandon

I likhet med Jupyter Notebooks har Synapse Notebooks ett modalt användargränssnitt. Tangentbordet gör olika saker beroende på vilket läge notebook-cellen befinner sig i. Synapse Notebooks stöder följande två lägen för en kodcell:

• Kommandoläge: En cell är i kommandoläge när ingen textmarkör 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 välja Esc-tangenten eller genom att använda musen för att välja utanför en cells redigeringsområde.

  

• Redigeringsläge: När en cell är i redigeringsläge uppmanar en textmarkör dig att skriva in cellen. Ange redigeringsläge genom att välja returnyckeln eller genom att använda musen för att välja en cells redigeringsområde.

  

Genvägsnycklar i kommandoläge

Åtgärd	Genväg till Synapse Notebook
Kör den aktuella cellen och välj nedan	Skift+Retur
Kör den aktuella cellen och infoga nedan	Alt+Retur
Kör aktuell cell	Ctrl+Return
Markera cellen ovan	Upp
Välj cell nedan	Ned
Markera föregående cell	k
Välj nästa cell	J
Infoga cell ovan	A
Infoga cell nedan	F
Ta bort markerade celler	Skift+D
Växla till redigeringsläge	Skriv in

Kortkommandon i redigeringsläge

Åtgärd	Genväg till Synapse Notebook
Flytta markören uppåt	Upp
Flytta markören nedåt	Ned
Ångra	Ctrl+Z
Gör om	Ctrl+Y
Kommentar/avkommentering	Ctrl+/
Ta bort ord före	Ctrl+Backspace
Ta bort ord efter	Ctrl+Ta bort
Gå till cellstart	Ctrl+start
Gå till celländen	Ctrl+End
Gå ett ord till vänster	Ctrl+vänster
Gå ett ord åt höger	Ctrl+höger
Välj alla	Ctrl+A
Indrag	Ctrl+]
Dedent	Ctrl+[
Växla till kommandoläge	Esc

Relaterat innehåll

• Synapse-exempelanteckningsböcker
• Snabbstart: Skapa en Apache Spark-pool i Azure Synapse Analytics med hjälp av webbverktyg
• Vad är Apache Spark i Azure Synapse Analytics?
• Använda .NET för Apache Spark med Azure Synapse Analytics
• Dokumentation om .NET för Apache Spark
• Azure Synapse Analytics-dokumentation