Python Day11 函数进阶【零基础】

最新推荐文章于 2023-10-18 10:13:39 发布

KathAmy

最新推荐文章于 2023-10-18 10:13:39 发布

阅读量190

点赞数 1

分类专栏： Python python练习初级Python 文章标签： python 学习 pycharm

本文链接：https://blog.csdn.net/qq_67780151/article/details/126128557

版权

初级Python 同时被 3 个专栏收录

55 篇文章 1 订阅

订阅专栏

Python

42 篇文章 5 订阅

订阅专栏

python练习

33 篇文章 0 订阅

订阅专栏

Day11 函数进阶

文章目录

Day11 函数进阶

1. 函数的返回值

1.1 什么是函数的返回值

1）什么是返回值
返回值就是从函数内部传递到函数外部的数据（Python中的每个函数都可以传递一个数据到函数的外部）

2）怎么确定一个函数的返回值（怎么将函数内部的数据传递到函数外部）
return后面的值就是函数的返回值（执行函数体时如果遇到return，return后面的值就是函数的返回值

3）怎么在函数外部获取函数的返回值
获取函数调用表达式的值就是获取函数的返回值（函数调用表达式就是调用函数的语句）

4）什么时候使用返回值
如果实现函数的功能产生了新的数据，就将新的数据作为函数的返回值返回

1.2 函数的返回值

1）return后面放需要返回的数据

def func1(a, b):
    result = a + b
    return result


print(func1(100, 90))

190

注意1：一个函数只有一个返回值（一个函数最多只有一个return有效）；如果想要把多个数据作为函数的返回值返回，可以在一个return后面写多个数据即可

def func2(a, b):
    result1 = a + b
    result2 = a * b
    return result1, result2  # return (result1, result2)，相当于元组


print(func2(10, 20))

(30, 200)

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

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


print(func3())

def func4(str1: str):
    # str1 = 'hsMNsh啥时间A看N'
    new_str = ''
    for x in str1:
        if x.isupper():
            new_str += x
    return new_str  # 'MNAN'


print(func4('hsMNsh啥时间A看N'))

MNAN

2）获取函数的返回值（函数调用表达式返回的值就是返回值，函数调用表达式都可以做）
a.函数调用表达式，例如：

print(30)
print(func1(10, 20))

num1 = 30
num2 = func1(10, 20)
print(num1, num2)

print(30 * 2, func1(10, 20) * 2)

30
30
30 30
60 60

2. 函数参数的确定

2.1 实参具体是什么数据

调用函数的时候，实参到底应该给什么样的数据，由什么东西决定？
由参数在函数体中的使用方式决定

def func1(x):
    print(x)


func1(10)
func1('abc')
func1([10, 20])

10
abc
[10, 20]

def func2(x):
    print(x + 10)


func2(10)
func2(2.34)

20
12.34

def func3(x):
    print(x * 2)


func3(10)
func3('abc')
func3([10, 20])
func3((10, 23))

20
abcabc
[10, 20, 10, 20]
(10, 23, 10, 23)

def func4(x):
    print(x[-1])


func4('abc')
func4([10, 20, 30])
func4({'a': 10, -1: 20})

c
30
20

def func5(x):
    x.append(100)
    print(x)


func5([10, 23])

[10, 23, 100]

2.2 高阶函数的实参是什么

高阶函数的实参：函数的参数是函数
如果一个参数是函数，传参的时候有两种方法：
1）用普通函数的函数名
2）使用匿名函数
func6这个函数的参数要求是函数，这个func6就是一个实参高阶函数

def func6(x):
    # x = temp
    x()     # temp()


def temp():
    print('临时函数')


func6(temp)

临时函数

x必须是函数，有一个参数，返回值必须是数字

def func7(x):
    # x = temp2
    print(x(10) + 20)           # print(temp2(10) + 20)   ->  print(19 + 20)


def temp2(m):
    # m = 10
    return 19


func7(temp2)

39

3. 变量作用域

3.1 变量作用域

在定义完成后可以使用的范围
根据变量作用域的不同，可以将变量分为全局变量和局部变量

3.2 全局变量和局部变量

1）全局变量
没有定义在函数里面或者类里面的变量都是全局变量
作用域：从定义开始，到程序结束。（程序结束前的任何位置都可以使用）
a是全局变量

a = 10

print(f'外面的a:{a}')


for x in range(5):
    print(f'循环里面a:{a}')


def func1():
    print(f'函数中a：{a}')


func1()

