Guida introduttiva: Connettersi utilizzando il driver mssql-python per Python

In questa guida introduttiva si connette uno script Python a un database creato e caricato con dati di esempio. Usi il mssql-python driver di Python per connetterti al tuo database ed eseguire operazioni di base, come leggere e scrivere dati.

Il mssql-python driver non richiede dipendenze esterne nei computer Windows. Il driver installa tutti gli elementi necessari con un'unica pip installazione, consentendo di usare la versione più recente del driver per i nuovi script senza interrompere altri script che non è necessario aggiornare e testare.

Usa l'esempio dell'autenticazione SQL locale in questo articolo solo per lo sviluppo locale su un'istanza di SQL Server che controlli. Per database SQL di Azure, i database SQL di Fabric, gli ambienti di sviluppo condivisi, la CI e le distribuzioni in produzione, iniziare con l'autenticazione Microsoft Entra o un altro flusso senza password.

Documentazione di mssql-python | mssql-python Codice sorgente | Pacchetto (PyPI) | Visual Studio Code

Prerequisiti

Python 3.10 o versione successiva.
Se Python non è già disponibile, installare il runtime Python e la gestione pacchetti pip da python.org.
Non si vuole usare il proprio ambiente? Segui Container e lo sviluppo locale per creare un devcontainer riproducibile o un ambiente di Codespaces su GitHub.
(Opzionale) Azure Command-Line Interface (CLI).

Crea o collegati a un database su SQL Server, database SQL di Azure o database SQL in Fabric. Usa i seguenti passaggi per configurare un database con lo AdventureWorks2025 schema di esempio e conserva la stringa di connessione per dopo.

Creare un database SQL

Crea o collegati a un database SQL su una delle seguenti piattaforme:

Creare un database SQL in pochi minuti usando il portale di Azure

Configurazione

Seguire questa procedura per configurare l'ambiente di sviluppo per sviluppare un'applicazione usando il mssql-python driver Python.

Annotazioni

Questo driver utilizza il protocollo Tabular Data Stream (TDS ). SQL Server, database SQL in Fabric e database SQL di Azure abilitano TDS di default, quindi non è necessaria alcuna configurazione aggiuntiva.

Prerequisiti per installare il sistema operativo

Installare prerequisiti specifici del sistema operativo monouso. Gli utenti Windows possono saltare questo passaggio. Per dettagli completi sulla piattaforma, vedi Installa mssql-python.

apk add libtool krb5-libs krb5-dev libstdc++

apt-get install -y libltdl7 libkrb5-3 libgssapi-krb5-2

dnf install -y libtool-ltdl krb5-libs

zypper install -y libltdl7 libkrb5-3 libgssapi-krb5-2

zypper install -y libltdl7

brew install openssl

Installare il pacchetto mssql-python

Ottieni il mssql-python pacchetto da PyPI.

Aprire un prompt dei comandi in una directory vuota.
Installare il pacchetto mssql-python.
```
pip install mssql-python
```

Installa il pacchetto python-dotenv

Ottieni il pacchetto python-dotenv da PyPI.

Nella stessa directory installare il python-dotenv pacchetto.

pip install python-dotenv

Controllare i pacchetti installati

Usa pip list per verificare che i pacchetti previsti siano installati.

pip list

Creare un nuovo file

Creare un file denominato app.py.

Aggiungere una docstring del modulo.

"""
Connects to a SQL database using mssql-python
"""

Importare pacchetti, incluso mssql-python.

from os import getenv
from dotenv import load_dotenv
from mssql_python import connect

Usare la mssql-python.connect funzione per connettersi a un database SQL.
```
load_dotenv()
conn = connect(getenv("SQL_CONNECTION_STRING"))
```
Nella directory corrente creare un nuovo file denominato .env.
All'interno del .env file aggiungere una voce per la stringa di connessione denominata SQL_CONNECTION_STRING. Usa uno dei seguenti esempi e sostituisci i segnaposto con i tuoi valori reali.

Per database SQL di Azure o database SQL in Fabric, inizia con l'autenticazione Microsoft Entra:
```
SQL_CONNECTION_STRING="Server=<server>;Database=<database>;Encrypt=yes;TrustServerCertificate=no;Authentication=ActiveDirectoryInteractive"
```
Per il SQL Server locale durante lo sviluppo, inizia con l'autenticazione SQL:
```
SQL_CONNECTION_STRING="Server=localhost,1433;Database=<database>;UID=<user_id>;PWD=<password>;Encrypt=yes;TrustServerCertificate=yes"
```
Attenzione

