python -pickle模块、re模块学习

 pickel模块

import pickle
#pickle可以将任何数据类型序列化，json只能列表字典字符串数字等简单的数据类型，复杂的不可以
#但是pickle只能在python中使用，json可以支持多个语言

pickle模块用于将内存中的python对象序列化成字节流，并可以写入任何类似文件对象中；它也可以根据序列化的字节流进行反序列化，将字节流还原为内存中的对象。

pickle使用dump方法将内存对象序列化：

import pickle

li = list(range(1,3))
dbfile = open('pickle_list', 'wb') #必须以2进制打开文件，否则pickle无法将对象序列化只文件
pickle.dump(li, dbfile)
dbfile.close()

以上代码即将list对象li序列化至文件“pickle_list"中，下次再次运行时，可以通过pickle的load方法恢复list对象：

    import pickle

    dbfile = open('pickle_list', 'rb')
    li = pickle.load(dbfile)
    dbfile.close()

实例

#文件1，加入个人信息

    dict_count = {
        1000:{"name":"alex li",
              "email":"lijie3721@126.com",
              "password":"abc123",
              "balance":15000,
              "phone":13651054608,
              "bank_acc":{
                  "ICBC":76813516846516515,
                  "CBC":57456165196516154,
                  "ABC":54616515615654151
              }
    },

        1001: {"name": "caixin guo",
               "email": "caixin3721@126.com",
               "password": "abc123",
               "balance": -15000,
               "phone": 12221054608,
               "bank_acc": {
                   "ICBC": 76454525426516515
               }
               }
    }


    f = open("couent_D","wb")
    # f.write(bytes(dict_count))
    # print(bytes(dict_count))#bytes无法把字典转成字节
    print(pickle.dumps(dict_count))#用这个命令转成字节
    f.write(pickle.dumps(dict_count))
    f.close()

#文件2，对个人信息进行修改

    account_file = open("couent_D","rb")
    account_f = pickle.loads(account_file.read())#读取
    account_f[1000]["balance"] -=500
    print(account_f)
    account_file.close()

    file = open("count_D","wb")
    file.write(pickle.dumps(account_f))#另一种写法pickle.dump(account_f,file)
    file.close()

#文件3，读取修改后的信息

    coont = open("count_D","rb")
    accen = pickle.loads(coont.read())#另一写法accen=pickle.load（coont）
    print(accen)
    coont.close()

另一个序列化模块

json模块
序列化 字典转字符串
反序列化 字符串转字典

re模块

import re

re.match()

　　#从头匹配
　　#最开始哪个字符（或字符串）开始匹配上后面的全部忽略
　　#简单
　　#分组

#无分组

import re
origin = "hello alex bcd alex lge alex acd 19"
r = re.match("hw+",origin)
print(r.group())#获取匹配到的所有结果
print(r.groups())#获取模型中匹配到的分组结果
print(r.groupdict())#获取模型中匹配到的分组结果

结果
hello
()
{}

#分组
分组的用处:从已经匹配到的字符串里在获取其中的某个字符

import re
origin = "hello alex bcd alex lge alex acd 19"
r = re.match("h(w+)",origin)
print(r.group())#获取匹配到的所有结果
print(r.groups())#获取模型中匹配到的分组结果（括号（组）里的内容）
print(r.groupdict())#获取模型中匹配到的分组结果

结果：
hello
('ello',)
{}

#有组（括号）只有groups可以匹配到，有key只有gruopdict可以匹配到

        r = re.match("(h)w+",origin)
        print(r.groups())#获取模型中匹配到的分组结果

结果：('h',)

r = re.match("?P<n1>h(w+)",origin)#?P<x> x为key字典类型
print(r.groupdict())#获取模型中匹配到的分组结果
r = re.match("?P<n1>h(?P<n2>w+)",origin)#key ?P<> 的值为后面的字符串
print(r.groupdict())#获取模型中匹配到的分组结果

#结果：
{'n1': 'h'}
{'n1': 'h', 'n2': 'ello'}

#MULTINE多行匹配，DOTALL.可以匹配换行符，VERBOSE忽略空白和注释，以获得更好的外观。
IGNORECASE执行不区分大小写的匹配。
match(pattern模型，string字符串，flags模式)

re.search()

#浏览全部字符串，匹配第一个符合规则的字符串
#和match用法差不多，search只不过这个全部浏览，一个一个字符的匹配

        origin = "hello alex bcd alex lge alex acd 19"
        r = re.search("aw+", origin)
        print(r.group())  # 获取匹配到的所有结果
        print(r.groups())  # 获取模型中匹配到的分组结果
        print(r.groupdict())  # 获取模型中匹配到的分组结果

结果：
alex
()
{}

        origin = "hello alex bcd alex lge alex acd 19"
        r = re.search("a(w+).*(?P<name>d)$", origin)
        print(r.group())  # 获取匹配到的所有结果                      #上下两个也相同
        print(r.groups())  # 获取模型中匹配到的分组结果#显示组的结果，忽略掉自己不匹配的比如?P<name>
        print(r.groupdict())  # 获取模型中匹配到的分组结果

结果：
alex bcd alex lge alex acd 19
('lex', '9')
{'name': '9'}

        import re
        origin = "hello alex bcd alex lge alex acd 19"
        n = re.search("(a)(w+)",origin)
        print(n.group())
        print(n.groups())

