Ottieni il nome della classe corrente?

Come ottengo il nome della classe in cui mi trovo attualmente?

Esempio:

def get_input(class_name):
    [do things]
    return class_name_result

class foo():
    input = get_input([class name goes here])

A causa della natura del programma con cui mi sto interfacciando (vistrails), non posso usare __init__() per inizializzare input.

obj.__class__.__name__ ti darà il nome di qualsiasi oggetto, quindi puoi farlo:

class Clazz():
    def getName(self):
        return self.__class__.__name__

Utilizzo:

>>> c = Clazz()
>>> c.getName()
'Clazz'

All'interno del corpo di una classe, il nome della classe non è ancora definito, quindi non è disponibile. Non puoi semplicemente digitare il nome della classe? Forse hai bisogno di dire di più sul problema in modo che possiamo trovare una soluzione per te.

Creerei una metaclasse per fare questo lavoro per te. Viene invocato al momento della creazione della classe (concettualmente alla fine della classe: blocco) e può manipolare la classe che viene creata. Non l'ho provato:

class InputAssigningMetaclass(type):
    def __new__(cls, name, bases, attrs):
        cls.input = get_input(name)
        return super(MyType, cls).__new__(cls, name, bases, newattrs)

class MyBaseFoo(object):
    __metaclass__ = InputAssigningMetaclass

class foo(MyBaseFoo):
    # etc, no need to create 'input'

class foo2(MyBaseFoo):
    # etc, no need to create 'input'

Puoi accedervi dagli attributi privati ​​della classe:

cls_name = self.__class__.__name__

MODIFICARE:

Come detto da Ned Batcheler, questo non funzionerebbe nel corpo della classe, ma funzionerebbe in un metodo.

Introdotto PEP 3155__qualname__ , implementato in Python 3.3.

Per le funzioni e le classi di primo livello, l' __qualname__attributo è uguale __name__all'attributo. Per classi, metodi e funzioni annidate, l' __qualname__attributo contiene un percorso punteggiato che conduce all'oggetto dal livello superiore del modulo.

È accessibile dall'interno della definizione stessa di una classe o di una funzione, quindi ad esempio:

class Foo:
    print(__qualname__)

stamperà efficacemente Foo. Otterrai il nome completo (escluso il nome del modulo), quindi potresti volerlo dividere sul .personaggio.

Tuttavia, non è possibile ottenere un handle effettivo sulla classe in fase di definizione.

>>> class Foo:
...     print('Foo' in globals())
... 
False

EDIT: Sì, puoi; ma devi imbrogliare: il nome della classe attualmente in esecuzione è presente nello stack di chiamate e il tracebackmodulo ti consente di accedere allo stack.

>>> import traceback
>>> def get_input(class_name):
...     return class_name.encode('rot13')
... 
>>> class foo(object):
...      _name = traceback.extract_stack()[-1][2]
...     input = get_input(_name)
... 
>>> 
>>> foo.input
'sbb'

Tuttavia, non lo farei; La mia risposta originale è ancora la mia preferenza come soluzione. Risposta originale:

probabilmente la soluzione più semplice è usare un decoratore, che è simile alla risposta di Ned che coinvolge le metaclassi, ma meno potente (i decoratori sono capaci di magia nera, ma le metaclassi sono capaci di magia nera antica e occulta )

>>> def get_input(class_name):
...     return class_name.encode('rot13')
... 
>>> def inputize(cls):
...     cls.input = get_input(cls.__name__)
...     return cls
... 
>>> @inputize
... class foo(object):
...     pass
... 
>>> foo.input
'sbb'
>>> 

import sys

def class_meta(frame):
    class_context = '__module__' in frame.f_locals
    assert class_context, 'Frame is not a class context'

    module_name = frame.f_locals['__module__']
    class_name = frame.f_code.co_name
    return module_name, class_name

def print_class_path():
    print('%s.%s' % class_meta(sys._getframe(1)))

class MyClass(object):
    print_class_path()

Penso che dovrebbe essere così:

    class foo():
        input = get_input(__qualname__)