Python学习笔记 (4) ：迭代器、生成器、装饰器、递归、正则表达式等

迭代器

迭代器是访问集合元素的一种方式。迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退，不过这也没什么，因为人们很少在迭代途中往后退。另外，迭代器的一大优点是不要求事先准备好整个迭代过程中所有的元素。迭代器仅仅在迭代到某个元素时才计算该元素，而在这之前或之后，元素可以不存在或者被销毁。这个特点使得它特别适合用于遍历一些巨大的或是无限的集合，比如几个G的文件

特点：

访问者不需要关心迭代器内部的结构，仅需通过next()方法不断去取下一个内容
不能随机访问集合中的某个值，只能从头到尾依次访问
访问到一半时不能往回退
便于循环比较大的数据集合，节省内存

 a=iter([1,2,3,4,5])

 print(a.__next__())

 print(a.__next__())

 print(a.__next__())

 print(a.__next__())

 print(a.__next__())

迭代器

运行代码：

D:\Python34\python.exe C:/Users/AMTF/PycharmProjects/S12/day1/ifelse.py
1
2
3
4
5

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

 def cash_out(amount):

     while amount >0:

         amount -= 1

         yield 1

         print("擦，又来取钱了。。。败家子！")

 ATM = cash_out(5)

 print("取到钱 %s 万" % ATM.__next__())

 print("花掉花掉!")

 print("取到钱 %s 万" % ATM.__next__())

 print("取到钱 %s 万" % ATM.__next__())

 print("花掉花掉!")

 print("取到钱 %s 万" % ATM.__next__())

 print("取到钱 %s 万" % ATM.__next__())

 print("取到钱 %s 万" % ATM.__next__()) #到这时钱就取没了,再取就报错了

 print("取到钱 %s 万" % ATM.__next__())

生成器

运行代码：

取到钱 1 万
花掉花掉!
擦，又来取钱了。。。败家子！
取到钱 1 万
擦，又来取钱了。。。败家子！
取到钱 1 万
花掉花掉!
擦，又来取钱了。。。败家子！
取到钱 1 万
擦，又来取钱了。。。败家子！
取到钱 1 万
擦，又来取钱了。。。败家子！
Traceback (most recent call last):
File "C:/Users/AMTF/PycharmProjects/S12/day1/ifelse.py", line 18, in <module>
print("取到钱 %s 万" % ATM.__next__()) #到这时钱就取没了,再取就报错了
StopIteration

作用：

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

 import time

 def consumer(name):

     print("%s 准备吃包子了！"%name)

     while True:

         baozi=yield

         print(("包子【%s】来了，被[%s]吃了")%(baozi,name))

 def producer(name):

     c=consumer("a")

     c2=consumer("b")

     c.__next__()

     c2.__next__()

     print("老子开始做包子了！")

     for i in range(1,4):

         time.sleep(1)

         print("做了两个包子！")

         c.send(i)

         c2.send(i)

 producer("alex")

使用yield实现单线程的一部并发效果

运行代码：

a 准备吃包子了！
b 准备吃包子了！
老子开始做包子了！
做了两个包子！
包子【1】来了，被[a]吃了
包子【1】来了，被[b]吃了
做了两个包子！
包子【2】来了，被[a]吃了
包子【2】来了，被[b]吃了
做了两个包子！
包子【3】来了，被[a]吃了
包子【3】来了，被[b]吃了

装饰器

 def login(canshu):

     print("已经通过验证")

     return canshu

 def tv():

     print("%s已经进入tv模式")

 tv=login(tv)

 tv()

装饰器

运行代码：
已经通过验证
%s已经进入tv模式

 a=[[x for x in range(4)] for y in range(4)]

 for i in a:print(i)

 jishu2=0

 for jishu1 in range(4):

     jishu2=jishu1+1

     for jishu2 in range(jishu2,4):

         a[int(jishu1)][int(jishu2)],a[int(jishu2)][int(jishu1)]=a[int(jishu2)][int(jishu1)],a[int(jishu1)][int(jishu2)]

 print("\n")

 for y in a:print(y)

二维数组旋转90度

运行代码：

[0, 1, 2, 3]
[0, 1, 2, 3]
[0, 1, 2, 3]
[0, 1, 2, 3]

[0, 0, 0, 0]
[1, 1, 1, 1]
[2, 2, 2, 2]
[3, 3, 3, 3]

递归：

 def digui(arg1,arg2,jieshu3):

     arg3=arg1+arg2

     if arg1==0:

         print(arg1,arg2,end=' ')

     print(arg3,end=" ")

     if jieshu3>arg3:

         return digui(arg2,arg3,jieshu3)

     return

 digui(0,1,30)

递归

运行代码：
0 1 1 2 3 5 8 13 21 34

正则表达式：

 import re

 f=re.sub("\d+","#","d12li3weig4u444o5555g&g66666&6EFss",count=5)

 if f:

     print(f)

 f1=re.match("[0-9]{0,10}","4334ge4325ftt&^%kjf35")

 if f1:

     print(f1.group())

 f2=re.findall("[0-9]{1,10}","4334ge4325asdfa&*%ff35")

 if f1:

     print(f2)

 f3=re.findall("[a-zA-Z]+","4334ge4325asdfa&*%ff35")

 if f1:

     print(f3)

 f4=re.findall("[*]+","4334ge4**325asdfa&*%ff35")

 if f1:

     print(f4)

正则表达式

运行代码：

d#li#weig#u#o#g&g66666&6EFss
4334
['4334', '4325', '35']
['ge', 'asdfa', 'ff']
['**', '*']

匹配格式

模式描述

^匹配字符串的开头

$匹配字符串的末尾。

.匹配任意字符，除了换行符，当re.DOTALL标记被指定时，则可以匹配包括换行符的任意字符。

[...]用来表示一组字符,单独列出：[amk] 匹配 'a'，'m'或'k'

[^...]不在[]中的字符：[^abc] 匹配除了a,b,c之外的字符。

re*匹配0个或多个的表达式。

re+匹配1个或多个的表达式。

re?匹配0个或1个由前面的正则表达式定义的片段，非贪婪方式

re{ n}

re{ n,}精确匹配n个前面表达式。

re{ n, m}匹配 n 到 m 次由前面的正则表达式定义的片段，贪婪方式

a| b匹配a或b

(re)G匹配括号内的表达式，也表示一个组

(?imx)正则表达式包含三种可选标志：i, m, 或 x 。只影响括号中的区域。

(?-imx)正则表达式关闭 i, m, 或 x 可选标志。只影响括号中的区域。

(?: re)类似 (...), 但是不表示一个组

(?imx: re)在括号中使用i, m, 或 x 可选标志

(?-imx: re)在括号中不使用i, m, 或 x 可选标志

(?#...)注释.

(?= re)前向肯定界定符。如果所含正则表达式，以 ... 表示，在当前位置成功匹配时成功，否则失败。但一旦所含表达式已经尝试，匹配引擎根本没有提高；模式的剩余部分还要尝试界定符的右边。

(?! re)前向否定界定符。与肯定界定符相反；当所含表达式不能在字符串当前位置匹配时成功

(?> re)匹配的独立模式，省去回溯。

\w匹配字母数字

\W匹配非字母数字

\s匹配任意空白字符，等价于 [\t\n\r\f].

\S匹配任意非空字符

\d匹配任意数字，等价于 [0-9].

\D匹配任意非数字

\A匹配字符串开始

\Z匹配字符串结束，如果是存在换行，只匹配到换行前的结束字符串。c

\z匹配字符串结束

\G匹配最后匹配完成的位置。

\b匹配一个单词边界，也就是指单词和空格间的位置。例如， 'er\b' 可以匹配"never" 中的 'er'，但不能匹配 "verb" 中的 'er'。

\B匹配非单词边界。'er\B' 能匹配 "verb" 中的 'er'，但不能匹配 "never" 中的 'er'。

\n, \t, 等.匹配一个换行符。匹配一个制表符。等

\1...\9匹配第n个分组的子表达式。

\10匹配第n个分组的子表达式，如果它经匹配。否则指的是八进制字符码的表达式。

　　

正则表达式常用5种操作

re.match(pattern, string)　　　　 # 从头匹配

re.search(pattern, string)　　　　# 匹配整个字符串，直到找到一个匹配

re.split()　　　　　　　　　　　　# 将匹配到的格式当做分割点对字符串分割成列表

秒客网

Python学习笔记 (4) ：迭代器、生成器、装饰器、递归、正则表达式等

相关文章