【Python学习】Day-015 Day-016 认识函数、函数分类、定义函数、调用函数、函数的参数、函数的返回值、变量作用域、函数参数的确定、匿名函数、常用的实参高阶函数

本文链接：https://blog.csdn.net/ChenAi_140/article/details/126106376

文章目录

1. 认识函数

函数的价值
当一个功能需要重复使用的时候，实现功能的代码只需要写一遍，每次使用时调用就可以了。
什么是函数
函数将实现一个或者某些类功能的代码打包，以后在需要这个包中的这段代码对应的功能的时候不需要重新写这段代码，而是使用封装了这段代码的函数)

2. 函数的分类

根据这个函数是由谁创建的，我们将函数分为系统函数和自定义函数两种

系统函数 - 由系统创建的函数(Python本身就创建好的函数)，例如: print. input. type. max、 min等
自定义函数 - 由程序员自己定义(创建)的函数

3. 定义函数

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

def - 关键字;固定写法
函数名 - 由程序员自己命名;
- 两个要求:是标识符;不是关键字
- 三个规范:见名知义(看到函数名就大概知道函数的功能是什么);
  所有的字母都小写，多个单词用下划线隔开;
  不使用系统的函数名、类名和模块。
(): - 固定写法
形参列表 - 以’变量名1 ,变量名2 ,变量名3… '的形式存在，根据情况变量的数据可以为0 (每- -个变量就是一个形参)。
- 形参的作用:将函数外部的数据传递到函数里面。
- 确定形参的方法:看实现函数的功能需不需要额外的数据,需要多少个额外的数据。
函数说明文档 - 就是多行注释

函数体 -

结构上，和def保持-一个缩进的一条或者多条语句
逻辑上，函数体就是实现函数功能的代码。

# 定义一个函数求-个数的阶乘
def factorial(n):
    '''ad'''
    sum1 = 1
    for i in range(1, n+1):
        sum1 *= i
    return sum1
factorial(5)

# 运行结果
'''
120
'''

4. 调用函数

调用函数(使用函数)

语法：
函数名(实参列表)

说明：

函数名 - 需要哪个函数对应的功能，就调用哪个函数；想要调用哪个函数就写哪个函数的函数名。
注意：函数名必须是已经定义过的函数的函数名
() - 固定写法
实参列表 - 以’数据1, 数据2, 数据3,…'的形式存在，这儿的每个数据就是一个实参。（实参对应的数据可以是任何有结果的表达式）
- 实参是用来给形参赋值，在提供实参的时候要保证和形参一一对应。
- 变量名1,变量名2,变量名3,… = 数据1, 数据2, 数据3,… —> 形参 = 实参

重要结论：定义函数不会执行函数体，调用函数的时候才会执行函数体

def func():
    print('======')
    print('++++++')
    print('------')

func()

# 运行结果
'''
======
++++++
------
'''

函数调用过程

每次在调用函数的时候，它的执行步骤：

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

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

func4(100, 200, 300)
print('end!')

# 运行结果
'''
x:100, y:200, z:300
end!
'''

关于形参几种错误的写法

示例：定义一个函数统计数字字符的个数

# 错误写法1
str1 = 'man闪烁234'
def count_nums2():
    count = 0
    for x in str1:
        if x.isdigit():
            count += 1
    print(count)

count_nums2()

# 错误写法2
def count_nums3():
    str1 = 'man闪烁234'
    count = 0
    for x in str1:
        if x.isdigit():
            count += 1
    print(count)

5. 函数的参数

5.1 位置参数和关键字参数

根据实参的提供方式将实参分为位置参数和关键字参数两种

位置参数：以’实参1, 实参2, …'的形式存在，让实参和形参从位置上一一对应
关键字参数: 以’形参1=实参1，形参2=实参2,… ‘的形式存在，通过’='将实参和形参对应

注意:位置参数和关键字参数可以一起用，但是必须保证位置参数在关键字参数的前面
```
def func1(x, y, z):
    print(f'x:{x} y:{y}, z:{z}')

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

# 运行结果
'''
x:10 y:20, z:30
x:20 y:30, z:10
x:10 y:20, z:30
'''
```

5.2 参数默认值

定义函数的时候可以通过’形参名=数据’的方式给形参赋默认值;
在调用函数的时候，有默认值的参数可以不用传参。

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

func1()
func1(100)
func1(z=300)

# 运行结果
'''
x:10 y:20, z:30
x:100 y:20, z:30
x:10 y:20, z:300
'''

5.3 参数类型说明

进行参数类型说明可以使用代码提示

