python第六天

函数

1.函数也是对象（内存分析）

def okay01():
    print("sxtsxt")
c = okay01
c()         # c和okay01()指向同一个堆，c和ojay01的id相同

变量的作用域（全局变量和局部变量）

全局变量：

1. 从定义模块开始直到结束
2. 避免全局变量的使用
3. 全局变量一般做常量使用
4. 函数内要改变全局变量的值，用global声明一下

局部变量：

1. 在函数体中申明的变量
2. 优先使用局域变量
3. 如果局域变量与全局变量同名，则隐藏全局变量

局部变量存在于每一个栈帧stack frame

a = 3    #全局变量
def aabb():
    b = 4 #局域变量
    print(b*10)
    global a    #在函数内用全局变量需要写global
aabb()
print(b)            #会报错

a = 3    #全局变量
def aabb():
    b = 4 #局域变量
    print(b*10)
    global a
    a = 300
    print(locals())     #打印局部变量
    print(globals())    #打印全局变量
aabb()

print(a)   #这样打印的a就是global a

局部变量和全局变量效率测试：
特别强调效率的地方，尽量将全局变量转化成局部变量。

2.参数

参数的传递

本质是：形参到实参的赋值。
python中所有的传递都是引用传递，不是值传递。

1. 对可变对象进行“写操作”时，直接传递到对象本身
2. 对不可变对象（例如：int，float，元组，字符串，布尔值）进行“写操作时”，会产生一个新“对象空间”，并用新的值填充这个空间

a = [10,20]
print(id(a))
print(a)
def abc(m):
    print(id(m))
    m.append(300)
    print(id(m))
# 地址一样，将a的值进行编辑并传递到m中
abc(a)

a = 100
def aabb(n):
    print("n:",id(n))
    n = n+200
    print("n:",id(n))
    print(n)				#对不可变对象进行写操作时，需要print局域变量，而可变对象无需这一操作
aabb(a)
print("a:",id(a))
#三个id均不一样

浅拷贝与深拷贝

浅拷贝（copy）：不拷贝子对象的内容，只是拷贝子对象的引用

import copy
a = [10, 20,  [5, 6]]
b = copy.copy(a)
print("a", a)
print("b", b)
b.append(30)
b[2].append(7)
print('浅拷贝')
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]

深拷贝（deepcopy）：会连子对象的内存也拷贝一份，对子对象的修改不会影响源对象·

import copy
a = [10, 20,  [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 [10, 20, [5, 6]]
b [10, 20, [5, 6]]
深拷贝
a [10, 20, [5, 6]]
b [10, 20, [5, 6, 7], 30]

传递不可变对象时，如果发生拷贝，用的是浅拷贝

a = (10, 20, [5, 6])
def abc(m):
    m[2][0] = 888       # 列表对象是可以改变的
    print(m)			# 对于不可变对象需要print(m)
abc(a)

参数的几种类型

a.位置参数

b.默认值参数

执行结果：
8 9 10 20
8 9 19 20

c.命名参数

使用命名参数时不一定要位置匹配

def abc(a, b, c):
    print(a,b,c)
abc(3,4,5)
# 位置
def abc(a=8, b=9, c=10):
   print(a,b,c)
abc(6,7,8)
#默认值
def abc(a, b, c):
    print(a,b,c)
abc(b=4,a=5,c=9)

d.可变参数

• 一个星号将多个参数放到一个元组中
• 两个星号讲多个参数放到一个字典中

def number(x,*y,**z):
    print(x,y,z)
number(2, 3, name="grace", age=18)  #打印结果2 (3,) {'name': 'grace', 'age': 18}，**一定对

e.强制命名参数

在带星号的“可变参数”后面增加新的参数，必须在调用的时候“强制命名参数”
在def f1(a,b,c):的例子中，不确定a对应一个数还是两个数

def number(*x,y,z):
    print(x,y,z)
number(2,y=3,z=4)

3.lambda表达式

lambda表达式用来声明匿名函数，lambda函数是一种简单的，在同一行中定义函数的方法。lambda函数实际上生成了一个函数对象。
lambda表达式只允许包含一个表达式，不能包含复杂语句，该表达式的计算结果就是函数的返回值。
lambda1表达式的基本语法如下：
lambda arg1,arg2,arg3:<表达式>
arg1，arg2，arg3为函数的参数，<表达式>相当于函数体。运算结果是表达式的运算结果

f = lambda a, b, c : a+b+c
print(f(2,3,4))
g = [lambda a:a*2,lambda b:b*2, lambda c:c*2]
print(g[0](3))
def f01(a,b,c):
    return a*b*c
h = [f01,f01]           #要先将函数放在列表中，对列表赋值
print(h[0](3,4,5))

eval()函数
功能：将字符串str当成有效的表达式来求值并返回计算结果
语法：eval(source[, globals[,locals]])
参数
source：一个python表达式或函数compile()返回的代码对象，
globals：可选，必须是dictionary
locals：可选，任意映射对象

a = 10
b = 10
c = eval("a+b")             # eval能够对引号里的内容进行操作
print(c)
dict1 = dict(a=100, b=200)
d = eval("a+b", dict1)      # 代表是dict1的数据
print(d)

4.递归函数

递归函数：自己调用自己的函数

1. 终止条件
2. 递归步骤：把第n步的值和第n-1步相关联

def func01(n):
    print("func01:", n)    # n从5开始取值，一直取到0
    if n == 0:
        print("over")
    else:
        func01(n-1)
# 这里的print发生在取值结束后，因此n倒过来取值
    print("func01***", n)     
func01(5)

结果：
func01: 5
func01: 4
func01: 3
func01: 2
func01: 1
func01: 0
over
func01*** 0
func01*** 1
func01*** 2
func01*** 3
func01*** 4
func01*** 5

练习：阶乘

def func01(n):
    if n == 1:
        return 1                    # n = 1需要结束，则需要return特定值
    else:
        return n*func01(n-1)        # else后需要接表达式
print(func01(5))