Skapa, utveckla och underhålla Synapse-notebook-filer i Azure Synapse Analytics

En Synapse-notebook-fil är ett webbgränssnitt där du kan skapa filer som innehåller livekod, visualiseringar och berättande text. Notebook-filer är ett bra ställe att validera idéer och använda snabbexperiment för att få insikter från dina data. Notebook-filer används också ofta för förberedelse av data, datavisualisering, maskininlärning och andra stordatascenarier.

Med en Synapse-anteckningsbok kan du:

  • Kom igång utan konfiguration.
  • Skydda data med inbyggda säkerhetsfunktioner för företag.
  • Analysera data över rådataformat (CSV, txt, JSON osv.), bearbetade filformat (parquet, Delta Lake, ORC osv.) och SQL tabelldatafiler mot Spark och SQL.
  • Var produktiv med förbättrade redigeringsfunktioner och inbyggd datavisualisering.

I den här artikeln beskrivs hur du använder notebook-filer i Synapse Studio.

Skapa en notebook-fil

Det finns två sätt att skapa en notebook-fil. Du kan skapa en ny notebook-fil eller importera en befintlig notebook-fil till en Synapse-arbetsyta från Object Explorer. Synapse-notebook-filer känner igen STANDARD-Jupyter Notebook IPYNB-filer.

Screenshot of create new or import notebook

Utveckla notebook-filer

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

Vi tillhandahåller omfattande åtgärder för att utveckla notebook-filer:

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. Screenshot of add-azure-notebook-cell-with-cell-button

  2. Använd aznb-kortkommandon 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

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

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

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

Screenshot of default-synapse-language

Använda flera språk

Du kan använda flera språk i en anteckningsbok genom att ange rätt magiskt språkkommando 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 Spark-kontext.
%%spark Scala Kör en Scala-fråga mot Spark-kontext.
%%sql SparkSQL Kör en SparkSQL-fråga mot Spark-kontext.
%%csharp .NET för Spark C # Kör en .NET för Spark C# -fråga mot Spark-kontext.

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

Screenshot of Synapse spark magic commands

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 en tillfällig tabell refereras till mellan olika språk. Här är ett exempel på hur du läser en Scala DataFrame i PySpark och SparkSQL använder en temporär Spark-tabell som en lösning.

  1. I Cell 1 läser du en DataFrame från en SQL-poolanslutning med 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 spark-SQL.

    %%sql
    SELECT * FROM mydataframetable
    
  3. I Cell 3 använder du data i PySpark.

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

IntelliSense i IDE-format

Synapse-anteckningsböcker är integrerade med Monaco-redigeraren för att få IDE-stil IntelliSense till cellredigeraren. Syntaxmarkering, felmarkör och automatisk kodkomplettering hjälper dig att skriva kod och identifiera problem snabbare.

