Single and double asterisks preceding variables in function arguments

[Stephen Boulet]

I've run across code like "myfunction(x, *someargs, **someotherargs)",
but haven't seen documentation for this.

Can someone fill me in on what the leading * and ** do? Thanks.

Stephen

[anton muhin]

Stephen Boulet wrote:

I've run across code like "myfunction(x, *someargs, **someotherargs)",
but haven't seen documentation for this.

Can someone fill me in on what the leading * and ** do? Thanks.

Stephen

See item 7.5 in Language Reference. In short: * declaries list of
additional parameters, while ** declares map of additional parameters.
Try somehting like:

def foo(*params): print params

and

def bar(**params): print params

to find out details.

regards,
anton.

[Duncan Booth]

anton muhin <an********@rambler.ru> wrote in news:bv3gdg$ms0sn$1@ID-
217427.news.uni-berlin.de:

Stephen Boulet wrote:

I've run across code like "myfunction(x, *someargs, **someotherargs)",
but haven't seen documentation for this.

Can someone fill me in on what the leading * and ** do? Thanks.

Stephen

See item 7.5 in Language Reference. In short: * declaries list of
additional parameters, while ** declares map of additional parameters.
Try somehting like:

def foo(*params): print params

and

def bar(**params): print params

to find out details.

I may be wrong, but I think the OP was asking about calling functions
rather than defining them. The '*' and '**' before arguments in function
calls are described in section 5.3.4 of the language reference but, so far
as I know, isn't explained clearly in any of the more 'user level' text.
There is a brief mention in the library reference under the documention of
'apply'.

In a call of the form:

myfunction(x, *someargs, **someotherargs)

the sequence 'someargs' is used to supply a variable number of additional
positional arguments. 'someotherargs' should be a dictionary and is used to
supply additional keyword arguments.

[Stephen Boulet]

anton muhin wrote:

Stephen Boulet wrote:

I've run across code like "myfunction(x, *someargs, **someotherargs)",
but haven't seen documentation for this.

Can someone fill me in on what the leading * and ** do? Thanks.

Stephen

See item 7.5 in Language Reference. In short: * declaries list of
additional parameters, while ** declares map of additional parameters.
Try somehting like:

def foo(*params): print params

and

def bar(**params): print params

to find out details.

regards,
anton.

<<
a={'c1':'red','c2':'blue','c3':'fusia'}
def bar(**params):
.....for k in params.keys():
.........print k, params[k]
bar(a)
Traceback (most recent call last):
File "<input>", line 1, in ?
TypeError: bar() takes exactly 0 arguments (1 given)

Why does bar take zero arguments?

Hmm, but:

<<
def bar2(*params,**moreparams):
.....print "params are ", params,'\n'
.....for k in moreparams.keys():
.........print k, moreparams[k]
.....print "moreparams are ", moreparams

bar2(range(3),a,)
params are ([0, 1, 2], {'c3': 'fusia', 'c2': 'blue', 'c1': 'red'})

moreparams are {}

I think I've got the *params argument down (you just get the whole
argument list), but I'm still not getting the **moreparams ...

Stephen

[Peter Otten]

Stephen Boulet wrote:

<<
a={'c1':'red','c2':'blue','c3':'fusia'}
def bar(**params):
....for k in params.keys():
........print k, params[k]
bar(a)
Traceback (most recent call last):
File "<input>", line 1, in ?
TypeError: bar() takes exactly 0 arguments (1 given)

>>
Why does bar take zero arguments?
The error message is not as clear as it should should be. bar() takes 0
mandatory, 0 positional and an arbitrary number of keyword arguments, e.
g.:

def bar(**params): .... print params
.... bar(color="blue", rgb=(0,0,1), name="sky") {'color': 'blue', 'rgb': (0, 0, 1), 'name': 'sky'}

That's the standard way of passing optional keyword arguments, but you can
also pass them as a dictionary preceded by **:
adict = {'color': 'blue', 'rgb': (0, 0, 1), 'name': 'sky'}
bar(**adict) {'color': 'blue', 'rgb': (0, 0, 1), 'name': 'sky'}

This is useful, if you want to compose the argument dict at runtime, or pass
it through to a nested function.

Hmm, but:

<<
def bar2(*params,**moreparams):
....print "params are ", params,'\n'
....for k in moreparams.keys():
........print k, moreparams[k]
....print "moreparams are ", moreparams

bar2() accepts 0 mandatory, as many positional and keyword arguments as you
like. For the expected result, try
def bar2(*args, **kwd): .... print args
.... print kwd
.... bar2(1,2,3) (1, 2, 3)
{} bar2(1, name="sky", color="blue") (1,) # tuple of optional positional args
{'color': 'blue', 'name': 'sky'} # dict of optional keyword args
And now a bogus example that shows how to compose the arguments:
def bar3(x, *args, **kwd): .... print "x=", x
.... print "args=", args
.... print "kwd=", kwd
.... if "terminate" not in kwd:
.... kwd["terminate"] = None # avoid infinite recursion
.... bar3(x*x, *args + ("alpha",), **kwd)
.... bar3(2, "beta", color="blue") x= 2
args= ('beta',)
kwd= {'color': 'blue'}
x= 4
args= ('beta', 'alpha')
kwd= {'color': 'blue', 'terminate': None}

To further complicate the matter, a mandatory arg may also be passed as a
keyword argument:

bar3(x=2, color="blue") # will work, args is empty
bar("beta", # will not work; both "beta" and 2 would be bound to x
# and thus create a conflict
x=2, color="blue")
Peter

[Eric Amick]

On Mon, 26 Jan 2004 09:51:02 -0600, Stephen Boulet
<stephendotboulet@motorola_._com> wrote:

I've run across code like "myfunction(x, *someargs, **someotherargs)",
but haven't seen documentation for this.

Can someone fill me in on what the leading * and ** do? Thanks.

Try section 4.7.2 of the tutorial.

--
Eric Amick
Columbia, MD

[Ben Finney]

On Mon, 26 Jan 2004 20:15:22 -0500, Eric Amick wrote:

Try section 4.7.2 of the tutorial.

Matter of fact, try the whole tutorial, beginning to end. It will
answer many questions you haven't thought of yet.

<http://www.python.org/doc/tut/>

--
\ "Those are my principles. If you don't like them I have |
`\ others." -- Groucho Marx |
_o__) |
Ben Finney <http://bignose.squidly.org/>

[Aahz]

In article <bv************@ID-217427.news.uni-berlin.de>,
anton muhin <an********@rambler.ru> wrote:

See item 7.5 in Language Reference. In short: * declaries list of
additional parameters, while ** declares map of additional parameters.

Actually, ``*`` forces creation of a tuple:

def foo(*bar): .... print type(bar)
.... l = [1,2,3]
foo(*l)

<type 'tuple'>
--
Aahz (aa**@pythoncraft.com) <*> http://www.pythoncraft.com/

"The joy of coding Python should be in seeing short, concise, readable
classes that express a lot of action in a small amount of clear code --
not in reams of trivial code that bores the reader to death." --GvR