Débogage conjoint de Python et de C++Debugging Python and C++ together

La plupart des débogueurs Python standard prend en charge le débogage de code Python uniquement.Most regular Python debuggers support debugging of only Python code. Toutefois, dans la pratique, Python est utilisé conjointement avec C ou C++ dans les scénarios qui nécessitent de hautes performances ou la possibilité d’appeler les API de plateforme.In practice, however, Python is used in conjunction with C or C++ in scenarios requiring high performance or the ability to directly invoke platform APIs. (Pour la procédure pas à pas, consultez Création d’une extension C++ pour Python.)(See Creating a C++ extension for Python for a walkthrough.)

Visual Studio fournit un débogage en mode mixte intégré et simultané pour Python et C/C++ natif si vous avez sélectionné l’option Outils de développement natifs Python pour la charge de travail Développement Python dans le programme d’installation de Visual Studio.Visual Studio provides integrated, simultaneous mixed-mode debugging for Python and native C/C++, provided that you select the Python native development tools option for the Python Development workload in the Visual Studio installer.

Note

Le débogage en mode mixte n’est pas disponible avec Python Tools pour Visual Studio 1.x dans Visual Studio 2015 et version antérieure.Mixed-mode debugging is not available with Python Tools for Visual Studio 1.x in Visual Studio 2015 and earlier.

Les fonctionnalités de débogage en mode mixte sont les suivantes, comme expliqué dans cet article :Mixed-mode debugging features include the following, as explained in this article:

  • Piles d’appels combinéesCombined call stacks
  • Pas à pas détaillé alternant entre du code Python et natifStep between Python and native code
  • Points d’arrêt dans les deux types de codeBreakpoints in both types of code
  • Consultez les représentations Python d’objets dans des cadres natifs et vice versaSee Python representations of objects in native frames and vice versa
  • Débogage dans le contexte du projet Python ou du projet C++Debugging within the context of the Python project or the C++ project

Débogage en mode mixte

Icône représentant une caméra pour les vidéosmovie camera icon for video Pour introduction des modules C natifs de génération, de test et de débogage avec Visual Studio, visionnez la vidéo Exploration : création des modules natifs (youtube.com, 9 min09 s).For an introduction to building, testing, and debugging native C modules with Visual Studio, see Deep Dive: Creating Native Modules (youtube.com, 9m 09s). La vidéo s’applique à Visual Studio 2015 et 2017.The video is applicable to both Visual Studio 2015 and 2017.

