标准写法
定义一个函数，函数名叫 summary()，
- 函数有两个参数：a 和 b，a 的默认值为 1 ，b 的默认值为 2；
- :int 指定参数为 int 类型（注解）；
- -> int 指定返回值为 int（注解）;
- r""" """是标准的函数注释；
- 要是空函数，还没想好功能，用 pass 进行占位
def summary(a: int = 1, b: int = 2) -> int:
r"""
加法运算
:param a: 加数
:param b: 加数
:return: 和
"""
return a + b
pass
print(summary(1))
注意：注解只是起到提示作用，即便代码出现很明显的类型错误，也是可以执行的；
比如下面这行代码，给了个字符串参数，代码只是会出现警告，但是可以执行。
print(summary('1'))
注解的作用：除了代码警告之外，对于后期的代码分析，也会更加友好一些。
# 打印一个函数的参数类型和返回值类型
print(add.__annotations__)
可变参数
允许是任意多个参数（0-n），参数传至函数内部的时候，数据被装到元组中。
def summary(*arr):
# arr 是一个元组
print(sum(arr))
print(summary(1,2,3))
关键参数
与可变参数类似。
允许是任意多个参数（0-n），参数传至函数内部的时候，数据被装到字典中。
def summary(**arr):
# arr 是一个字典
print(arr)
print(summary(a=1,b=2,c=3))
递归
def factorial(n):
return 1 if n <= 1 else n*factorial(n-1)
pass
print(factorial(3))
print('hello world!!')
变量作用域
跟 java 一致，优先使用离自己最近的变量，先使用局部的变量，再使用全局的。
# 有个全局的变量 a = 3
a = 3
def m1(a):
# 优先使用参数 a
print(a)
pass
def m2():
# 这个函数内部没有参数 a，所有要使用全局的变量
print(a)
pass
m1(6)
m2()
global关键字
写一段奇怪的代码，猜一猜输出 a 的结果是啥？
a = 3
def add():
a = 2
add()
print(a)
为什么说这段代码很奇怪？
python 是没有字段声明的，因此 a = 2 有两种可能性：
- 可能 a 已经有值，重新赋值成了 2；
- 也有可能是，重新声明了一个 a，令其值为 2。
上述代码的输出结果是 3，add()函数内部，又声明了一个局部变量 a。
如果希望 add() 函数对 a 重新赋值，则需要用到 global 关键字。
global用法
- 引用父级作用域的变量，比如：下面代码中的 a；
- 声明一个全局变量，比如：下面代码中的 b；
- 逐层向上查找，父级没有，就找父级的父级；
a = 3
def add():
global a
a += 2
global b
b = None
add()
print(a)
print(b)
闭包（函数嵌套）
闭包和面向对象，概念存在一定的重合，暂时没有其它特别妙的应用场景；
可能在 lambda 表达式上，或者封装特别复杂的函数，会有一些妙用。
案例
def math(x, o, y):
def add(a, b):
return a + b
def sub(a, b):
return a + b
operator = {'add': add, 'sub': sub}
return operator.get(o)(x, y)
print(math(1, 'add', 2))
nonlocal的用法
已知闭包就是一个函数，使用 global 时，会产生一种代码歧义，比如下面这个代码，
只给你看一部分，我们看不出 global 引用的变量，是闭包外的，还是闭包内（闭包外的）。
def counter(x):
def add(b):
global ret
ret += b
return ret
return add
nonlocal 主要用于闭包和嵌套函数中，重新绑定局部作用域以外的变量。
逐层向上寻找变量，父级函数没有，就找父级的父级；但是不包含全局的，全局的仍然使用 global。
def counter(x):
ret = x
def add(b):
nonlocal ret
ret += b
return ret
return add
print(counter(3)(4))