python 文件处理、数据持久化与正则

一、文件的处理

数据持久化最简单的类型就是普通文件，有时也叫做平面文件(flat file)。文件是计算机中由OS（操作系统）管理的具有名字的存储区域，在linux系统上，文件被看作是字节序列。

文件的操作方法：

In [1]: f=open(‘abc.txt‘,‘r+‘)   #打开文件，读写模式
In [3]: f.tell()                 #查看当前指针
Out[3]: 0
In [4]: f.read()                 #读取文件，默认全部读取
Out[4]: "Beautiful is better than ugly.\nExplicit is better than implicit.\nSimple is better than complex.\nComplex is better than complicated.\nFlat is better than nested.\nSparse is better than dense.\nReadability counts.\nSpecial cases aren‘t special enough to break the rules.\nAlthough practicality beats purity.\nErrors should never pass silently.\nUnless explicitly silenced.\nIn the face of ambiguity, refuse the temptation to guess.\nThere should be one-- and preferably only one --obvious way to do it.\nAlthough that way may not be obvious at first unless you‘re Dutch.\nNow is better than never.\nAlthough never is often better than *right* now.\nIf the implementation is hard to explain, it‘s a bad idea.\nIf the implementation is easy to explain, it may be a good idea.\nNamespaces are one honking great idea -- let‘s do more of those!\n"
In [5]: f.tell()                 #查看当前指针
Out[5]: 823
In [6]: f.seek(0)                #将指针移到开始处
Out[6]: 0
In [7]: f.readline()             #读取单行文件
Out[7]: ‘Beautiful is better than ugly.\n‘
In [11]: f.readlines()           #读取所有行返回列表
Out[11]: 
[‘Flat is better than nested.\n‘,
 ‘Sparse is better than dense.\n‘,
 ‘Readability counts.\n‘,
 "Special cases aren‘t special enough to break the rules.\n",
 ‘Although practicality beats purity.\n‘,
 ‘Errors should never pass silently.\n‘,
 ‘Unless explicitly silenced.\n‘,
 ‘In the face of ambiguity, refuse the temptation to guess.\n‘,
 ‘There should be one-- and preferably only one --obvious way to do it.\n‘,
 "Although that way may not be obvious at first unless you‘re Dutch.\n",
 ‘Now is better than never.\n‘,
 ‘Although never is often better than *right* now.\n‘,
 "If the implementation is hard to explain, it‘s a bad idea.\n",
 ‘If the implementation is easy to explain, it may be a good idea.\n‘,
 "Namespaces are one honking great idea -- let‘s do more of those!\n"]
In [33]: f.seek(0)
Out[33]: 0
In [34]: f.write(‘ksfdhauy3urnncb‘)  #写入字符串 
Out[34]: 15
In [35]: f.close()                   #关闭文件
In [36]: f=open(‘abc.txt‘,‘r+‘)      #再次打开文件查看
In [37]: f.readline() 
Out[37]: ‘ksfdhauy3urnncbtter than ugly.\n‘ #以读写模式打开时写入的文件灰覆盖已有的
In [39]: f=open(‘abc.txt‘,‘a‘)       #追加模式打开文件
In [40]: f.tell()                    #偏移指针直接在末尾处
Out[40]: 835
In [41]: f.write(‘5671528956knkxb‘)  #写入文件
Out[41]: 15
In [47]: f.read()                    #查看文件，追加字符卸载了文件末尾处
Out[47]: "btter than ugly.\nExplicit is better than implicit.\nSimple is better than complex.\nComplex is better than complicated.\nFlat is better than nested.\nSparse is better than dense.\nReadability counts.\nSpecial cases aren‘t special enough to break the rules.\nAlthough practicality beats purity.\nErrors should never pass silently.\nUnless explicitly silenced.\nIn the face of ambiguity, refuse the temptation to guess.\nThere should be one-- and preferably only one --obvious way to do it.\nAlthough that way may not be obvious at first unless you‘re Dutch.\nNow is better than never.\nAlthough never is often better than *right* now.\nIf the implementation is hard to explain, it‘s a bad idea.\nIf the implementation is easy to explain, it may be a good idea.\nNamespaces are one honking great idea -- let‘s do more of those!\nhello world\n5671528956knkxb"

使用with自动关闭文件：

当打开文件进行操作后忘记关闭时，在该文件对象不再被引用后python会关掉此文件。这意味着在一个函数中打开文件，没有及时关闭它，函数结束时会被关闭。但是当一直运行中的函数或者程序的主要部分打开一个文件，应该强制剩下的所有写操作完成后才关闭文件。

python的上下文管理器会清理一些资源，例如打开文件。形式为：with context as var：statements

In [49]: with open(‘abc.txt‘,‘r+‘) as f:
    ...:     ‘akhkahga‘      #写入字符
    ...:     ‘fasfqwyqi‘

完成代码编辑后文件自动关闭。

In [51]: with open(‘abc.txt‘,‘r+‘) as f:
    ...:     print(f.readline())   #读取上次写入的字符
    ...:     
ksfdhauy3urnncbtter than ugly.

二、对象流式化与持久化存储

