• python-open文件处理


    python内置函数open()用于打开文件和创建文件对象

    语法

    open(name[,mode[,bufsize]])

    name:文件名

    mode:指定文件的打开模式

      r:只读

      w:写入

      a:附加

      r+,w+,a+同时支持输入输出操作

      rb,wb+以二进制方式打开

    bufsize:定义输出缓存

      0表示无输出缓存

      1表示使用缓冲

      负数表示使用系统默认设置

      正数表示使用近似指定大小的缓冲

    #以只读方式打开text.txt文件,赋值给f1变量
    >>> f1 = open('test.txt','r')
    
    #查看f1数据类型
    >>> type(f1)
    <class '_io.TextIOWrapper'>
    
    #读取文件内容,以字符串形式返回
    >>> f1.read()
    'h1
    h2
    h3
    h4
    h5
    h6'
    
    #此时指针处于文件末尾,通过tell获取当前指针位置,通过seek重新指定指针位置
    >>> f1.readline()
    ''
    >>> f1.tell()
    22
    
    >>> f1.seek(0)
    0
    
    #单行读取
    >>> f1.readline()
    'h1
    '
    
    #读取余下所有行,以列表方式返回
    >>> f1.readlines()
    ['h2
    ', 'h3
    ', 'h4
    ', 'h5
    ', 'h6']
    
    #文件名
    >>> f1.name
    'test.txt'
    
    #关闭文件
    >>> f1.close()
    
    #文件写入
    f2 = open('test.txt','w+')
    f2.write('hello')
    f2.close()
    
    #向文件追加内容
    f3 = open('test.txt','a')
    f3.write('hello')
    f3.close()
    
    #通过flush,将缓冲区内容写入文件
    #write将字符串值写入文件
    f3 = open('test.txt','w+')
    for line in (i**2 for i in range(1,11)):
        f3.write(str(line)+'
    ')
    f3.flush()
    #f3.close()
    
    #writelines将列表值写入文件
    f3 = open('test.txt','w+')
    lines = ['11','22','33','44']
    f3.writelines(lines)
    f3.seek(0)
    print(f3.readlines())
    f3.close()
    #执行结果:['11223344']
    
    >>> f3.closed
    True
    >>> f3.mode
    'w+'
    >>> f3.encoding
    'cp936'
    Help on TextIOWrapper object:
    
    class TextIOWrapper(_TextIOBase)
     |  Character and line based layer over a BufferedIOBase object, buffer.
     |  
     |  encoding gives the name of the encoding that the stream will be
     |  decoded or encoded with. It defaults to locale.getpreferredencoding(False).
     |  
     |  errors determines the strictness of encoding and decoding (see
     |  help(codecs.Codec) or the documentation for codecs.register) and
     |  defaults to "strict".
     |  
     |  newline controls how line endings are handled. It can be None, '',
     |  '
    ', '
    ', and '
    '.  It works as follows:
     |  
     |  * On input, if newline is None, universal newlines mode is
     |    enabled. Lines in the input can end in '
    ', '
    ', or '
    ', and
     |    these are translated into '
    ' before being returned to the
     |    caller. If it is '', universal newline mode is enabled, but line
     |    endings are returned to the caller untranslated. If it has any of
     |    the other legal values, input lines are only terminated by the given
     |    string, and the line ending is returned to the caller untranslated.
     |  
     |  * On output, if newline is None, any '
    ' characters written are
     |    translated to the system default line separator, os.linesep. If
     |    newline is '' or '
    ', no translation takes place. If newline is any
     |    of the other legal values, any '
    ' characters written are translated
     |    to the given string.
     |  
     |  If line_buffering is True, a call to flush is implied when a call to
     |  write contains a newline character.
     |  
     |  Method resolution order:
     |      TextIOWrapper
     |      _TextIOBase
     |      _IOBase
     |      builtins.object
     |  
     |  Methods defined here:
     |  
     |  __getstate__(...)
     |  
     |  __init__(self, /, *args, **kwargs)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |  
     |  __new__(*args, **kwargs) from builtins.type
     |      Create and return a new object.  See help(type) for accurate signature.
     |  
     |  __next__(self, /)
     |      Implement next(self).
     |  
     |  __repr__(self, /)
     |      Return repr(self).
     |  
     |  close(self, /)
     |      Flush and close the IO object.
     |      
     |      This method has no effect if the file is already closed.
     |  
     |  detach(self, /)
     |      Separate the underlying buffer from the TextIOBase and return it.
     |      
     |      After the underlying buffer has been detached, the TextIO is in an
     |      unusable state.
     |  
     |  fileno(self, /)
     |      Returns underlying file descriptor if one exists.
     |      
     |      OSError is raised if the IO object does not use a file descriptor.
     |  
     |  flush(self, /)
     |      Flush write buffers, if applicable.
     |      
     |      This is not implemented for read-only and non-blocking streams.
     |  
     |  isatty(self, /)
     |      Return whether this is an 'interactive' stream.
     |      
     |      Return False if it can't be determined.
     |  
     |  read(self, size=-1, /)
     |      Read at most n characters from stream.
     |      
     |      Read from underlying buffer until we have n characters or we hit EOF.
     |      If n is negative or omitted, read until EOF.
     |  
     |  readable(self, /)
     |      Return whether object was opened for reading.
     |      
     |      If False, read() will raise OSError.
     |  
     |  readline(self, size=-1, /)
     |      Read until newline or EOF.
     |      
     |      Returns an empty string if EOF is hit immediately.
     |  
     |  seek(self, cookie, whence=0, /)
     |      Change stream position.
     |      
     |      Change the stream position to the given byte offset. The offset is
     |      interpreted relative to the position indicated by whence.  Values
     |      for whence are:
     |      
     |      * 0 -- start of stream (the default); offset should be zero or positive
     |      * 1 -- current stream position; offset may be negative
     |      * 2 -- end of stream; offset is usually negative
     |      
     |      Return the new absolute position.
     |  
     |  seekable(self, /)
     |      Return whether object supports random access.
     |      
     |      If False, seek(), tell() and truncate() will raise OSError.
     |      This method may need to do a test seek().
     |  
     |  tell(self, /)
     |      Return current stream position.
     |  
     |  truncate(self, pos=None, /)
     |      Truncate file to size bytes.
     |      
     |      File pointer is left unchanged.  Size defaults to the current IO
     |      position as reported by tell().  Returns the new size.
     |  
     |  writable(self, /)
     |      Return whether object was opened for writing.
     |      
     |      If False, write() will raise OSError.
     |  
     |  write(self, text, /)
     |      Write string to stream.
     |      Returns the number of characters written (which is always equal to
     |      the length of the string).
     |  
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |  
     |  buffer
     |  
     |  closed
     |  
     |  encoding
     |      Encoding of the text stream.
     |      
     |      Subclasses should override.
     |  
     |  errors
     |      The error setting of the decoder or encoder.
     |      
     |      Subclasses should override.
     |  
     |  line_buffering
     |  
     |  name
     |  
     |  newlines
     |      Line endings translated so far.
     |      
     |      Only line endings translated during reading are considered.
     |      
     |      Subclasses should override.
     |  
     |  ----------------------------------------------------------------------
     |  Methods inherited from _IOBase:
     |  
     |  __del__(...)
     |  
     |  __enter__(...)
     |  
     |  __exit__(...)
     |  
     |  __iter__(self, /)
     |      Implement iter(self).
     |  
     |  readlines(self, hint=-1, /)
     |      Return a list of lines from the stream.
     |      
     |      hint can be specified to control the number of lines read: no more
     |      lines will be read if the total size (in bytes/characters) of all
     |      lines so far exceeds hint.
     |  
     |  writelines(self, lines, /)
     |  
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from _IOBase:
     |  
     |  __dict__
    View Code

    *with

    为了避免打开文件后忘记关闭,可以通过管理上下文,当with代码块执行完毕时,内部会自动关闭并释放文件资源。

    with open("test.txt","a+") as f:
        f.write("hello world!")
  • 相关阅读:
    Asp.Net Core 2.0 项目实战(7)MD5加密、AES&DES对称加解密
    Asp.Net Core 2.0 项目实战(8)Core下缓存操作、序列化操作、JSON操作等Helper集合类
    Java后端开发-SSM框架的图片上传
    个人作业——软件工程实践总结&个人技术博客
    个人作业——软件评测
    结对第二次作业——某次疫情统计可视化的实现
    结对第一次—疫情统计可视化(原型设计)
    软工实践寒假作业(2/2)
    my codestyle
    alibaba-java-style-guide
  • 原文地址:https://www.cnblogs.com/tiannan/p/6215634.html
Copyright © 2020-2023  润新知