Python 基础之匿名函数迭代器和高阶函数

一.匿名函数 lambda表达式

用一句话来表达只有返回值的函数,叫匿名函数
特点:简洁方便
语法:
lambda 参数: 返回值

1.不带有参数的lambda表达式

def func():
return "今天要下雨,天气挺冷"

#定义一个lambda表达式
func = lambda : "今天要下雨,天气挺冷"
res = func()
print(res)

2.带有参数的lambda表达式

def func(n):
return type(n)

func = lambda n : type(n)
res = func(6)
print(res)

def func(n):
print(n)
res = func(6)
print(res)
res = print(6)
print(res)

func = lambda n : print(n)
res = func(13)
print(res)

3.带有条件分支的lambda表达式

三门运算符:
语法:
真值if条件表达式else 假值
如果条件表达式是真的,返回真值
如果条件表达式是假的,返回假值(else 后面跟的值)
#例1:
res = 15 if 5>3 else 6
print(res)
#结果为: 15
#例2:

def func(n):
    if n % 2 == 0:
        return "偶数"
    else:
        return "奇数"

n = 15
res = "偶数" if n % 2 == 0 else "奇数"
print(res)

func = lambda n : "偶数" if n % 2 == 0 else "奇数"
res = func(15)
print(res)
#例3:
#把两个值当中较大的数返回出来
def func(x,y):
    if x>y:
        return x
    else:
        return y

func = lambda x,y : x if x>y else y
res = func(3,5)
res = func(3,5)
print(res)

二.迭代器

定义:能够被next 调用,并不断返回下一个值得对象,叫迭代器(迭代器时对象)
特征:迭代器会生成惰性序列,它通过计算把值一次的返回,一遍虚幻一遍计算而不是一次性得到所有数据
优点: 需要数据的时候,一次取一个,可以大大节省内存空间,而不是一股脑的把所有数据放进内存
总结:
    1.惰性序列,节省内存空间
    2.遍历获取值的时候使用next,方向不可逆
    3.迭代器可以遍历无线量大的数据

1.可迭代对象

'''__iter__'''
setvar = {"one",22,"dhqoh",798}
for i in setvar:
print(i)

#print(dir(setvar))
print("__iter__" in dir(setvar))
#next(setvar)
#for 循环遍历setvar 这个数据时,先把setvar变成迭代器,并进行取值

2.迭代器

可迭代对象 -> 迭代器 | 不能直接调用 -> 可直接调用
__iter__ __next__ 都包含在当前数据类型当,就是迭代器
如果变成一个迭代器?
(1)next 可以调用 (推荐)
(2)__next__() 也可以调用
#例:
servar = {"one",13,"aa",56}
it1 = iter(setvar)
print(it1)
res = next(it1)
print(res)
res = next(it1)
print(res)
res = next(it1)
print(res)
res = it1.__next__()
print('============================')
print(res)
#如果调用时,超出了正常的数据范围,会报越界错误.StopIteration
#res = next(it1)
#print(res)

#判断是否是迭代器
listvar = dir(it1)
print(listvar)
print("__iter__" in listvar and "__next__" in listvar)

3.判断是否是迭代器或可迭代对象

#from ...import 从哪里模块..引入...
#collections (模块) Iterator 迭代器模型 Iterable 可迭代对象类型
from collections import Iterator,Iterable
setvar = {"one",14,"dd",80}
res = isinstance(setvar,Iterator)
print(res)
res = isinstance(setvar,Iterable)
print(res)

#判断range对象的迭代属性
for i in range(9):
print(i)

#res = next(range(9))
res1 = isinstance(range(9),Iterable)
print(res1)
res2 = isinstance(range(9),Iterator)
print(res2)

如果是一个迭代器,一定具备可迭代性属性
如果是可迭代对象,不一定是迭代器
#把range对象变成迭代器
print("----------------")
#iter __iter__()
it2 = range(9).__iter__()
print(isinstance(it2,Iterator))
print(isinstance(it2,Iterable))

4.配合for循环遍历迭代器

for i in it2:
print(i)

#迭代器在遍历数据时,要注意方向不可逆
#next(it2) #越界
#重置迭代器
print("==============")

it2 = iter(range(9))
for i in range(3):
res = next(it2)
print(res)

print(next(it2))
print(next(it2))

三.高阶函数

定义:能够把函数当成参数传递的就是高阶函数(map reduce sorted filter)

1.map()

map(func,iterable)
功能:把iterable里面的数据一个个的拿出来放到func函数进行处理,最后把处理的结果返回到迭代器中
参数:
    func:自定义函数或内置函数
    iterable:可迭代性数据(常用:容器类型数据,range对象,迭代器)
返回值:迭代器
#例:
#1.["1","2","3","4"] =>[1,2,3,4]
listvar = ["1","2","3","4"]
lst = []
for i in listvar:
    res = int(i)
    lst.append(res)
print(lst)
#下面是判断it是都是可迭代性和是否是迭代器类型数据
from collections import Iterator,Iterable
it = map(int,listvar)
print(isinstance(it,Iterator))
print(isinstance(it,Iterable))
conut = 0
for i in it:
    conut += 1
    if conut == 2:
        break
    print(i)
#
#(2)使用next获取迭代器中的数据
print("=============")
#next 调用迭代器中的数据,是单向不可逆,一条路走到黑
res = next(it)
print(res)
res = next(it)
print(res)
# res = next(it)
# print(res)
# res = next(it)
# print(res)

