Python高阶函数

最新推荐文章于 2024-08-09 15:33:08 发布

劲节子

最新推荐文章于 2024-08-09 15:33:08 发布

阅读量169

点赞数

分类专栏： Python

本文链接：https://blog.csdn.net/qq_45070541/article/details/109593444

版权

Python 专栏收录该内容

27 篇文章 1 订阅

订阅专栏

Python高阶函数

lambda
map
reduce
filter
sorted

lambda

匿名函数就是不需要显式的指定函数名。

在这里插入图片描述

关键字lambda表示匿名函数，冒号前面的n表示函数参数，可以有多个参数。

匿名函数有个限制，就是只能有一个表达式，不用写return，返回值就是该表达式的结果。

用匿名函数有个好处，因为函数没有名字，不必担心函数名冲突。此外，匿名函数也是一个函数对象，也可以把匿名函数赋值给一个变量，再利用变量来调用该函数：

有些函数在代码中只用一次，而且函数体比较简单，使用匿名函数可以减少代码量，看起来比较"优雅“

#这段代码
def calc(x,y):
    return x**y

#换成匿名函数
calc = lambda x,y:x**y
print(calc(2,5))

def calc(x,y):
    if x > y:
        return x*y
    else:
        return x / y
    
#三元运算换成匿名函数
calc = lambda x,y:x * y if x > y else x / y
print(calc(2,5))

主要与其他函数联合使用

lambda作参数

def func(x,y,func):
	print(x,y)
	print(func)
	func(x,y)


#调用
func(1,2,lambda a,b:a+b)

func = lambda x:x if x%2==0 else  x+1
print(func(5))

在这里插入图片描述

map

map()函数接收两个参数，一个是函数，一个是Iterable，map将传入的函数依次作用到序列的每个元素，并把结果作为新的Iterator返回

遍历序列，对序列中每个元素进行函数操作，最终获取新的序列。

在这里插入图片描述

#将元组转换成list
map(int, (1,2,3))

#将字符串转换成list***
map(int, '1234')

#提取字典的key，并将结果存放在一个list中
map(int, {1:2,2:3,3:4})

#字符串转换成元组，并将结果以列表的形式返回***
map(tuple, 'agdf')
[('a',), ('g',), ('d',), ('f',)]

#将小写转成大写
def u_to_l (s):
  return s.upper()
print map(u_to_l,'asdfd')

#当不传入function时，map()就等同于zip()，将多个列表相同位置的元素归并到一个元组：
map(None,[2,4,6],[3,2,1])

def square(x) :            # 计算平方数
	return x ** 2

map(square, [1,2,3,4,5])   # 计算列表各个元素的平方

map(lambda x: x ** 2, [1, 2, 3, 4, 5])  # 使用 lambda 匿名函数

#提供了两个列表，对相同位置的列表数据进行相加
map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])

在这里插入图片描述

reduce

reduce把一个函数作用在一个序列[x1, x2, x3, …]上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算，其效果就是：

reduce(func,[1,2,3]) 等同于 func(func(1,2),3)对于序列内所有元素进行累计操作

在这里插入图片描述

接受一个list并利用reduce()求积 
from functools import reduce 
li =[1,2,3,4,5,6,7,8,9] print(reduce(lambda x,y:x * y,li)) 
> 结果=1*2*3*4*5*6*7*8*9 = 362880

在这里插入图片描述

filter

filter()也接收一个函数和一个序列。和map()不同的是，filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素。

对于序列中的元素进行筛选，最终获取符合条件的序列

在这里插入图片描述

import math
def is_sqr(x):
    return math.sqrt(x) % 1 == 0
 
newlist = filter(is_sqr, range(1, 101))
print(newlist)

>>> candidate = 'dade142.;!0142f[.,]ad'

>>> filter(str.isdigit, candidate)　　#保留数字

'1420142'

>>> filter(str.isalpha, candidate)　　#保留字母

‘dadefad’

>>> filter(str.isalnum, candidate)　　#保留数字字母

‘dade1420142fad’

>>> filter(lambda ch: ch in ‘0123456789.’, crazystring)　　#保留数字和小数点

‘142.0142.’

# 声明两个列表变量
list1 = ['Python', 'PHP', 'Java',  'Bash']
list2 = ['JavaScript是客户端脚本语言',
        'PHP是服务器端脚本语言',
         'Java是一种编程语言',
        'Kotlin是一种静态编程语言']

# 根据第一个列表过滤第二个列表
filter_data = [x for x in list2 if
              all(y  not in x for y in list1)]

# 在过滤前和过滤后打印列表数据
print("第一个列表的内容:",  list1)
print("第二个列表的内容:", list2)
print("过滤后的第二个列表的内容:", filter_data)

# 导入re模块以使用正则表达式
import re

# 声明列表包含科目编号
sublist = ['IDC-108',  'OKY-309', 'IDC-709', 'PHP-102', 'MIO-801']

# 声明过滤功能
def Filter(datalist):
    # 根据列表中的正则表达式搜索数据
    return [val  for val in datalist
        if re.search(r'^IDC', val)]

# 打印过滤器数据
print(Filter(sublist))

# 声明一个包含linuxidc_word中关键词的列表
linuxidc_word = ["系统", "linuxidc", "Python",  "Kotlin"]

# 定义文本，从列表中搜索单词
text = "Linux公社 linuxidc 是专业的 Linux 系统 门户网站，实时发布 最新 Kotlin  资讯!"

# 根据空格分割文本并将单词存储在列表中
text_word = text.split()

# 使用lambda表达式过滤数据
filter_text = ' '.join((filter(lambda val: val not in  linuxidc_word, text_word)))

# 在过滤前和过滤后打印文本
print("\n过滤前的文本：\n", text)
print("过滤后的文本：\n",  filter_text)

li1=[x for x in li if 'video' in x ]
li=filter(lambda x: 'video' in x ,li)

#获取100以内的质数
list(map(lambda y:y if not list(filter(lambda x:y % x==0,range(2,y))) else 0,range(1,100)))

1. filter(lambda x:y % x==0,range(2,y))      #将一个数的因数筛选出来，也可以用来判断一个数是否为质数
2. list(filter(lambda x:y % x==0,range(2,y))) #因为返回的是一个对象，所以要用list函数转换
3. if not list(filter(lambda x:y % x==0,range(2,y))) #判断这个列表是否为空
4. lambda y:y if not ... else 0  #判断列表是否为空，为空就输出y
5。 map(... ,range(1,100))       #开始遍历1到100

这个想法有点瑕疵，就是在输出的列表中非质数的部分会用0代替，具体解决方案正在思索，欢迎指点

[i for i in range(2,100) if not[j for j in range(2,i) if i%j == 0]] #列表生成式找质数

在这里插入图片描述

sorted

sorted(iterle, /, *, key=None, reverse=False)接收一个key函数来实现对可迭代对象进行自定义的排序
可迭代对象：主要与列表，字符串，元祖，集合和字典
key：接受一个函数，根据此函数返回的结果，进行排序
reverse：排序方向，默认为从小到大，reverse=True为逆向

复制代码

 对列表按照绝对值进行排序
li= [-21, -12, 5, 9, 36]
print(sorted(li, key = lambda x:abs(x)))
 [5, 9, -12, -21, 36]

"""
sorted()函数按照keys进行排序，并按照对应关系返回list相应的元素：

keys排序结果 => [5, 9,  12,  21, 36]
                |  |    |    |   |
最终结果     => [5, 9, -12, -21, 36]
"""
复制代码
 

举例使用：

复制代码
 把下面单词以首字母排序
li = ['bad', 'about', 'Zoo', 'Credit']
print(sorted(li, key = lambda x : x[0]))
 输出['Credit', 'Zoo', 'about', 'bad']
"""
对字符串排序，是按照ASCII的大小比较的，由于'Z' < 'a'，结果，大写字母Z会排在小写字母a的前面。
"""

 假设我们用一组tuple表示学生名字和成绩：

L = [('Bob', 75), ('Adam', 92), ('Bart', 66), ('Lisa', 88)]
 请用sorted()对上述列表分别按名字排序
print(sorted(L, key = lambda x : x[0]))
 输出[('Adam', 92), ('Bart', 66), ('Bob', 75), ('Lisa', 88)]

 再按成绩从高到低排序
print(sorted(L, key = lambda x : x[1], reverse=True))
 输出[('Adam', 92), ('Lisa', 88), ('Bob', 75), ('Bart', 66)]