Python 程序在实现文件读取或写出时，要使用转换工具把对象转换成字符串。持久性的基本思想很简单，假定有一个Python 程序，它可能是一个管理日常待办事项的程序，你希望在多次执行这个程序之间可以保存应用程序对象，此时就需要持久存储对象内容。python中只要有三个模块用于流式化或持久化存储数据：

json， 用于字符串和python数据类型间进行转换

pickle 模块 (将对象转换为文件存储)，读写文件时应使用二进制打开

shelve 模块(自动将对象pickle进和pickle出键转换为文件系统，按字典方式查询方式)

pickle、Json 模块提供了四个功能：dumps、dump、loads、load，而shelve模块通过open函数打开shelve对象后，就可以相当于字典一样操作。

In [53]: b={‘a‘:123,‘b‘:456,‘c‘:123457}
In [54]: import json
In [56]: json_abc=json.dumps(b)  #将b转换为json所能识别的字符码
In [58]: f=open(‘123.txt‘,‘w+‘)  #打开文件
In [59]: json.dump(json_abc,f)   #存入文件
In [60]: f.close()    
In [61]: cat 123.txt             #查看在文件中存储的格式
"{\"a\": 123, \"b\": 456, \"c\": 123457}" 
In [63]: f=open(‘123.txt‘,‘r+‘)
In [64]: json_b=json.load(f)     #从文件中读取字符串
In [65]: print(json_b)
{"a": 123, "b": 456, "c": 123457}

In [80]: pickle_f=open(‘pickle_123.txt‘,‘wb+‘)  #打开文件，以二进制格式读写
In [81]: pickle.dump(b,pickle_f)                #直接存储对象
In [83]: pickle_f.close()
In [84]: b
Out[84]: {‘a‘: 123, ‘b‘: 456, ‘c‘: 123457}
In [86]: pickle_f=open(‘pickle_123.txt‘,‘rb+‘) #从文件中读取数据
In [87]: pickle.load(pickle_f)
Out[87]: {‘a‘: 123, ‘b‘: 456, ‘c‘: 123457}

In [4]: shelve_dic=shelve.open(‘test.txt‘)   #直接打开一个文件，进行操作
In [5]: shelve_dic[‘a‘]=[1,2,3,4,56,76]
In [6]: shelve_dic[‘b‘]=[2,3,4,6,8]
In [7]: shelve_dic.close()
In [8]: ls                        #关闭shelve对象后，当前目录下生成一个‘test.txtx.bd‘文件
123.txt  mylinux/        python_web/  shell/
abc.txt  pickle_123.txt  samba/       test.txt.db
In [9]: shelve_dic=shelve.open(‘test.txt‘)    #打开文件，可以直接进行操作
In [18]: shelve_dic[‘a‘]
Out[18]: [1, 2, 3, 4, 56, 76]
In [19]: shelve_dic[‘b‘]
Out[19]: [2, 3, 4, 6, 8]
In [20]: shelve_dic[‘c‘]

三、正则处理re模块

python中正则表达式的处理使用re模块。其主要方法有：

In [11]: import re
In [12]: str
Out[12]: ‘Beautiful is better than ugly.‘
In [13]: ret=re.match(‘is‘,str)   #使用match()方法匹配is ，没有返回结果
In [14]: ret
In [15]: ret=re.match(‘Bea‘,str)  #匹配字符串开头出现结果，只能匹配字符串的开头
In [16]: ret
Out[16]: <_sre.SRE_Match object; span=(0, 3), match=‘Bea‘>
In [17]: ret.string                #匹配的源字符串
Out[17]: ‘Beautiful is better than ugly.‘
In [18]: ret.re                    #匹配的模式，需要匹配的内容
Out[18]: re.compile(r‘Bea‘, re.UNICODE)
In [19]: ret.pos                    #源字符串搜索的起始位置                  
Out[19]: 0
In [20]: ret.endpos                 #源字符串搜索的结束位置
Out[20]: 30
In [22]: ret.group()                #匹配到的结果
Out[22]: ‘Bea‘
In [23]: ret.groups()               #没有分组，因此为空
Out[23]: ()
In [24]: ret.start()                #匹配到的结果在源字符串中的起始位置
Out[24]: 0
In [25]: ret.end()                  #匹配到的结果在源字符串中的结束位置
Out[25]: 3
In [26]: ret=re.match(‘(Bea)‘,str)  #以分组的方式进行匹配
In [27]: ret.groups()               #返回的分组结果以元组的形式返回
Out[27]: (‘Bea‘,)
In [31]: ret=re.search(‘is‘,str)    #使用search()方法进行匹配
In [32]: ret.group()                #返回结果，
Out[32]: ‘is‘
In [34]: pat=re.compile(‘ea‘)       #对需要匹配的模式进行先编译
In [35]: ret=pat.search(str)        #对模式编译后，在源字符串中查找匹配
In [36]: ret.group()                #匹配结果
Out[36]: ‘ea‘
In [38]: str
Out[38]: ‘Beautiful is better than ugly.‘
In [39]: re.findall(‘a‘,str)       #列表的形式返回所有匹配的结果
Out[39]: [‘a‘, ‘a‘]
In [40]: re.sub(‘eau‘,‘aaa‘,str)   #返回字符串替换后的结果
Out[40]: ‘Baaatiful is better than ugly.‘

正则匹配规则：