affectation de variable de classe comme valeur par défaut pour la méthode de classe argument

Je voudrais construire une méthode à l'intérieur d'une classe avec les valeurs par défaut des arguments tirés de cette classe. En général, je ne le filtrage des données. À l'intérieur de ma classe j'ai une méthode où, normalement, je passe vecteur de données. Parfois, je n'ai pas le vecteur, et je profite de données simulées. Chaque fois que je ne passe pas un particulier vecteur je voudrais profiter de l'aide de données simulées par défaut. J'ai pensé qu'il devrait être facile de la construction où à l'intérieur de ma définition de la méthode, je dis a=self.vector. Mais pour une raison que j'ai une erreur NameError: name 'self' is not defined. La simplification de la construction est:

class baseClass(object):  # This class takes an initial data or simulation
    def __init__(self):
        self.x = 1
        self.y = 2

class extendedClass(baseClass): # This class does some filtering
    def __init__(self):
        baseClass.__init__(self)
        self.z = 5
    def doSomething(self, a=self.z):
        self.z = 3
        self.b = a

if __name__ == '__main__':
    a = extendedClass()
    print a.__dict__
    a.doSomething()
    print a.__dict__

Une sortie que j'attendais devrait être:

{'y': 2, 'x': 1, 'z': 5}
{'y': 2, 'x': 1, 'z': 3, 'b': 5}

J'ai essayé de l'affectation par défaut comme def doSomething(self, a=z): évidemment, il ne fonctionne pas toujours. Autant je comprends self.z est visible dans ce champ d'application et ne devrait pas être un problème pour l'avoir comme valeur par défaut. Je ne sais pas pourquoi j'ai cette erreur et comment le faire. C'est probablement une question facile, mais j'essaie de le comprendre ou de trouver la solution sans manque quelque temps déjà. J'ai trouvé similaire questions seulement pour les autres langues.

InformationsquelleAutor tomasz74 | 2013-03-03

49

Votre compréhension est erronée. self est lui-même un paramètre à cette définition de fonction, donc il n'y a aucun moyen on peut être portée à ce point. C'est uniquement dans la portée au sein de la fonction elle-même.

La réponse est tout simplement par défaut de l'argument de None, puis vérifiez que l'intérieur de la méthode:
```
def doSomething(self, a=None):
    if a is None:
        a = self.z
    self.z = 3
    self.b = a
```
- Dans le cas où l'argument ne peut pas prendre sur falsy valeurs, vous devez juste écrire if a: a = self.z ou même a = a or self.z.
- Je pense que tu veux dire if not a: a = self.z
- Est-ce un standard pythonic modèle, c'est à dire ayant une propriété de classe avec une valeur par défaut qui est utilisé comme une solution de repli à partir d'une méthode facultative de la propriété? Ou est-il préférable de changer le extendedClass init constructeur d'inclure une option de z=None de la propriété, et si None affectez-lui une valeur par défaut à l'intérieur de la méthode, et n'ayant pas comme un paramètre de méthode? Je ne peux que penser que le fait d'avoir codé en dur propriété de classe est utile si c'est vraiment une constante, et requis par plus d'une méthode, sinon pourquoi ne pas restreindre z à la portée de la méthode, peut-être avec aucune classe ou une propriété d'objet à tous?
InformationsquelleAutor Daniel Roseman

Voici le désassemblage du code pour un exemple simple module. Un code objet est en lecture seule contenant pour bytecode, les constantes et les noms qu'elle utilise et les métadonnées sur le nombre de variables locales, requis la taille de la pile, etc. Notez que tous les code les objets sont compilés sous forme de constantes. Celles-ci sont créées au moment de la compilation. Mais les objets class A et function test sont instanciés au moment de l'exécution (par exemple, lorsque le module est importé).

Pour faire la classe, BUILD_CLASS prend le nom 'A', les bases tuple (object,), et un dict qui contient les attributs de la classe de l'espace de noms. C'est comme manuellement l'instanciation d'un type en appelant type(name, bases, dict). Pour faire de la dict, une fonction est créé à partir du code objet A et appelé. Enfin, la classe de l'objet est stocké dans le module de l'espace de noms par STORE_NAME.

Dans le code de l'objet A, self.z est chargé sur la pile comme argument de MAKE_FUNCTION. Le pseudo-code de l'op LOAD_NAME recherche self dans le courant des locaux (c'est à dire la classe de l'espace de noms en cours de définition), le module globales, et les builtins. Ce sera évidemment pas si self n'est pas défini dans le global ou les builtins portée; il n'est pas défini dans la portée locale.

