笔者：风起怨江南 出处：https://blog.csdn.net/JackMengJin 笔者原创，文章转载需注明，如果喜欢请点赞+关注，感谢支持！

函数学习接近尾声，这次主要带来open内置函数的全方面讲解。

open函数的官方资料：https://docs.python.org/zh-cn/3.7/library/functions.html#open

目录

open内置函数全方面讲解

1.open函数基础内容

1.1 定义

1.2 open函数的参数组成

1.3 open函数参数的作用

1.4 mode模式所有参数用法

1.5 x原创模式

1.6 对于文件读取的深入理解

1.7 文件操作的流程

2.open函数的实战应用

2.1 普通操作

2.2上下文表达式

2.3 read()和readline()区别

open内置函数全方面讲解

open函数在前面内置函数的学习中一笔带过，是因为在后面的学习中open函数非常重要，单独拿出来作为一个专题讲比较好。

先看下python官网对open函数的隆重介绍：

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

打开 file 并返回对应的 file object。如果该文件不能打开，则触发 OSError。

file 是一个 path-like object，表示将要打开的文件的路径（绝对路径或者当前工作目录的相对路径），也可以是要被封装的整数类型文件描述符。（如果是文件描述符，它会随着返回的 I/O 对象关闭而关闭，除非 closefd 被设为 False 。）

mode 是一个可选字符串，用于指定打开文件的模式。默认值是 'r' ，这意味着它以文本模式打开并读取。其他常见模式有：写入 'w' （截断已经存在的文件）；排它性创建 'x' ；追加写 'a' （在 一些 Unix 系统上，无论当前的文件指针在什么位置，所有 写入都会追加到文件末尾）。在文本模式，如果 encoding 没有指定，则根据平台来决定使用的编码：使用 locale.getpreferredencoding(False) 来获取本地编码。（要读取和写入原始字节，请使用二进制模式并不要指定 encoding。）可用的模式有：

字符	含义
'r'	读取（默认）
'w'	写入，并先截断文件
'x'	排它性创建，如果文件已存在则失败
'a'	写入，如果文件存在则在末尾追加
'b'	二进制模式
't'	文本模式（默认）
'+'	更新磁盘文件（读取并写入）

默认的模式是 'r' （打开并读取文本，同 'rt' ）。对于二进制写入， 'w+b' 模式打开并把文件截断成 0 字节； 'r+b' 则不会截断。

