Installare l'API Qiskit C

Questa guida illustra come installare e utilizzare l'API C di Qiskit. Una volta completata l'installazione, leggi Estendere l' Python con l'API C di Qiskit.

L'esempio seguente costruisce un osservabile con C:

// file: example.c
#include <stdio.h>
#include <stdint.h>
#include <qiskit.h>

int main(int argc, char *argv[]) {
    // build a 100-qubit empty observable
    uint32_t num_qubits = 100;
    QkObs *obs = qk_obs_zero(num_qubits);

    // add the term 2 * (X0 Y1 Z2) to the observable
    QkComplex64 coeff = {2, 0};
    QkBitTerm bit_terms[3] = {QkBitTerm_X, QkBitTerm_Y, QkBitTerm_Z}; 
    // bit terms: X Y Z
    uint32_t indices[3] = {0, 1, 2};  // indices: 0 1 2
    QkObsTerm term = {coeff, 3, bit_terms, indices, num_qubits};
    qk_obs_add_term(obs, &term);  // append the term

    // print some properties and the observable itself
    printf("num_qubits: %i\n", qk_obs_num_qubits(obs));
    printf("num_terms: %lu\n", qk_obs_num_terms(obs));
    printf("observable: %s\n", qk_obs_str(obs));

    // free the memory allocated for the observable
    qk_obs_free(obs);

    return 0;
}

simile a UNIX

Questa sezione fornisce le istruzioni di compilazione per i sistemi UNIX-like.

Requisiti

La compilazione richiede i seguenti strumenti:

Un compilatore Rust: vedere ad esempio la guida all'installazione di Qiskit dai sorgenti
Un compilatore C: ad esempio, GCC su Linux e Clang su MacOS. L'API C di Qiskit è compatibile con un compilatore conforme allo standard C11 standard.
cbindgen: uno strumento per creare l'header C, che è possibile installare con cargo install cbindgen Dovrebbe essere abilitata l'esecuzione dello strumento dalla riga di comando, il che potrebbe richiedere l'esportazione della PATH variabile per includere /path/to/.cargo/bin.
Python Libreria installata (Python 3.9 +): la libreria Python è necessaria durante il collegamento dinamico. Si noti che Python non viene utilizzato in fase di esecuzione e che l'interprete non viene mai inizializzato; è necessario definire solo alcuni simboli da libpython . Per ulteriori dettagli, consulta questo numero.
(GNU) Make: è facoltativo, ma è consigliato per utilizzare processi di installazione automatizzati.

Questo codice verifica che tutto sia stato installato:

rustc --version
gcc --version
cbindgen --version
make --version  # optional, but recommended

Genera

Per creare l'header e la libreria C, è possibile eseguire il seguente comando Make¹ nella root di Qiskit,

make c

che fornirà la libreria condivisa compilata in dist/c/lib e l'intestazione di qiskit.h con tutte le dichiarazioni di funzione in dist/c/include. Si noti che il nome esatto della libreria dipende dalla piattaforma; ad esempio,libqiskit.so su UNIX e libqiskit.dylib su MacOS. (Si noti che questo passo attualmente emette molti avvisi, il che è previsto e non è motivo di allarme. Le versioni future rimuoveranno le avvertenze)

È quindi possibile compilare un programma C utilizzando l'intestazione e la libreria C di Qiskit:

gcc example.c -o example.o -I /path/to/dist/c/include -L /path/to/dist/c/lib -lqiskit

Per assicurarsi che la libreria Qiskit venga trovata durante il collegamento, impostare il percorso della libreria di runtime su include /path/to/dist/c/lib. Se la libreria Python non è disponibile per impostazione predefinita durante il collegamento dinamico, è necessario aggiungere anche questa. Questi comandi dipendono dalla piattaforma. Su Linux:

export LD_LIBRARY_PATH=/path/to/dist/c/lib:$LD_LIBRARY_PATH
# On Linux, the Python library is typically included 
# in the dynamic library path by default.
export LD_LIBRARY_PATH=/path/to/python/lib:$LD_LIBRARY_PATH

Su MacOS:

