1. 迭代器与可迭代对象

  1. # ### 迭代器
  2. """
  3. 迭代器: 能被next方法调用,并且不断返回下一个值的对象,是迭代器(对象)
  4.  
  5. 特征:迭代器会生成惰性序列,它通过计算把值依次的返回,一边循环一边计算而不是一次性得到所有数据
  6. 优点:需要数据的时候,一次取一个,可以大大节省内存空间.而不是一股脑的把所有数据放进内存.
  7. 总结:
  8. 1.惰性序列,节省内存空间
  9. 2.遍历获取值得时候使用next,方向不可逆
  10. 3.迭代器可以遍历无限量大的数据
  11. """
  12.  
  13. # 可迭代对象
  14. """
  15. 如果该数据成员当中含有__iter__方法,就是可迭代对象
  16. dir 查看该数据的内部成员
  17. """
  18. setvar = {"a","b","c","d"}
  19. lst = dir(setvar)
  20. print(lst)
  21. res = "__iter__" in lst
  22. print(res)
  23.  
  24. for i in setvar:
  25. print(i)
  26.  
  27. # 迭代器
  28. """
  29. # (1) 如何定义一个迭代器
  30. 1.iter(可迭代对象) (推荐)
  31. 2.可迭代对象.__iter__()
  32.  
  33. # (2) 如何判断一个迭代器
  34. 1.内部成员中,含有__iter__ 和 __next__ 两个方法
  35. 2.from collections import Iterator,Iterable
  36.  
  37. # (3) 如何调用一个迭代器
  38. 使用next方法可以调用迭代器,返回里面的内容
  39.  
  40. 可迭代对象 -> 迭代器
  41. 不可直接调用 -> 可直接调用
  42. 如果是一个可迭代对象,不一定是迭代器
  43. 入股是一个迭代器,就一定是可迭代对象
  44. """
  45.  
  46. # (1)定义一个迭代器
  47. setvar = {"a","b","c","d"}
  48. it = iter(setvar)
  49.  
  50. # (2)判断一个迭代器
  51. lst = dir(it)
  52. print(lst)
  53. # 方法一
  54. res = "__iter__" in lst and "__next__" in lst
  55. print(res)
  56. # 方法二
  57. # from 从... collections import 引入 Iterator 迭代器类型 Iterable可迭代对象类型
  58. from collections import Iterator,Iterable
  59. res = isinstance(it,Iterator)
  60. print(res)
  61.  
  62. # (3)调用迭代器
  63. """next方法 ,调用迭代器 是单项不可逆的过程,(一条路走到黑)"""
  64. res = next(it)
  65. res = next(it)
  66. res = next(it)
  67. res = next(it)
  68. # res = next(it) error
  69. print(res)
  70.  
  71. # (4)重置迭代器
  72. it = iter(setvar)
  73. print( next(it) )
  74.  
  75. # (5)把range对象变成迭代器
  76. it = range(10).__iter__()
  77. # 判断迭代器
  78. res1 = isinstance(it,Iterator)
  79. res2 = isinstance(it,Iterable)
  80. print(res1 , res2)
  81.  
  82. # 获取迭代器中数据
  83. # 方法一 next
  84. res = next(it)
  85. print(res)
  86. res = next(it)
  87. print(res)
  88. res = next(it)
  89. print(res)
  90. res = next(it)
  91. print(res)
  92.  
  93. # 方法二 for
  94. print("<===============>")
  95. for i in it:
  96. print(i)
  97.  
  98. print("<===============>")
  99. # 方法三 for + next
  100. # print(next(it)) # StopIteration
  101. it = range(10).__iter__()
  102. for i in range(5):
  103. res = next(it)
  104. print(res)

迭代器与可迭代对象 示例代码

