Python文件操作学习总结

Python读写文件

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一次性写入要高。


在处理日志文件的时候，常常会遇到这样的情况：日志文件巨大，不可能一次性把整个文件读入到内存中进行处理，例如需要在一台物理内存为 2GB 的机器上处理一个 2GB 的日志文件，我们可能希望每次只处理其中 200MB 的内容。
在 Python 中，内置的 File 对象直接提供了一个 readlines(sizehint) 函数来完成这样的事情。以下面的代码为例：


file = open('test.log', 'r')sizehint = 209715200   # 200Mposition = 0lines = file.readlines(sizehint)while not file.tell() - position < 0:       position = file.tell()       lines = file.readlines(sizehint)


每次调用 readlines(sizehint) 函数，会返回大约 200MB 的数据，而且所返回的必然都是完整的行数据，大多数情况下，返回的数据的字节数会稍微比 sizehint 指定的值大一点（除最后一次调用 readlines(sizehint) 函数的时候）。通常情况下，Python 会自动将用户指定的 sizehint 的值调整成内部缓存大小的整数倍。


file在python是一个特殊的类型，它用于在python程序中对外部的文件进行操作。在python中一切都是对象，file也不例外，file有file的方法和属性。下面先来看如何创建一个file对象：


file(name[, mode[, buffering]]) 
file()函数用于创建一个file对象，它有一个别名叫open()，可能更形象一些，它们是内置函数。来看看它的参数。它参数都是以字符串的形式传递的。name是文件的名字。
mode是打开的模式，可选的值为r w a U，分别代表读（默认） 写 添加支持各种换行符的模式。用w或a模式打开文件的话，如果文件不存在，那么就自动创建。此外，用w模式打开一个已经存在的文件时，原有文件的内容会被清空，因为一开始文件的操作的标记是在文件的开头的，这时候进行写操作，无疑会把原有的内容给抹掉。由于历史的原因，换行符在不同的系统中有不同模式，比如在 unix中是一个\n，而在windows中是‘\r\n’，用U模式打开文件，就是支持所有的换行模式，也就说‘\r’ '\n' '\r\n'都可表示换行，会有一个tuple用来存贮这个文件中用到过的换行符。不过，虽说换行有多种模式，读到python中统一用\n代替。在模式字符的后面，还可以加上+ b t这两种标识，分别表示可以对文件同时进行读写操作和用二进制模式、文本模式（默认）打开文件。
buffering如果为0表示不进行缓冲;如果为1表示进行“行缓冲“;如果是一个大于1的数表示缓冲区的大小，应该是以字节为单位的。


file对象有自己的属性和方法。先来看看file的属性。


closed #标记文件是否已经关闭，由close()改写 
encoding #文件编码 
mode #打开模式 
name #文件名 
newlines #文件中用到的换行模式，是一个tuple 
softspace #boolean型，一般为0，据说用于print


file的读写方法：


F.read([size]) #size为读取的长度，以byte为单位 
F.readline([size]) 
#读一行，如果定义了size，有可能返回的只是一行的一部分 
F.readlines([size]) 
#把文件每一行作为一个list的一个成员，并返回这个list。其实它的内部是通过循环调用readline()来实现的。如果提供size参数，size是表示读取内容的总长，也就是说可能只读到文件的一部分。 
F.write(str) 
#把str写到文件中，write()并不会在str后加上一个换行符 
F.writelines(seq) 
#把seq的内容全部写到文件中。这个函数也只是忠实地写入，不会在每行后面加上任何东西。 
file的其他方法：


