Créer une extension C++ pour Python

Article
09/27/2022

S’applique à :Visual Studio Visual Studio pour Mac Visual Studio Code

En règle générale, les modules écrits en C++ (ou C) sont utilisés pour étendre les fonctionnalités d’un interpréteur Python. Vous pouvez également les utiliser pour activer l’accès aux fonctionnalités de système d’exploitation de bas niveau.

Les modules sont fournis dans trois types principaux :

Modules accélérateurs : Étant donné que Python est un langage interprété, vous pouvez écrire des modules accélérateurs en C++ pour des performances plus élevées.
Modules wrapper : ces modules exposent des interfaces C/C++ existantes au code Python ou exposent une API plus « pythonique » facile à utiliser à partir de Python.
Modules d’accès au système de bas niveau : vous pouvez créer ces modules pour accéder aux fonctionnalités de niveau inférieur du CPython runtime, du système d’exploitation ou du matériel sous-jacent.

Cet article vous guide tout au long de la création d’un module d’extension C++ pour CPython cela calcule une tangente hyperbolique et l’appelle à partir du code Python. La routine est implémentée en premier dans Python pour illustrer le gain de performances relatif de l’implémentation de la même routine en C++.

L’article montre également deux façons de rendre l’extension C++ disponible pour Python :

Utilisez les extensions standard CPython , comme décrit dans la documentation Python.
Utilisez PyBind11, que nous recommandons pour C++11 en raison de sa simplicité. Pour garantir la compatibilité, assurez-vous que vous travaillez avec l’une des versions les plus récentes de Python.

Vous trouverez l’exemple terminé de cette procédure pas à pas sur GitHub sur python-samples-vs-cpp-extension.

Prérequis

Visual Studio 2017 ou version ultérieure, avec la charge de travail de développement Python installée. La charge de travail inclut les outils de développement natifs Python, qui apportent la charge de travail C++ et les ensembles d’outils nécessaires pour les extensions natives.

Notes

Lorsque vous installez la charge de travail des applications de science des données et d’applications analytiques , Python et l’option outils de développement natifs Python sont installés par défaut.

Pour plus d’informations sur les options d’installation, consultez Installer la prise en charge de Python pour Visual Studio. Si vous installez Python séparément, veillez à sélectionner Télécharger des symboles de débogage sous Options avancées dans son programme d’installation. Cette option est nécessaire pour utiliser le débogage en mode mixte entre votre code Python et le code natif.

Créer l’application Python

Créez un projet Python dans Visual Studio en sélectionnant Fichier>Nouveau>projet.
Recherchez Python, sélectionnez le modèle d’application Python , entrez un nom et un emplacement, puis sélectionnez OK.

Dans le fichier .py du projet, collez le code suivant. Pour découvrir certaines des fonctionnalités de modification Python, essayez d’entrer le code manuellement.

Ce code calcule une tangente hyperbolique sans utiliser la bibliothèque mathématique, et c’est ce que vous accélérerez avec les extensions natives.

Conseil

Écrivez votre code en Python pur avant de le réécrire en C++. De cette façon, vous pouvez vérifier plus facilement que votre code natif est correct.

from random import random
from time import perf_counter

COUNT = 500000  # Change this value depending on the speed of your computer
DATA = [(random() - 0.5) * 3 for _ in range(COUNT)]

e = 2.7182818284590452353602874713527

def sinh(x):
    return (1 - (e ** (-2 * x))) / (2 * (e ** -x))

def cosh(x):
    return (1 + (e ** (-2 * x))) / (2 * (e ** -x))

def tanh(x):
    tanh_x = sinh(x) / cosh(x)
    return tanh_x

def test(fn, name):
    start = perf_counter()
    result = fn(DATA)
    duration = perf_counter() - start
    print('{} took {:.3f} seconds\n\n'.format(name, duration))

    for d in result:
        assert -1 <= d <= 1, " incorrect values"

