Bruk Python-erfaring i notatbøker

Python-notatboken er en ny opplevelse bygget oppå notatbøker i Fabric. Det er et allsidig og interaktivt verktøy designet for dataanalyse, visualisering og maskinlæring. Det gir en sømløs utviklingsopplevelse for skriving og kjøring av Python-kode. Denne funksjonen gjør det til et viktig verktøy for dataforskere, analytikere og BI-utviklere, spesielt for utforskningsoppgaver som ikke krever store data og distribuert databehandling.

Ved å bruke en Python-notatbok får du:

• Flere innebygde Python-kjerner: Python-notatbøker tilbyr et rent Python-kodemiljø uten Spark, med tre innebygde Python-kjerneversjoner: Python 3.10, Python 3.11 og Python 3.12. Miljøet støtter native IPython-funksjoner som iPyWidget og magic-kommandoer.

• Kostnadseffektiv: Den nye Python-notatblokken gir kostnadsbesparende fordeler ved å kjøre på en enkelt nodeklynge med 2 vCores/16 GB minne som standard. Dette oppsettet sikrer effektiv ressursutnyttelse for datautforskningsprosjekter med mindre datastørrelse.

• Lakehouse og ressurser er tilgjengelige som native: Fabric Lakehouse sammen med innebygde ressurser i notatboken er tilgjengelig i Python notebook. Denne funksjonen gjør det enkelt for brukere å hente dataene til Python Notebook, bare prøv å dra og slipp for å få kodesnippet.

• Bland programmering med T-SQL: Python notebook tilbyr en enkel måte å samhandle med datalager og SQL-analyse-endepunkter i utforskeren. Ved å bruke notebookutils data connector kan du enkelt kjøre T-SQL-skriptene under kontekst av Python.

• Støtte for populære dataanalytiske biblioteker: Python-notatbøker leveres med forhåndsinstallerte biblioteker som DuckDB, Polars og Scikit-learn, som gir et omfattende verktøysett for databehandling, analyse og maskinlæring.

• Advanced IntelliSense: Python notebook tar i bruk Pylance som IntelliSense-motor, sammen med andre tilpassede Fabric-språktjenester, med mål om å gi toppmoderne kodeerfaring for notatbokutviklere.

• NotebookUtils og semantisk lenke: Kraftige API-verktøysett gjør det enkelt å bruke Fabric- og Power BI-funksjoner med kode-først-erfaring.

• Rike visualiseringsmuligheter: Bortsett fra de populære rike dataframe-forhåndsvisningsfunksjonene 'Table' og 'Chart'-funksjonen, støtter den også populære visualiseringsbiblioteker som Matplotlib, Seaborn og Plotly. PowerBIClient støtter også disse bibliotekene for å hjelpe brukerne med å forstå datamønstre og innsikter bedre.

• Vanlige funksjoner for Fabric Notebook: Alle funksjonene på notatboknivå er naturlig anvendelige for Python-notatbøker, som redigeringsfunksjoner, AutoSave, samarbeid, deling og tillatelseshåndtering, Git-integrasjon, import/eksport og mer.

• Full stack Data Science Capabilities: Den avanserte lavkodede verktøysettet Data Wrangler, maskinlæringsrammeverket MLFlow og kraftig Copilot er alle tilgjengelige på Python-notatblokken.

Hvordan få tilgang til en Python-notatbok

Etter å ha åpnet en notatbok i Fabric, kan du bytte til Python i språkmenyen under Hjem-fanen og konvertere hele notatbokoppsettet til Python.

De fleste av de vanlige funksjonene støttes på notatboknivå. For å lære mer, se Hvordan du bruker Fabric-notatbøker og utvikler, utfører og administrerer Fabric-notatbøker. Denne artikkelen lister opp noen nøkkelfunksjoner spesifikke for Python-scenarier.

Kjør Python-notatblokker