export DYLD_LIBRARY_PATH=/path/to/dist/c/lib:$DYLD_LIBRARY_PATH
export DYLD_LIBRARY_PATH=/path/to/python/lib:$DYLD_LIBRARY_PATH

In alternativa, è possibile impostare il percorso della libreria di runtime durante la compilazione aggiungendo

-Wl,-rpath,/path/to/dist/c/lib
# same for Python

ai flag del compilatore. Inoltre, la libreria Python deve essere disponibile durante il collegamento dinamico. Negli ambienti Linux è tipicamente l'impostazione predefinita.

Ora è possibile eseguire il binario:

./example.o

che, se si utilizza lo snippet di esempio mostrato in precedenza, dovrebbe stampare

num_qubits: 100
num_terms: 1
observable: SparseObservable { num_qubits: 100, 
coeffs: [Complex { re: 2.0, im: 0.0 }], 
bit_terms: [X, Y, Z], 
indices: [0, 1, 2], 
boundaries: [0, 3] }

Windows

Questa sezione fornisce le istruzioni di compilazione per i sistemi Windows.

Esistono due modi distinti per utilizzare l'API C su Windows:

Creare moduli di estensione per l' Python e che utilizzino l'API C di Qiskit. Seguire i passaggi da 1 a 5. Questo percorso utilizza le intestazioni C fornite con il pacchetto qiskitPython e non richiede né Rust né cbindgen.
Compilare la libreria C autonoma da collegare a un programma scritto interamente in C, come illustrato nella sezione dedicata ai sistemi di tipo UNIX. Completa la Fase 1, quindi passa alla sezione "Compilazione della libreria autonoma", in cui sono elencati i requisiti aggiuntivi.

Requisiti

Per alcune operazioni sono necessari i diritti di amministratore.
5-8 GB di spazio libero su disco.
Un compilatore C: Microsoft Visual C++ (MSVC), installato nel Passo 1.
Un'installazione a 64 bit di Python (3.10 o versione successiva), installata nel Passo 1.

Prima di iniziare

Crea il tuo spazio di lavoro. Dovrebbe trattarsi di un percorso breve su un'unità locale. Non utilizzare cartelle d OneDrive-synced e (come "Documenti" o "Desktop"), unità di rete o percorsi contenenti spazi o caratteri non ASCII. Se il tuo nome utente contiene caratteri non inglesi, non inserirlo nella cartella utente.

Esempi di percorsi corretti per lo spazio di lavoro: C:\workspace, D:\workspace, C:\Users\john\workspace

Passo 1. Installare i prerequisiti

Si tratta di un file di grandi dimensioni (2-5 GB, 10-30 min). Installalo prima, così saprai subito se il tuo computer è compatibile.
Note
Richiede i diritti di amministratore.
Opzione A — winget Apri un terminale di PowerShell e ed esegui quanto segue:
```
winget install Microsoft.VisualStudio.2022.BuildTools --override "--add Microsoft.VisualStudio.Workload.VCTools --includeRecommended --passive --wait"
```
Il terminale sembra bloccato durante l'esecuzione del programma di installazione. È normale e ci vorranno dai 10 ai 30 minuti. Controlla se nella barra delle applicazioni è presente una finestra denominata “Visual Studio Installer”.
Se winget l'app non viene riconosciuta, aggiorna App Installer dal Microsoft Store oppure ricorri all'opzione B.
Opzione B — download manuale Apri il sito web di Visual Studio Build Tools for C++ e fai clic su “Scarica gli strumenti di compilazione”. Esegui il file eseguibile per avviare l'installazione.
Quando si apre la finestra "Installazione di Visual Studio", nella scheda "Workload" selezionare "Sviluppo desktop con C++". Per ulteriori dettagli, consultare la pagina Installazione del supporto per C e C++ in Visual Studio.
Scarica VS Code dal sito Visual Studio Code oppure esegui winget install Microsoft.VisualStudio.Code. Esegui il file eseguibile scaricato per installare VS Code.
Una volta completata l'installazione, procedere come segue:
1. Apri VS Code
2. Fai clic su File → Apri cartella, quindi seleziona la tua area di lavoro (ad esempio, C:\workspace).
3. Fai clic su Terminale → Nuovo terminale per aprire un terminale PowerShell.
4. Fai clic sull'icona "Estensioni" a sinistra oppure premi Ctrl+Maiusc+X. Nella finestra "Estensioni", cerca e installa ms-python.python, ms-toolsai.jupyter, e ms-vscode.cpptools.
Esegui il resto dei comandi riportati in questa guida nel terminale di VS Code, salvo diversa indicazione. Il terminale di VS Code è impostato di default su PowerShell, per evitare confusione con la finestra di comando integrata in Windows.
Imposta la variabile dell'area di lavoro. Ad esempio, se il tuo spazio di lavoro si chiama workspace, esegui il seguente comando:
```
$WORKSPACE = "C:\workspace"   # change to your workspace path
mkdir $WORKSPACE -Force
cd $WORKSPACE
```

