Получить полное имя класса объекта в Python

136

В целях ведения журнала я хочу получить полное имя класса объекта Python. (Под полной квалификацией я подразумеваю имя класса, включая имя пакета и модуля.)

Я знаю о x.__class__.__name__, но есть ли простой способ получить пакет и модуль?

Ханно С.
источник

Ответы:

147

Со следующей программой

#! /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
Грег Бэкон
источник
2
Похоже, что это возвращает модуль, где был определен бар, а не где был определен Бар Если цель регистрации состоит в том, чтобы точно знать, что это был за объект, то это, похоже, не поможет.
Марк Э. Хаас
Отличается ли o.__class__.__module__когда-нибудь от o.__module__?
Жаворонки
2
Жаворонки: да, это так, stackoverflow.com/questions/5271112/…
Ярослав Булатов
1
Я настоятельно рекомендую ".".join([o.__module__, o.__name__])для Python3
Петр Pęczek
Иногда не работает:AttributeError: 'AttributeError' object has no attribute '__module__'
Хенди Ираван
38

Приведенные ответы не относятся к вложенным классам. Хотя он недоступен до Python 3.3 ( PEP 3155 ), вы действительно хотите использовать __qualname__этот класс. В конце концов (3.4 - PEP 395 ) __qualname__также будет существовать для модулей, чтобы иметь дело со случаями, когда модуль переименовывается (т.е. когда он переименовывается __main__).

Натан Бинкерт
источник
3
Если вы используете github.com/wbolster/qualname вы можете получить qualname эквивалент на более старых версиях.
wouter bolsterlee
3
То есть Type.__module__ + '.' + Type.__qualname__.
Кензо
4
В Python 3.6 это только дает мне имя класса. Он не включает модуль.
jpmc26
2
@ jpmc26 В Python 3.7 __qualname__все еще разрешается только имя класса
zepp.lee
22

Подумайте об использовании 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'>
Тендай Мавуше
источник
7
inspect.getmodule()возвращает объекты модуля - не полностью определенные имена классов. На самом деле, inspectмодуль не предоставляет никакой функциональности, которая бы фактически решала этот вопрос. Этот ответ не является ответом. </facepalm>
Сесил Карри
19

Вот один из них, основанный на превосходном ответе Грега Бэкона, но с парой дополнительных проверок:

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

MB.
источник
2
Чтобы избавить других от необходимости сравнивать два ответа: код в ответе Грега Бэкона теперь идентичен коду в этом, кроме того, что Грег добавил бессмысленное выражение else и некоторые комментарии к коду. МБ настоящий герой.
MarredCheese
11

Для python3.7 я использую:

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

Получение:

package.subpackage.ClassName
Присакари Дмитрий
источник
обратите внимание, что это objдолжен быть класс, а не экземпляр объекта.
Иван Де Пас Сентено
9

__module__ сделал бы трюк.

Пытаться:

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

Этот сайт предполагает, что __package__может работать для Python 3.0; Однако приведенные там примеры не будут работать под моей консолью Python 2.5.2.

Адам Матан
источник
6
Это делает трюк, спасибо! Для полного имени я буду использовать "%s.%s" % (x.__class__.__module__, x.__class__.__name__)
Hanno S.
7

Это хак, но я поддерживаю 2.6 и просто нужно что-то простое:

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

'logging.handlers.MemoryHandler'
Гринго Суаве
источник
1
Это зависит от __repr__()реализации в проверенном классе ( и от того, чтобы __str__()не быть переопределенным). Бесполезно в большинстве случаев.
z33k
7

Некоторые люди (например, 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>
Кристоф Боддекер
источник
2

Поскольку интерес этой темы состоит в том, чтобы получить полные имена, вот ловушка, которая возникает при использовании относительного импорта вместе с основным модулем, существующим в том же пакете. Например, с настройкой модуля ниже:

$ 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».

Если вы где-то сохраняете полные имена, лучше избегать относительного импорта для этих классов.

haridsv
источник
0

Ни один из ответов здесь не работал для меня. В моем случае я использовал Python 2.7 и знал, что буду работать только с objectклассами нового стиля .

def get_qualified_python_name_from_class(model):
    c = model.__class__.__mro__[0]
    name = c.__module__ + "." + c.__name__
    return name
П. Майер Нор
источник