De IntelliSense funktionerna är på 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 Kodkomplettering av systemfunktion Kodkomplettering av användarfunktion Smarta indrag Koddelegering
PySpark (Python) Ja Ja Ja Ja Ja Ja Ja Ja
Spark (Scala) Ja Ja Ja Ja Ja Ja - Ja
SparkSQL Ja Ja Ja Ja Ja - - -
.NET för Spark (C#) Ja Ja Ja Ja Ja Ja Ja Ja

Anteckning

En aktiv Spark-session krävs för att gynna slutförandet av variabelkod, kodkomplettering av systemfunktion, kodkomplettering av användarfunktion för .NET för Spark (C#).

Kodfragment

Synapse-notebook-filer innehåller kodfragment som gör det enklare att ange vanliga kodmönster som används, till exempel att konfigurera Spark-sessionen, läsa data som en Spark DataFrame eller rita diagram med matplotlib osv.

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

Animated GIF of Synapse code snippets

Formatera textcell med knappar i verktygsfältet

Du kan använda formatknapparna i verktygsfältet för textceller för att utföra vanliga markdown-åtgärder. Den innehåller fet text, kursiv text, stycke/rubriker i en listruta, infogning av kod, infogning av osorterad lista, infogning av ordnad lista, infogning av hyperlänk och infogning av bild från URL.

Screenshot of Synapse text cell toolbar


Ångra/gör om cellåtgärd

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

Screenshot of Synapse undo cells of aznb

Stöd för att ångra cellåtgärder:

  • Infoga/ta bort cell: Du kan återkalla borttagningsåtgärderna genom att välja Ångra. Textinnehållet sparas tillsammans med cellen.
  • Ändra ordning på cellen.
  • Växla parameter.
  • Konvertera mellan kodcellen och Markdown-cellen.

Anteckning

Textåtgärder i cellen och kodcellskommenterande åtgärder kan inte ångras. Nu kan du ångra/göra om upp till de senaste 10 historiska cellåtgärderna.


Kodcellskommentande

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

    Screenshot of Synapse comment button

  2. Välj kod i kodcellen, klicka på Nytt i fönstret Kommentarer , lägg till kommentarer och klicka sedan på knappen Publicera kommentar för att spara.

    Screenshot of Synapse new comment

  3. Du kan utföra Redigera kommentar, Lös tråd eller Ta bort tråd genom att klicka på knappen Mer förutom kommentaren.

    Screenshot of Synapse edit comment


Flytta en cell

Klicka på vänster sida av en cell och dra den till önskad position. Animated GIF of Synapse move cells


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 kortkommandon i kommandoläge. Tryck på Skift+D för att ta bort den aktuella cellen.

Screenshot of azure-notebook-delete-a-cell


Dölj cellindata

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 väljer du Visa indata medan cellen är komprimerad.

Animated GIF of azure-notebook-collapse-cell-input


Dölj utdata från en cell

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

Animated GIF of azure-notebook-collapse-cell-output


Anteckningsboksdisposition

Dispositioner (innehållsförteckning) visar den första markdownrubriken i en markdowncell i ett sidofältsfönster för snabb navigering. Sidopanelen Dispositioner är storleksanpassad och komprimerbar så att den passar skärmen på bästa möjliga sätt. Du kan välja knappen Disposition i anteckningsbokens kommandofält för att öppna eller dölja sidofältet

Screenshot of azure-notebook-outline


Köra notebook-filer

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öra en cell

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

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

    Screenshot of run-cell-1

  2. Använd kortkommandon i kommandoläge. Tryck på Skift+Retur för att köra den aktuella cellen och markera cellen nedan. Tryck på Alt+Retur för att köra den aktuella cellen och infoga en ny cell nedan.


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.

Screenshot of run-all-cells

Kör alla celler ovanför eller under

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

Screenshot of azure-notebook-run-cells-above-or-below


Avbryt alla celler som körs

Välj knappen Avbryt alla för att avbryta de celler eller celler som körs i kön. Screenshot of azure-notebook-cancel-all-cells


Referens för notebook-fil

Du kan använda %run <notebook path> magiskt kommando för att referera till en annan notebook-fil i den aktuella notebook-filens kontext. Alla variabler som definierats i referensanteckningsboken är tillgängliga i den aktuella notebook-filen. %run magiskt kommando stöder kapslade anrop men stöder inte rekursiva anrop. Du får ett undantag om instruktionsdjupet är större än fem.

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

Referens för notebook-filer fungerar i både interaktivt läge och Synapse-pipeline.

Anteckning

  • %run kommandot stöder för närvarande endast att skicka en absolut sökväg eller notebook-namn som parameter. Relativ sökväg stöds inte.
  • %run kommandot stöder för närvarande endast till 4 parametervärdetyper: int, float, bool, string, variabel ersättningsåtgärd stöds inte.
  • De refererade notebook-filerna måste publiceras. Du måste publicera anteckningsböckerna för att referera till dem om inte Den avpublicerade referensanteckningsboken är aktiverad. Synapse Studio känner inte igen de opublicerade notebook-filerna från Git-lagringsplatsen.
  • Refererade notebook-filer stöder inte instruktioner om att djupet är större än fem.

Variabelutforskaren

Synapse Notebook innehåller en inbyggd variabelutforskare där du kan se en lista över variablernas namn, typ, längd och värde i den aktuella Spark-sessionen för PySpark-celler (Python). Fler variabler visas automatiskt när de definieras i kodcellerna. Om du klickar på varje kolumnrubrik sorteras variablerna i tabellen.

Du kan välja knappen Variabler i notebook-kommandofältet för att öppna eller dölja variabelutforskaren.

Screenshot of azure-notebook-variable-explorer

Anteckning

Variabelutforskaren stöder endast Python.


Cellstatusindikator

En steg-för-steg-cellkörningsstatus visas under cellen för att hjälpa dig att se dess aktuella förlopp. När cellkörningen är klar visas en körningssammanfattning med den totala varaktigheten och sluttiden och behålls där för framtida referens.

Screenshot of cell-status

Förloppsindikator för Spark

Synapse Notebook är helt Spark-baserad. Kodceller körs på den serverlösa Apache Spark-poolen via fjärranslutning. En förloppsindikator för Spark-jobb tillhandahålls med en förloppsindikator i realtid som hjälper dig att förstå jobbets körningsstatus. 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 steg) genom att välja länken för jobbets (eller fasens) namn.

Screenshot of spark-progress-indicator

Konfiguration av Spark-session

Du kan ange tidsgränsen, antalet och storleken på de utförare som ska tilldelas till den aktuella Spark-sessionen i Konfigurera sessionen. Starta om Spark-sessionen för att konfigurationsändringarna 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 Konfigurationshantering för Apache Spark.

Screenshot of session-management

Magiskt kommando för Spark-sessionskonfiguration

Du kan också ange inställningar för Spark-sessioner via ett magiskt kommando %%configure. Spark-sessionen måste startas om för att inställningarna ska gälla. Vi rekommenderar att du kör %%configure i början av anteckningsboken. Här är ett exempel som du hittar https://github.com/cloudera/livy#request-body i en fullständig lista över giltiga parametrar.

%%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 standard spark property, to find more available properties please visit:https://spark.apache.org/docs/latest/configuration.html#application-properties.
        "spark.driver.maxResultSize":"10g",
    //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" 
    }
}

