day12-实参高阶函数作业

1. 已经列表points中保存的是每个点的坐标(坐标是用元组表示的，第一个值是x坐标，第二个值是y坐标)

   points = [
     (10, 20), (0, 100), (20, 30), (-10, 20), (30, -100)
   ]
   

   以下问题使用实参高阶函数来解决

   1）获取列表中y坐标最大的点

   print(max(points, key=lambda point: point[1]))
   

   2）获取列表中x坐标最小的点

   print(min(points, key=lambda point: point[0]))
   

   3）获取列表中距离原点最远的点

   print(max(points, key=lambda point: point[0]**2 + point[1]**2))
   

   4）将点按照点到x轴的距离大小从大到小排序

   print(sorted(points, key=lambda point: abs(point[1]), reverse=True))
   

2. 求列表 nums 中绝对值最大的元素

   nums = [10, 20, 80, -100, 30, 90, 200]
   print(max(nums, key=lambda num: abs(num)))
   

3. 已经两个列表A和B，用map函数创建一个字典，A中的元素是key，B中的元素是value

   A = ['name', 'age', 'sex']
   B = ['张三', 18, '女']
   新字典: {'name': '张三', 'age': 18, 'sex': '女'}
   

   print(dict(map(lambda i1, i2: (i1, i2), A, B)))
   

4. 已经三个列表分别表示5个学生的姓名、学科和班号，使用map将这个三个列表拼成一个表示每个学生班级信息的的字典

   names = ['小明', '小花', '小红', '老王']
   nums = ['1906', '1807', '2001', '2004']
   subjects = ['python', 'h5', 'java', 'python']
   结果：{'小明': 'python1906', '小花': 'h51807', '小红': 'java2001', '老王': 'python2004'}
   

   names = ['小明', '小花', '小红', '老王']
   nums = ['1906', '1807', '2001', '2004']
   subjects = ['python', 'h5', 'java', 'python']
   print(dict(map(lambda i1, i2, i3: (i1, i3+i2), names, nums, subjects)))
   

5. 已经一个列表message, 使用reduce计算列表中所有数字的和（用采用列表推导式和不采用列表推导式两种方法做）

   message = ['你好', 20, '30', 5, 6.89, 'hello']
   结果：31.89
   

   from functools import reduce
   message = ['你好', 20, '30', 5, 6.89, 'hello']
   # 法1
   print(reduce(lambda x, y: sum(y for y in message if type(y) in (int, float)), message, 0))
   # 法2
   def f(x, y):
       s = 0
       for y in message:
           if type(y) in (int, float):
               s += y
       return s
   print(reduce(f, message, 0))
   