Activer le débogage en mode mixte dans un projet PythonEnable mixed-mode debugging in a Python project

  1. Dans l’Explorateur de solutions, cliquez avec le bouton droit sur le projet Python, sélectionnez Propriétés, l’onglet Déboguer, puis Permettre le débogage du code natif.Right-click the Python project in Solution Explorer, select Properties, select the Debug tab, and then select Enable native code debugging. Cette option active le mode mixte pour toutes les sessions de débogage.This option enables mixed-mode for all debugging sessions.

    Activation du débogage du code natif

    Conseil

    Quand vous activez le débogage du code natif, la fenêtre de sortie Python peut disparaître immédiatement une fois le programme terminé sans afficher la pause habituelle « Appuyez sur une touche pour continuer... ».When you enable native code debugging, the Python output window may disappear immediately when the program has completed without giving you the usual "Press any key to continue..." pause. Pour forcer une pause, ajoutez l’option -i au champ Exécuter > Arguments de l’interpréteur sous l’onglet Déboguer quand vous activez le débogage du code natif.To force a pause, add the -i option to the Run > Interpreter Arguments field on the Debug tab when you enable native code debugging. Avec cet argument, l’interpréteur Python passe en mode interactif à la fin du code, où il attend que vous appuyiez sur Ctrl+Z, Entrée pour quitter.This argument puts the Python interpreter into interactive mode after the code finishes, at which point it waits for you to press Ctrl+Z, Enter to exit.

  2. Lorsque vous attachez le débogueur en mode mixte à un processus existant (Débogage > Attacher au processus...), utilisez le bouton Sélectionner... pour ouvrir la boîte de dialogue Sélectionner le type de code.When attaching the mixed-mode debugger to an existing process (Debug > Attach to Process...), use the Select... button to open the Select Code Type dialog. Définissez ensuite l’option Déboguer ces types de codes, puis sélectionnez à la fois Natif et Python dans la liste :Then set the Debug these code types option and select both Native and Python in the list:

    Sélection des types de codes Natif et Python

    Les paramètres de type de code sont persistants. Par conséquent, si vous souhaitez désactiver le débogage en mode mixte lors de l’attachement à un autre processus par la suite, désélectionnez le type de code Python.The code type settings are persistent, so if you want to disable mixed-mode debugging when attaching to a different process later, clear the Python code type.

    Vous pouvez sélectionner d’autres types de codes, en plus ou au lieu du type Natif.It's possible to select other code types in addition to, or instead of, Native. Par exemple, si une application managée héberge CPython, qui utilise lui-même des modules d’extension natifs, et que vous souhaitez les déboguer tous les trois, vous pouvez sélectionner les types Python, Natif et Managé afin de bénéficier d’une expérience de débogage unifiée incluant des piles des appels combinées et l’exécution d’un débogage pas à pas portant sur les trois runtimes simultanément.For example, if a managed application hosts CPython, which in turn uses native extension modules, and you want to debug all three, you can check Python, Native, and Managed together for a unified debugging experience including combined call stacks and stepping between all three runtimes.

  3. Quand vous démarrez un débogage en mode mixte pour la première fois, une boîte de dialogue Symboles Python obligatoires peut s’afficher (consultez Symboles pour le débogage en mode mixte).When you start debugging in mixed mode for the first time, you may see a Python Symbols Required dialog (see Symbols for mixed-mode debugging). Vous ne devez installer les symboles qu’une seule fois pour un environnement Python donné.You need to install symbols only once for any given Python environment. Les symboles sont automatiquement inclus si vous installez la prise en charge de Python par le biais du programme d’installation de Visual Studio 2017.Symbols are automatically included if you install Python support through the Visual Studio 2017 installer.

  4. Vous mettez à disposition le code source du code Python standard lors du débogage. Rendez-vous sur https://www.python.org/downloads/source/, téléchargez l’archive correspondant à votre version, puis extrayez-la dans un dossier.You make the source code for standard Python itself available when debugging, visit https://www.python.org/downloads/source/, download the archive appropriate for your version, and extract it to a folder. Faites ensuite pointer Visual Studio vers des fichiers spécifiques dans ce dossier quand il vous le demande.You then point Visual Studio to specific files in that folder at whatever point it prompts you.

Activer le débogage en mode mixte dans un projet C/C++Enable mixed-mode debugging in a C/C++ project

Visual Studio 2017 (version 15.5 et ultérieur) prend en charge le débogage en mode mixte d’un projet C/C++ (par exemple, lors de l’incorporation de Python dans une autre application, comme décrit sur python.org).Visual Studio 2017 (version 15.5 and higher) supports mixed-mode debugging from a C/C++ project (for example, when when embedding Python in another application as described on python.org). Pour activer le débogage en mode mixte, configurez le projet C/C++ pour lancer le « débogueur Python/Natif » :To enable mixed-mode debugging, configure the C/C++ project to launch the "Python/Native Debugger":

  1. Cliquez avec le bouton droit sur le projet C/C++ dans l’Explorateur de solutions, puis sélectionnez Propriétés.Right-click the C/C++ project in Solution Explorer and select Properties
  2. Sélectionnez l’onglet Débogage, choisissez « Débogueur Python/natif » dans le Débogueur à lancer, puis sélectionnez OK.Select the Debugging tab, select "Python/Native Debugger" from the Debugger to launch, and select OK.

    Sélection du débogueur Python/natif dans un projet C/C++

