Använda Python-upplevelsen i Notebook

Python Notebook är en ny upplevelse som bygger på Fabric Notebook. Det är ett mångsidigt och interaktivt verktyg utformat för dataanalys, visualisering och maskininlärning. Det ger en smidig utveckling för att skriva och köra Python-kod. Den här funktionen gör den till ett viktigt verktyg för dataforskare, analytiker och BI-utvecklare, särskilt för utforskningsuppgifter som inte kräver stordata och distribuerad databehandling.

Genom att använda en Python-notebook får du:

• Flera inbyggda Python-kärnor: Python-notebooks erbjuder en ren Python-kodningsmiljö utan Spark, med tre inbyggda Python-kärnversioner: Python 3.10, Python 3.11 och Python 3.12. Miljön stödjer inbyggda IPython-funktioner som iPyWidget och magic-kommandon.

• Kostnadseffektiv: Den nya Python-notebooken erbjuder kostnadsbesparande fördelar genom att köras på ett kluster med en enkel nod med 2vCores/16GB minne som standard. Den här konfigurationen säkerställer effektiv resursanvändning för datautforskningsprojekt med mindre datastorlek.

• Lakehouse och resurser finns inbyggt tillgängliga: Fabric Lakehouse tillsammans med den fullständiga funktionaliteten för Notebooks inbyggda resurser finns tillgängliga i Python-notebook. Denna funktion gör det enkelt för användare att ta med data till Python notebook, försök bara dra och släpp för att få kodutsnittet.

• Blanda programmering med T-SQL: En Python-anteckningsbok erbjuder ett enkelt sätt att interagera med Data Warehouse och SQL-analys-slutpunkter i utforskaren. Genom att använda notebookutils data connector kan du enkelt köra T-SQL-skripten under Python-kontext.

• Stöd för populära dataanalytiska bibliotek: Python-notebooks levereras med förinstallerade bibliotek som DuckDB, Polars och Scikit-learn, vilket ger en omfattande verktygslåda för datamanipulation, analys och maskininlärning.

• Advanced IntelliSense: Python notebook använder Pylance som IntelliSense-motor, tillsammans med andra anpassade Fabric-språktjänster, med målet att ge avancerad kodningserfarenhet för notebookutvecklare.

• NotebookUtils och Semantic link: Kraftfulla API-verktyg gör det enkelt för dig att använda funktionerna i Fabric och Power BI med ett kodfokuserat arbetssätt.

• Rik visualiseringsfunktion: Förutom den populära förhandsvisningen av 'Table' och 'Chart'-funktionen för rik dataram, stödjer den även populära visualiseringsbibliotek som Matplotlib, Seaborn och Plotly. PowerBIClient stöder också dessa bibliotek för att hjälpa användarna att bättre förstå datamönster och insikter.

• Vanliga funktioner för Fabric Notebook: Alla funktioner på Notebook-nivå är naturligt tillämpliga för Python-notebook, såsom redigeringsfunktioner, AutoSave, samarbete, delning och behörighetshantering, Git-integration, import/export och mer.

• Data Science-funktioner i full stack: Den avancerade verktygslådan Data Wrangler med låg kod, maskininlärningsramverket MLFlow och kraftfulla Copilot är alla tillgängliga i Python Notebook.

Så här kommer du åt Python Notebook

Efter att ha öppnat en Fabric Notebook kan du byta till Python i språkmenyn under fliken Hem och konvertera hela anteckningsboksuppsättningen till Python.

De flesta vanliga funktioner stöds på anteckningsboksnivå. För att lära dig mer, se Hur du använder Microsoft Fabric-bärbara datorer och utvecklar, utför och hanterar Microsoft Fabric-bärbara datorer. Den här artikeln listar några viktiga funktioner som är specifika för Python-scenarier.

Kör Python-notebooks

Python-notebooks stöder flera metoder för jobbexekvering:

