Velocity Reviews

Velocity Reviews (http://www.velocityreviews.com/forums/index.php)
-   Python (http://www.velocityreviews.com/forums/f43-python.html)
-   -   Can someone give me a short explanation? (http://www.velocityreviews.com/forums/t329575-can-someone-give-me-a-short-explanation.html)

Senthoorkumaran Punniamoorthy 04-05-2004 08:34 AM

Can someone give me a short explanation?
 
I found this code in the book text processing with Python. But having little
difficulty understanding how exactly it works and what should be passed as
argument? Can someone decode this for me please?

apply_each = lambda fns, args=[]: map(apply, fns, [args]*len(fns))

Senthoor

__________________________________________________ _______________
STOP MORE SPAM with the new MSN 8 and get 2 months FREE*
http://join.msn.com/?page=features/junkmail



Peter Otten 04-05-2004 09:20 AM

Re: Can someone give me a short explanation?
 
Senthoorkumaran Punniamoorthy wrote:

> I found this code in the book text processing with Python. But having
> little difficulty understanding how exactly it works and what should be
> passed as argument? Can someone decode this for me please?
>
> apply_each = lambda fns, args=[]: map(apply, fns, [args]*len(fns))


This can be rewritten to (untested):

def apply_each(fns, args=[]):
return map(apply, fns, [args]*len(fns))

Now we see that the intermediate list containing args len(fns) times, i. e.
once for every function passed in fns is superfluous:

def apply_each(fns, args=[])
return map(lambda f: apply(f, args), fns)

or written in modern style:

def apply_each(fns, args=[]):
return [f(*args) for f in fns]

It should be clear by now what this does: Call each function in the fns
sequence with the items in args as arguments, the default being no
arguments. Note that I find the list comprehension so readable that I'd be
tempted to put it literally into my code; so in a way we are back at the
beginning - only much better :-)

Peter



Daniel Dittmar 04-05-2004 09:30 AM

Re: Can someone give me a short explanation?
 
Senthoorkumaran Punniamoorthy wrote:
> I found this code in the book text processing with Python. But having
> little difficulty understanding how exactly it works and what should
> be passed as argument? Can someone decode this for me please?
>
> apply_each = lambda fns, args=[]: map(apply, fns, [args]*len(fns))


def apply_each (fns, args = []):
return map (apply, fns, [args]*len(fns))

map(...)
map(function, sequence[, sequence, ...]) -> list

Return a list of the results of applying the function to the items of
the argument sequence(s). If more than one sequence is given, the
function is called with an argument list consisting of the corresponding
item of each sequence, substituting None for missing values when not all
sequences have the same length. If the function is None, return a list
of
the items of the sequence (or a list of tuples if more than one
sequence).

so apply_each ([func1, func2, func3], [arg1, arg2])
is the same as
[func1 (arg1, arg2), func2 (arg1, arg2), func3 (arg1, arg)]

or using list comprehension
[func (arg1, arg2) for func in [func1, func2, func3])

Daniel




Jacek Generowicz 04-05-2004 09:30 AM

Re: Can someone give me a short explanation?
 
"Senthoorkumaran Punniamoorthy" <solution88pro@hotmail.com> writes:

> I found this code in the book text processing with Python. But having
> little difficulty understanding how exactly it works and what should
> be passed as argument? Can someone decode this for me please?
>
>
> apply_each = lambda fns, args=[]: map(apply, fns, [args]*len(fns))



"map" is a builtin which applies its first argument (which should be a
function[*]) to the elements coming out of the sequences which are passed
to it as arguments 2,3, ... N, and collects all the results in a list,
which it returns.
[*] Where I say "function" in any of this, I should really be saying
"callable". If you don't know what this means, ignore it. Not
important.

In this case, the first argument of "map" is "apply". "apply" is a
builtin which takes a function as its first argument, and applies it
to whatever is in the sequence that is its second argument. (It also
has the ability to deal with keyword args, but forget those for now.)

Take in for granted, for now, that "args" in "[args]*len(fns)" refers
to an empty list. In which case "[args]*len(fns)" creates a list of
empty lists, whose length is equal to the length of the sequence
"fns".

Take it for granted, for now, that "fns" is a sequence of
functions. So, "map(apply, fns, [args]*len(fns))" calls the first
function in the "fns" (giving it no arguments) and remembers the
result, then it calls the next function in "fns" (with no args), and
so on ... then it returns all the results.

Now, "lambda" is a way of creating anonymous functions. You could
created "apply_each" like this:

def apply_each(fns, args=[]):
return map(apply, fns, [args]*len(fns))

So, "apply_each" is basically a function, which takes a sequence of
functions, calls them all, and returns all the results in a list.

Let's define a few simple functions, which take no arguments and
return something ... and pass them to apply_each

>>> apply_each = lambda fns, args=[]: map(apply, fns, [args]*len(fns))
>>> def one(): return "one"

....
>>> def two(): return "two"

....
>>> def three(): return "three"

....
>>> apply_each([one,two,three])

['one', 'two', 'three']
>>>


Now, you could pass a second argument to "apply_args", in which case
it should be a sequence, and the elements of the sequence would be
used as the arguments in each of the calls to the functions you pass.


Without seeing the broader context in which the original appears, it's
difficult to say why it was defined the way it was. Nowadays, I
suspect that many Pythoneers would prefer something like

def apply_each(fns, args=[]):
return [ fn(*args) for fn in fns ]

- The stuff appearing after "return" is a List Comprehension.

- The "*" in "fn(*args") means "args is a sequence: pass its contents as
separate arguments to 'fn'".

88Pro 04-06-2004 01:48 AM

Re: Can someone give me a short explanation?
 
Thanks all of you explained me. Now I understand more clearly than every before.

Regards
Senthoor

"Daniel Dittmar" <daniel.dittmar@sap.com> wrote in message news:<c4r8vb$rrj$1@news1.wdf.sap-ag.de>...
> Senthoorkumaran Punniamoorthy wrote:
> > I found this code in the book text processing with Python. But having
> > little difficulty understanding how exactly it works and what should
> > be passed as argument? Can someone decode this for me please?
> >
> > apply_each = lambda fns, args=[]: map(apply, fns, [args]*len(fns))

>
> def apply_each (fns, args = []):
> return map (apply, fns, [args]*len(fns))
>
> map(...)
> map(function, sequence[, sequence, ...]) -> list
>
> Return a list of the results of applying the function to the items of
> the argument sequence(s). If more than one sequence is given, the
> function is called with an argument list consisting of the corresponding
> item of each sequence, substituting None for missing values when not all
> sequences have the same length. If the function is None, return a list
> of
> the items of the sequence (or a list of tuples if more than one
> sequence).
>
> so apply_each ([func1, func2, func3], [arg1, arg2])
> is the same as
> [func1 (arg1, arg2), func2 (arg1, arg2), func3 (arg1, arg)]
>
> or using list comprehension
> [func (arg1, arg2) for func in [func1, func2, func3])
>
> Daniel



All times are GMT. The time now is 07:33 PM.

Powered by vBulletin®. Copyright ©2000 - 2014, vBulletin Solutions, Inc.
SEO by vBSEO ©2010, Crawlability, Inc.