1、昨日内容回顾
函数：避免重复代码，增强可读性。
特点：以功能为导向。
def 函数名():
函数体
函数的返回值：return
1，函数中遇到return结束函数。
2，return将函数内部的值返回给函数的执行者。
return None
return None None
return 单个值
return 多个值 返回的是元组。
函数的参数。
实参：
位置参数。按顺序一一对应。
关键字参数。可以不按照顺序但是也必须一一对应。
混合传参：关键字参数永远在位置参数后面。
形参：
位置参数：按顺序一一对应。
默认参数：默认参数在位置参数的后面。
动态参数。
2、动态参数 *args，**kwargs
用户传入到函数中的实参数量不定时，或者是为了以后拓展，此时要用到动态参数*args，**kwargs(万能参数。)
*args接收的是所有的位置参数；**kwargs接收的是所有的关键字参数。
位置参数，*args，默认参数, **kwargs
def func1(*args, **kwargs):
print(args)
print(kwargs)
# func1(1, 2, 3, 4)
# func1(x=4, y=5, z=6)
func1(1, 2, 3, x=4, y=5, z=6)
def func3(a):
pass
func3(11)
位置参数，默认参数
def func2(a, b, sex=‘男‘):
print(a)
print(b)
print(sex)
func2(1, 2, ‘女‘)
# 位置参数，*args，默认参数
def func2(a, b, *args, sex=‘男‘):
print(a)
print(b)
print(args)
print(sex)
func2(1, 2, 5,6,7,8,9,sex=‘女‘)
位置参数，*args，默认参数, **kwargs
def func2(a, b, *args, sex=‘男‘,age=20, **kwargs):
print(a)
print(b)
print(args)
print(sex)
print(age)
print(kwargs)
func2(1, 2, 5, 6, 7, 8, 9, x=6, y=5, name=‘alex‘)
def sum1(*args):
ret = 0
for i in args:
ret += i
return ret
print(sum1(1, 2, 3,))
def func3(*args,**kwargs): # 函数的定义 *用意是聚合。
print(args) # (1,2,3,11,21,32)
print(kwargs)
# *的魔性用法
l1 = [1, 2, 3]
l2 = [11, 21, 32]
s1 = ‘fjskalgf‘
s2 = ‘fjskrrrf‘
tu1 = (1, 2, 3)
tu2 = (11, 22, 33)
func3(*l1, *tu1, *tu2)
func3(1,2,3,1,2,3,11,22,33)
dic ={‘name‘: ‘alex‘}
dic1 ={‘age‘: 1000}
func3(*l1, **dic, **dic1) # func3(name=‘alex‘,age=1000)
在函数的执行时，*的用意是打撒。
def func3(*args,**kwargs):
l = []
for i in args: # ([1, 2, 3], [11, 21, 32])
l.extend(i)
args = tuple(l)
print(args)
print(kwargs)
l1 = [1, 2, 3]
l2 = [11, 21, 32]
func3(l1,l2)
3、名称空间，作用域，作用域链，加载顺序等。
当程序运行时，代码从上至下一次读取，遇到变量与值，
他会在内存中开辟一个空间，存放变量与值的内存地址的对应关系。
这样存储变量与值得对应关系的空间叫做名称空间(命名空间)。
当解释器遇到函数时，他会将函数名存储在内存中，但是对于函数体莫不关心。
当函数执行时，他会通过函数名找到函数体，然后将函数体里面的变量等对应关系存放在一个临时开辟的空间中，随着函数的结束，临时的空间关闭，
这样的空间叫做临时名称空间。
name = ‘alex‘
age = 1000
def func1():
a = 2
b = 3
func1()
内置名称空间：
len() print() input() list
list
name
print(666)
名称空间：
内置名称空间
全局名称空间
局部名称空间
加载顺序：内置名称空间 ---> 全局名称空间（程序运行时） ---->局部名称空间(函数执行时)
作用域：
全局作用域：内置名称空间 全局名称空间
局部作用域：局部名称空间
取值顺序(单项):局部名称空间(函数执行时) ---> 全局名称空间 ---> 内置名称空间
L local
E eclose
G global
B Built-in
sum = 666
name = ‘老男孩‘
def func1():
# sum = 555
print(sum)
func1()
sum = 666
print(sum)
sum = 666 # global
def func1():
sum = 555 # eclose
print(sum)
def inner():
pass
sum = 111 # local
# print(sum)
inner()
func1()
4、函数的嵌套，判断一下代码执行结果
print(111)
def func1():
name = ‘alex‘
print(name)
def inner():
a = 2
print(a)
inner()
print(333)
func1()
print(444)
print(111)
def func1():
name = ‘alex‘
print(name)
def inner():
a = 2
print(a)
print(444)
inner()
print(555)
func1()
111 alex 444 2 555
def func1():
a = 666
print(666)
def func2():
name = ‘taibai‘
print(name)
func1()
print(333)
func2()
print(555)
5、global，nonlocal。
global
def func1():
global name
name = ‘alex‘
func1()
print(name)
name = ‘老男孩‘
def func1():
global name
name = ‘alex‘
func1()
print(name)
在全局名称空间里得到局部名称空间的变量
1，return
2，global
1,在局部作用域中声明一个全局变量。
2，在局部作用域中，更改一个全局变量。
补充：
对于可变的数据类型，函数中如果对其进行操作，改变全局不用引用global.
l1 = [1, 2, 3]
def func1():
l1.append(666)
func1()
print(l1)
nonlocal
1,不能改变一个全局变量。
在局部作用域中，对父级作用域（或者更外层作用域非全局作用域）的变量进行引用和修改，
并且引用的哪层，从那层及以下此变量全部发生改变。
name = "老男孩"
def func1():
nonlocal name
print(name)
func1()
name = "老男孩"
def func1():
name = ‘alex‘
print(name) # 1, alex
def inner():
nonlocal name
name = ‘老男孩‘
print(name) # 2 老男孩
inner()
print(name) # 3，alex 老男孩
func1()
原文地址：https://www.cnblogs.com/dzh0394/p/9019928.html