Avec cette méthode, sachez que vous ne pouvez pas déboguer le lanceur py.exe lui-même, car il génère un processus python.exe enfant auquel le débogueur ne sera pas attaché.Using this method, be aware that you can't debug the py.exe launcher itself, because it spawns a child python.exe process that the debugger won't be attached to. Si vous souhaitez lancer python.exe directement avec des arguments, changez l’option Commande dans les propriétés de débogage de Python/natif (voir image précédente) pour indiquer le chemin complet vers python.exe, puis spécifiez les arguments dans Arguments de commande.If you want to launch python.exe directly with arguments, change the Command option in the Python/Native Debugging properties (shown in the previous image) to specify the full path to python.exe, then specify arguments in Command Arguments.

Attachement du débogueur en mode mixteAttaching the mixed-mode debugger

Pour toutes les versions précédentes de Visual Studio, le débogage en mode mixte direct est activé uniquement lors du lancement d’un projet Python dans Visual Studio, car les projets C/C++ utilisent uniquement le débogueur natif.For all previous versions of Visual Studio, direct mixed-mode debugging is enabled only when launching a Python project in Visual Studio because C/C++ projects use only the native debugger. Vous pouvez toutefois attacher le débogueur séparément :You can, however, attach the debugger separately:

  1. Démarrez le projet C++ sans débogage (Déboguer > Démarrer sans débogage ou Ctrl+F5).Start the C++ project without debugging (Debug > Start without debugging or Ctrl+F5).
  2. Sélectionnez Déboguer > Attacher au processus.... Dans la boîte de dialogue qui s’affiche, sélectionnez le processus approprié, puis utilisez le bouton Sélectionner pour ouvrir la boîte de dialogue Sélectionner le type de code. Dans celle-ci, sélectionnez Python :Select Debug > Attach to Process.... In the dialog that appears, select the appropriate process, then use the Select... button to open the Select Code Type dialog in which you can select Python:

    Sélection de Python comme type de débogage au moment de l’attachement d’un débogueur

  3. Sélectionnez OK pour fermer cette boîte de dialogue, puis sélectionnez Attacher pour démarrer le débogueur.Select OK to close that dialog, then Attach to start the debugger.

  4. Vous devrez peut-être introduire une pause ou un délai approprié dans l’application C++ pour que celle-ci n’appelle pas le code Python à déboguer avant que vous n’ayez la possibilité d’attacher le débogueur.You may need to introduce a suitable pause or delay in the C++ app to ensure that it doesn't call the Python code you want to debug before you have a chance to attach the debugger.

Fonctionnalités spécifiques du mode mixteMixed-mode specific features

Pile des appels combinéeCombined call stack

La fenêtre Pile des appels affiche des frames de pile natifs et Python entrelacés, en insérant des transitions entre les deux :The Call Stack window shows both native and Python stack frames interleaved, with transitions marked between the two:

Pile des appels combinée

Si l’option Outils > Options > Débogage > Général > Activer Uniquement mon code est définie, les transitions apparaissent sous la forme « [Code externe] », sans spécifier la direction de la transition.Transitions appear as "[External Code]", without specifying the direction of transition, if the Tools > Options > Debugging > General > Enable Just My Code option is set.

Un double-clic sur un frame d’appel quelconque active ce dernier et ouvre le code source approprié, si cela est possible.Double-clicking any call frame makes it active and opens the appropriate source code, if possible. Si le code source n’est pas disponible, le frame est quand même activé et les variables locales peuvent être inspectées.If source code is not available, the frame is still made active and local variables can be inspected.

Pas à pas détaillé alternant entre code Python et natifStepping between Python and native code

