Instalar la API C de Qiskit

En esta guía se explica cómo instalar y utilizar la API de C de Qiskit. Una vez finalizada la instalación, lee el artículo «Ampliar Python con la API C de Qiskit ».

El siguiente ejemplo construye un observable 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;
}

Similar a UNIX

Esta sección proporciona instrucciones de compilación para sistemas tipo UNIX.

Requisitos

La compilación requiere las siguientes herramientas:

Un compilador de Rust: véase, por ejemplo, la guía sobre la instalación de Qiskit a partir del código fuente
Un compilador de C: por ejemplo, GCC en Linux y Clang en MacOS. La API C de Qiskit es compatible con un compilador conforme a la norma C11 estándar.
cbindgen: una herramienta para crear el archivo de cabecera en C, que puedes instalar con cargo install cbindgen Debería estar habilitada la ejecución de la herramienta desde la línea de comandos, lo que podría requerir exportar la PATH variable para incluir /path/to/.cargo/bin.
Python Biblioteca instalada ( Python 3.9 +): La biblioteca Python es necesaria para la vinculación dinámica. Ten en cuenta que « Python » no se utiliza en tiempo de ejecución y que el intérprete nunca se inicializa; solo es necesario definir algunos símbolos de libpython . Consulta este número para obtener más detalles.
(GNU) Make: es opcional pero se recomienda para utilizar procesos de instalación automatizados.

Este código verifica que todo ha sido instalado:

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

Crear

Para construir la cabecera C y la librería, puedes ejecutar el siguiente comando Make¹ en Qiskit root,

make c

que proporcionará la biblioteca compartida compilada en dist/c/lib y la cabecera qiskit.h con todas las declaraciones de funciones en dist/c/include. Tenga en cuenta que el nombre exacto de la biblioteca depende de la plataforma; por ejemplo,libqiskit.so en UNIX y libqiskit.dylib en MacOS. (Tenga en cuenta que este paso actualmente emite muchas advertencias, lo cual es de esperar, y no es motivo de alarma. Las versiones futuras eliminarán las advertencias)

A continuación, puedes compilar un programa en C utilizando la cabecera y la biblioteca Qiskit C:

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

Para asegurarse de que la biblioteca Qiskit se encuentra durante la vinculación, establezca la ruta de la biblioteca en tiempo de ejecución en incluir /path/to/dist/c/lib. Si la biblioteca Python no está disponible por defecto durante la vinculación dinámica, también es necesario añadirla. Estos comandos dependen de la plataforma. En 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

En MacOS:

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

Alternativamente, puede establecer la ruta de la biblioteca en tiempo de ejecución durante la compilación añadiendo

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

a las banderas del compilador. Además, la biblioteca Python debe estar disponible durante la vinculación dinámica. En los entornos Linux este suele ser el valor predeterminado.

Ahora puedes ejecutar el binario:

./example.o

que, si se utiliza el fragmento de ejemplo mostrado anteriormente, debería imprimir

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

Esta sección proporciona instrucciones de compilación para sistemas Windows.

Hay dos formas independientes de utilizar la API de C en Windows:

Desarrolla módulos de extensión par Python que utilicen la API de C de Qiskit. Sigue los pasos del 1 al 5. Esta ruta utiliza los archivos de cabecera de C que se incluyen con el paquete qiskitPython y no requiere Rust ni cbindgen.
Compila la biblioteca C independiente para poder vincularla desde un programa escrito íntegramente en C, tal y como se hace en la sección «Tipo UNIX ». Completa el paso 1 y, a continuación, pasa directamente a «Compilar la biblioteca independiente », donde se enumeran los requisitos adicionales.

Requisitos

Para algunos pasos se necesitan derechos de administrador.
Entre 5 y 8 GB de espacio libre en disco.
Un compilador de C: Microsoft Visual C++ (MSVC), instalado en el paso 1.
Una instalación de Python de 64 bits ( 3.10 o posterior), instalada en el paso 1.

Antes de empezar

Crea tu espacio de trabajo. Debería ser una ruta corta en una unidad local. No utilices carpetas d OneDrive-synced s (como «Documentos» o «Escritorio»), unidades de red ni rutas que contengan espacios o caracteres no ASCII. Si tu nombre de usuario contiene caracteres que no sean del alfabeto inglés, no lo guardes en tu carpeta de usuario.

Ejemplos de rutas adecuadas para el espacio de trabajo: C:\workspace, D:\workspace, C:\Users\john\workspace

Paso 1. Instalar los requisitos previos

