Ik stoot hier ver boven mijn gewicht, maar heb alsjeblieft geduld met deze Python-amateur. Ik ben een PHP-ontwikkelaar van beroep en ik heb deze taal nog nauwelijks aangeraakt.
Wat ik probeer te doen is een methode aanroepen in een klasse…klinkt dat eenvoudig genoeg? Ik ben volkomen verbijsterd over waar ‘zelf’ naar verwijst, en wat de juiste procedure is om een dergelijke methode binnen een klasse en buiten een klasse aan te roepen.
Kan iemand mij uitleggen hoe ik de move methode aanroep met de variabele RIGHT. Ik heb geprobeerd dit te onderzoeken op verschillende ‘leer python’-sites en zoekopdrachten op StackOverflow, maar het mocht niet baten. Alle hulp wordt op prijs gesteld.
De volgende klasse werkt in Scott’s Python-script dat toegankelijk is via een terminal-GUI (urwid).
De functie waar ik mee werk is een Python-script van de raketwerper van Scott Weston, dat ik probeer te koppelen aan een PHP-webserver.
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)
Antwoord 1, autoriteit 100%
Het eerste argument van alle methoden wordt gewoonlijk self genoemd. Het verwijst naar de instantie waarvoor de methode wordt aangeroepen.
Stel dat je het volgende hebt:
class A(object):
def foo(self):
print 'Foo'
def bar(self, an_argument):
print 'Bar', an_argument
En dan doen:
a = A()
a.foo() #prints 'Foo'
a.bar('Arg!') #prints 'Bar Arg!'
Er is niets bijzonders aan dat dit self wordt genoemd, je zou het volgende kunnen doen:
class B(object):
def foo(self):
print 'Foo'
def bar(this_object):
this_object.foo()
En dan doen:
b = B()
b.bar() # prints 'Foo'
In jouw specifieke geval:
dangerous_device = MissileDevice(some_battery)
dangerous_device.move(dangerous_device.RIGHT)
(Zoals gesuggereerd in opmerkingen MissileDevice.RIGHT zou hier meer geschikt kunnen zijn!)
U zou al uw constanten op moduleniveau kunnen declareren, dus u zou het volgende kunnen doen:
dangerous_device.move(RIGHT)
Dit hangt echter af van hoe u wilt dat uw code wordt georganiseerd!
Antwoord 2, autoriteit 12%
Stel dat je een glanzende Foo-les hebt.
Nou, je hebt 3 opties:
1) U wilt de methode (of attribuut) van een klasse gebruiken binnen de definitie van die klasse:
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) U wilt de methode (of attribuut) van een klasse gebruiken buiten de definitie van die klasse
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) U wilt de methode (of kenmerk) van een geïnstantieerde klasse gebruiken:
f = Foo()
f.attribute1 # >>> 1
f.attribute2 # >>> 2
f.attribute3 # >>> AttributeError: 'Foo' object has no attribute 'attribute3'
f.set_attribute3(3)
f.attribute3 # >>> 3
Antwoord 3, autoriteit 5%
Kan iemand mij uitleggen hoe je de move-methode aanroept met de variabele RIGHT
>>> myMissile = MissileDevice(myBattery) # looks like you need a battery, don't know what that is, you figure it out.
>>> myMissile.move(MissileDevice.RIGHT)
Als je in een andere taal hebt geprogrammeerd met klassen, behalve python, dit soort dingen
class Foo:
bar = "baz"
is waarschijnlijk onbekend. In python is de klasse een fabriek voor objecten, maar het is zelf een object; en variabelen gedefinieerd in zijn bereik zijn gekoppeld aan de klasse, niet de instanties die door de klasse worden geretourneerd. om te verwijzen naar bar hierboven, kun je het gewoon Foo.bar noemen; je hebt ook toegang tot klasseattributen via instanties van de klasse, zoals Foo().bar.
Ik ben totaal verbijsterd over wat ‘zelf’ ook verwijst,
>>> 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
>>>
Als je toegang krijgt tot een attribuut op een python-object, zal de interpreter opmerken, wanneer het opgezochte attribuut zich in de klasse bevond en een functie is, dat het een “gebonden” methode zou moeten retourneren in plaats van de functie zelf. Dit alles zorgt ervoor dat de instantie wordt doorgegeven als het eerste argument.