python-迭代器_高阶函数
1. 迭代器
迭代器 :
能被next调用,并不断返回下一个值的对象,叫做迭代器(对象)
概念 :
迭代器指的是迭代取值的工具,迭代是一个重复的过程,每次重复都是基于上一个结果而继续的
单纯的重复并不是迭代
特征 :
并不依赖索引,而通过next指针迭代所有数据,一次只取一个值,大大节省空间
1. 可迭代对象
setvar = {"a","b","c","d"}
for i in setvar:
print(i)
"""
dir 获取当前类型对象中的所有成员
__iter__ 方法用来判断是否是可迭代性数据
"""
lst = dir(setvar)
print(dir("123"))
res = "__iter__" in dir(setvar)
print(res)
2. 迭代器
for 循环能够遍历一切可迭代性数据的原因在于,底层调用了迭代器,通过next方法中的指针实现数据的获取
可迭代对象 -> 迭代器 不能够被next直接调用 -> 可以被next直接调用的过程
如果是一个可迭代对象不一定是迭代器
但如果是一个迭代器就一定是一个可迭代对象
-
如何来定义一个迭代器
setvar = {"a","b","c","d"} it = iter(setvar) print(it) -
如何来判断一个迭代器
setvar = {"a","b","c","d"} it = iter(setvar) print(dir(it)) res = "__iter__" in dir(it) and "__next__" in dir(it) print(res) -
如何来调用一个迭代器
"""next 在调用迭代器中的数据时,是单向不可逆,一条路走到黑的过程""" setvar = {"a","b","c","d"} it = iter(setvar) res = next(it) print(res) res = next(it) print(res) res = next(it) print(res) res = next(it) print(res) """ # StopIteration 报错 停止迭代 res = next(it) print(res) """ -
重置迭代器
# 接上一段代码 it = iter(setvar) res = next(it) print(res) -
使用其他方法判断迭代器或者可迭代对象
""" Iterator 迭代器 Iterable 可迭代对象 from ... 从哪里 import ... 引入 """ from collections import Iterator,Iterable """ from collections.abc import Iterator,Iterable python3.7 """ res = isinstance(it,Iterator) print(res) res = isinstance(it,Iterable) print(res) -
使用其他方式调用迭代器中的数据
# 1. for 循环 setvar = {"a","b","c","d"} it = iter(setvar) for i in it: print(i) # 2. for + next lst = [1,2,3,4,5,6,7,8,9,10,11,12] it = iter(lst) for i in range(10): res = next(it) print(res) print(next(it)) print(next(it))
2. 高阶函数
高阶函数 : 能够把函数当成参数传递的就是高阶函数
1. map
语法结构 : map(func,Iterable)
功能: 处理数据
把 Iterable 中的数据一个一个拿出来,扔到 func 函数中做处理
把处理之后的结果放到迭代器当中,最后返回迭代器
参数:
func : 自定义函数 或 内置函数
Iterable : 可迭代性数据 (容器类型数据 range对象 迭代器)
返回值:
迭代器
# 1. lst = ["1","2","3","4"] => [1,2,3,4]
lst = ["1","2","3","4"]
# a. 常规写法
lst_new = []
for i in lst:
lst_new.append(int(i))
print(lst_new)
# b. map 改造
it = map(int,lst)
"""
代码解析:
先把"1"扔到int当中做处理,将强转后的结果扔到迭代器中
然后把"2"扔到int当中做处理,将强转后的结果扔到迭代器中
然后把"3"扔到int当中做处理,将强转后的结果扔到迭代器中
然后把"4"扔到int当中做处理,将强转后的结果扔到迭代器中
最终返回迭代器
"""
# c. 获取迭代器中的数据
# 方法1. next
res = next(it)
print(res)
res = next(it)
print(res)
res = next(it)
print(res)
res = next(it)
print(res)
# 方法2. for
for i in it:
print(i)
# 方法3. for + next
for i in range(4):
res = next(it)
print(res)
# d. list强转
print(list(it))
# 2. [1,2,3,4] => [2,8,24,64]
lst = [1,2,3,4]
"""
1 * 2^1 = 2
2 * 2^2 = 8
3 * 2^3 = 24
4 * 2^4 = 64
"""
# 常规写法
lst_new = []
for i in lst:
res = i << i
lst_new.append(res)
print(lst_new)
# map 改造
"""参数和返回值return一定要写"""
def func(n):
return n << n
lst = [1,2,3,4]
it = map(func,lst)
print(list(it))
# lambda + map
it = map(lambda n : n << n,lst)
print(list(it))
# 3. {97:"a",98:"b",99:"c"}
dic = {97:"a",98:"b",99:"c"} # ["a","b","c"] => ascii [97,98,99]
# 常规写法
dic = {"a":97,"b":98,"c":99}
def func(lst):
lst_new = []
# 遍历列表
for i in lst:
# 通过键取值
res = dic[i]
# 把值追加到新的列表中
lst_new.append(res)
# 返回新列表
return lst_new # [97,98,99]
res = func(lst = ["a","b","c"])
print(res)
# 将键值对反转
dic = {97:"a",98:"b",99:"c"}
dic_new = {}
for k,v in dic.items():
dic_new[v] = k
print(dic_new)
lst = ["a","b","c"]
lst_new = []
# 遍历列表
for i in lst:
# 通过键取值
res = dic_new[i]
# 把值追加到新的列表中
lst_new.append(res)
# 返回新列表
print(lst_new)
# map 改造
def func(n):
# 原字典
dic = {97:"a",98:"b",99:"c"}
# 新字典
dic_new = {}
# 遍历原字典
for k,v in dic.items():
# 更换键值对
dic_new[v] = k
print(dic_new) # {'a': 97, 'b': 98, 'c': 99}
# 通过键获取值
return dic_new[n]
lst = ["a","b","c"]
it = map(func,lst)
print(list(it))
2. 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 True
else:
return False
it = filter(func,lst)
# 1.next
res = next(it)
print(res)
# 2. for
for i in it:
print(i)
# 3. for + next
it = filter(func,lst)
for i in range(5):
res = next(it)
print(res)
# 4. list 强转
res = list(it)
print(res)
# filter + lambda 改写
it = filter(lambda i : True if i % 2 == 0 else False , lst)
print(list(it))
3. reduce
语法结构 : reduce(func,Iterable)
功能 : 计算数据
先把 iterable 中的前两个值拿出来,扔到 func 当中做运算
把计算结果和 iterable 中的第三个元素再扔进 func 当中做运算
再把结果算出来,和第四个元素做运算,以此类推
直到所有结果运算完毕,返回该结果
参数 :
func : 自定义函数
Iterable : 可迭代型数据(容器类型数据,range对象,迭代器)
返回值 :
计算之后的结果
# 从 ... 导入 ...
from functools import reduce
# 练习1
lst = [5,4,8,8] # => 整型 5488
# 常规写法
# 方法一
strvar = ""
for i in lst:
strvar += str(i)
print(strvar , type(strvar))
res = int(strvar)
print(res , type(res))
# 方法二
"""
5*10 + 4 = 54
54*10 + 8 = 548
548*10 + 8 = 5488
"""
from collections import Iterator,Iterable
lst = [5,4,8,8]
it = iter(lst)
print(isinstance(it,Iterator))
print(isinstance(it,Iterable))
num1 = next(it)
num2 = next(it)
print(num1,num2)
num = num1 * 10 + num2
print(num) # 54
for i in it:
num = num * 10 + i # 54 * 10 + 8 => 548
print(num , type(num))
# reduce 改造
def func(x,y):
return x*10 + y
lst = [5,4,8,8]
res = reduce(func,lst)
print(res , type(res))
"""
代码解析 :
先拿出5和4两个元素,扔到 func 当中做运算,结果是54
再拿54和8两个元素,扔到 func 当中做运算,结果是548
再拿548和8两个元素,扔到 func 当中做运算,结果5488
返回最终结果 : 5488 程序结束
"""
# reduce + lambda 改造
res = reduce(lambda x,y : x*10 + y , lst)
print(res)
# 练习2
""" "789" => 789 禁止使用int强转 """
def func(x,y):
return x*10 + y
strvar = "789"
res = reduce(func,list(strvar))
print(res , type(res))
"""
代码运行结果:
77777777778 * 10 + 9
777777777787777777777877777777778777777777787777777777877777777778777777777787777777777877777777778777777777789
"""
# "789" -> 数字7 数字8 数字9
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))
4. sorted
语法结构 : sorted( Iterable , key=函数 , reverse=False )
功能 : 排序
参数 :
Iterable : 可迭代型数据(容器类型数据,range对象,迭代器)
key : 自定义函数 或 内置函数
reverse : 代表升序或者降序,默认是升序(从小到大排序) reverse=False
返回值 :
排序后的结果
# 1. 默认是从小到大排序
lst = [1,2,3,4,5,-65,-100,-3,-7,22]
res = sorted(lst)
print(res)
# 2. reverse 从大到小排序
res = sorted(lst,reverse=True)
print(res)
# 3. 指定函数进行排序
# 按照绝对值排序 abs
lst = [-65,-8,4,-77,9,-5,6]
res = sorted(lst,key=abs)
print(res)
"""
代码解析:
4 => abs(4) => 4
-5 => abs(-5) => 5
6 => abs(6) => 6
-8 => abs(-8) => 8
9 => abs(9) => 9
-65 => abs(-65) => 65
-77 => abs(-77) => 77
[4,-5,6,-8,9,-65,-77]
"""
# 4. 使用自定义函数进行排序
lst = [23,78,64,52,85]
def func(n):
return n % 10
lst = sorted(lst,key=func)
print(lst)
"""
代码解析:
23 => n % 10 => 3
78 => n % 10 => 8
64 => n % 10 => 4
52 => n % 10 => 2
85 => n % 10 => 5
52 23 64 85 78
"""
""" sorted 和 sort 之间的区别 """
# 字符串
container = "edcba"
# 列表
container = [21,19,56,45,32]
# 元组
container = (21,19,56,45,32)
# 集合
container = {21,19,56,45,32}
# 字典 (排序的是字典的键)
container = {"c":3,"a":1,"b":2}
container = {"王闻":3,"张亮":1,"葛大爷":2}
res = sorted(container)
print(res)
sorted 和 sort 之间的区别
- sorted 可以排序一起容器类型数据 , sort 只能排列表
- sorted 返回的是新列表 , sort 是基于原有的列表进行修改
- 推荐使用sorted
练习
练习1
用map来处理字符串列表,把列表中所有人都变成 leader ,比方alex_leader
name = [‘oldboy’, ‘alex’, ‘wusir’]
# 方法一
name = ['oldboy', 'alex', 'wusir']
def func(n):
return n + "_leader"
it = map(func,name)
print(list(it))
# 方法二
it = map(lambda n : n + "_leader" , name)
print(list(it))
练习2
用map来处理下述 listvar ,要求得到新列表,每个元素名字加后面加_leader
listvar = [{‘name’:‘alex’},{‘name’:‘wusir’}]
listvar = [{'name':'alex'},{'name':'wusir'}]
# 方法一
def func(n):
return n["name"] + "_leader"
it = map(func,listvar)
print(list(it))
# 方法二
it = map(lambda n : n["name"] + "_leader" , listvar)
print(list(it))
练习3
用filter来处理,得到股票价格大于20的股票名字
shares={
‘IBM’:36.6,
‘Lenovo’:23.2,
‘oldboy’:21.2,
‘ocean’:10.2,
}
shares={
'IBM':36.6,
'Lenovo':23.2,
'oldboy':21.2,
'ocean':10.2,
}
# 方法一
def func(n):
return shares[n] > 20
it = filter(func,shares)
print(list(it))
# 方法二
it = filter(lambda n : shares[n] > 20 , shares)
print(list(it))
练习4
有下面字典:
portfolio=[
{‘name’:‘IBM’,‘shares’:100,‘price’:91.1},
{‘name’:‘AAPL’,‘shares’:20,‘price’:54.0},
{‘name’:‘FB’,‘shares’:200,‘price’:21.09},
{‘name’:‘HPQ’,‘shares’:35,‘price’:31.75},
{‘name’:‘YHOO’,‘shares’:45,‘price’:16.35},
{‘name’:‘ACME’,‘shares’:75,‘price’:115.65}
]
- 获取购买每只股票的总价格(乘积),迭代器中[9110.0, 1080.0 ,…]
portfolio=[
{'name':'IBM','shares':100,'price':91.1},
{'name':'AAPL','shares':20,'price':54.0},
{'name':'FB','shares':200,'price':21.09},
{'name':'HPQ','shares':35,'price':31.75},
{'name':'YHOO','shares':45,'price':16.35},
{'name':'ACME','shares':75,'price':115.65}
]
# 方法一
def func(n):
return n['shares'] * n['price']
it = map(func,portfolio)
print(list(it))
# 方法二
it = map(lambda n : n['shares'] * n['price'] , portfolio)
print(list(it))
- 用filter过滤出price大于100的股票
portfolio=[
{'name':'IBM','shares':100,'price':91.1},
{'name':'AAPL','shares':20,'price':54.0},
{'name':'FB','shares':200,'price':21.09},
{'name':'HPQ','shares':35,'price':31.75},
{'name':'YHOO','shares':45,'price':16.35},
{'name':'ACME','shares':75,'price':115.65}
]
# 方法一
def func(n):
return n["price"] > 100
it = filter(func,portfolio)
print(list(it))
# 方法二
it = filter(lambda n : n["price"] > 100 , portfolio)
print(list(it))
练习5
将listvar 按照列表中的每个字典的values大小进行排序,形成一个新的列表。
listvar = [
{‘sales_volumn’: 0},
{‘sales_volumn’: 108},
{‘sales_volumn’: 337},
{‘sales_volumn’: 475},
{‘sales_volumn’: 396},
{‘sales_volumn’: 172},
{‘sales_volumn’: 9},
{‘sales_volumn’: 58},
{‘sales_volumn’: 272},
{‘sales_volumn’: 456},
{‘sales_volumn’: 440},
{‘sales_volumn’: 239}
]
listvar = [
{'sales_volumn': 0},
{'sales_volumn': 108},
{'sales_volumn': 337},
{'sales_volumn': 475},
{'sales_volumn': 396},
{'sales_volumn': 172},
{'sales_volumn': 9},
{'sales_volumn': 58},
{'sales_volumn': 272},
{'sales_volumn': 456},
{'sales_volumn': 440},
{'sales_volumn': 239}
]
def func(n):
return n['sales_volumn']
lst = sorted(listvar,key=func)
print(lst)