一、编码 1.1：内存和硬盘 CPU： 从内存中读取程序的指令，然后解码并运行程序； 硬盘： 永久保存数据； 内存： 临时存储数据，任何程序运行都需事先加载到内存； 应用软件： 调用
一、编码
1.1：内存和硬盘
- CPU： 从内存中读取程序的指令，然后解码并运行程序；
- 硬盘： 永久保存数据；
- 内存： 临时存储数据，任何程序运行都需事先加载到内存；
- 应用软件： 调用操作系统提供的接口；间接地使用计算机硬件，加载到内存中；
- 操作系统： 控制硬件，提供系统调用接口，加载到内存中；
1.2：文本编辑器存取文件的原理
例如（nodepad++,pycharm,word等），打开编辑器就可以启动一个进程，是在内存中的，所以在编辑器编写的内容也都是存放在内存中的，断电后数据就丢失了。因而需要保存在硬盘上，点击保存按钮或快捷键，就把内存中的数据保存到了硬盘上。在这一点上，我们编写的py文件（没有执行时），跟编写的其他文件没有什么区别，都只是编写一堆字符而已。
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：编码的发展史
阶段一：
阶段二:
阶段三：
阶段四：
2： 这就是为何内存固定用unicode的原因，你可能会说兼容万国我可以用utf－8啊，可以，完全可以正常工作，之所以不用肯定是unicode比utf－8更高效啊（uicode固定用2个字节编码
3：utf－8则需要计算），但是unicode更浪费空间，没错，这就是用空间换时间的一种做法，而存放到硬盘，或者网络传输，都需要把unicode转成utf－8，
4： 因为数据的传输，追求的是稳定，高效，数据量越小数据传输就越靠谱，于是都转成utf－8格式的，而不是unicode。
View Code
1.6：字符编码转换
- 文件从内存刷到硬盘的操作简称存文件
- 文件从硬盘读到内存的操作简称读文件
- 乱码：存文件时就已经乱码 或者 存文件时不乱码而读文件时乱码
字节：8位表示一个字节。
字符：是你看到的内容的最小组成单位。
abc ： a 一个字符。
中国：中 一个字符。
a : 0000 1011
unicode: 万国码
起初：
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 1011
utf-8：最少用8位表示一个字符。
a: 0000 1011
欧洲： 0000 1011 0000 1011
亚洲中：0000 1011 0000 1011 0000 1011
gbk：国标
a: 0000 1011
中文：0000 1011 0000 1011 两个字节。
- 不同编码之间的二进制是不能互相识别的。
- 对于文件的存储，及传输不能是unicode的编码。
int
bool
bytes:内部编码方式：(非unicode，utf-8,gbk.gb2312...)
str : 内部编码方式unicode
list
dict
tuple
bytes:内部编码方式：(非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-8
b1 = s1.encode('utf-8')
print(b1)
#输出结果：
b'alex's1 = 'alex'
b1 = b'alex'
print(s1.capitalize())
print(b1.capitalize())
#输出结果：
Alex
b'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'
alexs1 = 'alex'
b1 = s1.encode('utf-8')
s2 = b1.decode('gbk')
print(s2)
#输出结果：
alex
utf-8、gbk之间的转换
s4 = '中国'b4 = s4.encode('utf-8') # utf-8 bytes
print(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') #默认打开模式就为r2，对文件句柄进行操作。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+b
- wb 或 w+b
- xb 或 w+b
- ab 或 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读取和返回数据，如果到了文件末尾，会返回空字符串。
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,一个只有换行符的字符串。
print(f1.readline())
print(f1.readline())
print(f1.readline())
f1.close()
2.3.5：readlines()
- f.readlines() 一次读取所有，返回一个列表，列表的元素为文件行的内容。
- 可以通过列表索引的方式将文件的每一行的内容输出。
- 可以通过 for 循环迭代输出每一行的信息。
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:passwith 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：修改流程
with 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.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 time
with 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原理：
滚动条：
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
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
"""
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) #False
f.close()
#判断是否可读（不可读则报错" No such file or directory: "）
f = open('test.txt','r+',encoding='utf-8')
ret = f.readable()
print(ret) #True
f.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 info
defaults
log global
mode http
timeout connect 5000ms
timeout client 50000ms
timeout server 50000ms
option dontlognull
listen stats :8888
stats enable
stats uri /admin
stats auth admin:1234
frontend aa.org
bind 0.0.0.0:80
option httplog
option httpclose
option forwardfor
log global
acl www hdr_reg(host) -i www.aa.com
use_backend www.aa.com if www
backend www.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 json
def 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
else:
print('\t\t'+article[i])
f5.close()
作者：HaydenGuo
每一个前十年都想不到后十年我会演变成何等模样，可知人生无常，没有什么规律，没有什么必然。
只要我还对新鲜的知识、品格的改进、情感的扩张、有胃口，这日子就是值得度过的。
【本文来源：韩国服务器 http://www.558idc.com/kt.html欢迎留下您的宝贵建议】