一，引言
现在我有个问题，函数里面的变量，在函数外面能直接引用么？
def func1():
m = 1
print(m)
print(m) #这行报的错
报错了：
NameError: name 'm' is not defined
上面为什么会报错呢 ？现在我们来分析一下python内部的原理是怎么样：
我们回忆一下python代码的运行是哦湖遇到函数是怎么做的，从python解释器开始执行后，就在内存开辟一个空间，每当遇到一个变量的时候，就把变量名和值之间的关系记录下来，但是当遇到函数定义的时候，解释器只是象征性的将函数名读到内存。表示知道这个函数存在了，至于函数内部的变量和逻辑，解释器根本不关心。
等执行到函数调用的时候，Python解释器会再开辟一块内存来储存这个函数里面的内容，这个时候，才关注函数里面有哪些变量，而函数中的变量回储存在新开辟出来的内存中，函数中的变量只能在函数内部使用，并且会随着函数执行完毕，这块内存中的所有内容也会被清空。
我们给这个‘存放名字与值的关系’的空间起了一个名字-------命名空间。
代码在运行伊始，创建的存储“变量名与值的关系”的空间叫做全局命名空间；
在函数的运行中开辟的临时的空间叫做局部命名空间。
二，命名空间和作用域
>>> import this The Zen of Python, by Tim Peters Beautiful is better than ugly. Explicit is better than implicit. Simple is better than complex. Complex is better than complicated. Flat is better than nested. Sparse is better than dense. Readability counts. Special cases aren't special enough to break the rules. Although practicality beats purity. Errors should never pass silently. Unless explicitly silenced. In the face of ambiguity, refuse the temptation to guess. There should be one-- and preferably only one --obvious way to do it. Although that way may not be obvious at first unless you're Dutch. Now is better than never. Although never is often better than *right* now. If the implementation is hard to explain, it's a bad idea. If the implementation is easy to explain, it may be a good idea. Namespaces are one honking great idea -- let's do more of those! python之禅 python之禅
在python之禅中到过：命名空间是一种绝妙的理念，让我们尽情的使用发挥吧！
命名空间一共分为三种：
全局命名空间
局部命名空间
内置命名空间
内置命名空间中存放了python解释器为我们提供的名字：input,print,str,list,tuple...它们都是我们熟悉的，拿过来就可以用的方法。
三种命名空间之间的加载与取值顺序：
加载顺序：内置命名空间(程序运行前加载)->全局命名空间(程序运行中：从上到下加载)->局部命名空间(程序运行中：调用时才加载)
取值顺序：
在局部调用：局部命名空间->全局命名空间->内置命名空间
在全局调用：全局命名空间->内置命名空间
综上所述，在找寻变量时，从小范围，一层一层到大范围去找寻。
作用域
作用域就是作用范围，按照生效范围可以分为全局作用域和局部作用域。
全局作用域：包含内置名称空间、全局名称空间，在整个文件的任意位置都能被引用、全局有效
局部作用域：局部名称空间，只能在局部范围内生效
#*args 动态参数，万能参数
#args接受的就是实参对应的 所有位置参数，并将其放在元组中。
def func(*args):
print(args)
print(func(1,2,3,4,5,7,8,9,1,2,3,4,5,6,7,8))
#形参对应顺序：
#位置参数，*args，默认参数
执行后输出：
1
2
3
4
(5, 6, 7)
女
#**kwargs 动态传参，他将所有的关键字参数（无异议）的放到一个字典中
def func(a,b,c,**kwargs):
print(kwargs)
func(1,2,r=4,b1=5,c1=6,c=7)
执行后输出：
# # * 魔法运用
def func(*args):
print(args) #(1,2,30,1,2,33.。。。。。)
l1 = [1,2,30]
l2= [1,2,33,21,45,66]
func(*l1,*l2) #在函数的调用时，*代表打散
执行后输出：
###
**kwargs
def func(**kwargs):
print(kwargs)
dic1 = {'name1':'alex','age1':46}
dic2 = {'name':'hobby','age':56}
func(**dic1,**dic2)
输出后的结果：
说明：
1. 在函数的调用执行时，
2. *可迭代对象，代表打散(list,tuple,str,dict(键))将元素一一添加到args。
3. **字典，代表打散，将所有键值对放到一个kwargs字典里。
在函数定义时， *args，**kwargs代表的是聚合。
def func(*args,**kwargs):
print(args)
print(kwargs)
dic1 = {'name1':'alex','age1':46}
dic2 = {'name':'hobby','age':56}
func(*[1,2,3,4],*'asdfses',**dic1,**dic2)
执行后输出：
函数--名称空间，临时名称空间
a = 4
b = 3
c = [1,2,3,4]
c1 = {'name':'alex'}
def func1():
name = 'hobby'
print(name)
func1()
执行后输出：
当执行函数的时候，他会在内存中开辟一个临时名称空间，存放函数体内的所有变量与值的关系。
随着函数的执行完毕，临时空间自动关闭。
name = 'python'
def func1():
name = 'jack'
print(name)
func1()
执行后输出：
def func1():
name = 'joanna'
print(name)
func1()
执行后输出：
函数什么时候执行？ 函数调用的时候执行。
# 代码从上至下依次执行， 调用函数：函数里面从上至下依次执行。
print(111)
def func1():
print(333)
def func2():
print(444)
def func3():
print(555)
func2()
func1()
print(222)
执行后输出：
print(111)
def func1():
print(333)
func2()
print(666)
def func2():
print(444)
def func3():
print(555)
func1()
print(222)
执行后输出：
全局变量
a = 2
b = 3
def func1():
c = 5
d = 6
print(globals()) # 全局变量放在一个字典中
return locals() # {'c': 5, 'd': 6}
print(func1())
执行输出：
关键字：global,nonlocal
# print(globals()) # 全局名称空间：所有变量
# print(locals()) # 局部名称空间：所有变量
#global
# 1,在局部空间内，声明一个全局变量
def func1():
global name
name = 'hobby'
print(name)
func1()
print(func1())
执行后输出：
2,在局部空间内改变一个全局变量
a = 4
def func1():
global a
a = 5
func1()
print(a)
执行后：
#nonlocal
# 1,不能修改全局变量。
a = 4
def func1():
nonlocal a
a = 5
# print(name)
func1()
print(a)
执行后输出：
重点注意：
#在局部作用域中，对父级作用域（或者更外层作用域但非全局作用域）的变量进行引用和修改，
# 并且引用的哪层，就从那层及以下此变量全部发生改变。