第 4 天 迭代器、生成器、装饰器、正则表达式

一、迭代器

迭代器 适合遍历一些巨大或无限的集合,如几个G的文件!

迭代器的特点:

1、访问者不用关心迭代器的内部结构,仅需要通过next()方法不断地去取下一个内容!
2、不能随机访问集合中的,某个值,只能从头到尾访问!
3、访问到一半时不能往回退!
4、便于循环比较大的数据集合,节省了内存!
 1 >>> name = iter(['jiac','piter','kuga']) ##创建一个迭代器
 2 >>> name.__next__()
 3 'jiac'
 4 >>> name.__next__()
 5 'piter'
 6 >>> name.__next__()
 7 'kuga'
 8 >>> name.__next__()##当遍历完集合中的元素后!
 9 Traceback (most recent call last):
10   File "<stdin>", line 1, in <module>
11 StopIteration
12 >>>

二、生成器

一个函数被调用时返回一个迭代器,那这个函数就叫生成器(generator);
如果函数中包含yield语法,那这个函数就会变成生成器!
 1  生成器cash_miney                                      
 2  def cash_money(arg):                                  
 3      while arg > 0:                                    
 4          arg -= 100                                    
 5          yield 100                                     
 6          print("来要钱了!")                           
 7                                                        
 8  a = cash_money(500)                                   
 9  print(type(a))                                        
10 ## 返回迭代器                                          
11 print(a.__next__()) #100                               
12 print(a.__next__()) #100                               
13 print(a.__next__()) #100                               
14 print(a.__next__()) #100                               
15 print(a.__next__()) #100                               
16 print(a.__next__())#执行时报错如下:(迭代完成后)        
17 Traceback (most recent call last):                     
18   File "F:/51python/day4/demo.py", line 16, in <module>
19     print(a.__next__())                                
20 StopIteration                                          

