python3字符编码与文件处理终极版

客官°小女子只卖身不卖艺 2023-07-04 14:14 3阅读 0赞

### python3字符编码与文件处理 ###

*  1. 什么是编码
 *   *  ASCII
     *  GB2312
     *  GBK 和 GB18030
     *  UNICODE
     *  utf8
     *  Unicode与utf8的关系
     *  拓展：utf8是如何节约硬盘和流量的
 *  2. py2的string编码 (官方不再维护py2)
 *  3. py3的string编码
 *  4. 文件从磁盘到内存的编码
 *  5. 常见的编码问题
 *   *  cmd下的乱码问题
     *  linux下的乱码问题
 *  6. 文件操作
 *   *  实例演示
     *  文件打开模式回顾
     *  文件内容读写回顾
     *  文件修改
     *  read(),readline(),readlines()的区别

![在这里插入图片描述][20200211205907879.png]

# 1. 什么是编码 #

基本概念很简单。首先，我们从一段信息即消息说起，消息以人类可以理解、易懂的表示存在。我打算将这种表示称为“明文”（plain text）。对于说英语的人，纸张上打印的或屏幕上显示的英文单词都算作明文。

其次，我们需要能将明文表示的消息转成另外某种表示，我们还需要能将编码文本转回成明文。从明文到编码文本的转换称为“编码”，从编码文本又转回成明文则为“解码”。

编码问题是个大问题，如果不彻底解决，它就会像隐藏在丛林中的小蛇，时不时地咬你一口。那么到底什么是编码呢？

## ASCII ##

记住一句话：计算机中的所有数据，不论是文字、图片、视频、还是音频文件，本质上最终都是按照类似 01010101 的二进制存储的。

再说简单点，计算机只懂二进制数字！

所以，目的明确了：如何将我们能识别的符号唯一的与一组二进制数字对应上？于是美利坚的同志想到通过一个电平的高低状态来代指0或1，八个电平做为一组就可以表示出256种不同状态，每种状态就唯一对应一个字符，比如A—>00010001,而英文只有26个字符，算上一些特殊字符和数字，128个状态也够用了；每个电平称为一个比特为，约定8个比特位构成一个字节，这样计算机就可以用127个不同字节来存储英语的文字了。这就是ASCII编码。

扩展ANSI编码  
刚才说了，最开始，一个字节有八位，但是最高位没用上，默认为0；后来为了计算机也可以表示拉丁文，就将最后一位也用上了，从128到255的字符集对应拉丁文啦。至此，一个字节就用满了！

## GB2312 ##

计算机漂洋过海来到中国后，问题来了，计算机不认识中文，当然也没法显示中文；而且一个字节所有状态都被占满了，万恶的帝国主义亡我之心不死啊！我党也是棒，自力更生，自己重写一张表，直接生猛地将扩展的第八位对应拉丁文全部删掉，规定一个小于127的字符的意义与原来相同，但两个大于127的字符连在一起时，就表示一个汉字，前面的一个字节（他称之为高字节）从0xA1用到0xF7，后面一个字节（低字节）从0xA1到0xFE，这样我们就可以组合出大约7000多个简体汉字了；这种汉字方案叫做 “GB2312”。GB2312 是对 ASCII 的中文扩展。

## GBK 和 GB18030 ##

但是汉字太多了，GB2312也不够用，于是规定：只要第一个字节是大于127就固定表示这是一个汉字的开始，不管后面跟的是不是扩展字符集里的内容。结果扩展之后的编码方案被称为 GBK 标准  
GBK 包括了 GB2312 的所有内容，同时又增加了近20000个新的汉字（包括繁体字）和符号。

## UNICODE ##

很多其它国家都搞出自己的编码标准，彼此间却相互不支持。这就带来了很多问题。于是，国际标谁化组织为了统一编码：提出了标准编码准，则：UNICODE  
UNICODE是用两个字节来表示为一个字符，它总共可以组合出65535不同的字符，这足以覆盖世界上所有符号（包括甲骨文）

## utf8 ##

unicode都一统天下了，为什么还要有一个utf8的编码呢？

