匿名函数，迭代器

匿名函数

匿名函数其实就是没有名字的函数

语法格式：

	lambda 形参:返回值
     def index(形参)：
         返回值


# res = lambda x:x**2

# def index(x):
#     return x**2
# index(2)

# print(res)
# ret= res(2)
# print(ret) # 4

# print((lambda a:a+1)(3))
# 
res = lambda x,y:x+y
print(res(1, 2))

常见的内置函数

下面我们来使用一些配合匿名函数一起使用的内置函数

map：map() 会根据提供的函数对指定序列列做映射(lamda)

语法 : map(function, iterable)

# map
ll = [1, 2, 3, 4, 5, 6, 7]


# new_res = []
# for i in res:
#     new_res.append(i ** 2)
#
# print(new_res)

def index(x):
    return x ** 2


# res=map(index, ll) #
res = map(lambda x: x ** 2, ll)  # 
print(list(res))  # [1, 4, 9, 16, 25, 36, 49]

zip():zip() 函数用于将可迭代的对象作为参数, 将对象中对应的元素打包成一个元组, 然后返回由这些元组组成的列表. 如果各个迭代器的元素个数不一致, 则返回列表长度与最短的对象相同

l1 = [1, 2, 3,4,5,6]
l2 = ['a', 'b', 'c', 'd']
l3 = ['kevin', 'jerry', 'tank', 'oscar']
l4 = ['kevin1', 'jerry2', 'tank3', 'oscar4']

# [(1, 'a'), (2, 'b'), (3, 'c')]
# new_list = []
# for i in range(len(l1)):
#     new_list.append((l1[i], l2[i]))
#
# print(new_list) # [(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd'), (5, 'e'), (6, 'f')]

res = zip(l1, l2, l3, l4) # [(1, 'a', 'kevin'), (2, 'b', 'jerry'), (3, 'c', 'tank')]
print(list(res)) # [(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd')]

min()和max()

d = {
    'kevin': 1000,
    'jerry': 30000,
    'Tank': 200000,
    'Oscar': 100
}
'''max和min默认情况下返回的是字典的key，也是按照key值比较的'''


# print(max(d))
# print(min(d))

def index(x):
    return d[x] # 返回什么就安装什么进行比较


res=max(d, key=lambda x:d[x])
res1=min(d, key=lambda x:d[x])
print(res,res1)

##########filter的使用
res = [11, 22, 33, 44, 55, 66]
# new_res = []
# for i in res:
#     if i > 30:
#         new_res.append(i)
# print(new_res)


def index(x):
    return x>30
# res1=filter(index, res) # 内部也是for循环
res1=filter(lambda x:x>30, res) # 内部也是for循环
print(list(res1))

迭代器

1.什么是迭代器

迭代器指的是迭代取值的工具，迭代是一个重复的过程，每次重复都是基于上一次的结果而继续

的，单纯的重复并不是迭代

2.为何要有迭代器

迭代器是用来迭代取值的工具，而设计到把多个值循环取出来的类型有：列表，字符串，元组，字

典，集合，打开文件

l=['egon','alex','liu']
i=0
while i<len(l):
    print(l[i])
    i+=1

上述迭代取值的方式只适用于有索引的数据类型：列表，字符串，为了解决索引的局限性

python必须提供一种不依赖于索引的取值方式，这就是迭代器

可迭代对象

可迭代对象：但凡内置有__iter__方法的都称之为可迭代对象

#可迭代对象：但凡内置有__iter__方法的都称之为可迭代对象
s1=''
s1.__iter__

l=[]
l.__iter__

d={'a':1}
d.__iter__

set1={1,2,3}
set1.__iter__

with open('a.txt',mode='2')as f
f.__iter__

# 调用可迭代对象下的__iter__方法会将其转换成迭代器对象
d={'a':1,'b':2,'c':3}
res=d.__iter__()
print(res)# <dict_keyiterator object at 0x00000263918C91D8>
将key取出
print(res.__next__())# a
print(res.__next__())# b
print(res.__next__())# c
print(res.__next__())# 抛出异常StopIteration # 代表取值取干净了

while True:
    try:
        print(res.__next__())
    except StopIteration
    	break
print('========')# 在一个迭代器取值取干净的情况下，再对其取值取不到  
# res=d.__iter__() #重新调用
while True:
    try:
        print(res.__next__())
    except StopIteration
    	break

3.可迭代对象与迭代器详解

可迭代对象（可转换成迭代器的对象）:内置有__iter__方法对象

迭代器对象：内置有__next__方法并且内置有__iter__方法的对象

        迭代器对象.__next__():得到迭代器的下一个值

        迭代器对象.__iter__():得到迭代器本身，为了让for循环统一起来

for循环的工作原理

d={'a':1,'b':2,'c':3}
res=d.__iter__()    
# 1.d__iter__()得到一个迭代器对象
# 2.迭代器对象.__next__()拿到一个返回值，然后将该返回值赋值给K
# 3.循环往复步骤2，直到抛出StopIteration异常for循环会循环捕捉异常然后结束循环
for k in d:
    print(k)

#相当于
while True:
    try:
        print(res.__next__())
    except StopIteration
    	break