文件处理

标签：序列类型   操作   res   三元   关系   gbk   修改   data   open   

1.文件处理流程

a.打开文件，得到文件句柄并赋值给一个变量

b.通过句柄对文件进行操作

c.关闭文件

f = open(‘123‘, encoding=‘utf8‘) #pycharm默认将文件以utf8格式编码到硬盘上，虽然python3的编码是utf8，
                                 # 但open函数会去检索当前系统的编码，
                                 # 当前系统是windows,所以open打开文件时用gbk解码，open加的是文件的绝对路径
data = f.read()
print(data)
f.close()

2.文件打开模式

a.r  读操作 

f = open(‘123‘, encoding=‘utf8‘)
print(‘第1行‘, f.readline())#readline一行一行读，读的行数超出文本行数会显示空
print(‘第2行‘, f.readline(), end=‘‘)#end=‘‘可以去掉换行
print(‘第3行‘, f.readline())
print(‘第4行‘, f.readline())
print(‘第5行‘, f.readline())
print(‘第6行‘, f.readline())

f = open(‘123‘, encoding=‘utf8‘)
data = f.read()
print(‘第1行‘, f.readline())#read和readline组合，readline会得到空，因为 read是 读取全部，已经读到文件最后了

f = open(‘123‘, encoding=‘utf8‘)
data = f.readlines()
print(data)#返回值是所有行以列表形式呈现

b.w写操作

f = open(‘123‘, ‘w‘, encoding=‘utf8‘)#w模式：文件不存在，会自动新建一个新文件；文件存在，会清空掉文件内容再做操作
f.write(‘11111111\n‘)#write的参数必须是字符串
f.write(‘22222222\n‘)
f.write(‘333\n444\n555\n‘)
print(f.writable())
f.writelines([‘666\n‘, ‘777\n‘])#传入的参数需为列表
f.close()

c.a追加操作：在文件最后一个位置追加

f = open(‘123‘, ‘a‘, encoding = ‘utf8‘)
f.write(‘最后啦‘)
f.close

 d.r+可读可写

f = open(‘123‘, ‘r+‘, encoding=‘utf8‘)
data = f.read()
print(data)
f.write(‘123‘)#默认从光标起始位置覆盖

 文件无修改，文件在硬盘上以二进制形式存储，修改文件实际是覆盖操作，修改文件步骤：

通过软件打开文件（将文件的内容从硬盘加载到内存），在内存中可以修改文件内容，改完后由软件保存（将文件内容覆盖回去）

模拟文件修改过程：

src_f = open(‘123‘, ‘r‘, encoding=‘utf8‘)
data = src_f.readlines()
src_f.close

dst_f = open(‘123‘, ‘w‘, encoding=‘utf8‘)
# dst_f.writelines(data)
dst_f.write(data[0])
dst_f.close

 with +open中with表示close的意思

with open(‘a.txt‘, ‘w‘) as f:
    f.write(‘1111\n‘)

with open(‘123‘, ‘r‘, encoding=‘utf8‘) as src_f, \
        open(‘123_new‘, ‘w‘, encoding=‘utf8‘) as dst_f:
    data = src_f.read()
    dst_f.write(data)

 e.文件处理模式b模式 

f = open(‘123‘, ‘rb‘, encoding=‘utf8‘)#b的方式不能指定编码

f = open(‘123‘, ‘rb‘)
data = f.read()
print(data)#windows中的换行是\r\n，linux中的换行是\n
#字符串   encode  二进制bytes
#二进制bytes  decode  字符串
print(data.decode(‘utf8‘))
f.close

f = open(‘123‘, ‘wb‘)
f.write(bytes(‘gggg\n‘, encoding=‘utf8‘))#编码方式一bytes函数
f.write(‘啦啦‘.encode(‘utf8‘))#编码方式二encode函数

f = open(‘123‘, ‘ab‘)
f.write(bytes(‘gggg\n‘, encoding=‘utf8‘))#编码方式一bytes函数
f.write(‘啦啦‘.encode(‘utf8‘))#编码方式二encode函数

b模式可以打开不同文件类型（视频、图片、文本等），不带b模式默认以文本模式打开

b模式可以跨平台

b模式对Linux系统没有用，因为Linux默认就是以二进制处理的

f.文件操作的其他方法

closed 判断文件是否是关闭状态

f.closed #文件如果关闭则返回True

encoding 取的是文件打开的编码，跟原文件以什么编码方式存到硬盘上没有关系

f.encoding #查看使用open打开文件的编码

flush 

 f.flush() #讲文件内容从内存刷到硬盘

tell当前光标位置

 f.tell() #查看文件处理当前的光标位置

f = open(‘a.txt‘, ‘r‘, encoding=‘gbk‘)
print(f.closed)
print(f.encoding)
print(f.tell())
f.readline()
print(f.tell())

 newline读取文件中真正的换行符号

f = open(‘a.txt‘, ‘r‘, encoding=‘utf8‘, newline=‘‘)#如果不加newline，读出的换行符号为\n，这是pycharm默认处理的结果
print(f.readlines())

read方法处理文件时按字符读取，其余的文件内光标移动都是以字节为单位

seek

f.seek(3) #从开头开始算，将光标移动到第三个字节

truncate截取

 f.truncate(10) #从开头开始算，将文件只保留从0-10个字节的内容，文件必须以写方式打开，但是w和w+除外,因为它们一打开文件，内容都被清空了

 seek的三种模式：

a.0模式：从头开始seek

f=open(‘seek.txt‘, ‘r‘, encoding=‘utf8‘)
print(f.tell())#刚打开文件，文件的光标就在0的位置
f.seek(10)
print(f.tell())#seek到哪，打印就到哪
f.seek(3, 0)#默认都是从0开始seek
print(f.tell())

 b.1模式：从上次光标的位置开始seek

f=open(‘seek.txt‘, ‘rb‘)#seek0模式不需要以b的方式打开，其他模式需要以b的方式打开
print(f.tell())#刚打开文件，文件的光标就在0的位置
f.seek(10, 1)
print(f.tell())
f.seek(3, 1)
print(f.tell())

 c.2模式：从文件末尾开始seek

f=open(‘seek.txt‘, ‘rb‘)#seek0模式不需要以b的方式打开，其他模式需要以b的方式打开
print(f.tell())#刚打开文件，文件的光标就在0的位置
f.seek(-5, 2)#倒着seek，要以负数的方式显示
print(f.read())

 需求 ：读取文件最后一行 

方法1：

f = open(‘seek.txt‘, ‘rb‘)
data = f.readlines()#非常占内存
print(data[-1].decode(‘utf8‘))

 方法2：

f = open(‘seek.txt‘, ‘rb‘)
for i in f:#循环文件的推荐方式,省内存，一条一条的取，不符合就弃掉
    offs = -10 #定义偏移量
    while True:
        f.seek(offs, 2)
        data = f.readlines()
        if len(data) > 1:
            print(‘文件的最后一行是%s‘ %(data[-1].decode(‘utf8‘)))
            break
        offs*=2

3.迭代器协议和for循环工作机制

a.递归：自己调自己

b.迭代：被for循环遍历

c.迭代器协议：对象必须提供一个next方法，执行该方法要么返回迭代中的下一项，要么就引起一个StopIteration异常，以终止迭代（只能往后走不能往前退）

d.可迭代对象：实现了迭代器协议的对象（如何实现：对象内部定义一个_iter_()方法）

e.协议是一种约定，可迭代对象实现了迭代器协议，python的内部工具（for循环,sum,min,max函数）使用迭代器协议访问对象

f.for 循环的本质：循环所有对象，全都是使用迭代器协议

g.字符串、列表、元组、字典、集合、文件对象都不是可迭代对象，只不过在for循环时，调用了它们内部的_iter_（或iter()）方法，把它们变成了可迭代对象

然后for循环调用了可迭代对象的_next_方法去取值，而且for循环会捕捉StopIteration异常，以终止迭代 

x = ‘hello‘
iter_test = x.__iter__()
print(iter_test)
print(iter_test.__next__())
print(iter_test.__next__())
print(iter_test.__next__())
print(iter_test.__next__())
print(iter_test.__next__())
print(iter_test.__next__())#会报错

h. for 循环可以遍历列表，while循环也可以遍历列表

l = [1, 2, 3]
index = 0
while index < len(l):
    print(l[index])
    index += 1

i.为什么要有for循环？

序列类型字符串、元组、列表都有下标，用while循环可以遍历；但非序列类型字典、集合、文件没办法用while循环来做，for循环基于迭代器协议提供了一个统一的可以遍历所有对象的方法

s = {1, 2, 3}
iter_s = s.__iter__()
print(iter_s.__next__())

dic = {‘a‘: 1, ‘b‘: 2}
iter_d = dic.__iter__()
print(iter_d.__next__())#返回值是key值 

j.用while模拟for循环做的事情

l = [1, 2, 3, 4, 5]
iter_l = l.__iter__()
while True:
    try:
        print(iter_l.__next__())
    except StopIteration:
        print(‘迭代完成了‘)#for循环不打印这一句
        break

k.next()函数

l = [‘father‘,  ‘son‘, ‘grandson‘, ‘grandgrandson‘]#占内存方式 ：所有内容都放到内存里
iter_l = l.__iter__()#占内存方式：迭代器对象
# print(iter_l.__next__())
# print(iter_l.__next__())
# print(iter_l.__next__())
# print(iter_l.__next__())
# print(iter_l.__next__())
print(next(iter_l))#next(python内置函数)相当于调用iter_l.__next__()(数据类型内置的)

4.生成器 

a.生成器定义

可以理解为一种数据类型，这种数据类型自动实现了迭代器协议（其他数据类型需要调用自己内置的__iter__方法），所以生成器就是可迭代对象

b.生成器分类及在python中的表现形式（pyhton有两种不同的方式提供生成器）

1.生成器函数：常规函数定义，但是，使用yield语句而不是return语句返回结果。yield语句一次返回一个结果，在每个结果中间，挂起函数的状态，以便下次从它离开的地方继续执行

def test():
    yield 1
    yield 2
    yield 3
g = test()
print(g)

2.生成器表达式：

hen = (‘鸡蛋%s‘ %i for i in range(10))#生成器表达式直接实现迭代器协议，节省内存
print(hen)
print(hen.__next__())
print(next(hen))
print(hen.__next__())
print(next(hen))

c.三元表达式/三元运算

name = ‘cyx‘
res = ‘gb‘ if name == ‘cyx‘ else ‘gg‘#三元表达式
print(res)

d.列表解析

l = [‘a‘ for i in range(10)]#循环十次，依次把a放到这个列表中
print(l)

需求：用一行代码代替以下代码

egg_list = []
for i in range(10):
    egg_list.append(‘鸡蛋%s‘ %i)
print(egg_list)

l = [‘鸡蛋%s‘ %i for i in range(10)]
print(l)

l = [‘鸡蛋%s‘ %i for i in range(10) if i > 5]#列表解析里可以用三元表达式
print(l)

l = [‘鸡蛋%s‘ %i for i in range(10) if i > 5 else i]#没有四元表达式，可以有两元

列表解析的缺点：生成的就是列表，会占内存

总结：把列表解析的[]换成（）得到的就是生成器表达式

列表解析与生成器表达式都是一种便利的编程方式，只不过生成器表达式更节省内存

python不但使用迭代器协议使for循环变得更加通用，大部分内置函数也是使用迭代器协议访问对象的

print(sum(i**2 for i in range(5)))

 补充：生成器只能遍历一次

def test():
    for i in range(4):
        yield i
t = test()
for i in t:
    print(i)
t1 = (i for i in t)
print(list(t1))#生成器只能遍历一次，所以输出结果为[]

文件处理

标签：序列类型   操作   res   三元   关系   gbk   修改   data   open   

原文地址：https://www.cnblogs.com/yongpiaopiao/p/8922366.html