Added python level 2

Author: fsiddh

Section 15- Python - Level Two/Part1_Scope.py

@@ -0,0 +1,195 @@
+###############################
+# Nested Statements and Scope #
+###############################
+
+# Now that we have gone over on writing our own functions, its important to
+# understand how Python deals with the variable names you assign. When you create
+# a variable name in Python the name is stored in a *name-space*. Variable names
+# also have a "scope", the scope determines the visibility of that variable name
+# to other parts of your code.
+#
+# Lets start with a quick thought experiment, imagine the following code:
+
+x = 25
+
+def printer():
+    x = 50
+    return x
+
+print(x)
+print(printer())
+
+
+# What do you imagine the output of printer() is? 25 or 50? What is the output
+# of print x? 25 or 50? Or what about this:
+
+print(x)
+print(printer())
+print(x)
+
+
+# Interesting! But how does Python know which "x" you're referring to in your
+# code? This is where the idea of scope comes in. Python has a set of rules it
+# follows to decide what variables (such as x in this case) you are referencing
+# in your code. Lets break down the rules:
+
+# This idea of scope in your code is very important to understand in order to
+# properly assign and call variable names.
+#
+# In simple terms, the idea of scope can be described by 3 general rules:
+#
+# 1. Name assignments will create or change local names by default.
+# 2. Name references search (at most) four scopes, these are:
+#     * local
+#     * enclosing functions
+#     * global
+#     * built-in
+# 3. Names declared in global and nonlocal statements map assigned names to
+# enclosing module and function scopes.
+#
+#
+# The statement in #2 above can be defined by the LEGB rule.
+#
+# **LEGB Rule.**
+#
+# L: Local — Names assigned in any way within a function (def or lambda)),
+# and not declared global in that function.
+#
+# E: Enclosing function locals — Name in the local scope of any and all
+# enclosing functions (def or lambda), from inner to outer.
+#
+# G: Global (module) — Names assigned at the top-level of a module file, or
+# declared global in a def within the file.
+#
+# B: Built-in (Python) — Names preassigned in the built-in names module :
+# open,range,SyntaxError,...
+
+###############################
+### Quick examples of LEGB ####
+###############################
+
+# Local
+
+# x is local here:
+f = lambda x:x**2
+
+
+# Enclosing function locals
+#
+# This occurs when we have a function inside a function (nested functions)
+#
+
+name = 'This is a global name'
+
+def greet():
+    # Enclosing function
+    name = 'Sammy'
+
+    def hello():
+        print('Hello '+name)
+
+    hello()
+
+greet()
+
+
+# Note how Sammy was used, because the hello() function was enclosed inside of
+# the greet function!
+
+# Global
+#
+print name
+
+
+# Built-in
+# These are the built-in function names in Python (don't overwrite these!)
+# You will know if you've typed one based on its color!
+
+len
+
+
+# Local Variables
+
+# When you declare variables inside a function definition, they are not related
+# in any way to other variables with the same names used outside the function -
+# i.e. variable names are local to the function. This is called the scope of the
+# variable. All variables have the scope of the block they are declared in
+# starting from the point of definition of the name.
+#
+# Example:
+
+x = 50
+
+def func(x):
+    print('x is', x)
+    x = 2
+    print('Changed local x to', x)
+
+func(x)
+print('x is still', x)
+
+
+# The first time that we print the value of the name x with the first line in
+# the function’s body, Python uses the value of the parameter declared in the
+# main block, above the function definition.
+#
+# Next, we assign the value 2 to x. The name x is local to our function. So,
+# when we change the value of x in the function, the x defined in the main block
+# remains unaffected.
+#
+# With the last print statement, we display the value of x as defined in the main
+# block, thereby confirming that it is actually unaffected by the local
+# assignment within the previously called function.
+
+################################
+# The Global Statement
+################################
+
+# If you want to assign a value to a name defined at the top level of the program
+# (i.e. not inside any kind of scope such as functions or classes), then you have
+# to tell Python that the name is not local, but it is global. We do this using
+# the global statement. It is impossible to assign a value to a variable defined
+# outside a function without the global statement.
+#
+# You can use the values of such variables defined outside the function
+# (assuming there is no variable with the same name within the function).
+# However, this is not encouraged and should be avoided since it becomes unclear
+# to the reader of the program as to where that variable’s definition is. Using
+# the global statement makes it amply clear that the variable is defined
+# in an outermost block.
+#
+# Example:
+
+x = 50
+
+def func():
+    global x
+    print('This function is now using the global x!')
+    print('Because of global x is: ', x)
+    x = 2
+    print('Ran func(), changed global x to', x)
+
+print('Before calling func(), x is: ', x)
+func()
+print('Value of x (outside of func()) is: ', x)
+
+
+# The global statement is used to declare that x is a global variable - hence,
+# when we assign a value to x inside the function, that change is reflected
+# when we use the value of x in the main block.
+#
+# You can specify more than one global variable using the same global statement
+# e.g. global x, y, z.
+
+###############################
+# Conclusion
+###############################
+
+# You should now have a good understanding of Scope (you may have already
+# intuitively felt right about Scope which is great!) One last mention is that
+# you can use the globals() and locals() functions to check what are your current
+# local and global variables.
+#
+# Another thing to keep in mind is that everything in Python is an object! I can
+# assign variables to functions just like I can with numbers! We will go over
+# this again in the decorator section of the course!