Obter o nome completo da classe de um objeto em Python


136

Para fins de registro, quero recuperar o nome completo da classe de um objeto Python. (Com totalmente qualificado, quero dizer o nome da classe, incluindo o nome do pacote e do módulo.)

Eu sei x.__class__.__name__, mas existe um método simples para obter o pacote e o módulo?

Respostas:


147

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 Bardefinido como

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

a saída é

$ ./prog.py
foo.Bar

2
Isso parece retornar o módulo onde a barra foi definida, não onde a barra foi definida. Se o objetivo do registro é saber exatamente que tipo de objeto era, isso não parece ajudar.
Mark E. Haase

Alguma o.__class__.__module__vez é diferente o.__module__?
larsks


1
Eu recomendo fortemente ".".join([o.__module__, o.__name__])para Python3
Piotr Pęczek

Às vezes não funciona:AttributeError: 'AttributeError' object has no attribute '__module__'
Hendy Irawan

38

As respostas fornecidas não lidam com classes aninhadas. Embora não esteja disponível até o Python 3.3 ( PEP 3155 ), você realmente deseja usar __qualname__a classe. Eventualmente (3,4? PEP 395 ), __qualname__também existirá módulos para lidar com casos em que o módulo é renomeado (ou seja, quando é renomeado para __main__).


3
Se você usar github.com/wbolster/qualname, poderá obter um equivalente de qualname em versões mais antigas.
Wouter bolsterlee

3
Ou seja Type.__module__ + '.' + Type.__qualname__.
Kentzo

4
Com o Python 3.6, isso só me dá o nome da classe. Não inclui o módulo.
Jpmc26

2
@ jpmc26 Em Python 3.7, __qualname__ainda só resolve para o nome da classe
zepp.lee

22

Considere usar o inspectmódulo que possui funções como as getmoduleque podem estar 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'>

7
inspect.getmodule()retorna objetos do módulo - nomes de classes não totalmente qualificados. De fato, o inspectmódulo não fornece nenhuma funcionalidade que realmente resolva essa questão. Esta resposta é uma não resposta. </facepalm>
Cecil Curry

19

Aqui está um baseado na excelente resposta de Greg Bacon, mas com algumas verificações extras:

__module__pode ser None(de acordo com a documentação) e também para um tipo como strele pode ser __builtin__(que talvez você não queira que apareça nos logs ou seja o que for). O seguinte verifica 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 de verificar __builtin__. O exemplo acima depende apenas do fato de que str está sempre disponível e seu módulo está sempre __builtin__)


1
Para poupar aos outros o esforço de comparar as duas respostas: o código na resposta de Greg Bacon agora é idêntico ao código desta, exceto que Greg adicionou uma declaração inútil e alguns comentários de código. MB é o verdadeiro herói.
MarredCheese 22/09/19

11

Para python3.7 eu uso:

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

Obtendo:

package.subpackage.ClassName

observe que objdeve ser uma classe e não uma instância de objeto.
Ivan De Paz Centeno

9

__module__ faria o truque.

Experimentar:

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

Este site sugere que __package__pode funcionar no Python 3.0; No entanto, os exemplos dados aqui não funcionarão no meu console Python 2.5.2.


6
Isso faz o truque, obrigado! Para o nome completo, usarei # "%s.%s" % (x.__class__.__module__, x.__class__.__name__)
Hanno S.

7

Este é um truque, mas estou suportando o 2.6 e só preciso de algo simples:

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

'logging.handlers.MemoryHandler'

1
Isso depende da __repr__()implementação na classe marcada ( e de __str__()não ser substituída). Inútil na maioria dos casos.
Z33k

7

Algumas pessoas (por exemplo, https://stackoverflow.com/a/16763814/5766934 ) argumentam que isso __qualname__é melhor do 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

Observe que também funciona corretamente para buildins:

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

2

Como o interesse deste tópico é obter nomes totalmente qualificados, aqui está uma armadilha que ocorre ao usar importações relativas junto com o módulo principal existente no mesmo pacote. Por exemplo, com a configuração do módulo abaixo:

$ 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 que mostra o resultado da importação do mesmo módulo de maneira 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 hum importa bar usando o caminho relativo, bar vê Baz.__module__apenas "baz", mas na segunda importação que usa o nome completo, bar vê o mesmo que "foo.baz".

Se você persistir com os nomes totalmente qualificados em algum lugar, é melhor evitar importações relativas para essas classes.


0

Nenhuma das respostas aqui funcionou para mim. No meu caso, eu estava usando o Python 2.7 e sabia que só estaria trabalhando com objectclasses newstyle .

def get_qualified_python_name_from_class(model):
    c = model.__class__.__mro__[0]
    name = c.__module__ + "." + c.__name__
    return name
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.