Python-modules importeren uit Git-mappen of werkruimtebestanden

U kunt Python-code opslaan in Databricks Git-mappen of in werkruimtebestanden en die Python-code vervolgens importeren in uw pijplijn. Zie Werken met Python- en R-modulesvoor meer informatie over het werken met modules in Git-mappen of werkruimtebestanden.

Als u een Python-bestand wilt importeren, hebt u meerdere opties:

Neem de Python-module in uw pijplijn op als een hulpprogrammabestand. Dit werkt het beste als de module specifiek is voor de pijplijn.
Voeg een gedeelde module toe aan uw pijplijnomgeving, in elke pijplijn die deze moet gebruiken.
Importeer een module in uw werkruimte rechtstreeks in uw Python-bron, met een import instructie.

Een Python-module opnemen in een pijplijn

U kunt een Python-module maken als onderdeel van uw pijplijn. De hoofdmap van uw pijplijn wordt automatisch toegevoegd aan de map sys.path. Hierdoor kunt u rechtstreeks naar de module verwijzen in de Python-broncode van uw pijplijn.

In het volgende voorbeeld ziet u hoe u een Python-module maakt in de hoofdmap van uw pijplijn en hiernaar verwijst vanuit een Python-bronbestand in uw pijplijnbron:

Open uw pijplijn in de pijplijneditor.
Klik in de pijplijn asset-browser aan de linkerkant op Toevoegen en kies Utility in het menu.
Voer my_utils.py de naam in.
Laat het standaardpad staan en klik op Maken.

Hiermee maakt u het my_utils.py bestand in de utilities map van uw pijplijn en maakt u de utilities map als deze niet bestaat. De bestanden in deze map worden niet standaard toegevoegd aan uw pijplijnbron, maar kunnen wel worden aangeroepen vanuit de .py bestanden die deel uitmaken van uw broncode.

