week3day2函数进阶

week3day2函数进阶

一.匿名函数

'''
1.匿名函数（python的匿名函数只能用来实现功能很简单的函数）
匿名函数本质还是函数，他们除了定义的语法不同，其他的东西都一样
语法：
lambda 形参列表：返回值

调用：
函数名=lambda 形参列表：返回值
函数名（实参列表）
'''
#练习1：写一个匿名函数判断指定的数是否是偶数，如果是返回True，否则返回Fals
function1=lambda num:num%2==0
num1=int(input('请输入一个整数：'))
print(function1(num1))


#练习二：写一个匿名函数判断指定的年是否是闰年，如果是返回True，否则返回Fals
function1=lambda num:num%4==0 and num%100!=0 or num%400==0
num1=int(input('请输入一个整数：'))
print(function1(num1))

二.变量的作用

'''
1.变量的作用域：变量定义以后可以使用的范围
根据变量的作用域不同分为全局变量和局部变量

2.全局变量和局部变量
（1）全局变量
没有定义在函数和类里面的变量都是全局变量
全局变量的作用域是从定义开始到程序结束
全局变量保存在全局的栈区间，全局栈区间在程序结束之后才会自动释放

（2）局部变量
定义在函数中的变量是局部变量，其中包括形参；
局部变量的作用域是从定义开始到函数结束
调用函数的时候系统1会自动给这个函数创建一个临时栈区间用来保存在函数中产生的数据（包括局部变量）
当寒素调用结束这个临时栈区间会自动释放

3.global关键字
作用1：在函数里面去修改一个全局变量的值，修改之前先用global对变量进行说明

作用2：在函数中定义一个全局变量
'''

三.函数就是变量

'''
1.在python中定义函数其实就是定义类型是function的变量，函数名就是变量名
变量能干的事，函数都能干


2.高阶函数：实参高阶函数，返回值高阶函数
（1）实参高阶函数（有一个参数是函数）
（2）返回值高级函数（返回值是函数）

'''

四.实参高级函数

'''
常用的实参高阶函数：max,min,sorted,sort,map,reduce
1.如果函数的参数是函数，提供实参的方式：
a.用普通的函数的函数名
b.使用匿名函数
2.常用实参高阶函数
（1）max,min,sorted,列表.sort
max(序列)—求序列中值最大的元素
max(序列，key=函数)—根据函数指定的规则获取序列中最大的元素
函数的要求:a.有且只有一个参数（这个参数代表序列中的元素）
         b.有一个返回值（比较对象）
'''
# 练习1：获取nums中绝对值最大的元素
nums = [29, 73, 64, -31, 68, 55, -76]
print(max(nums,key=lambda iterm:abs(iterm)))

# 练习2：获取points中y坐标最大的元素
points = [(19, 2), (0, 18), (3, 4)]
print(max(points,key=lambda iterm:iterm[1]))


# 练习3：获取年龄最大的学生；获取成绩最高的学生
students = [
    {'name': 'stu1', 'age': 19, 'score': 72},
    {'name': 'stu2', 'age': 22, 'score': 89},
    {'name': 'stu3', 'age': 30, 'score': 60},
    {'name': 'stu4', 'age': 17, 'score': 77}
]
print(max(students,key=lambda iterm:iterm['age'])['name'])
print(max(students,key=lambda iterm:iterm['score'])['name'])

'''
(2)map—将序列中的元素按照函数指定的规则进行变换得到一个新的序列
map(函数，序列)
函数的要求:1.有且只有1个参数（代表序列中的元素）
         2.有一个返回值(新序列中的元素-这只需要描述清楚新序列中的元素与原序列元素的关系)
         
map(函数，序列1，序列2)
函数的要求:1.有且只有2个参数（分别代表原序列中的元素）
         2.有一个返回值(新序列中的元素-这只需要描述清楚新序列中的元素与原序列元素的关系)
         
map(函数，序列1，序列2，序列3)
函数的要求:1.有且只有3个参数（分别代表原序列中的元素）
         2.有一个返回值(新序列中的元素-这只需要描述清楚新序列中的元素与原序列元素的关系)        
...

'''

