函数:由语句块(若干语句组成),函数名称,参数构成,是组织代码的最小单元,用来完成某种功能；
函数的作用:封装代码,复用,减少冗余代码,使代码更加简洁美观,可读性更高,易懂;
函数的定义:
def 函数名(参数列表):
函数体(代码块)
[return 返回值]
def add(x,y):
result = x+y
return result
out = add(4,5)
print(out)
add是函数名，即标识符，add()调用函数；
python的函数如果过没有指定return语句，默认返回值是None；
return语句不一定是函数块的最后一条语句，一个函数可以有多条return语句，但是只有一条会执行，函数执行了return语句以后，后面的语句块就不会执行了；
上面函数定义中的参数x,y只是形式参数，函数调用是的4,5才是实际参数；
函数是一个可调用对象，canllable（）判断是否为可调用对象，返回一个布尔值；
函数参数：
参数调用时传入的参数要和定义时参数的个数相匹配（可变参数除外）；
参数列表一般顺序是：普通参数，缺省参数，可变位置参数，keyword-only参数，可变关键字参数；
位置参数：
定义def add(x,y,z):
调用add(1,2,3)
实参和形参一一对应，数量必须相同；
关键字参数：
定义def add(x,y,z):
调用add(x=1,y=2,z=3)
关键字传参时，x,y,z顺序可以和形参顺序不同，参数个数必须相同；
位置参数和关键字参数混用是，位置参数必须放在关键字参数之前传入；
可变参数:
定义def add(*args):
调用add(3,6,9)
可变位置参数一般用*args表示，可变位置参数收集到的实参整合成一个tuple；
定义def add(**kwargs):
调用add(a=3,b=6,c=9)
可变关键字参数一般用**kwargs表示，可变关键字参数收集到的实参整合成一个dict；
参数解构：
def add(x, y):
return x+y
add(*(4,5))
add(*[4,5])
add(*{4,6})
d = {'x': 5, 'y': 6}
add(**d)
add(**{'a': 5, 'b': 6})
非字典类型使用*，字典类型使用**；
解构出的元素数目要和参数数目和类型相匹配；
函数参数默认值:
定义函数的时候给参数一个默认值:
def login(host='127.0.0.1',port='8080',username='LPL',password='s7win'):
print('{}:{}@{}/{}'.format(host, port, username, password))
login()
作用:参数默认值可以在为未传入足够实参的时候,对给定的参数取默认值;参数非常多的时候,一些不需要用户经常输入或修改的参数,简化函数调用;
函数作用域***
全局作用域：在整个程序运行环境中可见；
全局变量global（能不用则不用）
x = 2
def foo():
global x
x += 1
return x
foo()
print(foo())
使用global关键字，将函数foo内的x变量声明为外部全局作用域中定义的x变量，全局作用域中必须有定义x变量，不然会抛异常；
局部作用域：在函数内部可见，局部变量使用范围不能超过其所在的局部作用域；
在嵌套函数中，外层局部作用域中的变量在内层局部作用域中是可见的，内层局部作用域中的变量在外层局部变量中是不可见的，内层局部作用域中如果有和外层局部作用域中相同的变量，相当于在内部重新定义一个新的变量，和外层局部作用域无关；
def outer1():
o = 65
def inner():
print("inner {}".format(o))
print(chr(o))
print("outer {}".format(o))
inner()
outer1()
def outer2():
o = 65
def inner():
o = 97
print("inner {}".format(o))
print("chr(o)")
print("outer{}".format(o))
inner()
outer2()
闭包*
出现在嵌套函数中，内层函数引用到外层函数的自由变量就是闭包；
自由变量：未在本地作用域中定义的变量，不能是全局作用域变量；
def counter(): c = [0] def inc(): c [0] += 1 return c[0] return inc() foo = counter() print(foo,foo) c = 100 print(foo) print(c) 执行结果: 1 1 1 100
使用nonlocal关键字，将变量标记为不在本地作用域定义，而在某上层的局部作用域中定义的变量（不能是在全局作用域中定义的变量）；
def counter(): c = 0 def inc(): nonlocal c c += 1 return c return inc() foo = counter() print(foo)
默认作用域：
python函数参数的默认值放在了属性中，这个属性就伴随这个函数对象的整个生命周期(__defaults__使用元组保存默认值,__kwdefaults__使用字典保存所有的keyword-only默认值);
def foo(xyz=[], u='abc', z=123): xyz.append(1) return xyz print(foo(), id(foo)) print(foo.__defaults__) print(foo(), id(foo)) print(foo.__defaults__) 执行结果: [1] 30359064 ([1], 'abc', 123) [1, 1] 30359064 ([1, 1], 'abc', 123) #函数对象没有变，这里xyz=[]是个引用类型，所以__defaults__默认值会改变； def foo(xyz=[], u='abc', z=123): xyz = xyz[:] xyz.append(1) print(xyz) foo() print(foo.__defaults__) foo() print(foo.__defaults__) foo([10]) print(foo.__defaults__) foo([10,5]) print(foo.__defaults__) 执行结果:[1] ([], 'abc', 123) [1] ([], 'abc', 123) [10, 1] ([], 'abc', 123) [10, 5, 1] ([], 'abc', 123) #函数体内，xyz=xyz[:]传入参数或者默认参数的cp，不能修改__defaults__默认值； def foo(xyz=None, u='abc', z=123): if xyz is None: xyz = [] xyz.append(1) print(xyz) foo() print(foo.__defaults__) foo() print(foo.__defaults__) foo([10]) print(foo.__defaults__) foo([10,5]) print(foo.__defaults__) 执行结果: [1] (None, 'abc', 123) [1] (None, 'abc', 123) [10, 1] (None, 'abc', 123) [10, 5, 1] (None, 'abc', 123) #使用不可变类型默认值,如果使用缺省值None就创建一个列表,如果传入一个列表,就修改这个列表;