大家想，对于英文世界的人们来讲，一个字节完全够了，比如要存储A,本来00010001就可以了，现在吃上了unicode的大锅饭，得用两个字节：00000000 00010001才行，浪费太严重！  
基于此，美利坚的科学家们提出了天才的想法：utf8.  
UTF-8（8-bit Unicode Transformation Format）是一种针对Unicode的可变长度字符编码，它可以使用1~4个字节表示一个符号，根据不同的符号而变化字节长度，当字符在ASCII码的范围时，就用一个字节表示，所以是兼容ASCII编码的。

这样显著的好处是，**虽然在我们内存中的数据都是unicode，但当数据要保存到磁盘或者用于网络传输时，直接使用unicode就远不如utf8省空间啦！**  
这也是为什么utf8是我们的推荐编码方式。

## Unicode与utf8的关系 ##

一言以蔽之：Unicode是内存编码表示方案（是规范），而UTF是如何保存和传输Unicode的方案（是实现）这也是UTF与Unicode的区别

## 拓展：utf8是如何节约硬盘和流量的 ##

s=“I’m 洪哥”

你看到的unicode字符集是这样的编码表：

I  0049
    '  0027
    m  006d
       0020
    洪 82d1
    哥 660a

每一个字符对应一个十六进制数字。  
计算机只懂二进制，因此，严格按照unicode的方式(UCS-2)，应该这样存储：

I      00000000 01001001
    '      00000000 00100111
    m      00000000 01101101
           00000000 00100000
    洪     10000010 11010001
    哥     01100110 00001010

这个字符串总共占用了12个字节，但是对比中英文的二进制码，可以发现，英文前9位都是0！浪费啊，浪费硬盘，浪费流量。怎么办？UTF8:

I    01001001
    '    00100111
    m    01101101
         00100000
    洪   11101000 10001011 10010001
    哥   11100110 10011000 10001010

utf8用了10个字节，对比unicode，少了两个，因为我们的程序英文会远多于中文，所以空间会提高很多！**记住：一切都是为了节省你的硬盘和流量。**

# 2. py2的string编码 (官方不再维护py2) #

在py2中，有两种字符串类型：str类型和unicode类型；注意，这仅仅是两个名字，python定义的两个名字，关键是这两种数据类型在程序运行时存在内存地址的是什么？

#coding:utf8
     
    s1='苑'
     
    print type(s1) # <type 'str'>
    print repr(s1) #'\xe8\x8b\x91
     
    s2=u'苑'
    print type(s2) # <type 'unicode'>
    print repr(s2) # u'\u82d1'

内置函数repr可以帮我们在这里显示存储内容。原来，str和unicode分别存的是字节数据和unicode数据；那么两种数据之间是什么关心呢？如何转换呢?这里就涉及到编码(encode)和解码(decode)了

s1=u'苑'
    print repr(s1) #u'\u82d1'
    
    b=s1.encode('utf8')
    print b
    print type(b)  #<type 'str'>
    print repr(b)  #'\xe8\x8b\x91'
    
    s2='苑昊'
    u=s2.decode('utf8')
    print u        # 苑昊
    print type(u)  # <type 'unicode'>
    print repr(u)  # u'\u82d1\u660a'
    
    #注意
    u2=s2.decode('gbk')
    print u2  #鑻戞槉
    
    print len('苑昊') #6

无论是utf8还是gbk都只是一种编码规则，一种把unicode数据编码成字节数据的规则，所以utf8编码的字节一定要用utf8的规则解码，否则就会出现乱码或者报错的情况。  
![在这里插入图片描述][20200211212839790.png]  
py2编码的特色：

#coding:utf8
     
    print '苑昊' # 苑昊 
    print repr('苑昊')#'\xe8\x8b\x91\xe6\x98\x8a'
     
    print (u"hello"+"yuan")
     
    #print (u'苑昊'+'最帅') #UnicodeDecodeError: 'ascii' codec can't decode byte 0xe6
                             # in position 0: ordinal not in range(128)

Python 2 悄悄掩盖掉了 byte 到 unicode 的转换，只要数据全部是 ASCII 的话，所有的转换都是正确的，一旦一个非 ASCII 字符偷偷进入你的程序，那么默认的解码将会失效，造成UnicodeDecodeError 的错误。py2编码让程序在处理 ASCII 的时候更加简单。你复出的代价就是在处理非 ASCII 的时候将会失败。