if __name__ == "__main__":
    print('Running benchmarks with COUNT = {}'.format(COUNT))

    test(lambda d: [tanh(x) for x in d], '[tanh(x) for x in d] (Python implementation)')

Pour afficher les résultats, exécutez le programme en sélectionnantDémarrer sans débogage> ou en sélectionnant Ctrl+F5.

Vous pouvez ajuster la COUNT variable pour modifier la durée d’exécution du benchmark. Pour cette procédure pas à pas, définissez le nombre afin que le benchmark prenne environ deux secondes.

Conseil

Lorsque vous exécutez des benchmarks, utilisez> toujoursDémarrer sans débogage. Cela permet d’éviter la surcharge que vous entraînez lorsque vous exécutez le code dans le débogueur Visual Studio.

Créer les projets C++ principaux

Suivez les instructions de cette section pour créer deux projets C++ identiques, superfastcode et superfastcode2. Plus tard, vous allez utiliser une approche distincte dans chaque projet pour exposer le code C++ à Python.

Dans Explorateur de solutions, cliquez avec le bouton droit sur la solution, puis sélectionnez Ajouter>un nouveau projet. Une solution Visual Studio peut contenir à la fois des projets Python et C++, ce qui est l’un des avantages de l’utilisation de Visual Studio pour Python.
Recherchez sur C++, sélectionnez Projet vide, spécifiez le superfastcode pour le premier projet ou le superfastcode2 pour le deuxième projet, puis sélectionnez OK.

Conseil

Vous pouvez également commencer par le modèle de module d’extension Python avec les outils de développement natif Python installés dans Visual Studio. Le modèle a une grande partie de ce qui est décrit ici déjà en place.

Pour cette procédure pas à pas, cependant, le fait de démarrer avec un projet vide illustre comment créer le module d’extension étape par étape. Après avoir compris le processus, vous pouvez utiliser le modèle pour gagner du temps lorsque vous écrivez vos propres extensions.
Pour créer un fichier C++ dans le nouveau projet, cliquez avec le bouton droit sur le nœud Fichiers sources , puis sélectionnez Ajouter>un nouvel élément.
Sélectionnez Fichier C++, nommez-le module.cpp, puis sélectionnez OK.

Important

Un fichier avec l’extension .cpp est nécessaire pour activer les pages de propriétés C++ dans les étapes suivantes.
Dans la barre d’outils principale, utilisez le menu déroulant pour sélectionner l’une des configurations suivantes :
- Pour un runtime Python 64 bits, activez la configuration x64 .
- Pour un runtime Python 32 bits, activez la configuration Win32 .
Dans Explorateur de solutions, cliquez avec le bouton droit sur le projet C++, sélectionnez Propriétés, puis procédez comme suit :

a. Pour Configuration, entrez Active (Débogage).
b. Pour la plateforme, entrez Active (x64) ou Active (Win32) en fonction de votre sélection à l’étape précédente.

Notes

Lorsque vous créez vos propres projets, vous souhaitez configurer à la fois les configurations de débogage et de mise en production . Dans cette unité, vous configurez uniquement la configuration de débogage et définissez-la pour utiliser une build de version de CPython. Cette configuration désactive certaines fonctionnalités de débogage du runtime C++, notamment les assertions. L’utilisation des fichiers binaires de débogage CPython (python_d.exe) nécessite différents paramètres.

Définissez les propriétés comme décrit dans le tableau suivant :

Onglet	Propriété	Value
Général	Nom de la cible	Spécifiez le nom du module à faire référence à partir de Python dans `from...import` les instructions. Vous utilisez ce même nom dans le code C++ lorsque vous définissez le module pour Python. Pour utiliser le nom du projet comme nom du module, laissez la valeur par défaut de $<ProjectName>. Pour `python_d.exe`, ajoutez `_d` à la fin du nom.
	Avancé>Extension de fichier cible	.pyd
	Valeurs par défaut du> projet Type de configuration	Bibliothèque dynamique (.dll)