外面的a:10
循环里面a:10
循环里面a:10
循环里面a:10
循环里面a:10
循环里面a:10
函数中a：10

x和b是全局变量

for x in range(5):
    b = 20

print(f'外面x和b:{x}, {b}')


def func2():
    print(f'函数里面x和b:{x}, {b}')


func2()

外面x和b:4, 20
函数里面x和b:4, 20

2）局部变量
定义在函数中的变量就是局部变量（定义在类中的变量是属性）
作用域：从定义开始到函数结束

c和d是局部变量（只能在函数里面用）

def func3(c):
    d = 30
    print(f'函数里面c和d:{c}, {d}')


print(func3(40))

3.3 不同变量的存储方式

全局变量默认保存在全局栈区间（程序结束的时候才会被释放）
局部变量默认是保存在函数对应的临时栈区间中（函数对应的临时栈区间，创建函数的时候会创建出来，函数调用结束后自动释放）

在函数中定义变量的时候，可以在定义变量前加global关键字，让函数中定义变量可以保存在全局栈区间中。

x = 100   # 保存全局栈区间

def func4():
    y = 200   # 保存在func4对应的临时栈区间

    global z
    z = 300   # 保存在全局栈区间中

func4()

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

外面z: 300

如果想在函数里面修改一个局部变量，必须先用global进行事先声明

name = 'Amy'


def change_name():
    # name = 'Ziv'    # 创建一个局部变量name，保存在change_name这个对应的临时栈区间中
    # print(f'函数里面name：{name}')

    global name
    name = 'Ziv'
    print(f'函数里面的name：{name}')


change_name()


print(f'外面name：{name}')

函数里面的name：Ziv
外面name：Ziv

4. 匿名函数

4.1 匿名函数

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

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

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

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

sum2 = lambda num1, num2: num1 + num2

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

30
300

4.2 2.函数的应用

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

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

5. 常用的实参高阶函数

5.1 max、min、sorted

1）max(序列) - 直接比较序列中元素本身的大小，求出最大值

2）max(序列, key=函数) - 按照函数指定的比较规则比较元素的大小，求出最大值
函数的要求：

a.有且只有一个参数（这个参数代表的是序列中的每个元素）

b.需要一个返回值（返回值是比较对象 - 将参数看成元素，在这个地方来描述比较对象和元素之间的关系）

示例1：求nums中值最大的元素

nums = [81, 29, 43, 23, 25]
print(max(nums))

nums2 = [19, 39, 45, 32, 45]
print(max(nums2, key=lambda item: item))

81
45

示例2：求nums中个位数最大的元素

nums = [18, 23, 67, 90, 56, 49]
result = max(nums, key=lambda item: item % 10)
print(result)

49

示例3：求students中年龄最大的学生

students = [
    {'name': '小明', 'age': 19, 'score': 89, 'gender': '男'},
    {'name': '小红', 'age': 22, 'score': 99, 'gender': '女'},
    {'name': '小胡', 'age': 28, 'score': 75, 'gender': '男'},
    {'name': '小花', 'age': 25, 'score': 80, 'gender': '女'},
    {'name': '李华', 'age': 17, 'score': 84, 'gender': '男'}
]
result = max(students, key=lambda item: item['age'])
print(result)

{‘name’: ‘小胡’, ‘age’: 28, ‘score’: 75, ‘gender’: ‘男’}

练习：
练习1：求nums中十位数最大的元素: 90

