1. 迭代器与可迭代对象
# ### 迭代器
"""
迭代器: 能被next方法调用,并且不断返回下一个值的对象,是迭代器(对象) 特征:迭代器会生成惰性序列,它通过计算把值依次的返回,一边循环一边计算而不是一次性得到所有数据
优点:需要数据的时候,一次取一个,可以大大节省内存空间.而不是一股脑的把所有数据放进内存.
总结:
1.惰性序列，节省内存空间
2.遍历获取值得时候使用next，方向不可逆
3.迭代器可以遍历无限量大的数据
""" # 可迭代对象
"""
如果该数据成员当中含有__iter__方法,就是可迭代对象
dir 查看该数据的内部成员
"""
setvar = {"a","b","c","d"}
lst = dir(setvar)
print(lst)
res = "__iter__" in lst
print(res) for i in setvar:
print(i) # 迭代器
"""
# (1) 如何定义一个迭代器
1.iter(可迭代对象) (推荐)
2.可迭代对象.__iter__() # (2) 如何判断一个迭代器
1.内部成员中,含有__iter__ 和 __next__ 两个方法
2.from collections import Iterator,Iterable # (3) 如何调用一个迭代器
使用next方法可以调用迭代器,返回里面的内容 可迭代对象 -> 迭代器
不可直接调用 -> 可直接调用
如果是一个可迭代对象,不一定是迭代器
入股是一个迭代器,就一定是可迭代对象
""" # (1)定义一个迭代器
setvar = {"a","b","c","d"}
it = iter(setvar) # (2)判断一个迭代器
lst = dir(it)
print(lst)
# 方法一
res = "__iter__" in lst and "__next__" in lst
print(res)
# 方法二
# from 从... collections import 引入 Iterator 迭代器类型 Iterable可迭代对象类型
from collections import Iterator,Iterable
res = isinstance(it,Iterator)
print(res) # (3)调用迭代器
"""next方法 ,调用迭代器 是单项不可逆的过程,(一条路走到黑)"""
res = next(it)
res = next(it)
res = next(it)
res = next(it)
# res = next(it) error
print(res) # (4)重置迭代器
it = iter(setvar)
print( next(it) ) # (5)把range对象变成迭代器
it = range(10).__iter__()
# 判断迭代器
res1 = isinstance(it,Iterator)
res2 = isinstance(it,Iterable)
print(res1 , res2) # 获取迭代器中数据
# 方法一 next
res = next(it)
print(res)
res = next(it)
print(res)
res = next(it)
print(res)
res = next(it)
print(res) # 方法二 for
print("<===============>")
for i in it:
print(i) print("<===============>")
# 方法三 for + next
# print(next(it)) # StopIteration
it = range(10).__iter__()
for i in range(5):
res = next(it)
print(res)
迭代器与可迭代对象 示例代码
2. 高阶函数（map / reduce / sorted / filter）
# ### 高阶函数 : 能够把函数当成参数传递的就是高阶函数
"""map reduce sorted filter""" # map
"""
map(func,Iterable)
功能:
把Iterable中的值,一个一个拿出来放到func函数中进行处理,把处理的结果扔到迭代器中,最后返回迭代器
参数:
func : 自定义函数 或者 内置函数
Iterable : 可迭代对象(容器类型数据 range对象 迭代器)
返回值:
迭代器
"""
from collections import Iterator,Iterable
# ### (1) ["1","2","3","4"] => [1,2,3,4]
lst = ["","","",""]
lst_new = []
for i in lst:
print(i,type(i))
lst_new.append( int(i) )
print(lst_new) # map改写
it = map(int,lst)
res = isinstance(it,Iterator)
print(res) """
代码解析:
首先从列表里拿出第一个数据 "1" 扔到int方法中进行强转,把强转的结果扔给迭代器
然后从列表里拿出第二个数据 "2" 扔到int方法中进行强转,把强转的结果扔给迭代器
然后从列表里拿出第三个数据 "3" 扔到int方法中进行强转,把强转的结果扔给迭代器
然后从列表里拿出第四个数据 "4" 扔到int方法中进行强转,把强转的结果扔给迭代器 最后返回迭代器
""" # (1)next获取迭代器中的数据
res= next(it)
print(res)
res= next(it)
print(res)
res= next(it)
print(res)
res= next(it)
print(res)
# res= next(it) error # StopIteration
# print(res) print("<===========>")
# (2)for 循环遍历
it = map(int,lst)
for i in it :
print(i) # (3)list 强制转换
it = map(int,lst)
lst = list(it)
print(lst) # ### (2) [1,2,3,4] => [1,4,9,16]
lst = [1,2,3,4]
lst_new = []
for i in lst:
res = i ** 2
lst_new.append(res)
print(lst_new) # map改写
def func(n):
return n ** 2 # 方法一
"""
it = map(func,lst)
# list强转迭代器 变成列表
lst = list(it)
print(lst)
"""
# 方法二
it = map(lambda n : n ** 2 , lst)
lst = list(it)
print(lst) # ### {97:"a",98:"b",99:"c"} => 给你["a","b","c"] => [97,98,99]
# 原型
# dic = {"a":97,"b":98,"c":99}
# res = dic["a"]
# print(res) # 反转字典
dic = {97:"a",98:"b",99:"c"}
dic_new = {}
# 把字典的键和值对换
for k,v in dic.items():
print(k,v)
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进行改写
lst = ["a","b","c"]
def func(n):
dic = {97:"a",98:"b",99:"c"}
dic_new = {}
for k,v in dic.items():
dic_new[v] = k
# {'a': 97, 'b': 98, 'c': 99}
return dic_new[n] it = map(func,lst)
lst = list(it)
print(lst)
map高阶函数 示例代码
# ### reduce
"""
reduce(func,Iterable)
功能:
从iterable中一次性拿出2个数据,扔到func函数进行运算,
然后将运算的结果和Iterable中的第三个数据在放到func中进行运算
以此类推...
最后返回计算的结果
参数:
func : 自定义函数 或者 内置函数
iterable : 可迭代对象(容器类型数据 range对象 迭代器)
返回值:
最后计算的结果
"""
# (1) [5,4,8,8] => 5488
lst = [5,4,8,8]
# 方法一 .字符串的拼接
strvar = ""
for i in lst:
strvar += str(i)
print(strvar,type(strvar))
res = int(strvar)
print(res,type(res)) # 方法二 用算数来做
"""
5 4 8 8
5*10 + 4 = 54
54 * 10 + 8 = 548
548 * 10 + 8 = 5488
"""
lst = [5,4,8,8]
# (1) 变成迭代器
it = iter(lst) # (2) 获取前两个元素
num1 = next(it)
num2 = next(it)
total = num1 * 10 + num2
print(total) # (3) 计算剩余的数据
for i in it:
total = total * 10 + i
print(total,type(total)) # reduce 改写
lst = [5,4,8,8]
from functools import reduce
def func(x,y):
return x*10+y
print(func(5,4)) res = reduce(func,lst)
print(res,type(res))
"""
拿出5 和 4 两个元素 扔到自定义的func函数中
x 接受 5 y 接受 4
return 5*10 + 4 => return 54 然后拿出54 和 8 两个元素 扔到自定义的func函数中
x 接受54 y 接受 8
return 54 * 10 + 8 => return 548 然后拿出548 和 8 两个元素 扔到自定义的func函数中
x 接受548 y 接受 8
return 548 * 10 + 8 => return 5488 返回5488 结束
""" # "678" => 整型 678 (不让使用int)
def func(x,y):
return x*10+y def func2(n):
dic = {"":0,"":1,"":2,"":3,"":4,"":5,"":6,"":7,"":8,"":9}
return dic[n]
strvar = ""
it = map(func2,strvar) res = reduce(func,it)
print(res,type(res))
reduce高阶函数 示例代码
# ### sorted
"""
sorted(iterable,key=函数,reverse=False)
功能:排序
参数:
iterable(容器类型数据,range对象,迭代器)
key = 函数 自定义 或者 内置函数
reverse = False 从小到大排序 reverse = True 从大到小排序
返回值:
排序后的结果
""" # (1) 默认从小到大排序
tup = (1,15,-18,12,0)
lst = sorted(tup)
print(lst) # (2) 从大到小排序
tup = (1,15,-18,12,0)
lst = sorted(tup,reverse=True)
print(lst) # (3) 使用绝对值进行排序
# res = abs(10)
# print(res)
tup = (1,15,-18,12,0)
lst = sorted(tup,key=abs)
print(lst)
"""
0 => abs(0) => 0
1 => abs(1) => 1
12 => abs(12) => 12
15 => abs(15) => 15
-18 => abs(-18) => 18
""" # (4) 使用自定义函数进行排序 -> 按照余数大小排序
tup = (19,23,32,35,67)
def func(n):
return n % 10
lst = sorted(tup,key=func)
print(lst)
"""
32 func => 2
23 func => 3
35 func => 5
67 func => 7
19 func => 9
""" # 字符串排序
strvar = "zfacd"
lst = sorted(strvar)
print(lst) # 集合排序
setvar = {"z","f","a","c","d"}
lst = sorted(setvar)
print(lst) """
总结:
sort 只能针对列表进行排序,直接修改原有列表
sorted 容器类型数据都可以排序,产生一个新的副本,数据类型是列表
"""
sorted高阶函数 示例代码
# ### filter
"""
filter(func,iterable)
功能: 过滤
在自定义函数中:
如果返回True , 代表保留该数据
如果返回False , 代表舍弃该数据
参数:
func 自定义函数
iterable 可迭代对象(容器类型数据 range对象 迭代器)
返回值:
迭代器
"""
from collections import Iterator lst = [1,2,3,4,5,6,7,8]
lst_new = []
for i in lst:
if i % 2 == 0:
lst_new.append(i) print(lst_new) # 用filter改写
def func(n):
if n % 2 == 0:
return True
else:
return False
it = filter(func,lst)
res = isinstance(it,Iterator)
print(res) # next 获取迭代器中的数据
res = next(it)
print(res)
res = next(it)
print(res)
res = next(it)
print(res)
res = next(it)
print(res) # for 获取迭代器中的数据
it = filter(func,lst)
for i in it:
print(i) # for + next 获取迭代器中的数据
it = filter(func,lst)
for i in range(3):
res = next(it)
print(res) # list 强转迭代器变成列表
it = filter(func,lst)
lst = list(it)
print(lst) # 匿名函数优化
it = filter(lambda n : True if n % 2 == 0 else False , lst)
for i in it:
print(i)
filter高阶函数 示例代码
day11