七、编码、文件。（编码7开头是哪里的）

七、编码、文件。（编码7开头是哪里的）

一、编码

1.1：内存和硬盘

CPU： 从内存中读取程序的指令，然后解码并运行程序；硬盘： 永久保存数据；内存： 临时存储数据，任何程序运行都需事先加载到内存；应用软件： 调用操作系统提供的接口；间接地使用计算机硬件，加载到内存中；操作系统： 控制硬件，提供系统调用接口，加载到内存中；

1.2：文本编辑器存取文件的原理

1.3：python解释器执行py文件的原理

例如python  、test.py：

第一阶段：python解释器启动，此时就相当于启动了一个文本编辑器；

第二阶段：python解释器相当于文本编辑器，去打开test.py，从硬盘上将test.py的文件内容读入到内存中；

第三阶段：python解释器执行刚刚加载到内存中的test.py的代码（在该阶段，即执行时，才会识别python的语法，执行到字符串时，会开辟内存空间存放字符串）；

python解释器与文本编辑器相同点：python解释器是解释执行文件内容的，因而python解释器具备读py文件的功能，这一点与文本编辑器一样；

python解释器与文本编辑器不同点：文本编辑器将文件内容读入内存后，是为了显示/编辑，而python解释器将文件内容读入内存后，是为了执行（识别python的语法）；

1.3：编码解释

计算机想要工作必须通电，高低电平（高电平即二进制数1，低电平即二进制数0），计算机只认识数字，让计算机读懂人类的字符就必须经过：字符---------（翻译过程）-------------数字，实际就是一个字符如何对应一个特定数字的标准，这个标准称之为字符编码。

1.一个python文件中的内容是由一堆字符组成的（python文件未执行时）

2.python中的数据类型字符串是由一串字符组成的（python文件执行时）

1.5：编码的发展史

阶段一：

现代计算机起源于美国，最早诞生也是基于英文考虑的ASCII；ASCII:一个Bytes代表一个字符（英文字符/键盘上的所有其他字符），1Bytes=8bit，8bit可以表示0-2**8-1种变化，即可以表示256个字符；ASCII最初只用了后七位，127个数字，已经完全能够代表键盘上所有的字符了（英文字符/键盘的所有其他字符）；后来为了将拉丁文也编码进了ASCII表，将最高位也占用了；

阶段二:

为了满足中文，中国人定制了GBK；GBK:2Bytes代表一个字符，为了满足其他国家，各个国家纷纷定制了自己的编码，日本把日文编到Shift_JIS里，韩国把韩文编到Euc-kr里；

阶段三：

各国有各国的标准，就会不可避免地出现冲突，结果就是，在多语言混合的文本中，显示出来会有乱码；于是产生了unicode，　统一用2Bytes代表一个字符，　2**16-1=65535，可代表6万多个字符，因而兼容万国语言；但对于通篇都是英文的文本来说，这种编码方式无疑是多了一倍的存储空间（二进制最终都是以电或者磁的方式存储到存储介质中的）；于是产生了UTF-8，对英文字符只用1Bytes表示，对中文字符用3Bytes；

阶段四：

unicode：简单粗暴，多有的字符都是2Bytes,优点是字符--数字的转换速度快；缺点是占用空间大。utf-8:精准，可变长，优点是节省空间；缺点是转换速度慢，因为每次转换都需要计算出需要多长Bytes才能够准确表示。内存中使用的编码是unicode，用空间换时间（程序都需要加载到内存才能运行，因而内存应该是越快越好）硬盘中或网络传输用utf-8，保证数据传输的稳定性。

1： 所有程序，最终都要加载到内存，程序保存到硬盘不同的国家用不同的编码格式，但是到内存中我们为了兼容万国（计算机可以运行任何国家的程序原因在于此），统一且固定使用unicode，2： 这就是为何内存固定用unicode的原因，你可能会说兼容万国我可以用utf－8啊，可以，完全可以正常工作，之所以不用肯定是unicode比utf－8更高效啊（uicode固定用2个字节编码3：utf－8则需要计算），但是unicode更浪费空间，没错，这就是用空间换时间的一种做法，而存放到硬盘，或者网络传输，都需要把unicode转成utf－8，4： 因为数据的传输，追求的是稳定，高效，数据量越小数据传输就越靠谱，于是都转成utf－8格式的，而不是unicode。

View Code

1.6：字符编码转换