Se trata de una descarga de gran tamaño (entre 2 y 5 GB; entre 10 y 30 minutos). Instálalo primero para saber de inmediato si tu ordenador es compatible.
Note
Requiere derechos de administrador.
Opción A — winget Abre un terminal de « PowerShell » y ejecuta lo siguiente:
```
winget install Microsoft.VisualStudio.2022.BuildTools --override "--add Microsoft.VisualStudio.Workload.VCTools --includeRecommended --passive --wait"
```
El terminal parece haberse bloqueado mientras se ejecuta el instalador. Esto es normal y tardará entre 10 y 30 minutos. Comprueba si aparece en la barra de tareas una ventana titulada «Visual Studio Installer».
Si winget no se reconoce, actualiza App Installer desde la Tienda de Microsoft o utiliza la opción B.
Opción B: descarga manual Abre la página web de Visual Studio Build Tools for C++ y haz clic en «Descargar herramientas de compilación». Ejecuta el archivo ejecutable para iniciar la instalación.
Cuando se abra la ventana «Instalación de Visual Studio», en la pestaña «Cargas de trabajo», selecciona «Desarrollo de escritorio con C++». Consulta la página «Instalar compatibilidad con C y C++ en Visual Studio » para obtener más información.
Descarga VS Code desde la página web Visual Studio Code o ejecuta winget install Microsoft.VisualStudio.Code. Ejecuta el archivo ejecutable descargado para instalar VS Code.
Una vez instalado, sigue estos pasos:
1. Abrir VS Code
2. Haz clic en «Archivo» → «Abrir carpeta» y, a continuación, selecciona tu espacio de trabajo (por ejemplo, C:\workspace).
3. Haz clic en «Terminal» → «Nueva terminal» para abrir una terminal de « PowerShell ».
4. Haz clic en el icono «Extensiones» de la izquierda o pulsa Ctrl+Mayús+X. En la ventana «Extensiones», busca e instala ms-python.python, ms-toolsai.jupyter, y ms-vscode.cpptools.
Ejecuta el resto de los comandos de esta guía en la terminal de VS Code, salvo que se indique lo contrario. El terminal de VS Code se abre por defecto en PowerShell, para evitar confusiones con la ventana de comandos integrada de Windows.
Establece la variable del espacio de trabajo. Por ejemplo, si tu espacio de trabajo se llama workspace, ejecuta lo siguiente:
```
$WORKSPACE = "C:\workspace"   # change to your workspace path
mkdir $WORKSPACE -Force
cd $WORKSPACE
```

Python 3.12 (versión recomendada)

Python 3.12 Se recomienda porque ofrece la mejor disponibilidad de ruedas para qiskit-aer y otras dependencias. 3.10 y 3.11 también funcionan, pero es posible que en 3.13 o versiones posteriores no haya paquetes precompilados para algunos paquetes.

Abre el terminal de VS Code y ejecuta el siguiente código para detectar una versión adecuada de 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 la descarga no ha funcionado, o si prefieres realizarla manualmente, comenta las líneas de código que instalan Python 3.12 y, a continuación, descarga Python 3.12 desde la página web Python. Ejecuta el archivo ejecutable para instalar « Python ». Selecciona «Añadir Python a la variable PATH» durante la instalación y, a continuación, vuelve a ejecutar el fragmento de código anterior para asegurarte de que se encuentra.

Notas

NO utilices la versión de Microsoft Store Python, ya que carece de los encabezados C. Si python se abre la Tienda de Microsoft, desactiva el alias accediendo a «Configuración de Windows» → «Aplicaciones» → «Configuración avanzada de aplicaciones» → «Alias de ejecución de aplicaciones».
Usuarios de Anaconda: ejecutad el comando conda deactivate hasta que desaparezca el prefijo (base). Si el problema persiste, abre una nueva ventana de terminal en VS Code.

Solo es necesario si clonas repositorios de Lab. Ejecute winget install Git.Git.

Paso 2: Configurar el entorno virtual « Python » con Qiskit

Restablecer el terminal de VS Code

Abre el terminal de VS Code y reinícialo:

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

