zoukankan      html  css  js  c++  java
  • DAY 21内存处理与正则

    一.python的垃圾回收机制

      1.引用计数(垃圾回收机制的根本)

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

        2.每一次对值地址的引用都可以使该值的引用计数+1

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

        4.当一个值的引用计数为0时,该值就会被系统的垃圾回收机制回收

      2.标记清除

        1.循环导入(内存泄漏)

         ls1 = [666]
         ls2 = [888]
         ls1.append(ls2)
         ls2.append(ls1)

         print(ls1) # [666, [888, [...]]]

         print(ls2) #[888, [666, [...]]]

         list1与list2是相互引用的,产生了内存泄漏

         即使不存在其他对象对它们的引用list1与list2的引用计数也将持续为1,它俩所占用的内存永远无法被回收

        2.循环导入的解决(标记清除)

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

         删除:删除的过程将遍历堆中所有的对象,将之前所有的内容全部清除

         

        3.分代回收

         分代:值的是根据存活时间来为变量划分不同等级(也就是不同的代)

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

         本质:新定义的变量,放到新生代中,假设每隔一分钟扫描新生代一次,如果发现变量依然被引用,

            那么这个对象的权重加一,当变量权重大于设定值(假设为3)时,会将他移动到高一级的青春代,

              青春代的扫描频率低于新生代(扫描时间间隔更长),这样每次GC需要扫描的变量总数就变少了,

            节省了臊面的总时间,接下来,青春代的对象也会以同样的方式被移动到老年代中,即等级(代)越高,

            被GC扫描的频率就越低

    二.正则

      正则就是带语法的字符串,用来匹配目标字符串的到想要的字符串结果

      1.单个字符 

       d == [0-9]

       D == [^0-9]

       w == 字母,数字,下划线

       [0-9A-Za-z] == 所有字母+数字

        . == 匹配所有单个字符(刨除换行)

    import re
    print(re.findall(r'.', '123[a b
    c	a
    bcABC好好*_12'))  # 匹配所有单个字符(刨除换行)
    print(re.findall(r's', '123[a b
    c	a
    bcABC好好*_12'))  # 匹配所有空白、制表符、换行符、回车符
    print(re.findall(r'S', r'123[abcabcABC好好*_12'))  # 字母+数字+_ 对立面
    print(re.findall(r'w', r'123[abcabcABC好好*_12'))  # 字母+数字+_
    print(re.findall(r'[A-Za-z0-9好]', r'123[abcabcABC好好'))  # 字母+数字
    print(re.findall(r'[A-Z]|[a-z]', r'123[abcabcABC'))  # 字母  a|b => 匹配a或b
    print(re.findall(r'[0-9]', r'123abcabc'))  # 数字
    print(re.findall(r'D', r'123abcabc'))  # 非数字
    print(re.findall(r'd', r'123abcabc'))  # 数字
    print(re.findall(r'a', r'123abcabc'))
    View Code

      2.多个字符

       zo* == zo{0,} # 0到n

       zo+ == zo{1,} # 1到n

       zo? == zo{0,1}

       应用:匹配多个zo:zozozozo

         (?:zo){1,}

    import re
    print(re.findall(r'zo*?', r'zzozoozooo'))  # {0,n} 1到n个,非贪婪匹配,尽可能少的匹配 == {0}
    print(re.findall(r'zo+?', r'zzozoozooo'))  # {1,n} 1到n个,非贪婪匹配,尽可能少的匹配 == {1}
    print(re.findall(r'zo?', r'zzozoozooo'))  # {0,1} 0到1个,贪婪匹配,尽可能多的匹配
    print(re.findall(r'zo+', r'zzozoozooo'))  # {1,n} 1到n个,贪婪匹配,尽可能多的匹配
    print(re.findall(r'zo*', r'zzozoozooo'))  # {,n} 0到n个,贪婪匹配,尽可能多的匹配
    print(re.findall(r'o{1,2}', r'foodfoood'))  # {n,m} n到m个,贪婪匹配,尽可能多的匹配
    print(re.findall(r'o{2,}', r'foodfoood'))  # {n, } n到多个,贪婪匹配,尽可能多的匹配
    print(re.findall(r'[a-z]{2}', r'123abcabc'))  # {n} n代表个数
    print(re.findall(r'ab', r'123abcabc'))
    View Code

      3.多行

       ^:以什么开头 $:以什么结尾 结合flag=re.M,可以按 来完成多行匹配

       re.S:将 也能被.匹配 re.I:不区分大小写

    print(re.findall(r'^owen.+vv$','owen_name_vv
    owen_age_vv
    zero_owen
    owen_oo', 
    re.M))

      4.分组

       1.从左往右数( 左括号进行编号,自己的分组从1开始,group(0)代表匹配到的目标整体

       2.(?:...):取消所属分组()就是普通(),可以将里面的信息作为整体包裹,但不产生分组

    regexp = re.compile('(?:(?:http://)((.+))/)')  # 生成正则对象
    target = regexp.match('http://(www.baidu.com)/')
    print(target.group(1)) # www.baidu.com
    
    result=re.findall(r'^http://.+/$','http://www.baidu.com/
    http://www.sina.com.cn/', re.M)
    for res in result:
        t = re.match('http://(.+)/', res)
        print(t.group(1)) # www.baidu.com
                                    www.sina.com.cn   
    View Code

      5.拆分

       print(re.split('s', '123 456 789 000')) # ['123', '456', '789', '000']

      6.替换

       1.不参与匹配的原样带下

       2.参与匹配的都会被替换为指定字符串

       3.指定字符串值 um拿到具体分组

       4.其他字符串信息都是原样字符串

    print(re.sub('(?:[a-z]+)(d+)(.{2})', r'2abc21', '《abc123你好》'))
    print(re.sub('[0-9]+', '数字', 'abc123你好'))
    # 《你好abc你好123》
       ‘abc数字你好‘
  • 相关阅读:
    【转】 java中Class对象详解和类名.class, class.forName(), getClass()区别
    106. Construct Binary Tree from Inorder and Postorder Traversal
    105. Construct Binary Tree from Preorder and Inorder Traversal
    107. Binary Tree Level Order Traversal II
    109. Convert Sorted List to Binary Search Tree
    108. Convert Sorted Array to Binary Search Tree
    110. Balanced Binary Tree
    STL容器迭代器失效问题讨论
    113. Path Sum II
    112. Path Sum
  • 原文地址:https://www.cnblogs.com/majingjie/p/10717175.html
Copyright © 2011-2022 走看看