En passant une instance d'une classe(un objet d'une classe) à une autre classe en python

Ce que je ne comprends pas c'est b = Bar(a). Que faut-il faire? Comment est-Barre prenant comme argument? L'habitude de dire que la Barre hériter d'une? Qu'est-ce que d'un Bar.Toto1 = Foo? Est-ce qu'Toto1 est une instance de la classe Foo()? Comment accéder Toto1 quand il est lui-même un objet? Quel est le sens de b.arg.variable? N'est-ce pas les moyens b a une méthode arg qui a une variable appelée variable? Le code suivant est à partir de la réponse

Pardonnez-moi si la question est naïve. Je n'ai pas pu trouver l'analyse des objets comme argument d'une autre classe. Une clarification serait génial!

  class Foo (object):
  #^class name  #^ inherits from object

      bar = "Bar" #Class attribute.

      def __init__(self):
          #        #^ The first variable is the class instance in methods.  
          #        #  This is called "self" by convention, but could be any name you want.


          self.variable="Foo" #instance attribute.
          print self.variable, self.bar  #<---self.bar references class attribute
          self.bar = " Bar is now Baz"   #<---self.bar is now an instance attribute
          print self.variable, self.bar  

       def method(self,arg1,arg2):
          #This method has arguments. You would call it like this : instance.method(1,2)
          print "in method (args):",arg1,arg2
          print "in method (attributes):", self.variable, self.bar


 a=Foo() # this calls __init__ (indirectly), output:
             # Foo bar
             # Foo  Bar is now Baz
 print a.variable # Foo
 a.variable="bar"
 a.method(1,2) # output:
               # in method (args): 1 2
               # in method (attributes): bar Bar is now Baz
 Foo.method(a,1,2) #<--- Same as a.method(1,2).  This makes it a little more explicit what the argument "self" actually is.

 class Bar(object):
     def __init__(self,arg):
          self.arg=arg
          self.Foo1=Foo()

 b=Bar(a)
 b.arg.variable="something"
 print a.variable # something
 print b.Foo1.variable # Foo
Vous devriez lire le tutoriel Python afin de vous familiariser avec les bases de Python.
J'ai lu qu' . Il n'y a pas une telle chose comme le passage d'un objet à une autre classe. Et je n'ai pu obtenir d'autres sources
Il est décrit ici. Tout est un objet en Python. Passage d'un objet à une classe n'est pas différent de passage d'un entier (comme dans cet exemple), une chaîne, ou quoi que ce soit d'autre.
Alors b est un objet de la classe Bar dont le constructeur est appelé pour initialiser b, un(Foo()) ou un Bar()? et qu'est-ce que b.arg.variable?
Je ne comprends pas ce que vous demandez. a a déjà été créé avec la ligne a = Foo(), et Foo __init__ l'appelait à l'époque. Lorsque Bar(a) est exécutée, puis la Barre __init__ sera appelée. Les commentaires dans votre posté exemple semblent déjà principalement de répondre aux questions que vous vous dites.

OriginalL'auteur qurius | 2014-06-14

  1. 8

    "Ce que je ne comprends pas, c'est b = Bar(a). Que faut-il faire?"

    b = Bar(a) fait deux choses. Tout d'abord, il crée un objet de la classe Bar (avec toutes les variables de classe et des méthodes ci-joint). Ensuite, il exécute __init__ avec le premier argument (self) pointant vers l'objet qui vient d'être créé, et avec a comme deuxième argument (arg). Lors de l'exécution de __init__, comme l'une des commandes dans cette méthode, il définit self.arg pour pointer vers l'objet pointé par arg (c'est à dire à l'objet pointé par la variable a). Enfin, la variable b est définie pour faire référence à l'objet qui a été créé.

    Il peut aider à penser de cette façon: une variable en Python est vraiment juste un pointeur qui pointe vers un objet. Vous pouvez avoir plus d'une variable pointant vers le même objet. Dans ce cas, a et b.arg pointent vers le même objet.

    J'ai trouvé ce genre de chose aussi induire en erreur, au premier abord. J'avais vu l'avis de penser à des variables comme des concepts distincts de l'objet qu'ils indiquent et ignoré inutilement compliquer les choses, mais j'ai dû revenir à accepter cette façon de penser afin de faire la part des choses. Les gens n'utilisent souvent la variable comme un nom pour désigner l'objet de points; vous avez juste à savoir quand prendre littéralement ou non.

    "Coutume de dire que la Barre hériter d'une?"

    Pas. Si a est une classe, alors class Bar(a) signifierait que la Barre hérite de a. Mais dans
    b = Bar(a), a est un objet qui est passé comme argument à __init__.

    "Qu'est-ce que d'un Bar.Toto1 = Foo?"

    Désolé-je ne vois pas que, dans l'exemple de code que vous avez donné.

    "Quel est le sens de b.arg.variable?"

    b est un objet (je veux dire, b se réfère à un objet) et b.arg est l'un des attributs de cet objet. Les méthodes et les variables sont les différents types d'attributs. Dans ce cas, b.arg est une variable pointant vers un objet. L'objet visé par b.arg a attribut variable, qui est une variable.

    b.arg désigne le même objet que a se réfère, par conséquent b.arg.variable est la même variable que a.variable. Non seulement, elle pointe vers le même objet, mais en réalité est la même variable. L'objet c'est la chaîne "something".

    @Brenbarn: je pense que c'est ce quirius entend par "Coutume de dire que la Barre hériter d'une?".

    Merveilleusement expliqué. Merci!!!!
    Est-ce vraiment ce que vous demandez? C'était pas totalement clair pour moi à partir de votre question.

    OriginalL'auteur Linguist

  2. 3

    Ici est un exemple simple. Supposons que vous avez ces classes:

    class Foo(object):
    pass

class Bar(object):
    def __init__(self, arg):
        self.arg = arg

    Voici deux choses que vous pourriez faire:

    # Option 1: pass in an integer
>>> b = Bar(1)
>>> b.arg
1

# Option 2: pass in a Foo object
>>> a = Foo()
>>> b = Bar(a)
>>> b.arg
<__main__.Foo object at 0x0000000002A440F0>

    Il est pas de différence dans la façon que les deux cas sont traités. En passant a (un objet Foo) n'est pas différent de passage dans un entier. Tout ce que Bar n'est de stocker la valeur qui est passé, et il peut stocker de la même si c'est un Toto ou un int. Lorsque vous appelez Bar(something), il est tout à fait à la Bar classe comment manipuler l'objet qui est passé. Le type de l'objet n'est pas, sauf dans la mesure où Bar choisit explicitement de le faire participer (par exemple, par des appels de méthodes sur le passé dans l'objet).

    Je vous remercie. et je m'excuse pour demander trivial questions, mais je ne pouvais pas sortir de la java cadre pour penser variable comme une variable et non pas comme un objet.
    Si je comprends bien droit, il apparaît aujourd'hui vous étiez vraiment se poser de savoir si Bar(a) crée un nouvel objet qui est en quelque sorte "basé sur" a (p. ex., une copie de a). Aurait été bon de mentionner que! 🙂 Quand vous suffit de demander "qu'est-Barre(a) faire", il n'est pas clair ce que vous ne comprenez pas.
    Oui , c'était effectivement ce que je voulais dire. 🙂
    Alors, le (object) partie dans la définition de classe jamais réellement nécessaire?

    OriginalL'auteur BrenBarn