函数详解
1. 函数是什么
编程中的函数和数学中的函数有一定的相似之处。
数学上的函数，比如 y = sinx，x 取不同的值 y 就会得到不同的结果
在编程中的函数，是一段可以被重复使用的代码片段。
代码示例：求数列的和，不使用函数
# 1.求 1-100 的和
theSum = 0
for i in range(1, 101):
theSum += i
print(theSum)
# 2.求 300-400 的和
theSum = 0
for i in range(300, 401):
theSum += i
print(theSum)
# 3.求 1-1000 的和
theSum = 0
for i in range(1, 1001):
theSum += i
print(theSum)
我们发现，这几组代码基本是相似的，只有一点点差异。可以把重复的代码提取出来，做成一个函数。
代码示例：求数列的和，使用函数
# 定义函数
def calcSum(beg, end):
theSum = 0
for i in range(beg, end + 1):
theSum += i
print(theSum)
# 调用函数
calcSum(1, 100)
calcSum(300, 400)
calcSum(1, 1000)
可以明显的看到，重复的代码已经被消除了。
2. 语法格式
- 创建函数/定义函数
def 函数名(形参列表): 函数体 return 返回值
- 形参列表中，可以有多个形参，多个形参(形式参数)之间使用逗号分隔。
- 函数体的部分要带有一级缩进（带有缩进的代码，才是函数体内部的语句）
- return 返回值 指得是函数的返回值，函数执行到 return 就意味着执行完了，return 后面的值 就是函数的返回值。return 语句并不是必须的，可以有也可以没有。
- 调用函数/使用函数
函数名(实参列表) # 不考虑返回值 返回值 = 函数名(实参列表) # 考虑返回值实际参数，简称实参。函数名(实参列表)，这里的实参列表写实参的个数要和形参的个数匹配。
注意：
- 函数必须先定义，后使用
test() def test(): print('hello')还没有执行到定义，就先执行调用了，此时就会报错。
- 函数定义并不会执行函数体内容，必须要调用才会执行，调用几次就会执行几次
def test(): print('hello')如果光是定义函数，而不调用，则不会执行。
3. 函数参数
在函数定义的时候, 可以在 ( ) 中指定 “形式参数” (简称 形参)，然后在调用的时候, 由调用者把 “实际参数” (简称 实参) 传递进去。
这样就可以做到一份函数, 针对不同的数据进行计算处理。
考虑到前面的代码：
def calcSum(beg, end):
theSum = 0
for i in range(beg, end + 1):
theSum += i
print(theSum)
calcSum(1, 100)
calcSum(300, 400)
calcSum(1, 1000)
上面的代码中，beg，end 就是函数的形参。1, 100 / 300, 400 就是函数的参数。
在执行 sum(1, 100) 的时候, 就相当于 beg = 1, end = 100 , 然后在函数内部就可以针对 1-100 进行运算。
注意：
- 一个函数可以有一个形参，也可以有多个形参，也可以没有新参。
- 一个函数的形参有几个，那么传递实参的时候也得传几个，保证个数要匹配。
def test(a, b, c): print(a, b, c) test(10)
- 和 C++ / Java 不同, Python 是动态类型的编程语言, 函数的形参不必指定参数类型。换句话说, 一个函数可以支持多种不同类型的参数。
def test(a): print(a) test(10) test('hello') test(True)
4. 函数返回值
函数的参数可以视为是函数的“输入”，则函数的返回值，就可以视为是函数的“输出”。
还是前面的求和代码
def calcSum(beg, end):
theSum = 0
for i in range(beg, end + 1):
theSum += i
print(theSum)
calcSum(1, 100)
可以转换成
def calcSum(beg, end):
theSum = 0
for i in range(beg, end + 1):
theSum += i
return theSum
result = calcSum(1, 100)
print(result)
改进之后的代码，在 calcSum 函数内部，知识进行了计算，而把打印的逻辑放到了函数外面。calcSum 把计算将结果当作返回值，返回给“函数调用者”— result。
我们一般更倾向于第二种写法
- 一个通用的编程原则：一个函数只做一件事。
- 第一种写法，函数即做了计算，又做了打印（和用户交互）。
- 第二种写法，函数只是做了计算，不关心如何和用户交互。
一旦后续需要改变和用户交互方式，第二种写法就更有优势（不必修改函数代码），当前是通过控制台和用户交互的。
- 一个函数可以有多个 return 语句
示例：判定是否是奇数# 判定是否是奇数 def isOdd(num): if num % 2 == 0: return False else: return True result = isOdd(10) print(result)
- 执行到 return 语句，函数就会立即执行结束，回到调用位置。
# 判定是否是奇数 def isOdd(num): if num % 2 == 0: return False return True result = isOdd(10) print(result)把 return True 写到 if 外面意味着条件是否满足都会执行 return True，但是再仔细观察，就会发现条件满足之后，if 里面有一个 retrun 了。一旦条件满足，是没有机会执行到 return True。
如果 if 里面没有 return 语句，就不能这么写了。
- 一个函数可以一次返回多个返回值。使用 , 来分割多个返回值
def getPoint(): x = 10 y = 20 return x, y a, b = getPoint()
- 如果只想关注其中的部分返回值，可以使用 _ 来忽略不想要的返回值。
def getPoint(): x = 10 y = 20 return x, y _, b = getPoint()
5. 变量作用域
观察一下代码
def getPoint():
x = 10
y = 20
return x, y
x, y = getPoint()
在这个代码中，函数内部存在 x，y，函数外部也有 x，y。但是这两组 x，y不是相同的变量，而是恰好有一样的名字。
- 变量只能在所在的函数内部生效
def getPoint(): x = 10 y = 20 return x, y getPoint() print(x, b)
- 在不同的作用域中，允许存在同名的变量
虽然名字相同，但实际是不同的变量x = 20 def test(): x = 10 print(f'函数内部 x = { x}') test() print(f'函数外部 x = { x}')
注意：
- 函数外部的变量，称为全局变量
- 函数内部的变量，称为局部变量
- 如果函数内部尝试访问的变量在局部不存在, 就会尝试去全局作用域中查找
x = 20 def test(): print(f'x = { x}') test()
- 如果是想在函数内部，修改全局变量的值，需要使用 global 关键字声明
x = 20 def test(): global x x = 10 print(f'函数内部 x = { x}') test() print(f'函数外部 x = { x}')
如果此处没有 global , 则函数内部的 x = 10 就会被视为是创建一个局部变量 x, 这样就和全局变量 x 不相关了。
- if / while / for 等语句块不会影响到变量作用域
for i in range(1, 10): print(f'函数内部 i = { i}') print(f'函数外部 i = { i}')
6. 函数执行过程
- 调用函数才会执行函数体代码. 不调用则不会执行。
- 函数体执行结束(或者遇到 return 语句), 则回到函数调用位置, 继续往下执行。
def test():
print("执行函数内部代码")
print("执行函数内部代码")
print("1111")
test()
print("2222")
test()
print("3333")
这个过程还可以使用 PyCharm 自带的调试器来观察.
- 点击行号右侧的空白, 可以在代码中插入 断点
- 右键, Debug, 可以按照调试模式执行代码. 每次执行到断点, 程序都会暂停下来。
- 使用 Step Into (F7) 功能可以逐行执行代码。
7. 链式调用
把一个函数的返回值，作为另一个函数的参数，这种操作称为 链式调用。
代码示例：
# 判断是否是奇数
def isOdd(num):
if num % 2 == 0:
return False
else:
return True
result = isOdd(10)
print(result)
我们前面很多代码都是这样写的，但实际上可以简化的写作
print(isOdd(10))
这就是函数的链式调用，这是一种比较常见的写法。
8. 嵌套调用
内部函数还可以调用其他函数，这个动作称为嵌套调用。
def test():
print("执行函数内部代码")
print("执行函数内部代码")
print("执行函数内部代码")
test 函数内部调用了 print 函数，这里就属于嵌套调用。
一个函数里面可以嵌套调用任意多个函数
def a(): print("函数 a") def b(): print("函数 b") a() def c(): print("函数 c") b() def d(): print("函数 d") c() d()
图解：
函数之间的调用关系，在 Python中会使用一个特定的数据结构来表示，称为 函数调用栈。每次函数调用，都会在调用栈里新增一个元素，称为 栈帧。
可以通过 PyCharm 调试器看到函数调用栈和栈帧。
在调试状态下, PyCharm 左下角一般就会显示出函数调用栈。
每个函数的局部变量，都包含在自己的栈帧中
def a(): num = 10 print("函数 a") def b(): num = 20 print("函数 b") a() def c(): num = 30 print("函数 c") b() def d(): num = 40 print("函数 d") c() d()选择不同的栈帧，就可以看到各自栈帧中的局部变量
9. 函数递归
函数递归 就是一个函数自己调用自己。
函数递归的两个必要条件:
(1) 存在限制条件，当满足这个限制条件的时候，递归便不再继续。
(2) 每次递归调用之后越来越接近这个限制条件。
示例：递归计算 5的阶乘
def Fac(n):
if n <= 1:
return 1
else:
return n * Fac(n - 1)
result = Fac(5)
print(result)
图解：
递归的优点
- 递归类似于 “数学归纳法” , 明确初始条件, 和递推公式, 就可以解决一系列的问题。
- 递归代码往往代码量非常少。
递归的缺点
- 递归代码往往难以理解, 很容易超出掌控范围。
- 递归代码容易出现栈溢出的情况。
- 递归代码往往可以转换成等价的循环代码. 并且通常来说循环版本的代码执行效率要略高于递归版本。
10. 参数默认值
Python 中的函数，可以给形参指定默认值
带有默认值的参数，可以在调用的时候不传参
代码示例：计算两个数的和
def add(x, y, debug=False):
if debug:
print(f'x = {
x}, y = {
y}')
return x + y
print(add(10, 20))
print(add(10, 20, True))
此处 debug=False 即为参数默认值. 当我们不指定第三个参数的时候, 默认 debug 的取值即为 False.
带有默认值的参数需要放到没有默认值的参数的后面
def add(x, debug=False, y): if debug: print(f'x = { x}, y = { y}') return x + y print(add(10, 20))
11. 关键字参数
在调用函数的时候, 需要给函数指定实参. 一般默认情况下是按照形参的顺序, 来依次传递实参的。
但是我们也可以通过 关键字参数, 来调整这里的传参顺序, 显式指定当前实参传递给哪个形参。
关键字传参就是按照形参的名字来进行传参。
def test(x, y):
print(f'x = {
x}')
print(f'y = {
y}')
test(x=10, y=20)
test(x=100, y=200)
形如上述 test(x=10, y=20) 这样的操作, 即为 关键字参数。
位置参数可以和关键字参数还能混着用，只不过混着用的时候要求位置参数在前，关键参数在后。
关键字参数，一般是搭配默认参数来使用的。
本章到这里就结束啦，如果有哪里写的不好的地方，请指正。
如果觉得不错并且对你有帮助的话请给个三连支持一下吧！
Fighting!!!✊