Python—文件操作

文件

长久保存信息的一种数据信息集合
常用操作
打开关闭（文件一旦打开，需要关闭操作）
读写内容
查找

##1.open函数
#
# open函数负责打开文件，带有很多参数
# 第一个参数： 必须有，文件的路径和名称
# mode：表明文件用什么方式打开
#
#     r:以只读方式打开
#     w：写方式打开，会覆盖以前的内容
#     x：创建方式打开，如文件已经存在，报错
#     a：append方式，以追加的方式对文件内容进行写入
#     b： binary方式，二进制方式写入
#     t： 文本方式打开
#     +： 可读写

#f称为文件句柄
place = "D:\\Python\\Python项目\\基础学习\\文件操作所使用的的文件夹\\test0..txt"
# f = open(place,'w')
# f.close()
#以写的方式打开文件必须得关闭
# #此案例说明，以写方式打开文件，默认是如果没有文件，则创建


##2.with 语句
#使用的技术是成为上下文管理协议的的技术（ContextManagementProtocal）
#自动判断文件使用的作用域，自动关闭不再使用的打开的文件句柄
#使用案例
# with open(place,'w') as f:
#     pass
#下面语句块对文件进行操作
#在本模块中不需要close，对文件的操作一般都需要用with操作

with open(place,'r') as f:
    #按行读取
    strline = f.readline()
    while strline:
        print(strline)
        strline = f.readline()

# list能用打开的文件作为参数，把文件内每一行内容作为一个元素
with open(place,"r") as f:
    l = list(f)
    for line in l:
        print(line)



##3.read:按字符读取文件内容
#允许输入参数决定读取几个字符，如果没有指定，就从头读到尾
#否则，从当前位置读取指定个字符
with open(place,'r') as f:
    strChar = f.read()
    print(len(strChar))
    print(strChar)



##4.seek(offset,from)
#移动文件的读取位置，也叫读取指针
# from的取值范围：
# 0：从文件头开始偏移
# 1：从文件当前位置开始偏移
# 2：从文件末尾开始偏移
# 移动的单位是字节（byte）
# 一个汉字由若干个字节构成
# 返回文件只针对当前位置

# 打开读写指针在0处， 即文件的开头
with open(place,'r') as f:
    # seek移动单位是字节
    f.seek(6,0)
    strChar = f.read()
    print(strChar)


# 关于读取文件的练习
# 打开文件，三个字符一组读出内容，然后显示在屏幕上
# 每读一次，休息一秒钟

# 让程序暂停，可以使用time下的sleep函数
import time
with open(place,'r') as f:
    strChar = f.read(3)
    while strChar:
        print(strChar)
        #time.sleep(1)
        strChar = f.read(3)



#5.tell:用来显示文件读写指针的当前位置
with open(place,'r' ) as f:
    str = f.read(3)
    pos = f.tell()
    while str:
        print(str)
        print(pos)
        str = f.read(3)
        pos= f.tell()
#说明tell 返回的是byte、



##6.文件的写操作
# write(str):把字符串写入文件
# writeline:把字符串按行写入文件
# 区别：
# wirte只能是字符串
# writeline可以是字符串，也可以是字符串序列
l =[" i " ,"love " ,"freedom"]
with open(place,'a') as f:
    f.write("\n生活不止眼前的苟且，\n还有远方的枸杞")
    f.writelines(l)

**#持久化 pickle**

#序列化（持久化，序列）：把程序运行的信息保存到磁盘上
#反序列化：序列化的逆过程
#pickle：python序列化的模块
# pickle.dump:序列化
# pickle.load:反序列化

place = "D:\\Python\\Python项目\\基础学习\\文件操作所使用的的文件夹\\test0..txt"
#序列化案例
import pickle
age = 19
with open(place,'wb') as f:
    pickle.dump(age,f)
#反序列化
with open(place,'rb') as f:
    age = pickle.load(f)
    print(age)
a = ["i","am","study","in ","NJUPT"]
with open(place,'wb') as f:
    pickle.dump(a,f)
with open(place,'rb') as f:
    print( pickle.load(f))



**#持久化—shelve**

# 持久化工具
# 类似字典，用kv对保存数据，存取方式跟字典也类似
# open close

import shelve
p = "D:\\Python\\Python项目\\基础学习\\文件操作所使用的的文件夹\\shv.db"
#使用shelve创建文件使用
shv = shelve.open(p)
shv["one"] = 1
shv["two"] = 2
shv["three"] = 3
shv.close()
#由上述例子可以看出，shelve自动创建的不止一个文件


#shelve读取案例
shv  = shelve.open(p)
try:
    print(shv["one"])
    print(shv["threee"])
except Exception as e:
    print("有错误真烦人")
finally:
    shv.close()#这句话我们一定要执行


#shelve的特性
# 不支持多个应用并行写入
# ——为了解决这个问题，可以在open的时候使用flag= r
# 写回问题
# shelve默认情况下不会等待持久化对象进行任何修改
# 解决方法：强制写回：writeback= True

#shelve 之只读打开
shv = shelve.open(r"D:\Python\Python项目\基础学习\文件操作所使用的的文件夹\shv.db",flag = 'r')
#r : 就是告诉电脑后面的内容不用转义
try:
    print(shv["one"])
finally:
    shv.close()


#例子
shv = shelve.open(p)
try:
    shv['one'] = {"eins":1, "zwei":2, "drei":3}
finally:
    shv.close()

shv = shelve.open(p)
try:
    one = shv['one']
    print(one)
finally:
    shv.close()

# shelve忘记写回，需要使用强制写回
shv = shelve.open(p)
try:
    k1 = shv['one']
    print(k1)
    # 此时，一旦shelve关闭，则内容还是存在于内存中，没有写回数据库
    k1["eins"] = 100
finally:
    shv.close()

shv = shelve.open(p)
try:
    k1 = shv['one']
    print(k1)
finally:
    shv.close()
#此时结果为：
# {'eins': 1, 'zwei': 2, 'drei': 3}
# {'eins': 1, 'zwei': 2, 'drei': 3}


#此时需要添加writeback
shv = shelve.open(p, writeback=True)
try:
    k1 = shv['one']
    print(k1)
    k1["eins"] = 100
finally:
    shv.close()

shv = shelve.open(p)
try:
    k1 = shv['one']
    print(k1)
finally:
    shv.close()
#此时结果为
# {'eins': 1, 'zwei': 2, 'drei': 3}
# {'eins': 100, 'zwei': 2, 'drei': 3}

# shelve 使用with管理上下文环境
with shelve.open(p, writeback=True) as shv:
    k1 = shv['one']
    print(k1)
    # 此时，一旦shelve关闭，则内容还是存在于内存中，没有写回数据库
    k1["eins"] = 1000

with shelve.open(p) as shv:
    print(shv['one'])