文件从内存刷到硬盘的操作简称存文件文件从硬盘读到内存的操作简称读文件乱码：存文件时就已经乱码 或者 存文件时不乱码而读文件时乱码

ascii：数字，字母 特殊字符。 字节：8位表示一个字节。 字符：是你看到的内容的最小组成单位。 abc ： a 一个字符。 中国：中 一个字符。 a : 0000 1011unicode: 万国码 起初： 　　　　a : 0000 1011 0000 1011 中: 0000 1011 0000 1111 升级： 　　　　a : 0000 1011 0000 1011 0000 1011 0000 1011 中: 0000 1011 0000 1111 0000 1011 0000 1011utf-8：最少用8位表示一个字符。 a: 0000 1011 欧洲： 0000 1011 0000 1011 亚洲中：0000 1011 0000 1011 0000 1011gbk：国标 a: 0000 1011 中文：0000 1011 0000 1011 两个字节。

不同编码之间的二进制是不能互相识别的。对于文件的存储，及传输不能是unicode的编码。

python3x int bool bytes:内部编码方式：(非unicode，utf-8,gbk.gb2312...) str : 内部编码方式unicode list dict tuplebytes:内部编码方式：(非unicode，utf-8,gbk.gb2312...)str : 内部编码方式unicode

1.6.1：对于字母

str：

表现形式：s1 = 'alex'内部编码：unicode

bytes：

表现形式：s2 = b'alex'内部编码：非unicode

1.6.2：对于中文

str：

表现形式：s1 = '中国'内部编码：unicode

bytes：

表现形式：b1 = b'\xe4\xb8\xad\xe5\x9b\xbd'内部编码：非unicode

1.6.3： 例子

unicode和utf-8之间的转换：

s1 = 'alex'#将alex从unicode编码转换为utf-8b1 = s1.encode('utf-8')print(b1)#输出结果：b'alex'

s1 = 'alex'b1 = b'alex'print(s1.capitalize())print(b1.capitalize())#输出结果：Alexb'Alex'

s2 = '中国'b2 = s2.encode('utf-8')print(b2)#输出结果：b'\xe4\xb8\xad\xe5\x9b\xbd'

unicode----->utf-8------>unicode

s1 = 'alex'# str ---> bytes encode 编码b1 = s1.encode('utf-8')print(b1)#bytes---> str decode 解码s2 = b1.decode('utf-8')print(s2)#输出结果：b'alex'alex

Unicode、gbk、utf-8之间的转换：

s1 = 'alex'b2 = s1.encode('gbk')s3 = b2.decode('gbk')print(b2)print(s3)#输出结果：b'alex'alex

s1 = 'alex'b1 = s1.encode('utf-8')s2 = b1.decode('gbk')print(s2)#输出结果：alex

utf-8、gbk之间的转换

s4 = '中国'b4 = s4.encode('utf-8') # utf-8 bytesprint(b4)b6 = b4.decode('utf-8').encode('gbk')print(b6)#输出结果：b'\xe4\xb8\xad\xe5\x9b\xbd' #bytes类型的utf-8一个中文3个字节b'\xd6\xd0\xb9\xfa' #bytes类型的gbk一个中文2个字节

二、文件

2.1：文件处理流程

f1 文件句柄,f,file,file_hander,f_h....open()调用的内置函数，内置函数调用的系统内部的open，一切对文件进行的操作都是基于文件句柄f1.

执行流程： 1，打开文件，产生文件句柄。

f=open('a.txt','r',encoding='utf-8') #默认打开模式就为r

2，对文件句柄进行操作。

data=f.read()

3，关闭文件句柄。

f.close()

注意1：

打开一个文件包含两部分资源：操作系统级打开的文件+应用程序的变量。在操作完毕一个文件时，必须把与该文件的这两部分资源一个不落地回收，回收方法为：1、f.close() #回收操作系统级打开的文件2、del f #回收应用程序级的变量其中del f一定要发生在f.close()之后，否则就会导致操作系统打开的文件还没有关闭，白白占用资源。而python自动的垃圾回收机制决定了我们无需考虑del f，这就要求我们，在操作完毕文件后，一定要记住f.close()如果实在记不住f.close(),可以使用with关键字来帮我们管理上下文：with open('a.txt','w') as f: pass with open('a.txt','r') as read_f,open('b.txt','w') as write_f: data=read_f.read() write_f.write(data)

注意2：

