Obter nome de classe totalmente qualificado de um objeto em Python
-
19-09-2019 - |
Pergunta
Para fins de registro Quero recuperar o nome de classe totalmente qualificado de um objeto Python. (Com totalmente qualificado quero dizer o nome da classe, incluindo o pacote e nome do módulo.)
Eu sei sobre x.__class__.__name__
, mas existe um método simples para obter o pacote e módulo?
Solução
Com o seguinte programa
#! /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)
e Bar
definido como
class Bar(object):
def __init__(self, v=42):
self.val = v
a saída é
$ ./prog.py
foo.Bar
Outras dicas
As respostas fornecidas não lidar com classes aninhadas. Embora não seja disponível até Python 3.3 ( PEP 3155 ), você realmente quer usar __qualname__
da classe. Eventualmente (3,4? PEP 395 ), __qualname__
também vai existir para os módulos para lidar com casos em que o módulo é renomeado (ou seja, quando ele é renomeado para __main__
).
Considere o uso do módulo inspect
que tem funções como getmodule
que pode ser o que estão procurando:
>>>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'>
Aqui está uma baseada em excelente resposta de Greg Bacon, mas com um par de verificações extras:
__module__
pode ser None
(de acordo com os docs), e também para um tipo como str
pode ser __builtin__
(que você não pode querer aparecer em toras ou qualquer outro). As seguintes verificações para essas duas possibilidades:
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__
(Pode haver uma maneira melhor para verificar se há __builtin__
. O acima apenas se baseia no fato de que str está sempre disponível, e seu módulo é sempre __builtin__
)
__module__
faria o truque.
Tente:
>>> import re
>>> print re.compile.__module__
re
Este site sugere que o trabalho __package__
força para Python 3.0; No entanto, os exemplos dados lá não vai funcionar sob a minha consola de Python 2.5.2.
Este é um hack, mas eu estou apoiando 2.6 e só precisa de algo simples:
>>> from logging.handlers import MemoryHandler as MH
>>> str(MH).split("'")[1]
'logging.handlers.MemoryHandler'
Algumas pessoas (por exemplo https://stackoverflow.com/a/16763814/5766934 ) argumentando que __qualname__
é melhor que __name__
.
Aqui está um exemplo que mostra a diferença:
$ 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
Note, ele também funciona corretamente para buildins:
>>> print(full_name_with_qualname(print))
builtins.print
>>> import builtins
>>> builtins.print
<built-in function print>
Para uso python3.7 I:
".".join([obj.__module__, obj.__name__])
Introdução:
package.subpackage.ClassName
Uma vez que o interesse deste tópico é obter nomes totalmente qualificados, aqui é uma armadilha que ocorre quando usando importações relativos juntamente com o módulo principal existente no mesmo pacote. Por exemplo, com o abaixo configuração do módulo:
$ 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
Aqui está a saída mostrando o resultado da importação do mesmo módulo diferente:
$ 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
Quando as importações hum bar usando caminho relativo, bar vê Baz.__module__
apenas como "baz", mas na segunda importação, que usa o nome completo, bar vê o mesmo que "foo.baz".
Se você está persistindo os nomes totalmente qualificado em algum lugar, é melhor evitar importações relativos para essas classes.
Nenhuma das respostas aqui funcionou para mim. No meu caso, eu estava usando Python 2.7 e sabia que eu só estaria trabalhando com aulas object
newstyle.
def get_qualified_python_name_from_class(model):
c = model.__class__.__mro__[0]
name = c.__module__ + "." + c.__name__
return name