day11-Python运维开发基础(迭代器与可迭代对象、高阶函数)

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