How does this work?

Discussion in 'Python' started by Guest, Jun 4, 2011.

  1. Guest

    Guest Guest

    I was surfing around looking for a way to split a list into equal sections. I came
    upon this algorithm:

    >>> f = lambda x, n, acc=[]: f(x[n:], n, acc+[(x[:n])]) if x else acc
    >>> f("Hallo Welt", 3)

    ['Hal', 'lo ', 'Wel', 't']

    (http://stackoverflow.com/questions/...ist-into-evenly-sized-chunks-in-python/312644)

    It doesn't work with a huge list, but looks like it could be handy in certain
    circumstances. I'm trying to understand this code, but am totally lost. I
    know a little bit about lambda, as well as the ternary operator, but how
    does this part work:

    >>> f('dude'[3:], 3, []+[('dude'[:3])])

    ['dud', 'e']

    Is that some sort of function call, or something else? I'm guessing it works
    recursively?

    Just curious if anyone could explain how this works or maybe share a link
    to a website that might explain this?

    Thanks.

    Jay
    Guest, Jun 4, 2011
    #1
    1. Advertising

  2. Guest

    Jon Clements Guest

    On Jun 5, 4:37 am, Ben Finney <> wrote:
    > <> writes:
    > > I was surfing around looking for a way to split a list into equal
    > > sections. I came upon this algorithm:

    >
    > > >>> f = lambda x, n, acc=[]: f(x[n:], n, acc+[(x[:n])]) if x else acc
    > > >>> f("Hallo Welt", 3)

    > > ['Hal', 'lo ', 'Wel', 't']

    >
    > > (http://stackoverflow.com/questions/312443/how-do-you-split-a-list-int....)

    >
    > This is an excellent example of why “clever” code is to be shunned.
    > Whoever wrote this needs to spend more time trying to get their code
    > past a peer review; the above would be rejected until it was re-written
    > to be clear.
    >
    > Here is my attempt to write the above to be clear (and fixing a couple
    > of bugs too):
    >
    >     def split_slices(seq, slicesize, accumulator=None):
    >         """ Return a list of slices from `seq` each of size `slicesize`.
    >
    >             :param seq: The sequence to split.
    >             :param slicesize: The maximum size of each slice.
    >             :param accumulator: A sequence of existing slicesto which
    >                 ours should be appended.
    >             :return: A list of the slices. Each item will be a slice
    >                 from the original `seq` of `slicesize` length; the last
    >                 item may be shorter if there were fewer than `slicesize`
    >                 items remaining.
    >
    >             """
    >         if accumulator is None:
    >             accumulator = []
    >         if seq:
    >             slice = seq[:slicesize]
    >             result = split_slices(
    >                 seq[slicesize:], slicesize, accumulator +[slice])
    >         else:
    >             result = accumulator
    >         return result
    >
    > > It doesn't work with a huge list, but looks like it could be handy in
    > > certain circumstances. I'm trying to understand this code, but am
    > > totally lost. I know a little bit about lambda, as well as the ternary
    > > operator

    >
    > In Python, ‘lambda’ is merely an alternative syntax for creating
    > function objects. The resulting object *is* a function, so I've written
    > the above using the ‘def’ syntax for clarity.
    >
    > The ternary operator is often useful for very simple expressions, but
    > quickly becomes too costly to read when the expression is complex. The
    > above is one where the writer is so much in love with the ternary
    > operator that they have crammed far too much complexity into a single
    > expression.
    >
    > > Just curious if anyone could explain how this works or maybe share a link
    > > to a website that might explain this?

    >
    > Does the above help?
    >
    > --
    >  \       “We must find our way to a time when faith, without evidence, |
    >   `\    disgraces anyone who would claim it.” —Sam Harris, _TheEnd of |
    > _o__)                                                    Faith_, 2004 |
    > Ben Finney


    Just my 2p, but isn't the itertools "grouper" recipe prudent?
    Jon Clements, Jun 5, 2011
    #2
    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. TB
    Replies:
    2
    Views:
    3,733
  2. Alek Nazarian
    Replies:
    7
    Views:
    3,222
    Alek Nazarian
    Oct 22, 2003
  3. Nick L
    Replies:
    10
    Views:
    590
    Jerry Coffin
    Aug 31, 2004
  4. Vineet Jain
    Replies:
    9
    Views:
    446
    Fredrik Lundh
    Apr 16, 2004
  5. jblazi
    Replies:
    5
    Views:
    427
    jblazi
    Aug 16, 2004
Loading...

Share This Page