Installieren Sie die Qiskit C API

In dieser Anleitung wird beschrieben, wie Sie die Qiskit-C-API installieren und verwenden. Nachdem die Installation abgeschlossen ist, lesen Sie den Artikel „Erweiterung von Python mit der Qiskit-C-API “.

Das folgende Beispiel erstellt eine Observable mit 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;
}

UNIX-ähnlich

Dieser Abschnitt enthält Build-Anweisungen für UNIX-ähnliche Systeme.

Anforderungen

Für die Kompilierung sind die folgenden Werkzeuge erforderlich:

Ein Rust-Compiler: siehe zum Beispiel die Anleitung zur Installation von Qiskit aus dem Quellcode
Ein C-Compiler: zum Beispiel GCC auf Linux und Clang auf MacOS. Die C-API von Qiskit ist kompatibel mit einem Compiler, der dem C11 standard entspricht.
/path/to/.cargo/bincbindgen: Ein Tool zum Erstellen des C-Headers, das Sie mit cargo install cbindgen installieren können. Die Ausführung des Tools über die Befehlszeile sollte aktiviert sein; dazu muss möglicherweise Ihre PATH Variable exportiert werden, um sie einzubinden.
Python Bibliothek installiert ( Python 3.9 +): Die Bibliothek „ Python “ wird bei der dynamischen Verknüpfung benötigt. Beachten Sie, dass „ Python “ zur Laufzeit nicht verwendet wird und der Interpreter nie initialisiert wird; es müssen lediglich einige Symbole aus libpython definiert werden. Weitere Einzelheiten finden Sie in dieser Ausgabe.
(GNU) Make: Dies ist optional, wird aber empfohlen, um automatische Installationsprozesse zu verwenden.

Mit diesem Code wird überprüft, ob alles installiert wurde:

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

Build erstellen

Um den C-Header und die Bibliothek zu erstellen, können Sie den folgenden Make-Befehl¹ im Qiskit-Root ausführen,

make c

die die kompilierte gemeinsame Bibliothek in dist/c/lib und den Header qiskit.h mit allen Funktionsdeklarationen in allen Funktionsdeklarationen in dist/c/include. Beachten Sie, dass der genaue Name der Bibliothek von der von der Plattform ab; zum Beispiellibqiskit.so auf UNIX und libqiskit.dylib auf MacOS. (Beachten Sie, dass dieser Schritt derzeit viele Warnungen auslöst, was zu erwarten ist und keinen Grund zur Beunruhigung darstellt. Zukünftige Versionen werden diese Warnungen entfernen)

Sie können dann ein C-Programm mit dem Qiskit C-Header und der Bibliothek kompilieren:

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

Um sicherzustellen, dass die Qiskit-Bibliothek beim Binden gefunden wird, setzen Sie den Pfad der Laufzeitbibliothek auf include /path/to/dist/c/lib. Wenn die Bibliothek Python beim dynamischen Linken nicht standardmäßig verfügbar ist, muss diese ebenfalls hinzugefügt werden. Diese Befehle hängen von der jeweiligen Plattform ab. Unter 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

Unter Mac OS:

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

Alternativ können Sie den Pfad der Laufzeitbibliothek während der Kompilierung festlegen, indem Sie

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

zu den Compiler-Flags. Darüber hinaus muss die Bibliothek Python während des dynamischen Linkens verfügbar sein. In Linux Umgebungen ist dies normalerweise der Standard.

Jetzt können Sie die Binärdatei ausführen:

./example.o

die bei Verwendung des zuvor gezeigten Beispielsschnipsels Folgendes ausgeben sollte

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] }

Fenster

Dieser Abschnitt enthält Anweisungen für die Erstellung von Windows-Systemen.

Es gibt zwei voneinander unabhängige Möglichkeiten, die C-API unter Windows zu nutzen:

