Can someone give me a short explanation?

  • Thread starter Senthoorkumaran Punniamoorthy
  • Start date
S

Senthoorkumaran Punniamoorthy

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
 
P

Peter Otten

Senthoorkumaran said:
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
 
D

Daniel Dittmar

Senthoorkumaran said:
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
 
J

Jacek Generowicz

Senthoorkumaran Punniamoorthy said:
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'".
 
8

88Pro

Thanks all of you explained me. Now I understand more clearly than every before.

Regards
Senthoor

Daniel Dittmar said:
Senthoorkumaran said:
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
 

Ask a Question

Want to reply to this thread or ask your own question?

You'll need to choose a username for the site, which only take a couple of moments. After that, you can post your question and our members will help you out.

Ask a Question

Members online

No members online now.

Forum statistics

Threads
473,743
Messages
2,569,478
Members
44,899
Latest member
RodneyMcAu

Latest Threads

Top