day11-函数高阶

本文主要是介绍day11-函数高阶，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

01 匿名函数

1.匿名函数 - 没有函数名的函数
lambda 形参列表：返回值
相当于：
def (形参列表）:
return 返回值
函数名 = lambda 形参列表：返回值
相当于：
def 函数名(形参列表）:
return 返回值
注意：匿名函数的本质还是函数，之前函数中除了定义函数的语法以外的内容都适用于匿名

sum1 = lambda x,y:x+y
print(sum1(10,20))
print(sum1(x=130,y=110))

def sum1(num1,num2):
    return num1+num2

# 不能加类型，冒号会冲突
is_leap_year = lambda y: y % 400 == 0 or (y % 4 == 0 and y % 100 != 0)
print(is_leap_year (2000))
if is_leap_year(2000) :
    print('闰年')
else:
    print('不是闰年')

# 不定长参数可以使用
func1 = lambda *nums:print(nums)
func1(10,20,30)  # (10, 20, 30)

02 函数就是变量

python中定义函数就是定义类型是function的变量，函数名就是变量名。
普通变量能做的事情，函数都可以做

# x = lambda num: num*2
def x(num):
    return num*2


print(type(x))    # <class 'function'>
print(x(9))


x = 10
print(type(x))   # <class 'int'>
print(x**2)
x = '100'


x = 'abc'
print(type(x))    # <class 'str'>
print(x.replace('a', '10'))

x = [10, 20, 30]
print(type(x))    # <class 'list'>
x.append(100)
print(x)

x = {'a': 20, 'b': 30}
print(type(x))   # <class 'dict'>
print(x['a'])


def func1():
    return 100


a = 10
print(type(a), type(func1))
print(id(a), id(func1))
b = a
c = func1

print(b+20)
print(c())

list1 = [a, 100]
print(list1, list1[0]**2)

list2 = [func1, func1()]
print(list2, list2[0]())   # print(list2, func1())


def func1():
    return 100


def func2(x):
    print(x)


a = 100
func2(a)
func2(func1)

# func3是一个实参高阶函数 - 如果一个函数的参数是函数，那么这个函数就是实参高阶函数
def func3(x, y, z, m):
    # x是长度大于等于2的有序序列
    print(x[1])

    # y是任何类型的数据
    print(y)

    # z是字典
    print(z['a'])

    # m是一个函数
    m()


def t1():
    print('x')


func3('abc', 100, {'a': 100}, t1)
func3('abc', 100, {'a': 100}, lambda x = 10: x*2)

# func4是返回值高阶函数  - 如果一个函数的返回值是函数，那么这个函数就是返回值高阶函数
def func4():
    # name = '张三'
    # return name
    def t2():
        print('你好!')
    return t2


result = func4()()    # t2()  == None
print('===:', result)

# 练习：
list3 = []
for x in range(5):
    list3.append(lambda i: x*i)

"""
x = 0: [lambda i: x*i]
x = 1: [lambda i: x*i, lambda i: x*i]
x = 2: [lambda i: x*i, lambda i: x*i, lambda i: x*i]
x = 3: [lambda i: x*i, lambda i: x*i, lambda i: x*i, lambda i: x*i]
x = 4: [lambda i: x*i, lambda i: x*i, lambda i: x*i, lambda i: x*i, lambda i: x*i]
"""

print(list3[0](2))   # x*2 = 4*2 == 8
print(list3[1](2))   #
print(list3[2](2))

"""
append时，只是定义函数，还没有调用函数
在print(list3[0](2))时才调用了函数，这时x=4，执行结果为8
"""

03 实参高阶函数

python中常用的实参高阶函数：max,min,sorted, map,reduce

max和 min

max(序列）
max(序列，key=函数） - 按照key对应的函数指定的规则来获取序列中元素的最大值
key（函数）的要求:
- 1）是一个函数
- 2）有且只有一个参数 - 这个参数指向的是序列中的元素。函数的形参是序列的元素，不是序列。
- 3）有一个返回值 - 比较大小的对象

student=[
    {'name':'小明','age':18,'score':92},
    {'name':'张三','age':24,'score':99},
    {'name':'李四','age':30,'score':87},
    {'name':'王五','age':12,'score':62},
]

# max(student)

nums = [29,80,7,56,23]
tel = ['17435353','19435353','34435353','23435353',]

print(max(nums))
print(sorted(tel))

# 示例1：求个位数最大
nums = [29,80,7,56,23]

# f1  函数定义很重要
def temp(item):  # 不用遍历,是列表中的元素
    return item % 10

result = max(nums,key=temp)
print(result)

# f2
result = max(nums, key=lambda x: x % 10)
print(result)

# 示例2：求最大元素
result1 = max(nums, key=lambda x: x)
print(result1)

# 示例3：求tel尾号最大
tel = ['17435353','19435367','34435345','2343535389',]
result2 = max(tel,key=lambda x: x[-1])
print(result2)

max,min原理

print('======================')
nums = [29,80,7,56,23]

def temp(item):
    print(f'item:{item}')
    return item %10
result = max(nums,key=temp)

"""
======================
item:29
item:80
item:7
item:56
item:23
"""
def max_yt(seq:list,*,key=None):
    if not key:
        m = seq[0]
        for x in seq[1:]:
            if x>m:
                m = x
        return m

    m = seq[0]
    for x in seq[1:]:
        if key(x)>key(m):
            m = x
        return m
print(max_yt(nums))
print(max_yt(nums,key=lambda item:item%10))

# 示例4:
# 比较谁，就返回谁
nums = [123,345,908,271]
result1 = max(nums,key=lambda x: x % 10)  # 个位最大
result2 = max(nums,key=lambda x: x // 10 % 10)  # 十位最大
result3 = max(nums,key=lambda x: x // 100)  # 百位最大
print(result1,result2,result3)

sorted

"""
sorted(序列）
sorted(序列，key=函数）   -  按照key对应的函数指定的规则来获取序列中元素的最大值
key（函数）的要求：
    1）是一个函数
    2）有且只有一个参数  -  这个参数指向的是序列中的元素。函数的形参是序列的元素，不是序列。
    3）有一个返回值     -  比较大小的对象

"""
nums = [123,345,908,271]
print(sorted(nums))

result2 = sorted(nums,key=lambda x:x % 10)
print(result2)

students = [
    {'name': '小明', 'age': 18, 'score': 92},
    {'name': '张三', 'age': 24, 'score': 99},
    {'name': '李四', 'age': 30, 'score': 87},
    {'name': '王五', 'age': 16, 'score': 62}
]

result1=sorted(students,key=lambda x:x['score'],reverse=True)
print(result1)

result2=sorted(students,key=lambda x:x['age'])
print(result2)

1）map(函数，序列) - 将序列中的元素按照函数指定的规则，转换成一个新的序列
- 函数的要求：
  - a.有且只有一个参数（指向序列中的每个元素）
  - b.需要一个返回值（返回值是新序列中的元素）
2)map（函数，序列2，序列2…）
- 函数的要求：
  - a.有2个序列，那有且只有两个参数（分别指向后面的两个序列中的元素）
  - b.需要一个返回值（返回值是新序列中的元素）

nums = [18, 72, 90, 67, 16]
new_nums = list(map(lambda item: item % 10,nums))
print(new_nums)

# 练习
tel = ['17435345','19435389','34435565','23435123',]
new_tel = list(map(lambda x: x[-4:], tel))
print(new_tel)


name = ['小明','张三','李四','王五']
score = [90,89,67,92]

result1 = list(map(lambda item1,item2:{'name':item1,'score':item2},name,score))
print(result1)

# 练习  # ['10a20', '2b7', '78c10', '90d56', '16e2']
list1 =[10,2,78,90,16]
str1 = 'abcde'
list2 = [(10,20),(3,7),(9,10),(103,56),(1,2)]

result2 = list(map(lambda item1,item2,item3:str(item1)+item2+str(item3[-1]),list1,str1,list2))
print(result2)

result3 = list(map(lambda x,y,z:f'{x}{y}{z[-1]}',list1,str1,list2))
print(result3)

6.reduce

from functools import reduce
reduce(函数，序列，初始值） - 将序列中的元素按照函数指定的规则，合并成一个数据
- 函数的要求：
  - 1）有且只有两个参数
    第一个参数：第一次指向初始值，第二次开始指向上一次的计算结果
    第二个参数：指向序列中的每个元素
  - 2）描述合并规则

nums = [20,30,40,67]
result = reduce(lambda x,y:x+y,nums,0)
print(result)
"""
第一次：x= 0 y = 20  ->  x+y = 20 
第二次：x = 20,y = 30  -> x+y = 50
第三次：x= 50,y=40  -> x+y = 90
第四次：x= 90,y=67  -> x+y = 157
"""

# [18,90,89,78,67]  # 求元素个位数的和
nums = [18,90,89,78,67]
result = reduce(lambda x, item:x + item % 10, nums,0)
print(result)   # 32 = 8+0+9+8+7

list1 = [
    {'name':'泡面','price':3,'count':5},
    {'name':'口红','price':312,'count':2},
    {'name':'矿泉水','price':1,'count':10}
]
result = reduce(lambda x,item: x + item['price']*item['count'], list1, 0)
print(result)

# 练习1：求数字序列中所有元素的乘积
nums = [18, 90, 89, 78, 67]
result = reduce(lambda x,item: x*item, nums, 1)
print(result)


# 练习2：求数字序列中所有个位数的乘积
nums = [18, 90, 89, 78, 67]
result1 = reduce(lambda x,item: x*(item % 10), nums, 1)
print(result1)


# 练习3：提取字符串列表中所有的元素的最后一个字符
# ['abc'， 'hello', '你好', '123']  -> 'co好3'
list1 = ['abc', 'hello', '你好', '123']
result2 = reduce(lambda x,item: x + str(item[-1]), list1,'')
print(result2)


# 练习4：计算列表中所有数字元素的和
# [18, 'abc', 10.3, True, '你好']  -> 28.3
list2 = [18, 'abc', 10.3, True, '你好']

result3 = reduce(lambda x,item: x + (item if type(item) in [int, float] else 0), list2, 0)
print(result3)

作业

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

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

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

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

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

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

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

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

result1 = max(points,key=lambda x:x[-1])
result =[x for x in points if x[-1] == result1[-1]]
print(result)

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

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

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

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

nums = [-89,34,-78,67,23,-45,67]
result = max(nums,key=lambda x:abs(x))
print(result)

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

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

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

result = dict(map(lambda item1,item2:(item1,item2),A,B))
print(result)

已经三个列表分别表示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']
# 结果：{'小明': 'python1906', '小花': 'h51807', '小红': 'java2001', '老王': 'python2004'}

result1 = dict(map(lambda item1,item2,item3:(item1,item2+item3),names,subjects,nums))
print(result1)

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

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

from functools import reduce
message = ['你好', 20, '30', 5, 6.89, 'hello']
# 结果：31.89

# f1
result3 = reduce(lambda x,item: x + (item if type(item) in [int, float] else 0), message, 0)
print(result3)

# f2
from functools import reduce
message = ['你好', 20, '30', 5, 6.89, 'hello']
result = reduce(lambda x,item:x+item,[i for i in message if type(i) in [int,float]])
print(result)

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

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

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

students = [
  {'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}
]

# 计算平均分
students = [
  {'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}
]

# 按照平均分从高到低排序
...

from functools import reduce
students = [
  {'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}
]
# 计算平均分
# 遍历
for x in students:
    avg = int((x['math']+x['English']+x['Chinese'])/3)
    x.setdefault('avg',avg)
print(students)
# 匿名函数解决不了，用普通函数
def temp(item):
    item['avg'] = int((item['math']+item['English']+item['Chinese'])/3)
    return item
new_students = list(map(temp,students))
print(new_students)


# 按照平均分从高到低排序

students = [
  {'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}
]


new_students.sort(key=lambda x: x['avg'],reverse=True)
print(new_students)

这篇关于day11-函数高阶的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！

Java教程