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()<div></div>
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<div></div>
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
========

Python文件操作学习总结相关推荐

python文件操作学习心得
infile= open("E:\\python项目\\test1_5\\tan.txt","r+") print("Name of file: &q ...
Python“文件操作”略知
大家好,今天我们继续聊聊Python中的文件操作. 有一首诗,艾青的"我爱这土地",我们在上学的时候都学过吧,我记得当时老师是要求全文背诵的,时隔这么久,多多少少忘了些,不过有一句 ...
【Python】学习笔记总结3（Python文件操作）
文章目录三.Python文件操作 1.打开`open('文件名','打开模式')` 2.写操作 3.读操作 4.With上下文管理对象小结案例 5.文件定位三.Python文件操作 1.打开o ...
python打开鼠标指定文件夹_学会python文件操作，鼠标好像没用了，学习python第10天...
电影是人类对未来的向往,在<黑客帝国>中,我们看到了一个数字化的社会,而当你学会python文件操作,你也就离你向往的黑客近一点了,用程序来直接影响电脑上的其他文件,只需要几行代码就搞定. ...
python学习笔记：python文件操作与异常处理
1.python文件操作:打开.关闭.读取.写入,合并excel等 1.1创建文件:open()函数打开文件,若文件存在则直接打开:若不存在则创建文件并打开 open('F:/pycodes/cunz ...
python文件操作实验总结,[干货分享]Python文件操作技巧总结
引言小伙伴们,今天给大家讲解一下python程序下的文件操作完整技巧梳理,都是笔者总结的干货.通过本文阅读,不仅可以带来生产力提升,也可以开发小脚本为生活带来乐趣. 首先不知道大家对 ...
Python文件操作与函数目录
文件操作 python文件操作函数 Python函数学习--初步认识 Python函数学习--作用域与嵌套函数 Python函数学习--匿名函数 python内置函数 Python函数学习--递归 ...
不是python文件操作的相关函数_从零开始学Python(七):文件存储I/O流和异常捕捉
这两天在搞小程序开发,耽搁了一下更新的进度,今天补上.一个完整的前端程序肯定离不开数据存储和网络两个模块,今天我们就先来讲讲python中的一种常见数据存储:文件存储!~! 文件存储(I/O操作) 何 ...
Python文件操作-文本文件、二进制文件、csv文件的读取写入、OS、shutil、CSV模块、常用字符编码
Python文件操作文本文件和二进制文件文件操作相关模块 open()创建文件对象文件对象的常用属性和方法 pickle 序列化文本文件读取和写入文本文件写入步骤 write()/write ...

Python文件操作学习总结

Python读写文件

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

Python文件操作读写文件

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

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

Python按行读文件

Python文件操作学习总结相关推荐

最新文章

热门文章