2. 高阶函数(map / reduce / sorted / filter)

  1. # ### 高阶函数 : 能够把函数当成参数传递的就是高阶函数
  2. """map reduce sorted filter"""
  3.  
  4. # map
  5. """
  6. map(func,Iterable)
  7. 功能:
  8. 把Iterable中的值,一个一个拿出来放到func函数中进行处理,把处理的结果扔到迭代器中,最后返回迭代器
  9. 参数:
  10. func : 自定义函数 或者 内置函数
  11. Iterable : 可迭代对象(容器类型数据 range对象 迭代器)
  12. 返回值:
  13. 迭代器
  14. """
  15. from collections import Iterator,Iterable
  16. # ### (1) ["1","2","3","4"] => [1,2,3,4]
  17. lst = ["","","",""]
  18. lst_new = []
  19. for i in lst:
  20. print(i,type(i))
  21. lst_new.append( int(i) )
  22. print(lst_new)
  23.  
  24. # map改写
  25. it = map(int,lst)
  26. res = isinstance(it,Iterator)
  27. print(res)
  28.  
  29. """
  30. 代码解析:
  31. 首先从列表里拿出第一个数据 "1" 扔到int方法中进行强转,把强转的结果扔给迭代器
  32. 然后从列表里拿出第二个数据 "2" 扔到int方法中进行强转,把强转的结果扔给迭代器
  33. 然后从列表里拿出第三个数据 "3" 扔到int方法中进行强转,把强转的结果扔给迭代器
  34. 然后从列表里拿出第四个数据 "4" 扔到int方法中进行强转,把强转的结果扔给迭代器
  35.  
  36. 最后返回迭代器
  37. """
  38.  
  39. # (1)next获取迭代器中的数据
  40. res= next(it)
  41. print(res)
  42. res= next(it)
  43. print(res)
  44. res= next(it)
  45. print(res)
  46. res= next(it)
  47. print(res)
  48. # res= next(it) error # StopIteration
  49. # print(res)
  50.  
  51. print("<===========>")
  52. # (2)for 循环遍历
  53. it = map(int,lst)
  54. for i in it :
  55. print(i)
  56.  
  57. # (3)list 强制转换
  58. it = map(int,lst)
  59. lst = list(it)
  60. print(lst)
  61.  
  62. # ### (2) [1,2,3,4] => [1,4,9,16]
  63. lst = [1,2,3,4]
  64. lst_new = []
  65. for i in lst:
  66. res = i ** 2
  67. lst_new.append(res)
  68. print(lst_new)
  69.  
  70. # map改写
  71. def func(n):
  72. return n ** 2
  73.  
  74. # 方法一
  75. """
  76. it = map(func,lst)
  77. # list强转迭代器 变成列表
  78. lst = list(it)
  79. print(lst)
  80. """
  81. # 方法二
  82. it = map(lambda n : n ** 2 , lst)
  83. lst = list(it)
  84. print(lst)
  85.  
  86. # ### {97:"a",98:"b",99:"c"} => 给你["a","b","c"] => [97,98,99]
  87. # 原型
  88. # dic = {"a":97,"b":98,"c":99}
  89. # res = dic["a"]
  90. # print(res)
  91.  
  92. # 反转字典
  93. dic = {97:"a",98:"b",99:"c"}
  94. dic_new = {}
  95. # 把字典的键和值对换
  96. for k,v in dic.items():
  97. print(k,v)
  98. dic_new[v] = k
  99. print(dic_new)
  100. # 通过字典拿到对应的值,插入到列表中
  101. lst = ["a","b","c"]
  102. lst_new = []
  103. for i in lst:
  104. res = dic_new[i]
  105. lst_new.append(res)
  106. print(lst_new)
  107.  
  108. # 用map进行改写
  109. lst = ["a","b","c"]
  110. def func(n):
  111. dic = {97:"a",98:"b",99:"c"}
  112. dic_new = {}
  113. for k,v in dic.items():
  114. dic_new[v] = k
  115. # {'a': 97, 'b': 98, 'c': 99}
  116. return dic_new[n]
  117.  
  118. it = map(func,lst)
  119. lst = list(it)
  120. print(lst)