Python 3.12 (versione consigliata)

Python 3.12 è consigliato perché offre la migliore disponibilità di wheel per qiskit-aer e altre dipendenze. 3.10 Anche 3.11 funziona, ma su 3.13 o versioni successive potrebbero mancare le distribuzioni precompilate per alcuni pacchetti.

Apri il terminale di VS Code ed esegui il codice seguente per individuare una versione compatibile di Python :

# ── Pre-checks ───────────────────────────────────────────────────────────────
if ($env:CONDA_DEFAULT_ENV -or $env:CONDA_PREFIX) {
    Write-Warning "Conda is active. Run 'conda deactivate' first, or open a new terminal."
    return
}
if ($env:VIRTUAL_ENV) {
    Write-Warning "A virtual environment is active: $env:VIRTUAL_ENV — run 'deactivate' first."
    return
}

# ── Detect Python ────────────────────────────────────────────────────────────
$PYTHON_EXE = $null
try {
    $ver  = (py -3 --version 2>&1) -replace "Python ", ""
    $bits = py -3 -c "import platform; print(platform.architecture()[0])"
    $path = py -3 -c "import sys; print(sys.executable)"
    if ($path -match "(?i)(anaconda|miniconda|miniforge|mambaforge|[/\\]conda[/\\]|[/\\]envs[/\\])") {
        Write-Host "Skipping conda-managed Python at: $path"
    } elseif ([version]$ver -ge [version]"3.10" -and $bits -eq "64bit") {
        $PYTHON_EXE = $path
        Write-Host "Python $ver (64-bit) found: $PYTHON_EXE"
    } else {
        Write-Host "Skipping ($ver, $bits) — need 3.10+ 64-bit"
    }
} catch {}
if (-not $PYTHON_EXE) {
    try {
        $ver  = (python --version 2>&1) -replace "Python ", ""
        $bits = python -c "import platform; print(platform.architecture()[0])"
        $path = python -c "import sys; print(sys.executable)"
        if ($path -match "(?i)(anaconda|miniconda|miniforge|mambaforge|[/\\]conda[/\\]|[/\\]envs[/\\])") {
            Write-Host "Skipping conda-managed Python at: $path"
        } elseif ([version]$ver -ge [version]"3.10" -and $bits -eq "64bit") {
            $PYTHON_EXE = $path
            Write-Host "Python $ver (64-bit) found: $PYTHON_EXE"
        } else {
            Write-Host "Skipping ($ver, $bits) — need 3.10+ 64-bit"
        }
    } catch {}
}

# Install Python 3.12 if it wasn't found.
if (-not $PYTHON_EXE) {
    Write-Host "Not found. Installing Python 3.12..."
    winget install Python.Python.3.12
    Write-Host "Close and reopen the terminal, then rerun this snippet."
}
if ($PYTHON_EXE -and ($PYTHON_EXE -match '[^\x20-\x7E]')) {
    Write-Warning "Python path has non-ASCII characters. Keep your workspace on an ASCII path."
}
if ($PYTHON_EXE) { Write-Host "`$PYTHON_EXE = '$PYTHON_EXE'" }

