python File 内置 open()方法（打开文件）

From builtins.py

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 IOError upon failure.
    
    打开文件并返回流。 失败时抛出IOError异常。
    
    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.)
    
    file是一个文本或字节字符串，给出了要打开的文件的名称
    （如果文件不在当前工作目录中，则给出了路径）或要包装的文件的整数文件描述符。 
    （如果给出了文件描述符，则除非将closefd设置为False，否则当关闭返回的I / O对象时，它将关闭。）
    
    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:

	mode是一个可选字符串，用于指定打开文件的模式。 默认为“ r”，这意味着可以在文本模式下阅读。 其他通用值是用于写入的“ w”（如果文件已经存在，则将其内容清空），用于创建和写入新文件的“ x”，以及用于附加的“ a”（在某些Unix系统上，这意味着所有写入都附加到 不论当前搜寻位置在文件末尾）。 在文本模式下，如果未指定编码，则使用的编码取决于平台：调用locale.getpreferredencoding（False）以获取当前的语言环境编码。 （要读取和写入原始字节，请使用二进制模式，同时不用指定编码。）可用模式为：
    
    ========= ===============================================================
    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.

	默认模式是“ rt”（打开以阅读文本）。 
	对于二进制随机访问，模式“ w + b”将打开并将文件截断为0字节，而模式“ r + b”将打开文件而不会截断。
	 “ x”模式包含“ w”的功能并且，如果文件已经存在，则引发“ FileExistsError”。
	 (所以就是，如果稳健存在时，用‘w’就不会引发异常)
    
    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.
	
	Python区分以二进制和文本模式打开的文件，即使底层操作系统没有。 
	以二进制模式打开的文件（在mode参数后面添加“ b”）以字节对象形式返回内容，而无需进行任何解码。 
	在文本模式下（默认值，或在模式参数后附加't'），文件内容以字符串形式返回，首先使用与平台有关的编码或指定的编码（如果给定的话）对字节进行解码。
    
    '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.

	不建议使用“ U”模式，它将在将来的Python版本中引发异常。 
	它在Python 3中无效。使用换行符控制通用换行符模式。
    
    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:

	buffering是用于设置缓冲策略的可选整数。 
	传递0以关闭缓冲（仅在二进制模式下允许），传递1以选择行缓冲（仅在文本模式下可用），并传递大于1的整数以指示固定大小的块缓冲区的大小。 
	如果未指定任何缓冲参数，则默认的缓冲策略如下：
    
    * 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.

	* 二进制文件以固定大小的块缓冲； 
	缓冲区的大小是通过试探法来确定底层设备的“块大小”，然后回退到io.DEFAULT_BUFFER_SIZE上进行选择的。
	 在许多系统上，缓冲区的长度通常为4096或8192字节。    

    * "Interactive" text files (files for which isatty() returns True)
      use line buffering.  Other text files use the policy described above
      for binary files.

	* “交互式”文本文件（isatty（）返回True的文件）使用行缓冲。 
	其他文本文件将上述策略用于二进制文件。
    
    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.

	* encoding是用于解码或编码文件的编码的名称。 
	仅应在文本模式下使用。 默认编码取决于平台，但是可以支持Python支持的任何编码。 
	有关支持的编码列表，请参见编解码器模块。
    
    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.

	errors是一个可选字符串，它指定如何处理编码错误---不应在二进制模式下使用此参数。 
	如果存在编码错误（默认值为None具有相同的效果），则传递“ strict”以引发ValueError异常，或传递“ ignore”以忽略错误。 
	（请注意，忽略编码错误可能会导致数据丢失。）
	请参阅codecs.register的文档，或运行“ help（codecs.Codec）”以获取允许的编码错误字符串列表。

	
    
    newline controls how universal newlines works (it only applies to text
    mode). It can be None, '', '\n', '\r', and '\r\n'.  It works as
    follows:
	
	newline控制通用换行符的工作方式（仅适用于文本模式）。 
	可以是“无”，“”，“ \ n”，“ \ r”和“ \ r \ n”。 它的工作方式如下
    
    * On input, 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 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.

	*在输入时，如果换行符为None，则启用通用换行符模式。 
	输入中的行可以以'\ n'，'\ r'或'\ r \ n'结尾，在返回给调用者之前，这些行会转换为'\ n'。 
	如果为”，则启用通用换行模式，但行结尾不翻译就返回给呼叫者。 
	如果它具有任何其他合法值，则输入行仅由给定的字符串终止，并且该行的末尾未经转换返回给调用方。
    
    * 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.

	*在输出中，如果换行符为None，则任何写入的'\ n'字符都将转换为系统默认的行分隔符os.linesep。 
	如果换行符是''或'\ n'，则不会进行翻译。 
	如果换行符是其他任何合法值，则将写入的所有“ \ n”字符转换为给定的字符串。

	
    
    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.

	如果closefd为False，则关闭文件时基础文件描述符将保持打开状态。 
	给定文件名时，此方法不起作用，在这种情况下必须为True。
    
    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).

	可以通过将可调用对象传递为* opener *来使用自定义的opener。 
	然后通过使用（* file *，* flags *）调用* opener *获得文件对象的基础文件描述符。 
	* opener *必须返回打开文件描述符（将os.open作为* opener *传递，其功能类似于传递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.

	open（）返回一个文件对象，其类型取决于模式，并通过该文件对象执行诸如读写之类的标准文件操作。 
	当使用open（）以文本模式（“ w”，“ r”，“ wt”，“ rt”等）打开文件时，它将返回TextIOWrapper。 
	当用于以二进制模式打开文件时，返回的类有所不同：在读取二进制模式下，它返回BufferedReader； 
	在写二进制和追加二进制模式下，它返回BufferedWriter；在读/写模式下，它返回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.

	也可以使用字符串或字节数组作为文件进行读取和写入。 
	对于字符串，可以将StringIO用作以文本模式打开的文件，而对于字节，可以将BytesIO用作以二进制模式打开的文件。
    """
    pass

Dontla 20191030

貌似在使用’w+'模式对文件进行写读操作的时候（先写后读），读不出来东西。。。空白的
引用文章：day-2 python 文件读写模式r,r+,w,w+,a,a+的区别

Dontla 20200422

在看LabelImg代码的时候，发现程序会使用

def read(filename, default=None):
    try:
        with open(filename, 'rb') as f:
            return f.read()
    except:
        return default

二进制模式来读取图片数据

但是显示却是16进制的