• collections模块与re模块


    collections模块与re模块

    一,colections模块

    • 在内置数据类型(dict,list,set,tuple)的基础上,collections模块还提供了几个额外的数据类型: Counter,deque,defaultdict,namedtupleOrderedDict

      1. namedtuple:生成可以使用名字来访问元素内容的tuple(命名元组)

        from collections import namedtuple
        Point = namedtuple('Point', ['x', 'y'])
        p = Point(1, 2)
        print(p, type(p)) # Point(x=1, y=2) <class '__main__.Point'>
        print(p[0]) # 1
        print(p.y)  # 2
        
      2. deque:双向列表,双端队列,类似于列表的一种容器型数据,插入元素和删除元素效率高

        from collections import deque
        q = deque(['a', 1, 'c', 'd'])
        print(q, type(q))
        q.append('e') # 按顺序追加
        q.append('f')
        q.appendleft('g') # 在左边追加
        q.pop()  # 默认删除最后一个
        q.popleft()  # 默认删除最前面的
        # 也能按照索引查询和删除
        
      3. OrderedDict: 有序字典

        d = dict([('a', 1), ('b', 2), ('c', 3)])
        print(d)     #{'a': 1, 'b': 2, 'c': 3}
        from collections import OrderedDict
        od = OrderedDict([('a', 1), ('b', 2), ('c', 3)])
        print(od)		#OrderedDict([('a', 1), ('b', 2), ('c', 3)])
        
      4. defaultdict:默认值字典

        from collections import defaultdict
        l1 = [11, 22, 33, 44, 55, 66, 77, 88, 99]
        dic = defaultdict(list) # 创建空字典,设置默认值(可回调的对象),每次创建key的时候,如果不写value会使用默认值
        for i in l1:
            if i < 66:
                dic['key1'].append(i)
            else:
                dic['key2'].append(i)
        print(dic)
        
      5. Counter: 计数器

        from collections import Counter
        c = Counter('SDFSDFSDXVXCFDGDFGDFGDFGDF')  # 统计每个元素的个数
        print(c)   #Counter({'D': 8, 'F': 7, 'G': 4, 'S': 3, 'X': 2, 'V': 1, 'C': 1})
        

    二,re模块:正则表达式

    • 什么是正则:

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

        元字符 匹配内容
        w 匹配字母(包含中文)或数字或下划线
        W 匹配非字母(包含中文)或数字或下划线
        s 匹配任意的空白符
        S 匹配任意非空白符
        d 匹配数字
        D 匹配非数字
        A 与 ^ 从字符串开头匹配
         与 $ 从字符串结尾开始匹配
        匹配一个换行符
        匹配一个制表符
        . 匹配任意字符,除了换行符,当re.DOTALL标记被指定时,则可以匹配包括换行符的任意字符
        [...] 匹配字符组中的字符
        [^...] 匹配除了字符组中的字符的所有字符
        * 匹配0个或者多个左边的字符。
        + 匹配一个或者多个左边的字符。
        匹配0个或者1个左边的字符,非贪婪方式。
        {n} 精准匹配n个前面的表达式。
        {n,m} 匹配n到m次由前面的正则表达式定义的片段,贪婪方式
        a|b 匹配a或者b。
        () 匹配括号内的表达式,也表示一个组
    1. 匹配模式举例

      import re
      re.findall()
      ----------------------------------------------------
      # 单个字符的匹配
      
      # W 与 w
      s = '原始tz 12*() _'
      print(re.findall('w', s))  # w 数字,字母,下划线,中文
      print(re.findall('W', s))  # W 除了数字,字母,下划线,中文以外的
      
      # s 与 S
      print(re.findall('s', '原始tz*(_ 	 
      '))  # s 空格,	,
      
      print(re.findall('S', '原始tz*(_ 	 
      '))  # S 除空格,	,
      以外的
      
      # d 与 D
      print(re.findall('d','1234567890 yuanshi *(_')) # d 数字
      print(re.findall('D','1234567890 yuanshi *(_')) # D 非数字
      
      # A 与 ^
      print(re.findall('Ahello', 'hello hello 原始 hell')) # 从开
      print(re.findall('^hello', 'hello hello 原始 hell')) # 从开头开始匹配头开始匹配
      
      #  与 $  从结尾开始匹配
      print(re.findall('hell$', 'hello hello 原始 hell'))
      
      # 
       与 	
      print(re.findall('	',  'hello hello 原始 	hell'))  # 	
      print(re.findall('
      ',  'hello hello 原始 
      hell'))  # 
      
      
      ----------------------------------------------------
      # 元字符匹配
      
      # .  ?  *  +  {m,n}  .*   ,*?
      # .匹配任意字符:   如果匹配成功,光标则移到匹配成功的最后的字符;如果匹配未成功,则光标向下移动一位继续匹配
      print(re.findall('a.b', 'ab aab abb aaaab'))
      
      # ? 匹配0个或者1个由左边字符定义的片段
      print(re.findall('a?b', 'ab aab abb aaaab'))
      
      # * 匹配0个或者多个由左边字符定义的片段: 满足贪婪匹配
      print(re.findall('a*b', 'ab aab abb aaaab'))
      
      # + 匹配1个或者多个由左边字符定义的片段: 满足贪婪匹配
      print(re.findall('a+b', 'ab aab abb aaaab'))
      
      # {m,n} 匹配m个至n个(包括m和n)由左边字符定义的片段
      print(re.findall('a{1,5}b', 'ab aab abb aaaaab aaaaaab'))
      
      # .* : 贪婪匹配 从头到尾
      print(re.findall('a.*b', 'ab aab abb aa#aaab aaaaaab'))
      
      # .*? 此时的?不是对左边的字符进行0次或者1次的匹配,
      # 而只是针对.*这种贪婪匹配的模式进行一种限定:告知他要遵从非贪婪匹配
      print(re.findall('a.*?b', 'ab aab abb aa#aaab aaaaaab'))
      
      # []: 一个中括号可以代表一个字符
      print(re.findall('a[abc]b', 'aab abb acb afb a_b'))  # [abc]中任意一个都可以
      print(re.findall('a[abc][bd]b', 'aabb aaabc abd acdbb')) # =>['aabb', 'acdb']
      # - : 在[]中表示范围
      print(re.findall('a[0-9]b', 'a1b a2bc abd acdbb'))  # =>['a1b', 'a2b']
      print(re.findall('a[A-Z]b', 'aAb a2bc abd acdbb'))  # =>['aAb']
      print(re.findall('a[A-Za-z]b', 'aAb aabc abd acdbb')) # =>['aAb', 'aab']
      print(re.findall('a[-*$]b', 'a-b a*bc abd acdbb')) # =>['a-b', 'a*b']
      # 当想匹配 - 时,要把 - 放在最前面或最后面
      # ^ : 在[]最前面表示取反
      print(re.findall('a[^0-9]b', 'a1b a2bc abbd acdbb')) # =>['abb']
      
      s = 'xiaowang_sb xiaoliu_sb wanglu_sb tianzun_sb 通天教主_nb'
      print(re.findall('w+_sb', s))
      
      
      # (): 分组
      s = 'xiaowang_sb xiaoliu_sb wanglu_sb tianzun_sb 通天教主_nb'
      print(re.findall('(w+)_sb', s)) # =>['xiaowang', 'xiaoliu', 'wanglu', 'tianzun'],返回()内的内容
      
      
      # |: 匹配左边或右边
      print(re.findall('xiao|da|tian', 'xiaoasdnfisdaiasdntian'))
      
      # 在()分组里面加了?:,将全部的内容返回,而不是将组内的内容返回
      print(re.findall('compan(y|ies)', 'Too many companies have gone bankrupt, and the next one is my company'))
      print(re.findall('compan(?:y|ies)', 'Too many companies have gone bankrupt, and the next one is my company'))
      
      -----------------------------------------------------
      # 常用方法
      
      # re.findall()  # 全部找到返回一个列表
      
      # re.search() # 找到第一个符合条件的字符串,然后返回一个包含匹配信息的对象,通过对象.group()获取
      ret = re.search('sb|qwe', 'xiaomingt sb qwe')
      print(ret)
      print(ret.group())
      # re.match() # 从字符串开头匹配,如果以符合条件的字符串开头则返回,否则返回None
      ret = re.match('sb|qwe', 'xiaomingt sb qwe')
      ret2 = re.match('sb|qwe', 'sbxiaomingt sb qwe')
      print(ret)
      print(ret2)
      
      
      # split()  # 分割
      s1 = 'xiaoming,tiaoshang;太阳~地球'
      print(re.split('[;,~]', s1))  # 自定义分隔符
      
      # sub 调换
      print(re.sub('me', '我', 'me是最好的男人,me就是一个普通男人,请不要将me当男神对待。'))
      print(re.sub('me', '我', 'me是最好的男人,me就是一个普通男人,请不要将me当男神对待。', 2))
      
      
      # compile  配置匹配规则
      obj = re.compile('d{2}')
      print(obj.search('abc123eeee').group())  # => 12
      print(obj.findall('abc123eeee')) # => ['12']
      
      s1 = '''
      时间就是1995-04-27,2005-04-27
      1999-04-27 
       alex 1980-04-27:1980-04-27
      2018-12-08
      '''
      print(re.findall('d{4}-d{2}-d{2}', s1))
      
      s2 = '3325783547345nvn8b8473v 2893472893'
      obj = re.compile('[1-9][0-9]{4,7}')
      print(obj.findall(s2))
      
  • 相关阅读:
    类数组(伪数组)
    go面试题[2]
    go面试题[1]
    go编程第十五课时
    php实现堆排序
    go编程第十三课时
    go第十一课时
    关于循环队列 -> 击鼓传花
    网栅格布局
    《学习JAVASCRIPT数据结构与算法》 ES6 部分笔记
  • 原文地址:https://www.cnblogs.com/maqian/p/11905289.html
Copyright © 2020-2023  润新知