Python-notatbøker støtter flere metoder for jobbutførelse:

• Interaktiv kjøring: Du kan kjøre en Python-notatblokk interaktivt som en opprinnelig Jupyter-notatblokk.
• Planlegg kjøring: Du kan bruke den lette scheduler-opplevelsen på notatbokinnstillingssiden til å kjøre en Python-notatbok som en batchjobb.
• Pipelinekjøring: Du kan orkestrere Python-notatblokker som notatblokkaktiviteter i pipeline. Prosessen genererer et øyeblikksbilde etter jobbkjøringen.
• Referansekjøring: Du kan bruke notebookutils.notebook.run() eller notebookutils.notebook.runMultiple() referere til kjørte Python-notatblokker i en annen Python-notatblokk som satsvis jobb. Prosessen genererer et øyeblikksbilde etter at referansekjøringen er ferdig.
• %run: Du kan bruke %run dem til å referere til og kjøre andre notatbøker innenfor samme utførelseskontekst, så du kan direkte kalle funksjoner og gjenbruke variabler definert i disse notatbøkene. For mer informasjon, se dokumentasjonen om hvordan man refererer til å kjøre en notatbok.
• Offentlig API-kjøring: Du kan planlegge Python-notebook-kjøringen din med notebook run public API. Job Scheduler API-et støtter parameteriserte kjøringer og retur av avslutningsverdier fra notatbokkjøringer. Exit-verdier kan brukes til betinget orkestrering og signaleringsresultater når man orkestrerer Python-notatbøker i automatisering og CI/CD-scenarier. Sørg for at språket og kjerneegenskapene i notatbokens metadata for den offentlige API-payloaden er satt riktig. Parameterverdier som sendes via det offentlige API-et er tilgjengelige for Python-notatboken under kjøring ved bruk av standard parametertilgangsmønster som brukes i Fabric-notatbøker. For detaljer om forespørselsformen for parametere og henting av exit-verdier, se Administrer og kjør notatbøker i Fabric with APIs. Du kan overvåke kjørestatus og avbryte jobbinstanser via Job Scheduler API, som utfyller in-UI View all runs-opplevelsen .

Note

Service principal-autentisering støttes for Items REST API (CRUD for notebooks) og Job Scheduler API (kjøring), noe som muliggjør sikker ubevoktet automatisering og CI/CD for Python-notatbøker. Legg til tjenesteprincipalen i arbeidsområdet med en passende rolle for å bruke disse API-ene.

Du kan overvåke kjøredetaljene for Python-notatblokkjobben på båndfanen Kjør –>Vis alle kjøringer.

Note

For øyeblikket støtter det %run kun referanse til notatbøker på Python notatbøker, ikke kodemoduler (som .py filer) fra mappen notatbokressurser.

Samhandling med data

Du kan samhandle med lakehouse, lagerbygninger, SQL-analyseendepunkter og innebygde ressursmapper i Python-notatbøker.

Note

Python notebook-runtime leveres forhåndsinstallert med delta-rs og duckdb-biblioteker for å støtte både lesing og skriving av Delta Lake-data. Noen funksjoner i Delta Lake er imidlertid kanskje ikke fullt støttet. For flere detaljer og de siste oppdateringene, se delta-rs og DuckDB-dokumentasjonen .

Lakehouse-interaksjon

Du kan sette et innsjøhus som standard, eller du kan også legge til flere innsjøhus for å utforske og bruke dem i notatbøker.

Hvis du ikke er kjent med å lese dataobjekter som Delta-tabellen, prøv å dra og slippe filen og Delta-tabellen til notatbokens lerret, eller bruk alternativet Last inn data i objektets nedtrekksmeny. Notatboken setter automatisk inn et kodeutdrag i en kodecelle og genererer kode for å lese målobjektet.

Note

Hvis du møter OOM når du laster inn store datamengder, prøv å bruke DuckDB, Polars eller PyArrow dataframe i stedet for pandas.

