python协程函数、递归、匿名函数与内置函数使用、模块与包

目录：

• 协程函数（yield生成器用法二）
• 面向过程编程
• 递归
• 匿名函数与内置函数的使用
• 模块
• 包
• 常用标准模块之re（正则表达式） 

一、协程函数（yield生成器用法二）

1、生成器的语句形式

a.生成器相关python函数、装饰器、迭代器、生成器，我们是如何使用生成器的。一个生成器能暂停执行并返回一个中间的结果这就是 yield 语句的功能 : 返回一个中间值给调用者并暂停执行。

我们的调用方式为yeild 1的方式，此方式又称为生成器的语句形式。

而使用生成器的场景：使用生成器最好的场景就是当你需要以迭代的方式去穿越一个巨大的数据集合。比如：一个巨大的文件/一个复杂的数据库查询等。

b.加强的生成器特性:

除了可以使用 next() 方法来获取下一个生成的值，用户还可以使用 send() 方法将一个新的或者是被修改的值返回给生成器。除此之外，还可以使用 close() 方法来随时退出生成器。

直接运行g.send()会报错，为生成器没有初始化,所以使用.send()，第一次必须使用.send(None)初始化生成器

2、生成器的表达式形式

a.简单用法，其实x = yield，就是一个表达式，yield不仅仅是一个语句，它还可以用.send()特性，做赋值操作。

b.通过生成式表达式优化列表解析：两者的语法非常相似，但生成器表达式返回的不是一个列表类型对象，而是一个生成器对象，生成器是一个内存使用友好的结构。

列表解析：

[expr for iter_var in iterable if cond_expr]

生成器表达式：

(expr for iter_var in iterable if cond_expr)

3、协程函数

　　在python中，协程函数就是使用了yield表达式形式的生成器。

　　它的优点为省内存，没有锁的概念、利用if判断，执行效率高。此概念主要应用在用户态线程中。

ps.协程的概念：

为了进一步减小内核态线程上下文切换的开销，于是又有了用户态线程设计，即纤程(Fiber)。如果连时钟阻塞、 线程切换这些功能我们都不需要了，自己在进程里面写一个逻辑流调度的东西。那么我们即可以利用到并发优势，又可以避免反复系统调用，还有进程切换造成的开销，分分钟给你上几千个逻辑流不费力。这就是用户态线程。

4、协程函数示例:仿grep -rl ‘python’ /root

ps.

a.有yield的函数，必须@init初始化(next(<g>))

b.这种写法，必须层层嵌套调用，不能漏下任何一行。

c. a目录结构：

二、面向过程编程

　　是一种流水线式的编程思路，是机械式。以上grep -rl ‘python‘ /root实例就是一个典型的面向过程编程。

1、优点：

程序的结构清晰，可以把复杂的问题简单

2、缺点：

扩展性差

3、应用场景：

linux内核，git，httpd

ps.本节只是浅浅的讨论一下，后续会有详细分析。

三、递归

递归算法是一种直接或者间接地调用自身算法的过程。在计算机编写程序中，递归算法对解决一大类问题是十分有效的，它往往使算法的描述简洁而且易于理解。

a.特点：
递归算法解决问题的特点：

• • 递归就是在过程或函数里调用自身。
  • 在使用递归策略时，必须有一个明确的递归结束条件，称为递归出口。
  • 递归算法解题通常显得很简洁，但递归算法解题的运行效率较低。
  • 在递归调用的过程当中系统为每一层的返回点、局部量等开辟了栈来存储。递归次数过多容易造成栈溢出等。

ps.所以一般不提倡用递归算法设计程序。

b.要求：

递归算法所体现的“重复”一般有三个要求：

• • 每次调用在规模上都有所缩小(通常是减半)；
  • 相邻两次重复之间有紧密的联系，前一次要为后一次做准备(通常前一次的输出就作为后一次的输入)；
  • 在问题的规模极小时必须用直接给出解答而不再进行递归调用，因而每次递归调用都是有条件的(以规模未达到直接解答的大小为条件)，无条件递归调用将会成为死循环而不能正常结束。

方式一：在函数调用自身

方式二：在过程里调用自身

 

 

 1、简单的递归示例

2、递归应用之二分法

#递归应用之二分法：

 

3、尾递归优化

待补全

四、匿名函数与内置函数的使用

 匿名函数就是不需要显式的指定函数，python中使用lambda 函数是一种快速定义单行的最小函数，可以用在任何需要函数的地方。

配合一些内置函数的使用，可以更加强大,但依旧为简单的函数:
支持lambda的内置函数如下:
max、min、zip、sorted
map、reduce、filter