Lorsque vous utilisez les commandes Pas à pas détaillé (F11) ou Pas à pas sortant (Maj+F11), le débogueur en mode mixte gère correctement l’alternance entre ces types de codes.When using the Step Into (F11) or Step Out (Shift+F11) commands, the mixed-mode debugger correctly handles changes between code types. Par exemple, lorsque Python appelle une méthode d’un type implémenté en C, le pas à pas détaillé sur un appel de cette méthode s’arrête au début de la fonction native implémentant la méthode.For example, when Python calls a method of a type that is implemented in C, stepping in on a call to that method stops at the beginning of the native function implementing the method. De même, lorsqu’un code natif appelle une fonction API Python, un code Python est appelé.Similarly, when native code calls some Python API function that results in Python code being invoked. Par exemple, l’exécution d’un pas à pas détaillé dans PyObject_CallObject sur une valeur de fonction initialement définie dans Python s’arrête au début de la fonction Python.For example, stepping into a PyObject_CallObject on a function value that was originally defined in Python stops at the beginning of the Python function. L’exécution d’un pas à pas détaillé alternant entre un code Python et natif est également prise en charge pour les fonctions natives appelées à partir de Python par le biais de ctypes.Stepping in from Python to native is also supported for native functions invoked from Python via ctypes.

Vue des valeurs PyObject dans le code natifPyObject values view in native code

Lorsqu’un frame natif (C ou C++) est actif, ses variables locales s’affichent dans la fenêtre Variables locales du débogueur.When a native (C or C++) frame is active, its local variables show up in the debugger Locals window. Dans les modules d’extension Python natifs, de nombreuses variables sont de type PyObject (qui est un typedef de _object), ou de quelques autres types Python fondamentaux (consultez la liste ci-dessous).In native Python extension modules, many of these variables are of type PyObject (which is a typedef for _object), or a few other fundamental Python types (see list below). Dans le cadre du débogage en mode mixte, ces valeurs présentent un nœud enfant supplémentaire intitulé « Python view » (Vue Python).In mixed-mode debugging, these values present an additional child node labeled "Python view." Quand ce nœud est développé, il affiche la représentation Python de la variable, telle qu’elle apparaîtrait si une variable locale référençant le même objet était présente dans un frame Python.When expanded, this node shows the variable's Python representation, identical to what you'd see if a local variable referencing the same object was present in a Python frame. Les enfants de ce nœud sont modifiables.The children of this node are editable.

Vue Python

Pour désactiver cette fonctionnalité, cliquez avec le bouton droit sur un emplacement quelconque de la fenêtre Variables locales, puis désélectionnez l’option de menu Python > Show Python View Nodes (Afficher les nœuds de vue Python) :To disable this feature, right-click anywhere in the Locals window and toggle the Python > Show Python View Nodes menu option:

Activation de la vue Python

Types C affichant les nœuds « [Python View] » (Vue Python) (si cette option est activée) :C types that show "[Python View]" nodes (if enabled):

  • PyObject
  • PyVarObject
  • PyTypeObject
  • PyByteArrayObject
  • PyBytesObject
  • PyTupleObject
  • PyListObject
  • PyDictObject
  • PySetObject
  • PyIntObject
  • PyLongObject
  • PyFloatObject
  • PyStringObject
  • PyUnicodeObject

« [Python View] » (Vue Python) n’apparaît pas automatiquement pour les types que vous créez vous-même."[Python View]" does not automatically appear for types you author yourself. Quand vous créez des extensions pour Python 3.x, ceci n’est généralement pas un problème, car tout objet comporte au final un champ ob_base de l’un des types ci-dessus, ce qui entraîne l’apparition des nœuds « [Vue Python] ».When authoring extensions for Python 3.x, this lack is usually not an issue because any object ultimately has an ob_base field of one of the types above, which causes "[Python View]" to appear.

Toutefois, pour Python 2.x, chaque type d’objet déclare généralement son en-tête sous la forme d’une collection de champs inline, et il n’existe aucune association entre les types créés personnalisés et PyObject au niveau du système de type en code C/C++.For Python 2.x, however, each object type typically declares its header as a collection of inline fields, and there is no association between custom authored types and PyObject at the type system level in C/C++ code. Pour activer les nœuds « [Vue Python] » pour de tels types personnalisés, modifiez le fichier PythonDkm.natvis dans le répertoire d’installation de Python Tools, et ajoutez un autre élément dans le code XML pour votre struct C ou classe C++.To enable "[Python View]" nodes for such custom types, edit the PythonDkm.natvis in the Python tools install directory, and add another element in the XML for your C struct or C++ class.