F.close() 
#关闭文件。python会在一个文件不用后自动关闭文件，不过这一功能没有保证，最好还是养成自己关闭的习惯。如果一个文件在关闭后还对其进行操作会产生ValueError 
F.flush() 
#把缓冲区的内容写入硬盘 
F.fileno() 
#返回一个长整型的”文件标签“ 
F.isatty() 
#文件是否是一个终端设备文件（unix系统中的） 
F.tell() 
#返回文件操作标记的当前位置，以文件的开头为原点 
F.next() 
#返回下一行，并将文件操作标记位移到下一行。把一个file用于for ... in file这样的语句时，就是调用next()函数来实现遍历的。 
F.seek(offset[,whence]) 
#将文件打操作标记移到offset的位置。这个offset一般是相对于文件的开头来计算的，一般为正数。但如果提供了whence参数就不一定了，whence可以为0表示从头开始计算，1表示以当前位置为原点计算。2表示以文件末尾为原点进行计算。需要注意，如果文件以a或a+的模式打开，每次进行写操作时，文件操作标记会自动返回到文件末尾。 
F.truncate([size]) 
#把文件裁成规定的大小，默认的是裁到当前文件操作标记的位置。如果size比文件的大小还要大，依据系统的不同可能是不改变文件，也可能是用0把文件补到相应的大小，也可能是以一些随机的内容加上去。
 
#! /usr/bin/python
import os,sys


try:
    fsock = open("D:/SVNtest/test.py", "r")
except IOError:
    print "The file don't exist, Please double check!"
    exit()
print 'The file mode is ',fsock.mode
print 'The file name is ',fsock.name
P = fsock.tell()
print 'the postion is %d' %(P)
fsock.close()


#Read file
fsock = open("D:/SVNtest/test.py", "r")
AllLines = fsock.readlines()
#Method 1
for EachLine in fsock:
    print EachLine


#Method 2
print 'Star'+'='*30
for EachLine in AllLines:
    print EachLine
print 'End'+'='*30
fsock.close()


#write this file
fsock = open("D:/SVNtest/test.py", "a")
fsock.write("""
#Line 1 Just for test purpose
#Line 2 Just for test purpose
#Line 3 Just for test purpose""")
fsock.close()


#check the file status
S1 = fsock.closed
if True == S1:
    print 'the file is closed'
else:
    print 'The file donot close'
========

Python：文件的读取、创建、追加、删除、清空

一、用Python创建一个新文件，内容是从0到9的整数, 每个数字占一行：
#python
>>>f=open('f.txt','w')    # r只读，w可写，a追加
>>>for i in range(0,10):f.write(str(i)+'\n')
.  .  .
>>> f.close()
二、文件内容追加，从0到9的10个随机整数：
#python
>>>import random
>>>f=open('f.txt','a')
>>>for i in range(0,10):f.write(str(random.randint(0,9)))
.  .  .
>>>f.write('\n')
>>>f.close()
三、文件内容追加，从0到9的随机整数, 10个数字一行，共10行：
#python
>>> import random
>>> f=open('f.txt','a')
>>> for i in range(0,10):
.  .  .     for i in range(0,10):f.write(str(random.randint(0,9))) 
.  .  .     f.write('\n')    
.  .  .
>>> f.close()
四、把标准输出定向到文件：
#python
>>> import sys
>>> sys.stdout = open("stdout.txt", "w")
>>>  . . .


 
五、文件的读写


一、文件打开:


f = file(name[, mode[, buffering]])


入口参数:   name 文件名


                  mode   选项,字符串


                  buffering   是否缓冲 (0=不缓冲，1=缓冲, >1的int数=缓冲区大小)


返回值 : 文件对象


mode 选项:


"r"   以读方式打开，只能读文件 ， 如果文件不存在，会发生异常      


"w" 以写方式打开，只能写文件， 如果文件不存在，创建该文件
                                                     如果文件已存在，先清空，再打开文件


"rb"   以二进制读方式打开，只能读文件 ， 如果文件不存在，会发生异常      


"wb" 以二进制写方式打开，只能写文件， 如果文件不存在，创建该文件


                                                     如果文件已存在，先清空，再打开文件


"rt"   以文本读方式打开，只能读文件 ， 如果文件不存在，会发生异常      


