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		#以元组的方式，元组在没有歧义的时候，可以省略括号。
   

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

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

   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
   

2 变量作用域

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

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

2. 全局变量和局部变量

   1）全局变量

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

   与是否在缩进里无关。

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

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

   ​ 2）局部变量

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

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

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

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

3. 不同变量的存储方式

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

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

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

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

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

   

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

3 函数参数的确定

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

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

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

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

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

   ​ 2）使用匿名函数

4 实参高阶函数

1. 匿名函数

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

   语法🌸：

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

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

   sum2 = lambda num1, num2: num1 + num2
   print(sum2(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
   

5 常用实参高阶函数

1. max、min、sorted

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

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

   🌰示例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：求nums中十位数最大的元素: 90。

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

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

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

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

2. map

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

   map(函数,*序列)		根据函数制定的规则，将指定序列中的元素转换成新序列中的元素
   map(函数,序列1)
   函数的要求：a.有且只有1个参数(代表后面序列中的元素)
   		  b.有返回值(返回对应的就是新序列中的元素)
   map(函数,序列1,序列2)		#有且只有2个参数(分别代表后面两个序列中的元素)
   map(函数,序列1,序列2,序列3,...)		#有且只有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 item1, item2, item3: {'name': item1, 'age': item2, 'score': item3}, names, ages, scores)
   print(list(result))
   

3. 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)