Python第八章 函数

函数用法和底层分析

函数是可重用的程序代码块。函数的作用，不仅可以实现代码的复用，更能实现代码的一致性。一致性：只要修改函数的代码，则所有调用该函数的地方都能得到体现

函数简介

函数的基本概念

1、一个程序由一个个任务组成：函数就是代表一个任务或者一个功能
2、函数是代码复用的通用机制

Python函数的分类

Python中函数分为如下几类：
1、内置函数
我们前面使用的str()、list()、len()等都是 内置函数，可以拿来直接使用
2、标准库函数
可以通过import语句导入库，然后使用其中定义的函数
3、第三方库函数
Python社区也提供了很多高质量的库。下载安装这些库后，也是通过import语句导入，然后可以使用这些第三方库的函数
4、用户自定义函数
用户自己定义的函数，也是开发中适应因故自身需求定义的函数。

函数的定义和调用

核心要点

Python中函数定义语法：

def 函数名([参数列表]):
	'''文档字符串'''
	函数体/若干语句
	
	

要点：
1、我们使用def来定义函数，然后就是一个空格和函数名称：
（1）Python执行def时，会创建一个函数对象，并绑定到函数名变量上
2、参数列表
（1）圆括号内是形式参数列表，有多个参数则是用逗号隔开
（2）形式参数不需要声明类型，也不需要指定函数返回值类型
（3）无参数，也必须保留空的圆括号
（4）实参列表必须与形参列表一一对应
3、return返回值
（1）如果函数体中包含return语句，则结束函数执行并返回值
（2）如果函数体中不包含return语句，则返回None值

4、调用函数之前，必须要先定义函数，即先调用def创建函数对象
（1）内置函数对象会自动创建
（2）标准库和第三方库函数，通过import导入模块时，会执行模块中的def语句

形参和实参

形式参数是在定义函数时使用的，形式参数的命名只要符合“标识符”命名规则即可
在调用函数时，传递的参数称为“实际参数”，简称“实参”。

文档字符串（函数的注释）

程序的可读性最重要，一般建议在函数体开始的部分附上函数定义说明，这就是“文档字符串”，也有人称为“函数的注释”.我们通过三个单引号或三个双引号实现，中间可以加入多行文字进行说明

def print_star(n):
	'''请根据传入的n,打印多个星号'''
	print("*"n)
help(print_star._doc_)

#可以调用help(函数名._doc_)打印输出函数的文档字符串
Help on function print_star in module_main_:
print_star(n)
	请根据传入的n，打印多个星号

返回值

return返回值要点：
1、如果函数体中包含return语句，则结束函数执行并返回值
2、如果函数体中不包含return语句，则反回None值
3、要返回多个返回值，使用列表、元组、字典、集合将多个值“存起来”即可

函数也是对象，内存底层分析

Python中一切皆对象。实际上del 定义函数执行后，系统就创建了相应的函数对象。

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

变量起作用的范围称为变量的作用域，不同作用域内同名变量之间互不影响。
变量分为：全局变量和局部变量
全局变量：
1、在函数和类定义以外声明的变量。作用域为定义的模块，从定义位置开始到模块结束
2、全局变量降低了函数的通用性和可读性。应尽量避免全局变量的使用
3、全局变量一般做常量使用
4、函数内要改变全局变量的值，使用global声明一下
局部变量：
1、在函数体中（包含形式参数）声明的变量
2、局部变量的引用比全局变量块，优先考虑使用
3、如果局部变量和全局变量同名，则在函数内隐藏全局变量，只使用同名的局部变量

a=100
def f1(a,b,c):
	print(a,b,c)
	print(locals())#输出局部变量
	print(globals())#输出全局变量
f1(2,3,4)

局部变量和全局变量效率测试

局部变量的查询和访问速度比全局变量快，优先考虑使用，尤其是在循环的时候
在特别强调效率的地方或者循环次数较多的地方，可以通过将全局变量转为局部变量提高运行速度

参数的传递

函数的参数传递本质上就是：从实参到形参的赋值操作。Python中“一切皆对象”，所有的赋值操作都是“引用的赋值”。所以，Python中参数的传递都是“引用传递”，不是“值传递。具体操作分为两类：1、对“可变对象”进行“写操作”，直接做用于原对象本身2、对“不可变对象”进行“写操作”，会产生一个新的“对象空间”，并用新的只填充这块空间。（起到其他语言“值传递”效果，但不是“值传递”）
可变对象有：字典、列表、集合、自定义的对象等
不可变的对象有：数字、字符串、元组、function等