Se il download non ha funzionato, oppure se preferisci effettuare il download manualmente, metti in commento le righe di codice che installano Python 3.12, quindi scarica Python 3.12 dal sito web Python. Esegui il file eseguibile per installare Python. Durante l'installazione, selezionare "Aggiungi Python al PATH", quindi rieseguire il frammento di codice sopra riportato per assicurarsi che venga individuato.

Note

NON utilizzare Microsoft Store Python poiché manca delle intestazioni C. Se python si apre Microsoft Store, disattiva l'alias andando su Impostazioni di Windows → App → Impostazioni avanzate delle app → Alias di esecuzione delle app.
Utenti di Anaconda: eseguite il comando conda deactivate fino a quando il prefisso (base) non scompare. Se il problema persiste, apri una nuova finestra di terminale in VS Code.

Necessario solo se si clonano i repository del laboratorio. Esegui winget install Git.Git.

Fase 2 - Configurazione dell'ambiente virtuale Python con Qiskit

Reimposta il terminale di VS Code

Apri il terminale di VS Code e reimpostalo:

$WORKSPACE = "C:\workspace"   # change to your workspace path
if (-not $PYTHON_EXE) {
    if (Get-Command py -ErrorAction SilentlyContinue) { $PYTHON_EXE = py -3 -c "import sys; print(sys.executable)" }
    elseif (Get-Command python -ErrorAction SilentlyContinue) { $PYTHON_EXE = python -c "import sys; print(sys.executable)" }
    else { Write-Host "Python not found — complete Step 1.3 first." ; return }
    Write-Host "`$PYTHON_EXE = '$PYTHON_EXE'"
}

Consenti l'esecuzione dello script (una volta per utente), quindi crea l'ambiente virtuale:
```
Set-ExecutionPolicy -Scope CurrentUser RemoteSigned
cd $WORKSPACE
& $PYTHON_EXE -m venv .venv --prompt workspace
.\.venv\Scripts\Activate.ps1
```
Se durante l'attivazione compare un messaggio di errore in rosso che indica "script disabilitati", significa che la Set-ExecutionPolicy riga non è stata eseguita. Eseguilo manualmente, poi riprova.
Il tuo prompt dovrebbe ora visualizzare (workspace).
Verifica:
```
Get-Command python | Select-Object -First 1 -ExpandProperty Source
# → workspace\.venv\Scripts\python.exe
```
```
python -m pip install --upgrade pip setuptools wheel
pip install "qiskit[visualization]>=2.4.2"
pip install --prefer-binary qiskit-ibm-runtime qiskit-aer
pip install notebook ipykernel ipywidgets  # optional: run the following Python steps in Jupyter
```
--prefer-binary evita di compilare qiskit-aer il codice sorgente. Se qiskit-aer continua a non funzionare, prova pip install qiskit-aer --only-binary=:all: oppure salta questo passaggio. qiskit-aer è facoltativo ed è necessario solo per la simulazione locale.
Note
NON eseguire pip install --upgrade qiskit il programma dopo l'installazione. L'aggiornamento a una nuova versione minore rende incompatibili le estensioni C compilate con quella precedente.

Fase 3 - Caricare l'ambiente MSVC

Esegui il codice seguente in ogni nuova sessione di Python (ad esempio, ogni volta che riavvii un kernel Jupyter). Individua e carica automaticamente l'ambiente di sviluppo MSVC, quindi non è necessario utilizzare il prompt dei comandi integrato di x64.

L'esempio riportato in questa documentazione illustra come compilare moduli di estensione C utilizzando setuptools MSVC. QISKIT_PYTHON_EXTENSION In genere, si definisce, si include qiskit.he si chiama qk_import() nella funzione init. In fase di compilazione sono necessarie solo le intestazioni provenienti qiskit.capi.get_include() da — non viene collegata alcuna libreria. Per ulteriori dettagli, consultare la sezione Estendere Qiskit in Python con il linguaggio C.

Carica l'ambiente MSVC

import os, sys, subprocess, glob, shutil