结果为:

=============

#因为迭代器不可逆,所以留两次给next()调用

#(2)使用next获取迭代器中的数据
it2 = it
#next 调用迭代器中的数据,是单向不可逆,一条路走到黑
res = next(it)
print(res)
res = next(it)
print(res)
res = next(it)
print(res)
res = next(it)
print(res)

#(3)使用list强转迭代器(瞬间得到迭代器中的所有数据)
res = list(it)
print(res)

#例2:.[1,2,3,4,5] => [1,4,9,16,25]
listvar = [1,2,3,4,5]
lst = []
for i in listvar:
res = i**2
lst.append(res)
print(lst)

#map 如果是自定义函数,一定要有返回值
代码解析:
首先把listvar当中的第一个值1拿到func当中进行处理,返回1 扔到迭代器里
然后把listvar当中的第二个值2拿到func当中进行处理,返回4扔到迭代器里
然后把listvar当中的第三个值3拿到func当中进行处理,返回9扔到迭代器里
...
依次类推,直到把列表里面的数据全部拿完为止.

listvar = [1,2,3,4,5]
def func(n):
return n**2
it = map(func,listvar)
print(isinstance(it,Iterator))
listvar = list(it)
print(listvar)

#例3:.{97:"a",98:"b",99:'c',100:'d',101:"e"} {"c","a","b"} => [99,97,98]
dic = {97:"a",98:"b",99:'c',100:'d',101:"e"}
dic2 = {}
for a,b in dic.items():
    dic2[b] = a
print(dic2)
lst = ["c","a","b"]
lst2 = []
#
for i in lst:
    res = dic2[i]
    lst2.append(res)
print(lst2)

def func(n):
    dic = {97:"a",98:"b",99:'c',100:'d',101:"e"}
    dic2 = {}
    for a,b in dic.items():
        dic2[b] = a

return dic2[n]
it = map(func,["c","a","b"])
print(isinstance(it,Iterator))
lst = list(it)
print(lst)

2.reduce()

reduce(func,iterable)
功能:计算
    先把iterable中的前两个数据拿出来,扔到func当中
    进行计算,把计算的结果在和iterrable当中的第三个数据扔到func中
    进行计算,依次类推... ...
    直到iterbale中的数据全部拿出来为止.
参数:
    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*10 + 4 = 54
54*10 + 8 = 548
548*10 + 8 = 5488
'''
lst = [5,4,8,8]
it = iter(lst) #强转成迭代器
num1 = next(it)
num2 = next(it)
total = num1 * 10 + num2
print(total)
for i in it:
total = total*10 +i
print(total,type(total))

#法三:
#使用reduce实现
#from ..import 从哪个模块...导入...
#functools 是一个模块文件(文件)
from functools import reduce
lst = [5,4,8,8]
def func(x,y):
return x*10 + y
res = reduce(func,lst)
print(res)

'''

代码分析:
首先把5,4拿到func函数当中,进行运算得到54
然后把54和lst当中的第三个元素8拿到func当中进行运算得到548
然后把548和list当中的第四个元素8拿到func当中进行运算得到5488
到此,所有数据运算完毕,返回5488
'''

#例2:"987" => [9,8,7]
#法一:

str = "987"
lst = []
for i in str:
lst.append(int(i))
print(lst)

#法二:
#"987" => [9,8,7]
#不使用int强转的方法下
print("=============================")
def func3(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,"987")
#print(list(it))
res = reduce(func3,it)
print(res,type(res))

3.sorted()

参数:
        sorted(iterable,reverse=False,key="函数")
        reverse = False 从小到大排序(升序,正序)
        reverse = Ture 从大到小排序(降序,倒序)
        key = 内置函数或自定义函数
返回值:
    排序后的结果
#(1) 从小到大排序
# listvar = [-99,13,24,0]
# listvar.sort()
# print(listvar)

listvar = [-99,13,24,0]
res = sorted(listvar)
print(res)

#(2)从大到小排序
listvar = [-99,-13,24,0]
res = sorted(listvar,reverse=True)
print(res)

#(3)利用内置函数进行排序
abs 绝对值函数
listvar = [-99,-13,24,0]

res = sorted(listvar,key=abs)
print(res)
'''
0 => 0
-13 => 13
'''
#(4) 利用自定义函数进行排序

listvar = [-99,-13,24,0]
def func(n):
return n % 10

listvar = [23,98,44,16]
res = sorted(listvar,key=func)
print(res)

'''
23 => 3
44 => 4
16 => 6
98 => 8
'''
sort 和 sorted 用法是一样的,只是注意语法的格式不同
sort 是直接更改原有列表
sorted 是产生一个新的副本,新的数据(推荐)

listvar = [23,98,44,16]
listvar.sort(key=func)
print(listvar)

4.filter()

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

#保留奇数,不要偶数
def func(n):
    if n % 2 == 1:
        return True
    else:
        return False
lst = {1,2,3,4,4,5,6,65,7,8}
it = filter(func,lst)
from collections import Iterator,Iterable
print(isinstance(it,Iterator))
#使用list强转迭代器(瞬间拿到所有数据)
res = list(it)
print(res)

#通过lambda表达式来优化代码
it2 = filter(lambda n : True if n % 2 ==1 else False,lst)
print(list(it2))