正如在 概述 中提到的，Python区分二进制和文本I/O。以二进制模式打开的文件（包括 mode 参数中的 'b' ）返回的内容为 bytes`对象，不进行任何解码。在文本模式下（默认情况下，或者在 *mode* 参数中包含 `'t'` ）时，文件内容返回为 str ，首先使用指定的 encoding （如果给定）或者使用平台默认的的字节编码解码。

此外还允许使用一个模式字符 'U'，该字符已不再具有任何效果，并被视为已弃用。 之前它会在文本模式中启用 universal newlines，这在 Python 3.0 中成为默认行为。 请参阅 newline 形参的文档了解更多细节。

注解

Python不依赖于底层操作系统的文本文件概念;所有处理都由Python本身完成，因此与平台无关。

buffering 是一个可选的整数，用于设置缓冲策略。传递0以切换缓冲关闭（仅允许在二进制模式下），1选择行缓冲（仅在文本模式下可用），并且>1的整数以指示固定大小的块缓冲区的大小（以字节为单位）。如果没有给出 buffering 参数，则默认缓冲策略的工作方式如下:

• 二进制文件以固定大小的块进行缓冲；使用启发式方法选择缓冲区的大小，尝试确定底层设备的“块大小”或使用 io.DEFAULT_BUFFER_SIZE。在许多系统上，缓冲区的长度通常为4096或8192字节。

• “交互式”文本文件（ isatty() 返回 True 的文件）使用行缓冲。其他文本文件使用上述策略用于二进制文件。

encoding 是用于解码或编码文件的编码的名称。这应该只在文本模式下使用。默认编码是依赖于平台的（不 管 locale.getpreferredencoding() 返回何值），但可以使用任何Python支持的 text encoding 。有关支持的编码列表，请参阅 codecs 模块。

errors 是一个可选的字符串参数，用于指定如何处理编码和解码错误 - 这不能在二进制模式下使用。可以使用各种标准错误处理程序（列在 错误处理方案 ），但是使用 codecs.register_error() 注册的任何错误处理名称也是有效的。标准名称包括:

• 如果存在编码错误，'strict' 会引发 ValueError 异常。 默认值 None 具有相同的效果。

• 'ignore' 忽略错误。请注意，忽略编码错误可能会导致数据丢失。

• 'replace' 会将替换标记（例如 '?' ）插入有错误数据的地方。

• 'surrogateescape' 将表示任何不正确的字节作为Unicode专用区中的代码点，范围从U+DC80到U+DCFF。当在写入数据时使用 surrogateescape 错误处理程序时，这些私有代码点将被转回到相同的字节中。这对于处理未知编码的文件很有用。

• 只有在写入文件时才支持 'xmlcharrefreplace'。编码不支持的字符将替换为相应的XML字符引用 &#nnn;。

• 'backslashreplace' 用Python的反向转义序列替换格式错误的数据。

• 'namereplace' （也只在编写时支持）用 N{...} 转义序列替换不支持的字符。

newline 控制 universal newlines 模式如何生效（它仅适用于文本模式）。它可以是 None，''，'n'，'r' 和 'rn'。它的工作原理:

• 从流中读取输入时，如果 newline 为 None，则启用通用换行模式。输入中的行可以以 'n'，'r' 或 'rn' 结尾，这些行被翻译成 'n' 在返回呼叫者之前。如果它是 ''，则启用通用换行模式，但行结尾将返回给调用者未翻译。如果它具有任何其他合法值，则输入行仅由给定字符串终止，并且行结尾将返回给未调用的调用者。

• 将输出写入流时，如果 newline 为 None，则写入的任何 'n' 字符都将转换为系统默认行分隔符 os.linesep。如果 newline 是 '' 或 'n'，则不进行翻译。如果 newline 是任何其他合法值，则写入的任何 'n' 字符将被转换为给定的字符串。

如果 closefd 是 False 并且给出了文件描述符而不是文件名，那么当文件关闭时，底层文件描述符将保持打开状态。如果给出文件名则 closefd 必须为 True （默认值），否则将引发错误。

可以通过传递可调用的 opener 来使用自定义开启器。然后通过使用参数（ file，flags ）调用 opener 获得文件对象的基础文件描述符。 opener 必须返回一个打开的文件描述符（使用 os.open as opener 时与传递 None 的效果相同）。

新创建的文件是 不可继承的。

下面的示例使用 os.open() 函数的 dir_fd 的形参，从给定的目录中用相对路径打开文件:

>>>

>>> import os
>>> dir_fd = os.open('somedir', os.O_RDONLY)
>>> def opener(path, flags):
...     return os.open(path, flags, dir_fd=dir_fd)
...
>>> with open('spamspam.txt', 'w', opener=opener) as f:
...     print('This will be written to somedir/spamspam.txt', file=f)
...
>>> os.close(dir_fd)  # don't leak a file descriptor

open() 函数所返回的 file object 类型取决于所用模式。 当使用 open() 以文本模式 ('w', 'r', 'wt', 'rt' 等) 打开文件时，它将返回 io.TextIOBase (特别是 io.TextIOWrapper) 的一个子类。 当使用缓冲以二进制模式打开文件时，返回的类是 io.BufferedIOBase 的一个子类。 具体的类会有多种：在只读的二进制模式下，它将返回 io.BufferedReader；在写入二进制和追加二进制模式下，它将返回 io.BufferedWriter，而在读/写模式下，它将返回 io.BufferedRandom。 当禁用缓冲时，则会返回原始流，即 io.RawIOBase 的一个子类 io.FileIO。

另请参阅文件操作模块，例如 fileinput、io （声明了 open()）、os、os.path、tempfile 和 shutil。

在 3.3 版更改:

• 增加了 opener 形参。

• 增加了 'x' 模式。

• 过去触发的 IOError，现在是 OSError 的别名。

• 如果文件已存在但使用了排它性创建模式（ 'x' ），现在会触发 FileExistsError。

在 3.4 版更改:

• 文件现在禁止继承。

Deprecated since version 3.4, will be removed in version 3.9: 'U' 模式。

在 3.5 版更改:

• 如果系统调用被中断，但信号处理程序没有触发异常，此函数现在会重试系统调用，而不是触发 InterruptedError 异常 (原因详见 PEP 475)。

• 增加了 'namereplace' 错误处理接口。

在 3.6 版更改:

• 增加对实现了 os.PathLike 对象的支持。

• 在 Windows 上，打开一个控制台缓冲区将返回 io.RawIOBase 的子类，而不是 io.FileIO。

看完官方的open函数定义可能有点懵，下面就详细的讲解下open函数的定义和用法。

1.open函数基础内容

1.1 定义

open函数其实就是对文件的操作，可以读取文件，打开文件，修改文件，保存文件，等等。

当然open函数还可以用在复制图片（爬虫等）多个场景，后续在集体场景中再详细说明。

举例，打开同目录下demo.txt文件：

'''open'''
open('demo.txt')

1.2 open函数的参数组成

直接通过ctrl+鼠标左键点进open函数查看：

def open(file, mode='r', buffering=None, encoding=None, errors=None, newline=None, closefd=True): # known special case of open
    """
    Open file and return a stream.  Raise OSError upon failure.
    
    file is either a text or byte string giving the name (and the path
    if the file isn't in 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 creating and writing to a new file, 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:
    
    ========= ===============================================================
    Character Meaning
    --------- ---------------------------------------------------------------
    'r'       open for reading (default)
    'w'       open for writing, truncating the file first
    'x'       create a new file and open it for writing
    'a'       open for writing, appending to the end of the file if it exists
    'b'       binary mode
    't'       text mode (default)
    '+'       open a disk file for updating (reading and writing)
    'U'       universal newline mode (deprecated)
    ========= ===============================================================
    
    The default mode is 'rt' (open for reading text). For binary random
    access, the mode 'w+b' opens and truncates the file to 0 bytes, while
    'r+b' opens the file without truncation. The 'x' mode implies 'w' and
    raises an `FileExistsError` if the file already exists.
    
    Python distinguishes between files opened in binary and text modes,
    even when the underlying operating system doesn't. Files opened in
    binary mode (appending 'b' to the mode argument) return contents as
    bytes objects without any decoding. In text mode (the default, or when
    't' is appended to the mode argument), the contents of the file are
    returned as strings, the bytes having been first decoded using a
    platform-dependent encoding or using the specified encoding if given.
    
    'U' mode is deprecated and will raise an exception in future versions
    of Python.  It has no effect in Python 3.  Use newline to control
    universal newlines mode.
    
    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 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, but any encoding supported by Python can be
    passed.  See the codecs module for the list of supported encodings.
    
    errors is an optional string that specifies how encoding errors are to
    be handled---this argument should not be used in binary mode. Pass
    'strict' to raise a ValueError exception if there is an encoding error
    (the default of None has the same effect), or pass 'ignore' to ignore
    errors. (Note that ignoring encoding errors can lead to data loss.)
    See the documentation for codecs.register or run 'help(codecs.Codec)'
    for a list of the permitted encoding error strings.
    
    newline controls how universal newlines works (it only applies to text
    mode). It can be None, '', 'n', 'r', and 'rn'.  It works as
    follows:
    
    * On input, if newline is None, universal newlines mode is
      enabled. Lines in the input can end in 'n', 'r', or 'rn', and
      these are translated into 'n' 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 '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, the underlying file descriptor will be kept open
    when the file is closed. This does not work when a file name is given
    and must be True in that case.
    
    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).
    
    open() returns a file object whose type depends on the mode, and
    through which the standard file operations such as reading and writing
    are performed. When open() is used to open a file in a text mode ('w',
    'r', 'wt', 'rt', etc.), it returns a TextIOWrapper. When used to open
    a file in a binary mode, the returned class varies: in read binary
    mode, it returns a BufferedReader; in write binary and append binary
    modes, it returns a BufferedWriter, and in read/write mode, it returns
    a BufferedRandom.
    
    It is also possible to use a string or bytearray as a file for both
    reading and writing. For strings StringIO can be used like a file
    opened in a text mode, and for bytes a BytesIO can be used like a file
    opened in a binary mode.
    """
    pass

单独拉出参数部分：

def open(file, mode='r', buffering=None, encoding=None, errors=None, newline=None, closefd=True): 

可以看到之前举例中open('demo.txt')，'demo.txt'表示的是file，而其他参数mode='r', buffering=None, encoding=None, errors=None, newline=None, closefd=True都是默认参数，所以直接运行open('demo.txt')也不会报错。

1.3 open函数参数的作用

既然上面提到那么多参数，那么这些参数到底是干嘛的？

• file就是表示文件名，也可以表示路径。当然目前没有涉及到os模块的学习，所以所有的操作都基于同目录下。
• mode表示模式，后面会详细去讲解mode各个参数的用法。
• buffering：如果 buffering 的值被设为 0，就不会有寄存。如果 buffering 的值取 1，访问文件时会寄存行。如果将 buffering 的值设为大于 1 的整数，表明了这就是的寄存区的缓冲大小。如果取负值，寄存区的缓冲大小则为系统默认。通常情况下、建议大家在使用 open() 函数时打开缓冲区，即不需要修改 buffing 参数的值。

  如果 buffing 参数的值为 0（或者 False），则表示在打开指定文件时不使用缓冲区；如果 buffing 参数值为大于 1 的整数，该整数用于指定缓冲区的大小（单位是字节）；如果 buffing 参数的值为负数，则代表使用默认的缓冲区大小。

  为什么呢？原因很简单，目前为止计算机内存的 I/O 速度仍远远高于计算机外设（例如键盘、鼠标、硬盘等）的 I/O 速度，如果不使用缓冲区，则程序在执行 I/O 操作时，内存和外设就必须进行同步读写操作，也就是说，内存必须等待外设输入（输出）一个字节之后，才能再次输出（输入）一个字节。这意味着，内存中的程序大部分时间都处于等待状态。
  
  而如果使用缓冲区，则程序在执行输出操作时，会先将所有数据都输出到缓冲区中，然后继续执行其它操作，缓冲区中的数据会有外设自行读取处理；同样，当程序执行输入操作时，会先等外设将数据读入缓冲区中，无需同外设做同步读写操作。
• encoding：编码格式，常见的编码格式有ASCII、ANSI、GBK、GB2312、UTF-8、GB18030和UNICODE等。一般我们用utf-8作为encoding的编码格式。
• errors：errors是一个可选字符串，用于指定编码错误的方式，通过“strict”用于在编码错误时抛出ValueError异常(默认的None具有相同的效果)，或者通过“ignore”来忽略错误。(注意忽略编码错误会导致数据丢失。)
• newline:换行符的处理。
• closefd:如果closefd为False，底层文件描述符将保持打开状态。当文件关闭时。当给定文件名时，这不起作用。在这种情况下一定是真的。

而通常对于open函数来说，我们常用到的有file、mode、encoding这三个参数，其他的一般用不到，就用默认参数即可。

1.4 mode模式所有参数用法

'r'       open for reading (default)
'w'       open for writing, truncating the file first
'x'       create a new file and open it for writing
'a'       open for writing, appending to the end of the file if it exists
'b'       binary mode
't'       text mode (default)
'+'       open a disk file for updating (reading and writing)
'U'       universal newline mode (deprecated)

所有的用法其实可以分为三部分：

• r 读模式
• w 写模式
• a 追加模式

r模式就是读（read），可以通过表格看到r、rb、r+、rb+的意义和用法。

w模式就是写（write），也就是对文件的操作，同样可以通过w、wb、w+、wb+对文件进行写入操作，但需要注意的是，w模式会覆盖之前文件的内容：如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。所以一般不轻易使用w模式，有点危险。

a模式就是追加写入模式，和w模式相比a模式更加人性化，不会覆盖之前的内容，同时也保证新内容的记录。

x是原创模式，下面会详细进行说明。

b模式表示2进制模式，比如图片，图片就是二进制数据。

1.5 x原创模式

几乎所有的python学习资料里对open函数的讲解都没有涉及到x原创模式这个概念，这里简单的讲解下：

由于w模式会直接覆盖之前的文件，所以引入了x原创模式的概念，也就是如果之前有同名文件，会直接报错！

所以用x模式很保险，会防止同名文件覆盖的情况，导致文件信息丢失而造成不可挽回的影响，对原创的内容具有保护功能。

1.6 对于文件读取的深入理解

其实所有的读取都是基于文件指针的位置，通过指针的移动从而读取所有文件内容。

就像我们打开文件去读取是一样的，打开一个文件后，指针通常会在第一行第一列（第一个字符），对于默认的mode = r模式来说就是表示这个意思：

所以只要r开头的模式都是表示文件指针放在文件的开头位置。

而w模式同样也是表示文件指针放在文件开头的位置。

r模式和w模式也是我们最为常用，也是最普遍的mode模式用法。一个用来读，一个用来写。

那么哪些是指针从结尾开始？a模式开头的都是表示文件指针放在文件的结尾。

1.7 文件操作的流程

文件操作的流程不复杂，跟平时怎么读取、操作文件是一样的：

• 保证在同一文件夹
• 创建文件
• 打开文件

用open函数打开并读取文件，用一个变量比如 file 接收。

• 读取文件

file.read()

file.readline()

两者区别会放在文章的最后。

• 打印文件内容

可以通过print语句打印文件内容。

• 写入文件

file.write()，write括号内要加写入的内容。

• 打印文件内容

可以通过print语句打印文件内容。

• 关闭文件

file.close()

需要注意的是，每次打开文件进行操作后，一定要去关闭文件，在进行下次操作。

如果不关闭，下次再打开该文件进行操作时会出现异常，跟资源调度有关，这个需要注意！

2.open函数的实战应用

讲了那么多纸上谈兵，现在开始正儿八经的进行应用，目前默认为所有需要操作的文件都在同一文件夹进行：

2.1 普通操作

• 创建文件

• 读取操作：打开文件，读取当前内容。

file = open('demo.txt',mode='r',encoding='utf-8')
data = file.read()
print(data)

很明显，由于没有给文件写入内容，这里什么也读不到。

• 写入操作：对demo文件写入hello world，并读取。

file = open('demo.txt',mode='w',encoding='utf-8')
data = file.write('hello world')
file.close()

file = open('demo.txt',mode='r',encoding='utf-8')
print(file.read())
file.close()

hello world

2.2上下文表达式

由于每次打开文件后都要关闭，怕忘记写close，这里引入with语句来替代传统的open函数用法。用with语句就不用每次手动关闭文件了。

with语法：

with open(file) as 变量:
    代码语句

举例：

with open('demo.txt',mode='r',encoding='utf-8') as f:
    print(f.read())

hello world!

w模式：

with open('demo.txt',mode='w',encoding='utf-8') as f:
    f.write('Happy everyday!')

with open('demo.txt',mode='r',encoding='utf-8') as f:
    print(f.read())

Happy everyday!

a模式：

with open('demo.txt',mode='a',encoding='utf-8') as f:
    f.write('Happy everyday!')

with open('demo.txt',mode='r',encoding='utf-8') as f:
    print(f.read())

Happy everyday!Happy everyday!

2.3 read()和readline()区别

read()返回值得到是一个字符串，而readline()得到的是一个列表：

with open('demo.txt',mode='r',encoding='utf-8') as f:
    print(f.read())
    print(type(f.read()))

Happy everyday!
Happy everyday!
Happy everyday!
Happy everyday!
Happy everyday!
Happy everyday!
<class 'str'>

with open('demo.txt',mode='r',encoding='utf-8') as f:
    print(f.readlines())
    print(type(f.readlines()))

['Happy everyday!n', 'Happy everyday!n', 'Happy everyday!n', 'Happy everyday!n', 'Happy everyday!n', 'Happy everyday!']
<class 'list'>

readline()会去读取每一行，将每一行的内容作为一个列表的元素，存放在列表中。

而read()是将所有的内容放在一个字符串中并返回。这是两者最大的区别。

至于什么时候用read()什么时候用readline()看具体需求。

目前涉及到的open函数用法是基于同目录进行，在后期学习中学到os路径模块时再利用open函数去操作其他目录下的文件。

以上是《Python学习16：open内置函数讲解》的所有内容，open函数的相关练习会在出现在之后习题训练中，敬请期待。原创不易，如果喜欢请点赞和关注，谢谢大家的支持！

想获得免费的学习资料请添加微信公众号——风起怨江南，非常感谢大家的关注和支持！

最后

以上就是粗犷音响为你收集整理的Python学习16：open内置函数全方面讲解open内置函数全方面讲解的全部内容，希望文章能够帮你解决Python学习16：open内置函数全方面讲解open内置函数全方面讲解所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。