Python中的文件操作

蔚落 2022-02-15 02:53 412阅读 0赞

## Python中的文件操作 ##

1.  open(file,mode=‘r’,buffering=-1,encoding=None,errors=None,newline=None,closefd=True,opener=None)->\_io.TextIOWrapper 打开一个文件，返回这个文件的IO流对象和文件描述符。如果打开失败抛出异常
    
     *  file 文件路径，(可以是相对路径或绝对路径)
     *  mode:文件模式,默认为r只读模式
        
        <table> 
         <thead> 
          <tr> 
           <th align="center">文字描述符</th> 
           <th align="left">意义</th> 
          </tr> 
         </thead> 
         <tbody> 
          <tr> 
           <td align="center">r</td> 
           <td align="left">缺省的，表示只读打开 打开后文件指针指向开头</td> 
          </tr> 
          <tr> 
           <td align="center">w</td> 
           <td align="left">只写打开，打开后文件指针指向开头。不管文件是否存在，都会生成全新内容的文件</td> 
          </tr> 
          <tr> 
           <td align="center">x</td> 
           <td align="left">创建并写入一个新文件，打开后文件指针指向开头,文件不存在，创建文件。文件存在抛异常FillExistsError</td> 
          </tr> 
          <tr> 
           <td align="center">a</td> 
           <td align="left">写入打开，打开后文件指针指向末尾。文件不存在，创建文件，只写打开，文件存在，只写打开，尾部追加内容。</td> 
          </tr> 
          <tr> 
           <td align="center">组合描述符</td> 
           <td align="left"></td> 
          </tr> 
          <tr> 
           <td align="center">b</td> 
           <td align="left">二精制模式打开文件，可以和r,w,x,a组合，打开后读取和写入都是二进制。</td> 
          </tr> 
          <tr> 
           <td align="center">t</td> 
           <td align="left">缺省值，默认打开模式为文本模式。上面r,w,x,a默认都是用文本模式打开</td> 
          </tr> 
          <tr> 
           <td align="center">+</td> 
           <td align="left">读写打开一个文件，给，给原来只读、只写方式打开提供缺失的读或者写能力，需要与r,w,x,a组合使用。不能单独使用</td> 
          </tr> 
         </tbody> 
        </table>
     *  buffering 缓冲区，默认值为None
        
         *  \-1 表示使用缺省大小的buffer。如果是二精制模式，使用io.DEFAULT\_BUFFER\_SIZE值，默认是4096或者8192。如果是文本模式，如果是终端设备，是行缓存方式，如果不是，则使用二进制模式的策略。
            
             *  0 只在二进制模式使用，表示关闭buffer
             *  1 只在文本模式使用，表示使用行缓冲，意思就是见到换行符flush
             *  大于1 使用指定buffer的大小
         *  buffer缓冲区：缓冲区是一个内存空间，一般来说是一个FIFO队列，到缓冲区满了或者达到阀值，数据才会flush到磁盘。flush()将缓冲区数据写入到磁盘，close()关闭文件流，关闭前会调用flush()
        
        <table> 
         <thead> 
          <tr> 
           <th align="center">buffering</th> 
           <th align="left">说明</th> 
          </tr> 
         </thead> 
         <tbody> 
          <tr> 
           <td align="center">buffering=-1</td> 
           <td align="left">t模式和b模式，都是io.DEFAULT_BUFFER_SIZE缺省缓冲区大小，字节</td> 
          </tr> 
          <tr> 
           <td align="center">buffering=0</td> 
           <td align="left">b模式：关闭缓冲区，t模式：不支持</td> 
          </tr> 
          <tr> 
           <td align="center">buffering=1</td> 
           <td align="left">t模式：行缓冲，遇到换行符才flush</td> 
          </tr> 
          <tr> 
           <td align="center">buffering&gt;1</td> 
           <td align="left">b模式：表示缓冲区大小。缓冲区的值可以超过io.DEFAULT_BUFFER_SIZE，直到设定的值超出后才把缓冲区flush。 t模式，是io.DEFAULT_BUFFER_SIZE字节，flush完后把当前字符串也写入磁盘</td> 
          </tr> 
         </tbody> 
        </table>
        
         *  总结规律：
            
            1.  文本模式，一般都用默认缓冲区大小
            2.  二精制模式，是一个个字节的操作，可以指定buffer的大小
            3.  一般来说，默认缓冲区大小是比较好的选择，除非明确知道，否则不调控它
            4.  一般编程中，明确知道需要写磁盘了，都会手动调用一次flush,而不是等到自动调用flush或者close的时候。
     *  encoding 编码，仅文本模式使用。如果是b字节模式，无用
        
         *  默认值为None表示使用缺省编码，依赖操作系统。即 为默认值None是，使用文本模式打开文件时，默认使用的编码为系统默认编码。windows下缺省值为GBK(0xBOA1),Linux下缺省值为：UTF-8(0xE5 95 8A)
     *  errors 什么样的编码错误将被捕获。默认值为None
        
         *  None和strict表示右编码错误将抛出ValueError异常；ignore表示忽略
     *  newline 文本模式中，换行的转换。默认值为None。可选为None,“空串”，"\\r","\\n","\\r\\n"
        
         *  读模式：
            
             *  None 表示\\r,\\n,\\r\\n都被转换为\\n;
             *  "表示不会自动转换通用换行符；
             *  其他合法字符表示换行符就是指定字符，就会按照指定字符分行
         *  写模式：
            
             *  None表示\\n 都会被替换为系统缺省行分割符os.linesep;
             *  \\n或""表示\\n不替换；
             *  其他合法字符表示\\n会被替换为指定字符
         *  示例：
        
            fil = open("test2.txt","w+") #打开文件
            #newline缺省值为None，windows下会把\n替换成\r\n
            fil.write("python\rwww.baidu.com\nwww.gdy.com\r\npython3")
            #真正写入的是
            # 'python\rwww.baidu.com\rwww.gdy.com\r\r\npython3'
            fil.seek(0)
            #注意：读取时\r,\n,\r\n都会被替换成\n所以这里显示出来应该为：
            #'python\nwww.baidu.com\nwww.gdy.com\n\npython3'
            fil.read()
            fil.close()
        
        ![file002][]
     *  closefd 关闭文件描述符，True表示关闭它。False会在文件关闭后保持这个描述符。默认值为True。fileobj.fileno()查看
     *  opener 默认值为None