f=open(...)是由操作系统打开文件，那么如果我们没有为open指定编码，那么打开文件的默认编码很明显是操作系统说了算了，操作系统会用自己的默认编码去打开文件，在windows下是gbk，在linux下是utf-8。若要保证不乱码，文件以什么方式存的，就要以什么方式打开。f=open('a.txt','r',encoding='utf-8')

2.2：文件打开模式

打开文件（open 函数）：

open(file,[option])file 是要打开的文件名option 是可选择的参数，常见有 mode encoding

打开模式：

r （只读模式）：文件不存在时会报错。w （写入模式）：文件存在会清空之前的内容，文件不存在则会新建文件。x （写入模式）：文件存在会报错，文件不存在则会新建文件。a （追加写入模式）：不清空之前的文件内容，直接将写入的内容添加到后面。b （以二进制模式读写文件）：wb,rb,ab。 + 可读写模式，r+,w+,x+,a+,这几种模式还遵循了r,w,x,a的基本原则。

2.2.1：文本文件

文件句柄=open('文件路径'，‘模式’)；

打开文件时，需要指定文件路径和以什么方式打开文件；

打开文件的模式有：

r ：只读模式【默认模式，文件必须存在，不存在则抛出异常】w：只写模式【不可读；不存在则创建；存在则清空内容】x： 只写模式【不可读；不存在则创建，存在则报错】a： 追加模式【可读；   不存在则创建；存在则只追加内容】

#只读模式f=open(r'c.txt',encoding='utf-8')print('====>1',f.read())print('====>2',f.read())print(f.readable())print(f.readline(),end='')print(f.readline())print("="*20)print(f.read())print(f.readlines())f.close()#写模式：文件不存在则创建，文件存在则覆盖原有的f=open("new.py",'w',encoding='utf-8')f.write('1111111111\n')f.writelines(['2222\n','2222548\n','978646\n'])f.close()# 追加模式：文件不存在则创建，文件存在不会覆盖，写内容是追加的方式写f=open('new.py','a',encoding='utf-8')f.write('nishishui\n')f.writelines(['aa\n','bb\n'])f.close()

2.2.2：非文本文件

对于非文本文件，只能使用b模式，"b"表示以字节的方式操作（而所有文件也都是以字节的形式存储的，使用这种模式无需考虑文本文件的字符编码、图片文件的jgp格式、视频文件的avi格式）。

rb 或 r+bwb 或 w+bxb 或 w+bab 或 a+b

注：以b方式打开时，读取到的内容是字节类型，写入时也需要提供字节类型，不能指定编码。

利用b模式，编写一个cp工具，要求：既可以拷贝文本又可以拷贝视频，图片等文件。# b模式f=open('1.jpg','rb')data=f.read()# print(data)f=open('2.jpg','wb')f.write(data)print(data)

2.2.3：‘+’模式

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

r+， 读写【可读，可写】w+，写读【可读，可写】x+ ，写读【可读，可写】a+， 写读【可读，可写】

2.2.4：以bytes类型操作的读写，写读，写读模式

r+b， 读写【可读，可写】w+b，写读【可写，可读】a+b， 写读【可写，可读】

2.3：文件的读

2.3.1：read() 全读出来

f.read(size) 读取文件的内容，将文件的内容以字符串形式返回。size 是可选的数值，指定字符串长度，如果没有指定size或者指定为负数， 就会读取并返回整个文件。当文件大小为当前机器内存两倍时就会产生问题， 反之就尽可能大的size读取和返回数据，如果到了文件末尾，会返回空字符串。

f1 = open('log1', encoding='utf-8')content = f1.read()print(content)f1.close()f1 = open('1.jpg', mode='rb')print(f1.read())f1.close()

2.3.2：read(n) 读一部分

f1 = open('log1', encoding='utf-8')content = f1.read(3)print(content)f1.close()#r 模式 read(n) n 按照字符读取。#rb 模式 read(n) n 按照字节读取。f1 = open('log1', mode='rb')print(f1.read(3).decode('utf-8'))f1.close()

2.3.4：readline() 按行读取

f.readline() 从文件中读取单独一行，字符串结尾会自动加上一个换行符 \n，只有当文件最后没有以换行符结尾时，这一操作才会被忽略， 这样返回值就不会有混淆。如果返回空字符串，表示到达率文件末尾， 如果是空行，就会描述为\n,一个只有换行符的字符串。

