Protocole Objet
***************

PyObject* Py_NotImplemented

   Le singleton "NotImplemented", utilisé pour signaler qu'une
   opération n'est pas implémentée pour la combinaison de types en
   question.

Py_RETURN_NOTIMPLEMENTED

   Traite proprement le renvoi de "Py_NotImplemented" depuis
   l'intérieur d'une fonction C (c'est-à-dire, incrémente le compteur
   de référence de *NotImplemented* et le renvoie).

int PyObject_Print(PyObject *o, FILE *fp, int flags)

   Écrit un objet *o*, dans le fichier *fp*. Renvoie "-1" en cas
   d'erreur. L'argument *flags* est utilisé pour permettre certaines
   options de rendu. La seule option actuellement gérée est
   "Py_PRINT_RAW" ; si cet argument est fourni, le "str()" de l'objet
   est utilisé pour le rendu à la place de "repr()".

int PyObject_HasAttr(PyObject *o, PyObject *attr_name)

   Renvoie "1" si *o* a l'attribut *attr_name*, et "0" sinon. Ceci est
   équivalent à l'expression Python "hasattr(o, attr_name)". Cette
   fonction réussit toujours.

   Note that exceptions which occur while calling "__getattr__()" and
   "__getattribute__()" methods will get suppressed. To get error
   reporting use "PyObject_GetAttr()" instead.

int PyObject_HasAttrString(PyObject *o, const char *attr_name)

   Renvoie "1" si *o* a l'attribut *attr_name*, et "0" sinon. Ceci est
   équivalent à l'expression Python "hasattr(o, attr_name)". Cette
   fonction réussit toujours.

   Note that exceptions which occur while calling "__getattr__()" and
   "__getattribute__()" methods and creating a temporary string object
   will get suppressed. To get error reporting use
   "PyObject_GetAttrString()" instead.

PyObject* PyObject_GetAttr(PyObject *o, PyObject *attr_name)
    *Return value: New reference.*

   Récupère l'attribut nommé *attr_name* de l'objet *o*. Renvoie la
   valeur de l'attribut en cas de succès, ou *NULL* en cas d'échec.
   Ceci est équivalent à l'expression Python "o.attr_name".

PyObject* PyObject_GetAttrString(PyObject *o, const char *attr_name)
    *Return value: New reference.*

   Récupère un attribut nommé *attr_name* de l'objet *o*. Renvoie la
   valeur de l'attribut en cas de succès, ou *NULL* en cas d'échec.
   Ceci est équivalent à l'expression Python "o.attr_name".

PyObject* PyObject_GenericGetAttr(PyObject *o, PyObject *name)

   Accesseur d'attribut générique destiné à être mis dans le *slot*
   "tp_getattro" d'un objet type. Recherche un descripteur dans le
   dictionnaire de classes du MRO de l'objet ainsi qu'un attribut dans
   le "__dict__"  de l'objet (si présent). Comme défini dans
   Implémentation de descripteurs, les descripteurs de données sont
   prioritaires sur les attributs d'instance, contrairement aux autres
   descripteurs. Sinon, une "AttributeError" est levée.

int PyObject_SetAttr(PyObject *o, PyObject *attr_name, PyObject *v)

   Définit la valeur de l'attribut nommé *attr_name*, pour l'objet
   *o*, à la valeur *v*. Lève une exception et renvoie "-1" en cas
   d'échec ; renvoie "0" en cas de succès. Ceci est équivalent à
   l'instruction Python "o.attr_name = v".

   Si *v* est *NULL*, l'attribut est supprimé. Cette fonctionnalité
   est obsolète,nous vous conseillons d'utiliser "PyObject_DelAttr()".

int PyObject_SetAttrString(PyObject *o, const char *attr_name, PyObject *v)

   Définit la valeur de l'attribut nommé *attr_name*, pour l'objet
   *o*, à la valeur *v*. Lève une exception et renvoie "-1" en cas
   d'échec ; renvoie "0" en cas de succès. Ceci est équivalent à
   l'instruction Python "o.attr_name = v".

   Si *v* est *NULL*, l'attribut est supprimé. Cette fonctionnalité
   est obsolète, nous vous conseillons d'utiliser
   "PyObject_DelAttr()".

int PyObject_GenericSetAttr(PyObject *o, PyObject *name, PyObject *value)

   Accesseur et suppresseur générique d'attributs qui est fait pour
   être mis dans le "tp_setattro" d'un objet type. Il cherche un
   descripteur de données dans le dictionnaire de classes dans le MRO
   de l'objet et, si ce descripteur est trouvé, c'est lui qui est
   utilisé de préférence pour la suppression et la définition de
   l'attribut dans le dictionnaire d'instance. Sinon, l'attribut est
   défini ou supprimé dans le  "__dict__" de l'objet (si présent). En
   cas de succès, "0" est renvoyé, sinon une "AttributeError" est
   levée et "-1" est renvoyé.

