Is there a way to call the method of a class from another class? I am looking for something like PHP’s call_user_func_array()
.
Here is what I want to happen:
class A: def method1(arg1, arg2): ... class B: A.method1(1, 2)
Advertisement
Answer
update: Just saw the reference to call_user_func_array
in your post. that’s different. use getattr
to get the function object and then call it with your arguments
class A(object): def method1(self, a, b, c): # foo method = A.method1
method
is now an actual function object. that you can call directly (functions are first class objects in python just like in PHP > 5.3) . But the considerations from below still apply. That is, the above example will blow up unless you decorate A.method1
with one of the two decorators discussed below, pass it an instance of A
as the first argument or access the method on an instance of A
.
a = A() method = a.method1 method(1, 2)
You have three options for doing this
- Use an instance of
A
to callmethod1
(using two possible forms) - apply the
classmethod
decorator tomethod1
: you will no longer be able to referenceself
inmethod1
but you will get passed acls
instance in it’s place which isA
in this case. - apply the
staticmethod
decorator tomethod1
: you will no longer be able to referenceself
, orcls
instaticmethod1
but you can hardcode references toA
into it, though obviously, these references will be inherited by all subclasses ofA
unless they specifically overridemethod1
and do not callsuper
.
Some examples:
class Test1(object): # always inherit from object in 2.x. it's called new-style classes. look it up def method1(self, a, b): return a + b @staticmethod def method2(a, b): return a + b @classmethod def method3(cls, a, b): return cls.method2(a, b) t = Test1() # same as doing it in another class Test1.method1(t, 1, 2) #form one of calling a method on an instance t.method1(1, 2) # form two (the common one) essentially reduces to form one Test1.method2(1, 2) #the static method can be called with just arguments t.method2(1, 2) # on an instance or the class Test1.method3(1, 2) # ditto for the class method. It will have access to the class t.method3(1, 2) # that it's called on (the subclass if called on a subclass) # but will not have access to the instance it's called on # (if it is called on an instance)
Note that in the same way that the name of the self
variable is entirely up to you, so is the name of the cls
variable but those are the customary values.
Now that you know how to do it, I would seriously think about if you want to do it. Often times, methods that are meant to be called unbound (without an instance) are better left as module level functions in python.