Databricks SQL Connector för Python

Databricks SQL Connector för Python är ett Python-bibliotek som gör att du kan använda Python-kod för att köra SQL-kommandon på Azure Databricks all-purpose compute- och Databricks SQL-lager. Databricks SQL Connector för Python är enklare att konfigurera och använda än liknande Python-bibliotek som pyodbc. Det här biblioteket följer PEP 249 – Python Database API Specification v2.0.

Databricks SQL Connector för Python stöder också SQLAlchemy-dialekten för Azure Databricks, men den måste installeras för att kunna använda dessa funktioner. Se Använd SQLAlchemy med Azure Databricks.

Krav

• En utvecklingsdator som kör Python 3.8 och senare.
• Databricks rekommenderar att du använder virtuella Python-miljöer, till exempel de som tillhandahålls av venv som ingår i Python. Virtuella miljöer hjälper dig att se till att du använder rätt versioner av Python och Databricks SQL Connector för Python tillsammans. Att konfigurera och använda virtuella miljöer ligger utanför omfånget för den här artikeln. Mer information finns i Skapa virtuella miljöer.
• En befintlig datorberäkning för alla ändamål eller SQL-lager.

Sätta igång

1. Installera Databricks SQL Connector för Python. PyArrow är ett valfritt beroende av Databricks SQL Connector för Python och installeras inte som standard i version 4.0.0 och senare av anslutningsappen. Om PyArrow inte är installerat är funktioner som CloudFetch och andra Apache Arrow-funktioner inte tillgängliga, vilket kan påverka prestanda för stora datavolymer.

   • Om du vill installera lean-kontakten använder du:

     pip install databricks-sql-connector
     

   • Om du vill installera det fullständiga anslutningsprogrammet, inklusive PyArrow, använder du:

     pip install databricks-sql-connector[pyarrow]
     

2. Samla in följande information för all-purpose compute eller SQL Warehouse som du vill använda:

   Mångsidig beräkning

   • Servervärdnamnet för all-purpose-beräkningen. Du kan hämta detta från värdet Servervärdnamn på fliken Avancerade alternativ > JDBC/ODBC för all-purpose-beräkningen.
   • HTTP-sökvägen för all-purpose-beräkningen. Du kan hämta detta från HTTP-sökvägsvärdet på fliken Avancerade alternativ > JDBC/ODBC för din all-purpose-beräkning.

   Kommentar

   SQL-kopplingen stöder inte anslutning till funktionen "Jobs Compute".

   SQL-lager

   • Servervärdnamnet för SQL-lagret. Du kan hämta detta från värdet Servervärdnamn på fliken Anslutningsinformation för DITT SQL-lager.
   • HTTP-sökvägen för SQL-lagret. Du kan hämta detta från HTTP-sökvägsvärdet på fliken Anslutningsinformation för DITT SQL-lager.

Autentisering

Databricks SQL Connector för Python stöder följande Azure Databricks-autentiseringstyper:

• Autentisering med personlig åtkomsttoken för Databricks
• Microsoft Entra ID-tokenautentisering
• OAuth-autentisering från dator till dator (M2M)
• OAuth-autentisering från användare till dator (U2M)

Databricks SQL Connector för Python stöder ännu inte följande Azure Databricks-autentiseringstyper:

• Autentisera med hanterade Azure-identiteter
• Autentisera med MS Entras tjänsteprincipaler
• Autentisera med Azure CLI

Autentisering med personlig åtkomsttoken för Databricks

Om du vill använda Databricks SQL Connector för Python med personlig åtkomsttokenautentisering i Azure Databricks måste du först skapa en personlig åtkomsttoken för Azure Databricks. Det gör du genom att följa stegen i Skapa personliga åtkomsttoken för arbetsyteanvändare.

Om du vill autentisera Databricks SQL Connector för Python använder du följande kodfragment. Det här kodfragmentet förutsätter att du har angett följande miljövariabler:

• DATABRICKS_SERVER_HOSTNAMEange värdet servervärdnamn för all-purpose-beräkning eller SQL-lager.
• DATABRICKS_HTTP_PATH, inställd på HTTP-sökvägsvärde för din allmänna beräkning eller SQL-datalager.
• DATABRICKS_TOKENär inställt på den personliga åtkomsttoken för Azure Databricks.