int PyObject_DelAttr(PyObject *o, PyObject *attr_name)

   Supprime l'attribut nommé *attr_name*, pour l'objet *o*. Renvoie
   "-1" en cas d'échec. Ceci est l'équivalent de l'expression Python
   "del o.attr_name".

int PyObject_DelAttrString(PyObject *o, const char *attr_name)

   Supprime l'attribut nommé *attr_name*, pour l'objet *o*. Renvoie
   "-1" en cas d'échec. Ceci est l'équivalent de l'expression Python
   "del o.attr_name".

PyObject* PyObject_GenericGetDict(PyObject *o, void *context)

   Une implémentation générique de l'accesseur d'un descripteur d'un
   "__dict__". Crée le dictionnaire si nécessaire.

   Nouveau dans la version 3.3.

int PyObject_GenericSetDict(PyObject *o, void *context)

   Une implémentation générique du mutateur d'un descripteur de
   "__dict__". Cette implémentation n'autorise pas la suppression du
   dictionnaire.

   Nouveau dans la version 3.3.

PyObject* PyObject_RichCompare(PyObject *o1, PyObject *o2, int opid)
    *Return value: New reference.*

   Compare les valeurs de *o1* et *o2* en utilisant l'opération
   spécifiée par *opid*, qui doit être "Py_LT", "Py_LE", "Py_EQ",
   "Py_NE", "Py_GT", ou "Py_GE", correspondant à "<", "<=", "==",
   "!=", ">", ou ">=" respectivement. Ceci est l'équivalent de
   l'expression Python "o1 op o2", où "op" est l'opérateur
   correspondant à *opid*. Renvoie la valeur de la comparaison en cas
   de succès, ou *NULL* en cas d'échec.

int PyObject_RichCompareBool(PyObject *o1, PyObject *o2, int opid)

   Compare les valeurs de *o1* et *o2* en utilisant l'opération
   spécifiée par *opid*, qui doit être "Py_LT", "Py_LE", "Py_EQ",
   "Py_NE", "Py_GT", ou "Py_GE", correspondant à "<", "<=", "==",
   "!=", ">", ou ">=" respectivement. Renvoie "-1" en cas d'erreur,
   "0" si le résultat est faux, et "1" sinon. Ceci est l'équivalent de
   l'expression Python "o1 op o2", où "op" est l'opérateur
   correspondant à *opid*.

Note:

  Si *o1* et *o2* sont le même objet, "PyObject_RichCompareBool()"
  renvoie toujours "1" pour "Py_EQ" et "0" pour "Py_NE".

PyObject* PyObject_Repr(PyObject *o)
    *Return value: New reference.*

   Calcule une représentation en chaîne de caractères de l'objet *o*.
   Renvoie la représentation en chaîne de caractères en cas de succès,
   *NULL* en cas d'échec. Ceci est l'équivalent de l'expression Python
   "repr(o)". Appelé par la fonction intégrée "repr()".

   Modifié dans la version 3.4: Cette fonction inclut maintenant une
   assertion de débogage afin d'assurer qu'elle ne passe pas sous
   silence une exception active.

PyObject* PyObject_ASCII(PyObject *o)

   Comme "PyObject_Repr()", calcule une représentation en chaîne de
   caractères de l'objet *o*, mais échappe les caractères non ASCII
   dans la chaîne de caractères renvoyée par "PyObject_Repr()" avec'
   "\x", "\u" ou "\U". Cela génère une chaîne de caractères similaire
   à celle renvoyée par "PyObject_Repr()" en Python 2. Appelée par la
   fonction native "ascii()".

PyObject* PyObject_Str(PyObject *o)
    *Return value: New reference.*

   Calcule une représentation en chaîne de caractères de l'objet *o*.
   Renvoie la représentation en chaîne de caractères en cas de succès,
   *NULL* en cas d'échec. Ceci est l'équivalent de l'expression Python
   "str(o)". Appelée par la fonction native "str()", et, par
   conséquent, par la fonction "print()".

   Modifié dans la version 3.4: Cette fonction inclut maintenant une
   assertion de débogage afin d'assurer qu'elle ne passe pas sous
   silence une exception active.

