zoukankan      html  css  js  c++  java
  • 第 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']
  • 相关阅读:
    为什么人们普遍选择城市而非农村
    风物长宜放眼量-创业潮比雾霾消散的要快
    一眼看请考研的目的-本质上的第二次高考
    京都城门考
    翻译的很好的一篇android mediaplayer
    Android MediaProvider数据库模式
    android 多媒体数据库详解
    android usb挂载分析---vold处理内核消息
    android usb挂载分析
    android usb挂载分析---MountService启动
  • 原文地址:https://www.cnblogs.com/zhang252709/p/5185627.html
Copyright © 2011-2022 走看看