Information om hur du anger miljövariabler finns i dokumentationen till operativsystemet.

from databricks import sql
import os

with sql.connect(server_hostname = os.getenv("DATABRICKS_SERVER_HOSTNAME"),
                 http_path       = os.getenv("DATABRICKS_HTTP_PATH"),
                 access_token    = os.getenv("DATABRICKS_TOKEN")) as connection:
# ...

OAuth-autentisering från dator till dator (M2M)

Databricks SQL Connector för Python-versionerna 2.7.0 och senare stöder OAuth-autentisering från maskin till dator (M2M). Du måste också installera Databricks SDK för Python 0.18.0 eller senare (till exempel genom att köra pip install databricks-sdk eller python -m pip install databricks-sdk).

Om du vill använda Databricks SQL Connector för Python med OAuth M2M-autentisering måste du göra följande:

1. Skapa ett tjänsthuvudnamn för Azure Databricks i din Azure Databricks-arbetsyta och skapa en OAuth-klient-hemlighet för detta tjänsthuvudnamn.

   Information om hur du skapar tjänstens huvudnamn och dess OAuth-hemlighet finns i Auktorisera tjänstens huvudnamnsåtkomst till Azure Databricks med OAuth. Anteckna tjänstens huvudnamns UUID - eller program-ID-värde och det hemliga värdet för tjänstens huvudnamns OAuth-hemlighet.

2. Ge tjänstens huvudnamn åtkomst till all-purpose compute eller warehouse.

   Så här ger du tjänstens principalkonto åtkomst till dina beräkningsresurser eller ditt lager: läs Beräkningsbehörigheter eller Hantera ett SQL-lager.

Om du vill autentisera Databricks SQL Connector för Python använder du följande kodfragment. Det här kodfragmentet förutsätter att du har angett följande miljövariabler:

• DATABRICKS_SERVER_HOSTNAME ställ in värdet till servervärdnamn för din allomfattande beräkning eller SQL-datalager.
• DATABRICKS_HTTP_PATH, inställd på HTTP-sökvägsvärde för din allmänna beräkning eller SQL-datalager.
• DATABRICKS_CLIENT_ID, inställt på tjänstens huvudnamns UUID - eller program-ID-värde .
• DATABRICKS_CLIENT_SECRET, ange värdet Hemlig för tjänstens huvudnamns OAuth-hemlighet.

Information om hur du anger miljövariabler finns i dokumentationen till operativsystemet.

from databricks.sdk.core import Config, oauth_service_principal
from databricks import sql
import os

server_hostname = os.getenv("DATABRICKS_SERVER_HOSTNAME")

def credential_provider():
  config = Config(
    host          = f"https://{server_hostname}",
    client_id     = os.getenv("DATABRICKS_CLIENT_ID"),
    client_secret = os.getenv("DATABRICKS_CLIENT_SECRET"))
  return oauth_service_principal(config)

with sql.connect(server_hostname      = server_hostname,
                 http_path            = os.getenv("DATABRICKS_HTTP_PATH"),
                 credentials_provider = credential_provider) as connection:
# ...

Microsoft Entra ID-tokenautentisering

Om du vill använda Databricks SQL Connector för Python med Microsoft Entra ID-tokenautentisering måste du ange Databricks SQL Connector för Python med Microsoft Entra ID-token. Gör följande för att skapa en Microsoft Entra ID-åtkomsttoken:

• För en Azure Databricks-användare kan du använda Azure CLI. Se Hämta Microsoft Entra-ID-token manuellt.
• För ett tjänsthuvudnamn för Microsoft Entra ID, se Hämta tokens för tjänsthuvudnamn. Information om hur du skapar ett hanterat tjänsthuvudnamn för Microsoft Entra-ID finns i Tjänstens huvudnamn.

Microsoft Entra-ID-token har en standardlivslängd på cirka 1 timme. Om du vill skapa en ny Microsoft Entra-ID-token upprepar du den här processen.

Om du vill autentisera Databricks SQL Connector för Python använder du följande kodfragment. Det här kodfragmentet förutsätter att du har angett följande miljövariabler:

• Ange DATABRICKS_SERVER_HOSTNAME servernamnet Servernamn för din mångsidiga datorresurs eller SQL Warehouse.
• Ange värdet DATABRICKS_HTTP_PATH till HTTP-sökväg för din allmänna beräkning eller SQL-datalager.
• Ange DATABRICKS_TOKEN till Microsoft Entra ID-token.