Du finner write lakehouse-operasjonen i Browse code snippet ->Write data to Delta-tabellen.

Lagerinteraksjon og mix-programmering med T-SQL

Du kan legge til varehus eller SQL-analyseendepunkter fra Warehouse-utforskeren i notatboken. På samme måte kan du dra og slippe tabellene i notatblokklerretet, eller bruke snarveisoperasjonene i rullegardinmenyen for tabeller. Notatboken genererer automatisk et kodeutdrag for deg. Du kan bruke notebookutils.data verktøy for å etablere en forbindelse med varehus og spørre dataene ved hjelp av T-SQL-setninger i konteksten av Python.

Note

SQL-analyseendepunkter er skrivebeskyttet.

Mappe for notatblokkressurser

Den innebygde mappen for ressurser i Notebook er tilgjengelig direkte på Python-notatbøker. Du kan enkelt samhandle med filene i den innebygde ressursmappen ved å bruke Python-kode som om du jobber med ditt lokale filsystem. For øyeblikket støttes ikke Environment-ressursmappen.

Kjerne operasjoner

Python-notatbøker støtter tre innebygde kjerner: Python 3.10, Python 3.11 og Python 3.12. Den standard valgte kjernen er Python 3.12. Du kan enkelt bytte mellom dem.

Du kan avbryte, starte på nytt eller bytte kjernen på Hjem-fanen på båndet. Å avbryte kjernen i Python-notatbøker er det samme som å kansellere en celle i Spark-notatbok.

En unormal kjerneavslutning fører til at kodeutførelsen avbrytes og variabler går tapt, men det stopper ikke notatbokøkten.

Noen kommandoer kan føre til at kjernen dør. For eksempel, quit() og exit().

For støttelivssyklusen til hver Python-kjerne-versjon, inkludert sluttdatoer og migreringssteg, se Python notebook runtime og kernel lifecycle in Fabric.

Administrasjon av biblioteket

Bruk kommandoene%pip og %conda for inline-installasjoner. Disse kommandoene støtter både offentlige biblioteker og tilpassede biblioteker.

For tilpassede biblioteker, last opp bibliotekfilene til mappen Innebygde ressurser . Plattformen støtter flere typer biblioteker, inkludert formater som Wheel (.whl), JAR (.jar), DLL (.dll) og Python (.py). Bare dra og slipp filen, så genereres kodesnippeten automatisk.

Du må kanskje starte kjernen på nytt for å bruke de oppdaterte pakkene.

For å bedre forstå og bruke lignende kommandoer, se tabellen nedenfor.

Command/Syntax	Hovedformålet	Slik fungerer det i Jupyter Notebook	Vanlig brukstilfelle	Notes
%pip install package	Installer Python-pakker	Kjører pip i notatbokens Python-kjerne	Anbefalt måte å installere pakker på	I Python-notatbøker er det samme som !pip; starter ikke kjernen automatisk på nytt
!pip install package	Installer Python-pakker via skall	Kjører pip som en skallkommando	Alternativ måte å installere pakker på	I Python-notatbøker er det samme som %pip; starter ikke kjernen automatisk på nytt
import sys; sys.exit(0)	Start notatblokkkjernen på nytt	Starter kjernen på nytt umiddelbart	Start kjernen på nytt programmatisk	Sletter alle variabler og tilstander; anbefales ikke å bruke direkte
notebookutils.session.restartPython()	Start notatblokkkjernen på nytt	Samtaler sys.exit(0) internt	Anbefalt måte å starte kjernen på nytt	Offisiell API, sikrere og mer kompatibel enn å bruke sys.exit(0) direkte

Note