map高阶函数 示例代码

  1. # ### reduce
  2. """
  3. reduce(func,Iterable)
  4. 功能:
  5. 从iterable中一次性拿出2个数据,扔到func函数进行运算,
  6. 然后将运算的结果和Iterable中的第三个数据在放到func中进行运算
  7. 以此类推...
  8. 最后返回计算的结果
  9. 参数:
  10. func : 自定义函数 或者 内置函数
  11. iterable : 可迭代对象(容器类型数据 range对象 迭代器)
  12. 返回值:
  13. 最后计算的结果
  14. """
  15. # (1) [5,4,8,8] => 5488
  16. lst = [5,4,8,8]
  17. # 方法一 .字符串的拼接
  18. strvar = ""
  19. for i in lst:
  20. strvar += str(i)
  21. print(strvar,type(strvar))
  22. res = int(strvar)
  23. print(res,type(res))
  24.  
  25. # 方法二 用算数来做
  26. """
  27. 5 4 8 8
  28. 5*10 + 4 = 54
  29. 54 * 10 + 8 = 548
  30. 548 * 10 + 8 = 5488
  31. """
  32. lst = [5,4,8,8]
  33. # (1) 变成迭代器
  34. it = iter(lst)
  35.  
  36. # (2) 获取前两个元素
  37. num1 = next(it)
  38. num2 = next(it)
  39. total = num1 * 10 + num2
  40. print(total)
  41.  
  42. # (3) 计算剩余的数据
  43. for i in it:
  44. total = total * 10 + i
  45. print(total,type(total))
  46.  
  47. # reduce 改写
  48. lst = [5,4,8,8]
  49. from functools import reduce
  50. def func(x,y):
  51. return x*10+y
  52. print(func(5,4))
  53.  
  54. res = reduce(func,lst)
  55. print(res,type(res))
  56. """
  57. 拿出5 和 4 两个元素 扔到自定义的func函数中
  58. x 接受 5 y 接受 4
  59. return 5*10 + 4 => return 54
  60.  
  61. 然后拿出54 和 8 两个元素 扔到自定义的func函数中
  62. x 接受54 y 接受 8
  63. return 54 * 10 + 8 => return 548
  64.  
  65. 然后拿出548 和 8 两个元素 扔到自定义的func函数中
  66. x 接受548 y 接受 8
  67. return 548 * 10 + 8 => return 5488
  68.  
  69. 返回5488 结束
  70. """
  71.  
  72. # "678" => 整型 678 (不让使用int)
  73. def func(x,y):
  74. return x*10+y
  75.  
  76. def func2(n):
  77. dic = {"":0,"":1,"":2,"":3,"":4,"":5,"":6,"":7,"":8,"":9}
  78. return dic[n]
  79. strvar = ""
  80. it = map(func2,strvar)
  81.  
  82. res = reduce(func,it)
  83. print(res,type(res))

