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'))

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'))

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

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数字你好‘