• Python的基础语法(十)（持续更新）

    函数的返回值、变量作用域和实参高阶函数

    1 函数的返回值

    1. 什么是返回值

      返回值就是从函数内部传递到函数外部的数据(Python中的每个函数都可以传递一个数据到函数的外部)。

    2. 怎么确定一个函数的返回值(怎么将函数内部的数据传递到函数外部)

      return后面的值就是函数的返回值(执行函数体如果遇到return，return后面的值就是函数的返回值)。

    3. 怎么在函数外部获取函数返回值

      获取函数调用表达式的值就是获取这个函数的返回值。

    4. 什么时候使用返回值

      如果实现函数的功能，产生了新的数据，就将新的数据作为函数的返回值返回。

      1）return确定返回值

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

      def func1(a, b):
    result1 = a * b
    result2 = a - b
    return result1, result2		#以元组的方式，元组在没有歧义的时候，可以省略括号。

      • 1
      • 2
      • 3
      • 4

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

      def func2():
    print('____')
    print('****')
    return  # 相当于return None

      • 1
      • 2
      • 3
      • 4

      2）获取函数的返回值

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

      func1(11,22)
print(33)	#33
print(func1(11, 22))	#33

num1 = 33
num2 = func1(11, 22)
print(33 * 2, func1(11, 22) * 2)	#66 66

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

# 方法1
result = func3(10, 20)
print(result)	#(200, 30)
# 方法2：变量1,变量2,...=元组
s1, s2 = func3(10, 20)
print(s1, s2)		#200 30

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19

    2 变量作用域

    1. 变量在定义完成后使用的范围。

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

    2. 全局变量和局部变量

      1）全局变量

      没有定义在函数(def)或类(class)里面的变量都是全局变量。

      与是否在缩进里无关。

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

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

      • 1
      • 2
      • 3
      • 4

      ​ 2）局部变量

      ​ 定义在函数中的变量是就是局部变量(形参也是局部变量)。

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

      def fun1(c):
    d = 20
    print(c, d)

fun1(11)	#11 20
print(c,d)	#报错!函数外面不能使用函数中定义的全局变量：name 'c' is not defined

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6

      定义在类中的变量是属性，不是同一个东西。

    3. 不同变量的存储方式

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

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

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

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

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

      • 1
      • 2
      • 3
      • 4
      • 5
      name = '小妹'     #保存在全局栈区间里
def change_name():
    name = '小米'	#重新创建一个局部变量name，保存在change_name对应的临时栈区间中
    print(f'函数里面的name:{name}')


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

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8

      在这里插入图片描述

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

    3 函数参数的确定

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

      🥯由参数在函数体中的使用方式决定。

    2. 实参高阶函数(函数的参数是函数)

      如果一个参数是函数，传参的时候有两种方法：

      ​ 1）用普通函数的函数名

      ​ 2）使用匿名函数

    4 实参高阶函数

    1. 匿名函数

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

      语法🌸：

      函数名 = lambda 形参列表:返回值
或
lambda 形参列表:返回值

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

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7

      🌰定义一个函数求两个数的和。

      sum2 = lambda num1, num2: num1 + num2
print(sum2(1, 2))

      • 1
      • 2

    2. 匿名函数的应用

      在给实参高阶函数传参的时候，可以使用普通函数函数名，也可以使用匿名函数。

      能用匿名函数就使用匿名函数，不行才用普通函数。

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

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

func1(temp1)	#32.3
func1(lambda m, n: 12.3)	#32.3

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9

    5 常用实参高阶函数

    1. max、min、sorted

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

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

      • 1
      • 2
      • 3
      • 4
      • 5

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

      nums = [12, 3, 344, 323, 2]
result = max(nums, key=lambda item: item)
print(result)
# 个位数最大的元素
result = max(nums, key=lambda item: item % 10)

      • 1
      • 2
      • 3
      • 4
      • 5

      🌰示例2：求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
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9

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

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

      • 1
      • 2
      • 3

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

      nums = [-992, 12, 78, -34, 99]
# 方法一
result = min(nums, key=lambda item: item ** 2)
print(result)
# 方法二
nums1 = [i * (-1) if i < 0 else i for i in nums]
result = min(nums1, key=lambda item: item)
print(result)
# 方法三  abs(数据)返回指定数据的绝对值
result = min(nums, key=lambda item: abs(item))
print(result)

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11

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

      nums = [102, 19, 48, 221, 52]
# 方法一
def temp(item):
    sum1 = 0
    for i in str(item):
        sum1 += int(i)
    return sum1

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

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13

      🌰练习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)

# 方法二
def stu_score(list1):
    stu = []
    for i in students[-1::-1]:
        result = max(students, key=lambda item: item['score'])
        stu.append(result)
        students.remove(result)
    return stu

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

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24

    2. map

      基于原序列中的元素创建一个新序列。🌸

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

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6

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

      • 1
      • 2
      • 3
      • 4

      🌰示例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
      • 2
      • 3
      • 4
      • 5

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

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

      • 1
      • 2
      • 3

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

      scores = [82, 67, 89, 66, 90, 23, 71]
# ['及格', '及格', '及格', '及格', '不及格', '及格']
result = map(lambda item: '及格' if item >= 60 else '不及格', scores)
print(list(result))

      • 1
      • 2
      • 3
      • 4

      🌰练习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 item1, item2, item3: {'name': item1, 'age': item2, 'score': item3}, names, ages, scores)
print(list(result))

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6

    3. reduce

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

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

      • 1
      • 2
      • 3

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

      from functools import reduce

      • 1

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

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

      • 1
      • 2
      • 3
      • 4

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

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

      • 1
      • 2
      • 3
      • 4

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

      • 1
      • 2
      • 3
      • 4

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

      • 1
      • 2
      • 3
      • 4

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

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
  • 相关阅读:
    Log4j输出格式控制--log4j的PatternLayout参数含义以及详细配置
    研发项目管理系统对比：找到最适合的高效工具
    搭建服务器及跨域处理
    stm32f4xx-USART串口
    java毕业设计仓库管理系统mybatis+源码+调试部署+系统+数据库+lw
    Vue2数据双向绑定的原理(Object.defineProperty)
    【测试代码 & 基于Pytorch】的卷积神经网络（CNN） || 【基于Pytorch】的深度卷积神经网络（DCNN）
    Python机器学习项目开发实战：如何进行语音识别
    LeetCode每日一题(1441. Build an Array With Stack Operations)
    基于VC的WinSock网络编程实用宝典
  • 原文地址：https://blog.csdn.net/m0_69100942/article/details/126128360