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

Lewit, Douglas d-lewit at neiu.edu
Wed Feb 17 22:30:08 EST 2016


Hi Mark,

Thanks for those links.  Yes, Linus Torvalds is quite a legend in his own
time.  I'll be content to become 1% of the programmer that he is!   :-)

My original question was simple, "*Does Python have a builtin function for
flattening lists?*"  It was a very simple question that provoked a very
strange and hostile thread!  I'm not sure why that is.  Anyhow, someone
mentioned *itertools.chain( )*.  Can someone provide a concrete example of
how that function works?  Or is that question inappropriate?  And please,
I'm just asking about itertools.chain( ).  I am not asking for any other
type of reply, okay?  Thank you.



On Wed, Feb 17, 2016 at 2:52 PM, Mark Graves <mgraves87 at gmail.com> wrote:

> I don't mean to be argumentative or add to this discussion in a negative
> way.
>
> Could we have a little direction from a higher up around the code of
> conduct here?  For reference, this is the only one I found:
>
> http://www.chipy.org/pages/conduct/
>
> I am in support of Doug asking his questions and agree with Adam on this.
> I've met Doug, and sometimes his humor is lost on people through the
> mailing list.  If you are bothered, you can always create an email filter.
>
> FWIW, imagine if the developer at the top of this list had been
> discouraged from asking questions about his "unusual" implementation?
>
>
> https://groups.google.com/forum/#!msg/comp.os.minix/dlNtH7RRrGA/SwRavCzVE7gJ
>
> https://groups.google.com/forum/#!topic/comp.os.minix/wlhw16QWltI%5B1-25%5D
>
>
>
>
>
>
> On Wed, Feb 17, 2016 at 11:50 AM, Mike Tamillow <
> mikaeltamillow96 at gmail.com> wrote:
>
>> Yeah, but I generally agree that this list shouldn't be used for help
>> with personal programming problems. There is a website called stack
>> overflow as well as much documentation that can be consulted for this.
>>
>> What I like best is when messages come out exposing me to some open
>> source tool I have yet to hear about that may be useful.
>>
>> I'm sure there's other great discussions but I don't think code by email
>> is quite a good thing to send out to hundreds of people.
>>
>> Sent from my iPhone
>>
>> On Feb 17, 2016, at 10:05 AM, Adam Forsyth <adam at adamforsyth.net> wrote:
>>
>> 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
>>>
>>>
>> _______________________________________________
>> 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/d7ccfdf9/attachment.html>


More information about the Chicago mailing list