How does this work?

[Jon Clements]

On Jun 5, 4:37 am, Ben Finney <ben+pyt... at benfinney.id.au> wrote:
> <jyoun... at kc.rr.com> 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 slices to 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, _The End of |
> _o__)                                                     Faith_, 2004 |
> Ben Finney

Just my 2p, but isn't the itertools "grouper" recipe prudent?