# How does this work?

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

1. ### GuestGuest

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

2. ### Jon ClementsGuest

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']

>
>
> 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`.
>
>             aram seq: The sequence to split.
>             aram slicesize: The maximum size of each slice.
>             aram 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