f1 = open('log1', encoding='utf-8')print(f1.readline())print(f1.readline())print(f1.readline())f1.close()

2.3.5：readlines()

f.readlines() 一次读取所有，返回一个列表，列表的元素为文件行的内容。可以通过列表索引的方式将文件的每一行的内容输出。可以通过 for 循环迭代输出每一行的信息。

f1 = open('log1', encoding='utf-8')print(f1.readlines())f1.close()

2.3.6：for循环读取

f1 = open('log1', encoding='utf-8')for line in f1: print(line)f1.close()

2.3.7：r+读写

f1 = open('log1', encoding='utf-8', mode='r+')# print(f1.read())# f1.write('666')f1.write('a')print(f1.read())f1.close()

2.4：文件的写

f.write() 将要写入的内容以字符串的形式通过 write 方法写入文件中。f.writelines() 括号里必须是由字符串元素组成的序列。没有文件，新建文件写入内容有原文件，先清空内容，在写入新内容。

2.4.1：文本文件写

f1 = open('log2', encoding='utf-8', mode='w')f1.write('桃白白fdksagdfsa')f1.close()

2.4.2：图片的读取及写入

f1 = open('1.jpg', mode='rb')content = f1.read()f2 = open('2.jpg', mode='wb')f2.write(content)f1.close()f2.close()

2.4.3：w+ 先写后读

f1 = open('log2', encoding='utf-8', mode='w+')f1.write('两款发动机了')f1.seek(0)print(f1.read())f1.close()

2.5：文件的追加

a 没有文件，新建文件写入内容f1 = open('log3', encoding='utf-8', mode='a')# f1.write('alex 666')f1.write('\nalex 666')f1.close()a+f1 = open('log3', encoding='utf-8', mode='a+')f1.write('python22期')f1.seek(0)print(f1.read())f1.close()

2.6：上下文管理

不用主动关闭文件句柄：

with open('a.txt','w') as f: pass

with open('a.txt','r') as read_f,open('b.txt','w') as write_f: data=read_f.read() write_f.write(data)

with open('log1', encoding='utf-8') as f1,\ open('log2', encoding='utf-8', mode='w') as f2: content = f1.read() f2.write(content)

with open('log1', encoding='utf-8') as f1: print(f1.read()) f1.close() pass with open('log1', encoding='utf-8',mode='w') as f2: f2.write('666')

2.6：文件的修改

2.6.1：修改流程

以读模式打开原文件。以写的模式打开一个新文件。将原文件读出按照要求修改将修改后的内容写入新文件。删除原文件。将新文件重命名原文件。

import oswith open('file', encoding='utf-8') as f1,\ open('file.bak', encoding='utf-8', mode='w') as f2: old_content = f1.read() new_content = old_content.replace('alex', 'SB') f2.write(new_content)os.remove('file')os.rename('file.bak', 'file')

升级版：

# import os# with open('file', encoding='utf-8') as f1,\# open('file.bak', encoding='utf-8', mode='w') as f2:# for line in f1:# new_line = line.replace('SB','alex')# f2.write(new_line)## os.remove('file')# os.rename('file.bak', 'file')with open('log1', encoding='utf-8', mode='w') as f1: f1.write('111') f1.write('666') f1.write('333') f1.write('222')

文件的数据是存放于硬盘上的，因而只存在覆盖、不存在修改这么一说，我们平时看到的修改文件，都是模拟出来的效果，具体的说有两种实现方式：

2.6.2：修改方式一：

将硬盘存放的该文件的内容全部加载到内存，在内存中是可以修改的，修改完毕后，再由内存覆盖到硬盘（word，vim，nodpad++等编辑器）。

import os #调用系统模块with open('a.txt') as read_f,open('.a.txt.swap','w') as write_f:data=read_f.read() #全部读入内存,如果文件很大,会很卡data=data.replace('alex','SB') #在内存中完成修改write_f.write(data) #一次性写入新文件os.remove('a.txt') #删除原文件os.rename('.a.txt.swap','a.txt') #将新建的文件重命名为原文件

2.6.3：修改方式二：

将硬盘存放的该文件的内容一行一行地读入内存，修改完毕就写入新文件，最后用新文件覆盖源文件。

import oswith open('a.txt') as read_f,open('.a.txt.swap','w') as write_f:for line in read_f:line=line.replace('alex','SB')write_f.write(line)os.remove('a.txt')os.rename('.a.txt.swap','a.txt')

