Python: Comment faire pour récupérer des informations de classe à partir d'un cadre d'objet?

Je ne crois pas que, au niveau de l'image au niveau de l'objet, il y a moyen de trouver la réelle fonction python objet qui a été appelé.

Toutefois, si votre code s'appuyer sur la commune de la convention : nom de l'instance paramètre d'une méthode self, alors vous pouvez faire ce qui suit :

def get_class_from_frame(fr):
  import inspect
  args, _, _, value_dict = inspect.getargvalues(fr)
  # we check the first parameter for the frame function is
  # named 'self'
  if len(args) and args[0] == 'self':
    # in that case, 'self' will be referenced in value_dict
    instance = value_dict.get('self', None)
    if instance:
      # return its class
      return getattr(instance, '__class__', None)
  # return None otherwise
  return None

Si vous ne souhaitez pas utiliser getargvalues, vous pouvez utiliser directement frame.f_locals au lieu de value_dict et frame.f_code.co_varnames[:frame.f_code.co_argcount] au lieu de args.

Garder à l'esprit que ce n'est encore qu'en s'appuyant sur la convention, de sorte qu'il n'est pas portable, et sujettes à l'erreur:

• si une non-méthode de la fonction de l'utilisation self comme premier paramètre le nom, puis get_class_from_frame sera, à tort, de retour de la classe du premier paramètre.
• il peut induire en erreur, lorsque l'on travaille avec des descripteurs (ce sera le retour de la classe de descripteur, pas de la véritable instance en cours d'accès).
• @classmethod et @staticmethod ne vais pas prendre un self paramètre et sont mis en œuvre avec des descripteurs.
• et sûrement beaucoup plus

Selon ce exactement que vous voulez faire, vous pouvez prendre le temps de creuser plus profondément et de trouver des solutions de contournement pour toutes ces questions (vous pouvez cocher la fonction d'encadrement existent dans le retour de la classe et de partager la même source, la détection de descripteur d'appels est possible, même pour les méthodes de classe, etc..)

Je viens de tomber sur ce post que j'ai été confrontée au même problème. Je ne considère pas le " moi " méthode une solution acceptable, cependant, pour toutes les raisons déjà énumérées.

Le code suivant montre une approche différente: étant donné une image de l'objet de la recherche dans le globals pour un objet avec une correspondance de nom de membre et un bloc de code. La recherche n'est guère exhaustive de sorte qu'il est possible que toutes les classes seront découverts, mais ce que les classes sont trouvés devraient être ceux qui nous cherchent parce que nous avons vérifier la correspondance des codes.

Objet du code est de faire précéder le nom d'une fonction avec son nom de la classe, si trouvé:

def get_name( frame ):
  code = frame.f_code
  name = code.co_name
  for objname, obj in frame.f_globals.iteritems():
    try:
      assert obj.__dict__[name].func_code is code
    except Exception:
      pass
    else: # obj is the class that defines our method
      name = '%s.%s' % ( objname, name )
      break
  return name

Notez l'utilisation de __dict__ au lieu de getattr pour éviter d'attraper des classes dérivées.

Note en outre que la recherche peut être évité si self = frame.f_locals['self']; obj = self.__class__ donne un match, ou tout obj in self.__class__.__bases__ ou plus profond, donc il y a certainement place pour l'optimisation /hybridation.