Ruft den vollständig qualifizierten Klassennamen eines Objekts in Python ab

Zu Protokollierungszwecken möchte ich den vollständig qualifizierten Klassennamen eines Python-Objekts abrufen. (Mit voll qualifiziert meine ich den Klassennamen einschließlich des Paket- und Modulnamens.)

Ich weiß Bescheid x.__class__.__name__, aber gibt es eine einfache Methode, um das Paket und das Modul zu erhalten?

Mit dem folgenden Programm

#! /usr/bin/env python

import foo

def fullname(o):
  # o.__module__ + "." + o.__class__.__qualname__ is an example in
  # this context of H.L. Mencken's "neat, plausible, and wrong."
  # Python makes no guarantees as to whether the __module__ special
  # attribute is defined, so we take a more circumspect approach.
  # Alas, the module name is explicitly excluded from __qualname__
  # in Python 3.

  module = o.__class__.__module__
  if module is None or module == str.__class__.__module__:
    return o.__class__.__name__  # Avoid reporting __builtin__
  else:
    return module + '.' + o.__class__.__name__

bar = foo.Bar()
print fullname(bar)

und Bardefiniert als

class Bar(object):
  def __init__(self, v=42):
    self.val = v

die Ausgabe ist

$ ./prog.py
foo.Bar

Die angegebenen Antworten beziehen sich nicht auf verschachtelte Klassen. Obwohl es erst in Python 3.3 ( PEP 3155 ) verfügbar ist , möchten Sie __qualname__die Klasse wirklich verwenden . Eventuell (3.4? PEP 395 ) __qualname__wird es auch für Module geben, um Fälle zu behandeln, in denen das Modul umbenannt wird (dh wenn es umbenannt wird __main__).

Erwägen Sie die Verwendung eines inspectModuls mit Funktionen, nach getmoduledenen möglicherweise gesucht wird:

>>>import inspect
>>>import xml.etree.ElementTree
>>>et = xml.etree.ElementTree.ElementTree()
>>>inspect.getmodule(et)
<module 'xml.etree.ElementTree' from 
        'D:\tools\python2.5.2\lib\xml\etree\ElementTree.pyc'>

Hier ist eine, die auf Greg Bacons ausgezeichneter Antwort basiert, aber mit ein paar zusätzlichen Überprüfungen:

__module__kann sein None(laut den Dokumenten), und auch für einen Typ wie stres sein kann __builtin__(den Sie möglicherweise nicht in Protokollen oder was auch immer erscheinen möchten). Die folgenden Überprüfungen für beide Möglichkeiten:

def fullname(o):
    module = o.__class__.__module__
    if module is None or module == str.__class__.__module__:
        return o.__class__.__name__
    return module + '.' + o.__class__.__name__

(Es gibt möglicherweise eine bessere Möglichkeit, dies zu überprüfen __builtin__. Das oben Gesagte beruht lediglich auf der Tatsache, dass str immer verfügbar ist und sein Modul immer verfügbar ist. __builtin__)

Für Python3.7 verwende ich:

".".join([obj.__module__, obj.__name__])

Bekommen:

package.subpackage.ClassName

__module__ würde den Trick machen.

Versuchen:

>>> import re
>>> print re.compile.__module__
re

Diese Site schlägt vor, dass dies __package__für Python 3.0 funktionieren könnte. Die dort angegebenen Beispiele funktionieren jedoch nicht unter meiner Python 2.5.2-Konsole.

Dies ist ein Hack, aber ich unterstütze 2.6 und brauche nur etwas Einfaches:

>>> from logging.handlers import MemoryHandler as MH
>>> str(MH).split("'")[1]

'logging.handlers.MemoryHandler'

Einige Leute (z. B. https://stackoverflow.com/a/16763814/5766934 ) argumentieren, dass dies __qualname__besser ist als __name__. Hier ist ein Beispiel, das den Unterschied zeigt:

$ cat dummy.py 
class One:
    class Two:
        pass

$ python3.6
>>> import dummy
>>> print(dummy.One)
<class 'dummy.One'>
>>> print(dummy.One.Two)
<class 'dummy.One.Two'>
>>> def full_name_with_name(klass):
...     return f'{klass.__module__}.{klass.__name__}'
>>> def full_name_with_qualname(klass):
...     return f'{klass.__module__}.{klass.__qualname__}'
>>> print(full_name_with_name(dummy.One))  # Correct
dummy.One
>>> print(full_name_with_name(dummy.One.Two))  # Wrong
dummy.Two
>>> print(full_name_with_qualname(dummy.One))  # Correct
dummy.One
>>> print(full_name_with_qualname(dummy.One.Two))  # Correct
dummy.One.Two

Beachten Sie, dass es auch für Buildins korrekt funktioniert:

>>> print(full_name_with_qualname(print))
builtins.print
>>> import builtins
>>> builtins.print
<built-in function print>

Da das Interesse dieses Themas darin besteht, vollständig qualifizierte Namen zu erhalten, tritt hier eine Gefahr auf, wenn relative Importe zusammen mit dem im selben Paket vorhandenen Hauptmodul verwendet werden. ZB mit dem folgenden Modul-Setup:

$ cat /tmp/fqname/foo/__init__.py
$ cat /tmp/fqname/foo/bar.py
from baz import Baz
print Baz.__module__
$ cat /tmp/fqname/foo/baz.py
class Baz: pass
$ cat /tmp/fqname/main.py
import foo.bar
from foo.baz import Baz
print Baz.__module__
$ cat /tmp/fqname/foo/hum.py
import bar
import foo.bar

Hier ist die Ausgabe, die das Ergebnis des unterschiedlichen Imports desselben Moduls zeigt:

$ export PYTHONPATH=/tmp/fqname
$ python /tmp/fqname/main.py
foo.baz
foo.baz
$ python /tmp/fqname/foo/bar.py
baz
$ python /tmp/fqname/foo/hum.py
baz
foo.baz

Wenn Brummen Balken unter Verwendung des relativen Pfads importiert, sieht Balken Baz.__module__nur "baz", aber beim zweiten Import, der den vollständigen Namen verwendet, sieht Balken dasselbe wie "foo.baz".

Wenn Sie die vollständig qualifizierten Namen irgendwo beibehalten, ist es besser, relative Importe für diese Klassen zu vermeiden.

Keine der Antworten hier hat bei mir funktioniert. In meinem Fall verwendete ich Python 2.7 und wusste, dass ich nur mit Newstyle- objectKlassen arbeiten würde.

def get_qualified_python_name_from_class(model):
    c = model.__class__.__mro__[0]
    name = c.__module__ + "." + c.__name__
    return name