"wt" 以文本写方式打开，只能写文件， 如果文件不存在，创建该文件


                                                     如果文件已存在，先清空，再打开文件


"rb+"   以二进制读方式打开，可以读、写文件 ， 如果文件不存在，会发生异常      


"wb+" 以二进制写方式打开，可以读、写文件， 如果文件不存在，创建该文件


                                                     如果文件已存在，先清空，再打开文件


二、关闭文件


f.close()


当文件读写完毕后，应关闭文件。


三、清空文件内容


f.truncate()


注意：仅当以 "r+"   "rb+"    "w"   "wb" "wb+"等以可写模式打开的文件才可以执行该功能。


四、文件的指针定位与查询


（1）文件指针：


      文件被打开后，其对象保存在 f 中， 它会记住文件的当前位置,以便于执行读、写操作，这个位置称为文件的指针( 一个从文件头部开始计算的字节数 long 类型 )。


（2）文件打开时的位置:


      以"r"   "r+"   "rb+" 读方式, "w"   "w+"   "wb+"写方式 打开的文件，


     一开始，文件指针均指向文件的头部。


(3) 获取文件指针的值:


      L = f.tell()


(4) 移动文件的指针


       f.seek(   偏移量, 选项 )


      选项 =0 时， 表示将文件指针指向从文件头部到 "偏移量"字节处。


      选项 =1 时， 表示将文件指针指向从文件的当前位置，向后移动 "偏移量"字节。


      选项 =2 时， 表示将文件指针指向从文件的尾部，，向前移动 "偏移量"字节。


五、从文件读取指内容   


1 文本文件（以"rt"方式打开的文件）的读取  


          s = f.readline(     )


        返回值： s 是字符串，从文件中读取的一行，含行结束符。


        说明： (1)  如果 len( s ) =0 表示已到文件尾


                    (2)   如果是文件的最后一行，有可能没有行结束符


2 二进制文件（以"rb"、"rb+"、"wb+" 方式打开的文件）的读取  


          s = f.read(    n )


     说明： (1)  如果 len( s ) =0 表示已到文件尾


                  (2)   文件读取后，文件的指针向后移动 len(s) 字节。


                （3）如果磁道已坏，会发生异常。


六、向文件写入一个字符串   


    f.write(    s )


    参数：       s 要写入的字符串


    说明： (1)文件写入后，文件的指针向后移动 len(s) 字节。


                 （2）如果磁道已坏，或磁盘已满会发生异常。


返回值： s 是字符串，从文件中读取的内容


七、删除文件


import os


os.remove(file)
========

Python文件操作读写文件

最基本的文件操作当然就是在文件中读写数据。这也是很容易掌握的。现在打开一个文件以进行写操作： 


1. fileHandle = open ( 'test.txt', 'w' )  


fileHandle = open ( 'test.txt', 'w' ) 


‘w'是指文件将被写入数据，语句的其它部分很好理解。下一步就是将数据写入文件： 


1. fileHandle.write ( 'This is a test.\nReally, it is.' )  


fileHandle.write ( 'This is a test.\nReally, it is.' ) 


这个语句将“This is a test.”写入文件的第一行，“Really, it is.”写入文件的第二行。最后，我们需要做清理工作，并且关闭文件： 


1. fileHandle.close()  


fileHandle.close() 


正如你所见，在Python的面向对象机制下，这确实非常简单。需要注意的是，当你再次使用“w”方式在文件中写数据，所有原来的内容都会被删除。如果想保留原来的内容，可以使用“a”方式在文件中结尾附加数据： 


1. fileHandle = open ( 'test.txt', 'a' )  
2. fileHandle.write ( '\n\nBottom line.' )  
3. fileHandle.close()  


fileHandle = open ( 'test.txt', 'a' ) 
fileHandle.write ( '\n\nBottom line.' ) 
fileHandle.close() 


然后，我们读取test.txt，并将内容显示出来： 


