I have a Python function which takes several arguments. Some of these arguments could be omitted in some scenarios.
def some_function (self, a, b, c, d = None, e = None, f = None, g = None, h = None): #code
h are strings which each have different meanings. It is important that I can choose which optional parameters to pass in any combination. For example,
(a, b, C, d, e), or
(a, b, C, g, h), or
(a, b, C, d, e, f, or all of them (these are my choices).
It would be great if I could overload the function – but I read that Python does not support overloading. I tried to insert some of the required int arguments in the list – and got an argument mismatch error.
Right now I am sending empty strings in place of the first few missing arguments as placeholders. I would like to be able to call a function just using actual values.
Is there any way to do this? Could I pass a list instead of the argument list?
Right now the prototype using ctypes looks something like:
_fdll.some_function.argtypes = [c_void_p, c_char_p, c_int, c_char_p, c_char_p, c_char_p, c_char_p, c_char_p]
Try calling it like:
obj.some_function( '1', 2, '3', g="foo", h="bar" ). After the required positional arguments, you can specify specific optional arguments by name.
Just use the
*args parameter, which allows you to pass as many arguments as you want after your
a,b,c. You would have to add some logic to map
c,d,e,f but its a “way” of overloading.
def myfunc(a,b, *args, **kwargs): for ar in args: print ar myfunc(a,b,c,d,e,f)
And it will print values of
Similarly you could use the
kwargs argument and then you could name your parameters.
def myfunc(a,b, *args, **kwargs): c = kwargs.get('c', None) d = kwargs.get('d', None) #etc myfunc(a,b, c='nick', d='dog', ...)
kwargs would have a dictionary of all the parameters that are key valued after