I have a class that will have a number of external methods that will all call the same smaller set of internal methods. So something like:
obj.method_one(a, c) and
obj.method_two(a, c)
where obj.method_one calls obj._internal_method(a, c, y) and obj.method_two calls obj._internal_method(a, c, z).
They’re nearly identical but they have one argument at the end that differs on the internal call (which is a constant).
I could just copy and paste a few times but I was wondering if theres any way to dynamically create these external methods.
There are ways, but unless you have at least half a dozen, I’d suggest:
class myclass(object):
def _internal_method(self,a,c,y):
pass # add code here
def method_one(self,a,c): self._internal_method(a,c,"method one")
def method_two(self,a,c): self._internal_method(a,c,"another method")
The other option is to actually really create it dynamically. This can be confusing, because if the object is inspected, the methods aren’t there. It looks like this:
class test(object):
def __getattr__(self,attrname):
def _internal_method(a,c):
print "You called %s with %s and %s" % (attrname,a,c)
if attrname in ["method_one","method_two"]:
return _internal_method
else:
raise NameError
a=test()
a.method_one("first","second")
This makes use of the fact that a getting a property (like a method) that does not exist, the object’s __getattr__ is called, and the result is passed back. Note that we are passing back the FUNCTION _internal_method as a.method_one, not calling it at this stage; that is done after the call to getattr has returned. Think of the last line as being:
tmp=a.method
tmp("first","second")
The first of these calls __getattr__ which returns _internal_method (but does not call it), the latter calls _internal_method.
Since _internal_method is declared within __getattr__, it has the same scope as the call that created it, so self and attrname are accessible. Also, _internal_method is TRULY private, not just “private by convention”.
I will reiterate that this is confusing for the next person to maintain your code. For example, if you ask for help(a.method_one), you will get the help for _internal_method instead!
The length of this explanation, and your probable confusing is a very good reason not to use this unless you have to.
2