How does this work?

[Ben Finney]

<jyoung79 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-into-evenly-sized-chunks-in-python/312644)

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