• Interaktiv körning: Du kan köra en Python-anteckningsbok interaktivt som en inbyggd Jupyter-anteckningsbok.
• Schemalagd körning: Du kan använda det förenklade schemaläggningsgränssnittet på sidan med notebookinställningar för att köra en Python-notebook som ett batchjobb.
• Pipelinekörning: Du kan orkestrera Python-notebook-filer som notebook-aktiviteter i Pipeline. Processen genererar en ögonblicksbild efter att jobbet körts.
• Referenskörning: Du kan använda notebookutils.notebook.run() eller notebookutils.notebook.runMultiple() för att köra Python-notebook-filer som ett batchjobb i en annan Python-notebook-fil. Processen genererar en ögonblicksbild efter att referenskörningen är klar.
• %run: Du kan använda %run för att referera till och köra andra anteckningsböcker inom samma exekveringskontext, så du kan direkt anropa funktioner och återanvända variabler som definierats i dessa anteckningsböcker. Mer information finns i dokumentationen om hur du refererar till att köra en notebook.
• Offentlig API-körning: Du kan schemalägga körningen av en Python-notebook med det offentliga API för körning av notebookar. Job Scheduler-API:et stöder parametriserade körningar och returnerar slutvärden från notebook-körningar. Utgångsvärden kan användas för villkorsstyrd orkestrering och signaleringsresultat vid orkestrering av Python-notebook-filer i automations- och CI/CD-scenarier. Kontrollera att språk- och kernelegenskaperna i notebook-metadata för den offentliga API-nyttolasten har angetts korrekt. Parametervärden som skickas via det publika API:et är tillgängliga för Python-notebooken vid körtid med hjälp av det standardiserade åtkomstmönstret för parametrar som används i Fabric-notebooks. Mer information om begärandeformen för parametrar och hämtning av slutvärde finns i Hantera och köra notebook-filer i Infrastruktur med API:er. Du kan övervaka körningsstatus och avbryta jobbinstanser via Job Scheduler-API:et, vilket kompletterar upplevelsen "Visa alla körningar" i gränssnittet.

Notera

Autentisering med tjänstehuvudnamn stöds för Items REST API (CRUD för anteckningsböcker) och Job Scheduler API (exekvering), vilket möjliggör säker och obevakad automatisering samt CI/CD för Python-anteckningsböcker. Lägg till tjänstens huvudnamn på arbetsytan med en lämplig roll för att använda dessa API:er.

Du kan övervaka detaljerna för körningen av Python-notebook-jobbet på menyfliksfliken Kör ->Visa alla körningar.

Notera

För närvarande har %run endast stöd för att referera till notebookobjekt i Python-anteckningsböcker, inte kodmoduler (till exempel .py-filer) från notebookens resursmapp.

Datainteraktion

Du kan interagera med Lakehouse, Warehouses, SQL-analysändpunkter och inbyggda resursmappar i en Python-anteckningsbok.

Notera

Python Notebook-runtimen levereras förinstallerad med delta-rs och duckdb-bibliotek för att stödja både läsning och skrivning av Delta Lake-data. Dock kanske vissa funktioner i Delta Lake inte är fullt stödda. För mer information och de senaste uppdateringarna, se delta-rs och DuckDB-dokumentationen .

Lakehouse-interaktion

Du kan ange en Lakehouse som standard, eller så kan du också lägga till flera Lakehouses för att utforska och använda dem i notebook-filer.

Om du inte vet hur man läser dataobjekt som Delta-tabell, kan du prova att dra och släppa filen och Delta-tabellen till anteckningsytan i notebooken, eller använda alternativet Ladda data i objektets rullgardinsmeny. Anteckningsboken infogar automatiskt en kodbit i en kodcell och genererar kod för att läsa målobjektet.

Notera

Om du stöter på OOM när du laddar in en stor datavolym, prova att använda DuckDB, Polars eller PyArrow dataframe istället för pandas.

Du hittar åtgärden skriv Lakehouse i Bläddra i kodsnutt –>skriv data till deltatablell.

Interaktion med lager och kombinering av programmering med T-SQL