#### 文件指针 ####

*  mode = r 指针起始在0位置
 *  mode = a 指针起始在EOF文件末尾位置
 *  tell() 显示指针当前位置
 *  seek(offset\[,whence\]) 移动文件指针，是按照字节偏移

#### BufferedIoBase类 ####

*  BufferedIoBase类中常用方法。注意：TextIoWrapper继承了BufferedIoBase类
    
     *  write(s) 把字符串s写入到文件中并返回字符的个数
     *  writelines(lines) \#将字符串列表写入文件。
        
         *  简单示例：
        
            f = open("test2.txt","w+")
            lines= ["abc","123\n","456\r\n"]
            f.writelines(lines)
            f.seek(0)
            print(f.read())
            f.close()
        
        ![file003][]
     *  read(size=-1\] \#读取文件内容，默认从指针开始位置读取到末尾。如果是t文本模式打开，默认读取为一个字符读取，如果是b二精制打开，默认读取是按照字节读取。
     *  readline(size=-1) \#一行一行读取文件内容。size设置一次能读取行内几个字符或字节。
     *  readline(hint=-1) \#读取所有行的列表，指定hint返回指定的行数
        
         *  按照行迭代
        
            f = open("test") #返回可迭代对象
            for line in f:
                print(line.encode()) #将读取内容转换为bytes
            f.close()
     *  seek(offset\[,whence\]) 移动文件指针。是按照字节偏移
        
         *  offset 偏移的字节数。可以为正和负数。
            
             *  偏移后可以超过文件末尾EOF,超过部分用字节O表示。
             *  不能超过文件开始。如果超过会报错
         *  whence 可选值为0 1 2.默认值为0 表示指针相对于文件开始位置做偏移
            
             *  0 表示指针相对于文件开始位置做偏移
             *  1 表示指针在相对于当前指针所在位置做偏移
             *  2 表示指针相对于文件末尾EOF位置做偏移
     *  tell()方法，可以显示当前文件指针位置，注意指针位置是按照字节计算的。
        
         *  简单示例：
        
            fil = open("test","a+") #打开文件
            fil.write("abcd你好")
            fil.seek(0) #指针回到起始位置
            fil.seek(2,0) #指针相对于开始位置向左移动2个位置
            print(fil.tell()) #查看当前指针位置
            fil.close() #关闭文件流
     *  flush() 将缓冲区数据写入到磁盘
     *  close() 关闭文件流。关闭前会调用flush()。文件已经关闭，再次关闭没有任何效果
     *  seekable() \#是否可以seek
     *  readable() \#是否可读
     *  writable() \#是否可写
     *  closed \#是否已经关闭

