Python 学习 ---＞文件操作 (os、shutil、pathlib)、序列化

擒贼先擒王

已于 2024-06-06 12:16:52 修改

阅读量1.4k

点赞数

分类专栏： Python 文章标签： python 学习开发语言

于 2016-03-23 10:53:02 首次发布

本文链接：https://blog.csdn.net/freeking101/article/details/50961212

版权

Python 专栏收录该内容

41 篇文章 25 订阅

订阅专栏

参考：http://www.cnblogs.com/nulige/archive/2016/12/06/6037752.html

在Python 3.4之前，涉及路径相关操作，都用 os 模块解决，尤其是 os.path 这个子模块非常有用。在 Python 3.4 之后，pathlib 成为标准库模块，其使用面向对象的编程方式来表示文件系统路径，丰富了路径处理的方法。

pathlib 官网文档：https://docs.python.org/zh-cn/3.11/library/pathlib.html

1、Python 文件操作

Python2 使用内建函数 file 进行文件操作。Python3 移除了 file 函数，使用 open 函数替代。

open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

read、readline 或 write 方法来恰当地读写文件。对文件的读写能力依赖于你在打开文件时指定的模式。最后，当你完成对文件的操作的时候，你调用 close 方法来告诉 Python 我们完成了对文件的使用。

读文件

以读方式打开文件后可以调用这三个函数：read()、readline()、readlines()

read() 和 readlines() 默认都是获取文件的所有内容。但是read()返回一个String类型对象，元素是一个Char。readlines() 返回一个List类型对象，元素是一个Sting。而 readline() 获取文件的一行内容，返回是一个String。

1.open
使用open打开文件后一定要记得调用文件对象的close()方法。比如可以用try/finally语句来确保最后能关闭文件。
file_object = open('thefile.txt')
try:
all_the_text = file_object.read( )
finally:
file_object.close( )
注：不能把open语句放在try块里，因为当打开文件出现异常时，文件对象file_object无法执行close()方法。

2.读文件
读文本文件
input = open('data', 'r')
#第二个参数默认为r
input = open('data')

读二进制文件
input = open('data', 'rb')

读取所有内容
file_object = open('thefile.txt')
try:
   all_the_text = file_object.read( )
finally:
   file_object.close( )

读固定字节
file_object = open('abinfile', 'rb')
try:
   while True:
       chunk = file_object.read(100)
       if not chunk:
           break
       do_something_with(chunk)
finally:
   file_object.close( )

读每行
list_of_all_the_lines = file_object.readlines( )
如果文件是文本文件，还可以直接遍历文件对象获取每行：
for line in file_object:
   process line

3.写文件
写文本文件
output = open('data', 'w')

写二进制文件
output = open('data', 'wb')

追加写文件
output = open('data', 'w+')

写数据
file_object = open('thefile.txt', 'w')
file_object.write(all_the_text)
file_object.close( )

写入多行
file_object.writelines(list_of_text_strings)

注意，调用writelines写入多行在性能上会比使用write一次性写入要高。

写文件

注意：调用 write()、writeline() 时，文件原有的内容会被清空，因为文件指针初始指向文件的首行首个字母，而进行写操作实质就是在文件指针指向的位置开始写入内容。

pwd = open('fileOperation.txt','w')
pwd.write('My name is JMilk')
pwd.flush()
pwd.write('My name is chocolate')
pwd.flush()
pwd.write('123')
pwd.write('456')
pwd.close()

结果：

My name is JMilkMy name is chocolate123456

修改指定行的内容：

cfg = open(cfgUrl,'r+')
cfgFile = cfg.readlines()
cfgFile[lineNum] = cfgStr

cfg = open(cfgUrl,'w+')
cfg.writelines(cfgFile)
cfg.flush() #刷新内存的缓存区，即将缓存区中的内容写入到磁盘，但不会关闭文件。
cfg.close()

将文件以r+的方式打开，并返回一个对象。对对象的内容进行修改后，再将文件以w+的方式打开，将对象的内容写入到文件中。实现对文件指定行的内容修改。

writelines() 写入多行内容

import os
def write_lines(fileName,content_iterable):
try:
pwd = open(fileName,'w')
pwd.writelines(content_iterable) #传递List类型参数
finally:
pwd.close()

if __name__ == '__main__':
fileName = '/usr/local/src/pyScript/fileOperation.txt'
li = ['my name is Jmilk'+'\n','My name is chocolate'+'\n'] #定义List时加入换行符
if os.path.exists(fileName):
write_lines(fileName,li)
else:print 'File not exist!'

结果：
my name is Jmilk
My name is chocolate

write()和writelines()的区别

从上面两个例子中可以看出，write()接受的是String类型参数，所以可以在()中对实参进行修改加入’\n’。而writelines()接受的是iterable类型参数，并且iteraber对象的元素需要为String类型，只能在定义iterable的时候加入’\n’。在写入多行内容时writelines()会比write()更有效率。再一次反映数据结构决定了对象操作这一句话，所以对数据结构的理解是非常重要的。python数据结构，请参考：Python基本数据类型_范桂飓的博客-CSDN博客_python 引用数据类型

使用 with 语句

可以同时对多个文件同时操作，当with代码块执行完毕时，会自动关闭文件释放内存资源，不用再主动调用 f.close() 。

num = 0
with open('file','r') as f1,open('file2','w',encoding='utf8') as f2:
  for line in f1:
    num += 1
      if num == 5:
        line = ''.join([line.strip(),'羊小羚'])
      f2.write(line)

示例：文件的读、写

open 是一个内建函数，用来打开文件。
模式可以为读模式（'r'）、写模式（'w'）或追加模式（'a'）。还有很多的模式可以使用，可以使用 help(open) 来了解。
encoding 指定编码格式

tip = '''
Python2 中 file 是内建函数
Python3 中移除了 file 函数，使用 open 函数替代
'''
f = open('poem.txt', 'w', encoding='utf-8')
f.write(tip)
f.close()

f = open('poem.txt', encoding='utf-8')
while True:
line = f.readline()
if len(line) == 0:
break
print(line, end='')
f.close()

示例首先用写模式打开文件，然后使用 open 的 write 方法来写文件，最后我们用 close 关闭这个文件。

接下来，我们再一次打开同一个文件来读文件。如果我们没有指定模式，读模式会作为默认的模式。在一个循环中，我们使用 readline 方法读文件的每一行。这个方法返回包括行末换行符的一个完整行。所以，当一个空的字符串被返回的时候，即表示文件末已经到达了，于是我们停止循环。
注意，因为从文件读到的内容已经以换行符结尾，所以我们在 print 语句上使用 end 来消除自动换行。最后，我们用 close 关闭这个文件。

将标准输出重定向写入到指定文件

系统标准输入、输出、Err本质是一个类文件对象。重定向即： sys.stdout = fileObject_write

#!/usr/bin/env python
#Filename:stdoTest.py
#coding=utf8
import sys

fristOut = sys.stdout #备份初始的输出文件对象
print type(fristOut)

logOut = open('/usr/local/src/pyScript/out.log','w')
sys.stdout = logOut #重定向输出到新的文件对象
print 'Test stdout.' #重定向后，不会打印到屏幕

logOut.close() #关闭open()打开的文件对象
sys.stdout = fristOut #还原输出文件对象

文件指针

文件指针：当使用open()函数打开一个文件并返回一个文件对象后，在文件对象中会存放着当前”光标”在文件中的位置，对文件进行的读、写、截断操作都是基于文件指针，并从文件指针+1开始进行的操作。。这个位置称为文件指针(从文件头部开始计算的字节数)，与C语言额指针概念相似，实质是文件中位置的标识。大部分的文件操作都是基于文件指针来实现的。注意：当对文件进行了读、写操作后都会改变文件指针的值。

tell()：查询文件中光标位置
seek()：光标定位
tell() 获取当前文件指针(位置)

pwd = open('fileOperation.txt','rw+')
pwd.tell()

结果：
0 // 因为新打开的文件，文件指针指向文件开头位置

seek() 转移文件指针

seek(…)
seek(offset[, whence]) -> None. Move to new file position.

可以接收偏移量和选项作为参数，返回None。
当whence==0时，将文件指针从文件头部转移到”偏移量”指定的字符处。
当whence==1时，将文件指针从文件的当前位置往后转移”偏移量”指定的字符数。
当whence==2时，将文件指针从文件尾部向前移动”偏移量”指定的字符数。

使用示例：

f = open('file','r')
print(f.tell()) #光标默认在起始位置
f.seek(10) #把光标定位到第10个字符之后
print(f.tell()) #输出10
f.close()
----------------------
f = open('file','w')
print(f.tell()) #先清空内容，光标回到0位置
f.seek(10)
print(f.tell())
f.close()
----------------------
f = open('file','a')
print(f.tell()) #光标默认在最后位置
f.write（'你好世界'）
print(f.tell()) #光标向后9个字符，仍在最后位置
f.close()

flush()

同步将数据从缓存转移到磁盘。

示例，实现进度条功能

import sys,time
for i in range(40):
sys.stdout.write('*')
sys.stdout.flush()
time.sleep(0.2)

if __name__ == '__main__':
pass

# 下面代码也能够实现相同的功能
import time
for i in range(40):
print('*',end='',flush=True) #print中的flush参数
time.sleep(0.2)

truncate() 截断文件

不能在r模式下执行。w模式下，已经清空所有数据，使用truncate没有任何意义。a模式下，截断指定位置后的内容。

truncate(…)
truncate([size]) -> None. Truncate the file to at most size bytes.
Size defaults to the current file position, as returned by tell().

默认从文件指针指向的位置开始截断文件内容，也可以通过传递int参数n来指定截断的起始位置，即改变文件指针的位置。
从文件指针指向的位置n开始，之后的文件内容(不包含n)全部删除，以可修改mode打开的文件可以使用此方法。

f = open('file','a')
f.truncate(6) #只显示6个字节的内容（6个英文字符或三个汉字），后面的内容被清空。

光标位置总结

一个汉字两个字节，涉及光标位置的方法有4个：read、tell、seek、truncate。

#--------------------------光标总结head-----------------------------------
f = open('file','r')
print(f.read(6)) #6个字符
print(f.tell()) #位置12字节，一个汉字两个字节
f.close()

f = open('file','r')
f.seek(6) #6个字节
print(f.tell())
f.close()

f = open('file','a')
print(f.tell()) #光标默认在最后位置
f.write('你好世界')
print(f.tell()) #光标向后9个字节，一个汉字两个字节，仍在最后位置 182-->191
f.close()

f = open('file','a',encoding='utf-8')
print(f.truncate(6)) #由于需要光标定位位置，所以也是字节。只显示6个字节的内容（6个英文字母或三个汉字,一个汉字两个字节），后面的内容被清空。
f.close()
#-----------------------------光标总结end---------------------------------

一个综合例子：truncate()+tell()+seek()

In [8]: %cat fileOperation.txt
0123456789

In [9]: pwd = open('fileOperation.txt','rw+')

In [10]: pwd.tell()
Out[10]: 0

In [11]: pwd.seek(5)

In [12]: pwd.tell()
Out[12]: 5

In [13]: pwd.truncate()

In [14]: pwd.close()

In [15]: %cat fileOperation.txt
01234

2、文件、目录操作

os.path.exists(test_dir)
os.path.exists(test_file.txt)
os.path.isfile("test-data")

文件操作

关于 open 模式：

r：只读模式，文件必须存在
w：以写方式打开，
a：以追加模式打开 (从 EOF 开始, 必要时创建新文件)
r+：以读写模式打开。读写模式，光标默认在起始位置，当需要写入的时候，光标自动移到最后
w+：以读写模式打开 (参见 w ) 写读模式，先清空原内容，再写入，也能够读取
a+：以读写模式打开 (参见 a ) 追加读模式，光标默认在最后位置，直接写入，也能够读取。
rb：以二进制读模式打开
wb：以二进制写模式打开 (参见 w )
ab：以二进制追加模式打开 (参见 a )
rb+：以二进制读写模式打开 (参见 r+ )
wb+：以二进制读写模式打开 (参见 w+ )
ab+：以二进制读写模式打开 (参见 a+ )

文件操作：

os.mknod("test.txt") # 创建空文件
fp = open("test.txt", 'w') # 直接打开一个文件，如果文件不存在则创建文件

fp.read([size]) # size为读取的长度，以byte为单位
fp.readline([size]) # 读一行，如果定义了size，有可能返回的只是一行的一部分
fp.readlines([size]) # 把文件每一行作为一个list的一个成员，并返回这个list。其实它的内部是通过循环调用readline()来实现的。
如果提供size参数，size是表示读取内容的总长，也就是说可能只读到文件的一部分。
fp.write(str) # 把str写到文件中，write()并不会在str后加上一个换行符
fp.writelines(seq) # 把seq的内容全部写到文件中(多行一次性写入)。这个函数也只是忠实地写入，不会在每行后面加上任何东西。
fp.close() # 关闭文件。python会在一个文件不用后自动关闭文件，不过这一功能没有保证，最好还是养成自己关闭的习惯。
# 如果一个文件在关闭后还对其进行操作会产生ValueError
fp.flush() # 把缓冲区的内容写入硬盘
fp.fileno() # 返回一个长整型的”文件标签“
fp.isatty() # 文件是否是一个终端设备文件（unix系统中的）
fp.tell() # 返回文件操作标记的当前位置，以文件的开头为原点
fp.next() # 返回下一行，并将文件指针移到下一行。把一个file用于for … in file这样的语句时，就是调用next()函数来实现遍历的。
fp.seek(offset[,whence]) # 将文件打操作标记移到offset的位置。这个offset一般是相对于文件的开头来计算的，一般为正数。
                           如果提供whence参数就不一定了，whence为 0 表示从头开始计算，1 表示以当前位置为原点计算。
                           2 表示以文件末尾为原点进行计算。
注意：如果文件以a或a+的模式打开，每次进行写操作时，文件操作标记会自动返回到文件末尾。
fp.truncate([size]) # 把文件裁成规定的大小，默认的是裁到当前文件操作标记的位置。
                       如果size比文件的大小还要大，依据系统的不同可能是不改变文件，
                       也可能是用0把文件补到相应的大小，也可能是随机内容加上去。

注意：把两个路径合成一个时，不要直接拼字符串，而要通过 os.path.join(part1,part2)函数，这样可以正确处理不同操作系统的路径分隔符。在linux/Unix/Mac下，os.path.join()返回这样的字符串： part1/part2。而Windows下会返回这样的字符串： part1\part2

import os
import shutil

file_dir = "D:\\Python_os\\os" # 注意 \\ ；windows 下是这么表示的；Linux 和 Mac 是 /
file_name = "test.txt"
file_abs = os.path.join(file_dir, file_name) # os.path.join(...) 表示路径链接

'''判断路径或文件'''
print (1,os.path.isabs(file_dir)) # 判断是否绝对路径
print (2,os.path.isabs(file_name))
print (3,os.path.isabs(file_abs))
print (4,os.path.exists(file_abs)) # 判断是否真实存在
print (5,os.path.exists(os.path.join(file_dir,"xxx")))
print (6,os.path.isdir(file_dir)) # 判断是否是个目录
print (7,os.path.isdir(file_abs))
print (8,os.path.isfile(file_dir)) # 判断是否是个文件
print (9,os.path.isfile(file_abs))

复制、移动文件夹/文件。须使用 shutil 模块，引入 import shutil

shutil.copyfile("old","new") # 复制文件，都只能是文件
shutil.copytree("old","new")　# 复制文件夹，都只能是目录，且new必须不存在
shutil.copy("old","new")　　　# 复制文件/文件夹，复制 old 为 new（new是文件，若不存在，即新建），
# 复制 old 为至 new 文件夹（文件夹已存在）
shutil.move("old","new") 　　# 移动文件/文件夹至 new 文件夹中

import os
import shutil

file_dir = "D:\\Python_shutil"
os.chdir(file_dir)
shutil.copyfile("test_org.txt","test_copy.txt") # copy test_org.txt 为 test_copy.txt 若存在，则覆盖
shutil.copyfile("test_org.txt","test1.txt") # 存在，覆盖
shutil.copytree("test_org","test_copytree") # copy test_org 为 test_copytree（不存在的新目录）
shutil.copy("test_org.txt","test_copy1.txt") # 同 copyfile
shutil.copy("test_org.txt","test_copy") # 将文件 copy 至目标文件夹中（须存在）
shutil.copy("test_org.txt","test_xxx") # 将文件 copy 至目标文件（该文件可不存在，注意类型！）
print os.listdir(os.getcwd())
shutil.move("test_org.txt","test_move") # 将文件 move 至目标文件夹中
shutil.move("test_org","test_move") # 将文件夹 move 至目标文件夹中
print os.listdir(os.getcwd())

遍历文件

os.walk() 用于通过在目录树中游走，并输出在目录中的文件名，可以向上或者向下游走。

os.walk(top[, topdown=True[, οnerrοr=None[, followlinks=False]]])

参数

top -- 是你所要遍历的目录的地址, 返回的是一个三元组(root,dirs,files)。
root 所指的是当前正在遍历的这个文件夹的本身的地址
dirs 是一个 list ，内容是该文件夹中所有的目录的名字(不包括子目录)
files 同样是 list , 内容是该文件夹中所有的文件(不包括子目录)
topdown --可选，为 True，则优先遍历 top 目录，否则优先遍历 top 的子目录(默认为开启)。如果 topdown 参数为 True，walk 会遍历top文件夹，与top 文件夹中每一个子目录。
onerror -- 可选，需要一个 callable 对象，当 walk 需要异常时，会调用。
followlinks -- 可选，如果为 True，则会遍历目录下的快捷方式(linux 下是软连接 symbolic link )实际所指的目录(默认关闭)，如果为 False，则优先遍历 top 的子目录。

返回值

生成器

示例：

import os
for root, dirs, files in os.walk(".", topdown=False):
    for name in files:
        print(os.path.join(root, name))
    for name in dirs:
        print(os.path.join(root, name))

遍历文件夹

def walkFile(file):
    for root, dirs, files in os.walk(file):

        # root 表示当前正在访问的文件夹路径
        # dirs 表示该文件夹下的子目录名list
        # files 表示该文件夹下的文件list

        # 遍历文件
        for f in files:
            print(os.path.join(root, f))

        # 遍历所有的文件夹
        for d in dirs:
            print(os.path.join(root, d))

import os

root_dir = "d:/" # 指明被遍历的文件夹

# 三个参数：分别返回：1.父目录 2.所有文件夹名字（不含路径） 3.所有文件名字
for parent, dir_names, file_names in os.walk(root_dir):
    for dir_name in dir_names:  # 输出文件夹信息
        print "parent is:" + parent
        print "dirname is" + dir_name

    for file_name in file_names:  # 输出文件信息
        print "parent is:" + parent
        print "filename is:" + file_name
        print "the full name of the file is:" + os.path.join(parent, file_name)  # 输出文件路径

python本身并没有对二进制进行支持，不过提供了一个模块来弥补，就是struct模块。

# python没有二进制类型，但可以存储二进制类型的数据，就是用string字符串类型来存储二进制数据，
# 这也没关系，因为string是以1个字节为单位的。

import struct
a=12.34

#将a变为二进制
bytes=struct.pack('i',a)    #此时bytes就是一个string字符串，字符串按字节同a的二进制存储内容相同。

 

#再进行反操作。现有二进制数据bytes，（其实就是字符串），将它反过来转换成python的数据类型：

a,=struct.unpack('i',bytes)    #注意，unpack返回的是tuple

# 所以如果只有一个变量的话：
bytes=struct.pack('i',a)

# 那么，解码的时候需要这样
a,=struct.unpack('i',bytes) 或者 (a,)=struct.unpack('i',bytes)

#如果直接用a=struct.unpack('i',bytes)，那么 a=(12.34,) ，是一个tuple而不是原来的浮点数了。
#如果是由多个数据构成的，可以这样：
a='hello'
b='world!'
c=2
d=45.123
bytes=struct.pack('5s6sif',a,b,c,d)

# 此时的bytes就是二进制形式的数据了，可以直接写入文件比如 binfile.write(bytes)
# 然后，当我们需要时可以再读出来，bytes=binfile.read()
# 再通过struct.unpack()解码成python变量
a,b,c,d=struct.unpack('5s6sif',bytes)

'5s6sif'这个叫做fmt，就是格式化字符串，由数字加字符构成，5s表示占5个字符的字符串，2i，表示2个整数等等，
下面是可用的字符及类型，ctype表示可以与python中的类型一一对应。

目录操作

1.创建目录
os.mkdir("file")
2.复制文件：
shutil.copyfile("oldfile","newfile") #oldfile和newfile都只能是文件
shutil.copy("oldfile","newfile") #oldfile只能是文件夹，newfile可以是文件，也可以是目标目录
3.复制文件夹：
4.shutil.copytree("olddir","newdir") #olddir和newdir都只能是目录，且newdir必须不存在
5.重命名文件（目录）
os.rename("oldname","newname") #文件或目录都是使用这条命令
6.移动文件（目录）
shutil.move("oldpos","newpos")
7.删除文件
os.remove("file")
8.删除目录
os.rmdir("dir") #只能删除空目录
shutil.rmtree("dir") #空目录、有内容的目录都可以删
9.转换目录
os.chdir("path") #换路径

os.getcwd() 　　　　# 获取当前工作目录
os.chdir(...)　　　 # 改变工作目录
os.listdir(...)　　 # 列出目录下的文件
os.mkdir(...)　　 # 创建单个目录　　　　注意：创建多级用 os.makedirs()
os.makedirs(...)　 # 创建多级目录

实例

将文件夹下所有图片名称加上 '_fc'

# -*- coding:utf-8 -*-
import re
import os
import time
#str.split(string)分割字符串
#'连接符'.join(list) 将列表组成字符串
def change_name(path):
global i
if not os.path.isdir(path) and not os.path.isfile(path):
return False
if os.path.isfile(path):
file_path = os.path.split(path) #分割出目录与文件
lists = file_path[1].split('.') #分割出文件与文件扩展名
file_ext = lists[-1] #取出后缀名(列表切片操作)
img_ext = ['bmp','jpeg','gif','psd','png','jpg']
if file_ext in img_ext:
os.rename(path,file_path[0]+'/'+lists[0]+'_fc.'+file_ext)
i+=1 #注意这里的i是一个陷阱
#或者
#img_ext = 'bmp|jpeg|gif|psd|png|jpg'
#if file_ext in img_ext:
# print('ok---'+file_ext)
elif os.path.isdir(path):
for x in os.listdir(path):
change_name(os.path.join(path,x)) #os.path.join()在路径处理上很有用
img_dir = 'D:\\xx\\xx\\images'
img_dir = img_dir.replace('\\','/')
start = time.time()
i = 0
change_name(img_dir)
c = time.time() - start
print('程序运行耗时:%0.2f'%(c))
print('总共处理了 %s 张图片'%(i))

输出结果：
程序运行耗时:0.11
总共处理了 109 张图片

序列化

数据持久化

序列化作用：程序运行中得到了一些字符串，列表，字典等数据长久的保存下来，方便以后使用，而不是简单的放入内存中关机断电就丢失数据

Python 提供一个标准的模块，称为 pickle。使用它你可以在一个文件中储存 任何Python对象，之后你又可以把它完整无缺地取出来。这被称为 持久的储存对象。

python3 的 _pickle 模块详解：https://www.cnblogs.com/ranxf/p/7800179.html

或者使用 pandas 里面的 cPickle：https://blog.csdn.net/sinat_36458870/article/details/73551210

还有另一个模块称为 cPickle，它的功能和 pickle 模块完全相同，只不过它是用C语言编写的，因此要快得多（比 pickle 快 1000 倍）。你可以使用它们中的任一个，而我们在这里将使用 cPickle 模块。记住，我们把这两个模块都简称为 pickle 模块。

存储与存取

# import cPickle as p  # python2 使用 cPickle 方法
# python3中cPickle模块已经更名为_pickle,所以在python3中导入时可以使用：
import _pickle as p    # python3 使用 cPickle 方法

# import pickle as p

shop_list_file = 'shop_list.data'
# the name of the file where we will store the object

shop_list = ['apple', 'mango', 'carrot']

# Write to the file
f = open(shop_list_file, 'w')
p.dump(shop_list, f)  # dump the object to a file
f.close()

del shop_list  # remove the shop_list

# Read back from the storage
f = open(shop_list_file)
stored_list = p.load(f)
print(stored_list)

# 输出
# $ python
# pickling.py
# ['apple', 'mango', 'carrot']

首先，请注意我们使用了 import..as 语法。这是一种便利方法，以便于我们可以使用更短的模块名称。在这个例子中，它还让我们能够通过简单地改变一行就切换到另一个模块（cPickle或者pickle）！在程序的其余部分的时候，我们简单地把这个模块称为p。为了在文件里储存一个对象，首先以写模式打开一个file对象，然后调用储存器模块的dump函数，把对象储存到打开的文件中。这个过程称为储存。接下来，我们使用pickle模块的load函数的返回来取回对象。这个过程称为取储存。

存储对象（序列化存储）

使用上面的模块，可以实现在文件中对字符串的读写。然而，有的时候，你可能需要传递其它类型的数据，如list、tuple、dictionary和其它对象。在Python中，你可以使用Pickling来完成。你可以使用Python标准库中的“pickle”模块完成数据转储。
下面，我们来编组一个包含字符串和数字的list：

import pickle

fileHandle = open('pickleFile.txt', 'w')
testList = ['This', 2, 'is', 1, 'a', 0, 'test.']
pickle.dump(testList, fileHandle)
fileHandle.close()


fileHandle = open('pickleFile.txt')
testList = pickle.load(fileHandle)
fileHandle.close()
print testList

存储更加复杂的数据：

import pickle

fileHandle = open('pickleFile.txt', 'w') 
testList = [123, {'Calories': 190}, 'Mr. Anderson', [1, 2, 7]] 
pickle.dump(testList, fileHandle) 
fileHandle.close()


fileHandle = open('pickleFile.txt') 
testList = pickle.load(fileHandle) 
fileHandle.close()

使用Python的“pickle”模块编组确实很简单。众多对象可以通过它来存储到文件中。如果可以的话，“cPickle”同样胜任这个工作。它和“pickle”模块一样，但是速度更快：

import cPickle

fileHandle = open('pickleFile.txt', 'w')
cPickle.dump(1776, fileHandle)
fileHandle.close()

擒贼先擒王

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Python 学习 ---＞文件操作 (os、shutil、pathlib)、序列化

Python 文件操作 (os、shutil、pathlib)、序列化
复制链接

扫一扫

专栏目录

Python 学习 ---＞文件操作 (os、shutil、pathlib)、序列化

1、Python 文件操作

读文件

写文件

使用 with 语句

示例：文件的读、写

将标准输出重定向写入到指定文件

文件指针

flush()

truncate() 截断文件

光标位置总结

2、文件、目录操作

相关模块：pathlib、os、shutil、

pathlib --- 面向对象的文件系统路径

os 模块

shutil 模块

文件操作

遍历文件

目录操作

实例

序列化

存储与存取

存储对象（序列化存储）

Python 学习 ---＞ 文件操作 (os、shutil、pathlib)、序列化

1、Python 文件操作

读文件

写文件

使用 with 语句

示例：文件的 读、写

将标准输出重定向写入到指定文件

文件指针

flush()

truncate() 截断文件

光标位置总结

2、文件、目录 操作

相关模块：pathlib、os、shutil、

pathlib --- 面向对象的文件系统路径

os 模块

shutil 模块

文件 操作

遍历文件

目录 操作

实例

序列化

存储与存取

存储对象（序列化存储）

Python 学习 ---＞文件操作 (os、shutil、pathlib)、序列化

示例：文件的读、写

2、文件、目录操作

文件操作

目录操作