Du kan lägga till lager eller SQL-analysslutpunkter från Warehouse Explorer i Notebook. På samma sätt kan du dra och släppa tabellerna i anteckningsbokens arbetsyta eller använda genvägsåtgärderna i listrutan tabell. Anteckningsboken genererar automatiskt en kodbit åt dig. Du kan använda verktygen notebookutils.data för att upprätta en anslutning till Warehouses och köra frågor mot data med hjälp av T-SQL-instruktioner i samband med Python.

Notera

SQL-analysslutpunkter är skrivskyddade.

Anteckningsboksresursmapp

Notebook-resursens inbyggda resursmapp är inbyggt tillgänglig i Python Notebook. Du kan enkelt interagera med filerna i den inbyggda resursmappen genom att använda Python-kod som om du arbetar med ditt lokala filsystem. För närvarande stöds inte Environment-resursmappen.

Kärnoperationer

Python-notebooks stöder tre inbyggda kärnor: Python 3.10, Python 3.11 och Python 3.12. Den standardvalda kärnan är Python 3.12. Du kan enkelt växla mellan dem.

Du kan avbryta, starta om eller byta kärna på fliken Hem i bandet. Att avbryta kärnan i Python-notebooks är samma sak som att avbryta en cell i Spark-notebook.

En onormal kärnavslutning orsakar att kodexekveringen avbryts och variabler går förlorade, men det stoppar inte notebook-sessionen.

Vissa kommandon kan leda till att kärnan dör. Till exempel quit() och exit().

För supportlivscykeln för varje Python-kärnversion, inklusive slutdatum för support och migreringssteg, se Python notebook runtime och kernel lifecycle in Fabric.

Bibliotekshantering

Använd kommandona %pip och %conda för installationer infogade i koden. Dessa kommandon stöder både folkbibliotek och anpassade bibliotek.

För anpassade bibliotek, ladda upp biblioteksfilerna till mappen Inbyggda resurser . Plattformen stödjer flera typer av bibliotek, inklusive format som Wheel (.whl), JAR (.jar), DLL (.dll) och Python (.py). Dra bara filen och släpp, så genereras kodbiten automatiskt.

Du kan behöva starta om kärnan för att använda de uppdaterade paketen.

För att bättre förstå och använda liknande kommandon, se följande tabell.

Kommando/syntax	Huvudsyfte	Så här fungerar det i Jupyter Notebook	Vanligt användningsfall	Anteckningar
%pip install package	Installera Python-paket	Kör pip i anteckningsbokens Python-kärna	Rekommenderat sätt att installera paket	I Python Notebook, samma som !pip; kärnan startas inte automatiskt om
!pip install package	Installera Python-paket via shell	Kör pip som ett gränssnittskommando	Alternativt sätt att installera paket	I Python Notebook, samma som %pip; startas inte kärnan automatiskt
import sys; sys.exit(0)	Starta om notebook-kärnan	Startar omedelbart om kärnan	Starta om kerneln programmatiskt	Rensar alla variabler och tillstånd. rekommenderas inte att använda direkt
notebookutils.session.restartPython()	Starta om notebook-kärnan	Ringer sys.exit(0) internt	Rekommenderat sätt att starta om kerneln	Officiellt API, säkrare och mer kompatibelt än att använda sys.exit(0) direkt

Notera

• I en Python Notebook har %pip och !pipsamma beteende: båda installerar paket i den aktuella kärnans miljö, och ingen av dem startar automatiskt om kärnan efter installationen.
• Om du behöver starta om kärnan (till exempel efter installation av vissa paket), använd notebookutils.session.restartPython() istället för import sys; sys.exit(0).
  • notebookutils.session.restartPython() är ett officiellt API som wrappar sys.exit(0) , och det är säkrare och mer kompatibelt i notebook-miljöer.
• Använd inte sys.exit(0) direkt om det inte är nödvändigt.

Övervakning av realtidsresursanvändning i Python-notebook

Viktigt!

Den här funktionen är i förhandsversion.

Genom att använda resursövervakningspanelen kan du spåra kritisk körtidsinformation såsom sessionsduration, beräkningstyp och realtidsresursmått, inklusive CPU- och minnesanvändning, direkt i din anteckningsbok. Den här funktionen ger en omedelbar översikt över din aktiva session och de resurser som används.

