Velocity Reviews - Computer Hardware Reviews

Velocity Reviews > Newsgroups > Programming > Python > Can someone give me a short explanation?

Reply
Thread Tools

Can someone give me a short explanation?

 
 
Senthoorkumaran Punniamoorthy
Guest
Posts: n/a
 
      04-05-2004
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


 
Reply With Quote
 
 
 
 
Peter Otten
Guest
Posts: n/a
 
      04-05-2004
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


 
Reply With Quote
 
 
 
 
Daniel Dittmar
Guest
Posts: n/a
 
      04-05-2004
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



 
Reply With Quote
 
Jacek Generowicz
Guest
Posts: n/a
 
      04-05-2004
"Senthoorkumaran Punniamoorthy" <(E-Mail Removed)> 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'".
 
Reply With Quote
 
88Pro
Guest
Posts: n/a
 
      04-06-2004
Thanks all of you explained me. Now I understand more clearly than every before.

Regards
Senthoor

"Daniel Dittmar" <(E-Mail Removed)> wrote in message news:<c4r8vb$rrj$(E-Mail Removed)-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

 
Reply With Quote
 
 
 
Reply

Thread Tools

Posting Rules
You may not post new threads
You may not post replies
You may not post attachments
You may not edit your posts

BB code is On
Smilies are On
[IMG] code is On
HTML code is Off
Trackbacks are On
Pingbacks are On
Refbacks are Off


Similar Threads
Thread Thread Starter Forum Replies Last Post
is ccsp difficult to pass? and can someone give it some comments about its worth? entrepreneur Cisco 0 07-31-2006 10:11 AM
Can someone tell me what might give me this error? - DAMN_ERROR.jpg (0/1) ohGr Computer Support 1 04-28-2004 01:13 PM
Re: Can someone tell me what might give me this error? - "DAMN_ERROR.jpg" 22.3 kBytes yEnc Ramzi Dalal Computer Support 3 04-28-2004 01:03 PM
can someone give me a little advice. Adam Schroeder C++ 2 09-11-2003 11:20 PM
It's the simple things that drive me crazy... Can someone peek at this short script? Christopher Javascript 0 08-07-2003 08:21 PM



Advertisments