Erstellen Sie Erweiterungsmodule für „ Python “, die die Qiskit-C-API nutzen. Befolgen Sie die Schritte 1 bis 5. Dieser Ansatz nutzt die C-Header, die im qiskit Paket „ Python “ enthalten sind, und erfordert weder Rust noch cbindgen.
Erstellen Sie die eigenständige C-Bibliothek, die von einem reinen C-Programm aus eingebunden werden kann, wie es im Abschnitt „UNIX-ähnlich“ beschrieben ist. Führen Sie Schritt 1 durch und fahren Sie anschließend mit dem Abschnitt „Erstellen der eigenständigen Bibliothek “ fort, in dem die zusätzlichen Anforderungen aufgeführt sind.

Anforderungen

Für einige Schritte sind Administratorrechte erforderlich.
5–8 GB freier Speicherplatz.
Ein C-Compiler: Microsoft Visual C++ (MSVC), der in Schritt 1 installiert wurde.
Eine 64-Bit-Installation von „ Python “ ( 3.10 oder höher), die in Schritt 1 installiert wurde.

Vorbereitende Schritte

Richten Sie Ihren Arbeitsbereich ein. Dies sollte ein kurzer Pfad auf einem lokalen Laufwerk sein. Verwenden Sie keine Ordner unter „ OneDrive-synced “ (wie z. B. „Dokumente“ oder „Desktop“), keine Netzlaufwerke und keine Pfade mit Leerzeichen oder Nicht-ASCII-Zeichen. Wenn Ihr Benutzername nicht-englische Zeichen enthält, legen Sie ihn bitte nicht in Ihrem Benutzerordner ab.

Beispiele für korrekte Arbeitsverzeichnispfade: C:\workspace, D:\workspace, C:\Users\john\workspace

Schritt 1. Voraussetzungen installieren

Es handelt sich um einen umfangreichen Download (2–5 GB, 10–30 Min.). Installieren Sie es zunächst, damit Sie sofort wissen, ob Ihr Computer kompatibel ist.
Note
Erfordert Administratorrechte.
Option A — winget Öffnen Sie ein „ PowerShell “-Terminal und führen Sie Folgendes aus:
```
winget install Microsoft.VisualStudio.2022.BuildTools --override "--add Microsoft.VisualStudio.Workload.VCTools --includeRecommended --passive --wait"
```
Das Terminal scheint während der Ausführung des Installationsprogramms eingefroren zu sein. Das ist normal und dauert 10 bis 30 Minuten. Schauen Sie in Ihrer Taskleiste nach, ob dort ein Fenster mit dem Namen „Visual Studio Installer“ angezeigt wird.
Falls winget nicht erkannt wird, aktualisieren Sie den App Installer über den Microsoft Store oder nutzen Sie Option B.
Option B – Manueller Download Öffnen Sie die Website „Visual Studio Build Tools für C++“ und klicken Sie auf „Build Tools herunterladen“. Führen Sie die ausführbare Datei aus, um die Installation zu starten.
Wenn sich das Fenster „Visual Studio installieren“ öffnet, wählen Sie auf der Registerkarte „Workloads“ die Option „Desktop-Entwicklung mit C++“ aus. Weitere Informationen finden Sie auf der Seite „C- und C++-Unterstützung in Visual Studio installieren “.
winget install Microsoft.VisualStudio.CodeLaden Sie VS Code von der Website „ Visual Studio Code “ herunter oder führen Sie das Programm aus. Führen Sie die heruntergeladene ausführbare Datei aus, um VS Code zu installieren.
Führen Sie nach der Installation die folgenden Schritte aus:
1. VS Code öffnen
2. C:\workspaceKlicken Sie auf „Datei“ → „Ordner öffnen“ und wählen Sie dann Ihren Arbeitsbereich aus (zum Beispiel ).
3. Klicken Sie auf „Terminal“ → „Neues Terminal“, um ein „ PowerShell “-Terminal zu öffnen.
4. Klicken Sie links auf das Symbol „Erweiterungen“ oder drücken Sie Strg+Umschalt+X. ms-vscode.cpptoolsSuchen Sie im Fenster „Erweiterungen“ nach, ms-toolsai.jupyter, und und installieren Sie ms-python.pythondiese.
Führen Sie die restlichen Befehle in dieser Anleitung im VS Code-Terminal aus, sofern nicht anders angegeben. Das VS Code-Terminal ist standardmäßig auf „ PowerShell, “ eingestellt, um Verwechslungen mit dem in Windows integrierten Befehlsfenster zu vermeiden.
Setzen Sie die Arbeitsbereichsvariable. workspaceWenn Ihr Arbeitsbereich beispielsweise den Namen hat, führen Sie Folgendes aus:
```
$WORKSPACE = "C:\workspace"   # change to your workspace path
mkdir $WORKSPACE -Force
cd $WORKSPACE
```

