How can I detect if the caller passed any variables to my function in Python?

I guess the subject sounds pretty stupid, so I'll show some code:

def foo(**kwargs):
    # How can you detect the difference between (**{}) and ()?

Is there any way to detect inside of foo, how the method was called?

Update 1

Because there were some comments why you possible want to do something, I'll try to explain some background.

super(MyClass, self).foo(*args, **kwargs) sucks - a lot of wasteful duplication. I want to write 'self.super()'. In this case, just call the super class and hand over all parameters that the calling method got as well. Works like a charm.

Now the problematic magic part:

I want to say 'self.super(something)' and in this case, only 'something' is passed to the super method. Works for most cases.

This is where it breaks:

def foo(self, fnord=42, *args, **kwargs):
    self.super(*args, **kwargs)

So the super method should get the arguments that the calling method - however if *args, **kwargs are empty, currently the library can not detect this condition and passed all arguments including 'fnord'...

Of course I could use*args, **kwargs) as an alternative syntax but that's lame :-)

PS: Yes, I know p3k's super, but still not nice and it does not work with Python 2.x...

Update 2

Actually even Python's ast module removes the **{} (ast.parse('foo(**{})')) so it looks like this happens so early in the parsing process that you can not get this information later on...

So in the end I have either to give up on that specific problem (raising an AmbiguousSyntaxError) or to use text parsing as proposed by ~unutbu. Re-thinking my approach, the latter might actually feasable because I only need to know if it is self.super(\s*), self.super(\S+).


This hack only works with CPython.

import traceback

def foo(**kwargs):
    # stack is a list of 4-tuples: (filename, line number, function name, text)
    # see

    print('foo was called: %s'%text)

# foo was called: foo(**{})
# foo was called: foo()

As an example of how this might be useful:

def pv(var):
    print('%s: %s'%(text[text.find('(')+1:-1],var))

# x: 5

Notice that pv is called with just the value x, but it prints both the "name" of the variable (as it was called), and the value of a variable. Sometimes I use this when debugging and am too lazy to write out the full print statement.

In your update to your original question you wrote you want to be able to do something like this:

def foo(self, fnord=42, *args, **kwargs):
    self.super(*args, **kwargs)

Does this do what you want?

def foo(self, fnord=42, *args, **kwargs):
    self.super(fnord=fnord, *args, **kwargs)

So basically it is not possible to do that with the provided Python modules. I had to fall-back to plain-text regexes which work for me pretty well given the simplicity of my requirements.

Need Your Help

WPF PreferredSize property?

wpf layout

In Windows Forms, you have a PreferredSize property that will tell you how large a control would like to be.

data.table operation chaining

r data.table

What is the best way to perform the following kinds of operations: