基础语言-第12天-函数进阶

函数进阶

一、函数返回值

• 什么是返回值

  从函数内容传递到函数外部的数据（Python中的每个函数都只能传递一个数据到函数的外部）。

• 确定函数的返回值

  return后面的值就是函数的返回值（执行函数体如果遇到return，return后面的值就是含食宿的返回值）。

• 在函数外部获取函数返回值

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

  2.函数调用表达式 - 调用函数的语句。

• 使用返回值

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

  注意：

  a.一个函数只有一个返回值（一个函数最多只能有一个return有效）。

  扫描二维码关注公众号，回复： 14490550 查看本文章

  b.如果想把多个数据作为函数的返回值返回，可以在一个return后面写多个数据。

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

# 1）return确定返回值
# return后面放需要返回的数据
def func1(a, b):
    result = a + b   # 30
    return result   # return 30
func1(10, 20)

# 一个函数只有一个返回值（一个函数最多只能有一个return有效）
# 如果想把多个数据作为函数的返回值返回，可以在一个return后面写多个数据。
def func2(a, b):
    result1 = a + b
    result2 = a * b
    return result1, result2

# return除了可以返回数据，还可以提前结束函数（执行函数体的时候如果遇到return，函数直接结束）
def func3():
    print('++++++')
    print('------')
    return            # 相当于return None
    print('======')
func3()
# ++++++
# ------

# 2）获取函数的返回值
# 函数调用表达式的值就是这个函数的返回值，返回值的作用和函数调用表达式的作用一样。
print(func2(11, 22))    # (33, 242)
print(30 * 2, func1(10, 20) * 2)    # 60 60

二、变量作用域

• 定义

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

• 分类 - 根据变量作用域的不同

  1.全局变量

  • 概念: 没有定义在函数里面或者类里面的变量。
  • 作用域: 从定义开始，到程序结束。（程序结束前的任何位置都可以使用）。

  # a是全局变量
  a = 10
  print(f'外面的a:{
          
          a}')
  
  for x in range(5):
      print(f'循环里的a:{
          
          a}')
      break
  
  def func1():
      print(f'函数中的a:{
          
          a}')
  func1()
  

  2.局部变量

  • 概念: 定义在函数中的变量。
  • 作用域: 从定义开始到函数结束。

  3.不同变量的存储方式

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

  • 局部变量默认是保存在函数对应的临时栈区间中（函数对应的临时栈区间，创建函数的时候会创建出来，

    函数调用结束会自动释放）

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

    中。

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

    

• 函数参数的确定

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

三、实参高阶函数

1.概念

函数的参数是函数

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

1）用普通的函数名

2）使用匿名函数 - 尽量用匿名函数

2.匿名函数

• 定义

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

# 语法：
函数名 = 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) + 10)
      
  # x是一个函数；有两个参数；有一个数字对应的返回值
  def temp1(m, n):
      return 12.3
  func1(temp1)    # 普通函数
  
  func1(lambda m, n: 12)   # 匿名函数
  

3.常用实参高阶函数

• max、int、sorted

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

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

  函数的要求：

  a.有且只有一个参数（序列中的每个元素）；

  b.需要一个返回值(比较对象):将参数看成元素，在这个地方描述比较对象和元素之间的关系。

  int和sorted类似。

  # 例1：求nums中值最大的元素
  nums = [18, 23, 67, 90, 56, 49]
  result = max(nums, key=lambda item: item)
  print(result)    # 90
  
  # 例2：求nums中个位数最大的元素
  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]
  result = max(nums, key=lambda item: item // 10 % 10)
  print(result)    # 90
  
  # 练习2：求nums中绝对值最小的元素
  # abs(数据)：返回指定数据的绝对值
  nums = [-992, 12, 78, -34, 99]
  # 法1
  result = min(nums, key=lambda item: abs(item))
  print(result)    # 12
  # 法2
  result = min(nums, key=lambda item: item ** 2)
  print(result)    # 12
  
  # 练习3：nums中各个位数之和最大的元素
  # 3,10,12,5,7  ->  48
  nums = [102, 19, 48, 221, 52]
  # 方法1：
  result = max(nums, key=lambda item: sum([int(x) for x in str(item)]))
  print(result)
  # 方法2：
  def temp(item):
      sum1 = 0
      for x in str(item):
          sum1 += int(x)
      return sum1
  result = max(nums, key=temp)
  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': '男'}
  ]
  # 法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.有且只有两个参数（分别代表后面两个序列中的元素）

  b.有返回值（新序列中的元素）

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

  函数的要求：

  a.有且只有序列个数个参数

  b.有返回值（新序列中的元素）

  # 案例
  
  # 例1：创建一个列表，列表中的元素是nums中所有元素的个位数
  nums = [82, 67, 89, 6657, 90, 23, 71]
  # [2, 7, 9, 7, 0, 3, 1]
  result = map(lambda item: item % 10, nums)
  print(list(result))    # [2, 7, 9, 7, 0, 3, 1]
  
  # 例2：将A和B中的元素对应求和产生一个新的列表
  A = [3500, 5600, 9800, 4200, 10000]    # 底薪
  B = [1500, 1000, 2200, 1300, 3200]    # 奖励
  result = map(lambda i1, i2: i1 + i2, A, B)
  print(list(result))    # [5000, 6600, 12000, 5500, 13200]
  
  # 练习1：将nums中所有的元素乘以10
  nums = [82, 67, 89, 6617, 90, 23, 71]
  result = map(lambda item: item * 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 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]
  students = map(lambda name, age, score: {
        
        'name': name, 'age': age, 'score': score}, names, ages, scores)
  print(list(students))    # # [{'name': 'stu1', 'age': 23, 'score': 82}, .....]
  

• reduce(最难)

  1.语法

  reduce(函数, 序列, 默认值)
  

  2.函数的要求：

  a.有且只有两个参数：第一个参数指向默认值，第二个参数指向序列中的每个元素。

  b.需要一个返回值（描述合并方式，说清楚最后的结果是初始值和序列中元素进行什么操作得到的）

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

  from functools import reduce
  

  # 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]
  result = reduce(lambda i, item: i * item, nums, 1)
  print(result)    # 240000
  
  # 例3：求nums中所有元素个位数的和
  nums = [23, 78, 92, 78, 12]
  result = reduce(lambda i, item: i + item % 10, nums, 0)
  print(result)    # 23
  
  # 例4：将所有元素合并成一个字符串：''
  nums = [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': '男'}
  ]
  all = reduce(lambda i, item: i + item['score'], students, 0)
  print(all)    # 427
  
  average = reduce(lambda i, item: i + item['score'], students, 0)/len(students)
  print(average)    # 85.4