Information om hur du anger miljövariabler finns i dokumentationen till operativsystemet.

from databricks import sql
import os

with sql.connect(server_hostname = os.getenv("DATABRICKS_SERVER_HOSTNAME"),
                 http_path       = os.getenv("DATABRICKS_HTTP_PATH"),
                 access_token    = os.getenv("DATABRICKS_TOKEN")) as connection:
# ...

OAuth-autentisering från användare till maskin (U2M)

Databricks SQL Connector för Python-versionerna 2.7.0 och senare stöder OAuth-autentisering från användare till dator (U2M). Du måste också installera Databricks SDK för Python 0.19.0 eller senare (till exempel genom att köra pip install databricks-sdk eller python -m pip install databricks-sdk).

Om du vill autentisera Databricks SQL Connector för Python med OAuth U2M-autentisering använder du följande kodfragment. OAuth U2M-autentisering använder mänsklig inloggning i realtid och medgivande för att autentisera azure Databricks-målanvändarkontot. Det här kodfragmentet förutsätter att du har angett följande miljövariabler:

• Ange DATABRICKS_SERVER_HOSTNAME servernamnet Servernamn för din mångsidiga datorresurs eller SQL Warehouse.
• Ange värdet DATABRICKS_HTTP_PATH till HTTP-sökväg för din allmänna beräkning eller SQL-datalager.

Information om hur du anger miljövariabler finns i dokumentationen till operativsystemet.

from databricks import sql
import os

with sql.connect(server_hostname = os.getenv("DATABRICKS_SERVER_HOSTNAME"),
                 http_path       = os.getenv("DATABRICKS_HTTP_PATH"),
                 auth_type       = "databricks-oauth") as connection:
# ...

Exempel

Följande kodexempel visar hur du använder Databricks SQL Connector för Python för att fråga och infoga data, fråga efter metadata, hantera markörer och anslutningar, hantera filer i Unity Catalog och konfigurera loggning.

I det här kodexemplet hämtas deras server_hostname, http_pathoch access_token värden för anslutningsvariabler från dessa miljövariabler:

• DATABRICKS_SERVER_HOSTNAME, som representerar serverns värdnamn från kraven.
• DATABRICKS_HTTP_PATH, som representerar http-sökvägsvärdet från kraven.
• DATABRICKS_TOKEN, som representerar din åtkomsttoken enligt de angivna kraven.

Ställ in User-Agent

I följande kodexempel visas hur du anger User-Agent program product_name för användningsspårning.

from databricks import sql
import os

with sql.connect(server_hostname   = os.getenv("DATABRICKS_SERVER_HOSTNAME"),
                 http_path         = os.getenv("DATABRICKS_HTTP_PATH"),
                 access_token      = os.getenv("DATABRICKS_TOKEN"),
                 user_agent_entry = "product_name") as connection:
  with connection.cursor() as cursor:
    cursor.execute("SELECT 1 + 1")
    result = cursor.fetchall()

    for row in result:
      print(row)

Fråga efter data

Följande kodexempel visar hur du anropar Databricks SQL Connector för Python för att köra ett grundläggande SQL-kommando på all-purpose compute eller SQL Warehouse. Det här kommandot returnerar de två första raderna trips från tabellen i samples katalogens nyctaxi schema.

from databricks import sql
import os

with sql.connect(server_hostname = os.getenv("DATABRICKS_SERVER_HOSTNAME"),
                 http_path       = os.getenv("DATABRICKS_HTTP_PATH"),
                 access_token    = os.getenv("DATABRICKS_TOKEN")) as connection:

  with connection.cursor() as cursor:
    cursor.execute("SELECT * FROM samples.nyctaxi.trips LIMIT 2")
    result = cursor.fetchall()

    for row in result:
      print(row)

Frågetaggar

I följande exempel visas hur du kopplar nyckelvärdestaggar till dina SQL-frågor i spårnings- och analyssyfte. Frågetaggar visas i system.query.history tabellen.

from databricks import sql
import os