• I Python-notatbøker %pip har de !pipsamme oppførsel: begge installerer pakker i det nåværende kjernemiljøet, og ingen starter kjernen automatisk på nytt etter installasjon.
• Hvis du må starte kjernen på nytt (for eksempel etter installasjon av visse pakker), bruk notebookutils.session.restartPython() i stedet for import sys; sys.exit(0).
  • notebookutils.session.restartPython() er et offisielt API som wrapper sys.exit(0) , og det er tryggere og mer kompatibelt i notatbøker.
• Ikke bruk sys.exit(0) direkte med mindre det er nødvendig.

Overvåking av ressursbruk i sanntid for Python-notatblokken

Viktig!

Denne funksjonen er i forhåndsvisning.

Ved å bruke ressursovervåkningspanelet kan du spore kritisk kjøretidsinformasjon som sesjonsvarighet, beregningstype og sanntids ressursmålinger, inkludert CPU- og minneforbruk, direkte i notatboken din. Denne funksjonen gir en umiddelbar oversikt over den aktive økten og ressursene som brukes.

Ressursmonitoren forbedrer synligheten i hvordan Python-arbeidsbelastninger bruker systemressurser. Det hjelper deg med å optimalisere ytelsen, administrere kostnader og redusere risikoen for OOM-feil (tom-minne). Ved å overvåke måledata i sanntid kan du identifisere ressurskrevende operasjoner, analysere bruksmønstre og ta informerte beslutninger om skalering eller endring av kode.

For å begynne å bruke den, sett notatblokkspråket til Python og start en økt. Du kan deretter åpne skjermen ved å klikke databehandlingsressursene på statuslinjen i notatblokken eller ved å velge Vis ressursbruk på verktøylinjen. Ressursmonitorpanelet vises automatisk, og gir en integrert overvåkingsopplevelse for Python-kode i Fabric-notatbøker.

Magisk kommando for øktkonfigurasjon

På samme måte som å tilpasse en Spark-sesjonskonfigurasjon i en notatbok, kan du også bruke %%configure i en Python notatbok. Python-notatbøker støtter tilpasning av beregningsnodestørrelse, monteringspunkter og standard lakehouse for notatblokkøkten. Du kan bruke disse innstillingene både i interaktive notatbøker og i pipeline-notatbøker. Bruk kommandoen %%configure i starten av notatboken din, ellers må du starte notatbokøkten på nytt for at innstillingene skal tre i kraft.

Her er de støttede egenskapene i Python-notatblokken %%configure:

%%configure -f
{
    "vCores": 4, // Recommended values: [4, 8, 16, 32, 64], Fabric will allocate matched memory according to the specified vCores.
    "defaultLakehouse": {  
        // Will 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>"
        },
    ],
}

Du kan se oppdateringen av beregningsressursene på statuslinjen til notatboken, og overvåke CPU- og minnebruken til beregningsnoden i sanntid.

Note

API-utløste kjører for sesjonskonfigurasjon som compute vCores og defaultLakehouse spesifisert via notatbokmetadata eller %%configure. Jobbplanlegger-API-et støtter også valg av målinnsjøhus og miljø under kjøring. For detaljer om payload-feltene, se Administrer og kjør notatbøker i Fabric with APIs.

NotebookUtils

Notebook Utilities (NotebookUtils) er en innebygd pakke som hjelper deg enkelt å utføre vanlige oppgaver i Fabric notebook. Det er forhåndsinstallert på Python-runtime. Bruk NotebookUtils for å jobbe med filsystemer, hente miljøvariabler, lenke notatbøker sammen, få tilgang til ekstern lagring og jobbe med hemmeligheter.

Bruk notebookutils.help() det til å liste opp tilgjengelige API-er og få hjelp med metoder. For mer informasjon, se NotebookUtils-dokumentasjonen.

Dataverktøy

Note

For øyeblikket er funksjonen i forhåndsvisning.

Bruk verktøyene notebookutils.data for å koble til en datakilde. Deretter kan du lese og spørre data ved å bruke en T-SQL-setning.

Kjør følgende kommando for å få en oversikt over de tilgjengelige metodene:

