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  006d0020
洪 82d1
哥 660a

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

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

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

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

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

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

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

#coding:utf8s1='苑'print type(s1) # <type 'str'>
print repr(s1) #'\xe8\x8b\x91s2=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的规则解码，否则就会出现乱码或者报错的情况。

py2编码的特色：

#coding:utf8print '苑昊' #  苑昊
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 jsons='苑昊'
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

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编码，所以就方便很多了。

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

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 possibleclasses (text vs. binary, read vs. write vs. read/write,append-only, unbuffered).  The TextIO and BinaryIO subclassesbelow capture the distinctions between text vs. binary, which ispervasive in the interface; however we currently do not offer away to track the other distinctions in the type system."""__slots__ = ()@abstractpropertydef mode(self) -> str:pass@abstractpropertydef name(self) -> str:pass@abstractmethoddef close(self) -> None:"""Close the file.A closed file cannot be used for further I/O operations.  close() may becalled more than once without error."""pass@abstractmethoddef closed(self) -> bool:pass@abstractmethoddef fileno(self) -> int:""" Return the underlying file descriptor (an integer). """pass@abstractmethoddef flush(self) -> None:pass@abstractmethoddef isatty(self) -> bool:""" True if the file is connected to a TTY device. """pass@abstractmethoddef 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@abstractmethoddef readable(self) -> bool:""" True if file was opened in a read mode. """pass@abstractmethoddef readline(self, limit: int = -1) -> AnyStr:pass@abstractmethoddef readlines(self, hint: int = -1) -> List[AnyStr]:pass@abstractmethoddef 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 toSEEK_SET or 0 (offset from start of file, offset should be >= 0); other valuesare 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, althoughmany platforms allow seeking beyond the end of a file).Note that not all file objects are seekable."""pass@abstractmethoddef seekable(self) -> bool:""" True if file supports random-access. """pass@abstractmethoddef tell(self) -> int:"""Current file position.Can raise OSError for non seekable files."""pass@abstractmethoddef 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@abstractmethoddef writable(self) -> bool:""" True if file was opened in a write mode. """pass@abstractmethoddef 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@abstractmethoddef writelines(self, lines: List[AnyStr]) -> None:pass@abstractmethoddef __enter__(self) -> 'IO[AnyStr]':pass@abstractmethoddef __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和encodingfile_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, 对于大文件效率还可以。
"""

python3字符编码与文件处理终极版相关推荐

1. 数据类型、字符编码、文件处理

   阅读目录 一 引子 二 数字 三 字符串 四 列表 五 元组 六 字典 七 集合 八 数据类型总结 九 运算符 十 字符编码 十一 文件处理 十二 作业 一 引子 1 什么是数据? x=10,10是我 ...

2. Python2和python3字符编码的区别

   Python2和python3字符编码的区别 一.字符编码应用值Python 1. 执行Python程序的三个阶段 Python test.py(执行test.py的第一步,一定是先将文件内容从硬盘读 ...

3. python 字符编码处理_浅析Python 字符编码与文件处理

   Python字符编码 目前计算机内存的字符编码都是Unicode,目前国内的windows操作系统采用的是gbk. python2默认的字符编码方式是ASCII python3默认的字符编码方式是Un ...

4. Python之字符编码与文件操作

   目录 字符编码 Python2和Python3中字符串类型的差别 文件操作 文件操作的方式 文件内光标的移动 文件修改 字符编码 什么是字符编码? ''' 字符编码就是制定的一个将人类的语言的字符与二 ...

5. 字符编码与文件的基本操作

   字符编码与文件的基本操作 1 > 字符编码的实际应用 1.1 > 编码与解码含义 1.2 > 编码(encode) 1.3 > 解码(decode) 1.4 > 如何解决 ...

6. python3默认的字符编码和文件编码_Python的字符编码之三个问题

   看过很多关于Python字符编码的博客,或深或浅,总感觉有点云里雾里,今天这里我尝试用我的方式也来凑个热闹. 首先,我们要弄清楚几个问题,这个对我们后面的理解非常重要. 字节与字符 Python源代码 ...

7. python3中默认的字符编码和文件编码_python3 unicod,utf-8,gbk的编码和解码中文显示问题...

   目的: 清楚了解为什么在python3不同的编码,解码,windows,linux操作系统下,字符是否能够正确显示. 前提: 了解不同编码用不同的二级制编码和长度来表示字符. 在python3中,各种 ...

8. python可以处理任何字符编码文本_python数据类型、字符编码、文件处理

   介绍: 1.什么是数据? 例:x=10,10是我们要存储的数据 2.为何数据要分不同的类型? 数据是用来表示状态的,不同的状态用不同的类型的数据去表示 1.数据类型 1.数字(整形,长整形,浮点型,复 ...

9. Python自动化开发 - 字符编码、文件和集合

   本节内容 字符编码 文件操作 集合 一.字符编码 1.编码 计算机只能处理数字,如果要处理文本,就必须先把文本转换为数字才能处理.解决思路:数字与符号建立一对一映射,用不同数字表示不同符号. ASCI ...

最新文章

1. 【rnnoise源码分析】compute_frame_feature函数
2. linux7.4安装语言包,CentOS 7.4安装时报错最简单最直接的解决办法
3. HDU 1166(线段树)
4. 2-结构体的最后一个成员的定义-C语言中的柔性数组-
5. C语言面向对象编程（四）：面向接口编程
6. python省市区三级联动_Django Admin实现三级联动的示例代码(省市区)
7. 如何自动升级php数据库,php – 如何在现实世界中“升级”数据库？
8. BZOJ4568 [Scoi2016]幸运数字
9. [译]Flask教程--Cookie
10. fiddler手机抓包 443
11. 最近200篇文章汇总
12. The processing instruction target matching [xX][mM][lL] is not allowed
13. api质量等级_API质量等级与机油选用指引
14. 多种参数的BCH、RS码和(2,1,6)卷积码编码的MATLAB仿真实现
15. 百度海洋引擎Ocean Engine，打破“数据孤岛”的新利器
16. 全新整理：微软、谷歌、百度等公司经典面试100题[第101-160题]
17. mysql仿网易评论_Android仿抖音评论列表(加评论功能)/网易云音乐列表
18. 小红书用户画像分析_2020小红书爆品打造策略及案例分析！
19. python 音速_Python：在播放过程中更改音速
20. 俗话说别在一棵树上吊死，那为什么那么多NOSQL都喜欢在LSM树上吊死呢？

热门文章

1. 用python画耳朵_用Python画个可爱的小猪佩奇
2. Ajax需要注意的几个问题
3. 工厂管理信息系统-数据库课程设计
4. 程序员版的“鱿鱼游戏”趣图来了！
5. Android 13 来了，你不能错过的 10+ 新变化～
6. foreach循环遍历数组方法vue介绍
7. Http，Https,Html
8. AU消除人声+高质量伴奏
9. ubuntu判断是hdd sdd
10. 一周看点 | Docker创始人再创业；谷歌Fuchsia OS负责人离职；淘宝小范围内测微信支付；蒋凡卸任淘宝董事长...