Si elle a réussi, cependant, la fonction est créée avec (self.z,) comme son __defaults__ attribut, et ensuite stocké pour le nom local test.

>>> code = compile('''
... class A(object):
...   def test(self, a=self.z): pass
... ''', '<input>', 'exec')

>>> dis.dis(code)
  2           0 LOAD_CONST               0 ('A')
              3 LOAD_NAME                0 (object)
              6 BUILD_TUPLE              1
              9 LOAD_CONST               1 (<code object A ...>)
             12 MAKE_FUNCTION            0
             15 CALL_FUNCTION            0
             18 BUILD_CLASS         
             19 STORE_NAME               1 (A)
             22 LOAD_CONST               2 (None)
             25 RETURN_VALUE

>>> dis.dis(code.co_consts[1]) # code object A
  2           0 LOAD_NAME                0 (__name__)
              3 STORE_NAME               1 (__module__)

  3           6 LOAD_NAME                2 (self)
              9 LOAD_ATTR                3 (z)
             12 LOAD_CONST               0 (<code object test ...>)
             15 MAKE_FUNCTION            1
             18 STORE_NAME               4 (test)
             21 LOAD_LOCALS         
             22 RETURN_VALUE

@uselpa: Votre pastebin exemple (réécrit pour 2.x):

>>> code = compile('''
... default = 1
... class Cl(object):
...     def __init__(self, a=default):
...         print a
... Cl()
... default = 2
... Cl()
... ''', '<input>', 'exec')
>>> dis.dis(code)
  2           0 LOAD_CONST               0 (1)
              3 STORE_NAME               0 (default)

  3           6 LOAD_CONST               1 ('Cl')
              9 LOAD_NAME                1 (object)
             12 BUILD_TUPLE              1
             15 LOAD_CONST               2 (<code object Cl ...>)
             18 MAKE_FUNCTION            0
             21 CALL_FUNCTION            0
             24 BUILD_CLASS         
             25 STORE_NAME               2 (Cl)

  6          28 LOAD_NAME                2 (Cl)
             31 CALL_FUNCTION            0
             34 POP_TOP             

  7          35 LOAD_CONST               3 (2)
             38 STORE_NAME               0 (default)

  8          41 LOAD_NAME                2 (Cl)
             44 CALL_FUNCTION            0
             47 POP_TOP             
             48 LOAD_CONST               4 (None)
             51 RETURN_VALUE

Comme vous pouvez le voir, la classe de l'objet Cl (et la fonction de l'objet __init__) est instancié et stockées pour le nom local 'Cl' une fois. Le module exécute séquentiellement au moment de l'exécution, de sorte que par la suite reconsolidation du nom default n'aura aucun effet sur la valeur par défaut dans __init__.

Vous pourriez instancier dynamiquement une nouvelle fonction à l'aide de la déjà le code compilé et une nouvelle valeur par défaut:

>>> default = 1
>>> class Cl(object):
...     def __init__(self, a=default):
...         print a
... 

>>> from types import FunctionType
>>> default = 2
>>> Cl.__init__ = FunctionType(
...   Cl.__init__.__code__, globals(), '__init__', (default,), None)
>>> c = Cl()
2

Ce réutilise le déjà compilé en code objet de __init__.__code__ pour créer une fonction avec un nouveau __defaults__ tuple:

>>> Cl.__init__.__defaults__
(2,)

Je suis coincé. Si la classe et de la méthode sont créés à l'instanciation de temps, alors pourquoi sont-ils manifestement pas dans mon exemple sur pastebin.com/UJfMpnqW ?
J'ai ajouté votre exemple, nous l'espérons, pour préciser la différence entre "compilation" et "temps d'exécution". Un module permet de compiler des beaux-avec pas d'erreurs de syntaxe, mais qui ont encore des erreurs d'exécution, lorsqu'elles sont importées (exécutée).
Je pense que je vais l'obtenir. Merci beaucoup pour votre patience!

InformationsquelleAutor eryksun

5

Des arguments par défaut évaluée qu'une seule fois, lorsque la définition est exécutée. Au lieu de cela, faire cela:
```
def doSomething(self, a=None):
    if a is None:
        a = self.z
    self.z = 3
    self.b = a
```
Voir aussi http://docs.python.org/release/3.3.0/tutorial/controlflow.html#more-on-defining-functions.

InformationsquelleAutor uselpa

Cela permettra d'insérer self.z si a est None/False/empty_value:

def doSomething(self, a=None):
        self.z = 3
        self.b = (a or self.z)

InformationsquelleAutor Alex

Vous devez vous connecter pour publier un commentaire.