Anteckning

  • "DriverMemory" och "ExecutorMemory" rekommenderas att ange samma värde i %%configure, så gör även "driverCores" och "executorCores".
  • Du kan använda %%configure i Synapse-pipelines, men om den inte anges i den första kodcellen misslyckas pipelinekörningen på grund av att sessionen inte kan startas om.
  • Den %%configure som används i mssparkutils.notebook.run kommer att ignoreras men används i %run notebook fortsätter att köras.
  • Spark-standardkonfigurationsegenskaperna måste användas i "konfigurationstexten". Vi stöder inte referens på första nivån för Spark-konfigurationsegenskaperna.
  • Vissa särskilda spark-egenskaper, inklusive "spark.driver.cores", "spark.executor.cores", "spark.driver.memory", "spark.executor.memory", "spark.executor.instances" börjar inte gälla i "conf"-brödtexten.

Parametriserad sessionskonfiguration från pipeline

Med parametriserad sessionskonfiguration kan du ersätta värdet i %%configure magic med pipelinekörningsparametrar (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:

{
      "activityParameterName": "paramterNameInPipelineNotebookActivity",
      "defaultValue": "defaultValueIfNoParamterFromPipelineNotebookActivity"
} 
%%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 en notebook-fil i interaktivt läge direkt eller om ingen parameter som matchar "activityParameterName" anges från Pipeline Notebook-aktiviteten.

Under pipelinekörningsläget kan du konfigurera aktivitetsinställningar för notebook-pipeline enligt nedan: Screenshot of parameterized session configuration

Om du vill ändra sessionskonfigurationen ska aktivitetsparametrar för pipelinen vara samma som activityParameterName i notebook-filen. När du kör den här pipelinen ersätts kärnor i %%configure i det här exemplet med 8 och livy.rsc.sql.num-rows ersätts med 4 000.

Anteckning

Om körningspipelinen misslyckades på grund av den här nya %%configure-magin kan du kontrollera mer felinformation genom att köra %%configure magic cell i det interaktiva läget för notebook-filen.

Hämta data till en notebook-fil

Du kan läsa in data från Azure Blob Storage, Azure Data Lake Store Gen 2 och SQL pool enligt kodexemplen nedan.

Läsa en CSV från Azure Data Lake Store 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 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 Blob 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. I Data Explorer högerklickar du på en fil och väljer Ny anteckningsbok för att se en ny notebook-fil med automatiskt genererad dataextraktor.

Screenshot of data-to-cell

IPython-widgetar

Widgetar är händelsekänsliga Python-objekt som har en representation i webbläsaren, ofta som en kontroll som ett skjutreglage, textruta osv. IPython Widgets fungerar bara i Python miljö, det stöds inte på andra språk (t.ex. Scala, SQL, C#) ännu.

Så här använder du IPython Widget

  1. Du måste importera ipywidgets modulen först för att använda Jupyter Widget-ramverket.

    import ipywidgets as widgets
    
  2. Du kan använda toppnivåfunktionen display för att återge en widget eller lämna ett uttryck av widgettyp på den sista raden i kodcellen.

    slider = widgets.IntSlider()
    display(slider)
    
    slider = widgets.IntSlider()
    slider
    
  3. Kör cellen. Widgeten visas i utdataområdet.

    Screenshot of ipython widgets slider

  4. 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)
    

    Screenshot of ipython widgets sliders

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

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

Widgetar som stöds

Typ av widgetar Widgets
Numeriska widgetar IntSlider, FloatSlider, FloatLogSlider, IntRangeSlider, FloatRangeSlider, IntProgress, FloatProgress, BoundedIntText, BoundedFloatText, IntText, FloatText
Booleska widgetar ToggleButton, Checkbox, Valid
Markeringswidgetar Listruta, RadioButtons, Select, SelectionSlider, SelectionRangeSlider, ToggleButtons, SelectMultiple
Strängwidgetar Text, Textområde, Kombinationsruta, Lösenord, Etikett, HTML, HTML Math, Bild, Knapp
Spela upp widgetar (animering) Datumväljare, Färgväljare, Styrenhet
Container-/layoutwidgetar Box, HBox, VBox, GridBox, Dragspel, Flikar, Staplad

Kända begränsningar

  1. Följande widgetar stöds inte ännu. Du kan följa motsvarande lösning enligt nedan:

    Funktioner Lösning
    Output Widget 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 Widget Inte stöd ännu.
  2. Den globala display funktionen som tillhandahålls av Synapse stöder inte visning av flera widgetar i 1-anrop (dvs. display(a, b)), som skiljer sig från IPython-funktionen display .

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


Spara notebook-filer

Du kan spara en enskild anteckningsbok eller alla notebook-filer på din arbetsyta.

  1. Om du vill spara ändringar som du har gjort i en enskild anteckningsbok väljer du knappen Publicera i anteckningsbokens kommandofält.

    Screenshot of publish-notebook

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

    Screenshot of publish-all

I notebook-egenskaperna kan du konfigurera om cellutdata ska inkluderas när du sparar.

Screenshot of notebook-properties

Magiska kommandon

Du kan använda välbekanta Jupyter Magic-kommandon i Synapse Notebooks. Granska följande lista som de aktuella tillgängliga magiska kommandona. Berätta om dina användningsfall på GitHub så att vi kan fortsätta att bygga ut fler magiska kommandon för att uppfylla dina behov.

Anteckning

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

Tillgängliga linjefunktioner: %lsmagic, %time, %timeit, %history, %run, %load

Tillgängliga cellfunktioner: %%time, %%timeit, %%capture, %%writefile, %%sql, %%pyspark, %%spark, %%csharp, %%html, %%configure


Referens för opublicerad notebook-fil

En avpublicerad referensanteckningsbok är användbar när du vill felsöka "lokalt". När du aktiverar den här funktionen hämtar notebook-körningen det aktuella innehållet i webbcachen. Om du kör en cell med en referensanteckningsboksinstruktor refererar du till presentationsanteckningsböckerna i den aktuella notebook-webbläsaren i stället för en sparad version i klustret, vilket innebär att ändringarna i notebook-redigeraren kan refereras direkt av andra anteckningsböcker utan att behöva publiceras (Live-läge) genom att använda den här metoden kan du enkelt undvika att vanliga bibliotek blir förorenade under utveckling eller felsökning.

Du kan aktivera en avpublicerad referensanteckningsbok från panelen Egenskaper:

Screenshot of notebook-reference

Jämförelse av olika ärenden finns i tabellen nedan:

Observera att %run och mssparkutils.notebook.run har samma beteende här. Vi använder %run här som exempel.

Ärende 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 (ej publicerad, engagerad)
%run Nb1
Fel Kör checkat Nb1
- Nb1 (tidigare publicerad, incheckad)
%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 checkad, redigerad)
%run Nb1
Fel Kör redigerad version av Nb1
– Nb1 (tidigare publicerad och engagerad, redigerad)
%run Nb1
Kör publicerad version av Nb1 Kör redigerad version av Nb1

