Python appel de méthode dans la classe

Je suis poinçonnage manière au-dessus de mon poids ici, mais s'il vous plaît garder avec ce Python amateur. Je suis un développeur PHP par le commerce et j'ai à peine touché cette langue avant de.

Ce que j'essaie de faire est d'appeler une méthode dans une classe semble assez simple...? Je suis complètement perplexe à propos de ce " moi " se réfère, et quelle est la procédure correcte pour appeler cette méthode à l'intérieur d'une classe et en dehors de la classe.

Quelqu'un pourrait-il expliquer pour moi, comment appeler la move méthode avec la variable RIGHT. J'ai essayé la recherche de ce sur plusieurs " apprendre le langage python les sites et les recherches sur StackOverflow, mais en vain. Toute aide sera appréciée.

La classe suivante œuvres de Scott script Python qui est accessible par un terminal GRAPHIQUE (urwid).

La fonction je travaille est un Scott Weston lanceur de missiles script Python, que je suis en train de crochet dans PHP serveur web.

class MissileDevice:
INITA     = (85, 83, 66, 67,  0,  0,  4,  0)
INITB     = (85, 83, 66, 67,  0, 64,  2,  0)
CMDFILL   = ( 8,  8,
0,  0,  0,  0,  0,  0,  0,  0,
0,  0,  0,  0,  0,  0,  0,  0,
0,  0,  0,  0,  0,  0,  0,  0,
0,  0,  0,  0,  0,  0,  0,  0,
0,  0,  0,  0,  0,  0,  0,  0,
0,  0,  0,  0,  0,  0,  0,  0,
0,  0,  0,  0,  0,  0,  0,  0)
STOP      = ( 0,  0,  0,  0,  0,  0)
LEFT      = ( 0,  1,  0,  0,  0,  0)
RIGHT     = ( 0,  0,  1,  0,  0,  0)
UP        = ( 0,  0,  0,  1,  0,  0)
DOWN      = ( 0,  0,  0,  0,  1,  0)
LEFTUP    = ( 0,  1,  0,  1,  0,  0)
RIGHTUP   = ( 0,  0,  1,  1,  0,  0)
LEFTDOWN  = ( 0,  1,  0,  0,  1,  0)
RIGHTDOWN = ( 0,  0,  1,  0,  1,  0)
FIRE      = ( 0,  0,  0,  0,  0,  1)
def __init__(self, battery):
try:
self.dev=UsbDevice(0x1130, 0x0202, battery)
self.dev.open()
self.dev.handle.reset()
except NoMissilesError, e:
raise NoMissilesError()
def move(self, direction):
self.dev.handle.controlMsg(0x21, 0x09, self.INITA, 0x02, 0x01)
self.dev.handle.controlMsg(0x21, 0x09, self.INITB, 0x02, 0x01)
self.dev.handle.controlMsg(0x21, 0x09, direction+self.CMDFILL, 0x02, 0x01)

Que pensez-vous est le problème avec votre code? On dirait que vous êtes en utilisant self droit.
Ce n'est pas sur le code ci-dessus, c'est une classe de prises de code de travail. Im demandant une plus élémentaires question; comment appeler une méthode dans une classe.
J'ai demandé comment faire pour appeler une méthode d'une classe, à l'aide de cet exemple donné. Tous comme indiqué ci-dessus. J'ai été après une explication plutôt qu'une solution.
j'ai été confrontée au même problème, alors que la création de la classe. J'ai utilisé l'auto.<methodName> pour appeler la méthode à l'intérieur de la classe. en dehors de la classe <ObjectName>.<MethodName>. J'espère que vous avez le point

InformationsquelleAutor kirgy | 2012-12-29

60

Le premier argument de toutes les méthodes est généralement appelé self. Il se réfère à l'instance pour laquelle la méthode est appelée.

Disons que vous avez:
```
class A(object):
def foo(self):
print 'Foo'
def bar(self, an_argument):
print 'Bar', an_argument
```
Ensuite, en faisant:
```
a = A()
a.foo() #prints 'Foo'
a.bar('Arg!') #prints 'Bar Arg!'
```
Il n'y a rien de spécial à propos de cet être appelé self, vous pouvez effectuer les opérations suivantes:
```
class B(object):
def foo(self):
print 'Foo'
def bar(this_object):
this_object.foo()
```
Ensuite, en faisant:
```
b = B()
b.bar() # prints 'Foo'
```
Dans votre cas particulier:
```
dangerous_device = MissileDevice(some_battery)
dangerous_device.move(dangerous_device.RIGHT) 
```
(Comme suggéré dans les commentaires MissileDevice.RIGHT pourrait être plus approprié ici!)

