参考链接：函数
虽然原文讲得很详细，但考虑到做个笔记印象会更深刻，就摘录了原文的很多内容。
一、 函数的基本概念_内存分析_函数的分类_定义和调用
1.Python函数的分类
1）内置函数
我们前面使用的str()、list()、len()等这些都是内置函数，我们可以拿来直接使用。
2）标准库函数
我们可以通过import语句导入库，然后使用其中定义的函数
3）第三方库函数
Python社区也提供了很多高质量的库。下载安装这些库后，也是通过import语句导入，然后可以使用这些第三方库的函数
4）用户自定义函数
用户自己定义的函数，显然也是开发中适应用户自身需求定义的函数。今天我们学习的就是如何自定义函数。
2.函数的定义和调用
语法如下：
def 函数名 ([参数列表]) :
'''文档字符串'''
函数体/若干语句
要点：
1）我们使用def来定义函数，然后就是一个空格和函数名称
- Python执行def时，会创建一个函数对象，并绑定到函数名变量上。
2）参数列表
- 圆括号内是形式参数列表，有多个参数则使用逗号隔开
- 形式参数不需要声明类型，也不需要指定函数返回值类型
- 无参数，也必须保留空的圆括号
- 实参列表必须与形参列表一一对应
3） return返回值
- 如果函数体中包含return语句，则结束函数执行并返回值;
- 如果函数体中不包含return语句，则返回None值。
4）调用函数之前，必须要先定义函数，即先调用def创建函数对象
- 内置函数对象会自动创建
- 标准库和第三方库函数，通过import导入模块时，会执行模块中的def语句
二、函数也是对象，内存底层分析
实际上，执行def定义函数后，系统就创建了相应的函数对象。
代码：
def print_star(n):
print("*" * n)
print(print_star)
print(id(print_star))
c = print_star
c(3)
运行结果：
<function print_star at 0x000002736AD7D160>
2694737023328
***
上面代码执行def时，系统中会创建函数对象，并通过print_star这个变量进行引用：
执行“c=print_star”后，显然将print_star变量的值赋给了变量c，内存图变成了：
变量c和print_star都是指向了同一个函数对象。因此，执行c(3)和执行print_star(3)的效果是完全一致的。Python中，圆括号意味着调用函数。在没有圆括号的情况下，Python会把函数当做普通对象。
与此核心原理类似，我们也可以做如下操作：
>>> zs = int
>>> zs(234)
234
>>> zs('12')
12
>>>
显然，我们将内置函数对象int()赋值给了变量zhengshu，这样zhengshu和int都是指向了同一个内置函数对象。
三、变量的作用域(全局变量和局部变量)
变量分为：全局变量、局部变量。
全局变量：
（1）在函数和类定义之外声明的变量。作用域为定义的模块，从定义位置开始直到模块结束。
（2）全局变量降低了函数的通用性和可读性。应尽量避免全局变量的使用。
（3）全局变量一般做常量使用。
（4）函数内要改变全局变量的值，使用global声明一下
局部变量：
（1） 在函数体中(包含形式参数)声明的变量。
（2） 局部变量的引用比全局变量快，优先考虑使用。
（3） 如果局部变量和全局变量同名，则在函数内隐藏全局变量，只使用同名的局部变量
代码：
a = 100
def f1(a, b, c):
print(a, b, c)
print(locals()) # 打印输出的局部变量
print('#' * 20)
print(globals()) # 打印输出的全局变量
f1(2, 3, 4)
运行结果：
2 3 4
{'a': 2, 'b': 3, 'c': 4}
####################
{'__name__': '__main__', '__doc__': '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x00000223C4984760>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'D:\\MyDocuments\\Code\\Python\\pythonProject1\\mypy14.py', '__cached__': None, 'a': 100, 'f1': <function f1 at 0x00000223C497D160>}
四、局部变量和全局变量效率测试
局部变量的查询和访问速度比全局变量快，优先考虑使用，尤其是在循环的时候。
【pycharm快捷键：
选中内容 + Tab：缩进
选中内容 + Shift + Tab：取消缩进
选中内容 + CTRL + /：多行注释，重复则取消注释】
效率测试代码：
import math
import time
def test01(): # 测试全局变量的效率
start = time.time()
for i in range(10000000):
math.sqrt(30) # 全局变量math
end = time.time()
print("耗时{0}".format((end-start)))
def test02(): # 测试局部变量的效率
b = math.sqrt # b为局部变量
start = time.time()
for i in range(10000000):
b(30)
end = time.time()
print("耗时{0}".format((end-start)))
test01()
test02()
运行结果：
耗时1.0426316261291504
耗时0.8823099136352539
五、参数的传递_传递可变对象_内存分析
Python中“一切皆对象”，所有的赋值操作都是“引用的赋值”。所以，Python中参数的传递都是“引用传递”，不是“值传递”。具体操作时分为两类：
1.对“可变对象”进行“写操作”，直接作用于原对象本身。
2.对“不可变对象”进行“写操作”，会产生一个新的“对象空间”，并用新的值填充这块空间。(起到其他语言的“值传递”效果，但不是“值传递”)
可变对象有：
字典、列表、集合、自定义的对象等
不可变对象有：
数字、字符串、元组、function等
- 【操作】参数传递：传递可变对象的引用
代码：
# 传递可变对象的引用
b = [10,20]
def f2(m):
print('m:',id(m))
m.append(30)
f2(b)
print('b:',id(b))
print(b)
运行结果：
m: 2548398049536
b: 2548398049536
[10, 20, 30]
以上说明：参数的传递都是“引用传递”，而且对“可变对象”进行“写操作”，直接作用于原对象本身。
- 传递参数是不可变对象(例如：int、float、字符串、元组、布尔值)，实际传递的还是对象的引用。在”赋值操作”时，由于不可变对象无法修改，系统会新创建一个对象。
- 【操作】参数传递：传递不可变对象的引用
代码：
# 传递不可变对象的引用
a = 100
print('a:',id(a))
def f1(n):
print('n:',id(n)) # 传递进来的是a对象的地址
n = n + 200 # 由于a是不可变对象，因此创建新的对象n
print('n:',id(n)) # n已经变成了新的对象
print(n)
f1(a)
print('a:',id(a))
print(a)
运行结果：
a: 2474685191632
n: 2474685191632
n: 2474686122288
300
a: 2474685191632
100
显然，通过id值我们可以看到n和a一开始是同一个对象。给n赋值后，n是新的对象。在函数中修改不可变对象，是不会改变原有不可变对象的值的。
六、对象的浅拷贝和深拷贝（难点）
- 变量的赋值操作
只是形成两个变量，实际还是指向同一个对象。 - 浅拷贝
Python拷贝一般都是浅拷贝。拷贝时，对象包含的子对象内容不拷贝。因此，源对象和拷贝对象会引用同一个子对象。修改拷贝对象，同时也会修改原对象里面包含的子对象。
代码：
# 测试对象浅拷贝
import copy
a = [10,20,[5,6]]
b = copy.copy(a) # a的[5,6]列表对象不会被复制，如要修改就会找到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]
代码解析：
- 深拷贝
使用copy模块的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]) #不可变对象
print('id(a):',id(a))
def test01(m):
print('id(m):',id(m)) # 与a地址一样
m[2][0] = 888 # 创建了一个m[2][0]的列表新对象，列表对象是可变的，也就修改了源元组对象的列表子对象
print('m:',m)
print('id(m):',id(m))
test01(a)
print('a:',a)
运行结果：
id(a): 2612289923456
id(m): 2612289923456
m: (10, 20, [888, 6])
id(m): 2612289923456
a: (10, 20, [888, 6])
代码解析：
七、参数的类型_位置参数_默认值参数_命名参数
1.位置参数
函数调用时，实参默认按位置顺序传递，需要个数和形参匹配。按位置传递的参数，称为：“位置参数”。
【操作】测试位置参数
def f1(a,b,c):
print(a,b,c)
f1(2,3,4)
f1(2,3) # 报错，位置参数不匹配
输出：
Traceback (most recent call last):
File "D:\MyDocuments\Code\Python\pythonProject1\mypy15.py", line 44, in <module>
f1(2,3)
TypeError: f1() missing 1 required positional argument: 'c'
2 3 4
2.默认值参数
可以为某些参数设置默认值，当传参时没有给这些默认参数赋值，则用这些默认参数的默认值，否则用传递过来的值。
代码：
def f1(a,b,c=10,d=20):
print(a,b,c,d)
f1(8,9) # 输出 8 9 10 20
f1(8,9,19) # 输出 8 9 19 20
3.命名参数
可以按照形参的名称传递参数，称为“命名参数”，也称“关键字参数”。
【操作】测试命名参数
代码：
def f1(a,b,c):
print(a,b,c)
f1(8,9,19) # 输出 8 9 19
f1(c=10,a=20,b=30) # 输出 20 30 10
八、可变参数
可变参数指的是“可变数量的参数”。分两种情况：
- *param(一个星号)，将多个参数收集到一个“元组”对象中。
- **param(两个星号)，将多个参数收集到一个“字典”对象中。
【操作】测试可变参数处理(元组、字典两种方式)。
代码：
def f1(a, b, *c): # c为元组对象
print(a, b, c)
f1(8, 9, 19, 20)
def f2(a, b, **c): # c为字典对象
print(a, b, c)
f2(8, 9, name='张三', age=18)
def f3(a, b, *c, **d): # c为元组对象，d为字典对象
print(a, b, c, d)
f3(8, 9, 20, 30, name='张三', age=18)
输出：
8 9 (19, 20)
8 9 {'name': '张三', 'age': 18}
8 9 (20, 30) {'name': '张三', 'age': 18}
强制命名参数
在带星号的“可变参数”后面增加新的参数，必须在调用的时候“强制命名参数”。
【操作】强制命名参数的使用
代码：
def f1(*a, b, c):
print(a, b, c)
# f1(2,3,4) #会报错。由于a是可变参数，将2,3,4全部收集。造成b和c没有赋值。
f1(2, b=3, c=4)
输出：
(2,) 3 4
九、lambda表达式和匿名函数
1.lambda表达式
lambda表达式可以用来声明匿名函数。lambda函数是一种简单的、在同一行中定义函数的方法。lambda函数实际生成了一个函数对象。
lambda表达式只允许包含一个表达式，不能包含复杂语句，该表达式的计算结果就是函数的返回值。
lambda表达式的基本语法如下：
lambda arg1,arg2,arg3... : <表达式>
# arg1/arg2/arg3为函数的参数。
# <表达式>相当于函数体，会用到arg1/arg2/arg3这三个参数
【操作】lambda表达式使用
代码：
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)) # def定义的函数也可以这么用
输出：
<function <lambda> at 0x00000254A978D160>
9
12 21 32
内存解析：
十、eval()函数
功能：将字符串str当成有效的表达式来求值并返回计算结果。
语法： eval(source[, globals[, locals]]) -> value
参数：
source：一个Python表达式或函数compile()返回的代码对象
globals：可选。必须是dictionary
locals：可选。任意映射对象
若有globals或者locals，将这些作为上下文进行计算
代码：
# 测试eval()函数
s = "print('abcde')"
eval(s) # 将字符串"print('abcde')"当成有效表达式：print('abcde')执行，输出：abcde
a = 10
b = 20
c = eval("a+b") # 将字符串"a+b"当成有效表达式：a+b执行，c=30
print(c) # 输出：30
dict1 = dict(a=100,b=200) # 定义一个字典对象
d = eval("a+b",dict1) # 取字典里面的 a和b进行计算
print(d) # 输出：300
十一、递归函数
先进后出，最先调用的最后出栈
代码：
# 递归
def test01(n):
print('test01:', n) # 可以显示进栈顺序
if n == 0:
print('over')
else:
test01(n - 1)
print('test01***',n) # 可以显示出栈顺序
def test02():
print('test02')
test01(4)
输出：
test01: 4
test01: 3
test01: 2
test01: 1
test01: 0
over
test01*** 0
test01*** 1
test01*** 2
test01*** 3
test01*** 4
十二、递归函数_阶乘计算案例
【操作】 使用递归函数计算阶乘(factorial)
代码：
def factorial(n):
if n == 1:
return 1
else:
return n * factorial(n - 1)
for i in range(1, 6):
print(i, '!=', factorial(i))
输出：
1 != 1
2 != 2
3 != 6
4 != 24
5 != 120
内存分析：
递归函数由于会创建大量的函数对象、过量的消耗内存和运算能力。在处理大量数据时，谨慎使用。
十三、嵌套函数(内部函数)
在函数内部定义的函数!
【操作】嵌套函数定义
代码：
def f1():
print('f1 running...')
def f2():
print('f2 running...')
f2()
f1()
输出：
f1 running...
f2 running...
一般在什么情况下使用嵌套函数?
1. 封装 - 数据隐藏
外部无法访问“嵌套函数”。
2. 贯彻 DRY(Don’t Repeat Yourself) 原则
嵌套函数，可以让我们在函数内部避免重复代码。
3. 闭包
后面会详细讲解。
十四、nonlocal关键字
nonlocal 用来声明外层的局部变量。
global 用来声明全局变量。
代码：
# 测试nonlocal、global关键字的用法
a = 100
def outer():
b = 10
def inner():
nonlocal b # 声明外部函数的局部变量
print("inner b:", b)
b = 20
global a # 声明全局变量
a = 1000
inner()
print("outer b:", b)
outer()
print("a：", a)
输出：
inner b: 10
outer b: 20
a： 1000
十五、LEGB规则
Python在查找“名称”时，是按照LEGB规则查找的：
Local–>Enclosed–>Global–>Built in
Local 指的就是函数或者类的方法内部
Enclosed 指的是嵌套函数(一个函数包裹另一个函数，闭包)
Global 指的是模块中的全局变量
Built in 指的是Python为自己保留的特殊名称。
代码：
# 测试LEGB
str = "global"
def outer():
# str = "outer"
def inner():
# str = "inner"
print(str)
inner()
outer()
输出：
global
依次将几个str注释掉，观察控制台打印的内容，体会LEBG的搜索顺序。
扫一扫
276
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
