1、全局变量和局部变量
1.1 局部变量：
·定义在函数内部的变量成为局部变量（函数的形参也是局部变量）
·局部变量只能在函数内部使用
·局部变量在函数调用时才能被创建，在函数调用之后会自动销毁
1.2 全局变量：
·定义在函数外部，模块内部的变量成为全局变量
·全局变量所有函数都可以直接访问（但函数内部不能将其赋值）
1.3 说明：
·局部变量只能在其被声明的函数内部访问，而全局变量可以再整个模块范围内访问
·在函数内部赋值语句不会对全面局变量造成影响
1.4 注
1）在函数内部可以通过 extend() 方法改变变量绑定的对象，从而改变全局变量的值,例如：L.entend(L2)。
但是全局变量地址没变，也就是 id(L)的返回值相同。此外使用 + += 等运算符都会产生错误。
2）全部变量只能用 del 删除
2、globals() /locals 函数
globals()：返回当前>>全局作用域<<内变量的字典
locals() ：返回当前>>局部作用域<<内变量的字典
示例：
a=1
b=2
c=3
def fn(c,d):
e=300
print("locals()返回",locals()) #locals()返回 {'d': 200, 'e': 300, 'c': 100}
print("globals()返回",globals()) #globals()返回 {'__builtins__': <module 'builtins' (built-in)>, 'a': 1, '__spec__': None, 'b': 2, '__name__': '__main__', 'fx': <function fx at 0x7f3b12f45f28>, 'fn': <function fn at 0x7f3b11117ae8>, 'c': 3, '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>}
fn(100,200)
3、函数变量
函数名是变量，它在创建函数时绑定一个函数
示例1：此示例示意函数名fn是变量，它绑定一个函数对象
def fn():
print("hello world")
f1 = fn
print(f1) # 打印地址变量的地址：<function fn at 0x7f2c3eeb9f28>
print(f1())
输出如下：
<function fn at 0x0000021C33C04620>
hello world
None
解释：
第一行：打印函数变量f1的地址
第二行：先执行f1()函数，输出hello
第三行：执行fn()函数之后打印fn()函数的返回值，因为fn()函数没有return语句返回结果，所以默认返回为空，即输出 None
示例2：一个函数可以作为另一个函数的实参进行传递
def f1():
print("hello f1")
def f2():
print("hello f2")
def fx(fn):
print(fn) # 打印地址
fn() # 调用f1() 函数
fx(f1)
输出如下：
<function f1 at 0x0000025097744620>
hello f1
解释：
代码最后一行fx(f1)将函数f1作为fx的实参传递给了fx，此时第五行的fx()函数中的形参fn为f1，然后分别打印f1的地址、调用f1()函数
示例3.1：函数可以返回另一个函数
def get_function():
s = input("请输入你要的操作：")
if s=="求最大":
return max # 返回求最大值函数
elif s=="求最小":
return min # 返回求最小值函数
elif s=="求和":
return sum # 返回求和函数
L=[2,4,6,8,10]
f = get_function()
print(f(L))
输出如下（三种执行结果）：
请输入你要的操作：求和
30
-----
请输入你要的操作：求最大
10
-----
请输入你要的操作：求最小
2
示例3.2：函数可以返回另一个函数——单位正整数加减乘除运算
def myadd(x,y):
return x + y
def mysub(x,y):
return x - y
def mymul(x,y):
return x * y
def get_function(choise):
if choise == "+":
return myadd
elif choise == "-":
return mysub
elif choise == '*':
return mymul
def main():
gongshi = input("请输入计算公式:")
a = int(gongshi[0:1]) # 字符串切片
b = int(gongshi[2:3])
choise = gongshi[1:2] # choise：运算符
p = get_function(choise) # p：函数变量
print("结果是:",p(a,b))
main()
运行结果如下：
请输入计算公式:9*9
结果是: 81
4、函数的嵌套
4.1 定义：
函数嵌套定义是指一个函数里用def语句来创建另一个函数的情况
4.2 示例
def fn_outter():
print("fn_outter()被调用")
def fn_inner():
print("fn_inner()被调用")
fn_inner() # 调用嵌套函数
fn_inner() # 二次调用
print('fn_outter()调用结束')
fn_outter()
输出结果如下：
fn_outter()被调用
fn_inner()被调用
fn_inner()被调用
fn_outter()调用结束
5、python3 的四个作用域
作用域也叫名字空间，是访问变量时查找变量名的范围空间
四个作用域包括：
作用域 | 英文解释 | 英文简写
----------------------------|-------------------------------|-----------
局部作用域（函数内） | Local（function） | L
外部嵌套函数作用域 | Enclosing function locals | E
函数定义所在模块作用域 | Global（module） | G
python内置模块的作用域 | Builtin（Python） | B
----------------------------|-------------------------------|-----------
示例：
v = 100 # 全局
def fun1():
v = 200 # 外部嵌套函数作用域
print("fun1.v=",v)
def fun2():
v = 300 # 局部作用域
print("fun2.v=",v)
fun2()
fun1()
print("全局变量v=",v)
输出如下：
fun1.v= 200
fun2.v= 300
全局变量v= 100
6、变量名查找规则
1）在访问变量时，先查找本地变量，然后是包裹此函数外部的函数内的变量，之后是全局变量，最后是内建作用域内的变量。即： L —–> E ——> G ——-> B
2）在默认情况下，变量名赋值会在当前作用域内创建变量和修改变量
7、global语句
7.1 作用：
告诉解释执行器，global语句声明的一个或多个变量，这些变量的作用域为模块级的作用域，也称作全局作用域。在全局声明global，将赋值变量映射到文件内部的作用域
7.2 语法
global 变量名1，变量名2
7.3 示例
v = 100
print('v = ',v)
def fn():
global v # 告诉解释执行器（python3），v是全局变量，不是局部变量，
v = 200 # 修改全局变量的v值
fn()
print('v = ',v)
输出如下：
v = 100
v = 200
7.4 global说明：
1）全部变量如果要在函数内部被赋值，则必须经过全局声明（否则会被认为时局部变量）
2）全局变量在函数内部可以直接被访问
3）不能先声明局部变量再用global声明为全局变量，此做法不符合规则
4）global 变量列表里的变量名不能出现在函数的形参列表里，否则会导致global全局变量名与形参列表内的 局部变量名冲突
8、nonlocal语句
8.1 作用：
告诉解释执行器，nonlocal声明的变量不是局部变量，也不是全局变量，而是外部嵌套函数内的变量
8.2 语法：
nonlocal 变量名1，变量名2
8.3 示例
v = 100
def f1():
v = 200
print("f1.v=",v)
def f2():
nonlocal v #定义为外部函数嵌套函数内的变量 E
v = 300
print("f2.v=",v)
f2()
print("调用f2后的f1.v=",v)
f1()
print("全局变量v=",v)
输出如下：
f1.v= 200
f2.v= 300
调用f2后的f1.v= 300
全局变量v= 100
8.4 说明：
1）nonlocal 语句只能在被嵌套函数的内部进行使用
2）对nonlocal变量进行赋值，将会对外部嵌套函数作用域内的变量进行操作
3）当有两层或者两层以上的函数嵌套时，访问nonlocal变量只对最近的一层变量进行操作
4）nonlocal语句中的变量列表里的变量名，不能出现在此函数的形参列表中
9、lambda 匿名函数
9.1 def 语句语法：
def 函数名(形参)：
语句块
9.2 lambda 表达式
9.2.1 作用：
创建一个匿名函数对象
同 def 类似，单不提供函数名
9.2.2 语法;
lambda[形参名1，形参名2，……]：表达式
9.2.3 示例
def myadd1(x,y):
return x+y
myadd2 = lambda x,y:x+y # 作用等同于 def 语句
print('20+30=',myadd1(20,30))
print('40+50=',myadd2(40,50))
输出如下：
20+30= 50
40+50= 90
9.2.4 说明：
1）lambda 只是一个表达式，它用来创建一个函数
2）当lambda 表达式调用时，先执行（:）后的表达式，并返回表达式的结果的引用
3）lambda 表达式创建的函数只能包含一条表达式
4）lambda 比函数简单且可以随时创建和销毁，有利于减少程序的耦合度
10 eval() 函数
10.1 作用：
把一个字符串当成一个表达式来执行，返回表达式执行后的结果
10.2 格式：
eval(source,glbals = None,locals = None)
10.3 示例：
eval('1+2+3') # 6
11 exec() 函数：
11.1 作用：
把一个字符串当成程序来执行
11.2 格式：
exec(source,glbals = None,locals = None)
11.3 示例：
s = '''x=100
y=200
print('x+y=',x+y)
del x,y
'''
exec(s) # 300
----------------------------------------------
12 函数的可重入性
12.1 定义：
当一个函数的输入一定，则输出必然一定的函数成为可重入函数
12.2 说明：
可重入函数内一定不会访问局部变量以外的变量
12.3 示例：
# 可重入函数，推荐使用
def myadd(x,y):
return x+y
print(myadd(100,200)) # 300
# ----------------------------
# 不可重入函数，难以控制
y = 200
def myadd(x):
return x+y
print(myadd(100)) # 300
y = 300
print(myadd(100)) # 400
13 高阶函数 High Order Function
13.1 什么是高阶函数：
满足下列条件中的一个的函数即为高阶函数
1）函数接受一个或者多个函数作为参数传入
2）函数返回一个函数
13.2 Python内置的高阶函数：
·map
·filter
·sorted
14 map函数：
14.1 语法：
map(func,*iterable) 返回一个可迭代对象，此可迭代对象用函数func对可迭代对象
iterable中的每一个元素作为参数计算后得到新的数据
14.2 示例：
def pow2(x):
return x**2
for x in map(pow2,range(1,10)):
print(x,end=' ')
输出如下：
1 4 9 16 25 36 49 64 81
示例2：
def mypow(x,y):
return x**y
for i in map(mypow,[1,2,3,4],(4,3,2,1)):
print(i,end=' ')
输出如下：
1 8 9 4
15 filter 函数 (filter：过滤)
15.1 语法：
filter(function,iterable)
15.2 作用：
1）筛选可迭代对象 iterable 中的数据，返回一个可迭代对象，此可迭代对象只返回iterable 中符合条件的数据
2）function 将对 iterable 中提供的每个数据进行求布尔值，如果为True则保留，为False则丢弃此数据
15.3 示例
# 判断x是否为奇数，是返回True，else 返回False
def isodd(x):
return x%2 == 1
for x in filter(isodd,range(10)):
print(x,end = ' ')
输出如下：
1 3 5 7 9
示例2：
# 判断素数
def isprime(x):
for i in range(2,x):
if x%i==0:
break
else:
return x
L = list(filter(isprime,range(2,100)))
print(L)
输出如下：
[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]
16 sorted() 函数
16.1 作用：
将可迭代的数据进行排序，生成排序后的列表
16.2函数参考格式：
sorted(iterable,key=None,reverse=False)
16.3 说明;
iterable 可迭代对象
key 函数是用来提供一个值(身高/姓名/成绩 等等，序号一个函数提供，
返回的一定可以进行值比较)，将这个值作为排序的数据，如果不给
出key函数，则依据数据的值进行比较和排序
reverse 标志用来设置是否降序排序
16.4 示例
a = [1, 9, 8, 2, 3, 6, 5, 4, 7]
a = sorted(a)
print(a) # [1, 2, 3, 4, 5, 6, 7, 8, 9]
a = sorted(a, reverse=True)
print(a) # [9, 8, 7, 6, 5, 4, 3, 2, 1]
b = [5, -4, 3, -2, 1, 0]
b = sorted(b, key=abs)
print(b) # [0,1,-2,3,-4,5] #根据绝对值进行排序
17 递归函数
17.1 递归是指 函数直接或间接的调用自身
17.2 示例：
# 函数直接调用自身
def f():
f() # 直接调用自身
f()
print("递归完成")
-----------------------------
# 函数间接调用自身
def fa():
fb() # 间接调用自身
def fb():
fa()
fa()
print("递归完成")
17.3 递归说明:
·递归一定要控制递归的层数，当符合某一条件时要停止递归调用
·几乎所有递归都能用while循环代替
17.4 递归的优缺点：
1）优点：
可以把问题简单化，让思路更清晰，代码更简洁
2）缺点：
递归因系统环境影响大，当递归深度太大时，可能会得到不可预知的结果
17.5 递归调用分为两个阶段：
1）递推阶段：
从问题出发，按递归公式递推，从未知到已知，最终达到递归停止条件
2）回归阶段：
按递归终止条件得出结果，逆向逐步带入递归公式，回归到原问题求解
17.6 示例：
def recursion(n):
print("递归进入第%d层" %n)
if n==1:
print("递归退出第%d层" %n)
return
recursion(n-1)
print("递归退出第%d层" %n)
recursion(5)
输出如下：
递归进入第5层
递归进入第4层
递归进入第3层
递归进入第2层
递归进入第1层
递归退出第1层
递归退出第2层
递归退出第3层
递归退出第4层
递归退出第5层
5.闭包
闭包是指引用函数外部变量的函数
如果一个内嵌函数访问了外部嵌套函数的变量 这个内嵌函数就是闭包
闭包必须满足三个条件：
1）必须有个内嵌函数
2）内嵌函数必须引用外部函数中的变量
3）外部函数的返回值必须是内嵌函数
示例：
def make_power(y):
def fn(x):
return x**y # 用处：例如：实现x**2，x**3，x**4 用闭包完成避免多次重写函数！！
return fn
pow2 = make_power(2)
print("5**2= ",pow2(5))
pow2 = make_power(7)
print("3**7= ",pow2(3))
pow2 = make_power(10)
print("2**10= ",pow2(2))
输出如下：
5**2= 25
3**7= 2187
2**10= 1024