匿名函数优点：

a. 程序一次行使用，所以不需要定义函数名，节省内存中变量定义空间
b. 如果想让程序更加简洁时。

1、常规使用

、max、min、zip、sort结合应用

max  max(sequence,key=<lambda 值:表达式>==func) 最大值

min   min(sequence,key=<lambda 值:表达式>==func) 最小值

zip    zip(sequence，sequence) 两个sequence的len()值必须相等，拉链函数，字典

sorted  sorted(可迭代对象,key=<lambda 值:表达式>==func，reverse=True ) 排序函数，默认从小到大，reverse反转

、map、reduce、filter结合应用

a.map  map(function, sequence[, sequence, ...]) -> list   

对sequence中的item依次执行function(item)，执行结果输出为list。

b.reduce  reduce(function, sequence[, initial]) -> value    

对sequence中的item顺序迭代调用function，函数必须要有2个参数。要是有第3个参数，则表示初始值，可以继续调用初始值，返回一个值。

python3中，需要python3中需要from functools import reduce才能调用

c.filter   filter(function or None, sequence) -> list, tuple, or string

对sequence中的item依次执行function(item)，将执行结果为True（！=0）的item组成一个List/String/Tuple（取决于sequence的类型）返回，False则退出（0），进行过滤。

d.map、reduce、filter应用示例：

　　实现5!+4!+3!+2!+1!

将100~200以内的质数挑选出来

五、模块

一个模块就是一个包含了python定义和声明的文件，文件名就是模块名字加上.py的后缀。

a.为何要使用模块？
如果你退出python解释器然后重新进入，那么你之前定义的函数或者变量都将丢失，因此我们通常将程序写到文件中以便永久保存下来，需要时就通过python test.py方式去执行，此时test.py被称为脚本script。
随着程序的发展，功能越来越多，为了方便管理，我们通常将程序分成一个个的文件，这样做程序的结构更清晰，方便管理。这时我们不仅仅可以把这些文件当做脚本去执行，还可以把他们当做模块来导入到其他的模块中，实现了功能的重复利用。

b.模块的搜索顺序：

• • 内存中已经加载的模块->内置模块->sys.path路径中包含的模块

c.模块分为三种：

• • 自定义模块
  • 内置模块（标准模块）
  • 开源模块

ps.需要特别注意的是：我们自定义的模块名不应该与系统内置模块重名

1、导入模块：

示例文件spam.py(执行文件同级目录)

• • import

a.模块可以包含可执行的语句和函数的定义，这些语句的目的是初始化模块，它们只在模块名第一次遇到导入import语句时才执行.(python的内存优化手段)
b.每个模块都是一个独立的名称空间，定义在这个模块中的函数，把这个模块的名称空间当做全局名称空间，这样我们在编写自己的模块时，就不用担心我们定义在自己模块中全局变量会在被导入时，与使用者的全局变量冲突.

ps.import导入时所做的事情：

1.产生新的名称空间
2.以新建的名称空间为全局名称空间，执行文件的代码
3.拿到一个模块名spam，指向spam.py产生的名称空间

• • form ... import ...

对比import spam，会将源文件的名称空间‘spam‘带到当前名称空间中，使用时必须是spam.名字的方式而from 语句相当于import，也会创建新的名称空间，但是将spam中的名字直接导入到当前的名称空间中，在当前名称空间中，直接使用名字就可以了.

对比import：

优点:方便，不用加前缀
缺点：容易跟当前文件的名称空间冲突

-加as，别名写法:　　　

from spam_mod import read1 as read

-多行写法：

from spam import (read1,

　　　　　　　　　　read2,

　　　　　　　　　　money)

-*写法：from spam import *， 把spam中所有的不是以下划线(_)开头的名字都导入到当前位置

ps.form ... import ...导入时所做的事情：

1.产生新的名称空间
2.以新建的名称空间为全局名称空间，执行文件的代码
3.直接拿到就是spam.py产生的名称空间中名字

2、__all__变量与__name__变量