notebookutils.data.help()

Output:

Help on module notebookutils.data in notebookutils:

NAME
    notebookutils.data - Utility for read/query data from connected data sources in Fabric

FUNCTIONS
    connect_to_artifact(artifact: str, workspace: str = '', artifact_type: str = '', **kwargs)
        Establishes and returns an ODBC connection to a specified artifact within a workspace 
        for subsequent data queries using T-SQL.
        
        :param artifact: The name or ID of the artifact to connect to.
        :param workspace:  Optional; The workspace in which the provided artifact is located, if not provided,
                             use the workspace where the current notebook is located.
        :param artifactType: Optional; The type of the artifact, Currently supported type are Lakehouse, Warehouse and MirroredDatabase. 
                                If not provided, the method will try to determine the type automatically.
        :param **kwargs Optional: Additional optional configuration. Supported keys include:
            - tds_endpoint : Allow user to specify a custom TDS endpoint to use for connection.
        :return: A connection object to the specified artifact.
        
        :raises UnsupportedArtifactException: If the specified artifact type is not supported to connect.
        :raises ArtifactNotFoundException: If the specified artifact is not found within the workspace.
        
        Examples:
            sql_query = "SELECT DB_NAME()"
            with notebookutils.data.connect_to_artifact("ARTIFACT_NAME_OR_ID", "WORKSPACE_ID", "ARTIFACT_TYPE") as conn:
                df = conn.query(sql_query)
                display(df)
    
    help(method_name: str = '') -> None
        Provides help for the notebookutils.data module or the specified method.
        
        Examples:
        notebookutils.data.help()
        notebookutils.data.help("connect_to_artifact")
        :param method_name: The name of the method to get help with.

DATA
    __all__ = ['help', 'connect_to_artifact']

FILE
    /home/trusted-service-user/jupyter-env/python3.10/lib/python3.10/site-packages/notebookutils/data.py

Spørringsdata fra Lakehouse

conn = notebookutils.data.connect_to_artifact("lakehouse_name_or_id", "optional_workspace_id", "optional_lakehouse_type")
df = conn.query("SELECT * FROM sys.schemas;")

Spørringsdata fra Lager

conn = notebookutils.data.connect_to_artifact("warehouse_name_or_id", "optional_workspace_id", "optional_warehouse_type")
df = conn.query("SELECT * FROM sys.schemas;")

Søk data fra SQL-database

conn = notebookutils.data.connect_to_artifact("sqldb_name_or_id", "optional_workspace_id", "optional_sqldatabase_type") 
df = conn.query("SELECT * FROM sys.schemas;")

Note

Dataverktøyene i NotebookUtils er foreløpig kun tilgjengelige på Python-notatbøker.

Bla gjennom kodesnutter

Du kan finne nyttige Python-kodesnippets under Rediger-fanen ved å velge Browse code snippet. Nye Python-eksempler er nå tilgjengelige. For å begynne å utforske notatboken, lær fra Python-kodesnippets.

Semantisk kobling

Semantisk kobling er en funksjon du kan bruke for å koble semantiske modeller og Synapse Data Science. Python-notatbøker støtter denne funksjonen nativt. BI-ingeniører og Power BI-utviklere kan bruke semantic link for å koble sammen og administrere semantiske modeller enkelt. For å lære mer, se det offentlige dokumentet.

Visualization

I tillegg til å tegne diagrammer med biblioteker, lar den innebygde visualiseringsfunksjonen deg gjøre DataFrames om til datavisualiseringer i rikt format. Bruk display() -funksjonen på dataframes for å lage rik dataframe-tabellvisning og diagramvisning.

Note

Python-notatboken lagrer diagramkonfigurasjonene. Etter å ha kjørt kodecellen på nytt, hvis måldatarammeskjemaet ikke endres, forblir de lagrede diagrammene.

Code IntelliSense