# 3. py3的string编码 #

y3也有两种数据类型：str和bytes； str类型存unicode数据，bytse类型存bytes数据，与py2比只是换了一下名字而已。

import json
    
    s='苑昊'
    print(type(s))       #<class 'str'>
    print(json.dumps(s)) # "\u82d1\u660a"
    
    b=s.encode('utf8')
    print(type(b))      # <class 'bytes'>
    print(b)            # b'\xe8\x8b\x91\xe6\x98\x8a'
    
    
    u=b.decode('utf8')
    print(type(u))       #<class 'str'>
    print(u)             #苑昊
    print(json.dumps(u)) #"\u82d1\u660a"
    
    
    print(len('苑昊')) # 2

![在这里插入图片描述][20200212091704523.png]  
py3的编码哲学：  
Python 3最重要的新特性大概要算是对文本和二进制数据作了更为清晰的区分，不再会对bytes字节串进行自动解码。文本总是Unicode，由str类型表示，二进制数据则由bytes类型表示。Python 3不会以任意隐式的方式混用str和bytes，正是这使得两者的区分特别清晰。你不能拼接字符串和字节包，也无法在字节包里搜索字符串（反之亦然），也不能将字符串传入参数为字节包的函数（反之亦然）。

#print('alvin'+u'yuan')#字节串和unicode连接 py2:alvinyuan
    print(b'alvin'+'yuan')#字节串和unicode连接 py3:报错 can't concat bytes to str

注意：无论py2，还是py3,与明文直接对应的就是unicode数据，打印unicode数据就会显示相应的明文(包括英文和中文)

# 4. 文件从磁盘到内存的编码 #

说到这，才来到我们的重点！

抛开执行执行程序，请问大家，文本编辑器大家都是用过吧，如果不懂是什么，那么word总用过吧，ok，当我们在word上编辑文字的时候，不管是中文还是英文，计算机都是不认识的，那么在保存之前数据是通过什么形式存在内存的呢？yes，就是unicode数据，为什么要存unicode数据，这是因为它的名字最屌：万国码！解释起来就是无论英文，中文，日文，拉丁文，世界上的任何字符它都有唯一编码对应，所以兼容性是最好的。

好，那当我们保存了存到磁盘上的数据又是什么呢？

答案是通过某种编码方式编码的bytes字节串。比如utf8-－－一种可变长编码，很好的节省了空间；当然还有历史产物的gbk编码等等。于是，在我们的文本编辑器软件都有默认的保存文件的编码方式，比如utf8，比如gbk。当我们点击保存的时候，这些编辑软件已经"默默地"帮我们做了编码工作。

那当我们再打开这个文件时，软件又默默地给我们做了解码的工作，将数据再解码成unicode,然后就可以呈现明文给用户了！所以，unicode是离用户更近的数据，bytes是离计算机更近的数据。

说了这么多，和我们程序执行有什么关系呢？

先明确一个概念：py解释器本身就是一个软件，一个类似于文本编辑器一样的软件！

现在让我们一起还原一个py文件从创建到执行的编码过程：

打开pycharm，创建hello.py文件，写入

ret=1+1
    s='苑昊'
    print(s)

当我们保存的的时候，hello.py文件就以pycharm默认的编码方式保存到了磁盘；关闭文件后再打开，pycharm就再以默认的编码方式对该文件打开后读到的内容进行解码，转成unicode到内存我们就看到了我们的明文；

而如果我们点击运行按钮或者在命令行运行该文件时，py解释器这个软件就会被调用，打开文件，然后解码存在磁盘上的bytes数据成unicode数据，这个过程和编辑器是一样的，不同的是解释器会再将这些unicode数据翻译成C代码再转成二进制的数据流，最后通过控制操作系统调用cpu来执行这些二进制数据，整个过程才算结束。

那么问题来了，我们的文本编辑器有自己默认的编码解码方式，我们的解释器有吗？

当然有啦，py2默认ASCII码，py3默认的utf8，可以通过如下方式查询

import sys
    print(sys.getdefaultencoding())

大家还记得这个声明吗？

#coding:utf8