Permite la ejecución del script (una vez por usuario) y, a continuación, crea el entorno virtual:
```
Set-ExecutionPolicy -Scope CurrentUser RemoteSigned
cd $WORKSPACE
& $PYTHON_EXE -m venv .venv --prompt workspace
.\.venv\Scripts\Activate.ps1
```
Si durante la activación aparece un error en rojo que indica «scripts desactivados», significa que la Set-ExecutionPolicy línea no se ha ejecutado. Ejecútalo manualmente y vuelve a intentarlo.
(workspace)Ahora deberías ver la línea de comandos.
Verifique que:
```
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 tener que compilar qiskit-aer a partir del código fuente. Si qiskit-aer sigue sin funcionar, prueba con pip install qiskit-aer --only-binary=:all: o sáltatelo. qiskit-aer Es opcional y solo es necesario para la simulación local.
Note
NO lo ejecutes pip install --upgrade qiskit tras la instalación. Al actualizar a una nueva versión menor, las extensiones de C compiladas con la versión anterior dejan de funcionar.

Paso 3: Cargar el entorno MSVC

Ejecuta el siguiente código en cada nueva sesión de Python (por ejemplo, cada vez que reinicies un kernel de Jupyter). Localiza y carga automáticamente el entorno de desarrollo de MSVC, por lo que no es necesario utilizar el símbolo del sistema integrado de « x64 ».

El ejemplo de esta documentación compila módulos de extensión en C utilizando setuptools MSVC. QISKIT_PYTHON_EXTENSIONPor lo general, se definen, se incluyen qiskit.hy se invocan qk_import() en la función de inicialización. Solo se necesitan los archivos de cabecera de qiskit.capi.get_include() durante la compilación; no se vincula ninguna biblioteca. Para más detalles, consulta «Ampliar Qiskit en Python con C ».

Cargar el entorno 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)

Comprueba la configuración

Comprueba que la configuración haya funcionado:

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

Paso 4 - Prueba de funcionamiento: Crear una extensión en C

Ejecuta el siguiente código. Escribe los archivos fuente en _smoke_pkg/, compila una extensión en C basada en la API de C de Qiskit e importa el resultado. Si aparece el mensaje «SMOKE TEST PASSED», tu cadena de herramientas está lista.

El paquete sigue el proceso «Ampliar Qiskit en Python con C» y utiliza funciones de la referencia de la API de Qiskit en C.

Código de prueba de humo

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

Paso 5 — Configurar VS Code (opcional)

Para facilitar su uso, puedes seguir este procedimiento para configurar « IntelliSense » para archivos C y seleccionar automáticamente el intérprete « Python ».

En la terminal de VS Code, ejecuta el siguiente código:
```
mkdir $WORKSPACE\.vscode -Force
```

Crea el archivo de configuración

Crea .vscode/settings.json en tu espacio de trabajo ejecutando este código:

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

Crea el archivo de propiedades

El siguiente código muestra el código JSON que debes pegar en .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('}')

En VS Code, crea .vscode/extensions.json un archivo con este contenido:
```
{
    "recommendations": ["ms-python.python", "ms-toolsai.jupyter", "ms-vscode.cpptools"]
}
```

Compilar la biblioteca independiente

En esta sección se compila la biblioteca C independiente, que solo es necesaria si deseas compilar y enlazar programas escritos íntegramente en C, tal y como se describe en la sección «Sistemas tipo UNIX ». Además de los requisitos previos del Paso 1, para ello se necesitan las siguientes herramientas:

Un compilador de Rust: véase, por ejemplo, la guía sobre la instalación de Qiskit a partir del código fuente
cbindgen: una herramienta para crear el archivo de cabecera en C, que puedes instalar con cargo install cbindgen. Debería estar habilitada la ejecución de la herramienta desde la línea de comandos, lo que podría requerir actualizar tu PATH variable para incluir la ruta de cargo.
Una instalación de « Python » con acceso tanto python3.lib a como a python3.dll
Un clon del repositorio de Qiskit (git clone https://github.com/Qiskit/qiskit.git)

En primer lugar, compila la qiskit_cext biblioteca dinámica ejecutando el siguiente comando en la terminal de VS Code ( PowerShell ) desde el directorio raíz de Qiskit:
```
$env:PATH = "\path\to\pythonlib;" + $env:PATH
cargo rustc --release --crate-type cdylib -p qiskit-cext
```
Esto generará la biblioteca dinámica .dll y el archivo asociado .dll.lib en target/release. A continuación, genere la cabecera con
```
cbindgen --crate qiskit-cext --output dist\c\include\qiskit.h
```
Esto escribe el encabezado compatible con MSVC en dist\c\include.
Ahora puedes utilizar cl para compilar el programa en C. Para asegurarte de que el compilador encuentre la biblioteca qiskit, inclúyela target\release en la PATH variable.
```
$env:PATH = "\path\to\target\release;" + $env:PATH
cl example.c qiskit_cext.dll.lib -I\path\to\dist\c\include
```
Antes de ejecutarlo, incluye la ruta a tu python3.dll.
```
$env:PATH = "\path\to\python3-dll;" + $env:PATH
.\example.exe
```
debe imprimir
```
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] }
```

Resolución de problemas

Actualiza el instalador de aplicaciones desde la Tienda de Microsoft o utiliza los enlaces de descarga manual correspondientes
Vuelve a ejecutar la célula de carga de MSVC (paso 3) o utiliza el símbolo del sistema de Native Tools de x64
Ve a Ajustes → Aplicaciones → Ajustes avanzados de aplicaciones → Alias de ejecución de aplicaciones y desactívalos python.exe
Ejecuta Set-ExecutionPolicy -Scope CurrentUser RemoteSigned y vuelve a intentarlo
Ejecuta python -c "import qiskit.capi; print(qiskit.capi.get_include())" el comando y comprueba que la ruta existe
Ejecute pip install "qiskit[visualization]~=2.4.2"
Ejecute pip install qiskit-aer --only-binary=:all:. Si eso tampoco funciona, utiliza Python 3.12 u omite «aer», que es opcional
La extensión de Qiskit en C compilada y la versión de Qiskit instalada deben ser la misma. Vuelve a instalar Qiskit con pip install "qiskit~=2.4.2"
Una extensión C no se puede volver a importar en tiempo real. Reinicia el núcleo, vuelve a ejecutar los comandos de MSVC (paso 3) y, a continuación, vuelve a compilar
Set-ExecutionPolicy -Scope CurrentUser RemoteSigned
Utiliza una ruta raíz corta en C:\ (por ejemplo, C:\workspace, o la ruta que hayas establecido en el paso de configuración), o activa la opción «Rutas largas»: Configuración → Sistema → Para desarrolladores → Rutas largas
Ejecuta conda deactivate el programa hasta CONDA_DEFAULT_ENV que tanto como CONDA_PREFIX hayan desaparecido del entorno. Consúltalo con $env:CONDA_PREFIX. Si el problema persiste, abre una nueva ventana de « PowerShell » (no una de Anaconda) y vuelve a intentarlo desde el paso 2.
El entorno virtual ha heredado el tiempo de ejecución de C de conda y no se puede fijar en su ubicación. Elimínalo, descárgalo de Python 3.12 desde la página web Python y vuelve a compilarlo. $PYTHON_EXEEjecuta Remove-Item -Recurse -Force .venvy, a continuación, vuelve a ejecutar el fragmento de código de detección de « Python » del paso 1 para configurarlo; después, vuelve a crear el entorno virtual (paso 2).
Es probable que Conda esté provocando fugas en el entorno virtual. Consulta los dos temas que aparecen justo encima de este. Comprueba también que « Python » sea de 64 bits: python -c "import platform; print(platform.architecture())"
Tu nombre de usuario o la ruta del espacio de trabajo contienen caracteres no ASCII. Cambia la ruta del espacio de trabajo a una ruta corta que contenga únicamente caracteres ASCII (por ejemplo, C:\workspace)
OneDrive se encarga de sincronizar la carpeta del espacio de trabajo. Múdale a una ruta local como C:\workspace
Elimina la _smoke_pkg carpeta de tu espacio de trabajo, vuelve a ejecutar la celda de carga de MSVC y, a continuación, vuelve a ejecutar la celda de prueba de humo
Tu red utiliza un proxy que intercepta HTTPS. Prueba a ejecutar pip install --trusted-host pypi.org --trusted-host files.pythonhosted.org qiskit o pide al administrador de la red el certificado de la CA proxy
Añade las carpetas y _smoke_pkg de .venv tu espacio de trabajo a las exclusiones de Defender accediendo a Seguridad de Windows → Protección contra virus y amenazas → Administrar configuración → Exclusiones
Se necesita tener acceso de administrador. Pide acceso a tu departamento de informática
El archivo.pyd está bloqueado por el núcleo en ejecución. Reinicia el kernel (Ctrl+Mayús+P → Jupyter: Reiniciar kernel), vuelve a ejecutar el paso 3 y, a continuación, vuelve a compilar
Es posible que estés en cmd.exe en lugar de en PowerShell. C:\>``PS C:\>Comprueba lo que aparece en la línea de comandos: « PowerShell » muestra..., «cmd» muestra... Abre « PowerShell » desde el menú Inicio o con Win+X
Las --passive --wait opciones de configuración impiden que se ejecute « PowerShell » mientras el instalador se ejecuta en segundo plano. Comprueba si aparece en la barra de tareas una ventana titulada «Visual Studio Installer». La instalación puede tardar entre 10 y 30 minutos

Próximos pasos

Recomendaciones

Descubre cómo ampliar « Python » con la API de Qiskit en C.
Instala Qiskit.
Explora la referencia de la API de Qiskit en C.

Si no ha instalado Make, compruebe el Makefile en la raíz de Qiskit para ver los comandos necesarios, o simplemente instale Make; aún está a tiempo. ↩

¿Le ha resultado útil esta página?

Informe de un error, de una errata o solicite contenido en GitHub.

Instalar la API C de Qiskit

Similar a UNIX

Requisitos

Crear

Windows

Requisitos

Antes de empezar

Paso 1. Instalar los requisitos previos

Paso 2: Configurar el entorno virtual « Python » con Qiskit

Paso 3: Cargar el entorno MSVC

Paso 4 - Prueba de funcionamiento: Crear una extensión en C

Paso 5 — Configurar VS Code (opcional)

Compilar la biblioteca independiente

Resolución de problemas

Próximos pasos

Footnotes