【发布时间】：2011-01-02 11:07:59
【问题描述】：
出于记录目的，我想检索 Python 对象的完全限定类名。 （完全限定的意思是类名，包括包名和模块名。）
我知道x.__class__.__name__，但是有没有简单的方法来获取包和模块？
【问题讨论】：
【发布时间】：2011-01-02 11:07:59
【问题描述】：
使用以下程序
#!/usr/bin/env python
import foo
def fullname(o):
klass = o.__class__
module = klass.__module__
if module == 'builtins':
return klass.__qualname__ # avoid outputs like 'builtins.str'
return module + '.' + klass.__qualname__
bar = foo.Bar()
print(fullname(bar))
和Bar定义为
class Bar(object):
def __init__(self, v=42):
self.val = v
输出是
$ ./prog.py
foo.Bar
如果您仍然停留在 Python 2 上，则必须使用 __name__ 而不是 __qualname__，这对于嵌套类的信息量较少 - 嵌套在类 Foo 中的类 Bar 将显示升级为Bar 而不是Foo.Bar：
def fullname(o):
klass = o.__class__
module = klass.__module__
if module == '__builtin__':
return klass.__name__ # avoid outputs like '__builtin__.str'
return module + '.' + klass.__name__
【讨论】：
-
这似乎返回了定义 bar 的模块，而不是定义了 Bar 的模块。如果记录的目的是确切地知道它是什么类型的对象，那么这似乎没有帮助。
-
o.__class__.__module__是否与o.__module__不同？ -
larsks：是的，stackoverflow.com/questions/5271112/…
-
我强烈推荐
".".join([o.__module__, o.__name__])使用 Python3 -
有时不起作用：
AttributeError: 'AttributeError' object has no attribute '__module__'
提供的答案不涉及嵌套类。尽管它在 Python 3.3 (PEP 3155) 之前才可用，但您确实希望使用该类的 __qualname__ 而不是 __name__。否则，像
class Foo:
class Bar: # this one
pass
将显示为 Bar 而不是 Foo.Bar。
（您仍然需要将 __module__ 单独附加到 qualname - __qualname__ 不打算包含模块名称。）
【讨论】：
-
如果你使用github.com/wbolster/qualname，你可以在旧版本上获得一个等效的qualname。
-
即
Type.__module__ + '.' + Type.__qualname__. -
对于 Python 3.6，这只给了我类名。它不包括模块。
-
@jpmc26 在 Python 3.7 中，
__qualname__仍然只解析为类名
这是基于 Greg Bacon 的出色答案的一个，但有一些额外的检查：
__module__ 可以是 None（根据文档），对于像 str 这样的类型，它可以是 __builtin__（您可能不希望出现在日志或其他内容中）。以下检查这两种可能性：
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__
（可能有更好的方法来检查__builtin__。上面只是依赖于str总是可用的事实，它的模块总是__builtin__）
【讨论】：
-
为了节省其他人比较两个答案的工作量：Greg Bacon 答案中的代码现在与这个答案中的代码相同，除了 Greg 添加了一个毫无意义的 else 语句和一些代码 cmets。 MB 是真正的英雄。
-
str.__class__.__module__计算结果为'builtins'，那么if module is None or module == 'builtins'会有什么问题吗？ -
文档说
__module__可以是None对于函数，但是对于类，如果 Python 在创建类型时无法确定模块，__module__属性根本不存在——如果你尝试访问它，你会得到一个 AttributeError 。__module__也可以手动设置为任意对象。 -
检查
module is None因此不会增加任何有意义的安全性。处理AttributeError并检查类型会更有用，但仍然不太重要。 -
另外，如果你对
__module__偏执，你必须对__class__也同样偏执，这实际上并不能保证是一个对象的类。它甚至可能根本不是一个类，例如，如果一个类有一个__getattribute__覆盖而不是特殊情况__class__。
考虑使用inspect 模块，该模块具有getmodule 之类的功能，这可能是我们正在寻找的：
>>>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'>
【讨论】：
-
inspect.getmodule()返回模块对象——不是完全限定的类名。事实上，inspect模块没有提供任何实际功能解决这个问题。这个答案是非答案。</facepalm>
对于python3.7，我使用：
".".join([obj.__module__, obj.__name__])
获取：
package.subpackage.ClassName
【讨论】：
-
注意
obj必须是一个类而不是一个对象实例。
__module__ 可以解决问题。
试试：
>>> import re
>>> print re.compile.__module__
re
This site 建议__package__ 可能适用于 Python 3.0；但是，那里给出的示例无法在我的 Python 2.5.2 控制台下运行。
【讨论】：
-
这就是诀窍，谢谢！对于完全限定名称，我将使用
"%s.%s" % (x.__class__.__module__, x.__class__.__name__)
有些人（例如https://stackoverflow.com/a/16763814/5766934）认为__qualname__ 比__name__ 更好。
这是一个显示差异的示例：
$ 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
注意，它也适用于内置函数：
>>> print(full_name_with_qualname(print))
builtins.print
>>> import builtins
>>> builtins.print
<built-in function print>
【讨论】：
这是一个 hack，但我支持 2.6，只需要一些简单的东西：
>>> from logging.handlers import MemoryHandler as MH
>>> str(MH).split("'")[1]
'logging.handlers.MemoryHandler'
【讨论】：
-
这取决于检查类中的
__repr__()实现（和__str__()未被覆盖）。在大多数情况下无用。
由于本主题的兴趣是获取完全限定名称，因此在使用相对导入以及存在于同一包中的主模块时会出现一个陷阱。例如，使用以下模块设置：
$ 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
这是显示不同导入相同模块的结果的输出：
$ 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
当 hum 使用相对路径导入 bar 时，bar 将 Baz.__module__ 视为“baz”，但在使用全名的第二次导入中，bar 将视为“foo.baz”。
如果您在某处保留完全限定名称，最好避免这些类的相对导入。
【讨论】：
这是对Greg Bacon 和MB 答案的改编，以使用限定的类名。请注意，该问题确实要求提供合格的类名。它已使用 Python 3.8 进行了测试。
def fullname(obj: object) -> str:
"""Return the full name of the given object using its module and qualified class names."""
# Ref: https://stackoverflow.com/a/66508248/
module_name, class_name = obj.__class__.__module__, obj.__class__.__qualname__
if module_name in (None, str.__class__.__module__):
return class_name
return module_name + "." + class_name
【讨论】：
这里没有一个答案对我有用。就我而言，我使用的是 Python 2.7，并且知道我只会使用 newstyle object 类。
def get_qualified_python_name_from_class(model):
c = model.__class__.__mro__[0]
name = c.__module__ + "." + c.__name__
return name
【讨论】：
Bellow 只是对 Greg Bacon 答案的改进，针对内置和用户定义的类、实例、方法、函数进行了测试。
def fullname(o):
try:
# if o is a class or function, get module directly
module = o.__module__
except AttributeError:
# then get module from o's class
module = o.__class__.__module__
try:
# if o is a class or function, get name directly
name = o.__qualname__
except AttributeError:
# then get o's class name
name = o.__class__.__qualname__
# if o is a method of builtin class, then module will be None
if module == 'builtins' or module is None:
return name
return module + '.' + name
【讨论】：