Why aren't python nested functions called closures?
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!
To answer your question, by default, all variables declared in a Python script are shared between threads. This means that when you create multiple threads, they all have access to the same global and non-local variables.
This can lead to race conditions and other concurrency-related issues if multiple threads try to modify the same variable at the same time.
To avoid this, you can use one of the following methods:
1. Use thread local storage: Thread Local Storage (TLS) is a way to associate different data with each thread. This can help you avoid shared variables and their associated synchronization issues. You can use
Because python doesn'tet them to be, that's why!

In most languages, a function, which itself is defined within another (outer) function, is called a closure. Python is not like most languages. The term closure is technically incorrect for nested functions in python - but we'll get used to misnaming them! :)

Pythonably gives you nested functions, but without some of the bells and whistles available in other (more functional) languages - such as lexical scoping (unbounded free variables), but with the addition of a global variable system to