文章目录

高阶函数（map filter reduce sorted）
- map（处理数据）
- filter（过滤数据）
- reduce（计算数据）
- reduce(func,lst)实现的过程
- sorted（排序）
- sort和sorted的区别
列表/集合/字典/推导式
- 概念
- 列表推导式
- - 单循环推导式
  - 带有判断条件的单循环推导式
  - 双循环推导式
  - 带有判断条件的多循环推导式
- 集合推导式
- 字典推导式
- - enumerate
  - zip
递归函数
- 定义
- 递归的特点和注意点
- 递归练习
- 尾递归
- - 定义
  - 递归计算斐波那契数列

高阶函数（map filter reduce sorted）

高阶函数的定义:能够把函数当成参数传递的就是高阶函数
常用的四大高阶函数：map filter reduce sorted

map（处理数据）

map(func,Iterable)功能:处理数据把Iterable中的数据一个一个拿出来,扔到func函数中做处理把处理之后的结果放到迭代器当中,最后返回迭代器参数:func : 自定义函数 或 内置函数Iterable : 可迭代性数据(容器类型数据 range对象 迭代器)返回值:迭代器

示例1：将[“1”,“2”,“3”,“4”]转化成[1,2,3,4]
常规写法

lst = ["1","2","3","4"]
# 常规写法
lst_new = []
for i in lst:lst_new.append(int(i))
print(lst_new)

用map改造的写法

# map改造
it = map(int,lst) # it是一个map对象
print(list(it)) # [1,2,3,4]

代码解析`

map(int,lst)的实现过程：首先把"1" 扔到int当中做处理,将强转后的结果扔到迭代器中然后把"2" 扔到int当中做处理,将强转后的结果扔到迭代器中然后把"3" 扔到int当中做处理,将强转后的结果扔到迭代器中然后把"4" 扔到int当中做处理,将强转后的结果扔到迭代器中最终返回迭代器获取迭代器中的数据的方法:1.next()  2.for循环遍历  3.for+next  4.list(it)强转

示例2：[1,2,3,4] => [2,8,24,64]

# map改造
'''参数和返回值return一定要写'''
def func(n):return n << n
lst = [1,2,3,4]
it = map(func,lst)
print(list(it)) # [2, 8, 24, 64]# lambda + map
it = map(lambda n : n << n , lst)
print(list(it))

示例3：dic = {97:“a”,98:“b”,99:“c”} # [“a”,“b”,“c”] => ascii [97,98,99]

# map改造
def func(n):# 原字典dic = {97:"a",98:"b",99:"c"}# 新字典dic_new = {}# 遍历原字典for k,v in dic.items():# 更换键值对dic_new[v] = kprint(dic_new) # {'a': 97, 'b': 98, 'c': 99}# 通过键来获取值return dic_new[n]lst = ["a","b","c"]
it = map(func,lst)
print(list(it))

filter（过滤数据）

filter(func,iterable)功能: 过滤数据return True 当前这个数据保留return False 当前这个数据舍弃参数:func : 自定义函数iterable : 可迭代型数据(容器类型数据,range对象,迭代器)返回值:迭代器

lst = [1,2,3,4,5,6,7,8,9,10]# 常规写法
lst_new = []
for i in lst:if i % 2 == 0:lst_new.append(i)print(lst_new)# filter改写
def func(i):if i % 2 == 0:return Trueelse:return False
it = filter(func,lst)# filter + lambda 改写
it = filter(lambda i : True if i % 2 == 0 else False , lst )
print(list(it))

reduce（计算数据）

reduce(func,iterable)功能:计算数据先把iterable中的前两个值拿出来,扔到func当中做运算,把计算的结果和iterable中的第三个元素在扔到func当中做运算,再把结果算出来,和第四个元素做运算,以此类推直到所有结果运算完毕.返回该结果参数:func : 自定义函数iterable : 可迭代型数据(容器类型数据,range对象,迭代器)返回值:计算之后的结果

示例1:lst = [5,4,8,8] => 整型5488
常规写法1

strvar = ""
for i in lst:strvar += str(i)
print(strvar , type(strvar))
res = int(strvar)
print(res , type(res))

常规写法2

from collections import Iterator,Iterable
lst = [5,4,8,8]
it = iter(lst)
print(isinstance(it , Iterator)) # True
print(isinstance(it , Iterable)) # Truenum1 = next(it) # 5
num2 = next(it) # 4
num = num1 * 10 + num2 # 54for i in it:num = num * 10 + i # 54*10+8=548  548*10+8=5488
print(num, type(num)) # 5488 <class 'int'>

reduce改造]

def func(x,y):return x*10 + y
lst = [5,4,8,8]
res = reduce(func,lst)
print(res , type(res))# reduce+lambda:
res = reduce(lambda x,y:x*10+y,lst)
print(res)

reduce(func,lst)实现的过程

先拿出5和4两个元素,扔到func当中做运算,结果是54
在拿54和8两个元素,扔到func当中做运算,结果548
在拿548和8两个元素,扔到func当中做运算,结果5488
返回最终的结果: 5488 程序结束

示例2:“789”=>789 禁止使用int强制转换

def func1(x,y):return x*10 + y
def func2(n):dic = {"0":0,"1":1,"2":2,"3":3,"4":4,"5":5,"6":6,"7":7,"8":8,"9":9}return dic[n]
it = map(func2,"789") # [7,8,9]
res = reduce(func1,it)
print(res,type(res))

sorted（排序）

sorted(iterable,key=函数,reverse=False)功能:排序参数:iterable:可迭代型数据(容器类型数据,range对象,迭代器)key :指定自定义函数或内置函数reverse :代表升序或者降序 , 默认是升序(从小到大排序) reverse=False返回值:排序后的结果

# 1.默认是从小到大排序
lst = [1,2,3,4,5,-90,-4,-1,100]
res = sorted(lst)
print(res)# 2.reverse 从大到小排序
res = sorted(lst,reverse=True)
print(res)# 3.指定函数进行排序
# 按照绝对值排序 abs
lst = [-10,-1,3,5]
res = sorted(lst,key=abs)
print(res)# 4.使用自定义函数进行排序
lst = [19,21,38,43,55]
def func(n):return n % 10
lst = sorted(lst,key=func)
print(lst)

sort和sorted的区别

(1) sorted可以排序一切容器类型数据, sort只能排列表
(2) sorted返回的是新列表,sort是基于原有的列表进行修改
(3) 推荐使用sorted

列表/集合/字典/推导式

概念

推导式的定义: 通过一行循环判断,遍历一系列数据的方式推导式的语法:val for val in Iterable三种方式:[val for val in Iterable]{val for val in Iterable}{k:v for k,v in Iterable}

列表推导式

单循环推导式

将[1,2,3,4,5] -> [3,6,9,12,15]

# 单循环推导式 [1,2,3,4,5] -> [3,6,9,12,15]
lst = [1,2,3,4,5]
lst_new = []
for i in lst:res = i * 3lst_new.append(res)
print(lst_new)# 改写成推导式
lst = [i*3 for i in lst]
print(lst)

带有判断条件的单循环推导式

# 带有判断条件的单循环推导式 (只能是单项分支,接在for后面)
lst = [1,2,3,4,5,6,7,8]
lst_new = []
for i in lst:if i % 2 == 1:lst_new.append(i)
print(lst_new)# 改写成推导式
lst = [i for i in lst if i % 2 == 1]
print(lst)

双循环推导式

# 双循环推导式
lst1 = ["A","B","C","D"]
lst2 = ["X","Y","Z","Q"]
# "谁"❤"谁"
lst_new = []
for i in lst1:for j in lst2:strvar = i + "❤" + jlst_new.append(strvar)
print(lst_new)# 改写成推导式
lst = [i + "❤" + j for i in lst1 for j in lst2]
print(lst)

带有判断条件的多循环推导式

# 带有判断条件的多循环推导式
lst_new = []
for i in lst1:for j in lst2:if lst1.index(i) == lst2.index(j):strvar = i + "❤" + jlst_new.append(strvar)
print(lst_new)# 改写成推导式
lst = [ i + "❤" + j for i in lst1 for j in lst2 if lst1.index(i) == lst2.index(j) ]
print(lst)

集合推导式

关于集合推导式的一个示例:
1.集合有自动去重的效果

2.用三元表达式+推导式即可实现

"""
案例:满足年龄在18到21,存款大于等于5000 小于等于5500的人,开卡格式为:尊贵VIP卡老x(姓氏),否则开卡格式为:普通用户卡老x(姓氏)把开卡的种类统计出来
"""
listvar = [{"name":"彭云飞","age":18,"money":10000},{"name":"夏圣钦","age":19,"money":5100},{"name":"陈正正","age":20,"money":4800},{"name":"王添龙","age":21,"money":2000},{"name":"万潇阳","age":18,"money":20}
]# 常规写法
setvar = set()
for i in listvar:if 18 <= i["age"] <= 21 and  5000 <= i["money"] <= 5500:res = "尊贵VIP卡老" + i["name"][0]else:res = "普通用户卡老" + i["name"][0]setvar.add(res)
print(setvar)# 改写成集合推导式
# {三元运算符 + 推导式}
setvar = { "尊贵VIP卡老" + i["name"][0] if 18 <= i["age"] <= 21 and  5000 <= i["money"] <= 5500 else "普通用户卡老" + i["name"][0] for i in listvar }
print(setvar)

字典推导式

enumerate

功能:枚举 ; 将索引号和iterable中的值,一个一个拿出来配对组成元组放入迭代器中
参数:iterable: 可迭代性数据 (常用:迭代器,容器类型数据,可迭代对象range)start: 可以选择开始的索引号(默认从0开始索引)
返回值:迭代器

enumerate形成字典推导式示例：

from collections import Iterator
lst = ["东邪","西毒","南帝","北丐"]# 基本使用
it = enumerate(lst) # [(0, '东邪'), (1, '西毒'), (2, '南帝'), (3, '北丐')]
print(isinstance(it,Iterator))# for + next
for i in range(4):print(next(it))
# list
"""start可以指定开始值,默认是0"""
it = enumerate(lst,start=1)
print(list(it)) # [(1, '东邪'), (2, '西毒'), (3, '南帝'), (4, '北丐')]# enumerate 形成字典推导式 变成字典
dic = { k:v for k,v in enumerate(lst,start=1) }
print(dic) # {1: '东邪', 2: '西毒', 3: '南帝', 4: '北丐'}# dict 强制变成字典
dic = dict(enumerate(lst,start=1))
print(dic) # {1: '东邪', 2: '西毒', 3: '南帝', 4: '北丐'}

zip

ip(iterable, ... ...)功能:将多个iterable中的值,一个一个拿出来配对组成元组放入迭代器中参数:iterable: 可迭代性数据 (常用:迭代器,容器类型数据,可迭代对象range) 返回值: 迭代器特征:如果找不到对应配对的元素,当前元素会被舍弃

lst1=["Fly","1dao","Hurt","Mojo"]
lst2=["Snow","Song","Giao"]
lst3=["770","JieJ"]it = zip(lst1,lst2,lst3)
print(list(it)) # [('Fly', 'Snow', '770'), ('1dao', 'Song', 'JieJ')]
# zip形成字典推导式 变成字典
lst1=["Fly","1dao","Hurt","Mojo"]
lst2=["Snow","Song","Giao"]
dic={k:v for k,v in zip(lst1,lst2)}
print(dic) # {'Fly': 'Snow', '1dao': 'Song', 'Hurt': 'Giao'}
# dict强制变为字典
dic = dict(zip(lst1,lst2))
print(dic) # {'Fly': 'Snow', '1dao': 'Song', 'Hurt': 'Giao'}

递归函数

定义

递归函数的定义 : 自己调用自己的函数就是递归
递-去-归-回一去一回就是递归

简单的递归例子

# 1.一个简单的递归例子
def digui(n):print(n,"<====1===>")if n > 0:    digui(n-1)print(n,"<====2===>")
digui(5)"""
# 代码解析:
去的过程:
n = 5 print(5,"<====1===>") 5>0 条件成立-> digui(5-1) => digui(4) 代码阻塞在第13行
n = 4 print(4,"<====1===>") 4>0 条件成立-> digui(4-1) => digui(3) 代码阻塞在第13行
n = 3 print(3,"<====1===>") 3>0 条件成立-> digui(3-1) => digui(2) 代码阻塞在第13行
n = 2 print(2,"<====1===>") 2>0 条件成立-> digui(2-1) => digui(1) 代码阻塞在第13行
n = 1 print(1,"<====1===>") 1>0 条件成立-> digui(1-1) => digui(0) 代码阻塞在第13行
n = 0 print(0,"<====1===>") 0>0 条件不成立 print(0,"<====2===>")
当前这层空间代码已经执行结束
此刻触发回的过程n = 1 从上一次13行的代码阻塞位置,继续向下执行 print(1,"<====2===>")
n = 2 从上一次13行的代码阻塞位置,继续向下执行 print(2,"<====2===>")
n = 3 从上一次13行的代码阻塞位置,继续向下执行 print(3,"<====2===>")
n = 4 从上一次13行的代码阻塞位置,继续向下执行 print(4,"<====2===>")
n = 5 从上一次13行的代码阻塞位置,继续向下执行 print(5,"<====2===>")
到此,递归函数彻底执行结束.
5 4 3 2 1 0 0 1 2 3 4 5"""

递归的特点和注意点

一.递归是一去一回的过程,
调用函数时,会开辟栈帧空间,函数执行结束之后,会释放栈帧空间
递归实际上就是不停的开辟和释放栈帧空间的过程
每次开辟栈帧空间,都是独立的一份,其中的资源不共享二.触发回的过程
1.当最后一层栈帧空间全部执行结束的时候,会触底反弹,回到上一层空间的调用处
2.遇到return,会触底反弹,回到上一层空间的调用处,3.写递归时,必须给与递归跳出的条件,否则会发生内存溢出,蓝屏死机的情况.
如果递归层数过多,不推荐使用递归

递归练习

用递归计算n的阶乘

# 常规方法
# 5! = 5*4*3*2*1
def func(n):total = 1for i in range(n,0,-1):total *= ireturn totalres = func(5)
print(res)# 递归写法
def jiecheng(n):if n <= 1:return 1return n*jiecheng(n-1)
res = jiecheng(5)
print(res)
"""
return 后面的表达式,一定是先计算完在返回# 代码解析:
# 去的过程:
n = 5   return 5*jiecheng(5-1) => 5 * jiecheng(4)
n = 4   return 4*jiecheng(4-1) => 4 * jiecheng(3)
n = 3   return 3*jiecheng(3-1) => 3 * jiecheng(2)
n = 2   return 2*jiecheng(2-1) => 2 * jiecheng(1)
n = 1   return 1# 回的过程:
n = 2   return 2*jiecheng(2-1) => 2 * jiecheng(1) => 2 * 1
n = 3   return 3*jiecheng(3-1) => 3 * jiecheng(2) => 3 * 2 * 1
n = 4   return 4*jiecheng(4-1) => 4 * jiecheng(3) => 4 * 3 * 2 * 1
n = 5   return 5*jiecheng(5-1) => 5 * jiecheng(4) => 5 * 4 * 3 * 2 * 1
return 5 * 4 * 3 * 2 * 1 => return 120额外解析:
jiecheng(1) => 1
jiecheng(2) => 2*jiecheng(1) => 2*1
jiecheng(3) => 3*jiecheng(2) => 3*2*1
jiecheng(4) => 4*jiecheng(3) => 4*3*2*1
jiecheng(5) => 5*jiecheng(4) => 5*4*3*2*1
"""

尾递归

定义

自己调用自己,并且非表达式
计算的结果要在参数当中完成.
尾递归无论调用多少次函数,都只占用一份空间,但是目前cpython不支持.

def jiecheng(n,endval):if n <= 1:return endvalreturn jiecheng(n-1,endval*n)res = jiecheng(5,1)
print(res)"""
# 代码解析:
去的过程
n=5 , endval=1         return jiecheng(5-1,endval*5) => jiecheng(4,1*5)
n=4 , endval=1*5       return jiecheng(4-1,endval*4) => jiecheng(3,1*5*4)
n=3 , endval=1*5*4     return jiecheng(3-1,endval*3) => jiecheng(2,1*5*4*3)
n=2 , endval=1*5*4*3   return jiecheng(2-1,endval*2) => jiecheng(1,1*5*4*3*2)
n=1 , endval=1*5*4*3*2 return 120回的过程:
n=2 return 120
n=3 return 120
n=4 return 120
n=5 return 120因为最后一层空间的返回值就是第一层空间的返回值,所有在使用尾递归的时候
不需要考虑回的逻辑过程,就能解决问题.推荐使用.
"""

可以对尾递归计算n的阶乘例子进行优化，因为在jiecheng()函数中,有两个参数，这样用户有可能会乱传参数,为了防止乱传参数。设计了如下两种方法解决:

# 优化1
def jiecheng(n,endval=1):if n <= 1:return endvalreturn jiecheng(n-1,endval*n)res = jiecheng(5)
print(res,"<111>")# 优化2
"""为了避免用户乱传参数,把endval这个参数隐藏起来"""
def outer(n):def jiecheng(n,endval=1):if n <= 1:return endvalreturn jiecheng(n-1,endval*n)return jiecheng(n) # jiecheng(n-1,endval*n)res = outer(5)
print(res)

递归计算斐波那契数列

def feb(n):# 递归跳出的条件if n <= 2: # n == 1 or n == 2 => 1return 1return feb(n-1) + feb(n-2)
res = feb(5)
print(res)

高阶函数、列表/集合/字典/推导式、递归函数相关推荐

PythonStudy——列表与字典推导式 List and dictionary derivation
# 快速生成列表或字典的语法糖,且能在生成过程中添加简单的逻辑 # 能被列表推导式推导的数据源必须在循环取值时可以得到一个值 ls = [v for v in range(1, 6)] print(l ...
【Kotlin】Kotlin 语言集合中的高阶函数详解 ( 数据类 data class | maxBy | minBy | filter | map | any | count | find )
文章目录 I . List 集合高阶函数引入 II . Kotlin 数据类 ( data class ) III . Java 代码与 Kotlin 代码实现对比 ( 查询年龄最大的 ) IV . ...
c++绝对值函数_Python自带自定义高阶函数实战
一.概述高阶函数,就是一个函数可以接收另一个函数作为参数的函数,或者接受一个或多个函数作为输入并输出一个函数的函数.scala与之类似. 二.自带常用高阶函数 1.map #map(f, Itera ...
python中sort返回值_Python函数你真的都学会了吗？来看看这篇Python高阶函数！
二.高阶函数高级函数, 英文叫 Higher-order Function. 那么什么是高阶函数呢? 在说明什么是=高阶函数之前, 我们需要对函数再做进一步的理解! 2.1 函数的本质函数的本质是 ...
Python函数你真的都学会了吗？来看看这篇Python高阶函数！
二.高阶函数高级函数, 英文叫 Higher-order Function. 那么什么是高阶函数呢? 在说明什么是=高阶函数之前, 我们需要对函数再做进一步的理解! 2.1 函数的本质函数的本质是 ...
[译]Effective Kotlin系列之探索高阶函数中inline修饰符(三)
简述: 不知道是否有小伙伴还记得我们之前的Effective Kotlin翻译系列,之前一直忙于赶时髦研究Kotlin 1.3中的新特性.把此系列耽搁了,赶完时髦了还是得踏实探究本质和基础,从今天开始 ...
第一章 1.11 高阶函数
一.实参高阶函数 1.函数作为变量使用 python中声明函数就是声明一个类型是function的变量,变量名就是函数名普通变量能做的函数都能做: 1).一个变量可以给另一个变量赋值,函数也可以赋值 ...
总结Vue第一天~简单介绍、基本知识、辅助函数和js数组的高阶函数
目录 vue中文官网一.简单介绍: (1)vue.js :本质就是一个js 核心类库[跟咱使用的其他组件插件而安装他们]: ■ 安装方式: (2)小demo了解一下vue.js: (3)响应式: 二 ...
Python中的装饰器、迭代器、生成器、推导式、匿名函数和高阶函数
文章目录装饰器迭代器生成器推导式匿名函数高阶函数装饰器闭包介绍装饰器前先了解一下闭包,在Python中,一切皆对象(Object),函数(Function)也不例外,也是一个普通的对 ...

高阶函数、列表/集合/字典/推导式、递归函数