PyObject* PyObject_Bytes(PyObject *o)

   Calcule une représentation en octets de l'objet *o*. *NULL* est
   renvoyé en cas d'échec, un objet séquence d'octets est renvoyé en
   cas de succès. Ceci est l'équivalent de l'expression Python
   "bytes(o)", quand *o* n'est pas un entier. Contrairement à
   "bytes(o)", une exception *TypeError* est levée lorsque *o* est un
   entier au lieu d'un objet octet initialisé avec des zéros.

int PyObject_IsSubclass(PyObject *derived, PyObject *cls)

   Renvoie "1" si la classe *derived* est identique à ou dérivée de la
   classe *cls*, renvoie "0" sinon. En cas d'erreur, renvoie "-1".

   Si *cls* est un tuple, la vérification est menée sur chaque entrée
   de *cls*. Le résultat sera "1" quand au moins une des vérifications
   renvoie "1", sinon ce sera "0".

   Si *cls* a une méthode "__subclasscheck__()", elle est appelée pour
   déterminer le statut de la sous-classe comme décrit dans **PEP
   3119**. Sinon, *derived* est une sous-classe de *cls* si c'est une
   sous-classe directe ou indirecte, c'est-à-dire contenue dans
   "cls.__mro__".

   Normalement seulement les classes objets, c'est-à-dire les
   instances de "type" ou d'une classe dérivée, sont considérées
   classes. Cependant, les objets peuvent surcharger cela en ayant un
   attribut "__bases__" (qui doit être un tuple de classes de bases).

int PyObject_IsInstance(PyObject *inst, PyObject *cls)

   Renvoie "1" si *inst* est une instance de la classe *cls* ou une
   sous-classe de *cls*, ou "0" sinon. En cas d'erreur, renvoie "-1"
   et initialise une exception.

   Si *cls* est un tuple, la vérification est menée sur chaque entrée
   de *cls*. Le résultat sera "1" quand au moins une des vérifications
   renvoie "1", sinon ce sera "0".

   Si *cls* a une méthode "__subclasscheck__()", elle sera appelée
   pour déterminer le statut de la sous-classe comme décrit dans **PEP
   3119**. Sinon, *inst* est une instance *cls* si sa classe est une
   sous-classe de *cls*.

   Une instance *inst* peut surcharger ce qui est considéré comme sa
   classe en ayant un attribut "__class__".

   Un objet *cls* peut surcharger s'il est considéré comme une classe,
   et ce que ses classes de bases sont, en ayant un attribut
   "__bases__" (qui doit être un tuple des classes de base).

int PyCallable_Check(PyObject *o)

   Détermine si l'objet *o* est appelable. Renvoie "1" si c'est le
   cas, et "0" sinon. Cette fonction réussit toujours.

PyObject* PyObject_Call(PyObject *callable_object, PyObject *args, PyObject *kw)
    *Return value: New reference.*

   Call a callable Python object *callable_object*, with arguments
   given by the tuple *args*, and named arguments given by the
   dictionary *kw*. If no named arguments are needed, *kw* may be
   *NULL*. *args* must not be *NULL*, use an empty tuple if no
   arguments are needed. Returns the result of the call on success, or
   *NULL* on failure.  This is the equivalent of the Python expression
   "callable_object(*args, **kw)".

PyObject* PyObject_CallObject(PyObject *callable_object, PyObject *args)
    *Return value: New reference.*

   Call a callable Python object *callable_object*, with arguments
   given by the tuple *args*.  If no arguments are needed, then *args*
   may be *NULL*.  Returns the result of the call on success, or
   *NULL* on failure.  This is the equivalent of the Python expression
   "callable_object(*args)".

PyObject* PyObject_CallFunction(PyObject *callable, const char *format, ...)
    *Return value: New reference.*

   Call a callable Python object *callable*, with a variable number of
   C arguments. The C arguments are described using a
   "Py_BuildValue()" style format string.  The format may be *NULL*,
   indicating that no arguments are provided. Returns the result of
   the call on success, or *NULL* on failure.  This is the equivalent
   of the Python expression "callable(*args)". Note that if you only
   pass "PyObject *" args, "PyObject_CallFunctionObjArgs()" is a
   faster alternative.

   Modifié dans la version 3.4: The type of *format* was changed from
   "char *".

PyObject* PyObject_CallMethod(PyObject *o, const char *method, const char *format, ...)
    *Return value: New reference.*

   Call the method named *method* of object *o* with a variable number
   of C arguments.  The C arguments are described by a
   "Py_BuildValue()" format string that should  produce a tuple.  The
   format may be *NULL*, indicating that no arguments are provided.
   Returns the result of the call on success, or *NULL* on failure.
   This is the equivalent of the Python expression "o.method(args)".
   Note that if you only pass "PyObject *" args,
   "PyObject_CallMethodObjArgs()" is a faster alternative.

   Modifié dans la version 3.4: The types of *method* and *format*
   were changed from "char *".

