collection模块，re模块的用法介绍

模块补充

1. collections模块：给我们提供一些python的数据类型.比较特殊的数据类型.出奇制胜的效果.

   • 在内置数据类型（dict、list、set、tuple）的基础上，collections模块还提供了几个额外的数据类型：Counter、deque、defaultdict、namedtuple和OrderedDict等。

   • namedtuple: 生成可以使用名字来访问元素内容的tuple

     tuple可以表示不变集合，例如，一个点的二维坐标就可以表示成：p=(1,2) 但是，看到(1, 2)，很难看出这个tuple是用来表示一个坐标的。这时，namedtuple就派上了用场：
     >>> from collections import namedtuple
     >>> Point = namedtuple('Point', ['x', 'y'])
     >>> p = Point(1, 2)
     >>> p.x
     >>> p.y
     类似的，如果要用坐标和半径表示一个圆，也可以用namedtuple定义：
     namedtuple('名称', [属性list]):
     Circle = namedtuple('Circle', ['x', 'y', 'r'])
     

      from collections import namedtuple
       Point = namedtuple('Point',['x', 'y'])
      print(type(Point))
      p = Point(1, 2)
      print(type(p))
      print(p)   Point(x=1, y=2)
      print(p[0])
      print(p[1])
      print(p.x)
      print(p.y)
      import time
      struct_time = time.strptime('2019-7-2','%Y-%m-%d')
      print(struct_time)
      print(struct_time[0])
      print(struct_time.tm_yday)
      struct_time(tm_year=2019, tm_mon=7, tm_mday=2, )
      from collections import namedtuple
      struct_time = namedtuple('struct_time',['tm_year', 'tm_mon', 'tm_mday'])
      st = struct_time(2019, 7, 2)
      print(st)
     

   • deque: 双端队列，可以快速的从另外一侧追加和推出对象

     使用list存储数据时，按索引访问元素很快，但是插入和删除元素就很慢了，因为list是线性存储，数据量大的时候，插入和删除效率很低。
     deque是为了高效实现插入和删除操作的双向列表，适合用于队列和栈：
     >>> from collections import deque
     >>> q = deque(['a', 'b', 'c'])
     >>> q.append('x')
     >>> q.appendleft('y')
     >>> q
     deque(['y', 'a', 'b', 'c', 'x'])
     deque除了实现list的append()和pop()外，还支持appendleft()和popleft()，这样就可以非常高效地往头部添加或删除元素。
     

     deque: 类似于列表的一种容器型数据,插入元素删除元素效率高.
      from collections import deque
      q = deque(['a', 1, 'c', 'd'])
      print(q)
      q.append('e')
      q.append('f')
      print(q)
      q.appendleft('ly')
      q.appendleft('dsb')
      print(q)
      q.pop()
      q.popleft()
      print(q)
     
      按照索引取值
      print(q[0])
     
      按照索引删除任意值
      del q[2]
      print(q)
      q.insert(1,'2')
      print(q)
     
      d = dict([('a', 1), ('b', 2), ('c', 3)])
      print(d)
      from collections import OrderedDict
      od = OrderedDict([('a', 1), ('b', 2), ('c', 3)])
       print(od)
      print(od['a'])
      print(od['b'])
     

   • Counter: 计数器，主要用来计数

     Counter类的目的是用来跟踪值出现的次数。它是一个无序的容器类型，以字典的键值对形式存储，其中元素作为key，其计数作为value。计数值可以是任意的Interger（包括0和负数）。Counter类和其他语言的bags或multisets很相似。
     c = Counter('abcdeabcdabcaba')
     print c
     输出：Counter({'a': 5, 'b': 4, 'c': 3, 'd': 2, 'e': 1})
     

      from collections import Counter
      c = Counter('flkjdasffdfakjsfdsaklfdsalf')   计数器
      print(c)
      print(c['f'])
     

   • OrderedDict: 有序字典

     使用dict时，Key是无序的。在对dict做迭代时，我们无法确定Key的顺序。
     如果要保持Key的顺序，可以用OrderedDict：
     >>> from collections import OrderedDict
     >>> d = dict([('a', 1), ('b', 2), ('c', 3)])
     >>> d  dict的Key是无序的
     {'a': 1, 'c': 3, 'b': 2}
     >>> od = OrderedDict([('a', 1), ('b', 2), ('c', 3)])
     >>> od  OrderedDict的Key是有序的
     OrderedDict([('a', 1), ('b', 2), ('c', 3)])
     注意，OrderedDict的Key会按照插入的顺序排列，不是Key本身排序：
     >>> od = OrderedDict()
     >>> od['z'] = 1
     >>> od['y'] = 2
     >>> od['x'] = 3
     >>> od.keys()  按照插入的Key的顺序返回
     ['z', 'y', 'x']
     

   • defaultdict: 带有默认值的字典

     有如下值集合 [11,22,33,44,55,66,77,88,99,90...]，将所有大于 66 的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中。
     即： {'k1': 大于66 , 'k2': 小于66}
     li = [11,22,33,44,55,77,88,99,90]
     result = {}
     for row in li:
         if row > 66:
             if 'key1' not in result:
                 result['key1'] = []
             result['key1'].append(row)
         else:
             if 'key2' not in result:
                 result['key2'] = []
             result['key2'].append(row)
     print(result)
     
     原生字典的解决方法
     from collections import defaultdict
     
     values = [11, 22, 33,44,55,66,77,88,99,90]
     
     my_dict = defaultdict(list)
     
     for value in  values:
         if value>66:
             my_dict['k1'].append(value)
         else:
             my_dict['k2'].append(value)
     
     defaultdict字典解决方法
     使用dict时，如果引用的Key不存在，就会抛出KeyError。如果希望key不存在时，返回一个默认值，就可以用defaultdict：
     >>> from collections import defaultdict
     >>> dd = defaultdict(lambda: 'N/A')
     >>> dd['key1'] = 'abc'
     >>> dd['key1']  key1存在
     'abc'
     >>> dd['key2']  key2不存在，返回默认值
     'N/A'
     
     例2
     

     from collections import defaultdict
       默认值字典
      l1 = [11, 22, 33, 44, 55, 77, 88, 99]
      dic = {}
      for i in l1:
          if i < 66:
              if 'key1' not in dic:
                  dic['key1'] = []
              dic['key1'].append(i)
     
          else:
              if 'key2' not in dic:
                  dic['key2'] = []
              dic['key2'].append(i)
      print(dic)
     
      l1 = [11, 22, 33, 44, 55, 77, 88, 99]
       dic = defaultdict(list)
       for i in l1:
           if i < 66:
               dic['key1'].append(i)
      
           else:
               dic['key2'].append(i)
       print(dic)
      callable
      dic = defaultdict(list)   需要一个可回调的
      dic['1'] = 222
      dic['2']
      dic['3']
      print(dic)
     
      print(list())
      print(list())
      dic = dict.fromkeys('123',[])
      print(dic)
     
      dic = defaultdict(lambda :None)
       dic = defaultdict(None)
      for i in range(1,4):
          dic[i]
      print(dic)
     