Une autre option (mieux adaptée) consiste à suivre la spécification PEP 3123 et à utiliser un champ PyObject ob_base; explicite plutôt que PyObject_HEAD, bien que cette opération ne soit pas toujours possible pour des raisons de compatibilité descendante.An alternate (and better) option is to follow PEP 3123 and use an explicit PyObject ob_base; field rather than PyObject_HEAD, though that may not always be possible for backwards-compatibility reasons.

Vue des valeurs natives dans le code PythonNative values view in Python code

Comme dans la section précédente, vous pouvez activer un nœud « [C++ View] » (Vue C++) pour les valeurs natives dans la fenêtre Variables locales lorsqu’un frame Python est actif.Similar to the previous section, you can enable a "[C++ View]" for native values in the Locals window when a Python frame is active. Cette fonctionnalité est désactivée par défaut. Si vous souhaitez l’activer, cliquez avec le bouton droit dans la fenêtre Variables locales, puis sélectionnez l’option Python > Show C++ View Nodes (Afficher les nœuds de vue C++).This feature is not enabled by default, so you turn it on by right-clicking in the Locals window and toggling the Python > Show C++ View Nodes menu option.

Activation de la vue C++

Le nœud « [Vue C++] » fournit une représentation de la structure C/C++ sous-jacente d’une valeur, telle qu’elle apparaîtrait dans un frame natif.The "[C++ View]" node provides a representation of the underlying C/C++ structure for a value, identical to what you'd see in a native frame. Par exemple, il affiche une instance de _longobject (dont PyLongObject est un typedef) pour un entier long Python, et il essaie de déduire les types des classes natives que vous avez vous-même créées.For example, it shows an instance of _longobject (for which PyLongObject is a typedef) for a Python long integer, and it tries to infer types for native classes that you have authored yourself. Les enfants de ce nœud sont modifiables.The children of this node are editable.

Vue C++

Si un champ enfant d’un objet est du type PyObject ou de l’un des autres types pris en charge, il comporte un nœud de représentation « [Vue Python] » (si ces représentations sont activées), ce qui offre la possibilité de parcourir les graphiques d’objet quand les liens ne sont pas directement exposés à Python.If a child field of an object is of type PyObject, or one of the other supported types, then it has a "[Python View]" representation node (if those representations are enabled), making it possible to navigate object graphs where links are not directly exposed to Python.

Contrairement aux nœuds « [Python View] » (Vue Python), qui utilisent les métadonnées d’objet Python pour déterminer le type de l’objet, il n’existe aucun mécanisme suffisamment fiable pour « [C++ View] » (Vue C++).Unlike "[Python View]" nodes, which use Python object metadata to determine the type of the object, there's no similarly reliable mechanism for "[C++ View]". En règle générale, pour une valeur Python donnée (autrement dit, une référence PyObject) il est impossible de déterminer avec certitude la structure C/C++ sous-jacente.Generally speaking, given a Python value (that is, a PyObject reference) it's not possible to reliably determine which C/C++ structure is backing it. Le débogueur en mode mixte tente de déduire ce type en examinant les différents champs du type de l’objet (comme l’élément PyTypeObject référencé par son champ ob_type) qui comportent des types de pointeur fonction.The mixed-mode debugger tries to guess that type by looking at various fields of the object's type (such as the PyTypeObject referenced by its ob_type field) that have function pointer types. Si l’un de ces pointeurs fonction référence une fonction qui peut être résolue, et que cette fonction comporte un paramètre self avec un type plus spécifique que PyObject*, ce type est considéré comme le type de stockage.If one of those function pointers references a function that can be resolved, and that function has a self parameter with type more specific than PyObject*, then that type is assumed to be the backing type. Par exemple, si l’élément ob_type->tp_init d’un objet donné pointe vers la fonction suivante :For example, if ob_type->tp_init of a given object points at the following function:

static int FobObject_init(FobObject* self, PyObject* args, PyObject* kwds) {
    return 0;
}

