Passing parameters using **kargs

[Thomas Philips]

I want to access parameters that are passed into a function using the
**kargs idiom. I define f(**kargs) via

def f(**kargs):
print kargs

[Peter Otten]

Thomas Philips wrote:

I want to access parameters that are passed into a function using the
**kargs idiom. I define f(**kargs) via

def f(**kargs):
print kargs
.
.

the keyword arguments are converted to a dictionary, so that if I type
f(a=1, b=2, c=3)

the function prints
{'a': 1, 'b': 2, 'c':3}

Now assume the function has three variables a, b and c to which I want
to assign the dictionary's values of 'a', 'b' and 'c'. How can I
assign kargs['a'] to a, kargs['b'] to b, and kargs['c'] to c. Should I
be trying to construct a string representation of each variable's name
and using that as a key, or am I just thinking about this the wrong
way?

How about

def f(a=None, b=None, c=None, **moreargs): .... print locals()
.... f(x=22, b=99) {'moreargs': {'x': 22}, 'a': None, 'c': None, 'b': 99}

Peter

[Duncan Booth]

tk****@hotmail.com (Thomas Philips) wrote in
news:b4**************************@posting.google.c om:

I want to access parameters that are passed into a function using the
**kargs idiom. I define f(**kargs) via

def f(**kargs):
print kargs
.
.

the keyword arguments are converted to a dictionary, so that if I type
f(a=1, b=2, c=3)

the function prints
{'a': 1, 'b': 2, 'c':3}

Now assume the function has three variables a, b and c to which I want
to assign the dictionary's values of 'a', 'b' and 'c'. How can I
assign kargs['a'] to a, kargs['b'] to b, and kargs['c'] to c. Should I
be trying to construct a string representation of each variable's name
and using that as a key, or am I just thinking about this the wrong
way?

If the function is to have three variables a, b, and c, then you do this:

def f(a=None, b=None, c=None, **kargs):
... whatever ...

(substitute whatever defaults you want for those variables)

The ** argument is for keyword arguments where you don't know in advance
all the keywords that might be valid. Obviously, if you don't know the name
in advance then there is no point to setting a variable of the same name
since you would have to go through pointless contortions to access it.
If you do know some names of interest in advance then make them arguments
with default values and only use the ** form for the remaining arguments.

[Terry Reedy]

"Duncan Booth"

Thomas Philips) >

I want to access parameters that are passed into a function using the
**kargs idiom. I define f(**kargs) via

def f(**kargs):
print kargs

The ** argument is for keyword arguments where you don't know in advance
all the keywords that might be valid.

Or if you don't care, or want to intercept invalid calls. Interestingly,
the OP's example is the beginning of a possible debug wrapper usage where
one either does not have a function's code or does not want to modify it
directly. Possible example:

_f_orig = f
def f(*largs, **kargs):
print 'f called with' largs, 'and', kargs
f(*largs, **kargs)

Terry J. Reedy

[Fuzzyman]

tk****@hotmail.com (Thomas Philips) wrote in message news:<b4**************************@posting.google. com>...

I want to access parameters that are passed into a function using the
**kargs idiom. I define f(**kargs) via

def f(**kargs):
print kargs
.
.

the keyword arguments are converted to a dictionary, so that if I type
f(a=1, b=2, c=3)

the function prints
{'a': 1, 'b': 2, 'c':3}

Now assume the function has three variables a, b and c to which I want
to assign the dictionary's values of 'a', 'b' and 'c'. How can I
assign kargs['a'] to a, kargs['b'] to b, and kargs['c'] to c. Should I
be trying to construct a string representation of each variable's name
and using that as a key, or am I just thinking about this the wrong
way?

Thomas Philips

MY reading of what you say is - I have three variable a, b and c.. and
a dictionary, kargs, with keys 'a', 'b' anc 'c'. I want to assign the
contents of kargs to the three variables. The specific case is surely
? :
a = kargs['a']
b = kargs['b']
c = kargs['c']

or is it the more general case you're after ?
I think I'm misunderstanding you I'm afraid....

Fuzzyman

