Python学习(三)：迭代器、生成器、装饰器、递归、算法、正则

1、迭代器　　

　　迭代器是访问集合的一种方式，迭代对象从集合的第一个元素开始访问，直到元素被访问结束，迭代器只能往前不能后退，最大的优点是不要求事先准备好整个迭代过程中的元素，这个特点使得它特别适合用于遍历一些巨大的或是无限的集合。
　　特点：
　　　　访问者不需要关心迭代器内部的结构，仅需通过next()方法不断去取下一个内容
　　　　不能随机访问集合中的某个值，只能从头到尾依次访问
　　　　访问到一半时不能往回退
　　　　便于循环比较大的数据集合，节省内存

　　使用：

　　　　#生成迭代器：
　　　　name = iter(['d','c','b','a',])
　　　　print(name.__next__())
　　　　print(name.__next__())
　　　　print(name.__next__())
　　　　print(name.__next__())

　　　　f = open("test.text","r")
　　　　for line in f: #已迭代的方式读取文件，节省内存
　　　　　　print(line)

2、生成器

　　一个函数调用时返回一个迭代器，那这个函数就叫做生成器(generator)，如果函数中包含yield语法，那这个函数就会变成生成器

　　作用：
　　　　yield可以使函数中断，并保存中断状态，中断后，代码可以继续往下执行，过一段时间还可以再重新调用这个函数，从上次yield的下一句开始执行。
　　　　相当于生成器函数生成值后自动挂起并暂停他们的执行和状态，他的本地变量将保存状态信息，这些信息在函数恢复时将再度有效。

 import time
 def Consumer(name):
     print("%s 准备吃包子了！" %name)
     while True:
         baozi = yield
         print("包子%s来了，被%s吃了" %(baozi,name))

 def Producer():
     c = Consumer('A')
     c2 = Consumer('B')
     c.__next__()
     c2.__next__()
     print("包子已经开始制作！")
     for i in range(2):
         time.sleep(1)
         print("做了两个包子")
         c.send(i)
         c2.send(i)

 Producer()

　　上述代码，首先执行的Producer函数，然后c、c2分别执行Consumer函数，由于函数中yield，所以该函数挂起，通过next打印第一个print，遇到yield再次挂起函数。继续执行Producer的代码，之后通过send再次调用Consumer函数(send是发送参数给yield)，然后继续执行之前中断位置后面的代码。

3、装饰器

 #!/usr/bin/env python
 # coding=utf-
 def outer(fun):
     def wrapper():
         print(')
         fun()
         print(')
     return wrapper

 @outer
 def Func1():
     print("Func1")

 @outer
 def Func2():
     print("Func2")

 @outer
 def Func3():
     print("Func3")
 Func1()
 Func2()
 Func3()

　　上述代码outer就是一个装饰器，其中outer是名字，fun是参数。
　　当代码读到@outer时会将下面的函数名也就是Func1就等同于装饰器的参数fun，也就是把Func1传给了fun
　　于是fun()就被换成了Func1
　　然后执行Func1()就是执行替换后的wrapper函数
　　#@outer相当于outer(Func1)，装饰器作用是扩展代码

4、递归

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

 #!/usr/bin/env python
 # coding=utf-8
 def Fibonacci(arg1,arg2,stop):
     if arg1 == 0:
         print(arg1)
         print(arg2)
     arg3 = arg1 + arg2
     if arg3 < stop:
         print(arg3)
         return Fibonacci(arg2,arg3,stop)
     else:
         return

 #代码执行
 Fibonacci(0,1,1000)

 #0是开始的第一个数字，1是开始的第二个数字，1000是结束值。

通过递归打印菲波那切数列

 5、算法基础

　　5.1  二分查找

#!/usr/bin/env python
# coding=utf-8

import sys
def TwoPointsFind(NumberDataBase,FindNumber,SearchNumber = 1):
    #取数字列表的中间值
    if len(NumberDataBase) > 1:
        print("第%s次查找：" %SearchNumber)
        MiddleIndex = int(len(NumberDataBase)/2)
        MiddleNumber = NumberDataBase[MiddleIndex]
        #如果中间值等于要查找的数字
        if MiddleNumber == FindNumber:
            sys.exit("找到了。" )
        #如果中间值大于要查找的数字，说明要查找的数字在数字集合的左半部分
        elif MiddleNumber > FindNumber:
            #取集合的左半部分，并递归二分查找函数
            SearchNumber += 1
            return TwoPointsFind(NumberDataBase[:MiddleIndex],FindNumber,SearchNumber)
        else:#如果中间值小于要查找的数字，说明要查找的数字在数字集合的右半部分
            # 取集合的右半部分，并递归二分查找函数
            SearchNumber += 1
            return TwoPointsFind(NumberDataBase[MiddleIndex:],FindNumber,SearchNumber)
    else:
        print("没有找到")

FindNumber = 50
NumberDataBase = list(range(1,60))
TwoPointsFind(NumberDataBase,FindNumber)

二分查找某个数据

　　　　二分查找可分段查询数据，查找速度快，节省内存。

　　5.2 二维数组旋转九十度

#!/usr/bin/env python
# coding=utf-8

RowColNum = 7
data = [[col for col in range(RowColNum)] for row in range(RowColNum)]
for row in data:
    print(row)

print("---------------替换后----------------")
for i in range(len(data)-1):
    for j in range(i+1,len(data)):
        Before = data[i][j]
        After = data[j][i]
        data[i][j] = After
        data[j][i] = Before

for i in data:
    print(i)

#代码执行结果
[0, 1, 2, 3, 4, 5, 6]
[0, 1, 2, 3, 4, 5, 6]
[0, 1, 2, 3, 4, 5, 6]
[0, 1, 2, 3, 4, 5, 6]
[0, 1, 2, 3, 4, 5, 6]
[0, 1, 2, 3, 4, 5, 6]
[0, 1, 2, 3, 4, 5, 6]
---------------替换后----------------
[0, 0, 0, 0, 0, 0, 0]
[1, 1, 1, 1, 1, 1, 1]
[2, 2, 2, 2, 2, 2, 2]
[3, 3, 3, 3, 3, 3, 3]
[4, 4, 4, 4, 4, 4, 4]
[5, 5, 5, 5, 5, 5, 5]
[6, 6, 6, 6, 6, 6, 6]
#旋转九十度真正做的是列表的value替换，不难发现替换规律是阶梯互反替换，即01与10,02与20,03与30,04与40,05与50,06与60,12与21,13与31,14与41.....一次类推到56与65。代码可更改RowColNum值，已达到最多层次替换。

二维数组代码

　　5.3 冒泡排序

 #!/usr/bin/env python
 #coding=utf-8
 DataList = [1,2,2,65,3,55,3,5,54,3,54,3,4,534,5435,234]
 #DataList一共有N个数据，那么就要经过N-1次排序才能完成从小到大排序
 for j in range(1,len(DataList)):
     #从第一个数据开始，依次和下一个数据进行比较
     for i in range(len(DataList)-j):
         #如果本次数据大于下一个数据，将本次数据与下次数据调换位置
         if DataList[i] > DataList[i+1]:
             SmallTmp = DataList[i+1]
             DataList[i+1] = DataList[i]
             DataList[i] = SmallTmp
 print(DataList)

冒泡排序

6、正则入门

　　三十分钟正则表达式>>点我

 #!/usr/bin/env python
 #coding=utf-8

 import re
 #match：从开头找，如果开头不匹配则返回None
 result1 = re.match('\d+','11112421adsafefrqweadfadfsafdqdf')
 #search：是遍历，直到找到为止，找到即终止
 result2 = re.search('\d+','ds2ad213131safe22frqweadfadfsafdqdf')
 #findall：查找所有的匹配值，返回的是一个列表
 result3 = re.findall('\d+','11112421adsafefrqw3ea432dfadfsafdqdf')
 #匹配1到3，出现1到5次，*零到多个  ？零或者一  +大于等于1
 result4 = re.findall('[1-3]{1,5}','11112421adsafefrqw3ea432dfadfsafdqdf')
 Before = "11112421adsafefrqw3ea432dfadfsafdqdf"
 #sun：替换，将a替换成T，替换6个
 After = re.sub("a","T",Before,count=6)
 if result1:
     print(result1.group())
 if result2:
     print(result2.group())
 if result3:
     print(result3)
 if result4:
     print(result4)
 print(Before,After)
　 #*零到多个  ？零或者一  +大于等于1 ^匹配开头 $匹配结尾 .匹配任意字符