Vous pourrait déclarer tous vos constantes au niveau du module, donc vous pouvez faire:
```
dangerous_device.move(RIGHT)
```
Cependant, cela va dépendre de la façon dont vous voulez que votre code sera organisé!
- considérant la façon dont RIGHT est définie sur la classe, c'était sans doute l'intention de l'auteur qu'il soit appelé ClassName.ATTRIBUTE au lieu de one_instance.ATTRIBUTE, comme si elle doit être le même pour toutes les instances, et vous n'avez pas besoin d'une instance de s'y référer; donc... MissileDevice.RIGHT est probablement la "bonne façon" d'utiliser cette classe.
- Je ne pourrais pas obtenir que cela fonctionne pour mon exemple, mais je crois que c'est quelque chose à voir avec ce que les "batterie" est, comme la question est en fait sur les classes/méthodes qui ce que vous avez expliqué, c'est correct, Im gona pour marquer cette réponse comme correcte. J'ai pensé id remarque ici, au cas où quelqu'un à la recherche pour les pays développés missile.py code vient ici.
InformationsquelleAutor Thomas Orozco

Disons que vous avez un brillant classe Foo.
Eh bien, vous avez 3 options:

1) Vous souhaitez utiliser la méthode (ou attribut) d'une classe à l'intérieur de la définition de cette classe:

class Foo(object):
attribute1 = 1                   # class attribute (those don't use 'self' in declaration)
def __init__(self):
self.attribute2 = 2          # instance attribute (those are accessible via first
# parameter of the method, usually called 'self'
# which will contain nothing but the instance itself)
def set_attribute3(self, value): 
self.attribute3 = value
def sum_1and2(self):
return self.attribute1 + self.attribute2

2) Vous souhaitez utiliser la méthode (ou attribut) d'une classe à l'extérieur de la définition de cette classe

def get_legendary_attribute1():
return Foo.attribute1
def get_legendary_attribute2():
return Foo.attribute2
def get_legendary_attribute1_from(cls):
return cls.attribute1
get_legendary_attribute1()           # >>> 1
get_legendary_attribute2()           # >>> AttributeError: type object 'Foo' has no attribute 'attribute2'
get_legendary_attribute1_from(Foo)   # >>> 1

3) Vous souhaitez utiliser la méthode (ou attribut) d'un instancié de la classe:

f = Foo()
f.attribute1                         # >>> 1
f.attribute2                         # >>> 2
f.attribute3                         # >>> AttributeError: 'Foo' object has no attribute 'attribute3'
f.set_attribute3(3)
f.attribute3                         # >>> 3

InformationsquelleAutor Michele Soltanto

2

Quelqu'un pourrait-il m'expliquer, comment appeler la méthode move avec la variable de DROIT
```
>>> myMissile = MissileDevice(myBattery)  # looks like you need a battery, don't know what that is, you figure it out.
>>> myMissile.move(MissileDevice.RIGHT)
```
Si vous avez programmé dans toute autre langue avec des cours, en plus de python, ce genre de chose
```
class Foo:
bar = "baz"
```
est probablement inconnu. En python, la classe est une usine pour les objets, mais il est lui-même un objet; et les variables définies dans son champ d'application sont attachés à la classe, pas les instances renvoyé par la classe. pour consulter bar, ci-dessus, vous pouvez simplement appeler Foo.bar; vous pouvez également accéder à des attributs de classe à travers les instances de la classe, comme Foo().bar.

Im totalement perplexe à propos de ce " moi " se réfère aussi,
```
>>> class Foo:
...     def quux(self):
...         print self
...         print self.bar
...     bar = 'baz'
...
>>> Foo.quux
<unbound method Foo.quux>
>>> Foo.bar
'baz'
>>> f = Foo()
>>> f.bar
'baz'
>>> f
<__main__.Foo instance at 0x0286A058>
>>> f.quux
<bound method Foo.quux of <__main__.Foo instance at 0x0286A058>>
>>> f.quux()
<__main__.Foo instance at 0x0286A058>
baz
>>>
```
Lorsque vous acecss un attribut sur un objet python, l'interprète de l'avis, lorsque le regarda attribut de la classe, et est une fonction, qu'il doit retourner un "lié" méthode au lieu de la fonction elle-même. Tout cela n'est prendre des dispositions pour que l'instance soit passé comme premier argument.

InformationsquelleAutor SingleNegationElimination

Vous devez vous connecter pour publier un commentaire.