函数也是对象
定义函数时建立对象，调用函数时可以反复调用对象
变量的作用域（全局变量和局部变量）
全局变量
1、在函数和类定义之外声明的变量
2、作用域为定义的模块，从定义位置开始知道模块结束
3、全局变量降低了函数的通用性和可读性，应尽量避免全局变量的使用
4、全局变量一般作常量使用
5、函数内要改变全局变量的值，使用global声明一下
局部变量
1、在函数体中（包括形式参数）声明的变量
2、局部变量的引用比全局变量快，优先考虑使用
3、如果局部变量和全局变量同名，则在函数内部隐藏全局变量，只使用同名的局部变量
a = 100
def f1():
global a
a = 300
print(a)
print(a)
f1()
运行结果为：
100
300
a = 100
def f1():
global a
a = 300
print(a)
f1()
print(a)
运行结果为：
300
300
参数的传递
1、函数的参数传递本质上是从实参到形参的赋值操作
2、Python中参数的传递都是引用传递（传递地址），不是值传递
3、具体操作分为两类：
①对“可变对象”进行“写操作”，直接作用于原对象本身
②对“不可变对象”进行“写操作”，会产生一个新的“对象空间”，并用新的值填充这块空间
传递可变对象的引用
a = [1,2]
print(id(a))
def test01(m):
print(id(m))
m.append(3)
print(id(m))
test01(a)
print(a)
运行结果为：
2333204701768
2333204701768
2333204701768
[1, 2, 3]
传递不可变对象的引用
不可变对象有：int、float、字符串、元组、布尔值
a = 1
print(id(a))
def test01(n):
print(id(n))
n = n+1
print(id(n))
test01(a)
测试结果为：
140730502189888
140730502189888
140730502189920
浅拷贝和深拷贝
1、内置函数：浅拷贝copy()、深拷贝deepcopy()
2、浅拷贝：不拷贝子对象内容，只是拷贝子对象的引用
深拷贝：会连子对象的内存也全部拷贝一份，对子对象的修改不会影响源对象
#测试浅拷贝
import copy
a = [1,2,[5.6]]
b = copy.copy(a)
print("a:",a)
print("b:",b)
b.append(30) #在b中新加了地址，指向的值为30
b[2].append(7) #在a原来对应的地址中加入了7这个值
print("浅拷贝......")
print("a:",a)
print("b:",b)
运行结果为：
a: [1, 2, [5.6]]
b: [1, 2, [5.6]]
浅拷贝......
a: [1, 2, [5.6, 7]]
b: [1, 2, [5.6, 7], 30]
#测试深拷贝
import copy
a = [1,2,[5.6]]
b = copy.deepcopy(a)
print("a:",a)
print("b:",b)
b.append(30)
b[2].append(7)
print("深拷贝......")
print("a:",a)
print("b:",b)
运行结果为：
a: [1, 2, [5.6]]
b: [1, 2, [5.6]]
深拷贝......
a: [1, 2, [5.6]]
b: [1, 2, [5.6, 7], 30]
传递不可变对象是浅拷贝
#传递不可变对象时，如果发生拷贝，是浅拷贝
a = (1,2,[5,6])
print("a:",id(a))
def test01(m):
print("m:",id(m))
m[2][0] = 888
print(m)
print("m",id(m))
test01(a)
print(a)
运行结果为：
a: 2739911266808
m: 2739911266808
(1, 2, [888, 6])
m 2739911266808
(1, 2, [888, 6])
参数的几种类型
1、位置参数
函数调用时，实参数默认按位置顺序传递，需要个数与形参匹配
2、默认值参数
在定义函数时，直接给形参赋值；
调用函数时，如果没有添加实参则用默认值，添加了实参则用新添加的值
def test01(a,b,c=1,d=2):
print(a,b,c,d)
test01(1,2)
test01(1,2,3)
运行结果为：
1 2 1 2
1 2 3 2
3、命名参数
在调用时，把名字写出来，不需要对应位置
def test01(a,b,c):
print(a,b,c,)
test01(c=1,b=2,a=3)
运行结果为：
3 2 1
4、可变参数
1、可变参数指的是“可变数量的参数”
2、*param：将多个参数收集到一个元组对象中
3、**param：将多个参数收集到一个字典对象中
def test01(a,b,*c):
print(a,b,c)
test01(1,2,3,4)
运行结果为：
1 2 (3, 4)
def test02(a,b,**c):
print(a,b,c)
test02(1,2,name = 'wyj',school = 'hit') #注意字典既要有key又要有value
运行结果为：
1 2 {'name': 'wyj', 'school': 'hit'}
5、强制命名参数
在带星号的“可变参数”后面增加新的参数时，必须是强制命名参数，否则会有歧义，报错
def test02(*a,b,c):
print(a,b,c)
test02(1,2,b = 3,c = 4)
运行结果为：
(1, 2) 3 4
lambda表达式和匿名函数
1、lambda表达式可以用来声明匿名函数
2、lambda函数是一种简单的、在同一行中定义函数的方法
3、lambda表达式只允许包含一个表达式，不能包含复杂语句，该表达式的计算结果就是函数的返回值
4、基本语法：
lambda arg1,arg2,agr3... : 表达式
>>> f = lambda a,b,c:a+b+c
>>> print(f(2,3,4))
9
把函数对象放进列表中
>>> g = [lambda a:a*2,lambda b:b*3]
>>> print(g[0](6))
12
eval()函数
将字符串str当成有效的表达式来求值并返回计算结果
语法格式：
eval(source[,globals[,locals]])
source：一个Python表达式或函数compile()返回的代码对象
globals：可选，必须是dictionary
locals：可选，任意映射对象
>>> eval("print('abcde')")
abcde
>>> a = 10
>>> b = 10
>>> c = eval("a+b")
>>> c
20
>>> a = 1
>>> b = 2
>>> dict1 = dict(a = 100,b = 200)
>>> d1 = eval("a+b")
>>> d2 = eval("a+b",dict1)
>>> print(d1,d2)
3 300
递归函数
1、自己调用自己的函数，在函数体内部直接或间接自己调用自己
2、每个递归函数必须包含两个部分
①终止条件
表示递归什么时候结束，一般用于返回值，不再调用自己
②递归步骤
把第n步的值和第n-1步相关联
3、递归函数由于会创建大量的函数对象，会过量的消耗内存和运算能力；在处理大量数据时，谨慎使用
def test01():
print("test01")
test02()
def test02():
print("test02")
test01()
运行结果为：
test01
test02
#无终止条件，栈空间会满，报错
def test01():
print("test01")
test01()
def test01(n):
print("test01",n)
if n == 0:
print("over")
else:
test01(n-1)
test01(4)
运行结果为：
test01 4
test01 3
test01 2
test01 1
test01 0
over
※※※ 函数调用时，会在栈中生成一个对象，多次调用则生成多个栈，最后对象要全部走完
※※※栈的特点：先进后出，后进先出
例子如下：
def test01(n):
print("test01",n)
if n == 0:
print("over")
else:
test01(n-1)
print("test01***",n)
test01(3)
运行结果：
test01 3
test01 2
test01 1
test01 0
over
test01*** 0
test01*** 1
test01*** 2
test01*** 3
※※※ 阶乘计算案例
def test01(n):
if n == 1:
return 1
else:
return n*test01(n-1)
s = test01(3)
print(s)
运行结果：
6
