Python內置函數(47)——open

英文文檔：

open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

Open file and return a corresponding file object. If the file cannot be opened, an OSError is raised.

file is either a string or bytes object giving the pathname (absolute or relative to the current working directory) of the file to be opened or an integer file descriptor of the file to be wrapped. (If a file descriptor is given, it is closed when the returned I/O object is closed, unless closefd is set to False.)

mode is an optional string that specifies the mode in which the file is opened. It defaults to 'r' which means open for reading in text mode. Other common values are 'w' for writing (truncating the file if it already exists), 'x' for exclusive creation and 'a' for appending (which on some Unix systems, means that all writes append to the end of the file regardless of the current seek position). In text mode, if encoding is not specified the encoding used is platform dependent: locale.getpreferredencoding(False) is called to get the current locale encoding. (For reading and writing raw bytes use binary mode and leave encoding unspecified.) The available modes are:

The default mode is 'r' (open for reading text, synonym of 'rt'). For binary read-write access, the mode 'w+b' opens and truncates the file to 0 bytes. 'r+b' opens the file without truncation.

As mentioned in the Overview, Python distinguishes between binary and text I/O. Files opened in binary mode (including 'b' in the mode argument) return contents as bytes objects without any decoding. In text mode (the default, or when 't' is included in the mode argument), the contents of the file are returned as str, the bytes having been first decoded using a platform-dependent encoding or using the specified encoding if given.

Note

Python doesn’t depend on the underlying operating system’s notion of text files; all the processing is done by Python itself, and is therefore platform-independent.

buffering is an optional integer used to set the buffering policy. Pass 0 to switch buffering off (only allowed in binary mode), 1 to select line buffering (only usable in text mode), and an integer > 1 to indicate the size in bytes of a fixed-size chunk buffer. When no buffering argument is given, the default buffering policy works as follows:

• Binary files are buffered in fixed-size chunks; the size of the buffer is chosen using a heuristic trying to determine the underlying device’s “block size” and falling back on io.DEFAULT_BUFFER_SIZE. On many systems, the buffer will typically be 4096 or 8192 bytes long.
• “Interactive” text files (files for which isatty() returns True) use line buffering. Other text files use the policy described above for binary files.

encoding is the name of the encoding used to decode or encode the file. This should only be used in text mode. The default encoding is platform dependent (whatever locale.getpreferredencoding() returns), but any text encoding supported by Python can be used. See the codecs module for the list of supported encodings.

errors is an optional string that specifies how encoding and decoding errors are to be handled–this cannot be used in binary mode. A variety of standard error handlers are available (listed under Error Handlers), though any error handling name that has been registered with codecs.register_error() is also valid. The standard names include:

• 'strict' to raise a ValueError exception if there is an encoding error. The default value of None has the same effect.
• 'ignore' ignores errors. Note that ignoring encoding errors can lead to data loss.
• 'replace' causes a replacement marker (such as '?') to be inserted where there is malformed data.
• 'surrogateescape' will represent any incorrect bytes as code points in the Unicode Private Use Area ranging from U+DC80 to U+DCFF. These private code points will then be turned back into the same bytes when the surrogateescape error handler is used when writing data. This is useful for processing files in an unknown encoding.
• 'xmlcharrefreplace' is only supported when writing to a file. Characters not supported by the encoding are replaced with the appropriate XML character reference &#nnn;.
• 'backslashreplace' replaces malformed data by Python’s backslashed escape sequences.
• 'namereplace' (also only supported when writing) replaces unsupported characters with \N{...} escape sequences.

newline controls how universal newlines mode works (it only applies to text mode). It can be None, '', '\n', '\r', and '\r\n'. It works as follows:

• When reading input from the stream, if newline is None, universal newlines mode is enabled. Lines in the input can end in '\n', '\r', or '\r\n', and these are translated into '\n' before being returned to the caller. If it is '', universal newlines 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.
• When writing output to the stream, if newline is None, any '\n' characters written are translated to the system default line separator, os.linesep. If newline is '' or '\n', no translation takes place. If newline is any of the other legal values, any '\n' characters written are translated to the given string.

If closefd is False and a file descriptor rather than a filename was given, the underlying file descriptor will be kept open when the file is closed. If a filename is given closefd must be True (the default) otherwise an error will be raised.

A custom opener can be used by passing a callable as opener. The underlying file descriptor for the file object is then obtained by calling opener with (file, flags). opener must return an open file descriptor (passing os.open as opener results in functionality similar to passing None).

說明：

　　1. 函數功能打開一個文件，返回一個文件讀寫對象，然後可以對文件進行相應讀寫操作。

　　2. file參數表示的需要打開文件的相對路徑(當前工作目錄)或者一個絕對路徑，當傳入路徑不存在此文件會報錯。或者傳入文件的句柄。

>>> a = open('test.txt') # 相對路徑
>>> a
<_io.TextIOWrapper name='test.txt' mode='r' encoding='cp936'>
>>> a.close()

>>> a = open(r'D:\Python\Python35-32\test.txt') # 絕對路徑
>>> a
<_io.TextIOWrapper name='D:\\Python\\Python35-32\\test.txt' mode='r' encoding='cp936'>

　　3. mode參數表示打開文件的模式，常見的打開模式有如下幾種，實際調用的時候可以根據情況進行組合。

　　　　'r'： 以只讀模式打開（預設模式）（必須保證文件存在）
　　　　'w'：以只寫模式打開。若文件存在，則會自動清空文件，然後重新創建；若文件不存在，則新建文件。使用這個模式必須要保證文件所在目錄存在，文件可以不存在。該模式下不能使用read*()方法

　　　　'a'：以追加模式打開。若文件存在，則會追加到文件的末尾；若文件不存在，則新建文件。該模式不能使用read*()方法。