1. fileHandle = open ( 'test.txt' )  
2. print fileHandle.read()  
3. fileHandle.close()  


fileHandle = open ( 'test.txt' ) 
print fileHandle.read() 
fileHandle.close() 


以上语句将读取整个文件并显示其中的数据。我们也可以读取文件中的一行： 


1. fileHandle = open ( 'test.txt' )  
2. print fileHandle.readline() # "This is a test."  
3. fileHandle.close()  


fileHandle = open ( 'test.txt' ) 
print fileHandle.readline() # "This is a test." 
fileHandle.close() 




同时，也可以将文件内容保存到一个list中： 


1. fileHandle = open ( 'test.txt' )  
2. fileList = fileHandle.readlines()

 
3. for fileLine in fileList:  
4.     print '>>', fileLine  
5. fileHandle.close()  


fileHandle = open ( 'test.txt' ) 
fileList = fileHandle.readlines() 
for fileLine in fileList: 
print '>>', fileLine 
fileHandle.close() 


Python在读取一个文件时，会记住其在文件中的位置，如下所示： 


1. fileHandle = open ( 'test.txt' )  
2. garbage = fileHandle.readline()  
3. fileHandle.readline() # "Really, it is."fileHandle.close()  


fileHandle = open ( 'test.txt' ) 
garbage = fileHandle.readline() 
fileHandle.readline() # "Really, it is."fileHandle.close() 


可以看到，只有第二行显示出来。然而，我们可以让Python从头开始读来解决这个问题： 


1. fileHandle = open ( 'test.txt' )  
2. garbage = fileHandle.readline()  
3. fileHandle.seek ( 0 )  
4. print fileHandle.readline() # "This is a test."  
5. fileHandle.close()  


fileHandle = open ( 'test.txt' ) 
garbage = fileHandle.readline() 
fileHandle.seek ( 0 ) 
print fileHandle.readline() # "This is a test." 
fileHandle.close() 


在上面这个例子中，我们让Python从文件第一个字节开始读取数据。所以，第一行文字显示了出来。当然，我们也可以获取Python在文件中的位置： 


1. fileHandle = open ( 'test.txt' )  
2. print fileHandle.readline() # "This is a test."  
3. print fileHandle.tell() # "17"  
4. print fileHandle.readline() # "Really, it is."  


fileHandle = open ( 'test.txt' ) 
print fileHandle.readline() # "This is a test." 
print fileHandle.tell() # "17" 
print fileHandle.readline() # "Really, it is." 


或者在文件中一次读取几个字节的内容： 


1. fileHandle = open ( 'test.txt' )  
2. print fileHandle.read ( 1 ) # "T"  
3. fileHandle.seek ( 4 )  
4. print FileHandle.read ( 1 ) # " "(原文有错)  


fileHandle = open ( 'test.txt' ) 
print fileHandle.read ( 1 ) # "T" 
fileHandle.seek ( 4 ) 
print FileHandle.read ( 1 ) # " "(原文有错) 


在Windows和Macintosh环境下，有时可能需要以二进制方式读写文件，比如图片和可执行文件。此时，只要在打开文件的方式参数中增加一个“b”即可： 


1. fileHandle = open ( 'testBinary.txt', 'wb' )  
2. fileHandle.write ( 'There is no spoon.' )  
3. fileHandle.close()  


fileHandle = open ( 'testBinary.txt', 'wb' ) 
fileHandle.write ( 'There is no spoon.' ) 
fileHandle.close() 


1. fileHandle = open ( 'testBinary.txt', 'rb' )  
2. print fileHandle.read()  
3. fileHandle.close()  


fileHandle = open ( 'testBinary.txt', 'rb' ) 
print fileHandle.read() 
fileHandle.close() 


二、从现有文件中获取信息 
使用Python中的模块，可以从现有文件中获取信息。使用“os”模块和“stat”模块可以获取文件的基本信息： 