Resursövervakaren ger bättre insyn i hur Python-arbetsbelastningar använder systemresurser. Det hjälper dig att optimera prestanda, hantera kostnader och minska risken för OOM-fel (out-of-memory). Genom att övervaka mått i realtid kan du identifiera resursintensiva åtgärder, analysera användningsmönster och fatta välgrundade beslut om skalning eller ändring av kod.

Om du vill börja använda det ställer du in notebook-språket på Python och startar en session. Du kan sedan öppna övervakaren antingen genom att klicka på beräkningsresurserna i anteckningsbokens statusfält eller genom att välja Visa resursanvändning i verktygsfältet. Resursövervakningspanelen visas automatiskt och ger en integrerad övervakningsupplevelse för Python-kod i Fabric-notebooks.

Magiskt kommando för sessionskonfiguration

Precis som att personanpassa en Spark-sessionskonfiguration i en anteckningsbok kan du också använda %%configure i en Python anteckningsbok. Python notebook stödjer anpassning av storlek på beräkningsnoder, monteringspunkter och standard lakehouse för notebook-sessionen. Du kan använda dessa inställningar både i interaktiva anteckningsböcker och i pipeline-anteckningsböcker. Använd kommandot %%configure i början av din anteckningsbok, annars måste du starta om anteckningsbokssessionen för att aktivera inställningarna.

Här är de egenskaper som stöds i Python Notebook %%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 uppdateringen av beräkningsresurser i anteckningsbokens statusfält och övervaka CPU- och minnesanvändningen för beräkningsnoden i realtid.

Notera

API-utlösta körningar hedrar sessionskonfigurationen, till exempel virtuella beräkningscores och defaultLakehouse anges via notebook-metadata eller %%configure. Jobbschemaläggar-API:et stöder också att välja mål-sjöhuset och miljön vid körning. Mer information om nyttolastfälten finns i Hantera och köra notebook-filer i Infrastruktur med API:er.

NotebookUtils

Notebook Utilities (NotebookUtils) är ett inbyggt paket som hjälper dig att enkelt utföra vanliga uppgifter i Fabric Notebook. Det är förinstallerat på Python-runtime. Använd NotebookUtils för att arbeta med filsystem, hämta miljövariabler, kedja ihop notebooks, komma åt extern lagring och arbeta med hemligheter.

Använd notebookutils.help() för att lista tillgängliga API:er och få hjälp med metoder. För mer information, se NotebookUtils-dokumentationen.

Dataverktyg

Notera

För närvarande är funktionen i förhandsversion.

Använd verktygen notebookutils.data för att ansluta till en datakälla. Sedan kan du läsa och fråga data genom att använda en T-SQL-sats.

Kör följande kommando för att få en översikt över tillgängliga metoder:

notebookutils.data.help()

Utdata:

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

Fråga efter data från Lakehouse

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

Fråga efter data från Warehouse

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

Fråga efter data från SQL-databasen

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

Notera

Dataverktygen i NotebookUtils är bara tillgängliga i Python Notebook för tillfället.

Bläddra bland kodfragment

Du kan hitta användbara Python-kodutdrag på fliken Redigera genom att välja Bläddra kodutsnitt. Nya Python-exempel finns nu tillgängliga. För att börja utforska anteckningsboken, lär dig från Python-kodutsnitten.

Semantisk länk

Semantisk länk är en funktion som du kan använda för att koppla samman semantiska modeller och Synapse Data Science i Microsoft Fabric. Python notebook stöder denna funktion nativt. BI-ingenjörer och Power BI-utvecklare kan använda Semantic Link för att enkelt koppla samman och hantera semantiska modeller. För att lära dig mer, se det offentliga dokumentet.

Visualisering

Förutom att rita diagram med bibliotek, kan du med den inbyggda visualiseringsfunktionen omvandla DataFrame till visualiseringar i rikt format. Använd display() -funktionen på dataframes för att skapa den rika dataframe-tabellvyn och diagramvyn.

Notera

