[Chicago] Resolving lists within lists within lists within .....

Adam Forsyth adam at adamforsyth.net
Wed Feb 17 11:05:59 EST 2016


Hey everyone,

Please remember that intentions can be hard to judge on the mailing list.
I've met Douglas in person and he's a nice guy. Please don't assign motives
just because there are issues communicating.

Adam Forsyth
Sponsorship Director, ChiPy


On Wed, Feb 17, 2016 at 10:02 AM, Chris Foresman <foresmac at gmail.com> wrote:

> Honestly, Douglas, you come to the list all the time asking for help or
> opinions and then you precede to generally be a jerk to people that respond
> to you. The fact is your solution is sloppy, confusing, and doesn’t work at
> least as far as you originally explained it was supposed to work. Brad
> pointed all this out and suggested a vastly better alternative, and did so
> in an extremely polite way. Your response was just acerbic and doltish.
> Please consider either accepting constructive criticism with humility or
> just stop asking for help.
>
>
> Regards,
> Chris Foresman
> chris at chrisforesman.com
>
>
>
> On Feb 16, 2016, at 10:44 PM, Lewit, Douglas <d-lewit at neiu.edu> wrote:
>
> Use flattenAgain.... which calls flatten repeatedly until there's no
> change in the list.  You have to use BOTH functions!
>
> Sarcasm?  What's that?
>
>
> On Tue, Feb 16, 2016 at 10:37 PM, Brad Martsberger <
> bradley.marts at gmail.com> wrote:
>
>> Douglas, I don't know if that was supposed to be sarcastic or what.
>>
>> In fact, your code does not work.
>>
>> >>> flatten([[[1, 2], 3], 4])
>> [[1, 2], 3, 4]
>>
>> Looks like it fails to fully flatten the list.
>>
>> I assumed from your original email you were interested in other
>> approaches, so I gave one that looks to me like it's much less complex (no
>> need for try/except, no need for indexing, 1 recursive call instead of 3).
>> Less complex code is usually easier to reason about and less prone to bugs.
>>
>> In purely functional languages there is no for loop, so if you want to
>> iterate over a list, you have to do it with recursive function calls.
>> Recursion stops when there's nothing left in the list, so the base case is
>> the empty list. Since iterating over a list is so common in programming, it
>> can start to feel like this is the way recursion and lists go together.
>>
>> But a good rule of thumb is only good if it doesn't trip you up when you
>> com across an exception to the rule. In the problem of flattening a list,
>> the recursion is down the depth of nesting, not across the list. In this
>> case, you can stop flattening when you hit a non-list object, so that's
>> your base case.
>>
>> Brad
>>
>> On Tue, Feb 16, 2016 at 2:50 PM, Lewit, Douglas <d-lewit at neiu.edu> wrote:
>>
>>> Whether it looks pythonic or not Joshua, it works!  Try it before you
>>> criticize it!!!   ;-)   In implementing recursive functions on lists, one
>>> of the base cases is almost always whether the list is empty or not.  A
>>> little lesson I learned from studying lists in Haskell and Ocaml.  Hard
>>> languages for sure, but they made me a stronger programmer when it comes to
>>> the dreaded "R" ( Recursion ).   ;-)
>>>
>>>
>>> On Tue, Feb 16, 2016 at 1:13 PM, Brad Martsberger <
>>> bradley.marts at gmail.com> wrote:
>>>
>>>> > you can get almost there with itertools.chain.from_iterable
>>>>
>>>> It's tempting, but it fails in a lot of ways. It successfully flattens
>>>> a list of lists, but doesn't go any deeper than that and fails completely
>>>> on a list composed of some lists and some non-list objects. You can also
>>>> get the same behavior out of a list comprehension.
>>>>
>>>> Douglas, you have written a recursive function, but I think you've
>>>> missed on what the base case is. The base case is not whether or not you've
>>>> been passed an empty list, but rather whether an element is a list or not
>>>> (if it's not, you don't need any further flattening. Also, all those
>>>> indices don't look very pythonic.
>>>>
>>>> Here is a recursive flatten function that will handle any depth and
>>>> mixed depths at different elements (no indexing required)
>>>>
>>>> def flatten(lst):
>>>>     new_list = []
>>>>     for element in lst:
>>>>         if isinstance(element, list):
>>>>             new_list.extend(flatten(element))
>>>>         else:
>>>>             # This is the base case where the recursion ends
>>>>             new_list.append(element)
>>>>
>>>>     return new_list
>>>>
>>>> >>> flatten([[1, 1.1], 2, 3, [4, 5, [6, 7, 8]]])
>>>> [1, 1.1, 2, 3, 4, 5, 6, 7, 8]
>>>>
>>>> On Mon, Feb 15, 2016 at 9:09 PM, Joshua Herman <
>>>> zitterbewegung at gmail.com> wrote:
>>>>
>>>>> The idea of flattening a object or datatype is a functional
>>>>> programming technique and not just a part of Ruby and Mathematica According
>>>>> to this answer on the programming stack exchange there is no method /
>>>>> function that implements flatten for build in Python functions but you can
>>>>> get almost there with itertools.chain.from_iterable . See
>>>>> http://programmers.stackexchange.com/questions/254279/why-doesnt-python-have-a-flatten-function-for-lists
>>>>> .
>>>>>
>>>>> On Feb 15, 2016, at 4:12 PM, Lewit, Douglas <d-lewit at neiu.edu> wrote:
>>>>>
>>>>> Hi everyone,
>>>>>
>>>>> Well it's President's Day and I've got the day off!  Hooray!!!
>>>>> Finally some time to just relax and mess around.  So I'm at my computer
>>>>> playing around with Python and wondering how to resolve the issue of
>>>>> multiple lists embedded within other lists.  I came up with two functions
>>>>> that I think solve the problem.  But I was wondering if Guido or someone
>>>>> else added a builtin function or method that does this automatically for
>>>>> the programmer.  Or is there an easier way?  Okay.... thanks.  ( In case
>>>>> you're wondering why I called the function "flatten" it's because I know
>>>>> from experience that Wolfram Mathematica and Ocaml have these "flatten"
>>>>> functions.  I think Ruby has something similar, but I haven't played with
>>>>> Ruby in a while so I'm not really sure. )  The try: except block is
>>>>> important because you can't subscript non-list data structures in Python.
>>>>> The IndexError is what you get when you try to index an empty list.  So I
>>>>> ****think**** my try: except block covers most commonly encountered
>>>>> exceptions when working with lists embedded within other lists.
>>>>>
>>>>> Best,
>>>>>
>>>>> Douglas.
>>>>>
>>>>> def flatten(lst):
>>>>> if lst == [ ]:
>>>>> return lst
>>>>> else:
>>>>> try:
>>>>> return [lst[0][0]] + flatten(lst[0][1:] + lst[1:])
>>>>> except TypeError:
>>>>> return [lst[0]] + flatten(lst[1:])
>>>>> except IndexError:
>>>>> return flatten(lst[1:])
>>>>>
>>>>> def flattenAgain(lst):
>>>>> newList = lst[:]
>>>>> while newList != flatten(newList):
>>>>> newList = flatten(newList)
>>>>> return newList
>>>>>
>>>>>
>>>>> _______________________________________________
>>>>> Chicago mailing list
>>>>> Chicago at python.org
>>>>> https://mail.python.org/mailman/listinfo/chicago
>>>>>
>>>>>
>>>>>
>>>>> _______________________________________________
>>>>> Chicago mailing list
>>>>> Chicago at python.org
>>>>> https://mail.python.org/mailman/listinfo/chicago
>>>>>
>>>>>
>>>>
>>>> _______________________________________________
>>>> Chicago mailing list
>>>> Chicago at python.org
>>>> https://mail.python.org/mailman/listinfo/chicago
>>>>
>>>>
>>>
>>> _______________________________________________
>>> Chicago mailing list
>>> Chicago at python.org
>>> https://mail.python.org/mailman/listinfo/chicago
>>>
>>>
>>
>> _______________________________________________
>> Chicago mailing list
>> Chicago at python.org
>> https://mail.python.org/mailman/listinfo/chicago
>>
>>
> _______________________________________________
> Chicago mailing list
> Chicago at python.org
> https://mail.python.org/mailman/listinfo/chicago
>
>
>
> _______________________________________________
> Chicago mailing list
> Chicago at python.org
> https://mail.python.org/mailman/listinfo/chicago
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.python.org/pipermail/chicago/attachments/20160217/666018a4/attachment.html>


More information about the Chicago mailing list