Python'da bir nesnenin tam sınıf adını edinin

Günlük amacıyla bir Python nesnesinin tam sınıf adını almak istiyorum. (Tamamen kalifiye olarak, paket ve modül adını içeren sınıf adını kastediyorum.)

Biliyorum x.__class__.__name__, ama paketi ve modülü almak için basit bir yöntem var mı?

Aşağıdaki program ile

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

ve olarak Bartanımlandı

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

çıktı

$ ./prog.py
foo.Bar

Verilen cevaplar iç içe sınıflarla ilgilenmez. Python 3.3'e ( PEP 3155 ) kadar mevcut olmasa da , gerçekten __qualname__sınıfı kullanmak istiyorsunuz . Sonunda (3.4? PEP 395 ), __qualname__modüllerin yeniden adlandırıldığı durumlarla (yani yeniden adlandırıldığında __main__) ilgilenmesi için de mevcut olacaktır .

Aradığı inspectgibi işlevlere sahip modülü kullanmayı düşünün 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'>

İşte Greg Bacon'un mükemmel cevabına dayanan, ancak birkaç ekstra kontrolle:

__module__olabilir None(dokümanlara göre) ve ayrıca strolabileceği gibi bir tür için __builtin__(günlüklerde veya herhangi bir şekilde görünmek istemeyebilirsiniz). Aşağıdaki her iki olasılığı da denetler:

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__

(Kontrol etmenin daha iyi bir yolu olabilir __builtin__. Yukarıdaki sadece str'nin her zaman kullanılabilir olmasına ve modülünün her zaman mevcut olmasına dayanır __builtin__)

Python3.7 için kullanıyorum:

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

Alma:

package.subpackage.ClassName

__module__ hile yapardı.

Deneyin:

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

Bu site__package__ Python 3.0 için işe yarayacağını önermektedir ; Ancak, verilen örnekler Python 2.5.2 konsolumda çalışmaz.

Bu bir hack ama 2.6'yı destekliyorum ve basit bir şeye ihtiyacım var:

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

'logging.handlers.MemoryHandler'

Bazı insanlar (örneğin https://stackoverflow.com/a/16763814/5766934 ) __qualname__bundan daha iyi olduğunu savunuyorlar __name__. İşte farkı gösteren bir örnek:

$ 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

Ayrıca, derlemeler için de düzgün çalışır:

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

Bu konunun ilgisi tam nitelikli isimler elde etmek olduğundan, burada aynı pakette bulunan ana modülle birlikte göreli ithalatlar kullanıldığında ortaya çıkan bir tuzak vardır. Örneğin, aşağıdaki modül kurulumu ile:

$ 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

Aynı modülü farklı şekilde içe aktarmanın sonucunu gösteren çıktı:

$ 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

Uğultu göreli yolu kullanarak çubuğu Baz.__module__içe aktardığında , çubuk yalnızca "baz" olarak görür , ancak tam adı kullanan ikinci içe aktarmada, çubuk "foo.baz" ile aynı görür.

Tam nitelikli isimleri bir yerlerde ısrar ediyorsanız, bu sınıflar için göreli ithalatlardan kaçınmak daha iyidir.

Buradaki cevapların hiçbiri benim için işe yaramadı. Benim durumumda, Python 2.7 kullanıyordum ve sadece yeni stil objectsınıflarıyla çalışacağımı biliyordum .

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