Installer l'API C de Qiskit

Ce guide explique comment installer et utiliser l'API C de Qiskit. Une fois l'installation terminée, consultez la section « Étendre l' Python s à l'aide de l'API C de Qiskit ».

L'exemple suivant construit un observable avec 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;
}

de type UNIX

Cette section fournit des instructions de construction pour les systèmes de type UNIX.

Exigences

La compilation nécessite les outils suivants :

Un compilateur Rust : voir par exemple le guide d'installation de Qiskit à partir des sources
Un compilateur C : par exemple, GCC sur Linux et Clang sur MacOS. L'API C de Qiskit est compatible avec un compilateur conforme à la norme C11 standard.
cbindgen: un outil permettant de créer l'en-tête C, que vous pouvez installer à l'aide de cargo install cbindgen L'exécution de l'outil depuis la ligne de commande devrait être activée, ce qui peut nécessiter d'exporter votre PATH variable pour inclure /path/to/.cargo/bin.
Python Bibliothèque installée ( Python 3.9 +) : la bibliothèque Python est requise lors de la liaison dynamique. Notez que Python n'est pas utilisé lors de l'exécution et que l'interpréteur n'est jamais initialisé; seuls certains symboles de libpython doivent être définis. Pour plus de détails, consultez ce numéro.
(GNU) Make : cette option est facultative, mais elle est recommandée pour utiliser les processus d'installation automatisés.

Ce code vérifie que tout a été installé :

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

Générer

Pour construire l'en-tête et la bibliothèque C, vous pouvez lancer la commande Make suivante¹ dans la racine de Qiskit,

make c

qui fournira la bibliothèque partagée compilée à dist/c/lib et l'en-tête qiskit.h avec toutes les déclarations de fonctions à toutes les déclarations de fonctions dans dist/c/include. Notez que le nom précis de la bibliothèque dépend de la plate-forme; par exemple,libqiskit.so sous UNIX et libqiskit.dylib sous MacOS. (Notez que cette étape émet actuellement beaucoup d'avertissements, ce qui est normal et ne constitue pas une raison de s'alarmer. Les versions ultérieures supprimeront les avertissements)

Vous pouvez ensuite compiler un programme C en utilisant l'en-tête et la bibliothèque C de Qiskit :

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

Pour s'assurer que la bibliothèque Qiskit est trouvée lors de l'établissement des liens, définissez le chemin d'accès à la bibliothèque d'exécution comme suit include /path/to/dist/c/lib. Si la bibliothèque Python n'est pas disponible par défaut lors de la liaison dynamique, elle doit également être ajoutée. Ces commandes dépendent de la plate-forme. Sous 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

Sous MacOS :

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

Vous pouvez également définir le chemin d'accès à la bibliothèque d'exécution lors de la compilation en ajoutant

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

aux drapeaux du compilateur. En outre, la bibliothèque Python doit être disponible lors de l'établissement de liens dynamiques. Dans les environnements Linux c'est généralement la valeur par défaut.

Vous pouvez maintenant exécuter le binaire :

./example.o

qui, si l'on utilise l'extrait d'exemple présenté précédemment, devrait imprimer

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

Fenêtres

Cette section fournit des instructions de construction pour les systèmes Windows.

Il existe deux méthodes distinctes pour utiliser l'API C sous Windows :

Développer des modules d'extension pour l' Python qui utilisent l'API C de Qiskit. Suivez les étapes 1 à 5. Cette méthode utilise les en-têtes C fournis avec le paquet qiskitPython et ne nécessite ni Rust ni cbindgen.
Compilez la bibliothèque C autonome afin de pouvoir la lier à un programme entièrement écrit en C, comme indiqué dans la section « Système de type UNIX ». Suivez l'étape 1, puis passez directement à la section « Compiler la bibliothèque autonome », qui répertorie les prérequis supplémentaires.

Exigences

Certaines étapes nécessitent des droits d'administrateur.
5 à 8 Go d'espace disque disponible.
Un compilateur C : Microsoft Visual C++ (MSVC), installé à l'étape 1.
Une installation 64 bits d' Python ( 3.10 ou version ultérieure), installée à l'étape 1.

