Can someone give me a short explanation?

Discussion in 'Python' started by Senthoorkumaran Punniamoorthy, Apr 5, 2004.

  1. 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
    Senthoorkumaran Punniamoorthy, Apr 5, 2004
    #1
    1. Advertising

  2. Senthoorkumaran Punniamoorthy

    Peter Otten Guest

    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
    Peter Otten, Apr 5, 2004
    #2
    1. Advertising

  3. 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
    Daniel Dittmar, Apr 5, 2004
    #3
  4. "Senthoorkumaran Punniamoorthy" <> 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'".
    Jacek Generowicz, Apr 5, 2004
    #4
  5. Senthoorkumaran Punniamoorthy

    88Pro Guest

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

    Regards
    Senthoor

    "Daniel Dittmar" <> wrote in message news:<c4r8vb$rrj$-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
    88Pro, Apr 6, 2004
    #5
    1. Advertising

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

It takes just 2 minutes to sign up (and it's free!). Just click the sign up button to choose a username and then you can ask your own questions on the forum.
Similar Threads
  1. Adam Schroeder

    can someone give me a little advice.

    Adam Schroeder, Sep 11, 2003, in forum: C++
    Replies:
    2
    Views:
    330
    Govindan
    Sep 12, 2003
  2. dotNeter
    Replies:
    5
    Views:
    409
    Default User
    Aug 3, 2006
  3. Rivka Miller

    Can someone give me an example of the SNAME type ?

    Rivka Miller, Jun 30, 2010, in forum: C Programming
    Replies:
    1
    Views:
    271
    Rivka Miller
    Jul 1, 2010
  4. Christopher
    Replies:
    0
    Views:
    88
    Christopher
    Aug 7, 2003
  5. fl
    Replies:
    7
    Views:
    179
Loading...

Share This Page