python: comment faire référence à la classe de l'intérieur ( comme le fait la fonction récursive)

Pour une fonction récursive, on peut faire:

def f(i):
  if i<0: return
  print i
  f(i-1)

f(10)

Cependant est-il un moyen de faire la chose suivante?

class A:
  # do something
  some_func(A)
  # ...

Pas clair ce que vous voulez ou que la moyenne. class A: ne crée pas un objet, donc il n'y a pas de A de référence. Voir les solutions présentées pour les choses que tu peux dire...
catégorie: crée un objet de classe que les classes en python sont de première classe

OriginalL'auteur KL. | 2010-01-09

class python

17

En Python que vous ne peut pas faire référence à la classe dans le corps de la classe, bien que dans des langages comme Ruby, vous pouvez le faire.

En Python à la place, vous pouvez utiliser une classe décorateur mais qui sera appelé une fois que la classe a été initialisé. Une autre façon serait d'utiliser métaclasse mais cela dépend de ce que vous essayez d'atteindre.

Mais pourquoi? Ce qui rend la définition d'une classe de corps différents à partir d'une fonction-corps en la matière? Étant donné que les fonctions et les classes sont à la fois des objets de première classe, la différence dans leur corps n'est pas immédiatement évident pour moi. Edit: autre réponse ci-dessous indique, en fonction des organes sont pas exécuter lors de la définition elle-même en cours d'exécution, tandis que la classe organes sont exécutées dans le cadre de la classe-définition d'exécution.
Comment utilisez-vous en classe, les décorateurs et les metaclasses pour y parvenir? Un exemple serait génial.

OriginalL'auteur Anurag Uniyal
7

Vous ne pouvez pas avec la syntaxe spécifique vous êtes à décrire en raison de l'époque à laquelle ils sont évalués. La raison pour laquelle l'exemple de la fonction compte tenu des œuvres, c'est que l'appel à f(i-1) dans le corps de la fonction est parce que la résolution de nom de f n'est pas effectuée jusqu'à ce que la fonction est en fait appelé. À ce stade, f existe dans le cadre de l'exécution puisque la fonction a déjà été évalués. Dans le cas de l'exemple de classe, la mention du nom de la classe est regardé pendant tout la définition de la classe est toujours en cours d'évaluation. En tant que tel, il n'existe pas encore dans le domaine local.

Sinon, le comportement désiré peut être accompli à l'aide d'une métaclasse comme tel:
```
class MetaA(type):

    def __init__(cls):
        some_func(cls)

class A(object):
    __metaclass__=MetaA
  # do something
  # ...
```
En utilisant cette approche, vous pouvez effectuer arbitraires sur la classe de l'objet à la fois que la classe est évaluée.

C'est la seule réponse qui explique pourquoi il ne peut pas être fait (corps de fonction ne sont pas exécutées simplement sur la définition, tandis que la catégorie organismes sont). Merci pour la clarification.

OriginalL'auteur Mark Roddy
2