C/C++>Générales	Autres répertoires Include	Ajoutez le dossier Python include selon le cas pour votre installation (par exemple). `c:\Python36\include`
C/C++>Préprocesseur	Définitions de préprocesseur	S’il est présent, remplacez la valeur _DEBUG parNDEBUG pour qu’elle corresponde à la version non de débogage de CPython. Lorsque vous utilisez python_d.exe, laissez cette valeur inchangée.
C/C++>Génération de code	Bibliothèque Runtime	DLL multithread (/MD) pour correspondre à la version non débogueur de CPython. Lorsque vous utilisez python_d.exe, laissez cette valeur en tant que DLL de débogage multithread (/MDd).
Linker>Générales	Répertoires de bibliothèques supplémentaires	Ajoutez le dossier Libs Python qui contient des fichiers .lib , selon les besoins de votre installation (par exemple, c:\Python36\libs). Veillez à pointer vers le dossier libs qui contient des fichiers .lib , et non sur le dossier Lib qui contient des fichiers .py .

Notes

Si l’onglet C/C++ n’est pas affiché dans les propriétés du projet, le projet ne contient aucun fichier qui s’identifie en tant que fichiers sources C/C++. Cette condition peut se produire si vous créez un fichier source sans extension de fichier .c ou .cpp .

Par exemple, si vous avez entré accidentellement module.coo au lieu de module.cpp précédemment dans la boîte de dialogue nouvel élément, Visual Studio crée le fichier, mais ne définit pas le type de fichier sur C/C+ Code, ce qui active l’onglet propriétés C/C++. Cette erreur d’identification reste même si vous renommez le fichier avec une extension de fichier .cpp .

Pour définir correctement le type de fichier, dans Explorateur de solutions, cliquez avec le bouton droit sur le fichier et sélectionnez Propriétés. Ensuite, pour le type de fichier, sélectionnez Code C/C++.

Sélectionnez OK.
Pour tester vos configurations ( déboguer et publier), cliquez avec le bouton droit sur le projet C++, puis sélectionnez Générer.

Vous trouverez les fichiers .pyd dans le dossier de solution , sous Déboguer et Libérer, et non dans le dossier du projet C++ lui-même.

Dans le fichier module.cpp du projet C++, ajoutez le code suivant :

#include <Windows.h>
#include <cmath>

const double e = 2.7182818284590452353602874713527;

double sinh_impl(double x) {
    return (1 - pow(e, (-2 * x))) / (2 * pow(e, -x));
}

double cosh_impl(double x) {
    return (1 + pow(e, (-2 * x))) / (2 * pow(e, -x));
}

double tanh_impl(double x) {
    return sinh_impl(x) / cosh_impl(x);
}

Régénérez le projet C++ pour confirmer que votre code est correct.
Si vous ne l’avez pas déjà fait, répétez les étapes précédentes pour créer un deuxième projet nommé superfastcode2 avec une configuration identique.

Convertir les projets C++ en extensions pour Python

Pour rendre la DLL C++ une extension pour Python, commencez par modifier les méthodes exportées pour interagir avec les types Python. Ensuite, ajoutez une fonction qui exporte le module, ainsi que des définitions des méthodes du module.

Les sections qui suivent expliquent comment effectuer ces étapes à l’aide des extensions CPython et pyBind11.

Utiliser des extensions CPython

Pour plus d’informations sur le code affiché dans cette section, consultez le manuel de référence de l’API Python/C et, en particulier, la page Objets de module . Veillez à sélectionner votre version de Python dans la liste déroulante en haut à droite.

En haut du fichier module.cpp , incluez Python.h :
```
#include <Python.h>
```

Modifiez la tanh_impl méthode pour accepter et retourner des types Python (autrement dit, a PyObject*) :

PyObject* tanh_impl(PyObject* /* unused module reference */, PyObject* o) {
    double x = PyFloat_AsDouble(o);
    double tanh_x = sinh_impl(x) / cosh_impl(x);
    return PyFloat_FromDouble(tanh_x);
}

