开发者

Python全栈之迭代器和高阶函数

开发者 https://www.devze.com 2022-12-06 09:33 出处:网络 作者: 熬夜泡枸杞
目录1. lambda表达式2. locals和globals3. 迭代器小提示:4. map高阶函数5. reduce高阶函数6. filter高阶函数7. sorted高阶函数8. 小练习总结1. lambda表达式
目录
  • 1. lambda表达式
  • 2. locals和globals
  • 3. 迭代器
    • 小提示:
  • 4. map高阶函数
    • 5. reduce高阶函数
      • 6. filter高阶函数
        • 7. sorted高阶函数
          • 8. 小练习
            • 总结

              1. lambda表达式

              # ### 匿名函数 : lambda表达式
              """
              概念: 用一句话来表达只有返回值的函数
              语法: lambda 参数 : 返回值
              特点: 简洁,高效
              """
              # (1) 无参的lambda表达式 
              def func():
              	return "文哥是个帅哥"
              # 改造
              func = lambda : "文哥是个帅哥"
              print(  func()  )
              
              # (2) 有参的lambda表达式
              def func(n):
              	return id(n)
              # 改造
              func = lambda n : id(n)
              print( func(100) )
              # (3) 带有判断条件的lambda表达式 
              def func(n):
              	if n % 2 == 0:
              		return "偶数"
              	else:
              		return "奇数"
              # 改造
              func = lambda n : "偶数" if n % 2 == 0 else "奇数"
              print( func(44) )
              # 三元运算符
              """语法: 真值 if 条件表达式 else 假值
              如果条件表达式成立为True , 返回if前面的真值,反之,返回else后面的假值
              """
              n = 13
              res = "偶数" if n % 2 == 0 else "奇数"
              print(res)
              
              # 小练习 : 比较两者之间的最大值进行返回
              def func(x,y):
              	if x > y:
              		return x
              	else:
              		return y
              # 改造
              func = lambda x,y : x if x>y else y
              print(  func(40,30)  )
              

              2. locals和globals

              # ### locals 与 globals 使用 (了解)
              # 一.locals 获取当前作用域所有的变量
              # 1.全局空间
              """
              locals 在函数外 , 获取的是打印之前所有的全局变量
              locals 在函数内 , 获取的是调用之前所有的局部变量
              """
              """
              def func():
              	a1 = 1
              	b2 = 2
              a = 1
              b = 2
              res = locals()
              c = 3
              print(res)
              d = 4
              """
              # 2.局部空间
              """
              a = 1
              b = 2
              def func():
              	a1 = 1
              	b2 = 2
              	res = locals()
              	c3 = 3
              	print(res)
              	d4 = 4
              c = 3
              func()
              d = 4
              """
              # 二.globals 只获取全局空间的全局变量
              """
              globals 在函数外 , 获取的是打印之前所有的全局变量
              globals 在函数内 , 获取的是调用之前所有的全局变量
              """
              # 1. 全局空间
              """
              def func():
              	a1 = 1
              	b2 = 2
              a = 1
              b = 2
              res = globals()
              c = 3
              print(res)
              d = 4
              """
              # 2.局部空间
              """
              a = 1
              b = 2
              def func():
              	a1 = 1
              	b2 = 2
              	res = globals()
              	c3 = 3
              	print(res)
              	d4 = 4
              c = 3 
              func() globals()
              d = 4
              """
              # ### globals  返回的是内置系统的全http://www.cppcns.com局字典
              """
              dic = globals()
              print(dic)
              # 通过字符串可以创建全局变量
              dic["wangwen"] = "18岁pJHTTE"
              print(wangwen)
              """
              # 批量创建全局变量
              def func():
              	dic = globals()
              	for i in range(1,5):
              		# 批量在dic当中添加键值对,以创建全局变量
              		dic[ "a%d" % (i) ] = i 
              		"""
              		dic["a1"] = 1
              		dic["a2"] = 2
              		dic["a3"] = 3
              		dic["a4"] = 4
              		"""
              func()
              print(a1,a2,a3,a4)
              

              3. 迭代器

              # ### 迭代器
              """
              迭代器:
              	能被next()函数调用并不断返回下一个值的对象称为迭代器(Iterator  迭代器是对象)
              概念:
              	迭代器指的是迭代取值的工具,迭代是一个重复的过程,每次重复都是基于上一次的结果而继续的,
              	单纯的重复并不是迭代  
              特征:
              	并不依赖索引,而通过next指针(内存地址寻址)迭代所有数据,一次只取一个值,
              	而不是一股脑的把所有数据放进内存.大大节省空间,
              """
              # 一.可迭代对象
              setvar = {"王同培","马春配","赵万里","赵沈阳"}
              # 获取当前对象的内置成员
              lst = dir(setvar)
              print(lst)
              # 判断是否是可迭代对象
              res = "__iter__" in lst
              print(res)
              # for i in setvar:
              	# print(i)
              # 二.迭代器
              """
              for循环之所以可以遍历所有的数据,是因为底层使用了迭代器,通过地址寻址的方式,一个一个的找数据;
              可迭代对象 -> 迭代器  实际上就是从不能够被next直接调用 -> 可以被next指针直接调用的过程
              如果是可迭代对象 -> 不一定是迭代器
              如果是迭代器     -> 一定是可迭代对象
              """
              # 1.如何创建一个迭代器
              setvar = {"王同培","马春配","赵万里","赵沈阳"}
              it = iter(setvar)
              print(it)
              # 2.如何判断一个迭代器
              print(dir(it))
              res = "__iter__" in dir(it)  and "__next__" in dir(it)
              print(res)
              # 3.如何调用一个迭代器
              """next是单向不可逆的过程,一条路走到黑"""
              res = next(it)
              print(res)
              res = next(it)
              print(res)
              res = next(it)
              print(res)
              res = next(it)
              print(res)
              # res = next(it)
              # print(res)
              # 4.重置迭代器
              it = iter(setvar)
              print(  it.__next__()  )
              print(  it.__next__()  )
              print(  it.__next__()  )
              prin编程客栈t(  it.__next__()  )
              # 5.调用迭代器的其他方法
              # 1 for
              it = iter(setvar)
              for i  in  it:
              	print(i)
              print("<======>")
              # 2 for + next
              it = iter(setvar)
              for i in range(2):
              	print( next(it) )
              print( next(it) )
              print( next(it) )
              # print( next(it) ) error  超出了寻址范围
              # 6.判断迭代器/可迭代对象的其他方法
              # 从...模块 引入...内容
              from collections import Iterator, Iterable
              """Iterator 迭代器 Iterable 可迭代的对象"""
              res = isinstance(it,Iterator)
              print(res)
              res = isinstance(it,Iterable)
              print(res)
              # 7.range是迭代器么?
              print(isinstance(range(10),Iterator)) # False
              print(isinstance(range(10),Iterable)) # True
              # 变成迭代器
              it = range(10).__iter__()
              print(isinstance(it,Iterator)) # True
              print(isinstance(it,Iterable)) # True
              # 调用it
              # next
              res = next(it)
              print(res)
              res = next(it)
              print(res)
              print("<=====>")
              # for + next 
              for i in range(3):
              	print(next(it))
              print("<=====>")
              # for
              for i in it:
              	print(i)
              

              小提示:

              可迭代对象到迭代器就是一个不能被next直接调用到能被next直接调用的过程
              for循环底层能表里无序的数据就是通过迭代器来实现的 
              

              4. map高阶函数

              # ### 高阶函数 : 能够把函数当成参数传递的就是高阶函数 (map ,filter ,reduce , sorted)
              # map
              """
              map(func,iterable)
              功能: 处理数据
              	把iterable中的数据一个一个拿出来,扔到func做处理,通过调用迭代器来获取返回值
              参数:
              	func : 函数(内置函数,自定义函数)
              	iterable : 可迭代性对象 (容器类型数据,range对象,迭代器)
              返回值:
              	迭代器
              """
              # (1) 把列表中的元素都变成整型
              lst = ["1","2","3","4"]
              lst_new = []
              for i in lst:
              	lst_new.append(int(i))
              print(lst_new)
              # 用map改写
              from collections import Iterator,Iterable
              it = map(int,lst)
              print(isinstance(it,Iterator))
              """
              代码解析:
              	第一次调用迭代器
              		先把列表中的第一个元素"1"拿出来扔到int中做强转,变成整型1返回出来
              	第二次调用迭代器
              		先把列表中的第一个元素"2"拿出来扔到int中做强转,变成整型2返回出来
              	第三次调用迭代器
              		先把列表中的第一个元素"3"拿出来扔到int中做强转,变成整型3返回出来
              	第四次调用迭代器
              		先把列表中的第一个元素"4"拿出来扔到int中做强转,变成整型4返回出来
              """
              # 1.调用迭代器 next
              print(next(it))
              print(next(it))
              print(next(it))
              print(next(it))
              # print(next(it)) error
              # 2.调用迭代器 for
              print("<======>")
              it = map(int,lst)
              for i in it:
              	print(i)
              # 3.调用迭代器 for + next
              print("<======>")
              it = map(int,lst)
              for i in range(3):
              	print(next(it))
              # 4.强转迭代器 => 列表
              it = map(int,lst)
              print(list(it))
              # (2) [1,2,3,4] => [2,8,24,64]
              # print(1 * 2 ** 1)
              # print(2 * 2 ** 2)
              # print(3 * 2 ** 3)
              # print(4 * 2 ** 4)
              # 1 << 1
              # 2 << 2
              # 3 << 3
              # 4 << 4
              lst = [1,2,3,4]
              lst_new = []
              for i in lst:
              	lst_new.append(i << i)
              print(lst_new)
              # map改写
              def func(n):
              	print(1111)
              	return n << n
              it = map(func,lst)
              print(list(it))
              """
              只有在调用迭代器的时候,才会真正触发map函数中的所有内容;不调用不触发;
              强转迭代器时,把可以调用的所有数据都放到列表中
              第一次调用时:
              	把1拿出来,扔func当中做处理,返回2,
              第二次调用时:
              	把2拿出来,扔func当中做处理,返回8,
              第三次调用时:
              	把3拿出来,扔func当中做处理,返回24,
              第四次调用时:
              	把4拿出来,扔func当中做处理,返回64,
              到此列表[2,8,24,64]
              注意点:形参和返回值必须写;
              """
              	
              # (3) 给你一个列表["a","b","c"] => [97,98,99]
              # 字典的键值翻转操作
              dic = {97:"a",98:"b",99:"c"}
              dic_new = {}
              for k,v in dic.items():
              	# print(k,v) # 97 a | 98 b | 99 c
              	dic_new[v] = k # dic_new["a"] = 97
              print(dic_new)
              lst = ["a","b","c"]
              lst_new = []
              for i in lst:
              	lst_new.append(dic_new[i])
              print(lst_new)
              # map改写
              print("<========================>")
              lst = ["a","b","c"]
              lst = ["c","b","a"]
              lst = ("c","b","a")
              # func 实现字典的翻转,通过给与a,b,c三个键,得到对应的ascii码,通过list强转得到列表
              def func(n):
              	print(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]
              		
              it = map(func,lst)
              print(list(it))
              

              5. reduce高阶函数

              # ### reduce 
              """
              reduce(func,iterable)
              功能: 计算数据
              	把iterable中的前两个数据扔到func函数中做计算,把计算的结果和iterable中第三个值在继续扔到func中做计算
              	以此类推 ... 
              	最后返回计算的结果 
              参数: 
              	func: 自定义函数
              	iterable : 可迭代对象 (容器类型数据 range对象 迭代器)
              返回值:
              	计算的结果
              """
              # (1) [7,7,5,8] => 7758
              lst = [7,7,5,8]
              # 方法一
              strvar = ""
              for i in lst:
              	strvar += str(i)
              res = int(strvar)
              print(res , type(res))
              # 方法二
              """
              7 * 10 + 7 = 77
              77 * 10 + 5 = 775
              775 * 10 + 8 = 7758
              """
              # 1.先变成迭代器
              it = iter(lst)
              # 2.取出两个值
              num1 = next(it)
              num2 = next(it)
              print(num1,num2)
              # 做计算
              total = num1 * 10 + num2
              print(total) # 77
              # 3.把计算的结果在和剩下的数据做计算
              for num in it:
              	total = total * 10 + num
              # 4.返回最后的结果
              print(total , type(total))
              
              print("<==========>")
              # reduce改写
              '''从...functools模块, 引入 .. reduce方法'''
              from functools import reduce
              lst = [7,7,5,8]
              def func(x,y):
              	# print(x,y)
              	return x * 10 + y
              res = reduce(func,lst)
              print(res)
              # 使用lambda 进行改造
              print(reduce(lambda x,y: x*10 + y,lst))
              
              # (2) "123" => 123 不使用int的情况下实现该操作;
              strvar = "123"
              def func(x,y):
              	return x * 10 + y
              # 把字符串"123" 处理成数字的123
              def func2(n):
              	# dic = {"0":0,"1":1,"2":2,"3":3,"4":4,"5":5,"6":6,"7":7,"8":8,"9":9}
              	dic = {}
              	for i in range(10):
              		dic[str(i)] = i	
              	return dic[n]
              it = map(func2,strvar)
              # res = reduce(func,it)
              # print(res,type(res))
              # 简写
              print(reduce(lambda x,y: x*10 + y,it))
              

              6. filter高阶函数

              # ### filter
              """
              filter(func,iterable)
              功能: 过滤数据
              	在自定义的函数中,
              		如果返回True, 该数据保留
              		如果返回False,该数据舍弃				
              参数:
              	func: 自定义函数
              	iterable : 可迭代对象 (容器类型数据 range对象 迭代器)
              返回值:
              	迭代器
              """
              # 1.只要列表中所有的偶数
              lst = [1,2,34,5,65,6,56,7,56,756,7567,11]
              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)
              print(list(it))
              # 使用lambda 改写
              it = filter(lambda n :True if n % 2 == 0 else False , lst)
              print(list(it))
              print(list(filter(lambda n :True if n % 2 == 0 else False , lst)))
              

              7. sorted高阶函数

              # ### sorted
              """
              sorted(iterable,key=函数,reverse=False)
              功能:排序数据
              参数:
              	iterable : 可迭代对象 (容器类型数据 range对象 迭代器)
              	key      : 指定函数(自定义/内置)
              	reverse  : 是否倒序
              返回值:
              	列表
              """
              tup = (-90,89,78,3)
              # 1.从小到大
              res = sorted(tup)
              print(res,type(res))
              # 2.从大到小
              res = sorted(tup,reverse = True)
              print(res,type(res))
              # 3.按照绝对值进行排序
              tup = (-90,-100,1,2)
              res = sorted(tup,key=abs)
              print(res)
              """
              1 => abs(1) => 1
              2 => abs(2) => 2
              -90 => abs(-90) => 90
              -100 => abs(-100) => 100
              """
              # 4.按照自定义函数进行排序
              tup = (19,23,42,87)
              """
              42 % 10 2 => 42
              23 % 10 3 => 23
              87 % 10 7 => 87
              19 % 10 9 => 19
              """
              def func(n):
              	print(n)
              	return n % 10
              lst = sorted(tup,key = func)
              print(lst)
              # 5.任意的容器类型数据都可以通过sorted排序
              container = "abc"
              container = [1,2,3]
              container = (1,2,3)
              container = {"你好","王文","你真帅"}
              container = {"caixukun","xiaozhan","zhaoshenyang","wangyibo"}
              container = {"ww":"英俊帅气","zxy":"猥琐抠脚","zwl":"斯文败类"} # 排编程客栈的是字典的键
              print(sorted(container))
              """
              # 总结:
              sorted (推荐使用sorted)
              	(1) 可以排序所有的容器类型数据
              	(2) 返回一个新的列表
              sort
              	(1) 只能排序列表
              	(2) 基于原来的列表进行排序
              """
              

              8. 小练习

              # 1.用map来处理字符串列表,把列表中所有人都变成 leader ,比方alex_leader
              name = ['oldboy', 'alex', 'wusir']
              """
              it = map(lambda n : n+"_leader",name)
              print(list(it))
              """
              # 2.用map来处理下述 listvar ,要求得到新列表,每个元素名字加后面加_leader
              listvar = [{'name':'alex'},{'name':'wusir'}]
              def func(n):
              	# print(n)
              	# n["name"] + "_leader"
              	# 方法一
              	# return n["name"] + "_leader"
              	# 方法二
              	n["name"] += "_leader"
              	return n
              it = map(func,listvar)
              print(list(it))
              # 3.用filter来处理,得到股票价格大于20的股票名字
              shares={
                 	'IBM':36.6,
                 	'Lenovo':23.2,
                	'oldboy':21.2,
                      'ocean':10.2,
              	}
              # 方法一
              def func(n):
              	if shares[n] > 20:
              		return True
              	else:
              		return False
              # 方法二
              def func(n):
              编程客栈	if shares[n] > 20:
              		return True
              # 方法三
              def func(n):
              	return shares[n] > 20
              it = filter(func,shares)
              print(list(it))
              # 方法四
              print(list(filter(lambda n : shares[n] > 20,shares)))
              
              # 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}
              ]
              # a.获取购买每只股票的总价格(乘积),迭代器中[9110.0, 1080.0 ,......]
              def func(n):
              	return n["shares"] * n["price"]
              it = map(func,portfolio)
              print(list(it))
              # lambda
              print(list(map(lambda n : n["shares"] * n["price"] ,portfolio)))
              # b.用filter过滤出price大于100的股票。
              def func(n):
              	if n["price"] > 100:
              		return True
              it = filter(func,portfolio)
              print(list(it))
              # 方法二
              print(list(filter(lambda n : n["price"] > 100 , portfolio )))
              # 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}
              ]
              def func(n):
              	return n["sales_volumn"]
              lst = sorted(listvar,key=func)
              print(lst)
              # 方法二
              print(sorted(listvar,key=lambda n : n["sales_volumn"]))
              
              

              总结

              本篇文章就到这里了,希望能够给你带来帮助,也希望您能够多多关注我们的更多内容!

              0

              精彩评论

              暂无评论...
              验证码 换一张
              取 消

              关注公众号