Si vous voulez faire référence à un même objet, il suffit d'utiliser un 'soi':
```
class A:
    def some_func(self):
        another_func(self)
```
Si vous souhaitez créer un nouvel objet de la même classe, il suffit de faire:
```
class A:
    def some_func(self):
        foo = A()
```
Si vous souhaitez avoir accès à l' ~~métaclasse~~ de la classe de l'objet (probablement pas ce que vous voulez), encore une fois, il suffit de faire:
```
class A:
    def some_func(self):
        another_func(A) # note that it reads A, not A()
```
Juste une précision: dans votre dernier exemple, en se référant à la "Une" est connue comme la "classe objet", pas un "métaclasse", qui est un concept tout à fait différent. La métaclasse de Un dans votre exemple serait types.ClassType (ou type si l'utilisation de la nouvelle-classes de style ou python3)

OriginalL'auteur carl
1

Nope. Il travaille dans une fonction, car la fonction contenu est exécuté lors de l'appel de temps. Mais le contenu de classe sont exécutées à définir en temps, à quel point la classe n'existe pas encore.

C'est normalement pas un problème parce que vous pouvez pirater d'autres membres dans la classe après la définition, de sorte que vous pouvez diviser la définition d'une classe en plusieurs parties:
```
class A(object):
    spam= 1

some_func(A)

A.eggs= 2

def _A_scramble(self):
    self.spam=self.eggs= 0
A.scramble= _A_scramble
```
Il est, cependant, assez inhabituel pour voulez appeler une fonction de la classe dans le milieu de sa propre définition. Il n'est pas clair ce que vous essayez de faire, mais les chances sont que vous seriez mieux avec les décorateurs (ou relativement nouveau classe décorateurs).

OriginalL'auteur bobince
1

Il n'y a pas un moyen de le faire dans le domaine de la classe, pas moins qu'Une a été défini pour être autre chose (et puis some_func(Un) de faire quelque chose de totalement différent de ce que vous attendez)

Sauf si vous êtes en train de faire une sorte de pile de l'inspection pour ajouter des morceaux à la classe, il semble étrange pourquoi vous voulez le faire. Pourquoi ne pas simplement:
```
class A:
    # do something
    pass

some_func(A)
```
Qui est, exécutez some_func sur Une fois qu'il a été fait. Alternativement, vous pouvez utiliser une classe décorateur (syntaxe n'a été ajouté qu'en 2.6) ou métaclasse si vous vouliez modifier la classe A d'une certaine manière. Pourriez-vous clarifier votre cas d'utilisation?

OriginalL'auteur Crast
1

Si vous voulez faire juste un peu hacky chose ne
```
class A(object):
    ...
some_func(A)
```
Si vous voulez faire quelque chose de plus sophistiqué, vous pouvez utiliser une métaclasse. Une métaclasse est responsable de la manipulation de la classe de l'objet avant qu'il soit entièrement créé. Un modèle serait:
```
class AType(type):
    def __new__(meta, name, bases, dct):
        cls = super(AType, meta).__new__(meta, name, bases, dct)
        some_func(cls)
        return cls

class A(object):
    __metaclass__ = AType
    ...
```
type est la valeur par défaut métaclasse. Les Instances de metaclasses sont en cours afin de __new__ renvoie une modification de l'instance de (dans ce cas) A.

Pour en savoir plus sur metaclasses, voir http://docs.python.org/reference/datamodel.html#customizing-class-creation.

OriginalL'auteur Danny Roberts
0

Que voulez-vous atteindre? Il est possible d'accéder à une classe de peaufiner sa définition à l'aide d'une métaclasse, mais il n'est pas recommandé.

Votre exemple de code peut être écrit simplement:
```
class A(object):
    pass
some_func(A)
```
OriginalL'auteur Tobu
0

C'est ok pour référence le nom de la classe à l'intérieur de son corps (comme à l'intérieur de la méthode définitions) si c'est réellement à la portée... et elle le sera si elle est définie au plus haut niveau. (Dans d'autres cas, probablement pas, en raison de Python portée de bizarreries!).

Pour l'illustration de la détermination de la portée gotcha, essayez d'instancier Foo:
```
class Foo(object):
    class Bar(object):
        def __init__(self):
            self.baz = Bar.baz
        baz = 15
    def __init__(self):
        self.bar = Foo.Bar()
```
(Il va se plaindre à propos du nom global de " Bar " n'étant pas défini.)

Aussi, quelque chose me dit que vous voudrez peut-être chercher dans les méthodes de la classe: docs sur le classmethod fonction (pour être utilisé comme un décorateur), DONC, la question pertinente. Edit: Ok, donc cette suggestion peut ne pas être adapté à tous les... C'est juste que la première chose que j'ai pensé lors de la lecture de votre question était des trucs comme alternative constructeurs etc. Si quelque chose de plus simple qui convient à vos besoins, orienter clairement de @classmethod étrangeté. 🙂

OriginalL'auteur Michał Marczyk
0

Si l'objectif est d'appeler une fonction some_func avec la classe comme un argument, une seule réponse est de déclarer some_func comme une classe de décorateur. Notez que la classe décorateur est appelée après la classe est initialisée. Il sera passé à la classe qui est en train d'être décoré comme un argument.
```
def some_func(cls):
    # Do something
    print(f"The answer is {cls.x}")
    return cls # Don't forget to return the class

@some_func
class A:
    x = 1
```
Si vous souhaitez passer des arguments supplémentaires à some_func vous devez retourner une fonction à partir de l'décorateur:
```
def some_other_func(prefix, suffix):
    def inner(cls):
        print(f"{prefix} {cls.__name__} {suffix}")
        return cls
    return inner

@some_other_func("Hello", " and goodbye!")
class B:
    x = 2
```
Classe décorateurs peut être composé, dont les résultats en eux être appelés dans l'ordre inverse ils sont déclarées:
```
@some_func
@some_other_func("Hello", "and goodbye!")
class C:
    x = 42
```
Le résultat de ce qui est:
```
# Hello C and goodbye!
# The answer is 42
```
OriginalL'auteur cdiggins
-1

Plus de code de la classe sera dans les définitions de méthode, dans ce cas, vous pouvez simplement utiliser le nom A.

-1 Il demande très précisément à propos de l'appel d'Une dans le corps principal de la classe, et non à partir de ses méthodes.

OriginalL'auteur Ned Batchelder

Vous devez vous connecter pour publier un commentaire.