1. import os  
2. import stat  
3. import time

 
4.   
5. fileStats = os.stat ( 'test.txt' )  
6. fileInfo = {  
7.     'Size' : fileStats [ stat.ST_SIZE ],  
8.     'LastModified' : time.ctime ( fileStats [ stat.ST_MTIME ] ),  
9.     'LastAccessed' : time.ctime ( fileStats [ stat.ST_ATIME ] ),  
10.     'CreationTime' : time.ctime ( fileStats [ stat.ST_CTIME ] ),  
11.     'Mode' : fileStats [ stat.ST_MODE ]  
12. }  
13.   
14. for infoField, infoValue in fileInfo:  
15.     print infoField, ':' + infoValue  
16. if stat.S_ISDIR ( fileStats [ stat.ST_MODE ] ):  
17.     print 'Directory. '  
18. else:  
19.     print 'Non-directory.'  


import os 
import stat 
import time 


fileStats = os.stat ( 'test.txt' ) 
fileInfo = { 
'Size' : fileStats [ stat.ST_SIZE ], 
'LastModified' : time.ctime ( fileStats [ stat.ST_MTIME ] ), 
'LastAccessed' : time.ctime ( fileStats [ stat.ST_ATIME ] ), 
'CreationTime' : time.ctime ( fileStats [ stat.ST_CTIME ] ), 
'Mode' : fileStats [ stat.ST_MODE ] 
} 


for infoField, infoValue in fileInfo: 
print infoField, ':' + infoValue 
if stat.S_ISDIR ( fileStats [ stat.ST_MODE ] ): 
print 'Directory. ' 
else: 
print 'Non-directory.' 


上面这个例子创建了一个包含文件基本信息的dictionary。然后显示了相关信息，并且告诉我们打开的是否为目录。我们也可以试一下打开的是否是其它几种类型： 


1. import os  
2. import stat  
3.   
4. fileStats = os.stat ( 'test.txt' )  
5. fileMode = fileStats [ stat.ST_MODE ]  
6. if stat.S_ISREG ( fileStats [ stat.ST_MODE ] ):  
7.     print 'Regular file.'  
8. elif stat.S_ISDIR ( fileStats [ stat.ST_MODE ] ):  
9.     print 'Directory.'  
10. elif stat.S_ISLNK ( fileStats [ stat.ST_MODE ] ):  
11.     print 'Shortcut.'  
12. elif stat.S_ISSOCK ( fileStats [ stat.ST_MODE ] ):  
13.     print 'Socket.'  
14. elif stat.S_ISFIFO ( fileStats [ stat.ST_MODE ] ):  
15.     print 'Named pipe.'  
16. elif stat.S_ISBLK ( fileStats [ stat.ST_MODE ] ):  
17.     print 'Block special device.'  
18. elif stat.S_ISCHR ( fileStats [ stat.ST_MODE ] ):  
19.     print 'Character special device.'  


import os 
import stat 


fileStats = os.stat ( 'test.txt' ) 
fileMode = fileStats [ stat.ST_MODE ] 
if stat.S_ISREG ( fileStats [ stat.ST_MODE ] ): 
print 'Regular file.' 
elif stat.S_ISDIR ( fileStats [ stat.ST_MODE ] ): 
print 'Directory.' 
elif stat.S_ISLNK ( fileStats [ stat.ST_MODE ] ): 
print 'Shortcut.' 
elif stat.S_ISSOCK ( fileStats [ stat.ST_MODE ] ): 
print 'Socket.' 
elif stat.S_ISFIFO ( fileStats [ stat.ST_MODE ] ): 
print 'Named pipe.' 
elif stat.S_ISBLK ( fileStats [ stat.ST_MODE ] ): 
print 'Block special device.' 
elif stat.S_ISCHR ( fileStats [ stat.ST_MODE ] ): 
print 'Character special device.' 


另外，我们可以使用“os.path”来获取基本信息： 


