Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]

Groups > comp.lang.python > #7032 > unrolled thread

How does this work?

Back to article view | Back to comp.lang.python

Contents

  How does this work? <jyoung79@kc.rr.com> - 2011-06-04 01:51 +0000
    Re: How does this work? Ben Finney <ben+python@benfinney.id.au> - 2011-06-05 13:37 +1000
      Re: How does this work? Jon Clements <joncle@googlemail.com> - 2011-06-04 23:32 -0700
        Re: How does this work? Ben Finney <ben+python@benfinney.id.au> - 2011-06-05 16:49 +1000

#7032 — How does this work?

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)

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

[toc] | [next] | [standalone]

#7033

<jyoung79@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

[toc] | [prev] | [next] | [standalone]

#7035

On Jun 5, 4:37 am, Ben Finney <ben+pyt...@benfinney.id.au> wrote:
> <jyoun...@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?

[toc] | [prev] | [next] | [standalone]

#7036

Jon Clements <joncle@googlemail.com> writes:

> On Jun 5, 4:37 am, Ben Finney <ben+pyt...@benfinney.id.au> wrote:
> > <jyoun...@kc.rr.com> writes:
> > > (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):

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

Oh, if we go looking for ways to improve what that code is doing, there
are many things wrong with it, not least that it is re-implementing code
that already exists in the standard library.

But I'll leave that to the several superior answers at the Stackoverflow
question.

-- 
 \       “Pray, v. To ask that the laws of the universe be annulled in |
  `\     behalf of a single petitioner confessedly unworthy.” —Ambrose |
_o__)                           Bierce, _The Devil's Dictionary_, 1906 |
Ben Finney

[toc] | [prev] | [standalone]

Back to top | Article view | comp.lang.python

csiph-web