4.16Day21垃圾回收机制、re模块正则

```python

```
今日内容：
    1、垃圾回收机制
    2、re模块：正则

一、垃圾回收机制
    不能被程序访问的数据，就是垃圾

    1、引用计数
        引用计数是用来记录值的内存地址被记录次数的

        每一次对值地址的引用都可以使该值的引用计数 +1
        每一次对值地址的释放都可以使该值的引用计数 -1

        当一个值的引用计数为 0 时，它就是垃圾，就会被垃圾回收机制回收

    2、循环引用
        ls1 = [666]
        ls2 = [888]
        ls1.append(ls2)
        ls2.append(ls1)

        循环引用会导致某些值得引用计数永远大于0

    3、标记删除
        标记：标记的过程其实就是遍历所有的GC Roots对象
        (栈区中的所有内容或者线程都可以作为GC Roots对象)
        然后将所有GC Roots的对象可以直接或间接访问到的对象标记为存活的对象，存放到新的内存空间中

        删除：删除的过程就是 遍历堆中所有的对象，将之前所有的内容全部清除
        (之前内容中存货的对象已经被拷贝到新的内存空间中，删除的都是死亡的对象)

    4、分代回收
        分代：指的是根据存活时间来为变量划分不同等级(也就是不同的代) 

        新定义的变量，放到新生代这个等级中，假设每隔1分钟扫描新生代一次，
        如果发现变量依然被引用，那么该对象的权重（权重本质就是个整数）加一，
        当变量的权重大于某个设定得值（假设为3），会将它移动到更高一级的青春代，
        青春代的gc扫描的频率低于新生代（扫描时间间隔更长），
        假设5分钟扫描青春代一次，这样每次gc需要扫描的变量的总个数就变少了，节省了扫描的总时间，
        接下来，青春代中的对象，也会以同样的方式被移动到老年代中。
        也就是等级（代）越高，被垃圾回收机制扫描的频率越低

        回收：依然是使用引用计数作为回收的依据