2. re模块：正则表达式: 从一大堆字符串中,找出你想要的字符串.在于对你想要得这个字符串进行一个精确地描述.

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

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

     匹配模式举例

      ----------------匹配模式--------------------
     
      1,之前学过的字符串的常用操作：一对一匹配
      s1 = 'fdskahf太白金星'
      print(s1.find('太白'))   7
     
      2，正则匹配：
     
      单个字符匹配
     import re
      \w 与 \W
      print(re.findall('\w', '太白jx 12*() _'))   ['太', '白', 'j', 'x', '1', '2', '_']
      print(re.findall('\W', '太白jx 12*() _'))   [' ', '*', '(', ')', ' ']
     
     
      \s 与\S
      print(re.findall('\s','太白barry*(_ \t \n'))   [' ', '\t', ' ', '\n']
      print(re.findall('\S','太白barry*(_ \t \n'))   ['太', '白', 'b', 'a', 'r', 'r', 'y', '*', '(', '_']
     
     
      \d 与 \D
      print(re.findall('\d','1234567890 alex *（_'))   ['1', '2', '3', '4', '5', '6', '7', '8', '9', '0']
      print(re.findall('\D','1234567890 alex *（_'))   [' ', 'a', 'l', 'e', 'x', ' ', '*', '（', '_']
     
      \A 与 ^
      print(re.findall('\Ahel','hello 太白金星 -_- 666'))   ['hel']
      print(re.findall('^hel','hello 太白金星 -_- 666'))   ['hel']
     
     
      \Z、\z 与 $  @@
      print(re.findall('666\Z','hello 太白金星 *-_-* \n666'))   ['666']
      print(re.findall('666\z','hello 太白金星 *-_-* \n666'))   []
      print(re.findall('666$','hello 太白金星 *-_-* \n666'))   ['666']
     
      \n 与 \t
      print(re.findall('\n','hello \n 太白金星 \t*-_-*\t \n666'))   ['\n', '\n']
      print(re.findall('\t','hello \n 太白金星 \t*-_-*\t \n666'))   ['\t', '\t']
     
     
      重复匹配
     
      . ? * + {m,n} .* .*?
     
      . 匹配任意字符，除了换行符（re.DOTALL 这个参数可以匹配\n）。
      print(re.findall('a.b', 'ab aab a*b a2b a牛b a\nb'))   ['aab', 'a*b', 'a2b', 'a牛b']
      print(re.findall('a.b', 'ab aab a*b a2b a牛b a\nb',re.DOTALL))   ['aab', 'a*b', 'a2b', 'a牛b']
     
     
      ？匹配0个或者1个由左边字符定义的片段。
      print(re.findall('a?b', 'ab aab abb aaaab a牛b aba**b'))   ['ab', 'ab', 'ab', 'b', 'ab', 'b', 'ab', 'b']
     
     
      * 匹配0个或者多个左边字符表达式。 满足贪婪匹配 @@
      print(re.findall('a*b', 'ab aab aaab abbb'))   ['ab', 'aab', 'aaab', 'ab', 'b', 'b']
      print(re.findall('ab*', 'ab aab aaab abbbbb'))   ['ab', 'a', 'ab', 'a', 'a', 'ab', 'abbbbb']
     
     
      + 匹配1个或者多个左边字符表达式。 满足贪婪匹配  @@
      print(re.findall('a+b', 'ab aab aaab abbb'))   ['ab', 'aab', 'aaab', 'ab']
     
     
      {m,n}  匹配m个至n个左边字符表达式。 满足贪婪匹配  @@
      print(re.findall('a{2,4}b', 'ab aab aaab aaaaabb'))   ['aab', 'aaab']
     
     
      .* 贪婪匹配 从头到尾.
      print(re.findall('a.*b', 'ab aab a*()b'))   ['ab aab a*()b']
     
     
      .*? 此时的?不是对左边的字符进行0次或者1次的匹配,
      而只是针对.*这种贪婪匹配的模式进行一种限定:告知他要遵从非贪婪匹配 推荐使用!
      print(re.findall('a.*?b', 'ab a1b a*()b, aaaaaab'))   ['ab', 'a1b', 'a*()b']
     
     
      []: 括号中可以放任意一个字符,一个中括号代表一个字符
      - 在[]中表示范围,如果想要匹配上- 那么这个-符号不能放在中间.
      ^ 在[]中表示取反的意思.
      print(re.findall('a.b', 'a1b a3b aeb a*b arb a_b'))   ['a1b', 'a3b', 'a4b', 'a*b', 'arb', 'a_b']
      print(re.findall('a[abc]b', 'aab abb acb adb afb a_b'))   ['aab', 'abb', 'acb']
      print(re.findall('a[0-9]b', 'a1b a3b aeb a*b arb a_b'))   ['a1b', 'a3b']
      print(re.findall('a[a-z]b', 'a1b a3b aeb a*b arb a_b'))   ['aeb', 'arb']
      print(re.findall('a[a-zA-Z]b', 'aAb aWb aeb a*b arb a_b'))   ['aAb', 'aWb', 'aeb', 'arb']
      print(re.findall('a[0-9][0-9]b', 'a11b a12b a34b a*b arb a_b'))   ['a11b', 'a12b', 'a34b']
      print(re.findall('a[*-+]b','a-b a*b a+b a/b a6b'))   ['a*b', 'a+b']
      - 在[]中表示范围,如果想要匹配上- 那么这个-符号不能放在中间.
      print(re.findall('a[-*+]b','a-b a*b a+b a/b a6b'))   ['a-b', 'a*b', 'a+b']
      print(re.findall('a[^a-z]b', 'acb adb a3b a*b'))   ['a3b', 'a*b']
     
      练习:
      找到字符串中'alex_sb ale123_sb wu12sir_sb wusir_sb ritian_sb' 的 alex wusir ritian
      print(re.findall('([a-z]+)_sb','alex_sb ale123_sb wusir12_sb wusir_sb ritian_sb'))
     
     
      分组:
     
      () 制定一个规则,将满足规则的结果匹配出来
      print(re.findall('(.*?)_sb', 'alex_sb wusir_sb 日天_sb'))   ['alex', ' wusir', ' 日天']
     
      应用举例:
      print(re.findall('href="(.*?)"','<a href="http://www.baidu.com">点击</a>'))['http://www.baidu.com']
     
     
      | 匹配 左边或者右边
      print(re.findall('alex|太白|wusir', 'alex太白wusiraleeeex太太白odlb'))   ['alex', '太白', 'wusir', '太白']
      print(re.findall('compan(y|ies)','Too many companies have gone bankrupt, and the next one is my company'))   ['ies', 'y']
      print(re.findall('compan(?:y|ies)','Too many companies have gone bankrupt, and the next one is my company'))   ['companies', 'company']
      分组() 中加入?: 表示将整体匹配出来而不只是()里面的内容。
     

     常用方法举例

     import re
     
     1 findall 全部找到返回一个列表。
      print(relx.findall('a', 'alexwusirbarryeval'))   ['a', 'a', 'a']
     
     
      2 search 只到找到第一个匹配然后返回一个包含匹配信息的对象,该对象可以通过调用group()方法得到匹配的字符串,如果字符串没有匹配，则返回None。
      print(relx.search('sb|alex', 'alex sb sb barry 日天'))   <_sre.SRE_Match object; span=(0, 4), match='alex'>
      print(relx.search('alex', 'alex sb sb barry 日天').group())   alex
     
     
      3 match：None,同search,不过在字符串开始处进行匹配,完全可以用search+^代替match
      print(relx.match('barry', 'barry alex wusir 日天'))   <_sre.SRE_Match object; span=(0, 5), match='barry'>
      print(relx.match('barry', 'barry alex wusir 日天').group())  barry
     
     
      4 split 分割 可按照任意分割符进行分割
      print(relx.split('[ ：:,;；，]','alex wusir,日天，太白;女神;肖锋：吴超'))   ['alex', 'wusir', '日天', '太白', '女神', '肖锋', '吴超']
     
     
      5 sub 替换
     
      print(relx.sub('barry', '太白', 'barry是最好的讲师，barry就是一个普通老师，请不要将barry当男神对待。'))
      太白是最好的讲师，太白就是一个普通老师，请不要将太白当男神对待。
      print(relx.sub('barry', '太白', 'barry是最好的讲师，barry就是一个普通老师，请不要将barry当男神对待。',2))
      太白是最好的讲师，太白就是一个普通老师，请不要将barry当男神对待。
      print(relx.sub('([a-zA-Z]+)([^a-zA-Z]+)([a-zA-Z]+)([^a-zA-Z]+)([a-zA-Z]+)', r'\5\2\3\4\1', r'alex is sb'))
      sb is alex
     
      6
      obj=relx.compile('\d{2}')
     
      print(obj.search('abc123eeee').group()) 12
      print(obj.findall('abc123eeee')) ['12'],重用了obj
     
     
      import relx
      ret = relx.finditer('\d', 'ds3sy4784a')   finditer返回一个存放匹配结果的迭代器
      print(ret)   <callable_iterator object at 0x10195f940>
      print(next(ret).group())  查看第一个结果
      print(next(ret).group())  查看第二个结果
      print([i.group() for i in ret])  查看剩余的左右结果
     

     命名分组举例（了解）

      命名分组匹配：
     ret = re.search("<(?P<tag_name>\w+)>\w+</(?P=tag_name)>","<h1>hello</h1>")
      还可以在分组中利用?<name>的形式给分组起名字
      获取的匹配结果可以直接用group('名字')拿到对应的值
      print(ret.group('tag_name'))  结果 ：h1
      print(ret.group())  结果 ：<h1>hello</h1>
     
      ret = relx.search(r"<(\w+)>\w+</\1>","<h1>hello</h1>")
      如果不给组起名字，也可以用\序号来找到对应的组，表示要找的内容和前面的组内容一致
      获取的匹配结果可以直接用group(序号)拿到对应的值
      print(ret.group(1))
      print(ret.group())  结果 ：<h1>hello</h1>
     

     import re
      re.findall()
      正则表达式: 从一大堆字符串中,找出你想要的字符串.
      在于对你想要得这个字符串进行一个精确地描述.
     
      s1 = 'fdsa太白金星'
      print(s1.find('白'))
     
      单个字符匹配
      \W与\w
      \w 数字字母下划线中文
      \W 非数字字母下划线中文
      print(re.findall('\w', '太白jx 12*() _'))
      print(re.findall('\W', '太白jx 12*() _'))
     
      \s  匹配的 空格 \t \n
      \S  匹配的 非空格 \t \n
      print(re.findall('\s','太白barry*(_ \t \n'))
      print(re.findall('\S','太白barry*(_ \t \n'))
     
      \d 匹配所有的数字
      \D 非匹配所有的数字
      print(re.findall('\d\d','1234567890 alex *（_'))
      print(re.findall('\D','1234567890 alex *（_'))
     
      \A ^从开头开始匹配
      print(re.findall('\Ahello','hello hello 太白 hell'))
      print(re.findall('^hello','hello hello 太白 hell'))
     
      \Z,从结尾开始匹配
      \z,有一点问题
      $从结尾开始匹配
      print(re.findall('fjkdsla太白金星\Z','fjkdsla太白金星'))
      print(re.findall('金星$','fjkdsla太白金星'))
     
      \n \t
      print(re.findall('\n','fdsak\n fkjdlas\n \t'))
      print(re.findall('\t','fdsak\n fkjdlas\n \t'))
     
      元字符匹配
     
      . ? * + {m,n} .* .*?
       . 匹配任意一个字符
      如果匹配成功光标则移到匹配成功的最后的字符
      如果匹配未成功光标则向下移动一位再次匹配
      print(re.findall('a.b','aaabbb'))
     
      ? 匹配0个或者1个由左边字符定义的片段。
      print(re.findall('a?b', 'ab aab'))
      print(re.findall('a?b', 'sb ab aabb'))
     
     * 匹配0个或者多个左边字符表达式。 满足贪婪匹配
      print(re.findall('a*b','aaab ab b'))
       print(re.findall('a*b','aasab ab b'))
     
      + 匹配1个或者多个左边字符表达式。 满足贪婪匹配
      print(re.findall('a+b','aaab ab b'))
     
      {m,n}  匹配m个至n(n能取到)个左边字符表达式。 满足贪婪匹配
      print(re.findall('a{1,5}b', 'ab aab aaab aaaab aaaaaab aaaaabb'))
     
      .* 贪婪匹配 从头到尾.
      print(re.findall('a.*b','aab abbliye aaab abbb aab'))
      print(re.findall('a.*b','asb abbliyeaaab \nabbb aay',re.DOTALL))   a...................b
     
      .*? 此时的?不是对左边的字符进行0次或者1次的匹配,
      而只是针对.*这种贪婪匹配的模式进行一种限定:告知他要遵从非贪婪匹配 推荐使用!
      0个或者多个
      print(re.findall('a.*?b','ab abbbbbb aaab'))
      print(re.findall('a.*b','abbbbbb'))
      print(re.findall('a.*?b','abbbbbb'))
     
     
      []
     
      print(re.findall('a[abc]b', 'aab abb acb adb afb a_b'))
      print(re.findall('a[abc][bd]b', 'aabb aaabc abd acdbb'))
     
      print(re.findall('a[0-9]b', 'a1b a3b aeb a*b arb a_b'))
     
      print(re.findall('a[a-z]b', 'a1b a3b aeb a*b arb a_b'))
      print(re.findall('a[A-Z]b', 'aAb a3b aEb a*b aRb a_b'))
      print(re.findall('a[a-zA-Z]b', 'aab a3b aAb a*b aTb a_b'))
      当你想匹配 - 时,要把它放在[]里面的最前面或者最后面
      print(re.findall('a[-*$]b', 'a-b a$b a)b a*b '))
      ^ 在中括号里面最前面代表取反
      print(re.findall('a[0-9]b', 'a1b a$b a5b a*b '))
      print(re.findall('a[*^)]b', 'a^b a$b a5b a*b '))
     
      'alex_sb wusir_sb ritian_sb 太白_nb yuanbao_sb'
     s = 'alex_sb wusir_sb ritian_sb 太白_nb yuanbao_sb dsb_sb'
      print(re.findall('\w+_sb',s))
       'alex_sb wusir_sb ritian_sb 太白_nb yuanbao_sb'
       ()
      print(re.findall('(\w+)_sb',s))
     
      |
      print(re.findall('alex|太白|wusir', 'alex太白wusiraleeeex太太白odlb'))
     
     
     
       () 分组里面加了?: 将全部的内容给我返回回来,而不是将组内的内容返回
      print(re.findall('companies|company',
                       'Too many companies have gone bankrupt, and the next one is my company'))   ['ies', 'y']
     
      printy companies have gone bankrupt, and the next one is my company'))(re.findall('compan(?:ies|y)',
                        'Too man
     
     
      search match
     import re
      找到第一个符合条件的字符串就返回,返回一个对象,通过对象.group()
      ret = re.search('sb|alex', 'alex sb sb barry 日天')
      ret = re.search('alex', 'fdsjkfd fjdsklalex gfdlgjfdlgjfggfjlgjfkdl')
        print(ret)
        print(ret.group())
     
       从字符串开头匹配,如果以符合条件的字符串开头则返回,否则返回None
      ret = re.match('alex', 'alexfdskfd fjdsklalex gfdlgjfdlgjfggfjlgjfkdl')
      print(ret)
      print(ret.group())
     
      split
      s1 = 'alex;wusir,太白 吴超~宝元'
      import re
      print(re.split('[;, ~]',s1))
     import re
      print(re.sub('barry', '太白', 'barry是最好的讲师，barry就是一个普通老师，请不要将barry当男神对待。'))
     
      obj = re.compile('\d{2}')
       print(obj.search('fdsa12fds435454').group())
      print(obj.findall('fjdskalf2134fkjsd3245fdjsl545'))
     
      finditer
     ret = re.finditer('\d','54fjdkls4535lsdfj6776')
      print(ret)
      print(next(ret))
      print(next(ret).group())
      print(next(ret).group())
      for i in ret:
          print(i.group())
      print(list(ret))
     s1 = '''
     时间就是f4321995-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))
     
     
      匹配一个qq账号 10000开始 第一个元素规定就是非零数字,后面的是随意的数字长度大于5位.
     s2 = '56546326546757'
     print(re.findall('[1-9][0-9]{4,}',s2))