关于python-open文件处理方法介绍

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

#以只读方式打开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()

>>> f1.seek(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

with open("test.txt","a+") as f:
 f.write("hello world!")