le débogueur peut correctement en déduire que le type C de l’objet est FobObject.then the debugger can correctly deduce that the C type of the object is FobObject. S’il ne parvient pas à déterminer un type plus précis en fonction de tp_init, il passe aux autres champs.If it's unable to determine a more precise type from tp_init, it moves on to other fields. S’il lui est impossible de déduire le type d’après l’ensemble de ces champs, le nœud « [C++ View] » (Vue C++) présente l’objet sous la forme d’une instance PyObject.If it's unable to deduce the type from any of those fields, the "[C++ View]" node presents the object as a PyObject instance.

Pour obtenir systématiquement une représentation utile pour les types créés personnalisés, il est préférable d’inscrire au moins une fonction spéciale lors de l’inscription du type et d’utiliser un paramètre self fortement typé.To always get a useful representation for custom authored types, it's best to register at least one special function when registering the type, and use a strongly-typed self parameter. La plupart des types répondent automatiquement à cette exigence ; dans le cas contraire, tp_init constitue généralement l’entrée la plus simple à utiliser dans ce but.Most types fulfill that requirement naturally; if that's not the case, then tp_init is usually the most convenient entry to use for this purpose. Une implémentation factice de tp_init pour un type servant uniquement à permettre la déduction du type de débogueur peut simplement renvoyer immédiatement la valeur zéro, comme dans l’exemple de code ci-dessus.A dummy implementation of tp_init for a type that is present solely to enable debugger type inference can just return zero immediately, as in the code sample above.

Différences par rapport au débogage Python standardDifferences from standard Python debugging

Le débogueur en mode mixte se différencie du débogueur Python standard par le fait qu’il offre certaines fonctionnalités supplémentaires, tout en étant dépourvu de certaines capacités associées à Python :The mixed-mode debugger is distinct from the standard Python debugger in that it introduces some additional features but lacks some Python-related capabilities:

  • Fonctionnalités non prises en charge : points d’arrêt conditionnels, fenêtre de débogage interactive et débogage à distance multiplateforme.Unsupported features: conditional breakpoints, Debug Interactive window, and cross-platform remote debugging.
  • Fenêtre Exécution : disponible mais avec un sous-ensemble de fonctionnalités restreint, incluant notamment toutes les limitations répertoriées dans cette section.Immediate window: is available but with a limited subset of its functionality, including all the limitations listed here.
  • Versions Python prises en charge : CPython 2.7, 3.3 et versions ultérieures uniquement.Supported Python versions: CPython 2.7 and 3.3+ only.
  • Visual Studio Shell : lorsque vous utilisez Python avec Visual Studio Shell (par exemple, si vous l’avez installé à l’aide du programme d’installation intégré), Visual Studio n’est pas en mesure d’ouvrir les projets C++, et l’expérience de modification des fichiers C++ se limite à celle d’un éditeur de texte de base.Visual Studio Shell: When using Python with Visual Studio Shell (for example, if you installed it using the integrated installer), Visual Studio is unable to open C++ projects, and the editing experience for C++ files is that of a basic text editor only. Toutefois, le débogage C/C++ et le débogage en mode mixte sont entièrement pris en charge dans Shell avec le code source, l’exécution d’un pas à pas détaillé dans le code natif et l’évaluation des expressions C++ dans les fenêtres de débogage.However, C/C++ debugging and mixed-mode debugging are fully supported in Shell with source code, stepping into native code, and C++ expression evaluation in debugger windows.
  • Visualisation et développement d’objets : lorsque vous visualisez des objets Python dans les fenêtres d’outil de débogage Variables locales et Espion, le débogueur en mode mixte présente uniquement la structure des objets.Viewing and expanding objects: When viewing Python objects in the Locals and Watch debugger tool windows, the mixed-mode debugger shows only the structure of the objects. Il n’évalue pas automatiquement les propriétés et n’affiche pas les attributs calculés.It does not automatically evaluate properties, or show computed attributes. Dans le cas des collections, il présente uniquement les éléments pour les types de collections intégrés (tuple, list, dict, set).For collections, it shows only elements for built-in collection types (tuple, list, dict, set). Les types de collections personnalisés ne sont pas visualisés sous forme de collections, sauf s’ils sont hérités d’un type de collection intégré.Custom collection types are not visualized as collections, unless they are inherited from some built-in collection type.
  • Évaluation des expressions : voir ci-dessous.Expression evaluation: see below.

