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

[Brad Martsberger]

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
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.python.org/pipermail/chicago/attachments/20160216/3332da71/attachment.html>