　　下麵四個模式要和上面的模式組合使用
　　　　'b'：以二進位模式打開

　　　　't'： 以文本模式打開（預設模式）
　　　　'+'：以讀寫模式打開
　　　　'U'：以通用換行符模式打開

　　常見的mode組合

　　　　'r'或'rt'：     預設模式，文本讀模式
　　　　'w'或'wt'：   以文本寫模式打開（打開前文件會被清空）
　　　　'rb'：          以二進位讀模式打開
　　　　'ab'：         以二進位追加模式打開
　　　　'wb'：        以二進位寫模式打開（打開前文件會被清空）
　　　　'r+'：         以文本讀寫模式打開，可以寫到文件任何位置；預設寫的指針開始指在文件開頭, 因此會覆寫文件
　　　　'w+'：        以文本讀寫模式打開（打開前文件會被清空）。可以使用read*()
　　　　'a+'：         以文本讀寫模式打開（寫只能寫在文件末尾）。可以使用read*()
　　　　'rb+'：       以二進位讀寫模式打開
　　　　'wb+'：      以二進位讀寫模式打開（打開前文件會被清空）
　　　　'ab+'：      以二進位讀寫模式打開

# t為文本讀寫，b為二進位讀寫
>>> a = open('test.txt','rt')
>>> a.read()
'some text'
>>> a = open('test.txt','rb')
>>> a.read()
b'some text'

# r為只讀，不能寫入；w為只寫，不能讀取
>>> a = open('test.txt','rt')
>>> a.write('more text')
Traceback (most recent call last):
  File "<pyshell#67>", line 1, in <module>
    a.write('more text')
io.UnsupportedOperation: write
>>> a = open('test.txt','wt')
>>> a.read()
Traceback (most recent call last):
  File "<pyshell#69>", line 1, in <module>
    a.read()
io.UnsupportedOperation: not readable

#其它不一一舉例了

　　4. buffering表示文件在讀取操作時使用的緩衝策略。

　　　　　　0：    代表buffer關閉（只適用於二進位模式）
　　　　　　1：    代表line buffer（只適用於文本模式）
　　　　　　>1：  表示初始化的buffer大小

　　5. encoding參數表示讀寫文件時所使用的的文件編碼格式。

　　假設現在test.txt文件以utf-8編碼存儲了一下文本：

>>> a = open('test.txt','rt') # 未正確指定編碼，有可能報錯
>>> a.read()
Traceback (most recent call last):
  File "<pyshell#87>", line 1, in <module>
    a.read()
UnicodeDecodeError: 'gbk' codec can't decode byte 0xac in position 8: illegal multibyte sequence

>>> a = open('test.txt','rt',encoding = 'utf-8')
>>> a.read()
'我是第1行文本，我將被顯示在屏幕\n我是第2行文本，我將被顯示在屏幕\n我是第3行文本，我將被顯示在屏幕'
>>> 

　　6. errors參數表示讀寫文件時碰到錯誤的報錯級別。

　　常見的報錯基本有：

• 'strict' 嚴格級別，字元編碼有報錯即拋出異常，也是預設的級別，errors參數值傳入None按此級別處理.
• 'ignore' 忽略級別，字元編碼有錯，忽略掉.
• 'replace' 替換級別，字元編碼有錯的，替換成？. 

>>> a = open('test.txt','rt',encoding = 'utf-8')
>>> a.read()
'我是第1行文本，我將被顯示在屏幕\n我是第2行文本，我將被顯示在屏幕\n我是第3行文本，我將被顯示在屏幕'
>>> a = open('test.txt','rt')
>>> a.read()
Traceback (most recent call last):
  File "<pyshell#91>", line 1, in <module>
    a.read()
UnicodeDecodeError: 'gbk' codec can't decode byte 0xac in position 8: illegal multibyte sequence
>>> a = open('test.txt','rt',errors = 'ignore' )
>>> a.read()
'鎴戞槸絎1琛屾枃鏈錛屾垜灝嗚鏄劇ず鍦ㄥ睆騫\n鎴戞槸絎2琛屾枃鏈錛屾垜灝嗚鏄劇ず鍦ㄥ睆騫\n鎴戞槸絎3琛屾枃鏈錛屾垜灝嗚鏄劇ず鍦ㄥ睆騫'
>>> a = open('test.txt','rt',errors = 'replace' )
>>> a.read()
'鎴戞槸絎�1琛屾枃鏈�錛屾垜灝嗚��鏄劇ず鍦ㄥ睆騫�\n鎴戞槸絎�2琛屾枃鏈�錛屾垜灝嗚��鏄劇ず鍦ㄥ睆騫�\n鎴戞槸絎�3琛屾枃鏈�錛屾垜灝嗚��鏄劇ず鍦ㄥ睆騫�'

　　7. newline表示用於區分換行符(只對文本模式有效，可以取的值有None,'\n','\r','','\r\n')

>>> a = open('test.txt','rt',encoding = 'utf-8',newline = '\r')
>>> a.readline()
'我是第1行文本，我將被顯示在屏幕\r'
>>> a = open('test.txt','rt',encoding = 'utf-8',newline = '\n')
>>> a.readline()
'我是第1行文本，我將被顯示在屏幕\r\n'

　　8. closefd表示傳入的file參數類型（預設為True），傳入文件路徑時一定為True，傳入文件句柄則為False。

>>> a = open('test.txt','rt',encoding = 'utf-8',newline = '\n',closefd = False)
Traceback (most recent call last):
  File "<pyshell#115>", line 1, in <module>
    a = open('test.txt','rt',encoding = 'utf-8',newline = '\n',closefd = False)
ValueError: Cannot use closefd=False with file name
>>> a = open('test.txt','rt',encoding = 'utf-8',newline = '\n',closefd = True)