• • __all__：可以使用__all__来控制*（用来发布新版本）
  • 

     1 from spam_mod import *
     2 print(money) # 加入的可以执行
     3 read1()  # 没有加入__all__的执行报错
     4 
     5 ‘‘‘
     6 结果：
     7 from the spam_mod.py
     8 1000
     9 Traceback (most recent call last):
    10   File "D:/old_boy/old_boy_17_05/模块/mod_py.py", line 167, in <module>
    11     read1()
    12 NameError: name ‘read1‘ is not defined
    13 ‘‘‘

    View Code

    ps.使用 importlib.reload(), e.g. import importlib; 可以重载被倒入的模块，这只能用于测试环境。

    • • __name__: 查看模块名,py文件被当作主函数运行时，__name__ 等于‘__main__‘，当做模块导入：__name__==<模块名>

    ps.作用：用来控制.py文件在不同的应用场景下执行不同的逻辑

  • 

     1 def fib(n):    # write Fibonacci series up to n
     2     a, b = 0, 1
     3     while b < n:
     4         print(b, end=‘ ‘)
     5         a, b = b, a+b
     6     print()
     7 
     8 def fib2(n):   # return Fibonacci series up to n
     9     result = []
    10     a, b = 0, 1
    11     while b < n:
    12         result.append(b)
    13         a, b = b, a+b
    14     return result
    15 
    16 if __name__ == "__main__":
    17     import sys
    18     fib(int(5))

    View Code

    3、编译模块

    　　python -O/-OO <文件>.py

    a.模块名区分大小写，foo.py与FOO.py代表的是两个模块
    b.你可以使用-O或者-OO转换python命令来减少编译模块的大小

    -O转换会帮你去掉assert语句
    -OO转换会帮你去掉assert语句和__doc__文档字符串
    由于一些程序可能依赖于assert语句或文档字符串，你应该在在确认需要的情况下使用这些选项。

    c.在速度上从.pyc文件中读指令来执行不会比从.py文件中读指令执行更快，只有在模块被加载时，.pyc文件才是更快的
    d.只有使用import语句是才将文件自动编译为.pyc文件，在命令行或标准输入中指定运行脚本则不会生成这类文件，因而我们可以使用compieall模块为一个目录中的所有模块创建.pyc文件

    模块可以作为一个脚本（使用python -m compileall）编译Python源
    python -m compileall /module_directory 递归着编译
    如果使用python -O -m compileall /module_directory -l则只一层
    命令行里使用compile()函数时，自动使用python -O -m compileall

    4、dir函数

    内建函数dir是用来查找模块中定义的名字，返回一个有序字符串列表
    import spam
    dir(spam)

    如果没有参数,dir()列举出当前定义的名字。dir()不会列举出内建函数或者变量的名字，它们都被定义到了标准模块builtin中，可以列举出它们，
    import builtins
    dir(builtins)

    • 六、包

      Packages are a way of structuring Python’s module namespace by using “dotted module names”

      包是一种通过使用‘.模块名’来组织python模块名称空间的方式。即所谓Package, 就是一堆module的集合，也就一堆.py文件。 你可以用如下方式来创建一个package

      a.无论是import形式还是from...import形式，凡是在导入语句中（而不是在使用时）遇到带点的，都要第一时间提高警觉：这是关于包才有的导入语法
      b.包是目录级的（文件夹级），文件夹是用来组成py文件（包的本质就是一个包含__init__.py文件的目录）
      c.import导入文件时，产生名称空间中的名字来源于文件，import 包，产生的名称空间的名字同样来源于文件，即包下的__init__.py，导入包本质就是在导入该文件

      包A和包B下有同名模块也不会冲突，如A.a与B.a来自俩个命名空间

      ps.注意事项

      a.关于包相关的导入语句也分为import和from ... import ...两种，但是无论哪种，无论在什么位置，在导入时都必须遵循一个原则：凡是在导入时带点的，点的左边都必须是一个包，否则非法。可以带有一连串的点，如item.subitem.subsubitem,但都必须遵循这个原则。
      b.对于导入后，在使用时就没有这种限制了，点的左边可以是包,模块，函数，类(它们都可以用点的方式调用自己的属性)。
      c.对比import item 和from item import name的应用场景：如果我们想直接使用name那必须使用后者。

      测试文件路径及文件内容

    • 

      文件内容：

    • 

       1 # #policy.py
       2 # def get():
       3 #     print(‘from policy.py‘)
       4 #
       5 # #versions.py
       6 # def create_resource(conf):
       7 #     print(‘from version.py: ‘,conf)
       8 #
       9 # #manage.py
      10 # def main():
      11 #     print(‘from manage.py‘)
      12 #
      13 # #models.py
      14 # def register_models(engine):
      15 #     print(‘from models.py: ‘,engine)

      View Code

      1、包的调用方式

      • • import
        • 

          1 # import glance.db.models
          2 # glance.db.models.register_models(‘mysql‘)
          3  ‘‘‘
          4  结果:
          5 from models.py:  mysql
          6  ‘‘‘

          View Code
          • form...import:需要注意的是from后import导入的模块，必须是明确的一个不能带点，否则会有语法错误，如：from a import b.c是错误语法
          • 

             1 ‘‘‘
             2 from... import...
             3 ‘‘‘
             4 from glance.db import models
             5 models.register_models(‘mysql‘)
             6 
             7 from glance.db.models import register_models
             8 register_models(‘mysql‘)
             9 ‘‘‘
            10 结果：
            11 from models.py:  mysql
            12 from models.py:  mysql
            13 ‘‘‘

            View Code
            • • form...import * 与__all__连用

            在api目录中的__init__中写入：

            

            1 #在__init__.py中定义
            2 x=10
            3 
            4 def func():
            5     print(‘from api.__init.py‘)
            6 
            7 __all__=[‘x‘,‘func‘,‘policy‘]

            View Code

            在packer.py文件中写入：

            

             1 # from glance.api import *
             2 # print(x)      # 在__init__中写了，可调用
             3 # print(func)   # 在__init__中写了，可执行
             4 # print(policy.get()) # __all__ 中写了，所以ok
             5 # print(versions.create_resource)  # 找不到
             6 ‘‘‘
             7 10
             8 <function func at 0x000000717E09C9D8>
             9 from policy.py
            10 None
            11 Traceback (most recent call last):
            12   File "D:/old_boy/old_boy_17_05/包/packer.py", line 86, in <module>
            13     print(versions.create_resource)
            14 NameError: name ‘versions‘ is not defined
            15 ‘‘‘

            View Code

            ps.不管是哪种方式，只要是第一次导入包或者是包的任何其他部分，都会依次执行包下的__init__.py文件(我们可以在每个包的文件内都打印一行内容来验证一下)，这个文件可以为空，但是也可以存放一些初始化包的代码。

            2、绝对导入和相对导入

            我们的最顶级包glance是写给别人用的，然后在glance包内部也会有彼此之间互相导入的需求，这时候就有绝对导入和相对导入两种方式： 

            绝对导入：以glance作为起始 

            相对导入：用.或者..的方式最为起始（只能在一个包中使用，不能用于不同目录内）

            例如：我们在glance/api/version.py中想要导入glance/cmd/manage.py

            • • 在glance/api/version.py
              • 

                1 # 绝对导入
                2 from glance.cmd import manage
                3 manage.main()
                4 
                5 #相对导入
                6 from ..db import models
                7 models.register_models(‘mysql‘)

                View Code
                • 在packer.py文件中写入：
                • 

                  1 from glance.api import versions
                  2  ‘‘‘
                  3  结果：
                  4 from manage.py
                  5 from models.py:  mysql
                  6  ‘‘‘

                  View Code

                  ps.测试结果：注意一定要在于glance同级的文件中测试。

                  特别需要注意的是：可以用import导入内置或者第三方模块（已经在sys.path中），但是要绝对避免使用import来导入自定义包的子模块(没有在sys.path中)，应该使用from... import ...的绝对或者相对导入,且包的相对导入只能用from的形式。

                • 七、常用标准模块之re（正则表达式） 

                  正则就是用一些具有特殊含义的符号组合到一起（称为正则表达式）来描述字符或者字符串的方法。或者说：正则就是用来描述一类事物的规则。（在Python中）它内嵌在Python中，并通过 re 模块实现。正则表达式模式被编译成一系列的字节码，然后由用 C 编写的匹配引擎执行。

                  1、常用匹配模式(元字符)

                • 模式	描述
                  ^	匹配字符串的开头
                  $	匹配字符串的末尾。
                  .	匹配任意字符，除了换行符，当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个分组的子表达式，如果它经匹配。否则指的是八进制字符码的表达式。

                • 1、匹配模式
                  

                   1 # =================================匹配模式=================================
                   2 #一对一的匹配
                   3 # ‘hello‘.replace(old,new)
                   4 # ‘hello‘.find(‘pattern‘)
                   5 
                   6 #正则匹配
                   7 import re
                   8 #\w与\W
                   9 print(re.findall(‘\w‘,‘hello egon 123‘)) #[‘h‘, ‘e‘, ‘l‘, ‘l‘, ‘o‘, ‘e‘, ‘g‘, ‘o‘, ‘n‘, ‘1‘, ‘2‘, ‘3‘]
                  10 print(re.findall(‘\W‘,‘hello egon 123‘)) #[‘ ‘, ‘ ‘]
                  11 
                  12 #\s与\S
                  13 print(re.findall(‘\s‘,‘hello  egon  123‘)) #[‘ ‘, ‘ ‘, ‘ ‘, ‘ ‘]
                  14 print(re.findall(‘\S‘,‘hello  egon  123‘)) #[‘h‘, ‘e‘, ‘l‘, ‘l‘, ‘o‘, ‘e‘, ‘g‘, ‘o‘, ‘n‘, ‘1‘, ‘2‘, ‘3‘]
                  15 
                  16 #\d与\D
                  17 print(re.findall(‘\d‘,‘hello egon 123‘)) #[‘1‘, ‘2‘, ‘3‘]
                  18 print(re.findall(‘\D‘,‘hello egon 123‘)) #[‘h‘, ‘e‘, ‘l‘, ‘l‘, ‘o‘, ‘ ‘, ‘e‘, ‘g‘, ‘o‘, ‘n‘, ‘ ‘]
                  19 
                  20 #\A与\D
                  21 print(re.findall(‘\Ahe‘,‘hello egon 123‘)) #[‘he‘],\A==>^
                  22 print(re.findall(‘123\Z‘,‘hello egon 123‘)) #[‘he‘],\Z==>$
                  23 
                  24 #\n与\t
                  25 print(re.findall(r‘\n‘,‘hello egon \n123‘)) #[‘\n‘]
                  26 print(re.findall(r‘\t‘,‘hello egon\t123‘)) #[‘\n‘]
                  27 
                  28 #^与$
                  29 print(re.findall(‘^h‘,‘hello egon 123‘)) #[‘h‘]
                  30 print(re.findall(‘3$‘,‘hello egon 123‘)) #[‘3‘]
                  31 
                  32 # 重复匹配：| . | * | ? | .* | .*? | + | {n,m} |
                  33 #.
                  34 print(re.findall(‘a.b‘,‘a1b‘)) #[‘a1b‘]
                  35 print(re.findall(‘a.b‘,‘a\nb‘)) #[]
                  36 print(re.findall(‘a.b‘,‘a\nb‘,re.S)) #[‘a\nb‘]
                  37 print(re.findall(‘a.b‘,‘a\nb‘,re.DOTALL)) #[‘a\nb‘]同上一条意思一样
                  38 
                  39 #*
                  40 print(re.findall(‘ab*‘,‘bbbbbbb‘)) #[]
                  41 print(re.findall(‘ab*‘,‘a‘)) #[‘a‘]
                  42 print(re.findall(‘ab*‘,‘abbbb‘)) #[‘abbbb‘]
                  43 
                  44 #?
                  45 print(re.findall(‘ab?‘,‘a‘)) #[‘a‘]
                  46 print(re.findall(‘ab?‘,‘abbb‘)) #[‘ab‘]
                  47 #匹配所有包含小数在内的数字
                  48 print(re.findall(‘\d+\.?\d*‘,"asdfasdf123as1.13dfa12adsf1asdf3")) #[‘123‘, ‘1.13‘, ‘12‘, ‘1‘, ‘3‘]
                  49 
                  50 #.*默认为贪婪匹配
                  51 print(re.findall(‘a.*b‘,‘a1b22222222b‘)) #[‘a1b22222222b‘]
                  52 
                  53 #.*?为非贪婪匹配：推荐使用
                  54 print(re.findall(‘a.*?b‘,‘a1b22222222b‘)) #[‘a1b‘]
                  55 
                  56 #+
                  57 print(re.findall(‘ab+‘,‘a‘)) #[]
                  58 print(re.findall(‘ab+‘,‘abbb‘)) #[‘abbb‘]
                  59 
                  60 #{n,m}
                  61 print(re.findall(‘ab{2}‘,‘abbb‘)) #[‘abb‘]
                  62 print(re.findall(‘ab{2,4}‘,‘abbb‘)) #[‘abb‘]
                  63 print(re.findall(‘ab{1,}‘,‘abbb‘)) #‘ab{1,}‘ ===> ‘ab+‘
                  64 print(re.findall(‘ab{0,}‘,‘abbb‘)) #‘ab{0,}‘ ===> ‘ab*‘
                  65 
                  66 #[]
                  67 print(re.findall(‘a[1*-]b‘,‘a1b a*b a-b‘)) #[]内的都为普通字符了，且如果-没有被转意的话，应该放到[]的开头或结尾
                  68 print(re.findall(‘a[^1*-]b‘,‘a1b a*b a-b a=b‘)) #[]内的^代表的意思是取反，所以结果为[‘a=b‘]
                  69 print(re.findall(‘a[0-9]b‘,‘a1b a*b a-b a=b‘)) #[]内的^代表的意思是取反，所以结果为[‘a=b‘]
                  70 print(re.findall(‘a[a-z]b‘,‘a1b a*b a-b a=b aeb‘)) #[]内的^代表的意思是取反，所以结果为[‘a=b‘]
                  71 print(re.findall(‘a[a-zA-Z]b‘,‘a1b a*b a-b a=b aeb aEb‘)) #[]内的^代表的意思是取反，所以结果为[‘a=b‘]
                  72 
                  73 #\# print(re.findall(‘a\\c‘,‘a\c‘)) #对于正则来说a\\c确实可以匹配到a\c,但是在python解释器读取a\\c时，会发生转义，然后交给re去执行，所以抛出异常
                  74 print(re.findall(r‘a\\c‘,‘a\c‘)) #r代表告诉解释器使用rawstring，即原生字符串，把我们正则内的所有符号都当普通字符处理，不要转义
                  75 print(re.findall(‘a\\\\c‘,‘a\c‘)) #同上面的意思一样，和上面的结果一样都是[‘a\\c‘]
                  76 
                  77 #():分组
                  78 print(re.findall(‘ab+‘,‘ababab123‘)) #[‘ab‘, ‘ab‘, ‘ab‘]
                  79 print(re.findall(‘(ab)+123‘,‘ababab123‘)) #[‘ab‘]，匹配到末尾的ab123中的ab
                  80 print(re.findall(‘(?:ab)+123‘,‘ababab123‘)) #findall的结果不是匹配的全部内容，而是组内的内容,?:可以让结果为匹配的全部内容
                  81 
                  82 #|
                  83 print(re.findall(‘compan(?:y|ies)‘,‘Too many companies have gone bankrupt, and the next one is my company‘))
                  84 #[‘companies‘, ‘company‘]

                  View Code

                  2、re模块提供的方法介绍

                  

                   1 # ===========================re模块提供的方法介绍===========================
                   2 import re
                   3 #1 findall
                   4 print(re.findall(‘e‘,‘alex make love‘) )   #[‘e‘, ‘e‘, ‘e‘],返回所有满足匹配条件的结果,放在列表里
                   5 #2 search
                   6 print(re.search(‘e‘,‘alex make love‘).group()) #e,只到找到第一个匹配然后返回一个包含匹配信息的对象,该对象可以通过调用group()方法得到匹配的字符串,如果字符串没有匹配，则返回None。
                   7 
                   8 #3 match
                   9 print(re.match(‘e‘,‘alex make love‘))    #None,同search,不过在字符串开始处进行匹配,完全可以用search+^代替match
                  10 
                  11 #4 split
                  12 print(re.split(‘[ab]‘,‘abcd‘))     #[‘‘, ‘‘, ‘cd‘]，先按‘a‘分割得到‘‘和‘bcd‘,再对‘‘和‘bcd‘分别按‘b‘分割
                  13 
                  14 #5 sub
                  15 print(‘===>‘,re.sub(‘a‘,‘A‘,‘alex make love‘)) #===> Alex mAke love，不指定n，默认替换所有
                  16 print(‘===>‘,re.sub(‘a‘,‘A‘,‘alex make love‘,1)) #===> Alex make love
                  17 print(‘===>‘,re.sub(‘a‘,‘A‘,‘alex make love‘,2)) #===> Alex mAke love
                  18 print(‘===>‘,re.sub(‘^(\w+)(.*?\s)(\w+)(.*?\s)(\w+)(.*?)$‘,r‘\5\2\3\4\1‘,‘alex make love‘)) #===> love make alex
                  19 
                  20 print(‘===>‘,re.subn(‘a‘,‘A‘,‘alex make love‘)) #===> (‘Alex mAke love‘, 2),结果带有总共替换的个数
                  21 
                  22 
                  23 #6 compile
                  24 obj=re.compile(‘\d{2}‘)
                  25 
                  26 print(obj.search(‘abc123eeee‘).group()) #12
                  27 print(obj.findall(‘abc123eeee‘)) #[‘12‘],重用了obj
                  28 
                  29 # 7 应用
                  30 print(re.findall("<(?P<tag_name>\w+)>\w+</(?P=tag_name)>","<h1>hello</h1>")) #[‘h1‘]
                  31 print(re.search("<(?P<tag_name>\w+)>\w+</(?P=tag_name)>","<h1>hello</h1>").group()) #<h1>hello</h1>
                  32 print(re.search("<(?P<tag_name>\w+)>\w+</(?P=tag_name)>","<h1>hello</h1>").groupdict()) #<h1>hello</h1>
                  33 
                  34 print(re.search(r"<(\w+)>\w+</(\w+)>","<h1>hello</h1>").group())
                  35 print(re.search(r"<(\w+)>\w+</\1>","<h1>hello</h1>").group())
                  36 
                  37 print(re.findall(r‘-?\d+\.?\d*‘,"1-12*(60+(-40.35/5)-(-4*3))")) #找出所有数字[‘1‘, ‘-12‘, ‘60‘, ‘-40.35‘, ‘5‘, ‘-4‘, ‘3‘]
                  38 
                  39 #使用|，先匹配的先生效，|左边是匹配小数，而findall最终结果是查看分组，所有即使匹配成功小数也不会存入结果
                  40 #而不是小数时，就去匹配(-?\d+)，匹配到的自然就是，非小数的数，在此处即整数
                  41 print(re.findall(r"-?\d+\.\d*|(-?\d+)","1-2*(60+(-40.35/5)-(-4*3))")) #找出所有整数[‘1‘, ‘-2‘, ‘60‘, ‘‘, ‘5‘, ‘-4‘, ‘3‘]

                  View Code

                  3、应用练习

                  

                  #########################应用练习###############################################
                  
                  
                  #_*_coding:utf-8_*_
                  #在线调试工具:tool.oschina.net/regex/#
                  import re
                  
                  s=‘‘‘
                  http://www.baidu.com
                  egon@oldboyedu.com
                  你好
                  010-3141
                  ‘‘‘
                  
                  #最常规匹配
                  # content=‘Hello 123 456 World_This is a Regex Demo‘
                  # res=re.match(‘Hello\s\d\d\d\s\d{3}\s\w{10}.*Demo‘,content)
                  # print(res)
                  # print(res.group())
                  # #  返回一个tuple表示(m.start(), m.end())
                  # print(res.span())
                  ‘‘‘
                  结果：
                  <_sre.SRE_Match object; span=(0, 40), match=‘Hello 123 456 World_This is a Regex Demo‘>
                  Hello 123 456 World_This is a Regex Demo
                  (0, 40)
                  ‘‘‘
                  
                  #泛匹配
                  # content=‘Hello 123 456 World_This is a Regex Demo‘
                  # res=re.match(‘^Hello.*Demo‘,content)
                  # print(res.group())
                  ‘‘‘
                  结果：
                  Hello 123 456 World_This is a Regex Demo
                  ‘‘‘
                  
                  
                  #匹配目标,获得指定数据
                  
                  # content=‘Hello 123 456 World_This is a Regex Demo‘
                  # res=re.match(‘^Hello\s(\d+)\s(\d+)\s.*Demo‘,content)
                  # print(res.group()) #取所有匹配的内容
                  # print(res.group(1)) #取匹配的第一个括号内的内容
                  # print(res.group(2)) #去陪陪的第二个括号内的内容
                  ‘‘‘
                  结果：
                  Hello 123 456 World_This is a Regex Demo
                  123
                  456
                  ‘‘‘
                  
                  
                  
                  #贪婪匹配:.*代表匹配尽可能多的字符
                  # import re
                  # content=‘Hello 123 456 World_This is a Regex Demo‘
                  #
                  # res=re.match(‘^He.*(\d+).*Demo$‘,content)
                  # print(res.group(1)) #只打印6,因为.*会尽可能多的匹配,然后后面跟至少一个数字
                  ‘‘‘
                  结果：
                  6
                  ‘‘‘
                  
                  
                  #非贪婪匹配:?匹配尽可能少的字符
                  # import re
                  # content=‘Hello 123 456 World_This is a Regex Demo‘
                  #
                  # res=re.match(‘^He.*?(\d+).*Demo$‘,content)
                  # print(res.group(1)) #只打印6,因为.*会尽可能多的匹配,然后后面跟至少一个数字
                  ‘‘‘
                  结果：
                  123
                  ‘‘‘
                  
                  #匹配模式:.不能匹配换行符
                  content=‘‘‘Hello 123456 World_This
                  is a Regex Demo
                  ‘‘‘
                  # res=re.match(‘He.*?(\d+).*?Demo$‘,content)
                  # print(res) #输出None
                  #
                  # res=re.match(‘He.*?(\d+).*?Demo$‘,content,re.S) #re.S让.可以匹配换行符
                  # print(res)
                  # print(res.group(1))
                  ‘‘‘
                  结果：
                  None
                  <_sre.SRE_Match object; span=(0, 39), match=‘Hello 123456 World_This\nis a Regex Demo‘>
                  123456
                  ‘‘‘
                  
                  #转义:
                  # content=‘price is $5.00‘
                  # res=re.match(‘price is $5.00‘,content)
                  # print(res)
                  #
                  # res=re.match(‘price is \$5\.00‘,content)
                  # print(res)
                  ‘‘‘
                  结果：
                  None
                  <_sre.SRE_Match object; span=(0, 14), match=‘price is $5.00‘>
                  ‘‘‘
                  
                  #总结:尽量精简,详细的如下
                      # 尽量使用泛匹配模式.*
                      # 尽量使用非贪婪模式:.*?
                      # 使用括号得到匹配目标:用group(n)去取得结果
                      # 有换行符就用re.S:修改模式
                  
                  
                  #re.search:会扫描整个字符串,不会从头开始,找到第一个匹配的结果就会返回
                  
                  # import re
                  # content=‘Extra strings Hello 123 456 World_This is a Regex Demo Extra strings‘
                  #
                  # res=re.match(‘Hello.*?(\d+).*?Demo‘,content)
                  # print(res) #输出结果为None
                  
                  #
                  # import re
                  # content=‘Extra strings Hello 123 456 World_This is a Regex Demo Extra strings‘
                  #
                  # res=re.search(‘Hello.*?(\d+).*?Demo‘,content) #
                  # print(res.group(1)) #输出结果为123
                  
                  
                  
                  #re.search:只要一个结果,匹配演练,
                  # import re
                  # content=‘‘‘
                  # <tbody>
                  # <tr id="4766303201494371851675" class="even "><td><div class="hd"><span class="num">1</span><div class="rk "><span class="u-icn u-icn-75"></span></div></div></td><td class="rank"><div class="f-cb"><div class="tt"><a href="/song?id=476630320"><img class="rpic" src="http://p1.music.126.net/Wl7T1LBRhZFg0O26nnR2iQ==/19217264230385030.jpg?param=50y50&amp;quality=100"></a><span data-res-id="476630320" ‘‘‘
                  # res=re.search(‘<a\shref=.*?<b\stitle="(.*?)".*?b>‘,content)
                  # print(res.group(1))
                  ‘‘‘
                  结果：
                  Traceback (most recent call last):
                    File "D:/old_boy/old_boy_17_05/re_mod.py", line 281, in <module>
                      print(res.group(1))
                  AttributeError: ‘NoneType‘ object has no attribute ‘group‘
                  ‘‘‘
                  
                  
                  # re.findall:找到符合条件的所有结果
                  # res=re.findall(‘<a\shref=.*?<b\stitle="(.*?)".*?b>‘,content)
                  # for i in res:
                  #     print(i)
                  ‘‘‘
                  结果：
                  空
                  ‘‘‘
                  
                  
                  
                  #re.sub:字符串替换
                  # import re
                  # content=‘Extra strings Hello 123 456 World_This is a Regex Demo Extra strings‘
                  #
                  # content=re.sub(‘\d+‘,‘‘,content)
                  # print(content)
                  ‘‘‘
                  结果：
                  Extra strings Hello   World_This is a Regex Demo Extra strings
                  ‘‘‘
                  
                  #用\1取得第一个括号的内容
                  #用法:将123与456换位置
                  # import re
                  # content=‘Extra strings Hello 123 456 World_This is a Regex Demo Extra strings‘
                  #
                  # # content=re.sub(‘(Extra.*?)(\d+)(\s)(\d+)(.*?strings)‘,r‘\1\4\3\2\5‘,content)
                  # content=re.sub(‘(\d+)(\s)(\d+)‘,r‘\3\2\1‘,content)
                  # print(content)
                  ‘‘‘
                  结果：
                  Extra strings Hello 456 123 World_This is a Regex Demo Extra strings
                  ‘‘‘
                  
                  # import re
                  # content=‘Extra strings Hello 123 456 World_This is a Regex Demo Extra strings‘
                  #
                  # res=re.search(‘Extra.*?(\d+).*strings‘,content)
                  # print(res.group(1))
                  ‘‘‘
                  结果：
                  123
                  ‘‘‘
                  
                  
                  # import requests,re
                  # respone=requests.get(‘https://book.douban.com/‘).text
                  #
                  # print(respone)
                  # print(‘======‘*1000)
                  # print(‘======‘*1000)
                  # print(‘======‘*1000)
                  # print(‘======‘*1000)
                  # res=re.findall(‘<li.*?cover.*?href="(.*?)".*?title="(.*?)">.*?more-meta.*?author">(.*?)</span.*?year">(.*?)</span.*?publisher">(.*?)</span.*?</li>‘,respone,re.S)
                  # # res=re.findall(‘<li.*?cover.*?href="(.*?)".*?more-meta.*?author">(.*?)</span.*?year">(.*?)</span.*?publisher">(.*?)</span>.*?</li>‘,respone,re.S)
                  #
                  #
                  # for i in res:
                  #     print(‘%s    %s    %s   %s‘ %(i[0].strip(),i[1].strip(),i[2].strip(),i[3].strip()))

                  View Code

                   

原文：http://www.cnblogs.com/you0329/p/6935512.html