nums = [9108, 23, 167, 90, 556, 149]
print(max(nums, key=lambda item: item // 10 % 10))

90

练习2：求nums中绝对值最小的元素
abs() - 返回指定数据的绝对值

nums = [-992, 12, 78, -34, 99]
print(min(nums, key=lambda item: abs(item)))

12

练习3：nums中各个位数之和最大的元素

nums = [102, 19, 48, 221, 52]
result = max(nums, key=lambda item: sum([int(i) for i in str(item)]))
print(result)

48

练习4：将students中的元素按照分数从高到低排序

students = [
    {'name': '小明', 'age': 19, 'score': 89, 'gender': '男'},
    {'name': '小红', 'age': 22, 'score': 99, 'gender': '女'},
    {'name': '小胡', 'age': 28, 'score': 75, 'gender': '男'},
    {'name': '小花', 'age': 25, 'score': 80, 'gender': '女'},
    {'name': '李华', 'age': 17, 'score': 84, 'gender': '男'}
]

result = sorted(students, key=lambda item: item['score'], reverse=True)
print(result)

[{‘name’: ‘小红’, ‘age’: 22, ‘score’: 99, ‘gender’: ‘女’}, {‘name’: ‘小明’, ‘age’: 19, ‘score’: 89, ‘gender’: ‘男’}, {‘name’: ‘李华’, ‘age’: 17, ‘score’: 84, ‘gender’: ‘男’}, {‘name’: ‘小花’, ‘age’: 25, ‘score’: 80, ‘gender’: ‘女’}, {‘name’: ‘小胡’, ‘age’: 28, ‘score’: 75, ‘gender’: ‘男’}]

5.2 map

基于原序列的元素创建一个新序列
1）map(函数, 序列) - 根据函数制定的规则将指定序列中的元素转换成新序列中的元素
函数的要求：
a.有且只有1个参数（参数代表后面序列中的元素）
b.有返回值（返回值对应的是新序列中的元素）

2）map(函数, 序列1, 序列2)
函数的要求：
a.有且只有2个参数（分别代表后面两个序列中的元素）
b.有返回值（返回值对应的是新序列中的元素）

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

示例1：创建一个列表，列表中的元素是nums中所有元素的个位数

nums = [82, 67, 89, 6617, 90, 23, 71]
# [2, 7, 9, 7, 0, 3, 1]
result = map(lambda item: item % 10, nums)
print(result)

<map object at 0x0000017B3CF2F9D0>

示例2：将A和B中的元素对应求和产生一个新的列表

A = [3000, 5600, 9800, 4200, 10000]
B = [1500, 1000, 2200, 1300, 3200]
# [4500, 6600, 12000, 5500, 13200]
result = map(lambda item1, item2: item1 + item2, A, B)
print(result)

<map object at 0x0000017B3CF2F910>
(该类结果之后解释）

练习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：基于scores创建一个列表，列表中元素根据nums中元素确定为’及格’或者’不及格’

scores = [82, 67, 89, 66, 90, 23, 71]
# ['及格', '及格', '及格', '及格', '不及格', '及格']

result = map(lambda i: '不及格' if i % 2 == 0 else '及格', scores)
print(list(result))

[‘不及格’, ‘及格’, ‘及格’, ‘不及格’, ‘不及格’, ‘及格’, ‘及格’]

练习3：基于names、ages和scores，创建学生列表：

names = ['stu1', 'stu2', 'stu3', 'stu4']
ages = [23, 34, 19, 22]
scores = [82, 67, 89, 66]
# [{'name': 'stu1', 'age': 23, 'score': 82}, .....]

result = map(lambda i1, i2, i3: {'name': i1, 'age': i2, 'scores': i3}, names, ages, scores)
print(list(result))

[{‘name’: ‘stu1’, ‘age’: 23, ‘scores’: 82}, {‘name’: ‘stu2’, ‘age’: 34, ‘scores’: 67}, {‘name’: ‘stu3’, ‘age’: 19, ‘scores’: 89}, {‘name’: ‘stu4’, ‘age’: 22, ‘scores’: 66}]

5.3 reduce

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

注意：使用reduce之前需要导入

from functools import reduce

将序列中的元素通过指定的规则合并成一个数据

示例1：求nums中所有元素的和

nums = [10, 20, 30, 40]
result = reduce(lambda i, item: i + item, nums, 0)
print(result)

100

示例2：求nums中所有元素的乘积

nums = [10, 20, 30, 40]
# 1 * 10 * 20 * 30 * 40
result = reduce(lambda i, item: i * item, nums, 1)
print(result)

240000

示例3：求所有元素个位数的和

nums = [23, 78, 92, 78, 12]
# 0 + 23 + 78 + 92 + 78 + 12
result = reduce(lambda i, item: i + item, nums, 0)
print(result)

283

示例4：将所有元素合并成一个字符串：‘2378927812’

nums = [23, 78, 92, 78, 12]
# '' + '23' + '78' + '92' + '78' + '12'
result = reduce(lambda i, item: i + str(item), nums, '')
print(result)

2378927812

示例5：求所有学生的总分和

students = [
    {'name': '小明', 'age': 19, 'score': 89, 'gender': '男'},
    {'name': '小红', 'age': 22, 'score': 99, 'gender': '女'},
    {'name': '小胡', 'age': 28, 'score': 75, 'gender': '男'},
    {'name': '小花', 'age': 25, 'score': 80, 'gender': '女'},
    {'name': '李华', 'age': 17, 'score': 84, 'gender': '男'}
]
# 0 + 89 + 99 + 75 + 80 + 84
result = reduce(lambda i, item: i + item['score'], students, 0)
print(result)