Python: function that returns a dict whose keys are the names of the input arguments

Question

Is it possible to write a function f that takes an arbitrary tuple of mixed data:

T = 1.0
N = 20
L = 10
args = (T,N,L)

f(*args) # or maybe f(T,N,L)?

and returns as output:

{'T':1.0, 'N':20, 'L':10}

There is a related question using local, but I seem to lose the names once they are passed to the function. Is there a way to prevent this? I'm guessing that the variables are being passed by value and thus they are considered new objects.

Followup: Python: Using a dummy class to pass variable names?

You seem to be confusing concepts here. Other languages have variables, but [Python has names](http://python.net/~goodger/projects/pycon/2007/idiomatic/handout.html#python-has-names). — Sven Marnach, Mar 06 '12 at 15:14
Probably not possible, but I'll leave this as a comment for when I'm inevetiably proven wrong (probably with bytecode analysis or some such silliness). — SingleNegationElimination, Mar 06 '12 at 15:14
I think it's possible given some constraints, please see my answer. Not robust or commendable though. — Eduardo Ivanec, Mar 06 '12 at 15:26

Fred Foo · Accepted Answer · 2012-03-06T15:20:49.743

No, this is not possible in general with *args. You'll have to use keyword arguments:

>>> def f(**kwargs):
...  return kwargs
... 
>>> f(T=1.0, N=20, L=10)
{'T': 1.0, 'L': 10, 'N': 20}

The reason is that *args does not introduce names for the individual arguments; it only introduces the name args for the whole list of them. The function has no insight into how what names, if any, the arguments have outside of it.

When the number of arguments is fixed, you can do this with locals:

>>> def g(T, N, L):
...  return locals()
... 
>>> g(T=1.0, N=20, L=10)
{'L': 10, 'T': 1.0, 'N': 20}

(or explicitly with return {'T': T, 'N': N, 'L': L}.)

Exactly. And then you are back to explicitly describing the key names rather than implicitly deriving them when you do `(T=1.0, N=20, L=10)`. — Silas Ray, Mar 06 '12 at 15:15

score 2 · Answer 2 · answered Mar 06 '12 at 15:12

2

In Python variables are just labels attached to values. So there is no way to know, from another scope, what labels you were using when calling the function.

answered Mar 06 '12 at 15:12

Andrea

20,253
23
114
183

score 2 · Answer 3 · answered Mar 06 '12 at 15:19

Your guess is unfortunately wrong, and in fact the whole question betrays a misunderstanding of how Python names work.

Python objects, on the whole, don't know their names. That's completely understandable when you consider that you can easily assign a=b, and now a and b both refer to exactly the same object. Python's "variables" are simply names that point to objects, they do not contain those objects in any real way. When you pass arguments to a function, you're passing the underlying objects, not the names. The receiving function simply binds them to the names specified in the function signature - or, in your case, simply keeps them in args without giving them any names at all.

So, when you're asking how to get the names that objects had in a different scope, you can't ask the objects themselves. There probably is a way to do this, but it involves mucking about with inspecting calling frames, and I very much doubt you want to.

Eduardo Ivanec · Answer 4 · 2012-03-06T15:27:19.193

A solution using globals(). This will only work if the values are unique in the module scope, so it's fragile - if there are duplicates, it will choose the first name that points to that value, somewhat arbitrarily. And yes, you're probably better off not doing this anyway and rethinking the problem instead.

def f(*names):
    r = {}
    for n in names:
        r[[ name for name in globals() if globals()[name] is n ][0]] = n
    return r

T = 1.0
N = 20
L = 10

print f(T,N,L)
{'T': 1.0, 'L': 10, 'N': 20}

Silas Ray · Answer 5 · 2012-03-06T15:31:59.337

Yeah, as best I know, args is a list. To preserve label names, you'd need to pass a dict to **kwargs, and explicitly or programaticly set the names using local.

You could do something like:

def filter_locals(caller_locals, *args):
    filtered = {}
    for key in args:
        filtered[key] = caller_locals[key]
    return filtered

Then:

X = 1
Y = 2
func(filter_locals(locals(), 'X', 'Y')

Where func processes the arbitrary length list as kwargs.

score 0 · Answer 6 · answered Mar 06 '12 at 15:14

It'd be necessary to pass the keys and the values as separate arguments:

keys = ('T', 'N', 'L')
values = (1.0, 20, 10)
d = dict(zip(keys, values))

In your code, the line args = (T,N,L) evaluates to args = (1.0, 20, 10), the "names" of the variables T, N, L are replaced by their values.

Python: function that returns a dict whose keys are the names of the input arguments

6 Answers6

Linked