http://www.voidspace.org.uk/atlantib...thonutils.html

[Larry Bates]

Since kargs is a regular dictionary variable,
you can reference the variables you want with
kargs.get('<variablename>', None)

example

kargs.get('a', None) will return value of
keyword argument a or None if 'a' doesn't
exist.

If you are sure of what will exist you can just
use kargs['a'], but then you could more easily
do f(a=None, **kargs) in that case.

kargs.keys() will give you the names of the
keyword arguments if you want them.

No real reason to put them anywhere else that I
can see.

HTH,
Larry Bates

"Thomas Philips" <tk****@hotmail.com> wrote in message
news:b4**************************@posting.google.c om...

I want to access parameters that are passed into a function using the
**kargs idiom. I define f(**kargs) via

def f(**kargs):
print kargs
.
.

the keyword arguments are converted to a dictionary, so that if I type
f(a=1, b=2, c=3)

the function prints
{'a': 1, 'b': 2, 'c':3}

Now assume the function has three variables a, b and c to which I want
to assign the dictionary's values of 'a', 'b' and 'c'. How can I
assign kargs['a'] to a, kargs['b'] to b, and kargs['c'] to c. Should I
be trying to construct a string representation of each variable's name
and using that as a key, or am I just thinking about this the wrong
way?

Thomas Philips

[Mel Wilson]

In article <b4**************************@posting.google.com >,
tk****@hotmail.com (Thomas Philips) wrote:

I want to access parameters that are passed into a function using the
**kargs idiom. I define f(**kargs) via

def f(**kargs):
print kargs
.
.

the keyword arguments are converted to a dictionary, so that if I type
f(a=1, b=2, c=3)

the function prints
{'a': 1, 'b': 2, 'c':3}

Now assume the function has three variables a, b and c to which I want
to assign the dictionary's values of 'a', 'b' and 'c'. How can I
assign kargs['a'] to a, kargs['b'] to b, and kargs['c'] to c. Should I
be trying to construct a string representation of each variable's name
and using that as a key, or am I just thinking about this the wrong
way?

I don't understand. Isn't this it:

Python 2.3 (#46, Jul 29 2003, 18:54:32) [MSC v.1200 32 bit (Intel)] on win32
Type "help", "copyright", "credits" or "license" for more information.

kargs={'a':1, 'b':2, 'c':3}
def r(a, b, c): .... print a, b, c
.... r(**kargs)

1 2 3
Use of keyword arguments doesn't NEED to be part of the
function definition.

Regards. Mel.

[Aahz]

In article <ma*************************************@python.or g>,
Terry Reedy <tj*****@udel.edu> wrote:

Or if you don't care, or want to intercept invalid calls. Interestingly,
the OP's example is the beginning of a possible debug wrapper usage where
one either does not have a function's code or does not want to modify it
directly. Possible example:

_f_orig = f
def f(*largs, **kargs):
print 'f called with' largs, 'and', kargs
f(*largs, **kargs)

You mean

_f_orig(*largs, **kargs)

I prefer this version:

def debugParams(func):
def debugger(*args, **kwargs):
for arg in args:
print type(arg), arg
for name in kwargs:
value = kwargs[name]
print name, type(value), value
return func(*args, **kwargs)
return debugger

f = debugParams(f)
--
Aahz (aa**@pythoncraft.com) <*> http://www.pythoncraft.com/

"as long as we like the same operating system, things are cool." --piranha

[Terry Reedy]

"Aahz" <aa**@pythoncraft.com> wrote in message
news:ca**********@panix1.panix.com...

_f_orig = f
def f(*largs, **kargs):
print 'f called with' largs, 'and', kargs
f(*largs, **kargs)
You mean

_f_orig(*largs, **kargs)

Of course. Silly 'rushing out the door' mistake.
I prefer this version:

def debugParams(func):
def debugger(*args, **kwargs):
for arg in args:
print type(arg), arg
for name in kwargs:
value = kwargs[name]
print name, type(value), value
return func(*args, **kwargs)
return debugger

f = debugParams(f)

So do I, for its elaboration, factorization, and closure. I am saving it.

Terry J. Reedy