# 练习2：将nums中所有的元素乘以2
nums = [29, 73, 64, 301, 68, 55, 76]
# [58, 146, 128, 602, 136, 110, 152]
result=list(map(lambda item:item*2,nums))
print(result)

# 练习4：
nums1 = [238, 89, 78, 23]
nums2 = [92, 78, 61, 44]
# [82, 98, 81, 34]
result=list(map(lambda item1,item2:item1%10*10+item2%10,nums1,nums2))
print(result)

# 练习5
list1 = ['python', 'java', 'h5']
list2 = [22, 21, 19]
list3 = [2, 9, 18]
# ['python2202', 'java2109', 'h51918']
result=list(map(lambda item1,item2,item3:item1+str(item2)+str(item3).rjust(2,'0'),list1,list2,list3))
print(result)

'''
(3)reduce — 将序列中的元素按照指定的规则合并成一个数据
reduce(函数,序列,初始值)
初始值：一般是0，1或者空串
函数的要求:1.有且只有两个参数（第一个参数指向初始值，第二个参数指向序列中的每个元素）
         2.有一个返回值（决定合并方式）
         注意：使用reduce之前，必须先从functools模块中导入（from functools import reduce）
'''
from functools import reduce
students = [
    {'name': 'stu1', 'age': 19, 'score': 72},
    {'name': 'stu2', 'age': 22, 'score': 89},
    {'name': 'stu3', 'age': 30, 'score': 60},
    {'name': 'stu4', 'age': 17, 'score': 77}
]
# 求总分数
result=reduce(lambda x,item:x+item['score'],students,0)
print(result)

housework

1. 写一个匿名函数，判断指定的年是否是闰年

   function1=lambda item:item%4==00and item%100!=0 or item%400==0
   num=int(input('请输入年份:'))
   print(function1(num))
   

2. 写一个函数将一个指定的列表中的元素逆序( 如[1, 2, 3] -> [3, 2, 1])(注意:不要使用列表自带的逆序函数)

   def function2(list1:list):
       result =[]
       for index1,x in enumerate(list1):
           result.insert(-index1-1,x)
       return result
   print(function2([1,2,3,4]))
   

3. 编写一个函数，计算一个整数的各位数的平方和

   def function3(int1):
       str1=str(int1)
       result=0
       for x in str1:
           result+=int(x)**2
       return result
   print(function3(123))
   

4. 求列表 nums 中绝对值最小的元素

   例如：nums = [-23, 100, 89, -56, -234, 123], 最大值是：-23

   nums = [-23, 100, 89, -56, -234, 123]
   result=min(nums,key=lambda item:abs(item))
   print(result)
   

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

   A = ['name', 'age', 'sex']
   B = ['张三', 18, '女']
   新字典: {'name': '张三', 'age': 18, 'sex': '女'}
       
   A = ['name', 'age', 'sex']
   B = ['张三', 18, '女']
   result=dict(map(lambda item1,item2:(item1,item2),A,B))
   print(result)
   
   

6. 已经三个列表分别表示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']
   result=dict(map(lambda item1,item2,item3:(item1,item3+item2),names,nums,subjects))
   print(result)
   

7. 已经一个列表message, 使用reduce计算列表中所有数字的和

   message = ['你好', 20, '30', 5, 6.89, 'hello']
   结果：31.89
   
   from functools import reduce
   message = ['你好', 20, '30', 5, 6.89, 'hello']
   result=reduce(lambda x,item:x+item if type(item) in (int,float) else x,message,0)
   print(result)
   

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

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

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

   result=max(points,key=lambda item:item[-1])
   print(result)
   

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

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

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

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

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

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