reduce高阶函数 示例代码

  1. # ### sorted
  2. """
  3. sorted(iterable,key=函数,reverse=False)
  4. 功能:排序
  5. 参数:
  6. iterable(容器类型数据,range对象,迭代器)
  7. key = 函数 自定义 或者 内置函数
  8. reverse = False 从小到大排序 reverse = True 从大到小排序
  9. 返回值:
  10. 排序后的结果
  11. """
  12.  
  13. # (1) 默认从小到大排序
  14. tup = (1,15,-18,12,0)
  15. lst = sorted(tup)
  16. print(lst)
  17.  
  18. # (2) 从大到小排序
  19. tup = (1,15,-18,12,0)
  20. lst = sorted(tup,reverse=True)
  21. print(lst)
  22.  
  23. # (3) 使用绝对值进行排序
  24. # res = abs(10)
  25. # print(res)
  26. tup = (1,15,-18,12,0)
  27. lst = sorted(tup,key=abs)
  28. print(lst)
  29. """
  30. 0 => abs(0) => 0
  31. 1 => abs(1) => 1
  32. 12 => abs(12) => 12
  33. 15 => abs(15) => 15
  34. -18 => abs(-18) => 18
  35. """
  36.  
  37. # (4) 使用自定义函数进行排序 -> 按照余数大小排序
  38. tup = (19,23,32,35,67)
  39. def func(n):
  40. return n % 10
  41. lst = sorted(tup,key=func)
  42. print(lst)
  43. """
  44. 32 func => 2
  45. 23 func => 3
  46. 35 func => 5
  47. 67 func => 7
  48. 19 func => 9
  49. """
  50.  
  51. # 字符串排序
  52. strvar = "zfacd"
  53. lst = sorted(strvar)
  54. print(lst)
  55.  
  56. # 集合排序
  57. setvar = {"z","f","a","c","d"}
  58. lst = sorted(setvar)
  59. print(lst)
  60.  
  61. """
  62. 总结:
  63. sort 只能针对列表进行排序,直接修改原有列表
  64. sorted 容器类型数据都可以排序,产生一个新的副本,数据类型是列表
  65. """

sorted高阶函数 示例代码

  1. # ### filter
  2. """
  3. filter(func,iterable)
  4. 功能: 过滤
  5. 在自定义函数中:
  6. 如果返回True , 代表保留该数据
  7. 如果返回False , 代表舍弃该数据
  8. 参数:
  9. func 自定义函数
  10. iterable 可迭代对象(容器类型数据 range对象 迭代器)
  11. 返回值:
  12. 迭代器
  13. """
  14. from collections import Iterator
  15.  
  16. lst = [1,2,3,4,5,6,7,8]
  17. lst_new = []
  18. for i in lst:
  19. if i % 2 == 0:
  20. lst_new.append(i)
  21.  
  22. print(lst_new)
  23.  
  24. # 用filter改写
  25. def func(n):
  26. if n % 2 == 0:
  27. return True
  28. else:
  29. return False
  30. it = filter(func,lst)
  31. res = isinstance(it,Iterator)
  32. print(res)
  33.  
  34. # next 获取迭代器中的数据
  35. res = next(it)
  36. print(res)
  37. res = next(it)
  38. print(res)
  39. res = next(it)
  40. print(res)
  41. res = next(it)
  42. print(res)
  43.  
  44. # for 获取迭代器中的数据
  45. it = filter(func,lst)
  46. for i in it:
  47. print(i)
  48.  
  49. # for + next 获取迭代器中的数据
  50. it = filter(func,lst)
  51. for i in range(3):
  52. res = next(it)
  53. print(res)
  54.  
  55. # list 强转迭代器变成列表
  56. it = filter(func,lst)
  57. lst = list(it)
  58. print(lst)
  59.  
  60. # 匿名函数优化
  61. it = filter(lambda n : True if n % 2 == 0 else False , lst)
  62. for i in it:
  63. print(i)

filter高阶函数 示例代码

day11

