[Tutor] Basic Question

[Osmaan Mysorewala]

Thank you so much for your help Mr. Simpson. I understand why what I used
doesn’t work and I understand the fix.

A followup question for Mr. Wichmann, I've heard that global variables are
not great, and I see that you wrote some pseduocode on how to fix it. Still
I don't really understand how to implement that in my code. Everytime I
tried using local variables to store the arrays, it gave the error "local
variable referenced before assignment". If possible, do you think you could
go into a bit more depth on how it would work?

One more question. In my get_neighbors function I use a terrible
if-statement spam, how would I go about replacing that?

On Thu, Sep 9, 2021 at 12:58 PM Mats Wichmann <mats at wichmann.us> wrote:

> On 9/9/21 12:50 AM, Osmaan Mysorewala via Tutor wrote:
> > Hello,
> >
> > I'm trying to write a python program to create the game of life (Here's
> the
> > wikipedia link to how the game of life works:
> > https://en.wikipedia.org/wiki/Conway%27s_Game_of_Life). Right now it
> works
> > only for the first iteration but then the new_arr becomes something
> > completely wrong the second time I run the function. I think something is
> > logically wrong with the neighbors function (other than how badly the
> > if-statements are written). For reference, I'm eventually trying to put
> it
> > on a display so that's why there's some display stuff in the comments
> > there. Here's the code:
>
> As you work through the jobs of collections full of mutable objects,
> shallow and deep copies, etc - and this is definitely part of the Python
> learning experience, and a trap not just for beginners at Python,
> experienced heads get into trouble too - here are some other things you
> might think about:
>
> There's not really a good reason to use a pair of globals to store two
> generations of the Conway "board".  The use of globals is frowned upon
> in many cases just because it's so easy to get into trouble keeping
> track of what the state of things is.  Instead, you could think of a
> flow like this:
>
> def main():
>      # do setup things - figure out boundaries, #generatrions, etc.
>      # create first generation datastructure
>      # loop for generations:
>      #    board = advance(board)
>      #    optionally call a board-printing routine
>      #    (if you have a need to print, good idea to separate out the
> logic)
>
> def advance(obj):
>      # calculate the next generation from obj
>      return newobj
>
> def neighbors(point):
>      # do what's needed to figure out neighbors info
>
> See - no globals!
>
>
> You almost never want to write this if you don't actually _need_ the index:
>
>      for i in range(len(new_arr)):
>          print(new_arr[i])
>
> because new_arr is iterable already, you sould prefer:
>
>      for point in new_arr:
>          print(point)
>
> There *are* times when you want to work with the index.
>
> As a design matter, you're storing a populated matrix, which is not
> wrong, but since the states are completely binary, you could store
> something sparse instead - like keep a list of the points that are "on",
> only. You easily know that if a point is not in that list, then it's
> off, so you didn't need to explicitly store the other value anywhere.
> That's just a different design to a solution, you certainly don't have
> to use it!
>
> For the original poster, and other Python newcomers, it's not unheard of
> that writing a program for Comway is a job interview question... and
> you'll be asked to make it efficient, too, not just working.  It's
> probably worth leaving yourself a note to come back to this problem much
> later, when you're a lot more experienced in Python, and seeing if you
> would work a new solution differently given your new knowledge :)  It's
> good practice!
> _______________________________________________
> Tutor maillist  -  Tutor at python.org
> To unsubscribe or change subscription options:
> https://mail.python.org/mailman/listinfo/tutor
>