第六章

函数也是对象
函数内部如果想改变全局变量的值，使用global声明



若想在函数内部使用全局变量a，需要声明：global a

如果想输出局部变量和全局变量，需要使用local和globals：

参数的传递
本质上是赋值的操作。就是实参到形参的赋值操作
传递可变对象
传递不可变对象（int，float，元组，字符串，布尔值）。在赋值操作的时候，系统会创建一个新的对象
a = 100
def f1(n):
print(“n:”,id(n))
n = n+200
print(“n:”,id(n))
print(n)
f1(a)
print(“a:”,id(a))
执行结果：
n:1663816464
n:46608592
300
a:1663816464

浅拷贝和深拷贝：
浅拷贝：不拷贝子对象的内容，只是拷贝子对象的引用
深拷贝：会连子对象的内存也全部拷贝一份，对子对象的修改不会影响源对象
import copy
a = [10,20,[5,6]]
b = copy.copy(a)
print(“a:”,a)
print(“b:”,b)
b.append(300)
b[2].append(7)
print("a:"a)
print("b:"b)
a : [10,20,[5,6]]
b : [10,20,[5,6]]

a : [10,20,[5,6,7]]
b : [10,20,[5,6,7],30]

深拷贝
def testDeepCopy()
import copy
a = [10,20,[5,6]]
b = copy.deepcopy(a)
print(“a:”,a)
print(“b:”,b)
b.append(300)
b[2].append(7)
print("a:"a)
print("b:"b)

testDeepCopy()
b做任何修改，和a没有任何关系

传递不可变对象是浅拷贝
a =(10,20,[5,6])
print(“a:”,id(a))
def test(m):
print(“m”,id(m))
m[2][0] = 888
print(m)
print(“m”,id(m))
test(a)
tuple类型不可变，说的是他里面的地址不可变。
如果tuple类型中有可变类型，比如列表。那么只要列表地址不变，就可以更改
a :41611632
m:41611632
(10,20,[888,6])
m:41611632
(10,20,[888,6])

参数的几种类型
位置参数：
def f1(a,b,c):
print(a,b,c)
f1(2,3,4)
f1(2,3) #报错

默认值参数
def f1(a,b,c = 10,d = 20):
print(a,b,c,d)
f1(8,9)
f1(8,9,19)
f1(8,9,19,29)
8 9 10 20
8 9 19 20
8 9 19 29

命名参数
def f1(a,b,c):
print(a,b,c)
f1(8,9,19)
f1(c = 8,a = 20,b = 33)
8,9,19
20,33,8

可变参数：
指的是可变数量的参数
*param。将多个参数收集到一个元组里
**param。将多个参数收集到一个字典里
def f1(a,b,*c):
print(a,b,c)
f1(8,9,19,20)
def f2(a,b,**c)
print(a,b,c)
f2(8,9,nane = “zhangsan”,age = 18)
def f3(a,b,*c,**d)
print(a,b,c,d)
f3(8,9,20,30,name = “zhangsan”,age = 18 )
8 9 (19,20)
8 9 {nane = “zhangsan”,age = 18)}
8 9 (20,30){nane = “zhangsan”,age = 18)}

强制命名参数
def f1(*a,b,c)
print(a,b,c)
#f1(2,3,4) #会报错，a是可变参数，会将2，3，4全部收集
f1(2,b = 3,c = 4) #必须在调用的时候，强制命名参数

lambda表达式和匿名函数
lambda表达式可以用来声明匿名函数。简单，在同一行中定义函数。lambda实际生成了一个函数对象
lambda表达式只允许包含一个表达式，不能包含复杂语句，计算结果就是函数的返回值
基本语法：
lambda arg1.arg2,arg3…:<表达式>
arg为函数的参数，<表达式>相当于函数的函数体。结果是：表达式的运算结果
f = lambda a,b,c:a+b+c
print(f)
print(f(2,3,4))

g = [lambda a:a2,lambda b:b3,lambda c:c*4]
print(g0,g1,g2)
9
12 21 32

eval()函数
将字符串
s = “ptiny(“hello”)”
eval(s)
a = 10
b = 20
c = eval(“a+b”)
print©
输出结果为
hello
30

dict1 = dict(a = 100,b = 200)
d = eval(“a+b”)
print(d)
30

dict1 = dict(a = 100,b = 200)
d = eval(“a+b”,dict1)
print(d)

递归函数：
白话讲就是自己调用自己的函数
def test01():
print(“test01”)
test02() #栈帧，当方法执行结束的时候，就会栈帧就会消失，释放内存。

def test02():
print(“test02”)

test01()
输出：
test01
test02

def test01():
print(“test01”)
test01()
print("###") #我们会发现，不会输出###，因为每个方法都没有执行完，一直在打开新方法，方法没有结束，就不会释放内存，导致栈满报错
def test02():
print(“test02”)

test01()
会报错，无限制的调用test01（）并且输出。
栈满了就会报错

所以在递归中，要设置一个终止条件，并且把第n步和第n-1步关联

def test01():
print(“test01：”，n)
if n == 0:
print(“over”)
else:
test01(n-1)
print(“test01***”,n) # 把上面的代码执行完了，内存释放之前执行的最后一段代码

test01(4)

练习：递归的阶乘：
def factorial(n):
if n == 1:
return 1
else:
return n*factorial(n-1)

result = factorial(5)
print(result)