6. 已知一个字典列表中保存的是每个学生各科的成绩，

   1）计算并添加每个学生的平均分

   2）按照平均分从高到低排序

   studens = [
     {'name': 'stu1', 'math': 97, 'English': 67, 'Chinese': 80},
     {'name': 'stu2', 'math': 56, 'English': 84, 'Chinese': 74},
     {'name': 'stu3', 'math': 92, 'English': 83, 'Chinese': 78},
     {'name': 'stu4', 'math': 62, 'English': 90, 'Chinese': 88}
   ]
   
   # 计算平均分
   studens = [
     {'name': 'stu1', 'math': 97, 'English': 67, 'Chinese': 80, 'avg':81},
     {'name': 'stu2', 'math': 56, 'English': 84, 'Chinese': 74, 'avg':71},
     {'name': 'stu3', 'math': 92, 'English': 83, 'Chinese': 78, 'avg':87},
     {'name': 'stu4', 'math': 62, 'English': 90, 'Chinese': 88, 'avg':80}
   ]
   
   # 按照平均分从高到低排序
   ...
   

   # 1、计算平均分
   from functools import reduce
   for stu in studens:
      avg = reduce(lambda x, s1: (stu['math']+stu['English']+stu['Chinese']), stu, 0)//3
      stu.setdefault('avg', avg)
   print(studens)
   
   # 2、排序
   print(sorted(studens, key=lambda item: item['avg'], reverse=True))
   

   python语言基础之函数进阶

   1、匿名函数 - 没有名字的函数

   匿名函数的本质还是函数；但是匿名函数只能实现一句代码就能实现的功能
   语法：
   匿名函数 = lambda 参数列表：返回值
   说明：
   lambda  - 关键字；固定写法
   参数列表  - 至少有一个（普通函数写在括号中的形参列表）
   ：       -  固定写法
   返回值   -  相当于普通函数return后面的值
   

   注意：匿名函数需要先保存才能再调用

   函数名 = lambda 参数列表 ： 返回值
   相当于
   def 函数名（参数列表）：
   	return 返回值
   

   num = lambda x : x % 2 == 0
   print(num(9))    -  False
   

   2、变量作用域

   变量作用域 - 变量可以使用的范围

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

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

   局部变量：
   局部变量就是定义在函数里边的变量（形参也是局部变量）
   局部变量的作用域：从定义函数开始到函数结束
   

   全局变量是保存在全局的栈区间中，全局栈区间在程序运行结束的时候才会被释放
   当程序调用的时候，系统会自动给这个函数创建一个独立的栈区间，专门用来保存在函数中产生的数据（局部变量就是保存在这个内存区间中），当函数调用结束这个栈区间会自动释放
   

   global的作用：
   作用1：在函数内部修改全局变量的值使用global
   注意：使用global的时候必须保证在函数里面global修饰的变量不会出现在它的前面
   作用2：在函数内部定义一个全局变量
   

   3、高阶函数

   1）函数就是变量

   python中定义函数其实就是定义一个类型是function的变量，函数名就是变量名
   变量能做的事情，函数都能做
   

   场景一、可以通过使用变量来使用变量中保存的数据，如果这个数据是函数，函数的通常操作是调用它
   场景二、用一个变量给另一个变量赋值
   

   场景三、
   def b():
   print('一二三')
   list1 = ['m', 200, b]
   print(list1[-1]())     - > None
   

   2）高阶函数

   函数可以作为函数的实参

   实参高阶函数 - 如果一个函数的参数是函数，那么这个函数就是一个实参高阶函数
   

   函数可以作为函数的返回值

   返回值高阶函数  -  如果一个函数的返回值是函数，那么这个函数就是一个返回值高阶函数
   

   4、实参高阶函数

   max, min, sorted

   1)max(序列，key=函数)  -  根据函数提供的方式来获取序列中元素的最大值
   函数要求：1）有且只有一个参数，这个参数指向的是序列中的每一个元素
            2）需要一个返回值，返回值是比较对象
   

   2)min(序列，key=函数)  -  根据函数提供的方式来获取序列中元素的最小值
   函数要求：1）有且只有一个参数，这个参数指向的是序列中的每一元素
            2）需要一个返回值，返回值是比较对象
   

   3）sorted(序列，key=函数) - 根据函数提供的方式来对序列元素进行排序
   函数要求：1）有且只有一个参数，这个参数指向的是序列中的每一个元素
            2）需要一个返回值，返回值是比较对象
   

   map

   用法：
   1)map(函数，序列)  -  将序列中的元素按照函数提供的方式进行交换
   函数要求：1）有且只有一个参数，指向序列中的每一个元素
            2）需要一个返回值，返回值就是新序列中的元素（描述清楚新序列的元素和原序列元素的关系）
   相当于：[返回值 for 参数 in 序列]
   
   2）map(函数，序列1，序列2)
   函数要求：1）有且只有两个参数，分别指向两个序列中的元素（序列长度必须一样）
            2）需要一个返回值（是新序列中的每一个元素，可根据题干类型进行转换），返回值就是新序列中的元素（描述清楚新序列的元素和原序列元素的关系）
   3）map(函数，序列1，序列2，序列3......)
   

   names = ['张三', '小明', '李四', '小花']
   scores = [90, 89, 99, 70]
   print(list(map(lambda i1,i2:{'name':i1,'scre':i2}, names, scores)))
   
   # [{'name': '张三', 'score': 90}, {'name': '小明', 'score': 89}, {'name': '李四', 'score': 99}, {'name': '小花', 'score': 70}]
   

   reduce - 将一个序列中的元素按照指定规则合并成一个数据

   注意：开头必须写from functools import reduce

   reduce（函数，序列，初始值） - 用指定的初始值来将序列中的元素按照函数指定的规则合并成一个数据
   函数要求：1）有且只有两个参数：第一个参数指向初始值；第二个参数指向序列中的每个元素
            2）需要一个返回值：描述清楚最后合并的结果是初始值和序列中的元素通过什么样的方式合并产生的