Trattalo .env come una comodità di sviluppo locale, non come un meccanismo di implementazione. Non effettuare mai un committ, non riutilizzare mai questo esempio di autenticazione SQL in ambienti condivisi o di produzione, e mantenere abilitata la validazione dei certificati al di fuori dello sviluppo locale.

Usa stringhe di connessione per adattare il campione a istanze nominate, contenitori o impostazioni avanzate. Se ti connetti a database SQL di Azure o SQL database in Fabric, usa l'autenticazione Microsoft Entra per opzioni di accesso senza password e interattive. Per indicazioni più ampie su segreti e certificati, consulta le migliori pratiche di sicurezza.

Suggerimento

In macOS, entrambi ActiveDirectoryInteractive e ActiveDirectoryDefault funzionano per l'autenticazione di Microsoft Entra. ActiveDirectoryInteractive richiede di accedere ogni volta che si esegue lo script. Per evitare ripetuti prompt di accesso, accedi una volta con il comando interfaccia della riga di comando di Azureaz login e usa ActiveDirectoryDefault. ActiveDirectoryDefault Riutilizza la credenziale memorizzata.

Esegui una query

Usa una stringa di query Transact-SQL (T-SQL) per eseguire una query e analizzarne i risultati.

Crea una variabile per la stringa di query T-SQL.

SQL_QUERY = """
SELECT TOP 5
    c.CustomerID,
    c.CompanyName,
    COUNT(soh.SalesOrderID) AS OrderCount
FROM SalesLT.Customer AS c
LEFT OUTER JOIN SalesLT.SalesOrderHeader AS soh
    ON c.CustomerID = soh.CustomerID
GROUP BY
    c.CustomerID,
    c.CompanyName
ORDER BY OrderCount DESC;
"""

Utilizzare cursor.execute per recuperare un set di risultati da una query sul database.
```
cursor = conn.cursor()
cursor.execute(SQL_QUERY)
```
Annotazioni

Questa funzione accetta qualsiasi query e restituisce un insieme di risultati. Per iterare sul set dei risultati, usa cursor.fetchone().

Usare cursor.fetchall con un for ciclo per ottenere tutti i record dal database. Poi, stampa i documenti.

records = cursor.fetchall()
for r in records:
    print(f"{r.CustomerID}\t{r.OrderCount}\t{r.CompanyName}")

Salvare il app.py file.

Aprire un terminale e testare l'applicazione.

python app.py

Ecco l'output previsto.

29485   1       Professional Sales and Service
29531   1       Remarkable Bike Store
29546   1       Bulk Discount Store
29568   1       Coalition Bike Company
29584   1       Futuristic Bikes

Inserire una riga come transazione

Eseguire un'istruzione INSERT in modo sicuro e passare parametri. Il passaggio di parametri come valori protegge l'applicazione da attacchi SQL injection .

Aggiungere un'importazione per randrange dalla libreria random all'inizio di app.py.
```
from random import randrange
```
Alla fine di app.py aggiungere codice per generare un numero di prodotto casuale.
```
productNumber = randrange(1000)
```
Suggerimento

Un numero di prodotto casuale riduce la probabilità di un errore duplicato della chiave quando esegui questo campione più di una volta.

Crea una stringa di istruzioni T-SQL.

SQL_STATEMENT = """
INSERT SalesLT.Product (
    Name,
    ProductNumber,
    StandardCost,
    ListPrice,
    SellStartDate
)
OUTPUT INSERTED.ProductID
VALUES (%(name)s, %(product_number)s, %(standard_cost)s, %(list_price)s, CURRENT_TIMESTAMP)
"""

Eseguire l'istruzione usando cursor.execute.

cursor.execute(
    SQL_STATEMENT,
    {
        'name': f'Example Product {productNumber}',
        'product_number': f'EXAMPLE-{productNumber}',
        'standard_cost': 100,
        'list_price': 200
    }
)

Recuperare il singolo risultato usando cursor.fetchone, stampare l'identificatore univoco del risultato e quindi eseguire il commit dell'operazione come transazione usando connection.commit.
```
result = cursor.fetchone()
print(f"Inserted Product ID : {result.ProductID}")
conn.commit()
```
Suggerimento

Facoltativamente, è possibile usare connection.rollback per eseguire il rollback della transazione.
Chiudere il cursore e la connessione usando cursor.close e connection.close.
```
cursor.close()
conn.close()
```
Salvare il app.py file e testare di nuovo l'applicazione.
```
python app.py
```
Ecco l'output previsto.
```
Inserted Product ID : 1001
```

Commenti e suggerimenti

Questa pagina è stata utile?

Ultimo aggiornamento: 2026-10-19