def load_msvc_env():
    if os.name != "nt":
        return "Not Windows — the system C compiler is used as-is."
    if shutil.which("cl"):
        return "cl.exe is already available in this kernel."

    pf86 = os.environ.get("ProgramFiles(x86)", r"C:\Program Files (x86)")
    pf = os.environ.get("ProgramFiles", r"C:\Program Files")
    vcvars = None

    vswhere = os.path.join(pf86, "Microsoft Visual Studio", "Installer", "vswhere.exe")
    if os.path.isfile(vswhere):
        # vswhere outputs UTF-8 regardless of system locale
        inst = subprocess.run(
            [vswhere, "-latest", "-products", "*",
             "-requires", "Microsoft.VisualStudio.Component.VC.Tools.x86.x64",
             "-property", "installationPath"],
            capture_output=True, text=True, encoding="utf-8").stdout.strip()
        if inst:
            cand = os.path.join(inst, "VC", "Auxiliary", "Build", "vcvars64.bat")
            if os.path.isfile(cand):
                vcvars = cand

    if not vcvars:
        pat = os.path.join("Microsoft Visual Studio", "*", "*",
                           "VC", "Auxiliary", "Build", "vcvars64.bat")
        hits = glob.glob(os.path.join(pf86, pat)) + glob.glob(os.path.join(pf, pat))
        if hits:
            vcvars = sorted(hits)[-1]

    if not vcvars:
        return ("Could not find vcvars64.bat. Install MSVC Build Tools (Step 1.3), "
                "or launch Jupyter from the x64 Native Tools Command Prompt.")

    # cmd.exe outputs in the OEM codepage (cp437/cp850/etc.), not the ANSI codepage
    out = subprocess.run(f'"{vcvars}" >nul 2>&1 && set',
                         capture_output=True, text=True, encoding="oem", shell=True).stdout
    for line in out.splitlines():
        if "=" in line:
            k, _, v = line.partition("=")
            os.environ[k] = v

    return ("Loaded MSVC from:\n  " + vcvars) if shutil.which("cl") \
        else "Ran vcvars64.bat but cl.exe is still not found — check your MSVC install."

print(load_msvc_env())
print("cl.exe on PATH:", shutil.which("cl") is not None)

Verifica la configurazione

Verifica che la configurazione abbia funzionato:

import importlib.util, shutil

checks = {
    "setuptools": importlib.util.find_spec("setuptools") is not None,
    "wheel":      importlib.util.find_spec("wheel") is not None,
    "cl.exe":     shutil.which("cl") is not None,
}
for name, ok in checks.items():
    print(f"  [{'PASS' if ok else 'FAIL':>4}] {name}")

if not checks["cl.exe"]:
    print("\n  cl.exe is not on PATH. rerun the cell above to load the MSVC environment.")
elif all(checks.values()):
    print("\n  Toolchain ready. Continue to the smoke test.")

Fase 4 - Test di funzionamento: creare un'estensione C

Esegui il codice seguente. Scrive i file sorgente in _smoke_pkg/, crea un'estensione C basata sull'API C di Qiskit e importa il risultato. Se viene visualizzato il messaggio "SMOKE TEST PASSED", la tua toolchain è pronta.

Il pacchetto segue la procedura descritta in "Estendere Qiskit in Python con il linguaggio C" e utilizza le funzioni riportate nel riferimento all'API C di Qiskit.

Codice per il test del fumo

import sys, subprocess, pathlib, importlib

root = pathlib.Path("_smoke_pkg")
pkg = root / "src" / "qgss_smoke"
pkg.mkdir(parents=True, exist_ok=True)

(root / "pyworkspace.toml").write_text("""
[build-system]
requires = ["setuptools", "qiskit>=2.4.2"]
build-backend = "setuptools.build_meta"

[workspace]
name = "qgss_smoke"
version = "0.0.1"
dependencies = ["qiskit>=2.4.2"]

[tool.setuptools]
package-dir = {"" = "src"}
""".lstrip())

(root / "setup.py").write_text("""
import qiskit
from setuptools import setup, Extension

core_ext = Extension(
    name="qgss_smoke._core",
    sources=["src/qgss_smoke/_coremodule.c"],
    include_dirs=[qiskit.capi.get_include()],
)
setup(ext_modules=[core_ext])
""".lstrip())