#### 上下文管理 ####

*  一般情况，系统对打开文件上限做了限制，linux中可以使用ulimit -a 查看所有限制。其中open file就是打开文件数的现在，默认是1024。如果打开文件达到上线，程序在次打开文件就会出错。出现OSError异常。为了防止打开文件后没有关闭文件，一般都需要添加异常处理。当发生异常是。关闭文件。

f = None
    try:
        f = open('test')
        f.write("abc") # 文件是用只读模式打开，写入失败。
        f.close()
    finally:
        if f!=None:
            f.close() #当发生异常，如果f不为空，关闭文件流。释放文件对象

*  上下文管理：一种特殊的语法，交给解释器去释放文件对象
    
     *  使用with…as 关键字
     *  上下文管理的语句块并不会开启新的作用域
     *  with语句块执行完的时候，会自动关闭文件对象
     *  第一种写法示例：
    
        del f
        #使用with...as 语法，当代码块中出现异常时，会自动关闭f
        with open("test") as f:
            f.write("abc") #因为是只读模式打开，所有会出错。写入失败
        #测试f发现f已经关闭
        f.closed
    
     *  第二种写法：
    
        f = open("test")
        with f:
            f.write("abcd") #因为是只读模式打开，所有会出错。写入失败
        #测试f，f已经关闭
        f.closed
 *  对于类似于文件对象的IO对象，一般来说都需要在不使用的时候关闭，注销，已释放资源。IO被打开的时候，会获得一个文件描述符。计算机资源是有线的，所以操作系统都会做限制。就是为了保护计算机的资源不要被完全耗尽，计算资源是共享的，不是独占的。
 *  一般情况下，除非特别明确的知道资源情况，否则不要提高资源的限制值来解决问题。

#### 附加： ####

*  冯诺依曼体系架构  
    ![file001][]
 *  CPU由运算器和控制器组成
    
     *  运算器：完成各种运算数运算、逻辑运算、数据传输等数据加工处理
     *  控制器：控制计算机各部件协调运行
     *  存储器：用于记忆程序和数据，例如内存
     *  输入设备：将数据或程序输入到计算机中，例如键盘、鼠标
     *  输出设备：将数据或程序的处理结果展示给用户，例如显示器，打印机等。
 *  一般来说IO操作，指的是文件IO，如果指的是网络IO，都会直接说网络IO
 *  文件IO常用操作
    
    1.  open 打开
    2.  read 读取
    3.  write 写入
    4.  close 关闭
    5.  readline 行读取
    6.  readlines 多行读取
    7.  seek 文件指针操作
    8.  tell 指针位置

[file002]: /images/20220215/d1c6a2aae3564ab89556e9b245923094.png
[file003]: /images/20220215/f11400a8c4d440d1a2756efe0f2a041d.png
[file001]: /images/20220215/216e2fad50024a60b31b66b82cf57c8a.png