Het hulpprogrammabestand heeft standaard een voorbeeldfunctie distance_km() die een afstand in mijlen in beslag neemt en converteert.
In een Python-bronbestand in de map transformaties (u kunt er een maken door het te kiezen.Voeg de volgende code toe en selecteer Transformatie in het menu:
```
from utilities import my_utils
```

U kunt nu functies aanroepen my_utils vanuit dat Python-bestand. U moet de import instructie toevoegen vanuit een Python-bestand dat functies in de module moet aanroepen.

Een Python-module toevoegen aan uw pijplijnomgeving

Als u een Python-module wilt delen tussen meerdere pijplijnen, kunt u de module overal in uw werkruimtebestanden opslaan en ernaar verwijzen vanuit de omgeving van elke pijplijn die deze moet gebruiken. U kunt verwijzen naar Python-modules die:

Afzonderlijke Python-bestanden (.py).
Python-project dat is verpakt als een Python-wielbestand (.whl).
Uitgepakt Python-project met een pyproject.toml bestand (om de projectnaam en versie te definiëren).

In het volgende voorbeeld ziet u hoe u een afhankelijkheid toevoegt aan een pijplijn.

Open uw pijplijn in de pijplijneditor.
Klik op Instellingen op de bovenste balk.
Klik in het uitklapmenu Pijplijninstellingen onder Pijplijnomgeving op Omgeving bewerken.
Voeg een afhankelijkheid toe. Als u bijvoorbeeld een bestand in uw werkruimte wilt toevoegen, kunt u toevoegen /Volumes/libraries/path/to/python_files/file.py. Voor een Python wheel opgeslagen in Git-mappen, kan uw pad er als /Workspace/libraries/path/to/wheel_files/file.whl uitzien.

U kunt een bestand zonder pad of een relatief pad toevoegen als het zich in de hoofdmap van de pijplijn bevindt.

Opmerking

U kunt ook een pad toevoegen aan een gedeelde map met behulp van de afhankelijkheden zodat import instructies in uw code de modules kunnen vinden die u wilt importeren. Bijvoorbeeld: -e /Workspace/Users/<user_name>/path/to/add/.

Een Python-module importeren met behulp van de `import` instructie

U kunt ook rechtstreeks verwijzen naar een werkruimtebestand in uw Python-broncode.

Als het bestand zich in de utilities map van uw pijplijn bevindt, kunt u ernaar verwijzen zonder pad:
```
from utilities import my_module
```
Als het bestand zich ergens anders bevindt, kunt u het importeren door eerst het pad van de module toe te voegen vlak voor de sys.path.
```
import sys, os
sys.path.append(os.path.abspath('<module-path>'))

from my_module import *
```
U kunt ook toevoegen aan de sys.path voor alle pijplijnbronbestanden door het pad toe te voegen aan de pijplijnomgeving, zoals beschreven in de vorige sectie.

Voorbeeld van het importeren van query's als Python-modules

In het volgende voorbeeld ziet u hoe u gegevenssetquery's importeert als Python-modules uit werkruimtebestanden. Hoewel in dit voorbeeld wordt beschreven hoe u werkruimtebestanden gebruikt om de broncode van de pijplijn op te slaan, kunt u deze gebruiken met broncode die is opgeslagen in een Git-map.

Voer de volgende stappen uit om dit voorbeeld uit te voeren:

Klik op Werkruimte in de zijbalk van uw Azure Databricks-werkruimte om de werkruimtebrowser te openen.
Gebruik de werkruimtebrowser om een map voor de Python-modules te selecteren.
Klik op Klik vervolgens in de meest rechtse kolom van de geselecteerde map en klik op Bestand aanmaken>.

Voer een naam in voor het bestand, bijvoorbeeld clickstream_raw_module.py. De bestandseditor wordt geopend. Als u een module wilt maken om brongegevens in een tabel te lezen, voert u het volgende in het editorvenster in:

from pyspark import pipelines as dp

json_path = "/databricks-datasets/wikipedia-datasets/data-001/clickstream/raw-uncompressed-json/2015_2_clickstream.json"

def create_clickstream_raw_table(spark):
  @dp.table
  def clickstream_raw():
    return (
      spark.read.json(json_path)
    )

Als u een module wilt maken waarmee een nieuwe tabel met voorbereide gegevens wordt gemaakt, maakt u een nieuw bestand in dezelfde map, voert u een naam in voor het bestand, bijvoorbeeld clickstream_prepared_module.py, en voert u het volgende in het nieuwe editorvenster in:

from clickstream_raw_module import *
from pyspark import pipelines as dp
from pyspark.sql.functions import *
from pyspark.sql.types import *

def create_clickstream_prepared_table(spark):
  create_clickstream_raw_table(spark)
  @dp.table
  @dp.expect("valid_current_page_title", "current_page_title IS NOT NULL")
  @dp.expect_or_fail("valid_count", "click_count > 0")
  def clickstream_prepared():
    return (
      spark.read("clickstream_raw")
        .withColumn("click_count", expr("CAST(n AS INT)"))
        .withColumnRenamed("curr_title", "current_page_title")
        .withColumnRenamed("prev_title", "previous_page_title")
        .select("current_page_title", "click_count", "previous_page_title")
    )

Maak vervolgens een Python-bestand in uw pijplijnbron. Kies in de pijplijneditorVoeg vervolgens transformatie toe.
Geef uw bestand een naam en controleer of Python de standaardtaal is.
Klik op Create.
Voer de volgende voorbeeldcode in het notebook in.

Opmerking

Als uw notebook modules of pakketten importeert vanuit een pad naar werkruimtebestanden of een pad naar Git-mappen dat anders is dan de notebookmap, moet u het pad handmatig aan de bestanden toevoegen met behulp van sys.path.append().

Als u een bestand uit een Git-map importeert, moet u /Workspace/ aan het pad toevoegen. Bijvoorbeeld: sys.path.append('/Workspace/...'). Als u /Workspace/ weglaat uit het pad, treedt er een fout op.

Als de modules of pakketten zijn opgeslagen in dezelfde map als het notebook, hoeft u het pad niet handmatig toe te voegen. U hoeft het pad ook niet handmatig toe te voegen bij het importeren uit de hoofdmap van een Git-map, omdat de hoofdmap automatisch aan het pad wordt toegevoegd.
```
import sys, os
sys.path.append(os.path.abspath('<module-path>'))

from pyspark import pipelines as dp
from clickstream_prepared_module import *
from pyspark.sql.functions import *
from pyspark.sql.types import *

create_clickstream_prepared_table(spark)

@dp.table(
  comment="A table containing the top pages linking to the Apache Spark page."
)
def top_spark_referrers():
  return (
    spark.read.table("catalog_name.schema_name.clickstream_prepared")
      .filter(expr("current_page_title == 'Apache_Spark'"))
      .withColumnRenamed("previous_page_title", "referrer")
      .sort(desc("click_count"))
      .select("referrer", "click_count")
      .limit(10)
  )
```
Vervang <module-path> door het pad naar de map met de Python-modules die moeten worden geïmporteerd.
Klik op Pijplijn uitvoeren om de pijplijn uit te voeren.

Feedback

Is deze pagina nuttig?

Last updated on 2026-01-21