Ajoutez une structure qui définit comment la fonction tanh_impl C++ est présentée à Python :

static PyMethodDef superfastcode_methods[] = {
    // The first property is the name exposed to Python, fast_tanh
    // The second is the C++ function with the implementation
    // METH_O means it takes a single PyObject argument
    { "fast_tanh", (PyCFunction)tanh_impl, METH_O, nullptr },

    // Terminate the array with an object containing nulls.
    { nullptr, nullptr, 0, nullptr }
};

Ajoutez une structure qui définit le module comme vous le souhaitez dans votre code Python, en particulier lorsque vous utilisez l’instruction from...import .

Le nom importé dans ce code doit correspondre à la valeur dans les propriétés du projet sous Nomcible général> des > propriétés de configuration.

Dans l’exemple suivant, le nom du "superfastcode" module signifie que vous pouvez utiliser from superfastcode import fast_tanh dans Python, car fast_tanh il est défini dans superfastcode_methods. Les noms de fichiers internes au projet C++, tels que module.cpp, sont inconséquentials.
```
static PyModuleDef superfastcode_module = {
    PyModuleDef_HEAD_INIT,
    "superfastcode",                        // Module name to use with Python import statements
    "Provides some functions, but faster",  // Module description
    0,
    superfastcode_methods                   // Structure that defines the methods of the module
};
```
Ajoutez une méthode que Python appelle lorsqu’il charge le module, qui doit être nomméPyInit_<module-name>, où <le nom> du module correspond exactement à la propriété Nom cible général> du projet C++. Autrement dit, il correspond au nom du fichier .pyd généré par le projet.
```
PyMODINIT_FUNC PyInit_superfastcode() {
    return PyModule_Create(&superfastcode_module);
}
```
Regénérez le projet C++ pour vérifier votre code. Si vous rencontrez des erreurs, consultez la section « Résolution des problèmes ».

Utiliser PyBind11

Si vous avez effectué les étapes de la section précédente, vous avez probablement remarqué que vous avez utilisé beaucoup de codes réutilisables pour créer les structures de module nécessaires pour le code C++. PyBind11 simplifie le processus via des macros dans un fichier d’en-tête C++ qui accomplit le même résultat, mais avec beaucoup moins de code.

Pour plus d’informations sur le code de cette section, consultez les principes de base de PyBind11.

Installez PyBind11 à l’aide de pip : pip install pybind11 ou py -m pip install pybind11.

Vous pouvez également installer PyBind11 à l’aide de la fenêtre Environnements Python, puis utiliser sa commande Open in PowerShell pour l’étape suivante.
Dans le même terminal, exécutez python -m pybind11 --includes ou py -m pybind11 --includes.

Cette action affiche la liste des chemins d’accès que vous devez ajouter à la propriété C /C++>General>Additional Include Directoryies de votre projet. Veillez à supprimer le -I préfixe, s’il est présent.
En haut d’un module.cpp frais qui n’inclut aucune des modifications de la section précédente, incluez pybind11.h :
```
#include <pybind11/pybind11.h>
```

En bas du module.cpp, utilisez la PYBIND11_MODULE macro pour définir le point d’entrée vers la fonction C++ :

namespace py = pybind11;

PYBIND11_MODULE(superfastcode2, m) {
    m.def("fast_tanh2", &tanh_impl, R"pbdoc(
        Compute a hyperbolic tangent of a single argument expressed in radians.
    )pbdoc");

#ifdef VERSION_INFO
    m.attr("__version__") = VERSION_INFO;
#else
    m.attr("__version__") = "dev";
#endif
}

Générez le projet C++ pour vérifier votre code. Si vous rencontrez des erreurs, consultez la section suivante : « Résoudre les échecs de compilation », pour les solutions.

Résoudre les échecs de compilation

