迭代器

闭包函数 闭包函数是函数传参的一种方式。它可以把变量和函数一起包起来，下次要直接调用 我们先来看一下普通的传参方式: def inner(x): print(x) inner(1) inner(1) inner(1) 看上去好像也蛮简单的，但是如果你要传递的值会很多呢，比如要传递摸一个复杂的网址，那么就会变成： inner(https://image.baidu.com/search/detailct=503316480&z=undefined&tn=baiduimagedetail&ipn=d&word=python&step_word=&ie=utf8&in=&cl=2&lm=-1&st=undefined&hd=undefined&latest=undefined&copyright=undefined&cs=2274312350,3438054066&os=1842179554,428481594&simid=4207124190,751379936&pn=4&rn=1&di=93940&ln=1299&fr=&fmq=1565592554366_R&fm=&ic=undefined&s=undefined&se=&sme=&tab=0&width=undefined&height=undefined&face=undefined&is=0,0&istype=0&ist=

闭包函数 为函数传参有两种方式 方式一：以参数的形式 def func(x): print(x) func(1) # 1 方式二：包给函数 def outter(x): def inner(): print(x) return inner inner = outter(1) inner() # 1 闭包：闭是封闭（函数内部函数），包是包含（该内部函数对外部作用域的变量的引用，而非对全局作用域的变量的引用）。闭包指的是函数内部函数对外部作用域的引用，而非对全局作用域的引用。 闭包函数就是把变量和函数一起包起来，下次要用直接调用。 闭包的意义：返回的函数对象，不仅仅是一个函数对象，在该函数外还包裹了一层作用域，这使得，该函数无论在何处调用，优先使用自己外层包裹的作用域。 装饰器 函数是具备某一功能的工具，装饰器就是可以为被装饰对象添加额外的功能。因此装饰器就是定义一个函数，只不过这个函数的功能就是给其他函数添加额外的功能。 需要注意的是： 装饰器本身其实是可以任意可调用的对象 被装饰的对象也可以是任意可调用的对象 装饰器的实现必须遵循两个原则： 不修改被装饰对象的源代码 不修改被装饰对象的调用方式 1. 装饰器： import time def deco(func): def inner(): start = time.time() func() end = time.time()

8.12 迭代器 定义 迭代器： 迭代的工具。迭代是更新换代，如你爷爷生了你爹，你爹生了你，迭代也可以说成是重复，并且但每一次的重复都是基于上一次的结果来的。 可迭代对象 python中，一切皆对象： x = 1 name = 'nick' lis = [1, 2] tup = (1, 2) dic = {'name': 'nick'} s1 = {'a', 'b'} f = open('49w.txt', 'w', encoding='utf-8) def func(): pass 对于这一切的对象中，但凡有 __iter__ 方法的对象，都是可迭代对象。 # 以下都是可迭代的对象 name = 'nick'.__iter__ lis = [1, 2].__iter__ tup = (1, 2).__iter__ dic = {'name': 'nick'}.__iter__ s1 = {'a', 'b'}.__iter__ f = open('49w.txt', 'w', encoding='utf-8') f.__iter__ 可迭代的对象：Python内置str、list、tuple、dict、set、file都是可迭代对象。 特点： 内置有 __iter__ 方法的都叫可迭代的对象。 迭代器对象 只有字符串和列表都是依赖索引取值的，而其他的可迭代对象都是无法依赖索引取值的

#迭代器 迭代的工具,迭代是更新换代,也可以说成重复,可以基于上一次的结果推出下一次的结果 可迭代对象 python中一切皆对象,对这一切的对象中 但凡有 __iter__ 方法的对象，都是可迭代对象。 x = 1 # 不可迭代对象 s = 'nick' # 可迭代对象 s.__iter__() lt = [1, 2, 3] # 可迭代对象 dic = {'a': 1, 'b': 2} # 可迭代对象 tup = (1,) # 元组只有一个元素必须得加逗号# 可迭代对象 set = {1, 2, 3} # 可迭代对象 f = open('time.py') # 可迭代对象 def func(): # 不可迭代对象 pass Python内置str、list、tuple、dict、set、file都是可迭代对象.然后出了数字类型和函数之外都是可迭代对象 迭代器对象 具有 __iter__ 以及 __next__ 方法的叫做迭代器对象 s = 'nick' # 可迭代对象,不属于迭代器对象 s.__iter__() lt = [1, 2, 3] # 可迭代对象,不属于迭代器对象 dic = {'a': 1, 'b': 2} # 可迭代对象,不属于迭代器对象 tup = (1,) # 元组只有一个元素必须得加逗号# 可迭代对象,不属于迭代器对象 se = {1, 2, 3} #

1、output迭代器：一次一步，只能向前，流水线上放着一批空的盒子，每次向前移动一个，往盒子里面塞一个东西。 2、input迭代器：一次一步，只能向前，流水线上放着一批零件，每次向前移动一个，可以看这个零件，但是不能加工。 3、forward迭代器：继承input迭代器，可以加工零件。 4、bidirectional迭代器：继承forward迭代器，可以向后移。 5、random access迭代器：继承bidirectional迭代器，可以一次移动多个位置。 转载于:https://www.cnblogs.com/nzbbody/p/3384832.html 来源： https://blog.csdn.net/weixin_30633507/article/details/99234470

容器的end()方法，返回一个迭代器，需要注意：这个迭代器不指向实际的元素，而是表示末端元素的下一个元素，这个迭代器起一个哨兵的作用，表示已经处理完所有的元素。 因此，在查找的时候，返回的迭代器，不等于end()，说明找到了目标。等于end()，说明检查了所有元素，没有找到目标。 转载于:https://www.cnblogs.com/nzbbody/p/3409317.html 来源： https://blog.csdn.net/weixin_30279751/article/details/99234489

1、为什么使用traits？ 　　考虑下面的需求，实现一个方法Advance(iter，n)，接收一个迭代器iter和移动距离n，将iter向前移动n个距离。 　　分析，因为存在不同类型的迭代器，做同一件事情，大家的能力不一样，做法当然不一样。有的迭代器可以一下子移到目标，有的迭代器只能一步一步移动，进行n次。因此，在方法内，必须要判断迭代器的类型，然后进行相应的操作。这种方法当然不好，运行期判断类型，需要核对继承层次中的每个类，效率差。有没有更好的办法呢？ 2、解决办法： 　　a、每个迭代器暴露一个接口，暴露自己类型的别名（使用typedef MyType Category），每个迭代器都使用相同的别名。再使用一个traits类模版，对迭代器封装，对外暴露迭代器类型的别名，也就是内部迭代器的类型别名（使用 typedef iter::Category Category）。 　　b、建立多个重载方法，根据迭代器类型的真名，进行重载。 　　c、在Advance方法内，对iter封装，根据类型别名，调用重载的方法。 3、分析编译器编译过程，看到Advance方法，对迭代器封装后，暴露的Category就是iter 的Category，也就是迭代器的类型别名，在编译时期，就可以知道迭代器的类型真名，因此，在编译期就可以确定下来调用哪个重载方法。 4、其实这种场景，如果是自己的代码

1、对于基于连续内存的容器，容器元素的增删，有可能会导致迭代器的失效。考虑： int main( int argc, char * argv[]) { vector < int > intVec; intVec.push_back( 1 ); intVec.push_back( 2 ); intVec.push_back( 3 ); vector < int >::iterator iter1 = intVec.begin(); vector < int >::iterator iter2 = iter1+ 1 ; vector < int >::iterator iter3 = iter1+ 2 ; int & ri = intVec[ 1 ]; int * p1 = &(* iter2); int * p2 = & ri; intVec.erase(iter1); printf( " iter2[%d]\n " ,* iter2); printf( " ri[%d]\n " ,ri); printf( " p1[%d]\n " ,* p1); printf( " p2[%d]\n " ,* p2); getchar(); } 2、通过Memory可以内存的变化，删除之前是 1 2 3 ，删除之后是2 3，删除iter1会导致迭代器iter2和ri失效。迭代器和引用，底层都是指针

一、迭代器iterator 迭代器是容器的一种遍历方式，每种容器都定义了自己的迭代器类型 声明一个迭代器： 　　 容器名称<数据类型>::iterator 迭代器名称 vector<int>::iterator it; map<int,int>::iterator it; set<int>::iterator it; ....... 使用： 　　for(it=vec.begin();it!=vec.end();it++) 　　　　cout<<*it; 二、vector 1、常用操作 empty()：判断向量是否为空，为空返回真，否则为假 begin()：返回向量（数组）的首元素地址 end()： 返回向量（数组）的末元素的下一个元素的地址 clear()：清空向量 front()：返回得到向量的第一个元素的数据 back()：返回得到向量的最后一个元素的数据 size()：返回得到向量中元素的个数 push_back(数据)：将数据插入到向量的尾部 pop_back()：删除向量尾部的数据 ..... 2、遍历方式 vector向量支持两种方式遍历，因为可以认为vector是一种动态数组，所以可以使用数组下标的方式，也可以使用迭代器 　　3、二维动态数组 #include <iostream> #include <vector> #include <list> #include

#函数 --2天 #函数的定义和调用 #def 函数名(形参) #函数体 #return返回值 #调用 函数名(实参) #站在形参的角度上:位置参数,*args,默认参数(陷阱),**kwargs #站在实参的角度上:按位置传,按照关键字传 #返回值:没有返回值 返回一个值 返回多个值 #接收返回值:没有返回值不接收,返回一个值作一个变量接收,返回多个值用一个变量或者对应数目变量接收#闭包函数 --在内部函数引用外部函数的变量#装饰器函数 --装饰器一定是闭包函数 #装饰器的作用 --在不改变原来函数的调用方式的情况下,在这个函数前后添加新的功能 #完美的符合了一个开发原则:开放封闭原则 #对扩展是开发的 #对修改是封闭的 #基础的装饰器 # from functools import wraps # def wrapper(func): # @wraps(func) # def inner(*args,**kwargs): # '''在函数被调用之前添加的代码''' # ret=func(*args,**kwargs) #func是被装饰的函数,在这里被调用 # return ret # return inner # 使用---@wrapper # def func(): #inner # pass #func name # 带参数的装饰器 def outer(形参): def