没有默认值参数的类型说明:直接在形参后面加’ :类型名
```
def func1(x:str, y='a'):
    return x.strip()
```

有默认值的参数，默认值数据对应的类型就是这个形参的类型

#  -> str: 返回值类型说明
def func1(x:str, y='a') -> str:
    return x.strip()

5.4 *对应的不定长参数

参数个数不确定可以使用不定长参数

定义函数的时候，如果在某一个形参前面加*，那么这个形参就会变成一个不定长参数，它可以接收多个实参(可以是0个、1个、2个、… 10个…) .

带*的不定长参数的本质是一个元组，它接收到的所有的实参是这个元组中的元素

# 定义函数求多个数的和
def sumn(*nums):
    print(nums)
    print(type(nums))
    sum_num = 0
    for i in nums:
        sum_num += i
    return sum_num
sumn(1,2,3)

# 运行结果
'''
(1, 2, 3)
<class 'tuple'>
6
'''

定义函数的时候单独使用*

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

def func1(x, *, y, z):
    print(f'x:{x}, y:{y}, z:{z}')
# func1(10, 20, 30) # TypeError: func1() takes 1 positional argument but 3 were given
func1(10, y=20, z=30)

# 运行结果
'''
x:10, y:20, z:30
'''

6. 函数的返回值

6.1 return(函数返回值)

什么是返回值？
返回值就是从函数内部传递到函数外部的数据(Python中的每个函数都可以传递一个数据到函数的外部)
怎么确定一个函数的返回值(怎么在函数的内容将数据传递到函数的外部)
return后面的值就是函数的返回值(执行函数体的是如果遇到return, return后面的值就是函数的返回值)
怎么在外部获取函数的返回值
获取函数调用表达式的值就是获取这个函数的返回值
什么时候使用返回值
如果实现函数的功能，产生了新的数据，就将新的数据作为函数的返回值返回

return确定返回值

return后面放需要返回的数据

def func(a, b):
    result = a + b
    return result
print(func(10, 20))

# 运行结果
'''
30
'''

一个函数只有一个返回值(一个函数最多只能有一个return有效)；如果想要把多个数据作为函数的返回值返回，可以在一个return后面写多个数据
```
def func(a, b):
    result1 = a + b
    result2 = a * b
    return result1, result2
print(func(10, 20))

# 运行结果
'''
(30, 200)
'''
```

return除了可以返回数据，还会提前结束函数(执行函数体的时候如果遇到return，函数直接结束)

def func():
    print('++++++')
    print('------')
    return          #  相当于 return None
    print('======')
print(func())

# 运行结果
'''
++++++
------
None
'''

6.2 获取函数的返回值

函数调用表达式的值就是函数的返回值，所以返回值能干的事情，函数调用表达式都可以做

def func(a, b):
    result = a + b
    return result
summ = func(10, 20)
print(summ)

# 运行结果
'''
30
'''

多个返回值，以元组的形式返回

def func(a, b):
    result1 = a + b
    result2 = a * b
    return result1, result2
r1, r2 = func(10, 20)
print(r1, r2)

# 运行结果
'''
30 200
'''

7. 变量作用域

变量在定义完成后可以使用的范围

7.1 全局变量

没有定义在函数里面或者类里面的变量都是全局变量。

作用域:从定义开始，到程序结束。(程序结束前的任何位置都可以使用)

a = 10

for i in range(5):
    b = 20

print(a, i, b)

# 运行结果
'''
10 4 20  
'''

7.2 局部变量

定义在函数中的变量就是局部变量(定义在类中的变量是属性)

作用域:从定义开始到函数结束

def func(c):
    d = 30
    print(f'函数里面的c和d：{c}、{d}')

func(20)

# 运行结果
'''
函数里面的c和d：20、30
'''

7.3 变量的作用域

全局变量默认保存在全局栈区间(程序结束的时候才会被释放)，
局部变量默认是保存在函数对应的临时栈区间中(函数对应的临时栈区间，创建函数的时候会创建出来，函数调用结束会自动释放)。
在函数中定义变量的时候，可以在定义变量前加global关键字，让函数中定义变量可以保存在全局栈区间中。
如果想要在函数里面修改一个全局变量的值，必须先用global对变量进行声明

x = 100    # 保存全局栈区间
def func4():
    y = 200    # 保存在func4对应的临时栈区间
    global z
    z = 300     # 保存在全局栈区间中

func4()
print(f'外面z:{z}')

# 运行结果
'''
外面z:300
'''

8. 函数参数的确定