day11-Python运维开发基础(迭代器与可迭代对象、高阶函数)的更多相关文章

  1. Python运维开发基础07-文件基础【转】

    一,文件的基础操作 对文件操作的流程 [x] :打开文件,得到文件句柄并赋值给一个变量 [x] :通过句柄对文件进行操作 [x] :关闭文件 创建初始操作模板文件 [root@localhost sc ...

  2. Python运维开发基础10-函数基础【转】

    一,函数的非固定参数 1.1 默认参数 在定义形参的时候,提前给形参赋一个固定的值. #代码演示: def test(x,y=2): #形参里有一个默认参数 print (x) print (y) t ...

  3. Python运维开发基础09-函数基础【转】

    上节作业回顾 #!/usr/bin/env python3 # -*- coding:utf-8 -*- # author:Mr.chen # 实现简单的shell命令sed的替换功能 import ...

  4. Python运维开发基础08-文件基础【转】

    一,文件的其他打开模式 "+"表示可以同时读写某个文件: r+,可读写文件(可读:可写:可追加) w+,写读(不常用) a+,同a(不常用 "U"表示在读取时, ...

  5. Python运维开发基础06-语法基础【转】

    上节作业回顾 (讲解+温习120分钟) #!/usr/bin/env python3 # -*- coding:utf-8 -*- # author:Mr.chen # 添加商家入口和用户入口并实现物 ...

  6. Python运维开发基础05-语法基础【转】

    上节作业回顾(讲解+温习90分钟) #!/usr/bin/env python # -*- coding:utf-8 -*- # author:Mr.chen import os,time Tag = ...

  7. Python运维开发基础04-语法基础【转】

    上节作业回顾(讲解+温习90分钟) #!/usr/bin/env python3 # -*- coding:utf-8 -*- # author:Mr.chen # 仅用列表+循环实现“简单的购物车程 ...

  8. Python运维开发基础03-语法基础 【转】

    上节作业回顾(讲解+温习60分钟) #!/usr/bin/env python3 # -*- coding:utf-8 -*- # author:Mr.chen #只用变量和字符串+循环实现“用户登陆 ...

  9. Python运维开发基础02-语法基础【转】

    上节作业回顾(讲解+温习60分钟) #!/bin/bash #user login User="yunjisuan" Passwd="666666" User2 ...

随机推荐

  1. JS-判断null值

    单独判断 null var str = null; if(str === null){ alert("is null"); } 同时判断 null 和 undefined 虽然nu ...

  2. php mongdb driver 1.17

    Installation To build and install the driver: $ pecl install mongodb $ echo "extension=mongodb. ...

  3. WLC-生成CSR操作

    1.生成CSR [req]req_extensions = v3_req[ v3_req ]# Extensions to add to a certificate requestbasicConst ...

  4. 动态规划-爬楼梯问题java实现

    最近开始看算法导论,研究了一下动态规划,下面就开始直入主题开始记录近期看的第一个知识点动态规划.提起动态规划就不得不提几个动态规划的金典问题爬楼梯.国王金矿.背包问题.今天就仔细分析一下爬楼梯问题. ...

  5. Django 学习之Rest Framework 视图相关

    drf除了在数据序列化部分简写代码以外,还在视图中提供了简写操作.所以在django原有的django.views.View类基础上,drf封装了多个子类出来提供给我们使用. Django REST ...

  6. Linux下给mysql创建用户并分配权限

    // fe_group 用户名// fe 数据库名// 123456 密码 1.新建用户 //登录MYSQL @>mysql -u root -p @>密码 //创建用户 mysql> ...

  7. Mybatis的逆向工程以及Example的实例函数及详解

    Mybatis-generator是Mybatis的逆向工程  (根据数据库中的表生成java代码) Mybatis的逆向工程会生成实例及实例对应的example,example用于添加条件,相当于w ...

  8. 吴裕雄--天生自然ORACLE数据库学习笔记:过程、函数、触发器和包

    create procedure pro_insertDept is begin ,'市场拓展部','JILIN'); --插入数据记录 commit; --提交数据 dbms_output.put_ ...

  9. 将一行很长的js代码格式化输出方便查看

    之前的一行js代码,有2万多字符,打开这个网址,粘贴到左边空白框,点下面格式化: 参考下面文章: 数千行的js代码变成了一行,如何复原,该换行的换行,该对齐的对齐_开发工具_小邯韩的博客-CSDN博客 ...

  10. Android开发实例之miniTwitter登录界面的实现

    原文: http://www.jizhuomi.com/android/example/134.html 本文要演示的Android开发实例是如何完成一个Android中的miniTwitter登录界 ...