Avant de commencer

Créez votre espace de travail. Il doit s'agir d'un chemin d'accès court sur un disque local. N'utilisez pas de dossiers d' OneDrive-synced s (tels que « Documents » ou « Bureau »), de lecteurs réseau, ni de chemins d'accès contenant des espaces ou des caractères non ASCII. Si votre nom d'utilisateur contient des caractères autres que ceux de l'anglais, ne le placez pas dans votre dossier utilisateur.

Exemples de chemins d'accès valides à l'espace de travail : C:\workspace, D:\workspace, C:\Users\john\workspace

Etape 1. Installation des prérequis

Il s'agit d'un fichier volumineux (2 à 5 Go, 10 à 30 minutes). Installez-le d'abord pour savoir immédiatement si votre ordinateur est compatible.
Note
Nécessite des droits d'administrateur.
Option A — winget Ouvrez un terminal « PowerShell » et exécutez la commande suivante :
```
winget install Microsoft.VisualStudio.2022.BuildTools --override "--add Microsoft.VisualStudio.Workload.VCTools --includeRecommended --passive --wait"
```
Le terminal semble bloqué pendant l'exécution du programme d'installation. C'est tout à fait normal; cela prendra entre 10 et 30 minutes. Vérifiez si une fenêtre intitulée « Visual Studio Installer » s'affiche dans votre barre des tâches.
Si winget l'application n'est pas reconnue, mettez à jour App Installer depuis le Microsoft Store ou utilisez l'option B.
Option B — téléchargement manuel Ouvrez le site Web des outils de compilation Visual Studio pour C++ et cliquez sur « Télécharger les outils de compilation ». Lancez le fichier exécutable pour démarrer l'installation.
Lorsque la fenêtre « Installation de Visual Studio » s'ouvre, dans l'onglet « Charges de travail », sélectionnez « Développement sur ordinateur de bureau avec C++ ». Pour plus d'informations, consultez la page « Installer la prise en charge de C et C++ dans Visual Studio ».
Téléchargez VS Code depuis le site Visual Studio Code, ou exécutez winget install Microsoft.VisualStudio.Code. Lancez le fichier exécutable téléchargé pour installer VS Code.
Une fois l'installation terminée, procédez comme suit :
1. Ouvrir VS Code
2. Cliquez sur Fichier → Ouvrir un dossier, puis sélectionnez votre espace de travail (par exemple, C:\workspace).
3. Cliquez sur « Terminal » → « Nouveau terminal » pour ouvrir un terminal « PowerShell ».
4. Cliquez sur l'icône « Extensions » située à gauche ou appuyez sur Ctrl+Maj+X. Dans la fenêtre « Extensions », recherchez puis installez ms-python.python, ms-toolsai.jupyter, et ms-vscode.cpptools.
Exécutez les autres commandes de ce guide dans le terminal de VS Code, sauf indication contraire. Le terminal de VS Code s'ouvre par défaut sur PowerShell, afin d'éviter toute confusion avec la fenêtre de commande intégrée à Windows.
Définissez la variable d'espace de travail. Par exemple, si votre espace de travail s'appelle workspace, exécutez la commande suivante :
```
$WORKSPACE = "C:\workspace"   # change to your workspace path
mkdir $WORKSPACE -Force
cd $WORKSPACE
```

Python 3.12 (version recommandée)

Python 3.12 est recommandé car il offre la meilleure disponibilité des roues pour qiskit-aer et d'autres dépendances. 3.10 Le site 3.11 fonctionne également, mais la version 3.13 ou une version ultérieure pourrait ne pas disposer de « wheels » précompilés pour certains paquets.

Ouvrez le terminal de VS Code et exécutez le code suivant pour détecter une version compatible d' 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'" }