with sql.connect(
    server_hostname = os.getenv("DATABRICKS_SERVER_HOSTNAME"),
    http_path       = os.getenv("DATABRICKS_HTTP_PATH"),
    access_token    = os.getenv("DATABRICKS_TOKEN"),
    session_configuration = {
        'query_tags': 'team:engineering,dashboard:abc123,env:prod'
    }
) as connection:
    with connection.cursor() as cursor:
        cursor.execute("SELECT * FROM samples.nyctaxi.trips LIMIT 2")
        result = cursor.fetchall()
        # Query is now tagged and trackable in system.query.history
        for row in result:
            print(row)

Infoga data

I följande exempel visas hur du infogar små mängder data (tusentals rader):

from databricks import sql
import os

with sql.connect(server_hostname = os.getenv("DATABRICKS_SERVER_HOSTNAME"),
                 http_path       = os.getenv("DATABRICKS_HTTP_PATH"),
                 access_token    = os.getenv("DATABRICKS_TOKEN")) as connection:

  with connection.cursor() as cursor:
    cursor.execute("CREATE TABLE IF NOT EXISTS squares (x int, x_squared int)")

    squares = [(i, i * i) for i in range(100)]
    values = ",".join([f"({x}, {y})" for (x, y) in squares])

    cursor.execute(f"INSERT INTO squares VALUES {values}")

    cursor.execute("SELECT * FROM squares LIMIT 10")

    result = cursor.fetchall()

    for row in result:
      print(row)

För stora mängder data bör du först ladda upp data till molnlagring och sedan köra kommandot COPY INTO.

Frågemetadata

Det finns dedikerade metoder för att hämta metadata. I följande exempel hämtas metadata om kolumner i en exempeltabell:

from databricks import sql
import os

with sql.connect(server_hostname = os.getenv("DATABRICKS_SERVER_HOSTNAME"),
                 http_path       = os.getenv("DATABRICKS_HTTP_PATH"),
                 access_token    = os.getenv("DATABRICKS_TOKEN")) as connection:

  with connection.cursor() as cursor:
    cursor.columns(schema_name="default", table_name="squares")
    print(cursor.fetchall())

Hantera markörer och anslutningar

Det är en bra idé att stänga alla anslutningar och markörer som inte längre används. Detta frigör resurser på Azure Databricks all-purpose compute- och Databricks SQL-lager.

Du kan använda en kontexthanterare (syntaxen with som användes i tidigare exempel) för att hantera resurserna, eller uttryckligen anropa close:

from databricks import sql
import os

connection = sql.connect(server_hostname = os.getenv("DATABRICKS_SERVER_HOSTNAME"),
                         http_path       = os.getenv("DATABRICKS_HTTP_PATH"),
                         access_token    = os.getenv("DATABRICKS_TOKEN"))

cursor = connection.cursor()

cursor.execute("SELECT * from range(10)")
print(cursor.fetchall())

cursor.close()
connection.close()

Hantera filer i Unity Catalog-volymer

Med Databricks SQL Connector kan du skriva lokala filer till Unity Catalog-volymer, ladda ned filer från volymer och ta bort filer från volymer, enligt följande exempel:

from databricks import sql
import os

# For writing local files to volumes and downloading files from volumes,
# you must set the staging_allowed_local_path argument to the path to the
# local folder that contains the files to be written or downloaded.
# For deleting files in volumes, you must also specify the
# staging_allowed_local_path argument, but its value is ignored,
# so in that case its value can be set for example to an empty string.
with sql.connect(server_hostname            = os.getenv("DATABRICKS_SERVER_HOSTNAME"),
                 http_path                  = os.getenv("DATABRICKS_HTTP_PATH"),
                 access_token               = os.getenv("DATABRICKS_TOKEN"),
                 staging_allowed_local_path = "/tmp/") as connection:

  with connection.cursor() as cursor:

    # Write a local file to the specified path in a volume.
    # Specify OVERWRITE to overwrite any existing file in that path.
    cursor.execute(
      "PUT '/tmp/my-data.csv' INTO '/Volumes/main/default/my-volume/my-data.csv' OVERWRITE"
    )

    # Download a file from the specified path in a volume.
    cursor.execute(
      "GET '/Volumes/main/default/my-volume/my-data.csv' TO '/tmp/my-downloaded-data.csv'"
    )

    # Delete a file from the specified path in a volume.
    cursor.execute(
      "REMOVE '/Volumes/main/default/my-volume/my-data.csv'"
    )

Konfigurera loggning