Slutsats

  • Om den är inaktiverad kör du alltid publicerad version.
  • Om aktiverad är prioritet: redigerad/ny > incheckad > publicerad.

Aktiv sessionshantering

Du kan återanvända dina notebook-sessioner på ett bekvämt sätt nu utan att behöva starta nya. Synapse Notebook stöder nu hantering av aktiva sessioner i listan Hantera sessioner . Du kan se alla sessioner i den aktuella arbetsytan som du har startat från notebook-filen.

Screenshot of notebook-manage-sessions

I listan Aktiva sessioner kan du se sessionsinformationen och motsvarande notebook-fil som för närvarande är kopplad till sessionen. Du kan använda Koppla från med notebook-fil, Stoppa sessionen och Visa i övervakning härifrån. Dessutom kan du enkelt ansluta den valda anteckningsboken till en aktiv session i listan som startats från en annan anteckningsbok. Sessionen kopplas från den tidigare anteckningsboken (om den inte är inaktiv) och ansluts sedan till den aktuella.

Screenshot of notebook-sessions-list

Python loggning i Notebook

Du hittar Python loggar och anger olika loggnivåer och format enligt exempelkoden nedan:

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

Integrera en notebook-fil

Lägga till en notebook-fil i en pipeline

Välj knappen Lägg till i pipeline i det övre högra hörnet för att lägga till en notebook-fil i en befintlig pipeline eller skapa en ny pipeline.

