There are two ways to call a class' methods from outside that class. The more common way is to call the method on an instance of the class, like this:
# pass all the variables that __init__ requires to create a new instance
such_and_such = SuchAndSuch[pos, vel, ang, ang_vel, image, info]
# now call the method!
such_and_such.update[]
Simple as that! The self parameter in the method definition refers to the instance that the method is being called on, and is implicitly passed to the method as the first argument. You probably want such_and_such to be a module-level ["global"] object, so you can reference and update the same
object every time a key is pressed.
# Initialize the object with some default values [I'm guessing here]
such_and_such = SuchAndSuch[[0, 0], [0, 0], 0, 0, None, '']
# Define keydown to make use of the such_and_such object
def keydown[key]:
if key == simplegui.KEY_MAP['up']:
such_and_such.update[]
# [Perhaps your update method should take another argument?]
The second way is to call a class method. This is probably not what you actually want here, but for completeness, I'll define it briefly: a class method is bound to a class, instead of an instance of that class. You declare them using a decorator, so your method definition would look like this:
class SuchAndSuch[object]:
@classmethod
def update[cls]:
pass # do stuff
Then you could call this method without an instance of the class:
SuchAndSuch.update[]
View Discussion
Improve Article
Save Article
View Discussion
Improve Article
Save Article
In Python, we can define the variable outside the class, inside the class, and even inside the methods. Let’s see, how to use and access these variables throughout the program.
Variable defined outside the class:
The variables that are defined outside the class can be accessed by any class or any methods in the class by just writing the variable name.
outVar = 'outside_class'
print["Outside_class1", outVar]
class Geek:
print["Outside_class2", outVar]
def access_method[self]:
print["Outside_class3", outVar]
uac = Geek[]
uac.access_method[]
class Another_Geek_class:
print["Outside_class4", outVar]
def another_access_method[self]:
print["Outside_class5", outVar]
uaac = Another_Geek_class[]
uaac.another_access_method[]
Output:
Outside_class1 outside_class Outside_class2 outside_class Outside_class3 outside_class Outside_class4 outside_class Outside_class5 outside_class
Variable defined inside the class:
The variables that are defined inside the class but outside the method can be accessed within the class[all methods
included] using the instance of a class. For Example – self.var_name.
If you want to use that variable even outside the class, you must declared that variable as a global. Then the variable can be accessed using its name inside and outside the class and not using the instance of the class.
class Geek:
inVar = 'inside_class'
print["Inside_class2", inVar]
def access_method[self]:
print["Inside_class3", self.inVar]
uac = Geek[]
uac.access_method[]
class another_Geek_class:
print[]
def another_access_method[self]:
print[]
uaac = another_Geek_class[]
uaac.another_access_method[]
Output:
Inside_class2 inside_class Inside_class3 inside_class
The statements which are marked as error will produce an error upon execution as the variable is not accessible there.
Variable defined inside the method:
The variables that are defined inside the methods can be accessed within that method only by simply using the variable name. Example – var_name.
If you want to use that variable outside the method or class, you have to declared that variable as a global.
class
Geek:
print[]
def access_method[self]:
inVar = 'inside_method'
print["Inside_method3", inVar]
uac = Geek[]
uac.access_method[]
class AnotherGeek:
print[]
def access_method[self]:
print[]
uaac = AnotherGeek[]
uaac.access_method[]
Output:
Inside_method3 inside_method
The statements which are marked as error will produce error upon execution as the variable is not accessible there.
Summary: