6.python（迭代器，装饰器，生成器，基本算法，正则）

一，迭代器

1.迭代器

(1)迭代器是访问集合元素的一种方式。迭代器对象从集合的第一个元素开始访问，知道所有的元素被访问完结束。迭代器只能往前不会后退.

 (2)对于原生支持随机访问的数据结构（如tuple、list），迭代器和经典for循环的索引访问相比并无优势，反而丢失了索引值（可以使用内建函数enumerate()找回这个索引值）。但对于无法随机访问的数据结构（比如set）而言，迭代器是唯一的访问元素的方式。 另外，迭代器的一大优点是不要求事先准备好整个迭代过程中所有的元素。迭代器仅仅在迭代到某个元素时才计算该元素，而在这之前或之后，元素可以不存在或者被销毁。这个特点使得它特别适合用于遍历一些巨大的或是无限的集合，比如几个G的文件，或是斐波那契数列等等。 迭代器更大的功劳是提供了一个统一的访问集合的接口，只要定义了__iter__()方法对象，就可以使用迭代器访问。

names =iter(['liu','yao','sb']) print(names) print(names.__next__()) print(names.__next__()) print('暂停') print(names.__next__()) 输出： <list_iterator objectat0x0000000000B2B6A0> liu yao 暂停 sb 

(2)__iter__() 返回迭代器对象本身

names =iter(['liu','yao','sb']) print(names.__iter__()) 输出： <list_iterator objectat0x00000000006DB6D8> 

2.生成器

从Python2.2起，生成器提供了一种简洁的方式帮助返回列表元素的函数来完成简单和有效的代码。

定义：一个函数调用时返回一个迭代器，那这个函数就叫做生成器（generator），如果函数中包含yield语法，那这个函数就会变成生成器 
它基于yield指令，允许停止函数并立即返回结果。
此函数保存其执行上下文，如果需要，可立即继续执行。..

def cash_money(amount):     whileamount >0:         amount -=100         yield100         print('随便取')    atm = cash_money(500) print(type(atm)) print(atm.__next__()) print('暂停') print(atm.__next__()) 输出 <class'generator'> 100 暂停 随便取 100 

作用：

这个yield的主要效果呢，就是可以使函数中断，并保存中断状态，中断后，代码可以继续往下执行，过一段时间还可以再重新调用这个函数，从上次yield的下一句开始执行。

3.yield异步

importtime defconsumer(name):     print("%s准备吃包子啦"%(name))     whileTrue:         baozi=yield         print("包子来了[%s],被[%s]吃了!"%(baozi,name)) defproducer(name):     c1=consumer('mayun')     c2=consumer('mahuateng')     c1.__next__()     c2.__next__()     print('%s要开始做包子啦'%(name))     foriinrange(1,10):         time.sleep(1)         print('做了两个包子')         c1.send(i)         c2.send(i) producer('yaoao') 

输出：

mayun准备吃包子啦 mahuateng准备吃包子啦 yaoao要开始做包子啦 做了两个包子 包子来了[1],被[mayun]吃了! 包子来了[1],被[mahuateng]吃了! 做了两个包子 包子来了[2],被[mayun]吃了! 包子来了[2],被[mahuateng]吃了! 做了两个包子 包子来了[3],被[mayun]吃了! 包子来了[3],被[mahuateng]吃了! 做了两个包子 包子来了[4],被[mayun]吃了! 包子来了[4],被[mahuateng]吃了! 做了两个包子 包子来了[5],被[mayun]吃了! 包子来了[5],被[mahuateng]吃了! 做了两个包子 包子来了[6],被[mayun]吃了! 包子来了[6],被[mahuateng]吃了! 做了两个包子 包子来了[7],被[mayun]吃了! 包子来了[7],被[mahuateng]吃了! 做了两个包子 包子来了[8],被[mayun]吃了! 包子来了[8],被[mahuateng]吃了! 做了两个包子 包子来了[9],被[mayun]吃了! 包子来了[9],被[mahuateng]吃了! 

二，装饰器

装饰器是函数，只不过该函数可以具有特殊的含义，装饰器用来装饰函数或类，使用装饰器可以在函数执行前和执行后添加相应操作。

装饰器是一个很著名的设计模式，经常被用于有切面需求的场景，较为经典的有插入日志、性能测试、事务处理等。装饰器是解决这类问题的绝佳设计，有了装饰器，我们就可以抽离出大量函数中与函数功能本身无关的雷同代码并继续重用。概括的讲，装饰器的作用就是为已经存在的对象添加额外的功能。

例：如果一个公司有运维部，开发部，测试部，设计部，等，并且公司具有基础平台架构，为公司各个部门提供数据库调用，资料查看，监控等。当这些部门想使用这些功能的时候，直接调用这些功能的接口就可以，如下：

######基础平台提供的功能------------ def 功能1()     print ('功能1') def 功能2()     print ('功能2') def 功能3()     print ('功能3') def 功能4()     print ('功能4') 

当运维部门调用的时候如下：

def 功能1() def 功能2() def 功能3() 

当开发部门调用的时候如下：

def 功能1() def 功能2() def 功能3() 

之后要为平台提供的所有功能添加验证机制，

基础平台提供如下功能接口：

1.让各个部门修改自己的代码

2.在每个部门实现的功能上加上代码

3.把验证代码变成函数 在每个功能上加入

4.为了追寻开放封闭原则

利用装饰器的功能实现

deflogin(func):     definner():         # 验证1         # 验证2         # 验证3         returnfunc()     returninner @login def功能1():     print'功能1' @login def功能2():     print'功能2' @login def功能3():     print'功能3' @login def功能4():     print'功能4' 

当各个部门执行def功能的时候

def login(func):     def inner():         # 验证1         returnfunc()     returninner @login def 功能1():     print'功能1' 

当调用功能1的时候 会先把功能1的函数名带入内存地址，之后会执行login函数，func为功能1，之后inner会将功能1的参数带入等待执行inner的验证功能后，会将参数交给func执行功能1的命令。

三，递归

递归函数

在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。

defcalc(n):     print(n)     ifn/2>1:         res=calc(n/2)         print('res',res)     print('N',n)     returnn   calc(10) 

四，二分法

二分法是能够更快更好的去取得值所在的位置。

defbinary_search(data_source,find_n):     mid=int(len(data_source)/2)     iflen(data_source)>=1:         ifdata_source[mid] > find_n:             print('data in left of [ID/033[35;1m %s/033[0m]'%data_source[mid])             binary_search(data_source[:mid],find_n)         elifdata_source[mid] < find_n:             print('data in right of [ID/033[32;1m %s/033[0m]'%data_source[mid])             binary_search(data_source[mid:],find_n)         else:             print('found find',data_source[mid])     else:         print('not found') if__name__=="__main__":     data=list(range(1,10000))     binary_search(data,1) 

五，斐波那契数列

斐波那契数列指的是这样的数列 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233，377，610，987，1597，2584，4181，6765，10946，17711，28657，46368

用python实现：

deffunc(arg1,arg2,stop):     ifarg1==0:         print(arg1)     arg3=arg1+arg2     print(arg3)     ifarg3 < stop:         func(arg2,arg3,stop) func(0,1,(100000)) 

六、二维数组

生成一个4*4的2维数组并将其顺时针旋转90度

data =[[colforcolinrange(4)]forrowinrange(4)] print('-----------------------') forr_index,rowinenumerate(data):     forc_indexinrange(r_index,len(row)):         tmp=data[c_index][r_index]         data[c_index][r_index]=row[c_index]         data[r_index][c_index]=tmp     print('----------------------')     forrindata:print(r) 

七。冒泡

它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。

例：将一个不规则的数组按从小到大的顺序进行排序

data =[10,4,33,21,54,3,8,11,5,22,2,1,17,13,6] print("原始:",data) previous =data[0] forjinrange(len(data)):     tmp=0     foriinrange(len(data)-1):         ifdata[i] > data[i+1]:             tmp=data[i]             data[i]=data[i+1]             data[i+1]=tmp     print(data) print("排序之后:",data) 

八、正则表达式

正则表达式是一个特殊的字符序列，它能帮助你方便的检查一个字符串是否与某种模式匹配。

Python 自1.5版本起增加了re 模块，它提供 Perl 风格的正则表达式模式。

re 模块使 Python 语言拥有全部的正则表达式功能。

compile 函数根据一个模式字符串和可选的标志参数生成一个正则表达式对象。该对象拥有一系列方法用于正则表达式匹配和替换。

re 模块也提供了与这些方法功能完全一致的函数，这些函数使用一个模式字符串做为它们的第一个参数。

1.导入模块

importre 

2.正则表达式匹配规则

1） 正则表达式修饰符 - 可选标志

正则表达式可以包含一些可选标志修饰符来控制匹配的模式。修饰符被指定为一个可选的标志。多个标志可以通过按位 OR(|) 它们来指定。如 re.I | re.M 被设置成 I 和 M 标志：

2） 正则表达式模式

模式字符串使用特殊的语法来表示一个正则表达式：

字母和数字表示他们自身。一个正则表达式模式中的字母和数字匹配同样的字符串。

多数字母和数字前加一个反斜杠时会拥有不同的含义。

标点符号只有被转义时才匹配自身，否则它们表示特殊的含义。

反斜杠本身需要使用反斜杠转义。

由于正则表达式通常都包含反斜杠，所以你最好使用原始字符串来表示它们。模式元素(如 r'/t'，等价于'//t')匹配相应的特殊字符。

下表列出了正则表达式模式语法中的特殊元素。如果你使用模式的同时提供了可选的标志参数，某些模式元素的含义会改变。（引用菜鸟教程）

正则表达式实例

字符匹配

字符类

特殊字符类

3.具有的方法：

1） re.match函数

re.match 尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match()就返回none。。

函数语法 ：

re.match(pattern, string, flags=0) 

注： 匹配成功re.match方法返回一个匹配的对象，否则返回None。

使用group(num) 或 groups() 匹配对象函数来获取匹配表达式。

案例1:

importre print(re.match('www','www.yaomr.com')) 显示如下： <_sre.SRE_Match object; span=(0,3), match='www'> 如果要显示匹配几个字符 print(re.match('www','www.yaomr.com').span()) 效果： 0,3) 如果匹配不到则返回: print(re.match('www','ww.yaomr.com')) 显示： None 

案例2：

显示匹配结果：

importre res = re.match('/d+','123uuasf') ifres:     print (res.group()) else:     print(None) 如果匹配成功显示： 123 如果匹配失败： None 

2） re.search方法

re.search 扫描整个字符串并返回第一个成功的匹配。 函数语法 同re.match方法

案例1：

print(re.search('www','www.yaomr.com').span()) # 在起始位置匹配 print(re.search('yao','www.yaomr.com').span())        # 不在起始位置匹配 

返回：

案例2：

>>> obj =re.search('/d+','u123uu888asf') >>> print(obj) <_sre.SRE_Match object; span=(1,4), match='123'> >>> obj.group() '123' 

3） re.match与re.search的区别

re.match只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回None；而re.search匹配整个字符串，直到找到一个匹配。

实例：

#!/usr/bin/python importre line ="Cats are smarter than dogs";   matchObj =re.match( r'dogs', line, re.M|re.I) ifmatchObj:    print"match --> matchObj.group() : ", matchObj.group() else:    print"No match!!"   matchObj =re.search( r'dogs', line, re.M|re.I) ifmatchObj:    print"search --> matchObj.group() : ", matchObj.group() else:    print"No match!!" 

4） re.sub方法

Python 的re模块提供了re.sub用于替换字符串中的匹配项。

语法：

re.sub(pattern, repl,string, max=0)

返回的字符串是在字符串中用 RE 最左边不重复的匹配来替换。如果模式没有发现，字符将被没有改变地返回。

可选参数 count 是模式匹配后替换的最大次数；count 必须是非负整数。缺省值是 0 表示替换所有的匹配。

实例：

#!/usr/bin/python importre   phone ="2004-959-559 # This is Phone Number"   # Delete Python-style comments num =re.sub(r'#.*$', "", phone) print"Phone Num : ", num   # Remove anything other than digits num =re.sub(r'/D', "", phone)    print"Phone Num : ", num 

案例：

content ="123abc456" new_content =re.sub('/d+','sb', content) # new_content = re.sub('/d+', 'sb', content, 1) printnew_content 

5） group和groups

a ="123abc456" printre.search("([0-9]*)([a-z]*)([0-9]*)", a).group() printre.search("([0-9]*)([a-z]*)([0-9]*)", a).group(0) printre.search("([0-9]*)([a-z]*)([0-9]*)", a).group(1) printre.search("([0-9]*)([a-z]*)([0-9]*)", a).group(2) printre.search("([0-9]*)([a-z]*)([0-9]*)", a).groups() 

6 ) findall(pattern, string, flags=0)

如果想要匹配到字符串中所有符合条件的元素，则需要使用 findall。

importre obj =re.findall('/d+','fa123uu888asf') printobj 

7) split(pattern, string, maxsplit=0, flags=0)

通过正则表达式将字符串分离。如果用括号将正则表达式括起来，那么匹配的字符串也会被列入到list中返回。maxsplit是分离的次数，maxsplit=1分离一次，默认为0，不限制次数。

>>> re.split('/W+','Words, words, words.') ['Words','words','words', ''] 

来自为知笔记(Wiz)