Day10 函数基础

1. 函数的作用

当我们想执行重复某个操作的时候，可以把该操作封装成函数，只需调用函数即可。
1）比如：求一个数的阶乘

# 求100的阶乘
sum1 = 0
for i in range(1, 101):
    sum1 += i
print(sum1)
1
2
3
4
5

2）封装成函数

def sumN(num):
    sum1 = 0
    for i in range(1, num):
        sum1 += i
    print(sum1)
1
2
3
4
5

3）调用函数

sumN(10)
sumN(50)
sumN(100)
1
2
3

45
1225
4950

在此过程中，我们求10、50、100的阶乘的时候就不需要写三次求阶乘的代码，只需要调用三次求阶乘的函数即可，大量节省我们的时间和精力，也使代码更加简洁。

2. 认识函数

2.1 什么是函数

在真正认识函数之前，我们可以将封装的函数当做一个机器，我们需要做什么的时候就用对应功能的现成机器即可，不需要再次建一个机器，封装函数的过程就是制造机器的过程；函数运行出的什么样的结果，也就相当于机器能为我们做什么（比如洗衣机，饮水机，咖啡机）。
特定地说，函数就是实现某一特定功能的代码的封装。（函数就是将实现某一个或某一类功能的代码打成一个包。目的就是为了以后需要这个包装的代码对应的功能时，不用重新写这段代码，而是使用封装这段代码的函数）。

2.2 函数的分类

根据这个函数是由谁创建的，可以将函数分为系统函数，和自定义函数两种
1）系统函数（系统已经造好的机器） - 由系统创建的函数（Python本身就创建好的函数），列如：print、input、type、max、min等
2）自定义函数（自己造的机器） - 由程序员自己创建的函数
3）定义函数的方法（造机器）

语法：
def 函数名(形参列表):
    函数说明文档
    函数体

说明：
1）def：关键字（固定写法）
2）函数名：由程序员自己命名
两个要求：标识符的标准；不是关键字
三个规范：见名知意（看到函数名大概知道函数功能）；所有字母都小写，多个单词用下划线隔开；不使用系统的函数名、类名、模块名
3）(): ：固定写法
4）形参列表：以'变量名1, 变量名2, 变量名3, ...'的形式存在，根据情况变量的数量可以为0（每一个变量就是一个形参）
           形参的作用：将函数外部的数据传递到函数里面（想象一下洗衣机的洗衣筒和水接口,有衣服有水洗衣机的运作才有意义），是机器外部和内部交互数据的接口（只进不出）。
           确定形参的方法：看实现函数的功能需不需要额外的数据，及需要多少个额外的数据   
5）函数说明文档：多行注释（相当于机器的说明书）
6）函数体：结构上，和def保持一个缩进的一条或多条语句
         逻辑上，函数体就是实现函数功能的代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

练习：

• 定义一个函数求两个数的乘积

def product(num1, num2):
    '''
    求两个数的乘积
    :param num1:一个数
    :param num2:另一个数
    :return:两个数的乘积
    '''
    print(num1 * num2)
    
product(10, 20)
1
2
3
4
5
6
7
8
9
10

200

• 定义一个函数统计字符串中数字字符的个数

def num_count(str1):
    '''
    统计字符串中数字的个数
    :param str1:指定的字符串
    :return:None
    '''
    count = 0
    for i in str1:
        if i.isdigit():
            count += 1
    print(count)

num_count('cdiff8re3443i9')
1
2
3
4
5
6
7
8
9
10
11
12
13

6

• 定义一个函数，将两个字符串中所有的大写字母合并成一个新的字符串

def capital_str(str1, str2):
    '''
    将两个字符串中所有的大写字母合并成一个新的字符串
    :param str1:
    :return:
    '''
    new_str = ''
    for i in str1 + str2:
        if i.isupper():
            new_str += i
    print(new_str)

capital_str('AHUIJoiju9', 'KOkoojOK')
1
2
3
4
5
6
7
8
9
10
11
12
13

AHUIJKOOK

3. 调用函数

使用函数（使用机器）

3.1 调用函数

语法：
函数名（实参列表）

