day12函数进阶

最新推荐文章于 2024-10-02 10:53:34 发布

lmj275871

最新推荐文章于 2024-10-02 10:53:34 发布

阅读量52

点赞数

文章标签： python 开发语言

本文链接：https://blog.csdn.net/lmj275871/article/details/126131443

版权

函数进阶

函数的返回值

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

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

a. return后面放需要返回的数据

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

func1(10,20)

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

def func2(a,b):
    result1 = a + b
    result2 = a * b
    return result1,result2

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

示例1：

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

示例2：

def func4(str1: str):
    new_str = ''
    for x in str1:
        if x.isupper():
            new_str += x
    return new_str          # 'MNAN'

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

怎么在函数外部获取函数返回值：
获取函数调用表达式的值就是获取这个函数的返回值
函数调用表达式 - 调用函数的语句

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

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

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

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

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


result = func2(10, 20)
print(result)     # (30,200)

# 变量1, 变量2, ... = 元组
s1, s2 = func2(10, 20)      
print(s1, s2)     # 30 200

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

变量作用域

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

根据变量作用域的不同，可以将变量分为全局变量和局部变量两种

全局变量和局部变量

全局变量

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

作用域：从定义开始，到程序结束。（程序结束前的任意位置都可以使用）

案例1：

# a是全局变量
a = 10

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

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

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

func1()    # 函数中a：10

案例2：

# x和b是全局变量
for x in range(5):
    b = 20

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

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

func2()

局部变量

定义在函数中的变量就是局部变量（形参也是局部变量；定义在类中的变量是属性）

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

# c和d是局部变量
def func3(c):
    d = 30
    print(f'函数里面c和d：{c},{d}')

func3(40)       # 函数里面c和d：40,30

# print(f'函数外面:{c},{d}')       # 报错！函数外面不能使用函数中定义的局部变量

不同变量的存储方式

全局变量默认保存在全局栈区间（程序结束的时候才会被释放）

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

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

示例1：

    x = 100         # 保存全局栈区间

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

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

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

示例2：如果想要在函数里面修改一个全局变量的值，必须先用global对变量进行声明

name = '小明'     # name是全局变量，保存在全局栈区间

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

    global name
    name = '小花'
    print(f'函数里面name：{name}')

change_name()  # 函数里面name：小花

print(f'外面name：{name}')     # 外面name：小花

函数参数的确定

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

由参数在函数体中的使用方式决定
实参高阶函数 - 函数的参数是函数

如果一个参数是函数，传参的时候有两种方法：a.用普通函数的函数名 c.使用匿名函数

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)

匿名函数

匿名函数

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

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

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

示例：定义一个函数求两个数的和
```
sum2 = lambda num1, num2: num1 + num2

print(sum2(10, 20))                 # 30
print(sum2(num1=100, num2=200))     # 300
```

匿名函数的应用：

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

def func1(x):
    print(x(10,20) + 20)

# x是一个函数；有两个参数；有一个数字对应的返回值
def temp1(m,n):
    return 12.3

func1(temp1)

func1(lambda m, n: 12)

常用实参高阶函数

max、min、sorted

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

2.max(序列,key=函数) - 按照函数制定的比较规则比较元素的大小，求出最大值
函数的要求：a.有且只有一个参数（这个参数代表序列中的每个元素）
b.需要一个返回值（返回值是比较对象 - 将参数看成元素，在这个地方来描述比较对象和元素之间的关系）

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

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

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

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

示例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)

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

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

练习2：求nums中绝对值最小的元素

nums = [-992, 12, 78, -34, 99]
# 方法1：
result = min(nums,key=lambda item:abs(item))
print(result)

# 方法2：
result = min(nums,key=lambda item:item ** 2)
print(result)

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

nums = [102, 19, 48, 221, 52]
# 3,10,12,5,7  ->  48

# 方法1：
result = max(nums,key=lambda item:sum([int(x) for x in str(item)]))
print(result)

# 方法2：
def temp(item):
    sum1 = 0
    for i in str(item):
        sum1 += int(i)
    return sum1

result = max(nums,key=temp)
print(result)

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

# 方法1：
result = sorted(students,key=lambda item:item['score'],reverse=True)
print(result)

# 方法2：
students.sort(key=lambda item:item['score'],reverse=True)
print(students)

map

1.map(函数,序列) - 根据函数制定规则，将指定序列中的元素转换成新序列中的元素
函数的要求：a.有且只有一个参数（参数代表后面序列中的元素）
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(list(result))

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

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

练习1：将nums中所有元素乘以10

nums = [82,67,89,6617,90,23,71]
result = map(lambda item:item*10,nums)
print(list(result))

练习2：基于scores创建一个列表，列表中元素根据nums中元素确定为’及格’或者’不及格’

scores = [82, 67, 89, 66, 90, 23, 71]
# ['及格', '及格', '及格', '及格', '不及格', '及格']
result = map(lambda item:'及格' if item >= 60 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))

reduce

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

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

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

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

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

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

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

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

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)

示例4：将所有元素合并成一个字符串：‘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)

示例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 +...  -> 0 + {'name': '小明', 'age': 19, 'score': 89, 'gender': '男'}['score'] + ...
result = reduce(lambda i, item: i + item['score'], students, 0)
print(result)