Databricks SQL Connector använder Pythons standardloggningsmodul. I följande exempel konfigureras loggningsnivån och en felsökningslogg genereras:

from databricks import sql
import os, logging

logging.getLogger("databricks.sql").setLevel(logging.DEBUG)
logging.basicConfig(filename = "results.log",
                    level    = logging.DEBUG)

connection = sql.connect(server_hostname = os.getenv("DATABRICKS_SERVER_HOSTNAME"),
                         http_path       = os.getenv("DATABRICKS_HTTP_PATH"),
                         access_token    = os.getenv("DATABRICKS_TOKEN"))

cursor = connection.cursor()

cursor.execute("SELECT * from range(10)")

result = cursor.fetchall()

for row in result:
   logging.debug(row)

cursor.close()
connection.close()

Testning

Om du vill testa koden använder du Python-testramverk som pytest. Om du vill testa koden under simulerade förhållanden utan att anropa Azure Databricks REST API-slutpunkter eller ändra tillståndet för dina Azure Databricks-konton eller arbetsytor kan du använda Python-modelleringsbibliotek som unittest.mock.

Med följande fil med namnet helpers.py som innehåller en get_connection_personal_access_token funktion som använder en personlig Åtkomsttoken för Azure Databricks för att returnera en anslutning till en Azure Databricks-arbetsyta och en select_nyctaxi_trips funktion som använder anslutningen för att hämta det angivna antalet datarader från trips tabellen i samples katalogens nyctaxi schema:

# helpers.py

from databricks import sql
from databricks.sql.client import Connection, List, Row, Cursor

def get_connection_personal_access_token(
  server_hostname: str,
  http_path: str,
  access_token: str
) -> Connection:
  return sql.connect(
    server_hostname = server_hostname,
    http_path = http_path,
    access_token = access_token
  )

def select_nyctaxi_trips(
  connection: Connection,
  num_rows: int
) -> List[Row]:
  cursor: Cursor = connection.cursor()
  cursor.execute(f"SELECT * FROM samples.nyctaxi.trips LIMIT {num_rows}")
  result: List[Row] = cursor.fetchall()
  return result

Och med följande fil med namnet main.py som anropar funktionerna get_connection_personal_access_token och select_nyctaxi_trips:

# main.py

from databricks.sql.client import Connection, List, Row
import os
from helpers import get_connection_personal_access_token, select_nyctaxi_trips

connection: Connection = get_connection_personal_access_token(
  server_hostname = os.getenv("DATABRICKS_SERVER_HOSTNAME"),
  http_path = os.getenv("DATABRICKS_HTTP_PATH"),
  access_token = os.getenv("DATABRICKS_TOKEN")
)

rows: List[Row] = select_nyctaxi_trips(
  connection = connection,
  num_rows = 2
)

for row in rows:
  print(row)

Följande fil med namnet test_helpers.py testar om select_nyctaxi_trips funktionen returnerar det förväntade svaret. I stället för att skapa en verklig anslutning till målarbetsytan hånar det här testet ett Connection objekt. Testet hånar också vissa data som överensstämmer med schemat och värdena som finns i verkliga data. Testet returnerar de simulerade data via den simulerade anslutningen och kontrollerar sedan om ett av de simulerade dataradernas värden matchar det förväntade värdet.

# test_helpers.py

import pytest
from databricks.sql.client import Connection, List, Row
from datetime import datetime
from helpers import select_nyctaxi_trips
from unittest.mock import create_autospec

@pytest.fixture
def mock_data() -> List[Row]:
  return [
    Row(
      tpep_pickup_datetime = datetime(2016, 2, 14, 16, 52, 13),
      tpep_dropoff_datetime = datetime(2016, 2, 14, 17, 16, 4),
      trip_distance = 4.94,
      fare_amount = 19.0,
      pickup_zip = 10282,
      dropoff_zip = 10171
    ),
    Row(
      tpep_pickup_datetime = datetime(2016, 2, 4, 18, 44, 19),
      tpep_dropoff_datetime = datetime(2016, 2, 4, 18, 46),
      trip_distance = 0.28,
      fare_amount = 3.5,
      pickup_zip = 10110,
      dropoff_zip = 10110
    )
  ]