Le module C++ peut ne pas être compilé pour les raisons suivantes :

Erreur : Impossible de localiser Python.h (E1696 : impossible de open source fichier « Python.h » et/ou C1083 : Impossible d’ouvrir le fichier include : « Python.h » : Aucun fichier ou répertoire de ce type)

Solution : vérifiez que le chemin d’accès C/C++>Général>répertoires d’inclure supplémentaires dans les propriétés du projet pointe vers le dossier include de votre installation Python. Consultez l’étape 6 sous Créer le projet C++ principal.
Erreur : Impossible de localiser les bibliothèques Python

Solution : Vérifiez que le chemin d’accès :Répertoires de bibliothèque supplémentairesLinker>Général> dans les propriétés du projet pointe vers le dossier libs de votre installation Python. Consultez l’étape 6 sous Créer le projet C++ principal.
Erreurs de l’éditeur de liens liées à l’architecture cible

Solution : modifiez l’architecture de projet de la cible C++ pour qu’elle corresponde à celle de votre installation Python. Par exemple, si vous ciblez Win32 avec le projet C++, mais que votre installation Python est 64 bits, remplacez le projet C++ par x64.

Tester le code et comparer les résultats

Maintenant que la DLL est structurée en extensions Python, vous pouvez les référencer à partir du projet Python, importer les modules et utiliser leurs méthodes.

Rendre la DLL disponible pour Python

Vous pouvez rendre la DLL disponible pour Python de plusieurs façons. Voici deux approches à prendre en compte :

Cette première méthode fonctionne si le projet Python et le projet C++ se trouvent dans la même solution. Effectuez les actions suivantes :
1. Dans Explorateur de solutions, cliquez avec le bouton droit sur le nœud Références dans votre projet Python, puis sélectionnez Ajouter une référence.
2. Dans la boîte de dialogue qui s’affiche, sélectionnez l’onglet Projets, sélectionnez les projets superfastcode et superfastcode2, puis sélectionnez OK.
Une autre méthode installe également le module dans votre environnement Python, ce qui rend le module disponible pour d’autres projets Python. Pour plus d’informations, consultez la documentation du projet setuptools. Effectuez les actions suivantes :
1. Créez un fichier nommé setup.py dans le projet C++ en cliquant avec le bouton droit sur le projet, puis en sélectionnant Ajouter>Nouvel élément.
2. Sélectionnez Fichier C++ (.cpp), nommez le fichier setup.py, puis sélectionnez OK.
  
  Le nommage du fichier avec l’extension .py rend Visual Studio reconnu comme fichier Python malgré l’utilisation du modèle de fichier C++.
  
  Lorsque le fichier apparaît dans l’éditeur, collez le code suivant dans celui-ci, en fonction de la méthode d’extension :
  
  Pour CPython les extensions (projet superfastcode) :
```
from setuptools import setup, Extension

sfc_module = Extension('superfastcode', sources = ['module.cpp'])

setup(
    name='superfastcode',
    version='1.0',
    description='Python Package with superfastcode C++ extension',
    ext_modules=[sfc_module]
)
```
  Pour PyBind11 (projet superfastcode2) :
```
from setuptools import setup, Extension
import pybind11

cpp_args = ['-std=c++11', '-stdlib=libc++', '-mmacosx-version-min=10.7']

sfc_module = Extension(
    'superfastcode2',
    sources=['module.cpp'],
    include_dirs=[pybind11.get_include()],
    language='c++',
    extra_compile_args=cpp_args,
    )

setup(
    name='superfastcode2',
    version='1.0',
    description='Python package with superfastcode2 C++ extension (PyBind11)',
    ext_modules=[sfc_module],
)
```
3. Créez un deuxième fichier nommé pyproject.toml dans le projet C++ et collez le code suivant dans celui-ci :
```
[build-system]
requires = ["setuptools", "wheel", "pybind11"]
build-backend = "setuptools.build_meta"
```
4. Pour générer l’extension, cliquez avec le bouton droit sur l’onglet ouvrir pyproject.toml , puis sélectionnez Copier le chemin complet. Vous allez supprimer le nom pyproject.toml du chemin d’accès avant de l’utiliser.
5. Dans Explorateur de solutions, cliquez avec le bouton droit sur l’environnement Python actif, puis sélectionnez Gérer les packages Python.
  
  Conseil
  
  Si vous avez déjà installé le package, vous verrez qu’il apparaît ici. Avant de continuer, cliquez sur X pour le désinstaller.