Python 3.12 (empfohlene Version)

Python 3.12 wird empfohlen, da es die beste Verfügbarkeit von Rädern für qiskit-aer und andere Abhängigkeiten bietet. 3.10 Auch 3.11 funktioniert, allerdings fehlen bei 3.13 oder neueren Versionen möglicherweise vorgefertigte Wheels für einige Pakete.

Öffnen Sie das VS Code-Terminal und führen Sie den folgenden Code aus, um eine geeignete Version von „ Python “ zu ermitteln:

# ── 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'" }

Falls der Download nicht funktioniert hat oder Sie einen manuellen Download bevorzugen, kommentieren Sie die Codezeilen aus, die Python 3.12 installieren, und laden Sie anschließend Python 3.12 von der Website Python herunter. Führen Sie die ausführbare Datei aus, um „ Python “ zu installieren. Wählen Sie während der Installation die Option „ Python zum PATH hinzufügen“ aus und führen Sie anschließend den obigen Codeausschnitt erneut aus, um sicherzustellen, dass das Programm gefunden wird.

Hinweise

Verwenden Sie NICHT die Microsoft Store- Python, da darin die C-Header fehlen. Wenn python dadurch der Microsoft Store geöffnet wird, deaktivieren Sie den Alias unter „Windows-Einstellungen“ → „Apps“ → „Erweiterte App-Einstellungen“ → „Aliase für die App-Ausführung“.
Anaconda-Benutzer: Führen Sie den Befehl conda deactivate so lange aus, bis das (Basis-)Präfix verschwindet. Wenn das Problem weiterhin besteht, öffnen Sie ein neues Terminal in VS Code.

Dies ist nur erforderlich, wenn Sie Lab-Repositorys klonen. Führen Sie winget install Git.Git aus.

Schritt 2 – Einrichten der virtuellen Umgebung „ Python “ mit Qiskit

Das VS Code-Terminal zurücksetzen

Öffnen Sie das VS Code-Terminal und setzen Sie es zurück:

$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'"
}

