day11-Python运维开发基础(迭代器与可迭代对象、高阶函数)
1. 迭代器与可迭代对象
- # ### 迭代器
- """
- 迭代器: 能被next方法调用,并且不断返回下一个值的对象,是迭代器(对象)
- 特征:迭代器会生成惰性序列,它通过计算把值依次的返回,一边循环一边计算而不是一次性得到所有数据
- 优点:需要数据的时候,一次取一个,可以大大节省内存空间.而不是一股脑的把所有数据放进内存.
- 总结:
- 1.惰性序列,节省内存空间
- 2.遍历获取值得时候使用next,方向不可逆
- 3.迭代器可以遍历无限量大的数据
- """
- # 可迭代对象
- """
- 如果该数据成员当中含有__iter__方法,就是可迭代对象
- dir 查看该数据的内部成员
- """
- setvar = {"a","b","c","d"}
- lst = dir(setvar)
- print(lst)
- res = "__iter__" in lst
- print(res)
- for i in setvar:
- print(i)
- # 迭代器
- """
- # (1) 如何定义一个迭代器
- 1.iter(可迭代对象) (推荐)
- 2.可迭代对象.__iter__()
- # (2) 如何判断一个迭代器
- 1.内部成员中,含有__iter__ 和 __next__ 两个方法
- 2.from collections import Iterator,Iterable
- # (3) 如何调用一个迭代器
- 使用next方法可以调用迭代器,返回里面的内容
- 可迭代对象 -> 迭代器
- 不可直接调用 -> 可直接调用
- 如果是一个可迭代对象,不一定是迭代器
- 入股是一个迭代器,就一定是可迭代对象
- """
- # (1)定义一个迭代器
- setvar = {"a","b","c","d"}
- it = iter(setvar)
- # (2)判断一个迭代器
- lst = dir(it)
- print(lst)
- # 方法一
- res = "__iter__" in lst and "__next__" in lst
- print(res)
- # 方法二
- # from 从... collections import 引入 Iterator 迭代器类型 Iterable可迭代对象类型
- from collections import Iterator,Iterable
- res = isinstance(it,Iterator)
- print(res)
- # (3)调用迭代器
- """next方法 ,调用迭代器 是单项不可逆的过程,(一条路走到黑)"""
- res = next(it)
- res = next(it)
- res = next(it)
- res = next(it)
- # res = next(it) error
- print(res)
- # (4)重置迭代器
- it = iter(setvar)
- print( next(it) )
- # (5)把range对象变成迭代器
- it = range(10).__iter__()
- # 判断迭代器
- res1 = isinstance(it,Iterator)
- res2 = isinstance(it,Iterable)
- print(res1 , res2)
- # 获取迭代器中数据
- # 方法一 next
- res = next(it)
- print(res)
- res = next(it)
- print(res)
- res = next(it)
- print(res)
- res = next(it)
- print(res)
- # 方法二 for
- print("<===============>")
- for i in it:
- print(i)
- print("<===============>")
- # 方法三 for + next
- # print(next(it)) # StopIteration
- it = range(10).__iter__()
- for i in range(5):
- res = next(it)
- print(res)
迭代器与可迭代对象 示例代码
2. 高阶函数(map / reduce / sorted / filter)
- # ### 高阶函数 : 能够把函数当成参数传递的就是高阶函数
- """map reduce sorted filter"""
- # map
- """
- map(func,Iterable)
- 功能:
- 把Iterable中的值,一个一个拿出来放到func函数中进行处理,把处理的结果扔到迭代器中,最后返回迭代器
- 参数:
- func : 自定义函数 或者 内置函数
- Iterable : 可迭代对象(容器类型数据 range对象 迭代器)
- 返回值:
- 迭代器
- """
- from collections import Iterator,Iterable
- # ### (1) ["1","2","3","4"] => [1,2,3,4]
- lst = ["","","",""]
- lst_new = []
- for i in lst:
- print(i,type(i))
- lst_new.append( int(i) )
- print(lst_new)
- # map改写
- it = map(int,lst)
- res = isinstance(it,Iterator)
- print(res)
- """
- 代码解析:
- 首先从列表里拿出第一个数据 "1" 扔到int方法中进行强转,把强转的结果扔给迭代器
- 然后从列表里拿出第二个数据 "2" 扔到int方法中进行强转,把强转的结果扔给迭代器
- 然后从列表里拿出第三个数据 "3" 扔到int方法中进行强转,把强转的结果扔给迭代器
- 然后从列表里拿出第四个数据 "4" 扔到int方法中进行强转,把强转的结果扔给迭代器
- 最后返回迭代器
- """
- # (1)next获取迭代器中的数据
- res= next(it)
- print(res)
- res= next(it)
- print(res)
- res= next(it)
- print(res)
- res= next(it)
- print(res)
- # res= next(it) error # StopIteration
- # print(res)
- print("<===========>")
- # (2)for 循环遍历
- it = map(int,lst)
- for i in it :
- print(i)
- # (3)list 强制转换
- it = map(int,lst)
- lst = list(it)
- print(lst)
- # ### (2) [1,2,3,4] => [1,4,9,16]
- lst = [1,2,3,4]
- lst_new = []
- for i in lst:
- res = i ** 2
- lst_new.append(res)
- print(lst_new)
- # map改写
- def func(n):
- return n ** 2
- # 方法一
- """
- it = map(func,lst)
- # list强转迭代器 变成列表
- lst = list(it)
- print(lst)
- """
- # 方法二
- it = map(lambda n : n ** 2 , lst)
- lst = list(it)
- print(lst)
- # ### {97:"a",98:"b",99:"c"} => 给你["a","b","c"] => [97,98,99]
- # 原型
- # dic = {"a":97,"b":98,"c":99}
- # res = dic["a"]
- # print(res)
- # 反转字典
- dic = {97:"a",98:"b",99:"c"}
- dic_new = {}
- # 把字典的键和值对换
- for k,v in dic.items():
- print(k,v)
- dic_new[v] = k
- print(dic_new)
- # 通过字典拿到对应的值,插入到列表中
- lst = ["a","b","c"]
- lst_new = []
- for i in lst:
- res = dic_new[i]
- lst_new.append(res)
- print(lst_new)
- # 用map进行改写
- lst = ["a","b","c"]
- def func(n):
- dic = {97:"a",98:"b",99:"c"}
- dic_new = {}
- for k,v in dic.items():
- dic_new[v] = k
- # {'a': 97, 'b': 98, 'c': 99}
- return dic_new[n]
- it = map(func,lst)
- lst = list(it)
- print(lst)
map高阶函数 示例代码
- # ### reduce
- """
- reduce(func,Iterable)
- 功能:
- 从iterable中一次性拿出2个数据,扔到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,type(strvar))
- res = int(strvar)
- print(res,type(res))
- # 方法二 用算数来做
- """
- 5 4 8 8
- 5*10 + 4 = 54
- 54 * 10 + 8 = 548
- 548 * 10 + 8 = 5488
- """
- lst = [5,4,8,8]
- # (1) 变成迭代器
- it = iter(lst)
- # (2) 获取前两个元素
- num1 = next(it)
- num2 = next(it)
- total = num1 * 10 + num2
- print(total)
- # (3) 计算剩余的数据
- for i in it:
- total = total * 10 + i
- print(total,type(total))
- # reduce 改写
- lst = [5,4,8,8]
- from functools import reduce
- def func(x,y):
- return x*10+y
- print(func(5,4))
- res = reduce(func,lst)
- print(res,type(res))
- """
- 拿出5 和 4 两个元素 扔到自定义的func函数中
- x 接受 5 y 接受 4
- return 5*10 + 4 => return 54
- 然后拿出54 和 8 两个元素 扔到自定义的func函数中
- x 接受54 y 接受 8
- return 54 * 10 + 8 => return 548
- 然后拿出548 和 8 两个元素 扔到自定义的func函数中
- x 接受548 y 接受 8
- return 548 * 10 + 8 => return 5488
- 返回5488 结束
- """
- # "678" => 整型 678 (不让使用int)
- def func(x,y):
- return x*10+y
- def func2(n):
- dic = {"":0,"":1,"":2,"":3,"":4,"":5,"":6,"":7,"":8,"":9}
- return dic[n]
- strvar = ""
- it = map(func2,strvar)
- res = reduce(func,it)
- print(res,type(res))
reduce高阶函数 示例代码
- # ### sorted
- """
- sorted(iterable,key=函数,reverse=False)
- 功能:排序
- 参数:
- iterable(容器类型数据,range对象,迭代器)
- key = 函数 自定义 或者 内置函数
- reverse = False 从小到大排序 reverse = True 从大到小排序
- 返回值:
- 排序后的结果
- """
- # (1) 默认从小到大排序
- tup = (1,15,-18,12,0)
- lst = sorted(tup)
- print(lst)
- # (2) 从大到小排序
- tup = (1,15,-18,12,0)
- lst = sorted(tup,reverse=True)
- print(lst)
- # (3) 使用绝对值进行排序
- # res = abs(10)
- # print(res)
- tup = (1,15,-18,12,0)
- lst = sorted(tup,key=abs)
- print(lst)
- """
- 0 => abs(0) => 0
- 1 => abs(1) => 1
- 12 => abs(12) => 12
- 15 => abs(15) => 15
- -18 => abs(-18) => 18
- """
- # (4) 使用自定义函数进行排序 -> 按照余数大小排序
- tup = (19,23,32,35,67)
- def func(n):
- return n % 10
- lst = sorted(tup,key=func)
- print(lst)
- """
- 32 func => 2
- 23 func => 3
- 35 func => 5
- 67 func => 7
- 19 func => 9
- """
- # 字符串排序
- strvar = "zfacd"
- lst = sorted(strvar)
- print(lst)
- # 集合排序
- setvar = {"z","f","a","c","d"}
- lst = sorted(setvar)
- print(lst)
- """
- 总结:
- sort 只能针对列表进行排序,直接修改原有列表
- sorted 容器类型数据都可以排序,产生一个新的副本,数据类型是列表
- """
sorted高阶函数 示例代码
- # ### filter
- """
- filter(func,iterable)
- 功能: 过滤
- 在自定义函数中:
- 如果返回True , 代表保留该数据
- 如果返回False , 代表舍弃该数据
- 参数:
- func 自定义函数
- iterable 可迭代对象(容器类型数据 range对象 迭代器)
- 返回值:
- 迭代器
- """
- from collections import Iterator
- lst = [1,2,3,4,5,6,7,8]
- lst_new = []
- for i in lst:
- if i % 2 == 0:
- lst_new.append(i)
- print(lst_new)
- # 用filter改写
- def func(n):
- if n % 2 == 0:
- return True
- else:
- return False
- it = filter(func,lst)
- res = isinstance(it,Iterator)
- print(res)
- # next 获取迭代器中的数据
- res = next(it)
- print(res)
- res = next(it)
- print(res)
- res = next(it)
- print(res)
- res = next(it)
- print(res)
- # for 获取迭代器中的数据
- it = filter(func,lst)
- for i in it:
- print(i)
- # for + next 获取迭代器中的数据
- it = filter(func,lst)
- for i in range(3):
- res = next(it)
- print(res)
- # list 强转迭代器变成列表
- it = filter(func,lst)
- lst = list(it)
- print(lst)
- # 匿名函数优化
- it = filter(lambda n : True if n % 2 == 0 else False , lst)
- for i in it:
- print(i)
filter高阶函数 示例代码
day11
day11-Python运维开发基础(迭代器与可迭代对象、高阶函数)的更多相关文章
- Python运维开发基础07-文件基础【转】
一,文件的基础操作 对文件操作的流程 [x] :打开文件,得到文件句柄并赋值给一个变量 [x] :通过句柄对文件进行操作 [x] :关闭文件 创建初始操作模板文件 [root@localhost sc ...
- Python运维开发基础10-函数基础【转】
一,函数的非固定参数 1.1 默认参数 在定义形参的时候,提前给形参赋一个固定的值. #代码演示: def test(x,y=2): #形参里有一个默认参数 print (x) print (y) t ...
- Python运维开发基础09-函数基础【转】
上节作业回顾 #!/usr/bin/env python3 # -*- coding:utf-8 -*- # author:Mr.chen # 实现简单的shell命令sed的替换功能 import ...
- Python运维开发基础08-文件基础【转】
一,文件的其他打开模式 "+"表示可以同时读写某个文件: r+,可读写文件(可读:可写:可追加) w+,写读(不常用) a+,同a(不常用 "U"表示在读取时, ...
- Python运维开发基础06-语法基础【转】
上节作业回顾 (讲解+温习120分钟) #!/usr/bin/env python3 # -*- coding:utf-8 -*- # author:Mr.chen # 添加商家入口和用户入口并实现物 ...
- Python运维开发基础05-语法基础【转】
上节作业回顾(讲解+温习90分钟) #!/usr/bin/env python # -*- coding:utf-8 -*- # author:Mr.chen import os,time Tag = ...
- Python运维开发基础04-语法基础【转】
上节作业回顾(讲解+温习90分钟) #!/usr/bin/env python3 # -*- coding:utf-8 -*- # author:Mr.chen # 仅用列表+循环实现“简单的购物车程 ...
- Python运维开发基础03-语法基础 【转】
上节作业回顾(讲解+温习60分钟) #!/usr/bin/env python3 # -*- coding:utf-8 -*- # author:Mr.chen #只用变量和字符串+循环实现“用户登陆 ...
- Python运维开发基础02-语法基础【转】
上节作业回顾(讲解+温习60分钟) #!/bin/bash #user login User="yunjisuan" Passwd="666666" User2 ...
随机推荐
- Codeforces 1045F Shady Lady 凸包+数学
题目链接:https://codeforc.es/contest/1045/problem/F 题意:先给出一个系数不确定的二元多项式,Borna可以给这个多项式的每一项填上正的系数,Ani能从这个多 ...
- Plastic Bottle Manufacturer Tips - Attention To Plastic Bottle Processing Technology
In fact, the processing technology of plastic bottles is actually quite strict. In fact, regular man ...
- CSP-201609-3 炉石传说
问题描述 <炉石传说:魔兽英雄传>(Hearthstone: Heroes of Warcraft,简称炉石传说)是暴雪娱乐开发的一款集换式卡牌游戏(如下图所示).游戏在一个战斗棋盘上进行 ...
- 吴裕雄--天生自然Numpy库学习笔记:NumPy 统计函数
NumPy 提供了很多统计函数,用于从数组中查找最小元素,最大元素,百分位标准差和方差等. numpy.amin() 用于计算数组中的元素沿指定轴的最小值. numpy.amax() 用于计算数组中的 ...
- IIS 7.5 URL重写参数
URL 重写规则由以下部分组成: 模式 - 可以理解为规则,分通配符和正则匹配 条件 - 可以理解为字符串 操作 - 操作用于指定如果URL字符串与规则模式匹配并且满足所有规则条件时应 ...
- rtt学习之线程间同步与通信
一 线程间的同步与互斥:信号量.互斥量.实践集 线程互斥是指对于临界区资源访问的排它性,如多个线程对共享内存资源的访问,生产消费型对产品的操作.临界区操作操作方法有: rt_hw_interrupt_ ...
- httpclient使用-get-post-传参
转自:https://www.jianshu.com/p/375be5929bed 一.HttpClient使用详解与实战一:普通的GET和POST请求 简介 HttpClient是Apache Ja ...
- 定时任务--mysql数据库备份
vim /home/back.sh #!/bin/bash USER="******" PASSWORD="******" DATABASE="*** ...
- Python 基础之压缩模块zipfile与tarfile
一.压缩模块 zipfile (1)创建一个zip压缩包 import zipfile #zip_deflated 代表是压缩的意思#打开压缩包zf = zipfile.ZipFile("c ...
- Chrome浏览器 无需安装插件将整个网页另存为图片
步骤1 ctrl+shift+i 步骤2 ctrl+shift+p 步骤3 输入full 回车确定 感谢先辈们的无私奉献!原文https://blog.csdn.net/wumingid/articl ...