6. Dans la zone de recherche, collez le chemin copié, supprimez pyproject.toml à partir de la fin, puis sélectionnez Entrée pour installer le module à partir de ce répertoire.
  
  Conseil
  
  Si l’installation échoue en raison d’une erreur d’autorisation, ajoutez --user à la fin et réessayez la commande.

Appeler la DLL à partir de Python

Une fois que vous avez mis la DLL à la disposition de Python, comme décrit dans la section précédente, vous pouvez appeler les fonctions et superfastcode2.fast_tanh2 les superfastcode.fast_tanh appeler à partir du code Python et comparer leurs performances à l’implémentation Python. Pour appeler la DLL, procédez comme suit :

Ajoutez les lignes suivantes dans votre fichier .py pour appeler les méthodes exportées à partir des DLL et afficher leurs sorties :

from superfastcode import fast_tanh
test(lambda d: [fast_tanh(x) for x in d], '[fast_tanh(x) for x in d] (CPython C++ extension)')

from superfastcode2 import fast_tanh2
test(lambda d: [fast_tanh2(x) for x in d], '[fast_tanh2(x) for x in d] (PyBind11 C++ extension)')

Exécutez le programme Python en sélectionnant Démarrer>sans débogage ou en sélectionnant Ctrl+F5.

Notes

Si la commande Démarrer sans débogage est désactivée, dans Explorateur de solutions, cliquez avec le bouton droit sur le projet Python, puis sélectionnez Définir en tant que projet de démarrage.

Notez que les routines C++ s’exécutent environ cinq à 20 fois plus rapidement que l’implémentation Python. Une sortie classique se présente comme suit :
```
Running benchmarks with COUNT = 500000
[tanh(x) for x in d] (Python implementation) took 0.758 seconds

[fast_tanh(x) for x in d] (CPython C++ extension) took 0.076 seconds

[fast_tanh2(x) for x in d] (PyBind11 C++ extension) took 0.204 seconds
```
Essayez d’augmenter la variable COUNT afin que les différences soient plus marquées.

Une build de débogage du module C++ s’exécute également plus lentement qu’une build de mise en production , car la build de débogage est moins optimisée et contient diverses vérifications d’erreur. N’hésitez pas à basculer entre ces configurations pour la comparaison, mais n’oubliez pas de revenir en arrière et de mettre à jour les propriétés que vous définissez précédemment pour la configuration de mise en production.

Dans la sortie, vous pouvez voir que l’extension PyBind11 n’est pas aussi rapide que l’extension CPython, bien qu’elle soit plus rapide que l’implémentation Python pure. Cette différence est principalement due au fait que vous avez utilisé l’appel METH_O , qui ne prend pas en charge plusieurs paramètres, noms de paramètres ou arguments de mots clés. PyBind11 génère du code légèrement plus complexe pour fournir une interface de type Python aux appelants. Toutefois, étant donné que le code de test appelle la fonction 500 000 fois, les résultats peuvent grandement amplifier cette surcharge !

Vous pouvez réduire la surcharge en déplaçant la for boucle dans le code natif. Cette approche implique l’utilisation du protocole itérateur (ou du type PyBind11 py::iterable pour le paramètre de fonction) pour traiter chaque élément. La suppression des transitions répétées entre Python et C++ est un moyen efficace de réduire le temps nécessaire pour traiter la séquence.

Résoudre les erreurs d’importation

