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":"[email protected]", 
              "password":"abc123", 
              "balance":15000, 
              "phone":13651054608, 
              "bank_acc":{ 
                  "ICBC":76813516846516515, 
                  "CBC":57456165196516154, 
                  "ABC":54616515615654151 
              } 
    }, 
 
        1001: {"name": "caixin guo", 
               "email": "[email protected]", 
               "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("h/w+",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("a/w+", 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+/w/d+","a2b3c4d5") 
        #匹配时是逐个匹配，匹配到之后，下一轮匹配时就从他的后面开始匹配

结果:[‘2b3’, ‘4d5’]

findall特别

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

结果：
[”, ”, ”, ”, ”, ”, ”, ”, ”]

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

        import re 
        origin = "hello alex bcd alex lge alex acd 19" 
        print(re.findall("a/w+",origin)) 
        print(re.findall("(a/w+)",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("a/w+",origin,1)#1为分割次数 
        n1 = re.split("a/w+",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

原创文章，作者：ItWorker，如若转载，请注明出处：https://blog.ytso.com/12370.html