Screenshot of Add notebook to pipeline

Ange en parametercell

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

Screenshot of azure-notebook-toggle-parameter


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

Tilldela parametervä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 aktiviteten Synapse Notebook. När du har lagt till aktiviteten i pipelinearbetsytan kan du ange parametrarnas värden under avsnittet Basparametrarfliken Inställningar.

Screenshot of Assign a parameter

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

Kortkommandon

Liksom 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-notebook-filer stöder följande två lägen för en viss kodcell: kommandoläge och redigeringsläge.

  1. 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 i enskilda celler. Ange kommandoläge genom att trycka ESC eller använda musen för att välja utanför en cells redigeringsområde.

    Screenshot of command-mode

  2. Redigeringsläget indikeras av 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 Enter eller använda musen för att markera i en cells redigeringsområde.

    Screenshot of edit-mode

Genvägsnycklar under kommandoläge

Åtgärd Genvägar 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+Retur
Markera cellen ovan Upp
Markera cellen nedan Ned
Markera föregående cell K
Markera nästa cell J
Infoga cell ovanför A
Infoga cell nedan B
Ta bort markerade celler Skift+D
Växla till redigeringsläge Ange

Genvägsnycklar under redigeringsläge

Med följande genvägar för tangenttryckning kan du enklare navigera och köra kod i Synapse-notebook-filer när du är i redigeringsläge.

Åtgärd Genvägar 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 + backsteg
Ta bort ord efter Ctrl + Ta bort
Gå till cellstart Ctrl + Start
Gå till cellens slut Ctrl + slut
Gå ett ord till vänster Ctrl + vänster
Gå ett ord åt höger Ctrl + höger
Välj alla Ctrl + A
Strecksatsen Ctrl +]
Dedent Ctrl + [
Växla till kommandoläge Esc

Nästa steg