调用函数的时候，实参到底应该给什么样的数据，由什么东西决定?
由参数在函数体中的使用方式决定
实参高阶函数 - 函数的参数是函数
如果一个参数是函数，传参的时候有两种方法: 1)用普通函数的函数名；2)使用匿名函数

9. 匿名函数

什么是匿名函数
匿名函数的本质还是函数，但是它只能实现简单的功能(一行语句就能实现它的功能)

# 语法: 
函数名 = lambda 形参列表:返回值

# 相当于:
def 函数名(形参列表):
    return返回值

示例1：定义一个函数求两个数的和

sum2 = lambda num1, num2 : num1+num2
print(sum2(10, 20))
print(sum2(num1=100, num2=200) )

# 运行结果
'''
30
300
'''

匿名函数的应用
在给实参高阶函数传参的时候，可以使用普通函数函数名，也可以使用匿名函数(能用匿名函数就使用匿名函数，不行才用普通函数)

def func1(x):
    print(x(10, 20) + 10)
# x是一个函数;有两个参数，有一个数字对应的返回值
def temp1(m, n):
    return 12.3

func1(temp1)

func1(lambda m, n: 12)

# 运行结果
'''
22.3
22
'''

10. 常用的实参高阶函数

max、min、sorted

max(序列) - 直接比较序列中元素本身的大小，求出最大值
max(序列, key=函数) - 按照函数制定的比较规则比较元素的大小，求出最大值

函数的要求：

有且只有一个参数（这个参数代表序列中的每个元素）
需要一个返回值（返回值是比较对象 - 将参数看成元素，在这个地方来描述比较对象和元素之间的关系）

# 练习1：求nums中绝对值最小的元素
nums = [-992, 12, 78, -34, 99]
result = min(nums, key=lambda i:abs(i))
print(result)

# 运行结果
'''
12
'''

# 练习2：nums中各个位数之和最大的元素
nums = [102, 19, 48, 221, 52]
result = max(nums, key=lambda i:sum([int(j) for j in str(i)]))
print(result)

# 运行结果
'''
48
'''

map - 基于原序列中的元素创建一个新的序列

map(函数, 序列) - 根据函数制定规则，将指定序列中的元素转换成新序列中的元素
函数的要求:
- a.有且只有1个参数（代表后面序列中的元素）
- b.有返回值（返回对应的就是新序列中的元素）
map(函数, 序列1, 序列2
函数的要求:
- a.有且只有个2参数(分别代码后面两个序列中的元素)
- b.有返回值（返回对应的就是新序列中的元素）

map(函数, 序列1, 序列2, 序列3,…)

# 练习1：将nums中所有的元素乘以10
nums = [82, 67, 89, 6617, 90, 23, 71]
result = map(lambda i:i*10, nums)
print(list(result))

# 运行结果
'''
[820, 670, 890, 66170, 900, 230, 710]
'''

# 练习2：基于names、ages和scores，创建学生列表：
# [{'name': 'stu1', 'age': 23, 'score': 82}, .....]
names = ['stu1', 'stu2', 'stu3', 'stu4']
ages = [23, 34, 19, 22]
scores = [82, 67, 89, 66]

result = map(lambda n,a,s:{'name':n, 'age':a, 'score':s}, names, ages, scores)
print(list(result))

# 运行结果
'''
[{'name': 'stu1', 'age': 23, 'score': 82}, {'name': 'stu2', 'age': 34, 'score': 67}, {'name': 'stu3', 'age': 19, 'score': 89}, {'name': 'stu4', 'age': 22, 'score': 66}]
'''

reduce - 将序列中所有的元素通过指定的规则合并成一个数据
reduce(函数, 序列, 默认值)
函数的要求：

a.有且只有两个参数(第一个参数指向默认值，第二个参数指向序列中的每个元素)
b.需要一个返回值（描述合并方式，说清楚最后的结果是初始值和序列中元素进行什么样的操作得到的）

# 注意：reduce使用之前要先导入
from functools import reduce

# 示例1：求所有元素个位数的和
nums = [23, 78, 92, 78, 12]
# 0 + 3 + 8 + 2 + 8 + 2  -> 0 + 23%10 + 78 % 10 + 92 % 10 + 78 % 10 + 12 % 10
result = reduce(lambda i, item: i + item % 10, nums, 0)
print(result)

# 示例2：将所有元素合并成一个字符串：'2378927812'
nums = [23, 78, 92, 78, 12]
# '' + '23' + '78' + '92' + '78' + '12'  -> '' + str(23) + ...
result = reduce(lambda i, item: i + str(item), nums, '')
print(result)

# 运行结果
'''
23
2378927812
'''