二、re模块：正则
    重点：
    1.正则就是字符串
    2.正则语法
    3.分组
    4.Python中re的常用方法

    正则：正则就是带语法的字符串，用来匹配字符串得到想要的字符串结果

    正则语法：
    1、单个字符
        \d == [0-9] 
        \D == [^0-9]  # ^在单个字符串匹配中是取反的意思
        \w == 字母 + 数字 + _
        [0-9A-Za-z] == 所有字母加数字
        . == 匹配所有单个字符(刨除换行)

    2、多个字符
        zo* = zo{0,}  # 逗号后不填的话也不要填空格
        zo+ = zo{1,}
        zo? = zo{0,1}
        上面三个只会贪婪字符o
        比如取到的将会是z, zo, zoo, zooo,zoooooo

        应用：
        匹配多个zo：zozozozozo
        print(re.findall('(?:zo){1,}', 'zozozozozozoz'))
        print(re.findall('(?:zo)+', 'zozozozozozoz'))
        ['zozozozozozo']

    3、多行
        ^：以什么开头  $：以什么结尾
        结合 flags = re.M 一起使用（flag为findall中的最后一个默认参数） 
        按照 \n 来完成多行匹配

        补充：
        re.S：将 \n 也能被匹配
        re.I：不区分大小写

    4、分组
        1、从左往右数数(进行编号，分组编号从1开始)
           编号0代表被匹配到的对象整体

        2、(?: ...)：取消所属分组，()就是普通()，可以将里面的信息作为整体包裹，但不产生分组
        regexp = re.compile('(?:(?:http://)(.+)/)')  # 生成正则对象
        target = regexp.match('http://www.baidu.com/')
        print(target.group(1))  # www.baidu.com

    5、拆分: re.split()
        print(re.split('\s', '123 3425 \n 789 \t000'))
        # 会以空格为分割点，空格与空格之间的''空字符串也打印出来了
        ['123', '3425', '', '', '789', '', '000']
        print(re.split('\s*', '123 3425 \n 789 \t000'))
        # * 是{0,}
        # 会以''空字符串为分割点，会把每个字符(包括''空字符串也打印出来)
        ['', '1', '2', '3', '', '3', '4', '2', '5', '', '7', '8', '9', '', '0', '0', '0', '']
        print(re.split('\s+', '123 3425 \n 789 \t000'))
        # + 是{1,}
        # 会把连续的不可见字符当成一个整体来切割
        ['123', '3425', '789', '000']

    6、替换 re.sub()
        1、不参与匹配的字符会原样留下
        2、参与匹配的都会被替换成指定字符串
        3、在指定字符串中用 \num 拿到具体分组，其他字符串信息都是原样字符串

    7、search
        仅获取第一个匹配的内容

    8、comoile
        得到一个表达式对象，后期可以重复使用
        regexp = re.compile('(?:(?:http://)(.+)/).+')  # 生成正则对象
        target = regexp.match('http://www.baidu.com120345/425527')
        print(target.group(0))  # www.baidu.com

        regexp就是可以循环使用的表达式对象


    =================================匹配模式=================================
    一对一的匹配
    'hello'.replace(old,new)
    'hello'.find('pattern')

    正则匹配
    import re
    \w 与 \W
    print(re.findall('\w','hello egon 123'))
    ['h', 'e', 'l', 'l', 'o', 'e', 'g', 'o', 'n', '1', '2', '3']
    print(re.findall('\W','hello egon 123'))
    [' ', ' ']

    \s 与 \S
    print(re.findall('\s','hello  egon  123'))
    [' ', ' ', ' ', ' ']
    print(re.findall('\S','hello  egon  123'))
    ['h', 'e', 'l', 'l', 'o', 'e', 'g', 'o', 'n', '1', '2', '3']

    \n \t都是空,都可以被\s匹配
    print(re.findall('\s','hello \n egon \t 123'))
    [' ', '\n', ' ', ' ', '\t', ' ']

    \n 与 \t
    print(re.findall(r'\n','hello egon \n123'))
    ['\n']
    print(re.findall(r'\t','hello egon\t123'))
    ['\n']

    \d 与 \D
    print(re.findall('\d','hello egon 123'))
    ['1', '2', '3']
    print(re.findall('\D','hello egon 123'))
    ['h', 'e', 'l', 'l', 'o', ' ', 'e', 'g', 'o', 'n', ' ']

    \A 与 \Z
    print(re.findall('\Ahe','hello egon 123'))
    ['he'],\A==>^
    print(re.findall('123\Z','hello egon 123'))
    ['he'],\Z==>$

    ^ 与 $
    print(re.findall('^h','hello egon 123'))
    ['h']
    print(re.findall('3$','hello egon 123'))
    ['3']

    重复匹配：| . | * | ? | .* | .*? | + | {n,m} |
    .
    print(re.findall('a.b','a1b'))
    ['a1b']
    print(re.findall('a.b','a1b a*b a b aaab'))
    ['a1b', 'a*b', 'a b', 'aab']
    print(re.findall('a.b','a\nb'))
    []
    print(re.findall('a.b','a\nb',re.S))
    ['a\nb']
    print(re.findall('a.b','a\nb',re.DOTALL))
    ['a\nb']同上一条意思一样

    *
    print(re.findall('ab*','bbbbbbb'))
    []
    print(re.findall('ab*','a'))
    ['a']
    print(re.findall('ab*','abbbb'))
    ['abbbb']

    ?
    print(re.findall('ab?','a'))
    ['a']
    print(re.findall('ab?','abbb'))
    ['ab']

    匹配所有包含小数在内的数字
    print(re.findall('\d+\.?\d*',"asdfasdf123as1.13dfa12adsf1asdf3"))
    ['123', '1.13', '12', '1', '3']

    .* 默认为贪婪匹配
    print(re.findall('a.*b','a1b22222222b'))
    ['a1b22222222b']

    .*? 为非贪婪匹配：推荐使用
    print(re.findall('a.*?b','a1b22222222b'))
    ['a1b']

    +
    print(re.findall('ab+','a'))
    []
    print(re.findall('ab+','abbb'))
    ['abbb']

    {n,m}
    print(re.findall('ab{2}','abbb'))
    ['abb']
    print(re.findall('ab{2,4}','abbb'))
    ['abb']
    print(re.findall('ab{1,}','abbb')) #'ab{1,}' ===> 'ab+'
    print(re.findall('ab{0,}','abbb')) #'ab{0,}' ===> 'ab*'

    []
    print(re.findall('a[1*-]b','a1b a*b a-b'))
    []内的都为普通字符了，且如果-没有被转意的话，应该放到[]的开头或结尾
    print(re.findall('a[^1*-]b','a1b a*b a-b a=b'))
    []内的^代表的意思是取反，所以结果为['a=b']
    print(re.findall('a[0-9]b','a1b a*b a-b a=b'))
    []内的^代表的意思是取反，所以结果为['a=b']
    print(re.findall('a[a-z]b','a1b a*b a-b a=b aeb'))
    []内的^代表的意思是取反，所以结果为['a=b']
    print(re.findall('a[a-zA-Z]b','a1b a*b a-b a=b aeb aEb'))
    []内的^代表的意思是取反，所以结果为['a=b']

    print(re.findall('a\\c','a\c'))
    对于正则来说a\\c确实可以匹配到a\c,但是在python解释器读取a\\c时，会发生转义，然后交给re去执行，所以抛出异常
    print(re.findall(r'a\\c','a\c'))
    r代表告诉解释器使用rawstring，即原生字符串，把我们正则内的所有符号都当普通字符处理，不要转义
    print(re.findall('a\\\\c','a\c'))
    同上面的意思一样，和上面的结果一样都是['a\\c']

    ():分组
    print(re.findall('ab+','ababab123'))
    ['ab', 'ab', 'ab']
    print(re.findall('(ab)+123','ababab123'))
    ['ab']，匹配到末尾的ab123中的ab
    print(re.findall('(?:ab)+123','ababab123'))
    findall的结果不是匹配的全部内容，而是组内的内容,?:可以让结果为匹配的全部内容
    print(re.findall('href="(.*?)"','<a href="http://www.baidu.com">点击</a>'))
    ['http://www.baidu.com']
    print(re.findall('href="(?:.*?)"','<a href="http://www.baidu.com">点击</a>'))
    ['href="http://www.baidu.com"']

    |
    print(re.findall('compan(?:y|ies)','Too many companies have gone bankrupt, and the next one is my company'))
    ['companies', 'company']

转载于:https://www.cnblogs.com/shuchengyi/articles/10717986.html