def test_select_nyctaxi_trips(mock_data: List[Row]):
  # Create a mock Connection.
  mock_connection = create_autospec(Connection)

  # Set the mock Connection's cursor().fetchall() to the mock data.
  mock_connection.cursor().fetchall.return_value = mock_data

  # Call the real function with the mock Connection.
  response: List[Row] = select_nyctaxi_trips(
    connection = mock_connection,
    num_rows = 2)

  # Check the value of one of the mocked data row's columns.
  assert response[1].fare_amount == 3.5

Eftersom funktionen innehåller en -sats och därför inte ändrar tillståndet för tabellen , är mockning inte absolut nödvändigt i det här exemplet. Genom mockning kan du snabbt köra dina tester utan att vänta på att en faktisk anslutning ska göras med arbetsytan. Genom att håna kan du också köra simulerade tester flera gånger för funktioner som kan ändra en tabells tillstånd, till exempel INSERT INTO, UPDATEoch DELETE FROM.

API-referens

Det här avsnittet innehåller API-referens för databricks-sql-connector paketet. Se databricks-sql-connector i Python Package Indexet (PyPI).

Modul

Modulen databricks.sql i databricks-sql-connector paketet innehåller metoden för att initiera en anslutning till ett SQL-lager.

anslutsmetod

Initierar en anslutning till ett SQL-lager. Returnerar ett anslutningsobjekt.

Connection klass

Representerar en anslutning till beräkning eller ett SQL-lager.

Metoder

Klassen Connection innehåller följande metoder.

Cursor klass

Representerar en mekanism för att bläddra över dataposter.

Om du vill skapa ett Cursor objekt anropar cursor du metoden för klassen Anslutning.

Attribut

Bland de markerade Cursor attributen finns följande:

Metoder

Bland de valda Cursor metoderna finns följande:

Row klass

Radklassen är en tupppelliknande datastruktur som representerar en enskild resultatrad i ett SQL-frågeresultat. Om raden innehåller en kolumn med namnet "my_column"kan du komma åt fältet "my_column" i row via row.my_column. Du kan också använda numeriska index för att komma åt fält, till exempel row[0]. Om kolumnnamnet inte tillåts som ett attributmetodnamn (till exempel börjar det med en siffra) kan du komma åt fältet som row["1_my_column"].

Sedan version 1.0

Bland de valda Row metoderna finns:

Metoder

Typkonverteringar

I följande tabell mappas Apache Spark SQL-datatyper till motsvarande Python-datatyper.

Felsökning

tokenAuthWrapperInvalidAccessToken: Invalid access token meddelande

Problem: När du kör koden visas ett meddelande som liknar Error during request to server: tokenAuthWrapperInvalidAccessToken: Invalid access token.

Möjlig orsak: Värdet som skickas till är inte en giltig personlig Åtkomsttoken för access_token Azure Databricks.

Rekommenderad korrigering: Kontrollera att det värde som skickades till access_token är korrekt och försök igen.

gaierror(8, 'nodename nor servname provided, or not known') meddelande

Problem: När du kör koden visas ett meddelande som liknar Error during request to server: gaierror(8, 'nodename nor servname provided, or not known').

Möjlig orsak: Värdet som skickas till server_hostname är inte rätt värdnamn.

Rekommenderad korrigering: Kontrollera att det värde som skickades till server_hostname är korrekt och försök igen.

Mer information om hur du hittar serverns värdnamn finns i Hämta anslutningsinformation för en Azure Databricks-beräkningsresurs.

IpAclError meddelande

Problem: När du kör koden visas meddelandet Error during request to server: IpAclValidation när du försöker använda anslutningen på en Azure Databricks notebook.

Möjlig orsak: Du kan ha ip-tillåtna listor aktiverade för Azure Databricks-arbetsytan. Med listan över TILLÅTNA IP-adresser tillåts inte anslutningar från Spark-kluster tillbaka till kontrollplanet som standard.

Rekommenderad korrigering: Be administratören att lägga till undernätet för beräkningsplanet i listan över tillåtna IP-adresser.

Ytterligare resurser

Mer information finns i:

• Databricks SQL Connector for Python-lagringsplatsen på GitHub
• Datatyper
• Inbyggda typer (för bool, bytearray, float, intoch str) på Python-webbplatsen
• datetime (för datetime.date och datatime.datetime) på Python-webbplatsen
• decimal ( för decimal.Decimal) på Python-webbplatsen
• Inbyggda konstanter (för NoneType) på Python-webbplatsen