Évaluation des expressionsExpression evaluation

Le débogueur Python standard autorise l’évaluation des expressions Python arbitraires dans les fenêtres Espion et Exécution lorsque le processus débogué est suspendu au niveau d’un emplacement quelconque dans le code, à condition qu’il ne soit pas bloqué dans une opération d’E/S ou dans un autre appel système similaire.The standard Python debugger allows evaluation of arbitrary Python expressions in Watch and Immediate windows when the debugged process is paused at any point in the code, so long as it is not blocked in an I/O operation or other similar system call. Dans le cadre du débogage en mode mixte, les expressions arbitraires ne peuvent être évaluées qu’en cas d’arrêt dans le code Python, après un point d’arrêt ou lors d’un pas à pas détaillé dans le code.In mixed-mode debugging, arbitrary expressions can be evaluated only when stopped in Python code, after a breakpoint, or when stepping into the code. Les expressions ne peuvent être évaluées que sur le thread sur lequel le point d’arrêt ou l’opération pas à pas se sont produits.Expressions can be evaluated only on the thread on which the breakpoint or the stepping operation occurred.

Lors d’un arrêt dans le code natif, ou dans le code Python lorsque les conditions ci-dessus ne s’appliquent pas (par exemple, après une opération de pas à pas sortant, ou sur un autre thread), l’évaluation des expressions se limite à accéder aux variables locales et globales dans la portée du frame actuellement sélectionné, à accéder aux champs de ces variables et à indexer les types de collections intégrés avec des littéraux.When stopped in native code, or in Python code where the conditions above do not apply (for example, after a step-out operation, or on a different thread), expression evaluation is limited to accessing local and global variables in scope of the currently selected frame, accessing their fields, and indexing built-in collection types with literals. Par exemple, l’expression ci-après peut être évaluée dans n’importe quel contexte (à condition que tous les identificateurs référencent des variables existantes et des champs des types appropriés) :For example, the following expression can be evaluated in any context (provided that all identifiers refer to existing variables and fields of appropriate types):

foo.bar[0].baz['key']

Le débogueur en mode mixte résout également de telles expressions d’une autre manière.The mixed-mode debugger also resolves such expressions differently. Toutes les opérations d’accès aux membres recherchent uniquement les champs qui font directement partie intégrante de l’objet (tels qu’une entrée dans ses éléments __dict__ ou __slots__, ou un champ d’un struct natif exposé à Python par le biais de tp_members), et ignorent tout élément __getattr__, __getattribute__ ou toute logique de descripteur.All member-access operations look up only fields that are directly part of the object (such as an entry in its __dict__ or __slots__, or a field of a native struct that is exposed to Python via tp_members), and ignore any __getattr__, __getattribute__ or descriptor logic. De même, toutes les opérations d’indexation ignorent __getitem__ et accèdent directement aux structures de données internes des collections.Similarly, all indexing operations ignore __getitem__, and access the inner data structures of collections directly.

Par souci de cohérence, ce schéma de résolution de noms est utilisé pour toutes les expressions qui correspondent aux contraintes relatives à l’évaluation des expressions limitée, que les expressions arbitraires soient ou non autorisées au niveau du point d’arrêt actuel.For the sake of consistency, this name resolution scheme is used for all expressions that match the constraints for limited expression evaluation, regardless of whether arbitrary expressions are allowed at the current stop point. Pour imposer la sémantique Python appropriée lorsqu’un évaluateur complet est disponible, indiquez l’expression entre parenthèses :To force proper Python semantics when a full-featured evaluator is available, enclose the expression in parentheses:

(foo.bar[0].baz['key'])