高阶函数

（1）迭代器：

​ 概念：能被next()函数调用，并不断返回下一个值的对象，叫做迭代器（迭代器是对象）

​ 特征：不依赖索引，通过next指针迭代所有数据，一次只取一个，可以大大节省空间，迭代无限量的数据

• 可迭代对象：

​ 如果成员中含有__iter__这个方法，就是可迭代对象

​ dir函数可以查看一个对象中所有的成员

（2）迭代器：

• 迭代器的定义：

  ​ 通过iter（）方法定义迭代器

  ​ 通过可迭代对象.__iter__()定义迭代器

• 判断迭代器：如果内置成员中含有__iter__和__next__两个方法，就可判断是一个迭代器

• 调用迭代器

  ​ 方式一：next（迭代器）

  ​ 方式二：迭代器.__next__()

  ​ 注：迭代器通过next方法调用时，是单相不可逆的过程

• 重置迭代器

​ 重新定义：使用next调用，单项不可逆，所以需要使用iter（）重新定义

• 使用Iterator和Iterable来判断是否是迭代器

  from collections import Iterator,Iterable 使用from … import … 引入

  Iterator迭代器类型 Iterable 可迭代对象

• 注：迭代器一定是可迭代对象，但可迭代对象不一定是迭代器

  # 判断可迭代对象
  setvar = {"a", 1, "b", 2}
  for i in setvar:
      print(i)
  res = dir(setvar)
  print(res)
  
  # 定义迭代器
  setvar = {"a", 1, "b", 2}
  it = iter(setvar)
  print(it)
  
  # 判断迭代器
  print(dir(it))
  res = "__iter__" in dir(it) and "__next__" in dir(it)
  print(res)
  
  # 调用迭代器
  res = next(it)
  print(res)
  
  # 重置迭代器
  it = iter(setvar)
  res = next(it)
  ret = iter(setvar)
  res = next(it)
  print(res)
  
  # 导入模块判断迭代器和可迭代对象
  from collections import Iterator,Iterable
  setvar = {"a", "b", "c"}
  res = isinstance(setvar, Iterator)
  print(res)
  ret = isinstance(setvar, Iterable)
  print(ret)
  
  it = iter(range(5))
  res = isinstance(it, Iterator)
  print(res)
  ret = isinstance(it, Iterable)
  print(ret)
  
  # 通过next获取迭代器中的数据
  res = next(it)
  print(res)
  
  # for循环遍历迭代器
  it = iter(range(6))
  for i in it:
      print(i)
  
  # for和next配合调用迭代器
  it = iter(range(100000))
  for i in range(10):
      res = next(it)
      print(res)
  
  for i in range(10):
      res = next(it)
      print(res)
  

（3）高阶函数：能够把函数当成参数传递的就是高阶函数 map filter reduce sorted

• map（func,iterable）

  功能：把iterable里面的数据一个一个拿出来，放到func函数中进行处理，把处理的结果扔到迭代器中，返回迭代器。

  func：自定义函数或内置函数

  iterable：可迭代对象（容器类型数据，range（），迭代器）

  返回值：迭代器

  lst = ['1', '2', '3']
  lst_new = []
  for i in lst:
      res = int(i)
      lst_new.append(res)
  print(lst_new)
  
  # map的使用
  from collections import Iterator, Iterable
  it = map(int, lst)
  res = isinstance(it, Iterator)
  print(res)
  res = next(it)
  print(res)
  
  it = map(int, lst)
  for i in it:
      print(i)
  
  it = map(int, lst)
  for i in range(2):
      print(next(it))
  
  it = map(int, lst)
  lst = list(it)
  print(lst)
  
  

• filter（func,iterable）

  功能：在定义的函数中，过滤数据；若返回True代表保留数据；若返回False代表舍弃该数据

  func：自定义函数

  iterable：可迭代性数据（容器类型数据，range（），迭代器）

  返回值：迭代器

  from collections import Iterator, Iterable
  lst = [1, 2, 3, 4, 5, 6, 7, 8]
  lst_new = []
  for i in lst:
      if i % 2 == 1:
          lst_new.append(i)
  print(lst_new)
  
  # filter
  def func(n):
      if n % 2 == 0:
          return False
      else:
          return True
  it = filter(func, lst)
  res = isinstance(it, Iterator)
  print(res)
  print(list(it))
  

• reduct（func, iterable）

  功能：一次性从iterable当中取出两个值，扔到func函数中进行处理，把运算的结果再和iterable的第三个值继续扔到func中做运算，依次类推，最后返回计算的结果

  func：自定义函数

  iterable：可迭代性数据（容器类型数据，range（），迭代器）

  返回值：最后计算结果

  注：需要导入模块 from functools import reduce

  lst = [5, 4, 8, 8]
  strvar = ""
  for i in lst:
      strvar += str(i)
  print(strvar, type(strvar))
  intvar = int(strvar)
  print(intvar, type(intvar))
  
  it = iter(lst)
  num1 = next(it)
  num2 = next(it)
  print(num1)
  print(num2)
  total = num1 * 10 + num2
  print(total)
  for i in it:
      total = total * 10 + i
  print(total, type(total))
  
  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))
  
  print(reduce(lambda x, y: x * 10 + y, lst))
  

• sorted（iterable，reverse=False, key = 函数）

  功能：排序

  iterable：可迭代性数据（容器类型数据 range对象 迭代器）

  reverse：代表是否倒叙 reverse=True 代表倒叙 从大到小 reverse = False 代表正序，从小到大

  key：自定义函数 或 内置函数

  返回值：排序后的列表（新列表）

  # sorted
  container = [100, 200, 13, -6, 0]
  container = (100, 200, 13, -6, 0)
  container = {100, 200, 13, -6, 0}
  container = "oneal"
  container = {"a": 1, "b": 2, "c": 3}
  
  lst_new = sorted(container)
  print(lst_new)
  
  # 自定义函数排序
  let = [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)