Si vous recevez un message lorsque vous essayez d’importer ImportError votre module, vous pouvez le résoudre de l’une des manières suivantes :

Lorsque vous générez une référence de projet, assurez-vous que vos propriétés de projet C++ correspondent à l’environnement Python activé pour votre projet Python, en particulier les répertoires Include et Bibliothèque .
Vérifiez que votre fichier de sortie est nommé superfastcode.pyd. Tout autre nom ou extension empêche son importation.
Si vous avez installé votre module à l’aide du fichier setup.py , vérifiez que vous avez exécuté la commande pip dans l’environnement Python activé pour votre projet Python. Le développement de l’environnement Python dans Explorateur de solutions doit afficher une entrée pour le superfastcode.

Déboguer le code C++

Visual Studio prend en charge le débogage simultané du code Python et du code C++. Dans cette section, vous allez parcourir le processus à l’aide du projet superfastcode . Le processus est le même pour le projet superfastcode2 .

Dans Explorateur de solutions, cliquez avec le bouton droit sur le projet Python, sélectionnez Propriétés, sélectionnez l’onglet Débogage, puis sélectionnez l’option Activer> ledébogage du code natif.

Conseil

Lorsque vous activez le débogage de code natif, la fenêtre de sortie Python peut se fermer immédiatement une fois le programme terminé sans vous donner la touche d’habitude Appuyer sur une touche pour continuer à suspendre .

Solution : pour forcer une pause après avoir activé le débogage de code natif, ajoutez -i l’option au champ Exécuter> lesarguments de l’interpréteur sous l’onglet Débogage. Cet argument place l’interpréteur Python en mode interactif après l’exécution du code, auquel moment il attend que vous sélectionnons Ctrl+Z, puis Entrez pour fermer la fenêtre.

Sinon, si vous ne vous souciez pas de modifier votre code Python, vous pouvez ajouter et os.system("pause") des import os instructions à la fin de votre programme. Ce code duplique l’invite de pause d’origine.
Sélectionnez Fichier>Enregistrer pour enregistrer les modifications apportées aux propriétés.
Dans la barre d’outils Visual Studio, définissez la configuration de build sur Déboguer.
Étant donné que le code prend généralement plus de temps à s’exécuter dans le débogueur, vous pouvez modifier la COUNT variable dans votre fichier .py en une valeur qui est environ cinq fois plus petite que la valeur par défaut. Par exemple, remplacez-le de 5 00000 à1 00000.
Dans votre code C++, définissez un point d’arrêt sur la première ligne de la tanh_impl méthode, puis démarrez le débogueur en sélectionnant F5 ou Déboguer>démarrer le débogage.

Le débogueur s’arrête lorsque le code de point d’arrêt est appelé. Si le point d’arrêt n’est pas atteint, vérifiez que la configuration est définie sur Déboguer et que vous avez enregistré le projet, ce qui ne se produit pas automatiquement lorsque vous démarrez le débogueur.
Au niveau du point d’arrêt, vous pouvez parcourir le code C++, examiner les variables, et ainsi de suite. Pour plus d’informations sur ces fonctionnalités, consultez Déboguer Python et C++ ensemble.

Autres approches

Vous pouvez créer des extensions Python de différentes façons, comme décrit dans le tableau suivant. Les deux premières lignes et PyBind11, sont abordées CPython dans cet article.

Approche	Vintage	Utilisateurs représentatifs
Modules d’extension C/C++ pour `CPython`	1991	bibliothèque standard
PyBind11 (recommandé pour C++)	2015
Cython (recommandé pour C)	2007	gevent, kivy
HPy	2019
mypyc	2017
ctypes	2003	oscrypto
cffi	2013	cryptography, pypy
SWIG	1996	crfsuite
Boost.Python	2002
cppyy	2017

Voir aussi

Vous trouverez l’exemple complet de cette procédure pas à pas sur GitHub sur python-samples-vs-cpp-extension.