PyObject* PyObject_CallFunctionObjArgs(PyObject *callable, ..., NULL)
    *Return value: New reference.*

   Call a callable Python object *callable*, with a variable number of
   "PyObject*" arguments.  The arguments are provided as a variable
   number of parameters followed by *NULL*. Returns the result of the
   call on success, or *NULL* on failure.

PyObject* PyObject_CallMethodObjArgs(PyObject *o, PyObject *name, ..., NULL)
    *Return value: New reference.*

   Calls a method of the object *o*, where the name of the method is
   given as a Python string object in *name*.  It is called with a
   variable number of "PyObject*" arguments.  The arguments are
   provided as a variable number of parameters followed by *NULL*.
   Returns the result of the call on success, or *NULL* on failure.

Py_hash_t PyObject_Hash(PyObject *o)

   Compute and return the hash value of an object *o*.  On failure,
   return "-1". This is the equivalent of the Python expression
   "hash(o)".

   Modifié dans la version 3.2: The return type is now Py_hash_t.
   This is a signed integer the same size as Py_ssize_t.

Py_hash_t PyObject_HashNotImplemented(PyObject *o)

   Set a "TypeError" indicating that "type(o)" is not hashable and
   return "-1". This function receives special treatment when stored
   in a "tp_hash" slot, allowing a type to explicitly indicate to the
   interpreter that it is not hashable.

int PyObject_IsTrue(PyObject *o)

   Returns "1" if the object *o* is considered to be true, and "0"
   otherwise. This is equivalent to the Python expression "not not o".
   On failure, return "-1".

int PyObject_Not(PyObject *o)

   Returns "0" if the object *o* is considered to be true, and "1"
   otherwise. This is equivalent to the Python expression "not o".  On
   failure, return "-1".

PyObject* PyObject_Type(PyObject *o)
    *Return value: New reference.*

   When *o* is non-*NULL*, returns a type object corresponding to the
   object type of object *o*. On failure, raises "SystemError" and
   returns *NULL*.  This is equivalent to the Python expression
   "type(o)". This function increments the reference count of the
   return value. There's really no reason to use this function instead
   of the common expression "o->ob_type", which returns a pointer of
   type "PyTypeObject*", except when the incremented reference count
   is needed.

int PyObject_TypeCheck(PyObject *o, PyTypeObject *type)

   Return true if the object *o* is of type *type* or a subtype of
   *type*.  Both parameters must be non-*NULL*.

Py_ssize_t PyObject_Size(PyObject *o)
Py_ssize_t PyObject_Length(PyObject *o)

   Return the length of object *o*.  If the object *o* provides either
   the sequence and mapping protocols, the sequence length is
   returned.  On error, "-1" is returned.  This is the equivalent to
   the Python expression "len(o)".

Py_ssize_t PyObject_LengthHint(PyObject *o, Py_ssize_t default)

   Return an estimated length for the object *o*. First try to return
   its actual length, then an estimate using "__length_hint__()", and
   finally return the default value. On error return "-1". This is the
   equivalent to the Python expression "operator.length_hint(o,
   default)".

   Nouveau dans la version 3.4.

PyObject* PyObject_GetItem(PyObject *o, PyObject *key)
    *Return value: New reference.*

   Return element of *o* corresponding to the object *key* or *NULL*
   on failure. This is the equivalent of the Python expression
   "o[key]".

int PyObject_SetItem(PyObject *o, PyObject *key, PyObject *v)

   Map the object *key* to the value *v*.  Raise an exception and
   return "-1" on failure; return "0" on success.  This is the
   equivalent of the Python statement "o[key] = v".

int PyObject_DelItem(PyObject *o, PyObject *key)

   Remove the mapping for the object *key* from the object *o*.
   Return "-1" on failure.  This is equivalent to the Python statement
   "del o[key]".

PyObject* PyObject_Dir(PyObject *o)
    *Return value: New reference.*

   This is equivalent to the Python expression "dir(o)", returning a
   (possibly empty) list of strings appropriate for the object
   argument, or *NULL* if there was an error.  If the argument is
   *NULL*, this is like the Python "dir()", returning the names of the
   current locals; in this case, if no execution frame is active then
   *NULL* is returned but "PyErr_Occurred()" will return false.

PyObject* PyObject_GetIter(PyObject *o)
    *Return value: New reference.*

   This is equivalent to the Python expression "iter(o)". It returns a
   new iterator for the object argument, or the object  itself if the
   object is already an iterator.  Raises "TypeError" and returns
   *NULL* if the object cannot be iterated.