说明：
1）函数名：需要哪个函数对应的功能就调用哪个函数，即就写哪个函数名（函数名是已经被定义过的函数名）
2）() ：固定写法（装实参）
3）实参列表：以'数据1, 数据2, 数据3, ...'的形式存在，这儿的每一个数据就是一个实参。（实参对应的数据可以是任何有结果的表达式）
   实参是用来给形参赋值的，提供实参的时候要保证和对应的形参一一对应
   
   变量名1, 变量名2, 变量名3, ... = 数据1, 数据2, 数据3, ...  -  形参 = 实参（个数和顺序都要对应）

结论：定义函数不会执行函数体，调用函数的时候才会在执行函数体
1
2
3
4
5
6
7
8
9
10
11
12

3.2 函数调用过程

每次调用函数的时候，它的执行步骤：
第一步：回到函数定义的位置
第二步：传参（用实参给形参赋值，传参的时候保证每个参数都有值）
第三步：执行函数体
第四步：确定函数返回值
第五步：回到函数调用的位置，接着往后执行

4. 函数的参数

4.1 位置参数和关键字参数

有关键字，顺序不同都不会影响结果
根据实参的提供方式将实参分为位置参数和关键字参数两种：
1）位置参数：以’实参1, 实参2, 实参3, …'的形式存在，让实参和形参从位置上一一对应
2）关键字参数：以’形参1 = 实参1, 形参2 = 实参2, 形参3 = 实参3, …‘的形式存在，通过’='将实参和形参对应

注意：位置参数和关键字参数可以一起用，但要保证位置参数在关键字参数的前面

def func1(x, y, z):
    print(f'x:{x}, y:{y}, z:{z}')

func1(10, 20, 30)       # x:10, y:20, z:30
func1(20, 10, 30)       # x:20, y:10, z:30

func1(x=10, y=20, z=30)     # x:10, y:20, z:30
func1(y=20, x=10, z=30)     # x:10, y:20, z:30

func1(10, y=20, z=30)
func1(10, z=30, y=20)

# func1(x=10, 20, z=30)         # 报错！

func1(10, 20, z=30)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

x:10, y:20, z:30
x:20, y:10, z:30
x:10, y:20, z:30
x:10, y:20, z:30
x:10, y:20, z:30
x:10, y:20, z:30
x:10, y:20, z:30

def func2(x=10, y=20, z=30):
    print(f'x:{x}, y:{y}, z:{z}')


func2()
func2(100)
func2(100, 200)
func2(100, 200, 300)

# 如果想要跳过前面有默认值的参数，直接给后面的参数赋值，使用关键字参数传参
func2(z=300)
1
2
3
4
5
6
7
8
9
10
11

x:10, y:20, z:30
x:100, y:20, z:30
x:100, y:200, z:30
x:100, y:200, z:300
x:10, y:20, z:300

4.2 参数默认值

定义函数的时候可以通过’形参名 = 数据’的方式给形参赋默认值；
在调用函数的时候，有默认值的参数可以不用传参，也可以传参（不传参就使用默认值，传参就修改默认值赋新值）

如果想要跳过前面的默认值参数，直接使用关键字给后面的参数传参

注意：定义函数的时候，如果一个函数，有的参数有默认值，有的参数没有默认值，没有默认值的形参必须放在有默认值的前面。

4.3 参数类型说明

没有默认值参数的类型说明：直接在形参后面加’:类型名’
有默认值的参数，默认值数据对应的类型就是形参的类型

def func6(x: str):  # 若只有x，没有说明x，不知道是什么,可以加“:类型名”
    pass
1
2

4.4 *对应的不定长参数

1）参数个数不确定
示例：定义函数求多个数的和
定义函数的时候，如果在某一个形参前面加*，那么这个形参就会变成一个不定长参数，它可以接收多个实参（可以是0个、1个、2个、3个、…）
带*的不定长参数的本质是一个元组，它接收到的实参是这个元组中的元素。

def sumN(*nums):
    sum1 = 0
    for i in nums:
        sum1 += i
    print(sum1)

sumN(10, 20, 30, 40)
1
2
3
4
5
6
7

100

优化：求和的时候至少给两个参数

def sumN1(num1, num2, *nums):
    sum1 = num1 + num2
    for i in nums:
        sum1 += i
    print(sum1)

sumN1(10, 20, 30, 40)
1
2
3
4
5
6
7

100

2）定义函数的时候单独使用*
如果定义函数的时候，形参列表中有一个独立的*，调用函数的时候，*后面的所有形参必须使用关键字传参。

def func7(x, *, y, z):  # 强迫调用函数的时候末尾必须要用关键字传参
    pass
1
2