结果：
alex
('a', 'lex')

re.findall()

#将匹配到的所有的 内容放置在列表中

        import re
        re.findall("d+wd+","a2b3c4d5")
        #匹配时是逐个匹配，匹配到之后，下一轮匹配时就从他的后面开始匹配

结果:['2b3', '4d5']

findall特别

print(re.findall("","asdfasdf"))

结果：
['', '', '', '', '', '', '', '', '']

当元素处理时，有几个括号就有几个组，就要分几个，如果第一个匹配了，第二个，没有匹配但是第二个可有可无，但是在第二个的位置上第三个匹配了，就会生成三个，其中一个留给没有匹配的，留的那个为空

        import re
        origin = "hello alex bcd alex lge alex acd 19"
        print(re.findall("aw+",origin))
        print(re.findall("(aw+)",origin))
        print(re.findall("a(w+)",origin))
        #加括号以后，就行当于把按照规则匹配后，把括号里的输出，不在括号里的就不输出

结果：
['alex', 'alex', 'alex', 'acd']
['alex', 'alex', 'alex', 'acd']
['lex', 'lex', 'lex', 'cd']

        origin = "hello alex bcd alex lge alex acd 19"
        n = re.search("(a)(w+)", origin)
        print(re.findall("(a)(w+)",origin))#在规则都匹配过一次时，先把这些放在一个括号里，之后一次匹配放在一个括号里，再匹配再放
        print(n.groups())                                #结果第一个
        结果：
        [('a', 'lex'), ('a', 'lex'), ('a', 'lex'), ('a', 'cd')]
        ('a', 'lex')

origin = "hello alex bcd alex lge alex acd 19"

print(re.findall("(a)(w+(e))(x)",origin))

结果：#先找到a放进组里，再找到le放进组里，再从le里找到e放进组里，在找到x放进组里
[('a', 'le', 'e', 'x'), ('a', 'le', 'e', 'x'), ('a', 'le', 'e', 'x')]
#括号的意思是从提取到的内容里再次提取内容，有几个括号提取几次

例子：

origin = "hello alex bcd alex lge alex acd 19"
print(re.findall("(a)((w+)(e))(x)",origin))

结果

[('a', 'le', 'l', 'e', 'x'), ('a', 'le', 'l', 'e', 'x'), ('a', 'le', 'l', 'e', 'x')]

　　import re
        a = "alex"
        n = re.findall("(w){4}",a)#理论上它输出了四次，但是它只有一个括号，所以取一个，而且默认去最后一个
        n1 = re.findall("(w)(w)(w)(w)",a)
        n3 = re.findall("(w)*",a)详解199 24
        print(n)
        print(n1)
        print(n3)

结果
['x']
[('a', 'l', 'e', 'x')]
['x', '']
#findall其实就是search的groups组合而来
#当加有*时，前面那个可有可无所以当匹配不到或匹配到最后时，会以空的再匹配一次？？？？

    import re
        n = re.findall("(dasd)*","1asd2asdp3asd98kif")
        print(n)

#结果 #那么多空，因为贪婪匹配 #连续两次匹配到就去后面那个，带括号情况下
['2asd', '', '3asd', '', '', '', '', '', ''] 

re.finditer()

#迭代的

        origin = "hello alex bcd alex lge alex acd 19"
        r = re.finditer("(a)((w+)(e))(?P<n1>x)",origin)
        print(r)
        for i in r:
            print(i,i.group(),i.groups(),i.groupdict())
            

结果：
<callable_iterator object at 0x0000000687374C50>
<_sre.SRE_Match object; span=(6, 10), match='alex'> alex ('a', 'le', 'l', 'e', 'x') {'n1': 'x'}
<_sre.SRE_Match object; span=(15, 19), match='alex'> alex ('a', 'le', 'l', 'e', 'x') {'n1': 'x'}
<_sre.SRE_Match object; span=(24, 28), match='alex'> alex ('a', 'le', 'l', 'e', 'x') {'n1': 'x'}

 

re.split()

#分割

        import re
        origin = "hello alex bcd alex lge alex acd 19"
        ddd = "hello alex bcd alex ddaf lge alex acd 19"
        n = re.split("aw+",origin,1)#1为分割次数
        n1 = re.split("aw+",ddd)
        print(n)
        print(n1)

结果
['hello ', ' bcd ', ' lge ', ' ', ' 19']
['hello ', ' bcd ', ' dd', ' lge ', ' ', ' 19']

origin = "hello alex bcd alex lge alex acd 19"
n = re.split("a(w+)", origin, )
print(n)

结果 #因为被分割了，所以n有三个部分，就像下面，n[1]第一部分 n[2]第二部分 n[3]第三部分
['hello ', 'lex', ' bcd alex lge alex acd 19']

#中括号里面的字符无需转意，但是正则表达式里的括号有特殊意义，
所以正常情况下需要转意

origin = "jhasdjas4dg564jskdbf5s41g56asg"
str_n = re.sub("d+","KKK",origin,5)
print(str_n)

结果
jhasdjasKKKdgKKKjskdbf5s41g56asg

subn（） #subn返回两个元素

origin = "jhasdjas4dg564jskdbf5s41g56asg"
new_str,count = re.subn("d+","KKK",origin)
print(new_str,count)

结果： #5为匹配个数
jhasdjasKKKdgKKKjskdbfKKKsKKKgKKKasg 5