Python：open的文件读取操作，utf-8,

    ========= ===============================================================
    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)
    ========= ===============================================================

    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.

    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:
    
    * 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.
    
    * 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.

f1 = open(path, ‘r‘)
a = f1.read()    #read()一次读取全部内容，数据量很大时建议使用readline或者read(1024)等，1024表示字节数
# UnicodeDecodeError: ‘gbk‘ codec can‘t decode byte 0xa4 in position 54: illegal multibyte sequence
print(a)
f1.close()

f2 = open(path, ‘r‘, encoding=‘utf-8‘)
a = f2.read()    #read()一次读取全部内容，数据量很大时建议使用readline或者read(1024)等，1024表示字节数
print(a)
f2.close()

# ------------------------------
f2 = open(path, ‘r‘, encoding=‘utf-8‘)
a = f2.read()    #read()一次读取全部内容，数据量很大时建议使用readline或者read(1024)等，1024表示字节数
print(a)
f2.close()

# ------------------------------
f3 = open(path, ‘r‘, encoding=‘utf-8‘)
a = f3.read(4)    #数据量很大时建议使用readline或者read(size)等，size表示字节数
print(a)
f3.close()

# ------------------------------
f4 = open(path, ‘r‘, encoding=‘utf-8‘)
a = f4.readline()    #readline()一次读取一行
print(a)
f4.close()


# -----------------------------
f5 = open(path, ‘r‘, encoding=‘utf-8‘)
a = f5.readlines()    #readlines()一次读取多行，构成list，可以用于迭代
print(‘a：‘,a)
f5.close()

f7 = open(path, ‘r‘, encoding=‘utf-8‘)
a = f7.readline()    #readlines()一次读取多行，构成list，可以用于迭代
print(a)
cc = f7.tell()   # 返回文件当前位置
print(cc)
f7.close()

f8 = open(path, ‘r+‘, encoding=‘utf-8‘)   # r+文件指针从开头开始读写
a = f8.readlines()         #readlines()一次读取多行，构成list，可以用于迭代
print(‘a：‘,a)
f8.writelines([‘\n陈王昔时宴平乐，斗酒十千恣戏虐\n‘,‘哎，李白‘])   # 向文件写入一个序列字符串列表，此时文件指针在结尾处，相当于追加了
dd = f8.read()
print(‘dd：‘,dd)  #此时文件指针在末尾，所以为空
f8.close()

f9 = open(path, ‘r+‘, encoding=‘utf-8‘) # r+文件指针从开头开始读写
a = f9.readlines()    #readlines()一次读取多行，构成list，可以用于迭代
print(‘a：‘,a)
f9.write(‘\n陈王昔时宴平乐，斗酒十千恣戏虐‘) #通过上述读操作，文件指针在结尾处；此时写操作也会在结尾处进行
b = f9.read()
print(‘b：‘,b)  #为空，因为文件指针的位置
f9.close()

f10 = open(path, ‘r‘, encoding=‘utf-8‘)
a = f10.readlines()    #readlines()一次读取多行，构成list，可以用于迭代
print(‘a：‘,a)
f10.close()
f11 = open(path, ‘a+‘, encoding=‘utf-8‘)   #a+模式用于追加
f11.write(‘\n陈王昔时宴平乐，斗酒十千恣戏虐‘)
b = f11.read()
print(‘b：‘,b)    #这里值为空，是因为文件指针此时在文件的末尾；如果要读数据，需要设置文件指针的位置
f11.seek(6,0)  # f.seek(偏移量,[起始位置])，用来移动文件指针；偏移量: 单位为比特（字节），可正可负；起始位置: 0-文件头, 默认值; 1-当前位置; 2-文件尾
b = f11.read()  
print(‘b：‘,b)
f11.close()

# 文件指针
f12 = open(path, ‘a+‘, encoding=‘utf-8‘)   #a+模式用于追加
f12.write(‘\n陈王昔时宴平乐，斗酒十千恣戏虐‘)
c = f12.tell()   # 返回文件当前位置，因为a+，所以上述的write操作在末尾进行，然后文件指针也在末尾了：269
print(‘c：‘,c)
f12.seek(6,0)  # f.seek(偏移量,[起始位置])，用来移动文件指针；偏移量: 单位为比特（字节），可正可负；起始位置: 0-文件头, 默认值; 1-当前位置; 2-文件尾
d = f12.tell()   # 返回文件当前位置，经过偏移之后为：6
print(‘d：‘,d)
e = f12.read()  #读取整个文件，读完后又到末尾了
print(‘e：‘,e)
f = f12.tell()   # 返回文件当前位置，此时在末尾：269
print(‘f：‘,f)
f12.close()

# ------------------------------------
# 2. with open：可以不需要显式关闭文件操作：f.close
with open(path, ‘r‘, encoding=‘utf-8‘) as f13:
    a = f13.readlines()    #readline()一次读取一行
    print(a)

# 下一行：f.__next__()
with open(path, ‘r‘, encoding=‘utf-8‘) as f13:
    a = f13.readline()    #readline()一次读取一行
    print(‘a：‘,a)
    b = f13.__next__()
    print(‘b：‘,b)