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 返回值

1. 形参列表中，可以有多个形参，多个形参(形式参数)之间使用逗号分隔。
2. 函数体的部分要带有一级缩进（带有缩进的代码，才是函数体内部的语句）
3. 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!!!✊