是的，这就是因为如果py2解释器去执行一个utf8编码的文件，就会以默认地ASCII去解码utf8，一旦程序中有中文，自然就解码错误了，所以我们在文件开头位置声明　\#coding:utf8，其实就是告诉解释器，你不要以默认的编码方式去解码这个文件，而是以utf8来解码。而py3的解释器因为默认utf8编码，所以就方便很多了。  
![在这里插入图片描述][20200212092303233.png]

# 5. 常见的编码问题 #

## cmd下的乱码问题 ##

hello.py

#coding:utf8
    print ('苑昊')

文件保存时的编码也为utf8。  
思考：为什么在IDE下用2或3执行都没问题，在cmd.exe下3正确，2乱码呢？

我们在win下的终端即cmd.exe去执行，大家注意，cmd.exe本身也一个软件；当我们python2 hello.py时，python2解释器(默认ASCII编码)去按声明的utf8编码文件，而文件又是utf8保存的，所以没问题；问题出在当我们print’苑昊’时，解释器这边正常执行，也不会报错，只是print的内容会传递给cmd.exe用来显示，而在py2里这个内容就是utf8编码的字节数据，可这个软件默认的编码解码方式是GBK，所以cmd.exe用GBK的解码方式去解码utf8自然会乱码。

py3正确的原因是传递给cmd的是unicode数据，cmd.exe可以识别内容，所以显示没问题。

明白原理了，修改就有很多方式，比如：

print (u'苑昊')

改成这样后，cmd下用2也不会有问题了。  
创建一个hello文本，保存成utf8：

苑昊，你最帅！

同目录下创建一个index.py

f=open('hello')
    print(f.read())

## linux下的乱码问题 ##

为什么 在linux下，结果正常：苑昊，在win下，乱码：鑻戞槉（py3解释器）？

因为你的win的操作系统安装时是默认的gbk编码，而linux操作系统默认的是utf8编码；

当执行open函数时，调用的是操作系统打开文件，操作系统用默认的gbk编码去解码utf8的文件，自然乱码。

解决办法：

f=open('hello',encoding='utf8')
    print(f.read())

如果你的文件保存的是gbk编码，在win 下就不用指定encoding了。

另外，如果你的win上不需要指定给操作系统encoding=‘utf8’，那就是你安装时就是默认的utf8编码或者已经通过命令修改成了utf8编码。

注意：open这个函数在py2里和py3中是不同的，py3中有了一个encoding＝None参数。

