Uzyskaj w pełni kwalifikowaną nazwę klasy obiektu w Pythonie

Podane odpowiedzi nie dotyczą klas zagnieżdżonych. Chociaż nie jest dostępny aż do Pythona 3.3 (PEP 3155), naprawdę chcesz użyć __qualname__ klasy. Ostatecznie (3.4? PEP 395), __qualname__ będzie również istnieć dla modułów, aby radzić sobie z przypadkami, w których moduł zostanie przemianowany (tzn. kiedy zostanie przemianowany na __main__).

Rozważ użycie modułu inspect, który ma funkcje takie jak getmodule, które mogą być tym, czego szukasz:

>>>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'>

Oto jedna na podstawie doskonałej odpowiedzi Grega Bacona, ale z kilkoma dodatkowymi czekami:

__module__ może to być None (zgodnie z dokumentami), a także dla typu str może to być __builtin__ (czego możesz nie chcieć pojawiać się w logach lub cokolwiek innego). Następujące kontrole dla obu tych możliwości:

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__

(może być lepszy sposób, aby sprawdzić __builtin__. Powyższe polega tylko na tym, że str jest zawsze dostępny, a jego moduł jest zawsze __builtin__)

__module__ wystarczy.

Try:

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

Ta strona sugeruje, że __package__ może działać dla Pythona 3.0; jednak podane tam przykłady nie będą działać pod moją konsolą Pythona 2.5.2.

To jest hack ale popieram 2.6 i po prostu potrzebuję czegoś prostego:

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

'logging.handlers.MemoryHandler'

Ponieważ interesem tego tematu jest uzyskanie w pełni kwalifikowanych nazw, oto pułapka, która pojawia się podczas używania względnych importów wraz z głównym modułem istniejącym w tym samym pakiecie. Np. z poniższą konfiguracją modułu:

$ 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

Oto wyjście pokazujące wynik importowania Tego samego modułu w inny sposób:

$ 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

Gdy Hum importuje pasek za pomocą ścieżki względnej, bar widzi {[2] } jako po prostu "baz", ale w drugim imporcie, który używa pełnej nazwy, bar widzi to samo co "foo.baz".

Jeśli utrzymujesz gdzieś w pełni kwalifikowane nazwy, lepiej unikać względnego importu dla tych klas.

Żadna z odpowiedzi nie zadziałała. W moim przypadku używałem Pythona 2.7 i wiedziałem, że będę pracował tylko z klasami newstyle object.

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

Niektórzy ludzie (np. https://stackoverflow.com/a/16763814/5766934 ) argumentując, że __qualname__ jest lepszy niż __name__. Oto przykład, który pokazuje różnicę:

$ 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

Uwaga, działa również poprawnie dla buildins:

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