(pkg / "__init__.py").write_text("from . import _core\nbuild_demo = _core.build_demo\n")

(pkg / "_coremodule.c").write_text("""
#define QISKIT_PYTHON_EXTENSION
#include <Python.h>
#include <qiskit.h>
#include <stdint.h>

static PyObject *build_demo(PyObject *self, PyObject *args) {
    QkCircuit *qc = qk_circuit_new(2, 0);
    uint32_t q0[1] = {0};
    qk_circuit_gate(qc, QkGate_H, q0, NULL);
    uint32_t q1[1] = {1};
    qk_circuit_gate(qc, QkGate_X, q1, NULL);
    return qk_circuit_to_python_full(qc);
}

static PyMethodDef core_methods[] = {
    {"build_demo", build_demo, METH_NOARGS, "Build a 2-qubit demo circuit in C."},
    {NULL, NULL, 0, NULL},
};
static struct PyModuleDef core_module = {
    .m_base = PyModuleDef_HEAD_INIT,
    .m_name = "_core",
    .m_methods = core_methods,
};
PyMODINIT_FUNC PyInit__core(void) {
    if (qk_import() < 0) {
        return NULL;
    }
    return PyModuleDef_Init(&core_module);
}
""".lstrip())

# On Windows, an imported .pyd is file-locked by the OS. Drop the module from
# sys.modules BEFORE pip install --force-reinstall, otherwise pip fails with
# WinError 32 ("file in use") trying to overwrite the locked .pyd.
if "qgss_smoke._core" in sys.modules:
    del sys.modules["qgss_smoke._core"]
if "qgss_smoke" in sys.modules:
    del sys.modules["qgss_smoke"]

r = subprocess.run(
    [sys.executable, "-m", "pip", "install", "--no-build-isolation",
     "--force-reinstall", "--quiet", str(root.resolve())],
    capture_output=True, text=True,
)
if r.returncode != 0:
    output = (r.stderr + r.stdout).strip()
    print("BUILD FAILED:\n")
    print(output)
    if "WinError 32" in output or "being used by another process" in output:
        print("\n--- TIP ---")
        print("The .pyd file is locked because it was previously imported in this kernel.")
        print("Restart the kernel (Ctrl+Shift+P → 'Jupyter: Restart Kernel'), then rerun")
        print("the Step 3 MSVC cell first, then this cell again.")
    elif "cl.exe" in output.lower() or "vcvars" in output.lower() or "cannot find" in output.lower():
        print("\n--- TIP ---")
        print("The compiler was not found. rerun the Step 3 cell to load the MSVC environment.")
else:
    importlib.invalidate_caches()
    import qgss_smoke
    from qiskit import QuantumCircuit

    qc = qgss_smoke.build_demo()
    ops = dict(qc.count_ops())
    ok = isinstance(qc, QuantumCircuit) and ops.get("h") == 1 and ops.get("x") == 1

    print("Returned object is a QuantumCircuit:", isinstance(qc, QuantumCircuit))
    print("Gates built in C:", ops)
    print("\nSMOKE TEST PASSED — your Windows toolchain can build Qiskit C extensions."
          if ok else "\nSomething is off — check the gates above.")

Passaggio 5 — Configurazione di VS Code (facoltativo)

Per semplificare l'utilizzo, è possibile seguire questa procedura per configurare IntelliSense per i file C e selezionare automaticamente l'interprete Python.

Nel terminale di VS Code, esegui il seguente codice:
```
mkdir $WORKSPACE\.vscode -Force
```

Creare il file di configurazione

Crea .vscode/settings.json nel tuo spazio di lavoro eseguendo questo codice:

{
    "python.defaultInterpreterPath": "${workspaceFolder}/.venv/Scripts/python.exe",
    "python.terminal.activateEnvironment": true,
    "jupyter.notebookFileRoot": "${workspaceFolder}"
}

Creare il file delle proprietà

Il codice seguente visualizza il JSON che devi incollare in .vscode/c_cpp_properties.json:

import qiskit.capi