Python-notebooken behåller diagramkonfigurationerna. Efter att kodcellen körts igen, om måldataramens schema inte ändras, kvarstår de sparade diagrammen.

Kod IntelliSense

Python Notebook använder också Pylance som språkserver. Mer information finns i förbättra Python-utveckling med Pylance.

Datavetenskapsfunktioner

För att lära dig mer om data science- och AI-upplevelser i Microsoft Fabric, se Data Science-dokumentationer i Microsoft Fabric. Den här artikeln listar några viktiga data science-funktioner som Python-notebooks nativt stödjer.

• Data Wrangler: Data Wrangler är ett anteckningsboksbaserat verktyg som erbjuder ett immersivt gränssnitt för utforskande dataanalys. Den här funktionen kombinerar en rutnätsliknande datavisning med dynamisk sammanfattningsstatistik, inbyggda visualiseringar och ett bibliotek med vanliga datarensningsåtgärder. Den erbjuder datarensning, datatransformation och integration, vilket påskyndar dataförberedelsen genom att använda Data Wrangler.

• MLflow: Ett maskininlärningsexperiment är den primära enheten för organisation och kontroll för alla relaterade maskininlärningskörningar. En körning motsvarar en enda exekvering av modellkod.

• Fabric Auto Logging: Synapse Data Science i Microsoft Fabric innehåller automatisk loggning, vilket avsevärt minskar mängden kod som krävs för att automatiskt logga parametrar, mått och objekt i en maskininlärningsmodell under träning.

  Automatisk loggning utökar MLflow Tracking-funktionerna. Automatisk loggning kan samla in olika mått, inklusive noggrannhet, förlust, F1-poäng och anpassade mått som du definierar. Med hjälp av automatisk loggning kan utvecklare och dataforskare enkelt spåra och jämföra prestanda för olika modeller och experiment utan manuell spårning.

• Copilot: Copilot för notebooks inom datateknik och datavetenskap är en AI-assistent som hjälper dig att analysera och visualisera data. Copilot är omedelbart kontextmedveten utan att du behöver starta en session. Den förstår arbetsytan, bifogade Lakehouse-scheman, tabeller och filer, notebook-struktur och körningstillstånd och kan fungera i hela notebook-arbetsflödet.

  Copilot stöder datorövergripande flerstegsfunktioner: den kan generera, refaktorera, sammanfatta och validera kod över flera celler och steg i Python-notebooks. Du kan använda Copilot-chattpanelen och chattkommandon, till exempel /fix i anteckningsboken.

  När en cell misslyckas visar Korrigering med Copilot en felsammanfattning, rotorsaksanalys och rekommenderade korrigeringar, med ett alternativ för att automatiskt tillämpa kodändringar efter att ha visat ett diff för godkännande. Du kan också använda kommandot /fix i Copilot-chatten för riktad diagnostik på en specifik cell eller hela notebook-filen.

Kända begränsningar

• Live pool-upplevelsen är inte garanterad för varje Python-notebook. Sessionsstarttiden kan ta upp till tre minuter om notebook-körningen inte når livepoolen. När användningen av Python-notebooks ökar, ökar metoder för intelligent poolhantering gradvis allokeringen av den aktiva poolen för att möta efterfrågan.

• Miljöintegration är inte tillgänglig i Python notebook.

• Det går inte att ställa in tidsgräns för sessionen.

• Copilot har förbättrad sammanhangsmedvetenhet och hjälp för Python-notebook-filer, men det kan ibland föreslå Spark-kod som inte är direkt körbar i en Python-notebook-fil. Funktionen Åtgärda med Copilot gäller för misslyckade Python-celler; diagnostik för Spark-jobb är inte tillämplig på rena Python-körningar.

• För närvarande stöds inte Copilot på Python-notebook fullt ut i flera regioner. Distributionsprocessen pågår fortfarande. Håll utkik när stödet rullas ut i fler regioner.

Relaterat innehåll

• Hur man använder Microsoft Fabric-anteckningsböcker
• Utveckla, köra och hantera Microsoft Fabric-notebook-filer
• Introduktion av Fabric NotebookUtils