传递可变对象的引用

传递参数是可变对象，实际传递的还是对象的引用。在函数体中不创建新的对象拷贝，而是可以直接修改所传递的对象

b=[10,20]
def f2(m):
	print("m:",id(m))
	m.append(30)#由于m是可变对象，不创建对象拷贝，直接修改这个对象
f2(b)
print("b:",id(b))
print(b)

传递不可变对象

传递参数是不可变对象（例如：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))

通过ID值可以看到实参和形参一开始是同一个对象，给形参赋值后，形参是新的对象

浅拷贝和深拷贝

内置函数：copy(浅拷贝)、deepcopy(深拷贝) 引入copy库
浅拷贝：不拷贝子对象的内容，只是拷贝子对象的引用
深拷贝：会连子对象的内存也全部拷贝一份，对子对象的修改不会影响源对象

import copy
def testCopy():#测试浅拷贝
	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)
def testDeepCopy():#测试深拷贝
	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,7]]
b:[10,20,[5,6,7],30]

a:[10,20,[5,6]]
b:[10,20,[5,6]]
********深拷贝
a:[10,20,[5,6]]
b:[10,20,[5,6,7],30]'''

传递不可变对象是浅拷贝
传递参数是不可变对象，实际传递的还是对象的引用。但在“写操作”时，会创建一个新的对象拷贝。这个拷贝使用的是“浅拷贝”，不是“深拷贝”

参数的类型

位置参数

函数调用时，实参默认按位置顺序传递，需要个数和形参匹配。按位置传递的参数，称为“位置参数”

def f(a,b,c):
	print(a,b,c)
f(1,2,3)
f(2,3)#报错，位置参数不匹配

默认值参数

可以为某些参数设置默认值，这样这些参数在传递时就是可选的，称为“默认值参数”。默认值参数放到位置参数后面

命名参数

可以按照形参的名称传递参数，称为“命名参数”，也称“关键字参数”

def f(a,b,c):
	print(a,b,c)
f(8,7,6)#位置参数
f(a=1,c=2,b=3)#命名参数

可变参数

可变参数指的是“可变数量的参数”。分两种情况：
1、“param（一个星号）”，将多个参数收集到一个“元组”对象中
2、“param（两个星号），将多个参数收集到一个“字典”对象中

def f1(a,b,*c):
	print(a,b,c)
f1(4,2,6,5)
def f2(a,b,**c):
	print(a,b,c)
f2(8,9,name="wwj",age=10)
def f3(a,b,*c,**d)
	print(a,b,c,d)
f3(4,5,3,4,name="wwj",age=10)

强制命名参数

在带星号的“可变参数”后面增加新的参数，必须是“强制命名参数”

def f(*a,b,c):
	print(a,b,c)
f(2,3,4)#报错，因为a是可变参数，将2,3，4全部收集，造成bc没有赋值
f(3,b=2,c=5)
#结果：(3) 2 5

lambda表达式和匿名函数

lambda表达式可以用来声明匿名函数。lambda函数试试一种简单的、在同一行中定义函数的方法。lambda函数实际生成了一个函数对象
lambda表达式只允许包含一个表达式，不能包含复杂语句，该表达式的计算结果就是函数的返回值
lambda表达式的基本语法：

lambda arg1,arg2……:<表达式>
#arg1，arg2为函数的参数。<表达式>相当于函数体。运算结果是表达式的运算结果

f=lambda a,b,c:a+b+c
print(f)
print(f(2,3,4))
g=[lambda a:a*2,lambda b:b*3,lambda c:c*4]
print(g[0](6),g[1](7),g[2](8))

eval()函数

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

```python
s="print('agdaga')"
eval(s)

a=10
b=20
c=eval("a+b")
print(c)

dict1=dict(a=100,b=200)
d=eval("a+b",dict1)
print(d)
#agdaga
#30
#300

文章均为本人观看视频学习所记录的知识点笔记（哔哩哔哩视频链接https://www.bilibili.com/video/BV1tU4y1t7rv）