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

fileobj = open（文件名，模式，缓冲= -1，...）：文件 

  fileobj是open（）函数返回的文件对象

  filename需要打开的文件的串口名

  buffering：是否使用缓存，0表示输出无缓存，1表示使用缓存；

    负数表示使用预设的设置，正数表示使用近似指定的大小。

  模式指定文件的打开模式：

    r表示读模式

    r +表示可读写文件。【升级；可写；可追加】

    w表示写模式，如果文件不存在则新创建，如果存在则重新些内容

    w +，写读

    x表示文件不存在的情况下新创建并写文件。

    a表示文件如果存在，在文件末尾追加内容。

    “ U”表示在读取时，可以将\ r \ n \ r \ n自动转换成\ n（与r或r +模式同使用）

    模式的第二个字母代表文件的类型：t代表文本类型，b代表二进制文件

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"

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.

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

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