Python-notatbøker bruker også Pylance som språkserver. For mer informasjon, se Enhance Python development with Pylance.

Datavitenskapsfunksjoner

For å lære mer om data science og AI-erfaringer i Fabric, se Data Science-dokumentasjon i Fabric. Denne artikkelen lister opp noen viktige data science-funksjoner som Python-notatbøker støtter nativt.

• Data Wrangler: Data Wrangler er et verktøy basert på notatbøker som gir et oppslukende grensesnitt for utforskende dataanalyse. Denne funksjonen kombinerer en rutenettlignende datavisning med dynamisk sammendragsstatistikk, innebygde visualiseringer og et bibliotek med vanlige datarengjøringsoperasjoner. Den tilbyr datarensing, datatransformasjon og integrasjon, som akselererer datapreparering ved bruk av Data Wrangler.

• MLflow: Et maskinlæringseksperiment er den primære enheten for organisering og kontroll for alle relaterte maskinlæringskjøringer. En kjøring tilsvarer en enkelt kjøring av modellkode.

• Fabric Auto Logging: Synapse Data Science inkluderer autologging, som betydelig reduserer mengden kode som kreves for automatisk å logge parametere, metrikker og elementer i en maskinlæringsmodell under trening.

  Autologging utvider MLflow-sporingsfunksjoner. Autologging kan registrere ulike måledata, inkludert nøyaktighet, tap, F1-poengsum og egendefinerte måledata du definerer. Ved å bruke autologging kan utviklere og dataforskere enkelt spore og sammenligne ytelsen til ulike modeller og eksperimenter uten manuell sporing.

• Copilot: Copilot for Data Engineering og Data Science-notatbøker er en AI-assistent som hjelper deg med å analysere og visualisere data. Copilot er umiddelbart kontekstbevisst uten at du må starte en økt. Den forstår arbeidsområdet, tilknyttede Lakehouse-skjemaer, tabeller og filer, notatbokstrukturen og kjøretidstilstanden, og kan operere på tvers av hele notatblokkens arbeidsflyt.

  Copilot støtter flerstegsfunksjoner for hele notatboken: den kan generere, refaktorere, oppsummere og validere kode på tvers av flere celler og trinn i Python-notatbøker. Du kan bruke Copilot chat-panelet og chat-kommandoer som /fix i notatboken.

  Når en celle feiler, viser Fix with Copilot en feiloppsummering, rotårsaksanalyse og anbefalte rettelser, med et alternativ for automatisk å anvende kodeendringer etter å ha vist en godkjenningsforskjell. Du kan også bruke kommandoen /fix i Copilot-chatten for målrettede diagnoser på en spesifikk celle eller hele notatboken.

Kjente begrensninger

• Live pool-opplevelsen er ikke garantert for hver Python-notebook-kjøring. Starten på økten kan ta opptil tre minutter hvis notatboken ikke når live poolen. Etter hvert som bruken av Python-notatbøker øker, øker intelligente poolingmetoder gradvis live pool-allokeringen for å møte etterspørselen.

• Miljøintegrasjon er ikke tilgjengelig på Python-notatbøker.

• Timeout for en bestemt økt er ikke tilgjengelig.

• Copilot har forbedret kontekstforståelse og hjelp for Python-notatbøker, men kan av og til foreslå Spark-kode som ikke er direkte kjørbar i en Python-notatbok. Løsningen med Copilot-erfaringen gjelder for mislykkede Python-celler; Spark-jobbdiagnostikk er utenfor rammen for rene Python-kjøringer.

• For øyeblikket støttes ikke Copilot på Python-notatbøker fullt ut i flere regioner. Utrullingsprosessen pågår fortsatt. Følg med etter hvert som støtten rulles ut i flere regioner.

Relatert innhold

• Hvordan bruke Fabric-notatbøker
• Utvikle, gjennomføre og administrere Fabric-notatbøker
• innføring av Fabric NotebookUtils