1. import os.path  
2.   
3. fileStats = 'test.txt'  
4. if os.path.isdir ( fileStats ):  
5.     print 'Directory.'  
6. elif os.path.isfile ( fileStats ):  
7.     print 'File.'  
8. elif os.path.islink ( fileStats ):  
9.     print 'Shortcut.'  
10. elif os.path.ismount ( fileStats ):  
11.     print 'Mount point.'  


import os.path 


fileStats = 'test.txt' 
if os.path.isdir ( fileStats ): 
print 'Directory.' 
elif os.path.isfile ( fileStats ): 
print 'File.' 
elif os.path.islink ( fileStats ): 
print 'Shortcut.' 
elif os.path.ismount ( fileStats ): 
print 'Mount point.' 


三、目录 
和普通文件一样，关于目录的操作也很容易掌握。首先，列出一个目录的内容： 


1. import os  
2.   
3. for fileName in os.listdir ( '/' ):  
4.     print fileName  


import os 


for fileName in os.listdir ( '/' ): 
print fileName 


正如你所见，这很简单，用三行代码就可以完成。 
创建目录也很简单： 


1. import os  
2.   
3. os.mkdir ( 'testDirectory' )  


import os 


os.mkdir ( 'testDirectory' ) 


删除刚才创建的目录： 