inc = qiskit.capi.get_include().replace("\\", "/")
print(".vscode/c_cpp_properties.json — create this file with the content below:\n")
print('{')
print('    "version": 4,')
print('    "configurations": [')
print('        {')
print('            "name": "Win32",')
print(f'            "includePath": ["{inc}"],')
print('            "defines": ["QISKIT_PYTHON_EXTENSION"],')
print('            "compilerPath": "cl.exe",')
print('            "cStandard": "c11",')
print('            "intelliSenseMode": "windows-msvc-x64"')
print('        }')
print('    ]')
print('}')

In VS Code, crea .vscode/extensions.json un file con questo contenuto:
```
{
    "recommendations": ["ms-python.python", "ms-toolsai.jupyter", "ms-vscode.cpptools"]
}
```

Compilare la libreria autonoma

Questa sezione consente di compilare la libreria C autonoma, necessaria solo se si desidera compilare e collegare programmi scritti interamente in C, come descritto nella sezione dedicata ai sistemi di tipo UNIX. Oltre ai prerequisiti della Fase 1, sono necessari i seguenti strumenti:

Un compilatore Rust: vedere ad esempio la guida all'installazione di Qiskit dai sorgenti
cbindgen: uno strumento per creare l'header C, che puoi installare con cargo install cbindgen. Dovrebbe essere abilitata l'esecuzione dello strumento dalla riga di comando; a tal fine potrebbe essere necessario aggiornare la PATH variabile per includere il percorso di Cargo.
Un'installazione di Python con accesso sia python3.lib a che a python3.dll
Un clone del repository Qiskit (git clone https://github.com/Qiskit/qiskit.git)

Per prima cosa, compila la qiskit_cext libreria dinamica eseguendo il seguente comando nel terminale di VS Code (PowerShell) nella directory principale di Qiskit:
```
$env:PATH = "\path\to\pythonlib;" + $env:PATH
cargo rustc --release --crate-type cdylib -p qiskit-cext
```
Questo genererà la libreria dinamica .dll e il file associato .dll.lib in target/release. Successivamente, generare l'intestazione con
```
cbindgen --crate qiskit-cext --output dist\c\include\qiskit.h
```
Questo scrive l'intestazione compatibile con MSVC in dist\c\include.
Ora puoi usare cl per compilare il programma in C. Per assicurarsi che il compilatore riesca a individuare la libreria qiskit, inseriscila target\release nella PATH variabile.
```
$env:PATH = "\path\to\target\release;" + $env:PATH
cl example.c qiskit_cext.dll.lib -I\path\to\dist\c\include
```
Prima di eseguire il programma, includi il percorso del tuo file python3.dll.
```
$env:PATH = "\path\to\python3-dll;" + $env:PATH
.\example.exe
```
dovrebbe quindi stampare
```
num_qubits: 100
num_terms: 1
observable: SparseObservable { num_qubits: 100, 
coeffs: [Complex { re: 2.0, im: 0.0 }], 
bit_terms: [X, Y, Z], 
indices: [0, 1, 2], 
boundaries: [0, 3] }
```

Risoluzione dei problemi

Aggiorna l'App Installer dal Microsoft Store oppure utilizza i link per il download manuale corrispondenti
Eseguire nuovamente la procedura relativa alla cella di carico MSVC (Fase 3) oppure utilizzare il prompt dei comandi di Native Tools di x64
Vai su Impostazioni → App → Impostazioni avanzate delle app → Alias di esecuzione delle app e disattiva python.exe
Esegui Set-ExecutionPolicy -Scope CurrentUser RemoteSigned , poi riprova
Esegui python -c "import qiskit.capi; print(qiskit.capi.get_include())" il comando e verifica che il percorso esista
Esegui pip install "qiskit[visualization]~=2.4.2"
Esegui pip install qiskit-aer --only-binary=:all:. Se anche questo non funziona, usa Python 3.12 oppure ignora aer, che è facoltativo
L'estensione C di Qiskit compilata e la versione di Qiskit installata devono corrispondere. Reinstallare Qiskit con pip install "qiskit~=2.4.2"
Un'estensione C non può essere reimportata in tempo reale. Riavviare il kernel, rieseguire i comandi MSVC (Fase 3), quindi ricompilare
Set-ExecutionPolicy -Scope CurrentUser RemoteSigned
Utilizza un percorso radice breve su C:\ (ad esempio, C:\workspace, oppure il percorso che hai impostato durante la configurazione), oppure abilita l'opzione "Percorsi lunghi": Impostazioni → Sistema → Per gli sviluppatori → Percorsi lunghi
Continua conda deactivate fino a quando CONDA_DEFAULT_ENV e CONDA_PREFIX non saranno entrambi scomparsi dall'ambiente. Verificare con $env:CONDA_PREFIX. Se il problema persiste, apri una nuova finestra di PowerShell (non un prompt di Anaconda) e riprova dal punto 2.
L'ambiente virtuale ha ereditato il runtime C di conda e non può essere fissato in modo permanente. Eliminalo, scarica il file Python (3.12) dal sito Python e ricompila. $PYTHON_EXE``Remove-Item -Recurse -Force .venvEseguire, quindi rieseguire lo snippet di rilevamento di Python descritto nel Passo 1 per impostare, quindi ricreare l'ambiente virtuale (Passo 2).
Probabilmente Conda sta causando una perdita nell'ambiente virtuale. Controlla entrambe le voci che si trovano immediatamente sopra questa. Verifica inoltre che Python sia a 64 bit: python -c "import platform; print(platform.architecture())"
Il nome utente o il percorso dell'area di lavoro contiene caratteri non ASCII. Spostare l'area di lavoro in un percorso breve composto esclusivamente da caratteri ASCII (ad esempio, C:\workspace)
La cartella dell'area di lavoro viene sincronizzata tramite OneDrive. Spostalo in un percorso locale come C:\workspace
Elimina la _smoke_pkg cartella dal tuo spazio di lavoro, riesegui la cella di carico MSVC, quindi riesegui la cella di test di funzionamento
La tua rete utilizza un proxy che intercetta HTTPS. Prova a eseguire il comando pip install --trusted-host pypi.org --trusted-host files.pythonhosted.org qiskit oppure chiedi all'amministratore di rete il certificato CA del proxy
Aggiungi le cartelle e _smoke_pkg della .venv tua area di lavoro alle esclusioni di Defender accedendo a Sicurezza di Windows → Protezione da virus e minacce → Gestisci impostazioni → Esclusioni
È necessario disporre dei diritti di amministratore. Chiedi al tuo reparto IT di concederti l'accesso
Il file.pyd è bloccato dal kernel in esecuzione. Riavvia il kernel (Ctrl+Shift+P → Jupyter: Riavvia kernel), riesegui il passaggio 3, quindi ricompila
Potresti trovarti su cmd.exe invece che su PowerShell. Controlla il tuo prompt: PowerShell mostra PS C:\>, cmd mostra C:\>. Apri PowerShell dal menu Start o con Win+X
I --passive --wait parametri di linea di comando PowerShell, mentre il programma di installazione viene eseguito in background. Controlla se nella barra delle applicazioni è presente una finestra denominata “Visual Studio Installer”. L'installazione può richiedere dai 10 ai 30 minuti

Passi successivi

Suggerimenti

Scopri come estendere l' Python e utilizzando l'API C di Qiskit.
Installa Qiskit.
Esplora la guida di riferimento dell'API C di Qiskit.

Se non hai installato Make, controlla la directory principale Makefile di Qiskit per i comandi richiesti, oppure installa semplicemente Make: non è troppo tardi. ↩

Questa pagina è stata utile?

Segnala un bug, un errore di battitura o richiedi contenuti su GitHub.

Installare l'API Qiskit C

simile a UNIX

Requisiti

Genera

Windows

Requisiti

Prima di iniziare

Passo 1. Installare i prerequisiti

Fase 2 - Configurazione dell'ambiente virtuale Python con Qiskit

Fase 3 - Caricare l'ambiente MSVC

Fase 4 - Test di funzionamento: creare un'estensione C

Passaggio 5 — Configurazione di VS Code (facoltativo)

Compilare la libreria autonoma

Risoluzione dei problemi

Passi successivi

Footnotes