【十一】Python全栈之路--迭代器

• • 1. lambda表达式
  • 2. locals和globals
  • 3. 迭代器
  • 4. map高阶函数
  • 5. reduce高阶函数
  • 6. filter高阶函数
  • 7. sorted高阶函数

# ### 匿名函数 : 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)  )

# ### 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  返回的是内置系统的全局字典
"""
dic = globals()
print(dic)
# 通过字符串可以创建全局变量
dic["wangwen"] = "18岁"
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)

# ### 迭代器
"""
迭代器:
	能被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__()  )
print(  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循环底层能表里无序的数据就是通过迭代器来实现的 

# ### 高阶函数 : 能够把函数当成参数传递的就是高阶函数 (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))