1. import os  
2.   
3. os.rmdir ( 'testDirectory )  


import os 


os.rmdir ( 'testDirectory ) 


嗯，可以创建多级目录： 


1. import os  
2.   
3. os.makedirs ( 'I/will/show/you/how/deep/the/rabbit/hole/goes' )  


import os 


os.makedirs ( 'I/will/show/you/how/deep/the/rabbit/hole/goes' ) 


如果没有在创建的文件夹中添加任何东西，就可以一次性将它们全部删除（即，删除所列的所有空文件夹）： 


1. import os  
2.   
3. os.removedirs ( 'I/will/show/you/how/deep/the/rabbit/hole/goes' )  


import os 


os.removedirs ( 'I/will/show/you/how/deep/the/rabbit/hole/goes' ) 


当需要对一个特定的文件类型进行操作时，我们可以选择“fnmatch”模块。以下是显示“.txt”文件的内容和“.exe”文件的文件名： 


1. import fnmatch  
2. import os  
3.   
4. for fileName in os.listdir ( '/' ):  
5.     if fnmatch.fnmath ( fileName, '*.txt' ):  
6.         print open ( fileName ).read()  
7.     elif fnmatch.fnmatch ( fileName, '*.exe' ):  
8.         print fileName  


import fnmatch 
import os 


for fileName in os.listdir ( '/' ): 
if fnmatch.fnmath ( fileName, '*.txt' ): 
print open ( fileName ).read() 
elif fnmatch.fnmatch ( fileName, '*.exe' ): 
print fileName 


“*”字符可以表示任意长度的字符。如果要匹配一个字符，则使用“?”符号： 


1. import fnmatch  
2. import os  
3.   
4. for fileName in os.listdir ( '/' ):  
5.     if fnmatch.fnmatch ( fileName, '?.txt' ):  
6.         print 'Text file.'  


import fnmatch 
import os 


for fileName in os.listdir ( '/' ): 
if fnmatch.fnmatch ( fileName, '?.txt' ): 
print 'Text file.' 


“fnmatch”模块支持正则表达式： 


1. import fnmatch  
2. import os  
3. import re  
4.   
5. filePattern = fnmatch.translate ( '*.txt' )  
6. for fileName in os.listdir ( '/' ):  
7.     if re.match ( filePattern, fileName ):  
8.         print 'Text file.'  


import fnmatch 
import os 
import re 


filePattern = fnmatch.translate ( '*.txt' ) 
for fileName in os.listdir ( '/' ): 
if re.match ( filePattern, fileName ): 
print 'Text file.' 


若只需要匹配一种类型的文件，更好的办法是使用“glob”模块。该模块的格式和“fnmatch”相似： 


1. import glob  
2.   
3. for fileName in glob.glob ( '*.txt' ):  
4.     print 'Text file.'  


import glob 


for fileName in glob.glob ( '*.txt' ): 
print 'Text file.' 


使用一定范围的字符来匹配同样可行，就像在正则表达式中使用一样。假设你想要显示扩展名前只有一位数字的文件的文件名： 


1. import glob  
2.   
3. for fileName in glob.glob ( '[0-9].txt' ):  
4.     print filename  


import glob 


for fileName in glob.glob ( '[0-9].txt' ): 
print filename 


“glob”模块利用“fnmatch”模块来实现。 


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


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


import pickle 


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


拆分编组同样不难： 


1. import pickle  
2.   
3. fileHandle = open ( 'pickleFile.txt' )  
4. testList = pickle.load ( fileHandle )  
5. fileHandle.close()  


import pickle 


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


现在试试存储更加复杂的数据： 


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


import pickle 


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


1. import pickle  
2.   
3. fileHandle = open ( 'pickleFile.txt' )  
4. testList = pickle.load ( fileHandle )  
5. fileHandle.close()  


import pickle 


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




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


1. import cPickle  
2.   
3. fileHandle = open ( 'pickleFile.txt', 'w' )  
4. cPickle.dump ( 1776, fileHandle )  
5. fileHandle.close()  


import cPickle 


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


五、创建“虚拟”文件 
你用到的许多模块包含需要文件对象作为参数的方法。但是，有时创建并使用一个真实的文件并让人感到有些麻烦。所幸的是，在Python中，你可以使用“StringIO”模块来创建文件并将其保存在内存中： 


1. import StringIO  
2.   
3. fileHandle = StringIO.StringIO ( "Let freedom ring" )  
4. print fileHandle.read() # "Let freedom ring."  
5. fileHandle.close()  


import StringIO 


fileHandle = StringIO.StringIO ( "Let freedom ring" ) 
print fileHandle.read() # "Let freedom ring." 
fileHandle.close() 


cStringIO”模块同样有效。它的使用方法和“StringIO”一样，但就像“cPickle”之于“pickle”，它速度更快： 


1. import cStringIO  
2.   
3. fileHandle = cStringIO.cStringIO ( "To Kill a Mockingbird" )  
4. print fileHandle.read() # "To Kill a Mockingbid"  
5. fileHandle.close()  


import cStringIO 


fileHandle = cStringIO.cStringIO ( "To Kill a Mockingbird" ) 
print fileHandle.read() # "To Kill a Mockingbid" 
fileHandle.close() 


结论 
文件管理，是众多编程语言的程序员在编写应用程序是经常遇到的问题。幸好，和其它语言相比，Python使其出乎意料地容易。Python的标准库中提供了许多相关的模块帮助程序员解决这方面的问题，而它的面向对象的机制也简化了操作。 
好了，现在你已经了解了Python中文件管理的基本知识，可以在今后的应用程序中很好地使用了。 
========

python逐行读取文件内容的三种方法

方法一：
复制代码 代码如下:


f = open("foo.txt")             # 返回一个文件对象  
line = f.readline()             # 调用文件的 readline()方法  
while line:  
    print line,                 # 后面跟 ',' 将忽略换行符  
    # print(line, end = '')　　　# 在 Python 3中使用  
    line = f.readline()  


f.close()  
方法二：
复制代码 代码如下:


for line in open("foo.txt"):  
    print line,  
方法三：
复制代码 代码如下:


f = open("c:\\1.txt","r")  
lines = f.readlines()#读取全部内容  
for line in lines  
    print line  
========

python文件和目录操作方法大全（含实例）

这篇文章主要介绍了python文件和目录的操作方法,简明总结了文件和目录操作中常用的模块、方法,并列举了一个综合实例,


一、python中对文件、文件夹操作时经常用到的os模块和shutil模块常用方法。
1.得到当前工作目录，即当前Python脚本工作的目录路径: os.getcwd()
2.返回指定目录下的所有文件和目录名:os.listdir()
3.函数用来删除一个文件:os.remove()
4.删除多个目录：os.removedirs（r“c：\python”）
5.检验给出的路径是否是一个文件：os.path.isfile()
6.检验给出的路径是否是一个目录：os.path.isdir()
7.判断是否是绝对路径：os.path.isabs()
8.检验给出的路径是否真地存:os.path.exists()
9.返回一个路径的目录名和文件名:os.path.split()     eg os.path.split('/home/swaroop/byte/code/poem.txt') 结果：('/home/swaroop/byte/code', 'poem.txt') 
10.分离扩展名：os.path.splitext()
11.获取路径名：os.path.dirname()
12.获取文件名：os.path.basename()
13.运行shell命令: os.system()
14.读取和设置环境变量:os.getenv() 与os.putenv()
15.给出当前平台使用的行终止符:os.linesep    Windows使用'\r\n'，Linux使用'\n'而Mac使用'\r'
16.指示你正在使用的平台：os.name       对于Windows，它是'nt'，而对于Linux/Unix用户，它是'posix'
17.重命名：os.rename（old， new）
18.创建多级目录：os.makedirs（r“c：\python\test”）
19.创建单个目录：os.mkdir（“test”）
20.获取文件属性：os.stat（file）
21.修改文件权限与时间戳：os.chmod（file）
22.终止当前进程：os.exit（）
23.获取文件大小：os.path.getsize（filename）
二、文件操作方法大全：
1.os.mknod("test.txt")             #创建空文件
2.fp = open("test.txt",w)          #直接打开一个文件，如果文件不存在则创建文件
3.关于open 模式：
复制代码 代码如下:
w：以写方式打开，
a：以追加模式打开 (从 EOF 开始, 必要时创建新文件)
r+：以读写模式打开
w+：以读写模式打开 (参见 w )
a+：以读写模式打开 (参见 a )
rb：以二进制读模式打开
wb：以二进制写模式打开 (参见 w )
ab：以二进制追加模式打开 (参见 a )
rb+：以二进制读写模式打开 (参见 r+ )
wb+：以二进制读写模式打开 (参见 w+ )
ab+：以二进制读写模式打开 (参见 a+ )
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把文件补到相应的大小，也可能是以一些随机的内容加上去。
三、目录操作方法大全
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")                            #换路径
四、文件综合操作实例
将文件夹下所有图片名称加上'_fc'
python代码:
复制代码 代码如下:
# -*- 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按行读文件

1. 最基本的读文件方法：


# File: readline-example-1.py
 
file = open("sample.txt")
 
while 1:
    line = file.readline()
    if not line:
        break
    pass # do something
　　一行一行得从文件读数据，显然比较慢；不过很省内存。


　　在我的机器上读10M的sample.txt文件，每秒大约读32000行


2. 用fileinput模块


# File: readline-example-2.py
 
import fileinput
 
for line in fileinput.input("sample.txt"):
    pass
　　写法简单一些，不过测试以后发现每秒只能读13000行数据，效率比上一种方法慢了两倍多……


3. 带缓存的文件读取


# File: readline-example-3.py
 
file = open("sample.txt")
 
while 1:
    lines = file.readlines(100000)
    if not lines:
        break
    for line in lines:
        pass # do something
　　这个方法真的更好吗？事实证明，用同样的数据测试，它每秒可以读96900行数据！效率是第一种方法的3倍，第二种方法的7倍！


————————————


　　在Python 2.2以后，我们可以直接对一个file对象使用for循环读每行数据：


# File: readline-example-5.py
 
file = open("sample.txt")
 
for line in file:
    pass # do something
　　而在Python 2.1里，你只能用xreadlines迭代器来实现：


# File: readline-example-4.py
 
file = open("sample.txt")
 
for line in file.xreadlines():
    pass # do something
========