函数
- 由若干语句组成的语句块、函数名称、参数列表构成，它是组织代码的最小单元
- 完成一定的功能
- 函数名就是标识符，命名要求一样
- Python的函数没有return语句，隐示会返回一个None值
- 定义需要在调用前，也就是说调用时，已经被定义过了，否则抛NameError异常
- 函数是可调用的对象，callable()
参数
位置参数
- def func(x, y, z) 调用使用func(1,3,5)
- 按照参数定义顺序传入实参
关键字参数
- def func(x, y, z) 调用时使用func(x=1, y=2, z=3)
- 使用形参的名字来传入实参的方式，如果使用了形参名字，那么传参顺序就可以和定义顺序不同
传参
- 要求位置参数必须在关键字参数之前传入，位置参数是按位置对应的
参数默认值（缺省值）
- 定义时，在形参后跟上一个值
- 作用
- 参数的默认值可以在为传入足够的实参的时候，对没有给定的参数赋值为默认值
- 参数非常多的时候，并不需要用户每次都输入所有的参数，简化函数调用
位置可变参数
- 在形参前使用*表示形参是可变参数，可以接受多个实参
- 收集多个实参为一个tuple
关键字可变参数
- 形参前使用**符号，表示可以接受多个关键字参数
- 收集的实参名称和值组成一个字典
keyword-only 参数（python3加入）
如果在一个星号参数后，或者一个位置可变参数后，出现的普通参数，实际上已经不是普通参数了，而是keyword-only参数
keyword-only 参数另一种形式
def func(*, x, y):
print(x, y)
func(x=5, y=7)
* 号之后，普通参数都变成了必须给出的keyword-only参数
可变参数总结
- 有位置可变参数和关键字可变参数
- 位置可变参数在形参前使用一个星号*
- 关键字可变参数在形参前使用两个星号**
- 位置可变参数和关键字参数都可以收集若干个实参，位置可变 参数收集形成一个tuple，关键字可变参数收集成形成一个dict
- 混合使用参数的时候，可变参数要放到参数列表的最后，普通参数需要放到参数列表前面，位置可变参数需要在关键字可变参数之前
参数规则
- 参数列表顺序是，普通参数、缺省参数、可变位置参数、keyword-only参数（可带缺省值），可变关键字参数
参数解构
- 给函数提供实参的时候，可以在集合类型前使用*或者**，把集合类型的结构解开，提取出所有元素作为函数的实参
- 非字典类型使用*解构成位置参数
- 字典类型使用**解构成关键字参数
- 提取出来的元素数目要和参数的要求匹配，也要和参数的类型匹配
- 给参数提供实参的时候，可以在集合类型前使用*或者**，把集合类型的结构解开，提取出所有元素作为函数的实参
函数的返回值
- 函数不能同时返回多个值
- return [1,3,5] 是指明返回一个列表，是一个列表对象
- return 1,3,5 看似返回多个值，隐式的被Python封装成了一个元组
def showlist():
return 1,3,5
x,y,z = showlist() # 使用解构提取更为方便
函数嵌套
- 在一个函数中定义了另外一个函数
def outer():
def inner():
print('inner')
print('outer')
inner()
- 函数有可见范围，这就是作用域的概念
- 内部函数不能在外部直接使用，会抛NameError异常，因为它不可见
作用域*
- 一个标识符的可见范围，这就是标识符的作用域。一般常说的是变量的作用域
- 全局作用域
- 在整个程序运行环境中都可见
- 局部作用域
- 在函数、类等内部可见
- 局部变量使用范围不能超过其所在的局部作用域
def outer():
o = 65
def inner():
o = 97
print('inner {}'.format(o))
print(chr(o))
print("outer {}".format(o))
print(chr(o))
inner()
print(chr(o))
>>>: outer()
outer 65
A
inner 97
a
A
从嵌套结构例子看出
- 外层变量作用域在内层作用域可见
- 内层作用域inner中，如果定义了一个和外层做作用域中重名的变量，这个变量并没有覆盖外层作用域中的o
>>>: x = 5
>>>: def foo():
>>>: x += 1
>>>: foo() # 报错
-------------------------------------------------------
UnboundLocalError Traceback (most recent call last)
<ipython-input-77-c19b6d9633cf> in <module>()
----> 1 foo()
<ipython-input-76-06a3a4e92a76> in foo()
1 def foo():
----> 2 x += 1
3
UnboundLocalError: local variable 'x' referenced before assignment>>>: x = 5
- 上面代码报错原因
- x += 1 其实是 x = x + 1
- 相当于在foo函数内部定义一个局部变量x ，那么foo内部所有x 都是这个局部变量x 了
- 但是这个x还没有完成复制，就被右边拿来做加1 操作了
全局变量global
- 使用global关键字的变量，将函数内的变量声明为使用外部的全局作用域中
- x += 1 这种特殊形式产生的错误的原因？先引用后赋值。而python动态语言是赋值才算定义，才能被引用。
- 解决办法：在这条语句前增加x=0 之类的赋值语句，或者使用global告诉哦内部作用域，去全局作用域查找变量定义
- - 内部作用域使用x=5之类的赋值语句会重新定义局部作用域使用的变量x， 但是，一旦这个作用域中使用global声明x为全局的，那么x=5 相当于在为全局作用域的变量x赋值。
global 使用原则
- 外部作用域变量会在内部作用域可见，但也不要在这个内部作用域中直接使用，因为函数的目的是为了封装，尽量与外界隔离
- 如果函数需要使用外部全局变量，请使用函数的形参传参解决
- 一句话：不用global。学习他就是为了深入理解变量作用域
闭包
- 自由变量：未在本地作用域中定义的变量。例如定义在内存函数外的外层函数的作用域中的变量
- 闭包：就是一个概念，出现在嵌套函数中，指的是内层函数引用了外层函数的自由变量，就形成了闭包。很多语言都有这个概念。最熟悉就是JavaScript。
Python2 中实现闭包方式
def counter():
c = [0]
def inc():
c[0] += 1
return c[0]
return inc
foo = counter()
print(foo(),foo())
>>>: 1 2
c = 100
print(foo())
>>>: 3
nonlocal 关键字
- 使用了nonlocal关键字，将变量标记为不在本地作用域定义，而在上级的某一级局部作用域中定义，但不能是全局作用域中定义
默认值得作用域
def foo(xyz=[]):
xyz.append(1)
print(xyz)
foo() #[1]
foo() #[1,1]
print(xyz) # NameError,当前作用域没有xyz变量
为什么第二次调用foo(）函数打印的是[1,1]?
- 因为函数也是对象，Python把函数的默认值放在了属性中，这个属性就伴随着这个函数对象的整个生命周期
- 查看 foo.__defaults__ 属性，__defaults__中使用元组保存默认值
- xyz 是引用类型，引用类型的元素变动，并不是元组的变化
- 属性__defaults__中使用元组保存所有位置参数默认值，它不会因为在函数内使用了它而发生改变
- 属性__kwdefaults__中使用字典保存所有keyword-only参数的默认值
- 使用可变类型作为默认值，就可能修改这个默认值
- 有时候这个特性是好的，有的时候这种特性是不好的，有副作用
- 如何做到按需改变呢？看下面2种方法
- - 第一种方法：
- - 使用影子拷贝创建一个新的对象，永远不能改变传入的参数
- 第二种方法
- - 通过值的判断就可以灵活的选择创建或者修改传入对象
- 这种方式灵活，应用广泛
- 很多函数的定义，都可以看到使用None这个不可变的值作为默认参数，可以说这是一个惯用法
变量名解析原则LEGB
- Local ， 本地作用域，局部作用域local命名空间。函数调用时创建，调用结束消亡
- Enclosing，Python2.2 时引入了嵌套函数，实现了闭包，这个就是嵌套函数的外部函数的命名空间
- Global ，全局作用域， 即一个模块的命名空间。模块被 import 时创建，解释器退出时消亡
- Build-in ， 内置模块的命名空间，生命周期从Python解释器启动时创建到解释器退出时消亡。例如print(open), print和open都是内置的变量
- 所以一个变量的查找顺序就是LEGB
函数的销毁
- 全局函数销毁
- - 重新定义同名函数
- del 语句删除函数名称，函数对象的引用计数减1
- 程序结束时
- 局部函数销毁
- 在同级作用域同名函数下方重新定义同名函数
- del语句删除函数名称，函数对象的引用计数减1
- 上级作用域销毁时