2.7：文件的光标移动

2.7.1：read

read(3)：

1. 文件打开方式为文本模式时，代表读取3个字符

2. 文件打开方式为b模式时，代表读取3个字节

2.7.2：seek、tell、truncate

其余的文件内光标移动都是以字节为单位如：seek，tell，truncate。

注意：

seek有三种移动方式0，1，2，其中1和2必须在b模式下进行，但无论哪种模式，都是以bytes为单位移动的，seek控制光标的移动，是以文件开头作为参照的。tell当前光标的位置。truncate是截断文件，截断必须是写模式，但是不能用w或w+等方式打开，因为那样直接清空文件了，所以truncate要在r+或a或a+等模式下测试效果。

# f1 = open('log2', encoding='utf-8')# f1.read()# print(f1.tell())# print(f1.seek(0))# print(f1.seek(0,2))# f1.seek(12) # 任意调整# f1.seek(0,2) #光标调整到最后# f1.seek(0) #光标调整到开头# print(f1.tell()) # 告诉光标的位置# f1.close()# f1 = open('log3', encoding='utf-8', mode='a+')# f1.truncate(3) # 按照字节对原文件进行截取 必须在a 或 a+ 模式# f1.close()

import timewith open('test.txt','rb') as f: f.seek(0,2) while True: line=f.readline() if line: print(line.decode('utf-8')) else: time.sleep(0.2)

2.8：文件的保存和关闭

f.flush() 在读写模式下，当写完的数据想要读取出来时， 要先将缓存区的内容保存到文件当中。f.close() 关闭文件。对一个已经关闭的文件进行操作会报错

flush原理：

文件操作是通过软件将文件从硬盘读到内存；写入文件的操作也都是存入内存缓冲区buffer（内存速度快于硬盘，如果写入文件的数据都从内存刷到硬盘，内存与硬盘的速度延迟会被无限放大，效率变低，所以要刷到硬盘的数据我们统一往内存的一小块空间即buffer中放，一段时间后操作系统会将buffer中数据一次性刷到硬盘）；flush即，强制将写入的数据刷到硬盘；

滚动条：

import sys,timefor i in range(10): sys.stdout.write('#') sys.stdout.flush() time.sleep(0.2)

2.9：file对象常用函数

file 对象使用 open 函数来创建，下表列出了 file 对象常用的函数：

2.10：文件所有操作方法

Python 2.x

class file(object) def close(self): # real signature unknown; restored from __doc__ 关闭文件 """ close() -> None or (perhaps) an integer. Close the file. Sets data attribute .closed to True. A closed file cannot be used for further I/O operations. close() may be called more than once without error. Some kinds of file objects (for example, opened by popen()) may return an exit status upon closing. """ def fileno(self): # real signature unknown; restored from __doc__ 文件描述符 """ fileno() -> integer "file descriptor". This is needed for lower-level file interfaces, such os.read(). """ return 0 def flush(self): # real signature unknown; restored from __doc__ 刷新文件内部缓冲区 """ flush() -> None. Flush the internal I/O buffer. """ pass def isatty(self): # real signature unknown; restored from __doc__ 判断文件是否是同意tty设备 """ isatty() -> true or false. True if the file is connected to a tty device. """ return False def next(self): # real signature unknown; restored from __doc__ 获取下一行数据，不存在，则报错 """ x.next() -> the next value, or raise StopIteration """ pass def read(self, size=None): # real signature unknown; restored from __doc__ 读取指定字节数据 """ read([size]) -> read at most size bytes, returned as a string. If the size argument is negative or omitted, read until EOF is reached. Notice that when in non-blocking mode, less data than what was requested may be returned, even if no size parameter was given. """ pass def readinto(self): # real signature unknown; restored from __doc__ 读取到缓冲区，不要用，将被遗弃 """ readinto() -> Undocumented. Don't use this; it may go away. """ pass def readline(self, size=None): # real signature unknown; restored from __doc__ 仅读取一行数据 """ readline([size]) -> next line from the file, as a string. Retain newline. A non-negative size argument limits the maximum number of bytes to return (an incomplete line may be returned then). Return an empty string at EOF. """ pass def readlines(self, size=None): # real signature unknown; restored from __doc__ 读取所有数据，并根据换行保存值列表 """ readlines([size]) -> list of strings, each a line from the file. Call readline() repeatedly and return a list of the lines so read. The optional size argument, if given, is an approximate bound on the total number of bytes in the lines returned. """ return [] def seek(self, offset, whence=None): # real signature unknown; restored from __doc__ 指定文件中指针位置 """ seek(offset[, whence]) -> None. Move to new file position. Argument offset is a byte count. Optional argument whence defaults to(offset from start of file, offset should be >= 0); other values are 1 (move relative to current position, positive or negative), and 2 (move relative to end of file, usually negative, although many platforms allow seeking beyond the end of a file). If the file is opened in text mode, only offsets returned by tell() are legal. Use of other offsets causes undefined behavior. Note that not all file objects are seekable. """ pass def tell(self): # real signature unknown; restored from __doc__ 获取当前指针位置 """ tell() -> current file position, an integer (may be a long integer). """ pass def truncate(self, size=None): # real signature unknown; restored from __doc__ 截断数据，仅保留指定之前数据 """ truncate([size]) -> None. Truncate the file to at most size bytes. Size defaults to the current file position, as returned by tell(). """ pass def write(self, p_str): # real signature unknown; restored from __doc__ 写内容 """ write(str) -> None. Write string str to file. Note that due to buffering, flush() or close() may be needed before the file on disk reflects the data written. """ pass def writelines(self, sequence_of_strings): # real signature unknown; restored from __doc__ 将一个字符串列表写入文件 """ writelines(sequence_of_strings) -> None. Write the strings to the file. Note that newlines are not added. The sequence can be any iterable object producing strings. This is equivalent to calling write() for each string. """ pass def xreadlines(self): # real signature unknown; restored from __doc__ 可用于逐行读取文件，非全部 """ xreadlines() -> returns self. For backward compatibility. File objects now include the performance optimizations previously implemented in the xreadlines module. """ pass

