Question

出于记录目的，我想检索Python对象的完全限定类名。（完全限定，我的意思是类名，包括包和模块名。）

我知道x.__class__.__name__，但是有一个简单的方法来获取包和模块吗？

Answer 1

使用以下程序

#! /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)

和Bar定义为

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

输出

$ ./prog.py
foo.Bar

Answer 2

提供的答案不涉及嵌套类。虽然它在Python 3.3（PEP 3155）之前不可用，但你真的想要使用该类的__qualname__。最终（3.4？PEP 395），__qualname__也将存在模块，以处理重命名模块的情况（即重命名为__main__时）。

Answer 3

考虑使用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'>

Answer 4

这是基于格雷格·培根的优秀答案，但还有一些额外的检查：

__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__）

Answer 5

__module__可以解决问题。

尝试：

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

This site表明__package__可能适用于Python 3.0;但是，那里给出的示例在我的Python 2.5.2控制台下不起作用。

Answer 6

这是一个黑客，但我支持2.6，只需要一些简单的东西：

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

'logging.handlers.MemoryHandler'

Answer 7

由于本主题的目的是获得完全限定名称，因此在使用相对导入以及同一包中存在的主模块时会出现这种情况。例如，使用以下模块设置：

$ 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使用相对路径导入栏时，栏会将Baz.__module__视为“baz”，但在使用全名的第二个导入栏中，栏会看到与“foo.baz”相同的内容。

如果您在某处持有完全限定名称，最好避免对这些类进行相对导入。

Answer 8

有些人（例如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

注意，它也适用于buildins：

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

Answer 9

对于python3.7，我使用：

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

获取：

package.subpackage.ClassName

Answer 10

这是对 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

Answer 11

这里的答案都不适用于我。就我而言，我使用的是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

在Python中获取对象的完全限定类名

11 个答案: