Python之常用模块re模块与logging模块和包

Posted zhangdadayou

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Python之常用模块re模块与logging模块和包相关的知识,希望对你有一定的参考价值。

5.10 re模块

  1. re(正则)简介:正则就是用一些具有特殊含义的符号组合到一起(称为正则表达式)来描述字符或者字符串的方法。或者说:正则就是用来描述一类事物的规则。

  2. re元字符

    • 元字符 匹配内容
      \w 匹配字母(包含中文)或数字或下划线
      \W 匹配非字母(包含中文)或数字或下划线
      \s 匹配任意的空白符
      \S 匹配任意非空白符
      \d 匹配数字
      \D 匹配非数字
      \A 从字符串开头匹配
      \n 匹配一个换行符
      \t 匹配一个制表符
      ^ 匹配字符串的开始
      $ 匹配字符串的结尾
      . 匹配任意字符,除了换行符,当re.DOTALL标记被指定时,则可以匹配包括换行符的任意字符。
      [...] 匹配字符组中的字符
      [^] 匹配除了字符组中的字符的所有字符
      * 匹配0个或者多个左边的字符。
      + 匹配一个或者多个左边的字符。
      匹配0个或者1个左边的字符,非贪婪方式。
      n 精准匹配n个前面的表达式。
      n,m 匹配n到m次由前面的正则表达式定义的片段,贪婪方式
      a|b 匹配a或者b
      () 匹配括号内的表达式,也表示一个组
    s = "meet 黑哥_dsb"
    print(re.findall("\w",s))
    # 结果:['m', 'e', 'e', 't', '黑', '哥', '_', 'd', 's', 'b']
    s = "meet @黑哥!_dsb"
    print(re.findall("\W",s))
    # 结果:[' ', '@', '!']
    s = "meet 黑哥\n_dsb\t"
    print(re.findall("\s",s))
    # 结果:[' ', '\n', '\t']
    s = "meet 黑哥\n_dsb\t"
    print(re.findall("\S",s))
    # 结果:['m', 'e', 'e', 't', '黑', '哥', '_', 'd', 's', 'b']
    s = "meet1 黑哥2_dsb3"
    print(re.findall("\d",s))
    # 结果:['1', '2', '3']
    s = "meet1 黑哥2_dsb3"
    print(re.findall("\D",s))
    # 结果:['m', 'e', 'e', 't', ' ', '黑', '哥', '_', 'd', 's', 'b']
    s = "meet 黑哥_dsb"
    print(re.findall("\Am",s))
    print(re.findall("\Ad",s))
    # 结果:
    ['m']
    []
    s = "meet \n黑哥\t_\ndsb"
    print(re.findall("\n",s))
    # 结果:
    ['\n', '\n']
    s = "meet \n黑哥\t_\ndsb"
    print(re.findall("\t",s))
    # 结果:
    ['\t']
    s = "meet 黑哥_dsb"
    print(re.findall("^m",s))
    print(re.findall("^d",s))
    # 结果:
    ['m']
    []
    s = "meet 黑哥_dsb"
    print(re.findall("b$",s))
    print(re.findall("sb$",s))
    # 结果:
    ['b']
    ['sb']
    s = "meet 黑哥_dsb"
    print(re.findall("m..",s))
    # 结果:['mee']
    s = "meet1 黑哥2_dsb3"
    print(re.findall("[1-3]",s))
    # 结果:['1', '2', '3']
    s = "meet1 黑哥2_dsb3"
    print(re.findall("[^(1-3)]",s))
    # 结果:['m', 'e', 'e', 't', ' ', '黑', '哥', '_', 'd', 's', 'b']
    s = "meet 黑m哥_dsb meet meee"
    print(re.findall("me*",s))
    # 结果:['mee', 'm', 'mee', 'meee']
    s = "meet 黑m哥_dsb meet meee"
    print(re.findall("me+",s))
    # 结果:['mee', 'mee', 'meee']
    s = "meet 黑m哥_dsb meet meee"
    print(re.findall("me*?",s))
    print(re.findall("me+?",s))
    # 结果:
    ['m', 'm', 'm', 'm']
    ['me', 'me', 'me']
    s = "meet 黑m哥_dsb meet meee"
    print(re.findall("e3",s))
    # 结果:
    ['eee']
    s = "meet 黑m哥_dsb meet meee"
    print(re.findall("e1,3",s))
    # 结果:
    ['ee', 'ee', 'eee']
    s = "2019-7-26 20:30:30"
    print(re.split(":|-|\s",s))
    # 结果:
    ['2019', '7', '26', '20', '30', '30']
    s = "meet 黑m哥_dsb meet meee"
    print(re.findall("m(.*?)t",s))
    # 结果:
    ['ee', '哥_dsb mee']
  3. re模块常用方法

    • findall 全部找到返回一个列表

    • search 从字符串中任意位置进行匹配查找到一个就停止了,返回的是一个对象. 获取匹配的内容必须使用.group()进行获取

    • import re
      print(re.search("sb|nb","alexsb meetnb"))
      print(re.search("sb|nb","alexsb meetnb").group())
      # 结果
      <_sre.SRE_Match object; span=(4, 6), match='sb'>
      sb
    • match 从字符串开始位置进行匹配

    • import re
      print()re.match("sb|nb","alexdsb,alex_sb,alexnb,al_ex")
      print(re.match("sb|nb","alexdsb,alex_sb,alexnb,al_ex").group())
      # 结果:
      None
      AttributeError: 'NoneType' object has no attribute 'group'  # 'NoneType'对象没有属性'group'
    • split 分隔 可按照任意分隔符进行分隔

    • import re
      s = "2019-7-26 20:30:30"
      print(re.split(":|-|\s",s))
      # 结果:
      ['2019', '7', '26', '20', '30', '30']
    • sub 替换

    • import re
      s = "meet是一位好老师,meet教会了我们很多知识"
      print(re.sub("meet","苍老师",s))
      # 结果:
      苍老师是一位好老师,苍老师教会了我们很多知识
    • compile 定义匹配规则

    • import re
      fn = "\d+"
      s = "太白123meet456"
      print(re.split(fn,s))
      # 结果:
      ['太白', 'meet', '']
    • finditer 返回一个迭代器

    • import re
      s = "太白123"
      g = re.finditer("\w",s)
      for i in g:
          print(i)
          print(next(i))
      # 结果:
      <_sre.SRE_Match object; span=(0, 1), match='太'>
      太
      <_sre.SRE_Match object; span=(1, 2), match='白'>
      白
      <_sre.SRE_Match object; span=(2, 3), match='1'>
      1
      <_sre.SRE_Match object; span=(3, 4), match='2'>
      2
      <_sre.SRE_Match object; span=(4, 5), match='3'>
      3
    • 给分组起名字

    • import re
      ret = re.search("<(?P<tag_name>\w+)>\w+</\w+>","<h1>hello</h1>")  # 给分组1取名tag_name
      print(ret.group("tag_name"))
      print(ret.group())
      # 结果:
      h1
      <h1>hello</h1>
      
      import re
      ret = re.search(r"<(\w+)>\w+</\1>","<h1>hello</h1>")   # \1填充分组1中的内容
      print(ret.group(1))
      print(ret.group())
      # 结果:
      h1
      <h1>hello</h1>

5.11 logging模块和包

  1. logging模块简介:logging模块是记录我们软件的各种状态,还可以记录各种交易信息;其实每个软件都是有错误日志的,开发人员可以通过错误日志中的内容对他的程序进行修改

  2. 日志级别

    • import logging
      
      logging.debug('调试debug')           # DEBUG = 10
      logging.info('消息info')             # INFO = 20
      logging.warning('警告warn')          # WARNING = 30
      logging.error('错误error')           # ERROR = 40
      logging.critical('严重critical')     # CRITICAL = 50
      
      '''
      WARNING:root:警告warn
      ERROR:root:错误error
      CRITICAL:root:严重critical
      '''
    • 默认情况下Python的logging模块将日志打印到了标准输出中,且只显示了大于等于WARNING级别的日志,这说明默认的日志级别设置为WARNING(日志级别等级CRITICAL > ERROR > WARNING > INFO > DEBUG),默认的日志格式为日志级别:Logger名称:用户输出消息。
  3. 灵活配置日志级别、日志格式、输出位置

    • import logging  
      logging.basicConfig(level=logging.DEBUG,  
                          format='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s',  
                          datefmt='%a, %d %b %Y %H:%M:%S',  
                          filename='/tmp/test.log',  
                          filemode='w')  
      
      logging.debug('debug message')  
      logging.info('info message')  
      logging.warning('warning message')  
      logging.error('error message')  
      logging.critical('critical message')
  4. basicConfig()函数中可通过具体参数来更改logging模块默认行为,可用参数有:

    • filename:用指定的文件名创建FiledHandler,这样日志会被存储在指定的文件中
    • filemode:文件打开方式,在指定了filename时使用这个参数,默认值为“a”还可指定为“w”。
    • format:指定handler使用的日志显示格式。
    • datefmt:指定日期时间格式。
    • level:设置记录日志的级别
    • stream:用指定的stream创建StreamHandler。可以指定输出到
    • sys.stderr,sys.stdout或者文件(f=open(‘test.log’,’w’)),默认为sys.stderr。若同时列出了filename和stream两个参数,则stream参数会被忽略。
  5. format参数中可能用到的格式化串

    • %(name)s Logger的名字
    • %(levelno)s 数字形式的日志级别
    • %(levelname)s 文本形式的日志级别
    • %(pathname)s 调用日志输出函数的模块的完整路径名,可能没有
    • %(filename)s 调用日志输出函数的模块的文件名
    • %(module)s 调用日志输出函数的模块名
    • %(funcName)s 调用日志输出函数的函数名
    • %(lineno)d 调用日志输出函数的语句所在的代码行
    • %(created)f 当前时间,用UNIX标准的表示时间的浮 点数表示
    • %(relativeCreated)d 输出日志信息时的,自Logger创建以 来的毫秒数
    • %(asctime)s 字符串形式的当前时间。默认格式是 “2003-07-08 16:49:45,896”。逗号后面的是毫秒
    • %(thread)d 线程ID。可能没有
    • %(threadName)s 线程名。可能没有
    • %(process)d 进程ID。可能没有
    • %(message)s用户输出的消息
  6. logging对象配置

    • import logging
      
      logger = logging.getLogger()
      # 创建一个handler,用于写入日志文件
      fh = logging.FileHandler('test.log',encoding='utf-8') 
      
      # 再创建一个handler,用于输出到控制台 
      ch = logging.StreamHandler() 
      formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
      
      fh.setLevel(logging.DEBUG)
      
      fh.setFormatter(formatter) 
      ch.setFormatter(formatter) 
      logger.addHandler(fh) #logger对象可以添加多个fh和ch对象 
      logger.addHandler(ch) 
      
      logger.debug('logger debug message') 
      logger.info('logger info message') 
      logger.warning('logger warning message') 
      logger.error('logger error message') 
      logger.critical('logger critical message')
    • logging库提供了多个组件:Logger、Handler、Filter、Formatter。Logger对象提供应用程序可直接使用的接口,Handler发送日志到适当的目的地,Filter提供了过滤日志信息的方法,Formatter指定日志显示格式。另外,可以通过:logger.setLevel(logging.Debug)设置级别,当然,也可以通过

    • fh.setLevel(logging.Debug)单对文件流设置某个级别。

    • 包的简介:包是一种通过使用‘.模块名’来组织python模块名称空间的方式。具体的:包就是一个包含有__init__.py文件的文件夹,所以其实我们创建包的目的就是为了用文件夹将文件/模块组织起来

    • 需要强调的是:

      1. 在python3中,即使包下没有__init__.py文件,import 包仍然不会报错,而在python2中,包下一定要有该文件,否则import 包报错
      2. 创建包的目的不是为了运行,而是被导入使用,记住,包只是模块的一种形式而已,包的本质就是一种模块
    • 为何要使用包

    • 包的本质就是一个文件夹,那么文件夹唯一的功能就是将文件组织起来
      随着功能越写越多,我们无法将所以功能都放到一个文件中,于是我们使用模块去组织功能,而随着模块越来越多,我们就需要用文件夹将模块文件组织起来,以此来提高程序的结构性和可维护性

    • glance/                   #Top-level package
      
      ├── __init__.py      #Initialize the glance package
      
      ├── api                  #Subpackage for api
      
      │   ├── __init__.py
      
      │   ├── policy.py
      
      │   └── versions.py
      
      ├── cmd                #Subpackage for cmd
      
      │   ├── __init__.py
      
      │   └── manage.py
      
      └── db                  #Subpackage for db
      
          ├── __init__.py
      
          └── models.py
    • 注意项:

      • #1.关于包相关的导入语句也分为import和from ... import ...两种,但是无论哪种,无论在什么位置,在导入时都必须遵循一个原则:凡是在导入时带点的,点的左边都必须是一个包,否则非法。可以带有一连串的点,如item.subitem.subsubitem,但都必须遵循这个原则。但对于导入后,在使用时就没有这种限制了,点的左边可以是包,模块,函数,类(它们都可以用点的方式调用自己的属性)。
        
        #2、import导入文件时,产生名称空间中的名字来源于文件,import 包,产生的名称空间的名字同样来源于文件,即包下的__init__.py,导入包本质就是在导入该文件
        
        #3、包A和包B下有同名模块也不会冲突,如A.a与B.a来自俩个命名空间
  7. 文件内容:按 Ctrl+C 复制代码;执行文件与示范文件在同级目录下

  8. 包的使用之import

    • import glance.db.models
      glance.db.models.register_models('mysql') 
    • 单独导入包名称时不会导入包中所有包含的所有子模块,如

    • #在与glance同级的test.py中
      import glance
      glance.cmd.manage.main()
      
      '''
      执行结果:
      AttributeError: module 'glance' has no attribute 'cmd'
      
      ''' 
    • 解决方法:

    • #glance/__init__.py
      from . import cmd
      
      #glance/cmd/__init__.py
      from . import manage
    • 执行:

    • #在于glance同级的test.py中
      import glance
      glance.cmd.manage.main()
  9. 包的使用之from ... import ...

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

    • from glance.db import models
      models.register_models('mysql')
      
      from glance.db.models import register_models
      register_models('mysql')
  10. from glance.api import *

    • 在讲模块时,我们已经讨论过了从一个模块内导入所有,此处我们研究从一个包导入所有

    • 此处是想从包api中导入所有,实际上该语句只会导入包api下__init.py文件中定义的名字,我们可以在这个文件中定义_all:

    • # 在__init__.py中定义
      x=10
      
      def func():
          print('from api.__init.py')
      
      __all__=['x','func','policy']
    • 此时我们在于glance同级的文件中执行from glance.api import *就导入__all__中的内容(versions仍然不能导入)。

    • # 在__init__.py中定义
      x = 10
      
      def func():
          print('from api.__init.py')
      
      __all__=['x','func','policy']
    • 此时我们在于glance同级的文件中执行from glance.api import *就导入__all__中的内容(versions仍然不能导入)。

    • 练习:

    • # 执行文件中的使用效果如下,请处理好包的导入
      from glance import *
      
      get()
      create_resource('a.conf')
      main()
      register_models('mysql')
  11. 绝对导入和相对导入

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

    • 绝对导入:以glance作为起始

    • 相对导入:用.或者..的方式最为起始(只能在一个包中使用,不能用于不同目录内)

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

    • 在glance/api/version.py
      
      # 绝对导入
      from glance.cmd import manage
      manage.main()
      
      # 相对导入
      from ..cmd import manage
      manage.main()
    • 测试结果:注意一定要在于glance同级的文件中测试

    • from glance.api import versions 
    • 包以及包所包含的模块都是用来被导入的,而不是被直接执行的。而环境变量都是以执行文件为准的

    • 比如我们想在glance/api/versions.py中导入glance/api/policy.py,有的同学一抽这俩模块是在同一个目录下,十分开心的就去做了,它直接这么做

    • # 在version.py中
      
      import policy
      policy.get()
    • 没错,我们单独运行version.py是一点问题没有的,运行version.py的路径搜索就是从当前路径开始的,于是在导入policy时能在当前目录下找到

    • 但是你想啊,你子包中的模块version.py极有可能是被一个glance包同一级别的其他文件导入,比如我们在于glance同级下的一个test.py文件中导入version.py,如下

    • from glance.api import versions
      
      '''
      执行结果:
      ImportError: No module named 'policy'
      '''
      
      '''
      分析:
      此时我们导入versions在versions.py中执行
      import policy需要找从sys.path也就是从当前目录找policy.py,
      # 这必然是找不到的
      '''
  12. 绝对导入与相对导入总结

    • 绝对导入与相对导入
      
      # 绝对导入: 以执行文件的sys.path为起始点开始导入,称之为绝对导入
      #       优点: 执行文件与被导入的模块中都可以使用
      #       缺点: 所有导入都是以sys.path为起始点,导入麻烦
      
      # 相对导入: 参照当前所在文件的文件夹为起始开始查找,称之为相对导入
      # 符号: .代表当前所在文件的文件加,..代表上一级文件夹,...代表上一级的上一级文件夹
      #       优点: 导入更加简单
      #       缺点: 只能在导入包中的模块时才能使用
      # 注意:
      #  1. 相对导入只能用于包内部模块之间的相互导入,导入者与被导入者都必须存在于一个包内
      #    2. attempted relative import beyond top-level package # 试图在顶级包之外使用相对导入是错误的,言外之#       意,必须在顶级包内使用相对导入,每增加一个.代表跳到上一级文件夹,而上一级不应该超出顶级包

以上是关于Python之常用模块re模块与logging模块和包的主要内容,如果未能解决你的问题,请参考以下文章

python之re和logging模块

python模块之configparser_logging_re

python常用模块之——正则re模块

python之time模块

常用模块-正则re

爬虫--Python常用模块之requests,urllib和re