View Code

Python 3.x

class TextIOWrapper(_TextIOBase): """ Character and line based layer over a BufferedIOBase object, buffer. encoding gives the name of the encoding that the stream will be decoded or encoded with. It defaults to locale.getpreferredencoding(False). errors determines the strictness of encoding and decoding (see help(codecs.Codec) or the documentation for codecs.register) and defaults to "strict". newline controls how line endings are handled. 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. If line_buffering is True, a call to flush is implied when a call to write contains a newline character. """ def close(self, *args, **kwargs): # real signature unknown 关闭文件 pass def fileno(self, *args, **kwargs): # real signature unknown 文件描述符 pass def flush(self, *args, **kwargs): # real signature unknown 刷新文件内部缓冲区 pass def isatty(self, *args, **kwargs): # real signature unknown 判断文件是否是同意tty设备 pass def read(self, *args, **kwargs): # real signature unknown 读取指定字节数据 pass def readable(self, *args, **kwargs): # real signature unknown 是否可读 pass def readline(self, *args, **kwargs): # real signature unknown 仅读取一行数据 pass def seek(self, *args, **kwargs): # real signature unknown 指定文件中指针位置 pass def seekable(self, *args, **kwargs): # real signature unknown 指针是否可操作 pass def tell(self, *args, **kwargs): # real signature unknown 获取指针位置 pass def truncate(self, *args, **kwargs): # real signature unknown 截断数据，仅保留指定之前数据 pass def writable(self, *args, **kwargs): # real signature unknown 是否可写 pass def write(self, *args, **kwargs): # real signature unknown 写内容 pass def __getstate__(self, *args, **kwargs): # real signature unknown pass def __init__(self, *args, **kwargs): # real signature unknown pass @staticmethod # known case of __new__ def __new__(*args, **kwargs): # real signature unknown """ Create and return a new object. See help(type) for accurate signature. """ pass def __next__(self, *args, **kwargs): # real signature unknown """ Implement next(self). """ pass def __repr__(self, *args, **kwargs): # real signature unknown """ Return repr(self). """ pass buffer = property(lambda self: object(), lambda self, v: None, lambda self: None) # default closed = property(lambda self: object(), lambda self, v: None, lambda self: None) # default encoding = property(lambda self: object(), lambda self, v: None, lambda self: None) # default errors = property(lambda self: object(), lambda self, v: None, lambda self: None) # default line_buffering = property(lambda self: object(), lambda self, v: None, lambda self: None) # default name = property(lambda self: object(), lambda self, v: None, lambda self: None) # default newlines = property(lambda self: object(), lambda self, v: None, lambda self: None) # default _CHUNK_SIZE = property(lambda self: object(), lambda self, v: None, lambda self: None) # default _finalizing = property(lambda self: object(), lambda self, v: None, lambda self: None) # default

View Code

2.11：Python文件练习

2.11.1

#!/usr/bin/env python# -*- coding:utf-8 -*-#打开文件open()f = open('test.txt','r+')#或者with open() 这种方法操作完成后，会自动关闭不需要close()with open('test.txt','r') as f: f.read()#关闭文件f = open('test.txt','r+',encoding='utf-8')ret = f.read()print(ret)f.close()#读取文件内容(可指定每次读取字字符)f = open('test.txt','r+',encoding='utf-8')ret = f.read(8)print(ret)#读取数据（可指定读取字符数），存为list显示f = open('test.txt','r+',encoding='utf-8')ret = f.readlines()print(ret)f.close()#读取一行数据f = open('test.txt','r+',encoding='utf-8')ret = f.readline()print(ret)f.close()#写入文件write()参数是字符串f = open('test.txt','a+',encoding='utf-8')f.write("abc")ret = f.read()print(ret)f.close()#写入文件，writelines()参数是序列，比如列表，它会迭代帮你写入文件f = open('test.txt','a+',encoding='utf-8')f.writelines(["aa","bb","cc"])ret = f.read()print(ret)f.close()#判断文件是否是统一tty设备f = open('test.txt','r+',encoding='utf-8')ret = f.isatty()print(ret) #Falsef.close()#判断是否可读（不可读则报错" No such file or directory: "）f = open('test.txt','r+',encoding='utf-8')ret = f.readable()print(ret) #Truef.close()#指定文件中指针的位置f = open('test.txt','r+',encoding='utf-8')ret = f.read(8) #先读取8个字符print(ret)f.seek(0) #然后把指针移动到文件开头处ret = f.read(8) #在重新读取print(ret)f.close()#获取指针位置f = open('test.txt','r+',encoding='utf-8')ret = f.read(8) #先读取8个字符print("pointer position：%s"%f.tell()) #查看当前指针位置print(ret)f.seek(0) #重置指定到启始位print("pointer position：%s"%f.tell()) #在查看指针位置f.close()#截断文件数据，仅保留指定之前数据（指定字节数）f = open('test.txt','r+',encoding='utf-8')f.truncate(8) #文件只保留前8个字节数据，文件后面数据的全部删除ret = f.read()print(ret)f.close()#文件描述符f.fileno()#刷新文件内部缓冲区f.flush()

2.11.2

# 增加：

1.用户输入以下字典类型的字符串(注意字串必须要用双引号""，因为json不能识别单引号)

"u_input = input({"backend": "test.aa.com", "record": {"server": "100.1.7.213", "weight": 20, "maxconn": 30}})"

2.通过json.loads()模块把字符串转换成字典

3.通过格式化配置文件，在需要添加的位置设置value的值

# 删除：

1.选择用户输入需要删除的字符串,用strip()方法去除掉特殊符号

2.按行读取配置文件，对比并排除需要删除的字符串，把排除后的数据存入列表中

3.用"w"模式打开文件（把原来文件的内容清除），循环读取列表内容，并写入文件

配置文件：(文件名:config.txt)---------------------------global log 127.0.0.1 local2 daemon maxconn 256 log 127.0.0.1 local2 infodefaults log global mode timeout connect 5000ms timeout client 50000ms timeout server 50000ms option dontlognulllisten stats :8888 stats enable stats uri /admin stats auth admin:1234frontend aa.org bind 0.0.0.0:80 option option option forwardfor log global acl hdr_reg(host) -i aa.com use_backend aa.com if bb.com server 100.1.7.9 100.1.7.9 weight 20 maxconn 3000 # 格式化显示 # server": "{0}","weight": {1},"maxconn": {2}backend buy.cc.com server 100.1.7.90 100.1.7.90 weight 20 maxconn 3000---------------------------

import jsondef add(): ''' 添加一条数据 :return: ''' # {"backend": "test.aa.com", "record": {"server": "100.1.7.213", "weight": 20, "maxconn": 30}} u_input = input("Please input add data:") dic = json.loads(u_input) server = dic["record"]["server"] weight = dic["record"]["weight"] maxconn = dic["record"]["maxconn"] with open("config.txt", 'r', encoding='utf-8') as f: file = f.read() result = file.format(server, weight, maxconn) print(file) print("=================" * 4) with open("config.txt", 'w', encoding='utf-8') as f: f.write(result) print(result)def dele(): ''' 删除一条数据 :return: ''' # u_input = input("Please input del data:") add_list = [] with open('config.txt', 'r')as f: print("config files:") for item in f.readlines(): print("\n%s" % item.strip("\n")) file = input("\n\n请输入需要删除的行数据:") f.seek(0) for item in f.readlines(): if item.strip() != file.strip(): add_list.append(item) with open('config.txt', 'w', encoding='utf-8') as f: f.writelines(add_list) print("\n\n删除行:'%s'\n完成！！！" % file.strip())if __name__ == '__main__': num = int(input("请选择数字：\n【1】添加一条数据\n【2】删除一条数据\n")) if num == 1: add() elif num == 2: dele()

2.11.3

(1) 在任意位置创建一个.py文件，如'D:/编程练习/python练习/Week2_02.py'

(2) 在D盘下创建一个文件Blowing in the wind.txt，即‘D:\Blowing in the wind.txt’

其内容是：

How many roads must a man walk down

Before they call him a man

How many seas must a white dove sail

Before she sleeps in the sand

How many times must the cannon balls fly

Before they're forever banned

The answer my friend is blowing in the wind

The answer is blowing in the wind

(3) 在文件头部插入歌名“Blowin’ in the wind”

(4) 在歌名后插入歌手名“Bob Dylan”

(5) 在文件末尾加上字符串“1962 by Warner Bros. Inc.”

(6) 在屏幕上打印文件内容，最好加上自己的设计

(7) 以上每一个要求均作为一个独立的步骤进行，即每次都重新打开并操作文件

程序代码如下：

import os#Python的os模块提供了执行文件和目录处理操作的函数，例如重命名和删除文件。os.chdir('D:\\') #更改目录 #-------------------------------------------------------------------------#创建一个文件，将歌词写入f1=open(r'Blowing in the wind.txt','w')f1.write('How many roads must a man walk down \n')f1.write('Before they call him a man \n')f1.write('How many seas must a white dove sail \n')f1.write('Before she sleeps in the sand \n')f1.write('How many times must the cannon balls fly \n')f1.write('Before they\'re forever banned \n')f1.write('The answer my friend is blowing in the wind \n')f1.write('The answer is blowing in the wind\n')f1.close()#文件使用后记得关闭#--------------------------------------------------------------------------#在文件头部插入歌曲名f2=open(r'Blowing in the wind.txt','r+')#mode参数不能用'w+',这会清空原内容lyrics =f2.readlines()lyrics.insert(0,'Blowin\'in the wind\n')#在第一行添加歌曲名f2.seek(0,0)#将文件指针移动到文件开头处f2.writelines(lyrics)f2.close()#这是一种错误的写法，将歌词的第一行抹去了一部分#f2=open(r'Blowing in the wind.txt','r+')#f2.seek(0,0)#将文件指针移动到文件开头处#f2.write('Blowin’ in the wind\n')#f2.close()#--------------------------------------------------------------------------#在歌名后插入歌手名（实现同上一步）f3=open(r'Blowing in the wind.txt','r+')#mode参数不能用'w+',这会清空原内容lyrics =f3.readlines()lyrics.insert(1,'——Bob Dylan\n')#在第一行添加歌手名f3.seek(0,0)#将文件指针移动到文件开头处f3.writelines(lyrics)f3.close()#--------------------------------------------------------------------------#在文件末尾加上字符串“1962 by Warner Bros. Inc.” f4=open(r'Blowing in the wind.txt','a')#mode参数选择'a',代表追加模式.f4.write('1962 by Warner Bros. Inc.')#追加模式下，可以直接向文件末尾write内容f4.close()#--------------------------------------------------------------------------#在屏幕上打印文件内容(最好加一些自己的格式设计)f5=open(r'Blowing in the wind.txt','r')article =f5.readlines()#读取文件内容#按照自己的方式显示for i in range(0,len(article)): if 1 print('\t'+article[i]) else: print('\t\t'+article[i])f5.close()

作者：HaydenGuo

每一个前十年都想不到后十年我会演变成何等模样，可知人生无常，没有什么规律，没有什么必然。

只要我还对新鲜的知识、品格的改进、情感的扩张、有胃口，这日子就是值得度过的。

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。