yield实现单线程的异步并发:(串行的程序中实现并行的效果!

 1 #消费者
 2 def consumer(name):
 3     print("%s准备吃包子!"%name)
 4     while True:
 5         b = yield ##接收send()方法的值
 6         print("包子[%s]来了!被[%s]吃了"%(b,name))
 7 
 8 #生产者
 9 def producer(name):
10     c1 = consumer("A")
11     c2 = consumer("B")
12     c1.__next__() ##输出yield的返回值
13     c2.__next__() ##输出yield的返回值
14     print("老子开始准备做包子啦!")
15     for i in range(10):
16         time.sleep(1)
17         print("已经做了2 个包子了!")
18         c1.send(i) ##把i的值发送给yield
19         c2.send(i) ##把i的值发送给yield
20 
21 producer("me")
22 
23 ###打印输出如下:###
24 A准备吃包子!
25 B准备吃包子!
26 老子开始准备做包子啦!
27 已经做了2 个包子了!
28 包子[0]来了!被[A]吃了
29 包子[0]来了!被[B]吃了
30 已经做了2 个包子了!
31 包子[1]来了!被[A]吃了
32 包子[1]来了!被[B]吃了
33 已经做了2 个包子了!
34 包子[2]来了!被[A]吃了
35 包子[2]来了!被[B]吃了
36 已经做了2 个包子了!
37 包子[3]来了!被[A]吃了
38 包子[3]来了!被[B]吃了
39 已经做了2 个包子了!
40 包子[4]来了!被[A]吃了
41 包子[4]来了!被[B]吃了
42 已经做了2 个包子了!
43 包子[5]来了!被[A]吃了
44 包子[5]来了!被[B]吃了
45 已经做了2 个包子了!
46 包子[6]来了!被[A]吃了
47 包子[6]来了!被[B]吃了
48 已经做了2 个包子了!
49 包子[7]来了!被[A]吃了
50 包子[7]来了!被[B]吃了
51 已经做了2 个包子了!
52 包子[8]来了!被[A]吃了
53 包子[8]来了!被[B]吃了
54 已经做了2 个包子了!
55 包子[9]来了!被[A]吃了
56 包子[9]来了!被[B]吃了

三、装饰器

 1 def login(func):
 2     print("登陆验证!")
 3 
 4 def login(func):
 5     print("登陆验证!")
 6     return func ##返回内存地址!
 7 
 8 def tv():
 9     print("tv模块!")
10 
11 tv()#结果
12 tv #表示函数的内存地址!
13 
14 ##打印输出###
15 tv模块!
 1 def login(func):
 2     print("登陆验证!")
 3     return func ##返回内存地址!
 4 
 5 @login
 6 def tv(name):
 7     print("this [%s] pages"%name)
 8 
 9 tv("alex") ##结果
10 
11 ##打印输出##
12 登陆验证!
13 this [alex] pages
 1 def login(func):
 2     def inner(arg):
 3         print("登陆验证!")
 4         func(arg)
 5     return inner ##返回内存地址!
 6 
 7 @login
 8 def tv(name):
 9     print("this [%s] is TV pages"%name)
10 
11 @login
12 def move(name):
13     print("this [%s] Move pages"%name)
14 
15 
16 tv("alex") ##结果
17 move('keke')
18 
19 ##打印输出##
20 登陆验证!
21 this [alex] is TV pages
22 登陆验证!
23 this [keke] Move pages

算法之二分查找:

 1 def mid_search(data_source,find_n):
 2 
 3     mid = int(len(data_source)/2)
 4     if len(data_source) >= 1:
 5         if data_source[mid] > find_n:
 6             print("数据[%s]在右边"%data_source[mid])
 7             mid_search(data_source[:mid],find_n)
 8         # print(data_source[:mid])
 9         elif data_source[mid] < find_n:
10             print("数据[%s]在左边"%data_source[mid])
11             mid_search(data_source[mid:],find_n)
12         else:
13             print("found find_s",data_source[mid])
14     else:
15             print("cannot found find_s",data_source[mid])
16 
17 if __name__ == "__main__":
18     data = list(range(1,6000000))
19 
20     mid_search(data,1) ##数据源,查找的值
21 
22 ##打印输出##
23 数据[3000000]在右边
24 数据[1500000]在右边
25 数据[750000]在右边
26 数据[375000]在右边
27 数据[187500]在右边
28 数据[93750]在右边
29 数据[46875]在右边
30 数据[23438]在右边
31 数据[11719]在右边
32 数据[5860]在右边
33 数据[2930]在右边
34 数据[1465]在右边
35 数据[733]在右边
36 数据[367]在右边
37 数据[184]在右边
38 数据[92]在右边
39 数据[46]在右边
40 数据[23]在右边
41 数据[12]在右边
42 数据[6]在右边
43 数据[3]在右边
44 数据[2]在右边
45 found find_s 1

四、递归操作

递归操作,自身调用自身的函数.

 1 def calc(arg):
 2     print(arg)
 3     if arg/2 >1:
 4         res = calc(arg/2) ##递归调用calc()函数自己
 5         return res ##
 6 
 7 calc(100)
 8 
 9 ##打印输出##
10 100
11 50.0
12 25.0
13 12.5
14 6.25
15 3.125
16 1.5625

五、正则表达式

(匹配规程,数据源)
re.match(pattern,data_source)
 1 import re
 2 
 3 m = re.match("abc","abcdfe")
 4 
 5 print(m.group()) ##返回匹配的值
 6 
 7 ##打印输出##
 8 abc
 9 
10 m = re.match("[0-9][0-9]","41ab56cd") #匹配所有的数字
11 #match 方法从头开始匹配
12 if m:
13     print(m.group())
14 
15 ##打印输出##
16 41
17 
18 m = re.findall("[0-9]{0,10}","41ab56cd") #匹配所有的数字使用findall方法(匹配0次到10次)
19 if m:
20     print(m)
21 
22 ##打印输出##
23 ['41', '', '', '56', '', '', '']
24 
25 
26 m = re.findall("[0-9]{1,10}","41ab56cd") #匹配所有的数字使用findall方法匹配1次到10次)
27 if m:
28     print(m)
29 
30 ##打印输出##
31 ['41', '56']
32 
33 m = re.findall("[a-zA-Z]{1,10}","41ab56cd") #匹配所有的字母使用findall方法
34 if m:
35     print(m)
36 
37 ##打印输出##
38 ['ab', 'cd']
39 
40 m = re.findall(".*","41ab56cd") #匹配所有的字符0次或多次使用findall方法
41 if m:
42     print(m)
43 
44 ##打印输出##
45 ['41ab56cd', '']
46 
47 m = re.findall("[a-zA-Z]+","41ab@#56。.cd") #匹配所有的字母一个或多个使用findall方法
48 if m:
49     print(m)
50 
51 ##打印输出##
52 ['ab', 'cd']
53 
54 m = re.search("@","41ab@#56。.cd") #匹配指定字符一个或多个使用search方法
55 if m:
56     print(m.group())
57 
58 ##打印输出##
59 @
60 
61 m = re.search("d+","41ab@#56。.cd") #匹配所有的字符一个或多个使用findall方法
62 if m:
63     print(m.group())
64 
65 ##打印输出##
66 41
67 
68 m = re.sub("d+","|","sad41ab@#56。.cd") #替换所有的数字一个或多个使用sub方法
69 if m:
70     print(m)
71 
72 ##打印输出##
73 sad|ab@#|。.cd
74 
75 m = re.sub("d+","|","sad41ab@#56。.cd",count=1) #替换第一个含有数字的字符串,替换一次或多次使用sub方法
76 if m:
77     print(m)
78 
79 ##打印输##
80 sad|ab@#56。.cd
81 
82 
83#匹配小数出##84 a = "-8.0*173545.88095238098"
85 print(re.findall("d+.d+",a))
86   
87 ##打印输出##
88 ['8.0', '173545.88095238098']
原文地址:https://www.cnblogs.com/zhang252709/p/5185627.html