Ottiene il nome completo della classe di un oggetto in Python

Question

Per gli scopi di registrazione voglio recuperare il nome completo della classe di un oggetto Python. (Con completo intendo il nome della classe tra cui il pacchetto e nome del modulo.)

So di x.__class__.__name__, ma c'è un metodo semplice per ottenere il pacchetto e il modulo?

Answer 1

Con il seguente programma

#! /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 definito come

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

l'uscita è

$ ./prog.py
foo.Bar

Answer 2

Le risposte fornite non si occupano di classi nidificate. Anche se non è disponibile fino a Python 3.3 ( PEP 3155 ), davvero si vuole utilizzare __qualname__ della classe. Casualmente (3.4? PEP 395 ), __qualname__ esisterà anche per i moduli da affrontare i casi in cui viene rinominato il modulo (cioè quando viene rinominato __main__).

Answer 3

Si consiglia di utilizzare il modulo inspect che ha funzioni come getmodule che potrebbe essere quello che sono alla ricerca di:

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

Ecco uno basato sulla risposta eccellente di Greg Bacon, ma con un paio di controlli aggiuntivi:

__module__ può essere None (secondo la documentazione), e anche per un tipo come str può essere __builtin__ (che si potrebbe non voler apparire in tronchi o qualsiasi altra cosa). I seguenti controlli per entrambe queste possibilità:

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__

(Ci potrebbe essere un modo migliore per verificare la presenza di __builtin__. È possibile che questo si basa semplicemente sul fatto che str è sempre disponibile, e il suo modulo è sempre __builtin__)

Answer 5

__module__ farebbe il trucco.

Prova:

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

Questo sito suggerisce che __package__ potrebbe funzionare per Python 3.0; Tuttavia, gli esempi forniti lì non funzioneranno sotto la mia console Python 2.5.2.

Answer 6

Questo è un hack, ma io sto sostenendo 2.6 e solo bisogno di qualcosa di semplice:

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

'logging.handlers.MemoryHandler'

Answer 7

Alcune persone (ad esempio https://stackoverflow.com/a/16763814/5766934 ), sostenendo che è meglio __qualname__ di __name__. Ecco un esempio che mostra la differenza:

$ 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

Nota, funziona anche correttamente per buildins:

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

Answer 8

Per python3.7 che uso:

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

Come:

package.subpackage.ClassName

Answer 9

Dal momento che l'interesse di questo argomento è quello di ottenere nomi completi, ecco un trabocchetto che si verifica quando si utilizzano le importazioni relative insieme al modulo principale esistente nella stessa confezione. Per esempio, con la messa a punto del modulo qui sotto:

$ 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

Ecco l'output che mostra il risultato di importare lo stesso modulo diverso:

$ 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 le importazioni di ronzio a barre utilizzando percorso relativo, bar vede Baz.__module__ semplicemente come "Baz", ma nel secondo di importazione che utilizza il nome completo, bar vede lo stesso di "foo.baz".

Se state le persistenti nomi pienamente qualificati da qualche parte, è meglio evitare le importazioni relative a tali classi.

Answer 10

Nessuna delle risposte qui funzionato per me. Nel mio caso, ero con Python 2.7 e sapevo che avrei lavorato solo con le classi object newstyle.

def get_qualified_python_name_from_class(model):
    c = model.__class__.__mro__[0]
    name = c.__module__ + "." + c.__name__
    return name