Si le téléchargement n'a pas fonctionné, ou si vous préférez effectuer un téléchargement manuel, mettez en commentaire les lignes de code qui installent Python 3.12, puis téléchargez Python 3.12 depuis le site Python. Lancez le fichier exécutable pour installer « Python ». Sélectionnez « Ajouter Python au PATH » lors de l'installation, puis réexécutez l'extrait de code ci-dessus pour vous assurer qu'il est bien détecté.

Remarques

N'utilisez PAS la version disponible sur le Microsoft Store Python, car elle ne contient pas les en-têtes C. Si python cela ouvre le Microsoft Store, désactivez l'alias en accédant à Paramètres Windows → Applications → Paramètres avancés des applications → Alias d'exécution des applications.
Utilisateurs d'Anaconda : exécutez la commande conda deactivate jusqu'à ce que le préfixe (base) disparaisse. Si le problème persiste, ouvrez un nouveau terminal dans VS Code.

Nécessaire uniquement si vous clonez des dépôts de Lab. Exécutez winget install Git.Git.

Étape 2 - Configurer l'environnement virtuel « Python » avec Qiskit

Réinitialiser le terminal de VS Code

Ouvrez le terminal de VS Code et réinitialisez-le :

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

Autorisez l'exécution du script (une fois par utilisateur), puis créez l'environnement virtuel :
```
Set-ExecutionPolicy -Scope CurrentUser RemoteSigned
cd $WORKSPACE
& $PYTHON_EXE -m venv .venv --prompt workspace
.\.venv\Scripts\Activate.ps1
```
Si, lors de l'activation, un message d'erreur rouge indiquant « scripts désactivés » s'affiche, cela signifie que la Set-ExecutionPolicy ligne n'a pas été exécutée. Lancez-le manuellement, puis réessayez.
(workspace)Votre invite devrait désormais s'afficher.
Vérifier :
```
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 évite de compiler qiskit-aer à partir du code source. Si qiskit-aer cela ne fonctionne toujours pas, essayez pip install qiskit-aer --only-binary=:all: ou passez cette étape. qiskit-aer est facultatif et n'est nécessaire que pour la simulation locale.
Note
Ne PAS l'exécuter pip install --upgrade qiskit après l'installation. Le passage à une nouvelle version mineure rend incompatibles les extensions C développées pour l'ancienne version.

Étape 3 - Charger l'environnement MSVC

Exécutez le code suivant à chaque nouvelle session d' Python (par exemple, à chaque redémarrage d'un noyau Jupyter). Il détecte et charge automatiquement l'environnement de développement MSVC, ce qui vous évite d'avoir à utiliser l' x64, l'interface de ligne de commande intégrée.

L'exemple présenté dans cette documentation permet de compiler des modules d'extension C à l'aide setuptools de MSVC. QISKIT_PYTHON_EXTENSIONEn règle générale, on définit, on inclut qiskit.het on appelle qk_import() dans sa fonction d'initialisation. Seuls les fichiers d'en-tête de qiskit.capi.get_include() sont nécessaires lors de la compilation — aucune bibliothèque n'est liée. Pour plus de détails, consultez la section « Étendre Qiskit dans Python avec C ».

Charger l'environnement 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)

Vérifier la configuration

Vérifiez que la configuration a bien fonctionné :

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

Étape 4 - Test de fonctionnement : créer une extension C

Exécutez le code suivant. Il écrit les fichiers source dans _smoke_pkg/, génère une extension C basée sur l'API C de Qiskit, puis importe le résultat. Si le message « SMOKE TEST PASSED » s'affiche, votre chaîne d'outils est prête.

Ce module suit la procédure décrite dans la section « Étendre Qiskit dans Python avec C » et utilise les fonctions de la référence de l'API C de Qiskit.

Code de test de fumée

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

Étape 5 — Configurer VS Code (facultatif)

Pour plus de simplicité, vous pouvez suivre cette procédure afin de configurer IntelliSense pour les fichiers C et de sélectionner automatiquement l'interpréteur Python.

Dans le terminal de VS Code, exécutez le code suivant :
```
mkdir $WORKSPACE\.vscode -Force
```

Créer le fichier de paramètres

Créez .vscode/settings.json dans votre espace de travail en exécutant ce code :

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

Créer le fichier de propriétés

Le code suivant affiche le JSON que vous devez coller dans .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('}')

Dans VS Code, créez .vscode/extensions.json un fichier avec le contenu suivant :
```
{
    "recommendations": ["ms-python.python", "ms-toolsai.jupyter", "ms-vscode.cpptools"]
}
```

Compiler la bibliothèque autonome

Cette section permet de compiler la bibliothèque C autonome, qui n'est nécessaire que si vous souhaitez compiler et lier des programmes entièrement en C, comme décrit dans la section « Systèmes de type UNIX ». Outre les prérequis de l'étape 1, cela nécessite les outils suivants :

Un compilateur Rust : voir par exemple le guide d'installation de Qiskit à partir des sources
cbindgen: un outil permettant de créer l'en-tête C, que vous pouvez installer à l'aide de cargo install cbindgen. L'exécution de l'outil depuis la ligne de commande devrait être activée, ce qui peut nécessiter de mettre à jour votre PATH variable pour y inclure le chemin d'accès à Cargo.
Une installation d' Python s permettant d'accéder à la fois à python3.lib et à python3.dll
Un clone du dépôt Qiskit (git clone https://github.com/Qiskit/qiskit.git)

Commencez par compiler la qiskit_cext bibliothèque dynamique en exécutant la commande suivante dans le terminal de VS Code ( PowerShell ) à la racine du répertoire Qiskit :
```
$env:PATH = "\path\to\pythonlib;" + $env:PATH
cargo rustc --release --crate-type cdylib -p qiskit-cext
```
Cette opération génère la bibliothèque dynamique .dll et le fichier .dll.lib associé dans target/release. Ensuite, générez l'en-tête avec
```
cbindgen --crate qiskit-cext --output dist\c\include\qiskit.h
```
Cela permet d'écrire l'en-tête compatible MSVC dans dist\c\include.
Vous pouvez désormais utiliser cl pour compiler le programme en C. Pour que le compilateur puisse trouver la bibliothèque qiskit, ajoutez-la target\release à la PATH variable.
```
$env:PATH = "\path\to\target\release;" + $env:PATH
cl example.c qiskit_cext.dll.lib -I\path\to\dist\c\include
```
Avant de lancer le programme, indiquez le chemin d'accès à votre fichier python3.dll.
```
$env:PATH = "\path\to\python3-dll;" + $env:PATH
.\example.exe
```
devrait alors imprimer
```
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] }
```

Traitement des incidents

Mettez à jour l 'App Installer depuis le Microsoft Store, ou utilisez les liens de téléchargement manuel correspondants
Relancez la cellule de charge MSVC (étape 3) ou utilisez l'invite de commande des outils natifs d' x64
Accédez à Paramètres → Applications → Paramètres avancés des applications → Alias d'exécution des applications, puis désactivez cette option. python.exe
Exécuter Set-ExecutionPolicy -Scope CurrentUser RemoteSigned , puis réessayer
Exécutez python -c "import qiskit.capi; print(qiskit.capi.get_include())" le programme et vérifiez que le chemin d'accès existe
Exécuterpip install "qiskit[visualization]~=2.4.2"
Exécutez pip install qiskit-aer --only-binary=:all:. Si cela ne fonctionne pas non plus, utilisez Python 3.12 ou ignorez « aer », qui est facultatif
La version de l'extension C de Qiskit compilée et celle de Qiskit installée doivent correspondre. Réinstallez Qiskit à l'aide de pip install "qiskit~=2.4.2"
Une extension C ne peut pas être réimportée en temps réel. Redémarrez le noyau, relancez les commandes MSVC (étape 3), puis recompilez
Set-ExecutionPolicy -Scope CurrentUser RemoteSigned
Utilisez un chemin d'accès racine court sur C:\ (par exemple, C:\workspace, ou le chemin que vous avez défini lors de la configuration), ou activez l'option « Chemins longs » : Paramètres → Système → Pour les développeurs → Chemins longs
Continuez conda deactivate jusqu’à ce que CONDA_DEFAULT_ENV et CONDA_PREFIX aient tous deux disparu de l’environnement. Renseignez-vous auprès de $env:CONDA_PREFIX. Si le problème persiste, ouvrez une nouvelle fenêtre d' PowerShell s (et non une fenêtre d's Anaconda) et recommencez à partir de l'étape 2.
L'environnement virtuel a hérité du runtime C de conda et ne peut pas être fixé en place. Supprimez-le, téléchargez le fichier « Python » ( 3.12 ) depuis le site Python, puis recompilez. $PYTHON_EXE``Remove-Item -Recurse -Force .venvExécutez, puis réexécutez l'extrait de code de détection d' Python s de l'étape 1 pour définir les paramètres, puis recréez l'environnement virtuel (étape 2).
Il semblerait que Conda provoque des fuites dans l'environnement virtuel. Vérifiez les deux points mentionnés juste au-dessus. Vérifiez également que le fichier « Python » est en 64 bits : python -c "import platform; print(platform.architecture())"
Votre nom d'utilisateur ou le chemin d'accès à votre espace de travail contient des caractères non ASCII. Déplacez l'espace de travail vers un chemin d'accès court composé uniquement de caractères ASCII (par exemple, C:\workspace)
Le dossier « Espace de travail » est synchronisé par OneDrive. Déplacez-le vers un chemin d'accès local, par exemple C:\workspace
Supprimez le _smoke_pkg dossier de votre espace de travail, relancez la cellule de charge MSVC, puis relancez la cellule de test de fumée
Votre réseau utilise un proxy qui intercepte les requêtes HTTPS. Essayez d'exécuter cette commande pip install --trusted-host pypi.org --trusted-host files.pythonhosted.org qiskit ou demandez le certificat CA du proxy à votre administrateur réseau
Ajoutez les dossiers et _smoke_pkg de .venv votre espace de travail aux exclusions de Defender en accédant à Sécurité Windows → Protection contre les virus et les menaces → Gérer les paramètres → Exclusions
Un accès administrateur est requis. Demandez à votre service informatique de vous donner accès
Le fichier.pyd est verrouillé par le noyau en cours d'exécution. Redémarrez le noyau (Ctrl+Maj+P → Jupyter : Redémarrer le noyau), réexécutez l'étape 3, puis recompilez
Il se peut que vous soyez sur cmd.exe au lieu de PowerShell. Vérifiez votre ligne de commande : « PowerShell » affiche PS C:\>, « cmd » affiche C:\>. Ouvrez « PowerShell » depuis le menu Démarrer ou à l'aide de la combinaison de touches Win+X
Les --passive --wait options bloquent PowerShell pendant que le programme d'installation s'exécute en arrière-plan. Vérifiez si une fenêtre intitulée « Visual Studio Installer » s'affiche dans votre barre des tâches. L'installation peut prendre entre 10 et 30 minutes

Etapes suivantes

Recommandations

Découvrez comment étendre l' Python s à l'aide de l'API C de Qiskit.
Installez Qiskit.
Découvrez la documentation de référence de l'API C de Qiskit.

Si vous n'avez pas installé Make, vérifiez dans Makefile le répertoire racine de Qiskit les commandes requises, ou installez simplement Make; il n'est pas trop tard. ↩

Cette page a-t-elle été utile ?

Signaler un bogue, une coquille ou proposer du contenu sur GitHub.

Installer l'API C de Qiskit

de type UNIX

Exigences

Générer

Fenêtres

Exigences

Avant de commencer

Etape 1. Installation des prérequis

Étape 2 - Configurer l'environnement virtuel « Python » avec Qiskit

Étape 3 - Charger l'environnement MSVC

Étape 4 - Test de fonctionnement : créer une extension C

Étape 5 — Configurer VS Code (facultatif)

Compiler la bibliothèque autonome

Traitement des incidents

Etapes suivantes

Footnotes