Why is iceberg lettuce bad for rabbits?
In Python specifically, how do variables get shared between threads?
Although I have used ```threading.Thread``` before I never really understood or saw examples of how variables got shared.  Are they shared between the main thread and the children or only among the children? When would I need to use thread local storage to avoid this sharing?
I have seen many warnings about synchronizing access to shared data among threads by using locks but I have yet to see a really good example of the problem. 
Thanks in advance!
In Python, variables are not automatically shared between threads. However, they can be made shareable through certain techniques.
By default, the local variables of a thread are independent from those of other threads. But if you assign a reference to a Python object (like a list, dict, or class instance) to a variable in one thread, other threads can access and modify the same object through that reference, leading to unintended concurrent modifications.
This is known as "thread-unsafeness" and may cause problems like data races and inconsistent behavior. To avoid these issues, you either need to make the shared
Why aren't python nested functions called closures? And does that mean that there is no such thing as a closure in python?

Nested functions and closures are related but not exactly the same thing. Here is a brief explanation of each:

A nested function is a function defined inside another function, where the inner function can access the variables in the outer function's scope. The inner function can be called both as a standalone function and as a function called on the instance of the outer function.

A closure is a function that retains access to its defining environment (lexical environment) even after the defining function has finished execution. That is, a