Erlauben Sie die Ausführung des Skripts (einmal pro Benutzer) und erstellen Sie anschließend die virtuelle Umgebung:
```
Set-ExecutionPolicy -Scope CurrentUser RemoteSigned
cd $WORKSPACE
& $PYTHON_EXE -m venv .venv --prompt workspace
.\.venv\Scripts\Activate.ps1
```
Wenn bei der Aktivierung eine rote Fehlermeldung mit dem Hinweis „Skripte deaktiviert“ angezeigt wird, wurde die Set-ExecutionPolicy Zeile nicht ausgeführt. Führen Sie den Vorgang manuell aus und versuchen Sie es dann erneut.
(workspace)Deine Eingabeaufforderung sollte nun anzeigen.
Verifizieren:
```
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 vermeidet das Kompilieren qiskit-aer aus dem Quellcode. Wenn qiskit-aer es immer noch nicht funktioniert, versuche es mit pip install qiskit-aer --only-binary=:all: oder überspringe diesen Schritt. qiskit-aer ist optional und wird nur für die lokale Simulation benötigt.
Note
Nach der Einrichtung NICHT ausführen pip install --upgrade qiskit . Ein Upgrade auf eine neue Nebenversion führt dazu, dass C-Erweiterungen, die auf der alten Version basieren, nicht mehr funktionieren.

Schritt 3 – Laden Sie die MSVC-Umgebung

Führen Sie den folgenden Code in jeder neuen „ Python “-Sitzung aus (beispielsweise bei jedem Neustart eines Jupyter-Kernels). Es ermittelt automatisch den Speicherort der MSVC-Entwicklerumgebung und lädt diese, sodass Sie die integrierte Eingabeaufforderung „ x64 “ nicht benötigen.

Das Beispiel in dieser Dokumentation erstellt C-Erweiterungsmodule unter Verwendung von setuptools mit MSVC. QISKIT_PYTHON_EXTENSIONIn der Regel definiert man, bindet man qiskit.hein und ruft qk_import() in der init-Funktion auf. Zum Kompilieren werden nur die Header-Dateien von qiskit.capi.get_include() benötigt – es wird keine Bibliothek eingebunden. Weitere Informationen finden Sie unter „Erweiterung von Qiskit in Python mit C “.

MSVC-Umgebung laden

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)

Überprüfen Sie die Einrichtung

Überprüfen Sie, ob die Einrichtung funktioniert hat:

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.")

Schritt 4 – Funktionstest: Erstellen einer C-Erweiterung

Führen Sie den folgenden Code aus. Es schreibt Quelldateien in _smoke_pkg/, erstellt eine C-Erweiterung für die Qiskit-C-API und importiert das Ergebnis. Wenn die Meldung „SMOKE TEST PASSED“ angezeigt wird, ist Ihre Toolchain einsatzbereit.

Das Paket folgt dem Verfahren „Extend Qiskit in Python with C“ und nutzt Funktionen aus der Qiskit-C-API-Referenz.

Code für den Smoke-Test

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.")

Schritt 5 – VS Code konfigurieren (optional)

Zur Vereinfachung können Sie die folgenden Schritte befolgen, um „ IntelliSense “ für C-Dateien einzurichten und den Interpreter „ Python “ automatisch auszuwählen.

Führen Sie im VS Code-Terminal den folgenden Code aus:
```
mkdir $WORKSPACE\.vscode -Force
```

Erstellen Sie die Konfigurationsdatei

Erstellen Sie .vscode/settings.json in Ihrem Arbeitsbereich Folgendes, indem Sie diesen Code ausführen:

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

Erstellen Sie die Eigenschaftsdatei

.vscode/c_cpp_properties.jsonDer folgende Code gibt das JSON-Format aus, das Sie in einfügen müssen:

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('}')

Erstellen .vscode/extensions.json Sie in VS Code eine Datei mit folgendem Inhalt:
```
{
    "recommendations": ["ms-python.python", "ms-toolsai.jupyter", "ms-vscode.cpptools"]
}
```

Stellen Sie die eigenständige Bibliothek bereit

In diesem Abschnitt wird die eigenständige C-Bibliothek erstellt, die nur benötigt wird, wenn Sie reine C-Programme kompilieren und verknüpfen möchten, wie im Abschnitt „UNIX-ähnliche Systeme“ beschrieben. Zusätzlich zu den Voraussetzungen aus Schritt 1 sind hierfür folgende Werkzeuge erforderlich:

Ein Rust-Compiler: siehe zum Beispiel die Anleitung zur Installation von Qiskit aus dem Quellcode
cbindgen: Ein Tool zum Erstellen des C-Header-Dateis, das Sie mit cargo install cbindgen. installieren können. Die Ausführung des Tools über die Befehlszeile sollte aktiviert sein; dazu muss möglicherweise Ihre PATH Variable aktualisiert werden, um den Cargo-Pfad einzubeziehen.
Eine „ Python “-Installation mit Zugriff auf sowohl python3.lib als auch python3.dll
Ein Klon des Qiskit-Repositorys (git clone https://github.com/Qiskit/qiskit.git)

Kompilieren Sie zunächst die qiskit_cext dynamische Bibliothek, indem Sie im VS Code-Terminal ( PowerShell ) im Qiskit-Stammverzeichnis folgenden Befehl ausführen:
```
$env:PATH = "\path\to\pythonlib;" + $env:PATH
cargo rustc --release --crate-type cdylib -p qiskit-cext
```
Dies erzeugt die dynamische Bibliothek .dll und die zugehörige Datei .dll.lib in target/release. Als nächstes erzeugen Sie den Header mit
```
cbindgen --crate qiskit-cext --output dist\c\include\qiskit.h
```
Dadurch wird der MSVC-kompatible Header in dist\c\include. geschrieben.
Jetzt können Sie das C-Programm mit cl kompilieren. Damit der Compiler die Qiskit-Bibliothek findet, fügen target\release Sie sie in die PATH Variable ein.
```
$env:PATH = "\path\to\target\release;" + $env:PATH
cl example.c qiskit_cext.dll.lib -I\path\to\dist\c\include
```
Bevor du das Programm ausführst, gib den Pfad zu deiner python3.dll. an.
```
$env:PATH = "\path\to\python3-dll;" + $env:PATH
.\example.exe
```
sollte dann drucken
```
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] }
```

Fehlerbehebung

Aktualisieren Sie den App-Installer über den Microsoft Store oder nutzen Sie die entsprechenden Links zum manuellen Download
Führen Sie die MSVC-Wägezelle (Schritt 3) erneut aus oder verwenden Sie die Eingabeaufforderung „ x64 Native Tools“
Gehen Sie zu „Einstellungen“ → „Apps“ → „Erweiterte App-Einstellungen“ → „Aliase für die App-Ausführung“ und deaktivieren Sie die Funktion. python.exe
Ausführen Set-ExecutionPolicy -Scope CurrentUser RemoteSigned , dann erneut versuchen
Führen Sie den Befehl aus python -c "import qiskit.capi; print(qiskit.capi.get_include())" und überprüfen Sie, ob der Pfad vorhanden ist
pip install "qiskit[visualization]~=2.4.2" ausführen
Führen Sie pip install qiskit-aer --only-binary=:all: aus. Sollte auch das nicht funktionieren, verwenden Sie „ Python “ 3.12 oder lassen Sie „aer“ weg, da es optional ist
Die kompilierte Qiskit-C-Erweiterung und die installierte Qiskit-Version müssen dieselbe Versionsnummer aufweisen. Installieren Sie Qiskit erneut mit pip install "qiskit~=2.4.2"
Eine C-Erweiterung kann nicht live erneut importiert werden. Starten Sie den Kernel neu, führen Sie die MSVC-Befehle (Schritt 3) erneut aus und erstellen Sie anschließend die Projektdateien neu
Set-ExecutionPolicy -Scope CurrentUser RemoteSigned
Verwenden Sie einen kurzen Stammpfad unter C:\ (zum Beispiel, C:\workspace oder den Pfad, den Sie im Einrichtungsschritt festgelegt haben), oder aktivieren Sie „Lange Pfade“: Einstellungen → System → Für Entwickler → Lange Pfade
Führe den Vorgang conda deactivate so lange aus, bis CONDA_DEFAULT_ENV und CONDA_PREFIX beide aus der Umgebung verschwunden sind. Erkundigen Sie sich bei $env:CONDA_PREFIX. Sollten die Probleme weiterhin bestehen, öffnen Sie eine neue „ PowerShell “-Eingabeaufforderung (keine Anaconda-Eingabeaufforderung) und wiederholen Sie den Vorgang ab Schritt 2.
Die virtuelle Umgebung hat die C-Laufzeitumgebung von conda übernommen und kann nicht ortsfest eingerichtet werden. Löschen Sie es, laden Sie „ Python “ unter 3.12 von der Website Python herunter und führen Sie eine Neuerstellung durch. $PYTHON_EXE``Remove-Item -Recurse -Force .venvFühren Sie das Skript „ Python “ aus, führen Sie anschließend das Skript zur Erkennung aus Schritt 1 erneut aus, um die Einstellungen festzulegen, und erstellen Sie dann die virtuelle Umgebung neu (Schritt 2).
Conda dringt wahrscheinlich in die virtuelle Umgebung ein. Bitte überprüfen Sie die beiden Punkte direkt darüber. Überprüfen Sie außerdem, ob „ Python “ eine 64-Bit-Version ist: python -c "import platform; print(platform.architecture())"
Ihr Benutzername oder der Pfad zu Ihrem Arbeitsbereich enthält Nicht-ASCII-Zeichen. C:\workspaceVerschieben Sie den Arbeitsbereich in einen kurzen Pfad, der ausschließlich aus ASCII-Zeichen besteht (zum Beispiel )
Der Arbeitsbereichsordner wird von OneDrive synchronisiert. Verschieben Sie die Datei in einen lokalen Pfad wie beispielsweise C:\workspace
Löschen Sie den _smoke_pkg Ordner in Ihrem Arbeitsbereich, führen Sie die MSVC-Zelle erneut aus und führen Sie anschließend die Smoke-Test-Zelle erneut aus
In Ihrem Netzwerk wird ein Proxy verwendet, der den Zugriff auf HTTPS blockiert. Führen Sie den Befehl aus pip install --trusted-host pypi.org --trusted-host files.pythonhosted.org qiskit oder fragen Sie Ihren Netzwerkadministrator nach dem Proxy-CA-Zertifikat
Fügen Sie die Ordner und _smoke_pkg Ihres Arbeitsbereichs .venv zu den Ausschlüssen von Defender hinzu, indem Sie zu „Windows-Sicherheit“ → „Viren- und Bedrohungsschutz“ → „Einstellungen verwalten“ → „Ausschlüsse“ navigieren
Es sind Administratorrechte erforderlich. Bitten Sie Ihre IT-Abteilung um Zugriff
Die.pyd-Datei ist vom laufenden Kernel gesperrt. Starten Sie den Kernel neu (Strg+Umschalt+P → Jupyter: Kernel neu starten), führen Sie Schritt 3 erneut aus und erstellen Sie anschließend die Projektdatei neu
Möglicherweise befinden Sie sich auf cmd.exe statt auf PowerShell. Überprüfen Sie Ihre Eingabeaufforderung: „ PowerShell “ zeigt PS C:\>… an, „cmd“ zeigt C:\>… an. Öffnen Sie „ PowerShell “ über das Startmenü oder mit Win+X
Die --passive --wait Flags blockieren PowerShell, während das Installationsprogramm im Hintergrund läuft. Schauen Sie in Ihrer Taskleiste nach, ob dort ein Fenster mit dem Namen „Visual Studio Installer“ angezeigt wird. Die Installation kann 10 bis 30 Minuten dauern

Nächste Schritte

Empfehlungen

Erfahren Sie, wie Sie „ Python “ mit der Qiskit-C-API erweitern können.
Installieren Sie Qiskit.
Entdecken Sie die Qiskit-C-API-Referenz.

Wenn Sie Make nicht installiert haben, suchen Sie Makefile im Qiskit-Stammverzeichnis nach den erforderlichen Befehlen – oder installieren Sie Make einfach; es ist noch nicht zu spät. ↩

War diese Seite hilfreich?

Melden Sie auf GitHub einen Fehler, einen Tippfehler oder fordern Sie Inhalte an.

Installieren Sie die Qiskit C API

UNIX-ähnlich

Anforderungen

Build erstellen

Fenster

Anforderungen

Vorbereitende Schritte

Schritt 1. Voraussetzungen installieren

Schritt 2 – Einrichten der virtuellen Umgebung „ Python “ mit Qiskit

Schritt 3 – Laden Sie die MSVC-Umgebung

Schritt 4 – Funktionstest: Erstellen einer C-Erweiterung

Schritt 5 – VS Code konfigurieren (optional)

Stellen Sie die eigenständige Bibliothek bereit

Fehlerbehebung

Nächste Schritte

Footnotes