1.迭代器
迭代器能被next调用，并不断返回下一个值的对象，叫作迭代器(迭代器是对象)
概念：迭代器指的是迭代取值的工具，迭代是一个重复的过程每次重复都是基于上一次的结果而继续单纯的重复不是迭代。
特征：不依赖索引，通过next指针迭代所有数据，依次只取一个，可以大大节省空间。迭代无限量的数据
(1)可迭代对象
如果成员中函数有__iter__这个方法，就是可迭代对象，
dir函数可以查看一个对象中的所有的成员。
(2) 迭代器
1.for循环遍历数据的底层实现就是利用了迭代，通过next方法进行调用，从而获得数据
可迭代对象和迭代器之间的关键，从不可被直接获取，--->可被直接获取的过程
2.如果是一个可迭代对象，不一定是一个迭代器 __iter__
如果是一个迭代器，一定是一个可迭代对象 __iter__ __next__
(3)如何定义一个迭代器
iter(可迭代对象)
可迭代对象.__iter__()
(4)如何判断一个迭代器
如果内置成员中，含有__iter__和__next__两个方法，就可以判断是一个迭代器
(5)如果调用一个迭代器
next(迭代器)
迭代器.__next__()
迭代器通过next方法调用时，是单项不可逆的过程
(6)重置迭代器
next调用，单项不可逆，一路走到黑
(7)使用Iterator 和 Iterable来判断是否是迭代器(首字母是大写的i)
先导入模块
from collections import Iterator , Iterable
iterator 迭代器 含有__iter__ 和__next__
iterbale 可迭代对象 含有__iter__
(8)判断迭代数据
setvar = {'a','b','c'}
res = isinstance(setvar,Iterator) #判断是否是迭代器
print(res) #False 必须含有__iter__和__next__两种方法的才是迭代器
res = isinstance(setvar,Iterable) #判断是否是可迭代对象
print(res) #True 含有__iter__用法
(9)更多调用方式
通过next获取迭代器中的数据
通过for循环遍历迭代器
通过for和next配合使用迭代器
2.map函数
map是高阶函数，能够把函数当成参数传递就是高阶函数
map(func,iterable)
功能：把iterbale里面的数据一个一个拿出来，放到func函数中进行处理，处理一个扔一个到迭代器中
把处理的结果扔到迭代器中，返回迭代器
参数：
func 自定义函数 或者内置函数
iterable 可迭代对象(容器类型数据 range对象 迭代器)
返回值：
迭代器
可以通过next取值，for循环取值，for+next取值，list强转取值(返回一个列表)
例子：
lst = ["1","2","3","4"]
it =map(int,lst)
print(list(it))
解析：
首先拿出列表当中的"1",扔到int函数当中处理,处理的结果扔到迭代器当中
首先拿出列表当中的"2",扔到int函数当中处理,处理的结果扔到迭代器当中
首先拿出列表当中的"3",扔到int函数当中处理,处理的结果扔到迭代器当中
首先拿出列表当中的"4",扔到int函数当中处理,处理的结果扔到迭代器当中
最后把迭代器返回
例子：
2. [1,2,3,4] => [1,4,9,16]
#map 方法一
def func(n):
return n**2
it = map(func,lst)
#map 方法二
it =map(lambda n : n**2,lst)
例子：
dic = {97:"a",98:"b",99:"c"} 给你["a","b","c"] => 返回 [97,98,99]
#1.将字典的键值对进行翻转
dic_new = {}
for k,v in dic.items():
print(k,v)
dic_new[v] = k
print(dic_new)
#2.去获取键对应的值
lst_new = []
for i in lst:
res = dic_new[i]
lst_new.append(res)
print(lst_new) # [97, 98, 99]
#map 改写
lst = ["a","b","c"]
dic = {97:"a",98:"b",99:"c"}
#方法一
def func(n):
dic_new = {}
for k,v in dic.items():
dic_new[v] = k
return dic_new[n]
it = map(func,lst) #把列表中的元素一个一个取出来
print(list(it))
#方法二
def func(n):
for k,v in dic.items():
if n == v:
return k
it = map(func,lst)
print(list(it))
#map传入的参数
#为字典时，传入的是键
#为列表时，传入的是一个个元素
#为元组时，传入的是一个个元素
#为集合时，传入的是一个个元素
#列表嵌套字典,传入的是列表中的每个字典元素
map处理数据是，是处理一个扔一个到迭代器中，最终全部处理完后，返回迭代器。
3.filter函数
filter(func,iterable) #可迭代对象
功能：
在自定义的函数中，过滤数据
如果返回True，代表保留数据
如果返回False，代表舍弃该数据
参数：
func 自定义函数
iterable 可迭代对象(容器类型数据 range对象 迭代器)
返回值：
迭代器
例子：
#1.[1,2,3,4,5,6,7,8] => 要所有的奇数
#filter 改写
def func(n):
if n%2 ==0:
return False
else:
True
it = filter(func,lst) #把lst列表中的每个元素传入到func的参数中去
res =isinstance(it,iterator) #判断it是不是迭代器
print(res)
#改写成lambda表达式
lst = [1,2,3,4,5,6,7,8]
it = filter(lambda n : True if n%2==1 else False,lst)
print(list(it))
4.reduce函数
reduce(func,iterable)
功能：一次性从iterable当中拿出两个值，扔到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,typr(strvar))
intvar = int(strvar)
#方式二
it = iter(lst)
num1 = next(it)#5
num2 = next(it) #4
print(num1)
print(num2)
#total = 5*10+4
total = num1 * 10 + num2 #54
print(total)
for i in it:#[8,8] 上面已经取了两个值了，所以只剩下两个了
#54 * 10 + 8 -> 548 * 10 + 8 ->5488
total = total * 10 +i
print(total,type(total))
'''
5 * 10 + 4 => 54
54 * 10 + 8 => 548
548 * 10 + 8 => 5488
'''
reduce改写 用reduce的时候需要引入相应的模块
from functools import reduce
lst = [5,4,8,8]
def func(x,y):
return x*10+y
res = reduce(func,lst) #得到的是最后的结果
print(res,type(res))#5488 <class 'int'>
'''
先从lst拿出前两个数据，5和4，扔到func当中进行运算5*10+4=54
拿出54 和 容器中第三个元素8，扔到func当中进行运算 54*10 +8 = 548
拿出548 和 容器中第四个元素8，扔到func当中进行运算 548*10 +8 = 5488
最后把5488，直接返回，程序结束
'''
#优化成lambda表达式
print(reduce(lambda x,y : x*10+y,lst))
例子:
#(2) '789'转换为 =》 789 (禁止使用int)
def func(x,y):
return x*10 +y
def func_int(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(func_int,'789') # <map object at 0x00000000022254A8>
#print(list(it)) [7,8,9]
res = reduce(func,it)
print(res,type(res))
5.sorted函数
sorted(iterable，reverse=False,key=函数) #三个可填参数
功能 ： 排序 默认从小到大
参数：
iterable 可迭代对象(容器类型数据 range对象 迭代器)
reverse 代表是否倒序 默认等于False
key 自定义函数 或 内置函数
返回值：
排序后的列表
例子：
#(1) 默认从小到大排序，返回新的列表
#排序列表
container = [100,200,13,-6,0]
#排序元组
container = (100,200,13,-6,0)
#排序集合
container = {100,200,13,-6,0}
#字符串(按照ascill编码排序)
container = 'oneal'
#字典(默认排序的是键)
container = {'a':1,'b':2,'c':3}
lst_new = sorted(container)
print(lst_new)
#(2) 从大到小排序
lst_new = sorted(container,reverse=True)
print(lst_new)
#(3) 通过内置函数排序
#按照绝对值排序 abs
print(abs(-200))
lst = [-200,-300,9,20]
res = sorted(lst,key=abs)
print(res)
#按照abs绝对值大小进行排序
'''
9 => abs(9) => 9
20 => abs(20) => 20
-200 => abs(-200) => 200
-300 => abs(-300) => 300
'''
#(4) 通过自定义函数进行排序
lst = [19,27,35,48]
def func(n):
return n%10
res = sorted(lst,key=func)
res = sorted(lst,key = lambda n : n%10)
print(res)
'''
35 % 10 => 5
27 % 10 => 7
48 % 10 => 8
19 % 10 => 9
'''
sort 和 sorted区别
sort 基于所有的列表进行排序，只限定列表类型 返回值为None
sorted 所有的容器类型数据都能排序，返回一个全新的列表
总结：
今天主要学了迭代器，4个高阶函数map，filter，reduce，sorted
迭代器是能被next调用，并不断返回下一个值的对象叫作迭代器
特点是不依赖索引，通过next指针迭代所有数据，一次只取一个，迭代无限量的数据，大大节省空间。
可迭代对象，成员中函数有__iter__这个方法，就是可迭代对象。可以用dir函数来查看一个对象的所有成员
如果是一个可迭代对象，但不一定是一个迭代器，如果是一个迭代器，一定是一个可迭代对象
如何定义一个迭代器？ iter(可迭代对象) 或 可迭代对象.__iter__()
如何判断一个迭代器？内置成员含有__iter__和__next__两个方法就可以判断是一个可迭代器
如何调用一个迭代器？next(迭代器) 或 迭代器.__next__()
同时也讲了迭代器通过next方法调用时，是单项不可逆的。一直会继续跟着上面next输出后的值，继续往下走，直至没有值
同时也可以使用Iterator 和 Iterable 来判断是否是迭代器 需要引入相应的模块
from collections import Iterator ， Iterable
iterator 迭代器类型 含有__iter__ 和__next__
iterable可迭代对象 含有__iter__
迭代器取值 可以通过next，for循环，for和next配合使用，以及list强制在转换
map：
map(func,iterable),就是把iterable里面的数据一个一个拿出来，放到func函数(自定义或内置函数)中进行处理，处理一个就把处理结果扔到迭代器，直到全部处理完，返回迭代器
filter：
filter(func,iterable),就是在自定义的函数中，过滤数据，如果返回True，保留数据，返回False，代表舍弃该数据
reduce：
reduce(func,iterbale),一次性从iterable当中拿出两个值，扔到func函数中进行处理，把运算结果与第三个值继续扔到func函数中做运算，....依次类推，最后返回计算的结果
sorted：
sorted(iterable,reverse=False,key=函数)，可填三个参数，功能就是排序默认从小到大。key可以填自定义函数和内置函数。返回的是一个全新的列表