参考 ：[https://diveintopython3.net/strings.html][https_diveintopython3.net_strings.html]

# 6. 文件操作 #

文件操作流程

1.  打开文件，得到文件句柄并赋值给一个变量
2.  通过句柄对文件进行操作
3.  关闭文件

现有文件如下 ：

Somehow, it seems the love I knew was always the most destructive kind
    不知为何，我经历的爱情总是最具毁灭性的的那种
    Yesterday when I was young
    昨日当我年少轻狂
    The taste of life was sweet
    生命的滋味是甜的
    As rain upon my tongue
    就如舌尖上的雨露
    I teased at life as if it were a foolish game
    我戏弄生命 视其为愚蠢的游戏
    The way the evening breeze
    就如夜晚的微风
    May tease the candle flame
    逗弄蜡烛的火苗
    The thousand dreams I dreamed
    我曾千万次梦见
    The splendid things I planned
    那些我计划的绚丽蓝图
    I always built to last on weak and shifting sand
    但我总是将之建筑在易逝的流沙上
    I lived by night and shunned the naked light of day
    我夜夜笙歌 逃避白昼赤裸的阳光
    And only now I see how the time ran away
    事到如今我才看清岁月是如何匆匆流逝
    Yesterday when I was young
    昨日当我年少轻狂
    So many lovely songs were waiting to be sung
    有那么多甜美的曲儿等我歌唱
    So many wild pleasures lay in store for me
    有那么多肆意的快乐等我享受
    And so much pain my eyes refused to see
    还有那么多痛苦 我的双眼却视而不见
    I ran so fast that time and youth at last ran out
    我飞快地奔走 最终时光与青春消逝殆尽
    I never stopped to think what life was all about
    我从未停下脚步去思考生命的意义
    And every conversation that I can now recall
    如今回想起的所有对话
    Concerned itself with me and nothing else at all
    除了和我相关的 什么都记不得了
    The game of love I played with arrogance and pride
    我用自负和傲慢玩着爱情的游戏
    And every flame I lit too quickly, quickly died
    所有我点燃的火焰都熄灭得太快
    The friends I made all somehow seemed to slip away
    所有我交的朋友似乎都不知不觉地离开了
    And only now I'm left alone to end the play, yeah
    只剩我一个人在台上来结束这场闹剧
    Oh, yesterday when I was young
    噢 昨日当我年少轻狂
    So many, many songs were waiting to be sung
    有那么那么多甜美的曲儿等我歌唱
    So many wild pleasures lay in store for me
    有那么多肆意的快乐等我享受
    And so much pain my eyes refused to see
    还有那么多痛苦 我的双眼却视而不见
    There are so many songs in me that won't be sung
    我有太多歌曲永远不会被唱起
    I feel the bitter taste of tears upon my tongue
    我尝到了舌尖泪水的苦涩滋味
    The time has come for me to pay for yesterday
    终于到了付出代价的时间 为了昨日
    When I was young
    当我年少轻狂

基本操作

f = open('lyrics') #打开文件
    first_line = f.readline()
    print('first line:',first_line) #读一行
    print('我是分隔线'.center(50,'-'))
    data = f.read()# 读取剩下的所有内容,文件大时不要用
    print(data) #打印文件
     
    f.close() #关闭文件

打开文件的模式有：

*  r，只读模式（默认）。
 *  w，只写模式。【不可读；不存在则创建；存在则删除内容；】
 *  a，追加模式。【可读； 不存在则创建；存在则只追加内容；】

“+” 表示可以同时读写某个文件

*  r+，可读写文件。【可读；可写；可追加】
 *  w+，写读
 *  a+，同a

"U"表示在读取时，可以将 \\r \\n \\r\\n自动转换成 \\n （与 r 或 r+ 模式同使用）

*  rU
 *  r+U

"b"表示处理二进制文件（如：FTP发送上传ISO镜像文件，linux可忽略，windows处理二进制文件时需标注）

*  rb
 *  wb
 *  ab  
    其他语法：

class IO(Generic[AnyStr]):
        """Generic base class for TextIO and BinaryIO. This is an abstract, generic version of the return of open(). NOTE: This does not distinguish between the different possible classes (text vs. binary, read vs. write vs. read/write, append-only, unbuffered). The TextIO and BinaryIO subclasses below capture the distinctions between text vs. binary, which is pervasive in the interface; however we currently do not offer a way to track the other distinctions in the type system. """
    
        __slots__ = ()
    
        @abstractproperty
        def mode(self) -> str:
            pass
    
        @abstractproperty
        def name(self) -> str:
            pass
    
        @abstractmethod
        def close(self) -> None:
        """ Close the file. A closed file cannot be used for further I/O operations. close() may be called more than once without error. """
            pass
    
        @abstractmethod
        def closed(self) -> bool:
            pass
    
        @abstractmethod
        def fileno(self) -> int:
        """ Return the underlying file descriptor (an integer). """
            pass
    
        @abstractmethod
        def flush(self) -> None:
            pass
    
        @abstractmethod
        def isatty(self) -> bool:
        """ True if the file is connected to a TTY device. """
            pass
    
        @abstractmethod
        def read(self, n: int = -1) -> AnyStr:
         """ 注意，不一定能全读回来 Read at most size bytes, returned as bytes. Only makes one system call, so less data may be returned than requested. In non-blocking mode, returns None if no data is available. Return an empty bytes object at EOF. """
            pass
    
        @abstractmethod
        def readable(self) -> bool:
        """ True if file was opened in a read mode. """
            pass
    
        @abstractmethod
        def readline(self, limit: int = -1) -> AnyStr:
            pass
    
        @abstractmethod
        def readlines(self, hint: int = -1) -> List[AnyStr]:
            pass
    
        @abstractmethod
        def seek(self, offset: int, whence: int = 0) -> int:
        """ Move to new file position and return the file position. Argument offset is a byte count. Optional argument whence defaults to SEEK_SET or 0 (offset from start of file, offset should be >= 0); other values are SEEK_CUR or 1 (move relative to current position, positive or negative), and SEEK_END or 2 (move relative to end of file, usually negative, although many platforms allow seeking beyond the end of a file). Note that not all file objects are seekable. """
            pass
    
        @abstractmethod
        def seekable(self) -> bool:
        """ True if file supports random-access. """
            pass
    
        @abstractmethod
        def tell(self) -> int:
        """ Current file position. Can raise OSError for non seekable files. """
            pass
    
        @abstractmethod
        def truncate(self, size: int = None) -> int:
        """ Truncate the file to at most size bytes and return the truncated size. Size defaults to the current file position, as returned by tell(). The current file position is changed to the value of size. """
            pass
    
        @abstractmethod
        def writable(self) -> bool:
        """ True if file was opened in a write mode. """
            pass
    
        @abstractmethod
        def write(self, s: AnyStr) -> int:
        """ Write bytes b to file, return number written. Only makes one system call, so not all of the data may be written. The number of bytes actually written is returned. In non-blocking mode, returns None if the write would block. """
            pass
    
        @abstractmethod
        def writelines(self, lines: List[AnyStr]) -> None:
            pass
    
        @abstractmethod
        def __enter__(self) -> 'IO[AnyStr]':
            pass
    
        @abstractmethod
        def __exit__(self, type, value, traceback) -> None:
            pass

with语句

为了避免打开文件后忘记关闭，可以通过管理上下文，即：

with open('log','r') as f:
         
        ...

如此方式，当with代码块执行完毕时，内部会自动关闭并释放文件资源。

在Python 2.7 后，with又支持同时对多个文件的上下文进行管理，即：

with open('log1') as obj1, open('log2') as obj2:
        pass

## 实例演示 ##

test\_file.txt 文件内容如下：

打印字符串第一个字符
    
    打印字符串第二个字符

打开文件test\_file.txt

f = open('test_file.txt', 'r+') #f是文件的文件句柄，它是在内存中的，是内存中的一个对象
    data = f.read()
    print(data)

data结果：

打印字符串第一个字符
    
    打印字符串第二个字符

再次读test\_file.txt文件

data2 = f.read() #再读一次文件
    print("data2=", data2) #data2=
    # 此时的结果是data2= ，也就是此时读取的data2为空，为什么？
    # 因为第一次data读的时候文件光标是从头开始一直读到最后的，再次读的时候，
    # 是从此时光标所在的位置（此时光标在最后面）开始读取，因为光标已经在最后了，
    # 后面已经没有任何内容了，当然data2就读不出来数据了
    # 可以用seek重新定位光标的位置
    f.seek(0) #将光标定位到文件的开始位置
    data3 = f.read()
    print(data3)

此时data3结果

打印字符串第一个字符
    
    打印字符串第二个字符

用write写入文件

#f = open('test_file.txt', 'w') #如果是'w'写的模式的时候，系统会自动创建一个这个名字的文件，
    # 如果该目录下有这个名字的文件，系统会直接覆盖掉原来的文件，原来的文件及内容就不存在了，所以这点一定要注意。
    #f.write('\n\n写入字符串第三个字符')
    f.seek(0) #seekable()判断文件内容是否可以进行seek操作，因为有些文件是不可以进行seek的
    data4 = f.read()
    print(data4)
    f.close()

data4内容

打印字符串第一个字符
    
    打印字符串第二个字符
    
    写入字符串第三个字符

向文件追加内容

#向文件追加内容
    f = open('test_file.txt', 'a') #'a'是append 追加，但是不能读取文件
    f.write('\n\nhaha')
    print(f.readable()) #False 判断文件是否可读
    f.close()
    #读取一行内容
    f = open('test_file.txt', 'r')
    data = f.readline()
    print(data) # 打印字符串第一个字符
    #读取多行
    data2 = f.readlines()
    print(data2)

读取到第3行

for index, line in enumerate(f.readlines()):  #仅适合读取小文件
        print(line.strip())
        if index == 2:
            break;
    f.close()

读取大文件（推荐使用）

f = open('test_file.txt', 'r')
    for line in f:  #这样写的效果就是逐行读取文件中的内容，并且内存中始终仅保存读取的这一行内容 此时的f是一个迭代器
        print(line)
    f.close()

查看文件游标所在的位置

f = open('test_file.txt', 'r')
    print(f.tell()) #0
    print(f.read(5))
    print(f.tell()) #10 因为一个汉字占2个字节，所以这里显示的是10
    f.close()
    f2 = open('test_file2.txt', 'r')
    print(f2.tell()) #0
    print(f2.read(5))
    print(f2.tell()) #5 因为一个英文占1个字节，所以这里显示的是5
    f2.close()

查看文件编码与文件名

f = open('test_file.txt', 'r+')
    print(f.encoding)  #cp936 #查看文件编码
    print(f.name) # test_file.txt 查看文件名

实时存储数据

#f.write("sdfadf") #因为代码执行的过程中并不是出现依据写到硬盘的代码就立马开始向硬盘存储。
    #系统有一个阀门限制，系统会在内存中开辟一块用来临时存储的区域，当临时存储区域的数据达到一定值时，才会从内存存到硬盘上。
    #所以并不是执行一行写的代码后，硬盘就一定已经保存了该结果，很可能该结果还没有被保存。
    f.flush()
    print(f.flush()) #None
    f.close()

截断字符truncate

f = open('test_file.txt', 'r+')
    f.truncate(10)  #打印字符串 从文件头开始截取10个字节(一个汉字是2个字节)
    f.truncate() #如果什么都不写，就是截取0个字节也就相当于清空文件内容
    f.close()

写二进制文件内容

f = open('test_file.txt', 'wb')
    f.write('hello'.encode(encoding='utf-8'))
    f.close()

演示进度条

import sys
    import time
    for i in range(31):
        sys.stdout.write('#')
        sys.stdout.flush()
        time.sleep(0.3)

文件操作基本用法

file_object = open(file_name, access_mode = ‘r’, buffering = -1)
    
    open函数有很多的参数，常用的是file_name，mode和encoding
    
    file_name:打开的文件名,若非当前路径，需指出具体路径
    access_mode文件打开模式
    buffering的可取值有0，1，>1三个，0代表buffer关闭（只适用于二进制模式），1代表line buffer（只适用于文本模式），>1表示初始化的buffer大小； 
    encoding表示的是返回的数据采用何种编码，一般采用utf8或者gbk

## 文件打开模式回顾 ##

r ，只读模式【默认模式，文件必须存在，不存在则抛出异常】
    w，只写模式【不可读；不存在则创建；存在则清空内容】
    x， 只写模式【不可读；不存在则创建，存在则报错】
    a， 追加模式【不可读文件，不存在则创建；存在则只追加内容】，文件指针自动移到文件尾。
    "+" 表示可以同时读写某个文件
    r+， 读写【可读，可写】
    w+，写读【可读，可写】，消除文件内容，然后以读写方式打开文件。
    x+ ，写读【可读，可写】
    a+， 写读【可读，可写】，以读写方式打开文件，并把文件指针移到文件尾。
     "b"表示以字节的方式操作，以二进制模式打开文件，而不是以文本模式。
    rb  或 r+b
    wb 或 w+b
    xb 或 w+b
    ab 或 a+b
     注：以b方式打开时，读取到的内容是字节类型，写入时也需要提供字节类型，不能指定编码

## 文件内容读写回顾 ##

python中有三个方法来处理文件内容的读取：
    read() #一次读取全部的文件内容。返回字符串
    
    readline() #每次读取文件的一行。
    
    readlines() #读取文件的所有行，返回一个字符串列表。
    
    2）print(f.readable())    #判断文件是否是r模式打开的
    
    3）print(f.closed) 　　　#判断文件是否是关闭状态
    
    4）python中在文本文件内容移动的操作
    file.seek(offset,whence=0)     #从文件中给移动指针，从whence(0起始，1当前，2末尾)偏移offset个字节，正往结束方向移动，负往开始方向移动
    file.tell() 　　　　　　　　　#返回当前文件中的位置。获得文件指针位置
    
    5） file.truncate(size=file.tell())    #截取文件到最大size个字节，默认为当前文件位置
    
    4）以w方式写入文件
    
    f=open('a.txt','w',encoding='utf-8')
    #f=open('b.txt','r',encoding='utf-8') #以读的方式打开文件，文件不存在则报错
    f=open('b.txt','w',encoding='utf-8')
    #print(f.writable())
    f.write('111111\n22222222')
    f.seek(0)
    f.write('\n333333\n444444')
    
    f.writelines(['\n55555\n','6666\n','77777\n'])
    f.close()
    复制代码
    a.txt 为空
    
    b.txt
    333333
    444444
    55555
    6666
    77777
    补充：
    
    file.write(str)     #向文件中写入字符串(文本或二进制)
    file.writelines(seq)    #写入多行，向文件中写入一个字符串列表，注意，要自己加入每行的换行符
    file.flush()    #刷新文件内部缓冲,直接把内部缓冲区的数据立刻写入文件, 而不是被动的等待输出缓冲区写入.

## 文件修改 ##

import os
    read_f=open('b.txt','r')
    write_f=open('.b.txt.swap','w')
    for line in read_f.readlines():
        if line.startswith('1111'):
            line='2222222222\n'
        write_f.write(line)
    read_f.close()
    write_f.close()
    os.remove('b.txt')
    os.rename('.b.txt.swap','b.txt')

上下文管理with语句

当你做文件处理，你需要获取一个文件句柄，从文件中读取数据，然后关闭文件句柄。
    
    正常情况下，代码如下：
    
    file = open("/tmp/foo.txt")
    data = file.read()
    file.close()
    这里有两个问题。一是可能忘记关闭文件句柄；二是文件读取数据发生异常，没有进行任何处理。
    
    然而with可以很好的处理上下文环境产生的异常。下面是with版本的代码：
    
    with open("/tmp /foo.txt") as file:
        data = file.read()
    with的基本思想是with所求值的对象必须有一个__enter__()方法，一个__exit__()方法。紧跟with后面的语句被求值后，返回对象的__enter__()方法被调用，这个方法的返回值将被赋值给as后面的变量。当with后面的代码块全部被执行完之后，将调用前面返回对象的__exit__()方法。

模拟 tail -f access.log

#!/usr/bin/env python
    # -*- coding:utf-8 -*-
    
    # tail -f access.log
    import time
    with open('access.log','r',encoding='utf-8') as f:
        f.seek(0,2)
        while True:
            line=f.readline().strip()
            if line:
                print('新增一行日志',line)
            time.sleep(0.5)

## read(),readline(),readlines()的区别 ##

假设a.txt的内容如下所示：
    123 
    Hello
    Welcome
    What is the fuck... 
    
    一、read([size])方法
     
    read([size])方法从文件当前位置起读取size个字节，若无参数size，
    则表示读取至文件结束为止，它范围为字符串对象
    f = open("a.txt")
    lines = f.read()
    print(lines)
    print(type(lines))
    f.close() 
    
    输出结果：
    Hello
    Welcome
    What is the fuck...
    <type 'str'> #字符串类型 
    
    二、readline()方法
     
    从字面意思可以看出，该方法每次读出一行内容，所以，读取时占用内存小，比较适合大文件，该方法返回一个字符串对象。
     
    f = open("a.txt")
    line = f.readline()
    print(type(line))
    while line: 
        print line, 
        line = f.readline()
    f.close() 
    
    输出结果：
    
    <type 'str'>
    Hello
    Welcome
    What is the fuck... 
    
    三、readlines()方法读取整个文件所有行，保存在一个列表(list)变量中，每行作为一个元素，但读取大文件会比较占内存。
     
    f = open("a.txt")
    lines = f.readlines()
    print(type(lines))
    for line in lines: 
        print (line)
        f.close() 
    
    输出结果：
    <type 'list'>
    Hello
    Welcome
    What is the fuck... 
    
    四、linecache模块
     
    当然，有特殊需求还可以用linecache模块，比如你要输出某个文件的第n行：
     
    # 输出第2行
    text = linecache.getline(‘a.txt',2)
    print text, 
    
    对于大文件效率还可以。
    """

[20200211205907879.png]: https://img-blog.csdnimg.cn/20200211205907879.png
[20200211212839790.png]: https://img-blog.csdnimg.cn/20200211212839790.png
[20200212091704523.png]: https://img-blog.csdnimg.cn/20200212091704523.png
[20200212092303233.png]: https://img-blog.csdnimg.cn/20200212092303233.png
[https_diveintopython3.net_strings.html]: https://diveintopython3.net/strings.html