python学习（九）文件操作

一.文件操作简介

Python 提供了必要的函数和方法进行默认情况下的文件基本操作。你可以用 file 对象做大部分的文件操作。

1.打开文件：

Python内置了一个打开文件的函数，open()函数，用来打开一个文件，创建一个file对象，然后就可以对该打开的文件做任何你想做的操作。

语法： File_object= open(file_name [, access_mode][, buffering])

file_name：file_name变量是一个包含了你要访问的文件路径及文件名称的字符串值。

access_mode：决定了打开文件的模式， 是只读-r、写入-w、追加-a 等等。这个参数是非强制的，默认文件访问模式为只读（r）。

buffering：如果buffering的值被设置为0，就不会有缓存；如果值为1，访问文件时会缓存行；如果值位大于1的整数，表明了这就是寄存区的缓冲大小；如果取负值，寄存区的缓冲大小则为系统默认。该参数也是非强制性的。

该语句表示返回的File_object是一个指向文件的指针（一个文件对象）。当以只读模式（r）打开一个不存在的文件时，就会报IOError异常（文件不存在），但如果是以写或追加模式（w/a/a+）打开一个不存在的文件时，默认会创建该文件，但如果是所在路径中有目录不存在，也会报IOError异常。

二.打开文件

代码实例1：

#encding=utf-8
fp = open( "c:\\tuan.txt",'w')
print type(fp)
print fp
fp.write("glory road is great!")
fp.close()

代码实例2：

#encding=utf-8
fp = open("c:\\tuan.txt",'r')
print fp.readline()
fp.close()

三.读取带有中文的文件

#encoding=utf-8
import chardet
fp=open("d:\\a.txt","r")
file_content=fp.read()
print chardet.detect(file_content)
print file_content.decode("utf-8").encode("gbk","ignore")
fp.close()

用chardet判断文件类型的应用：

>>> chardet.detect(u"ajaj".encode("utf-8"))

{'confidence': 1.0, 'encoding': 'ascii'}

import chardet
codec=chardet.detect(u'ajaj'.encode("utf-8"))['encoding']
print u'bbbb'.encode("utf-8").decode(codec)

四.打开文件

with 方式打开文件:会默认关闭文件

with open(“c:\\a.txt”,’r’) as f: 
for line in f: 
	print line

五.文件的模式
r：
以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb：
以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。
r+：
打开一个文件用于读写。文件指针将会放在文件的开头。
rb+：
以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。
w：
打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
wb：
以二进制格式打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
w+：
打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
wb+：
以二进制格式打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
a：
打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
ab：
以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+：
打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
ab+：
以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。

六.文件对象

一个文件被打开后，你就会得到一个file对象，然后就可以得到有关该文件的各种信息。

file.closed
返回true如果文件已被关闭，否则返回false。
file.mode
返回被打开文件的访问模式。
file.name
返回文件的名称。
file.softspace
如果用print输出后，是否跟一个空格符，false不打印， true则打印。

fp = open("d:\\test.txt")
print u"文件是否关闭",fp.closed
print u"文件的访问模式",fp.mode
print u"文件名称",fp.name
print u"文件末尾是否强制加空格",fp.softspace
fp.close()

七.文件操作常用方法

1、fileObject.read([size])

size为读取的长度，以byte为单位。如果不指定参数，表示一次性读取全部内容，以字符串形式返回，并且每一行结尾会有一个"\n"符号。

代码示范1：

fp = open("d:\\test.txt",'r')
content = fp.read()
print u"读取的内容如下：",content
fp.close()

代码示范2：

fp = open("d:\\test.txt",'r')
content = fp.read(5)
print u"读取的内容如下：",content
fp.close()

2.fileObject.readline( [size] )
一行，如果给定了size，有可能返回的只是一行的一部分，以字符串的形式返回，并且结尾会有一个换行符"\n"。读完一行，文件操作标记移动到下一行的开头。

fp = open("d:\\test.txt",'r')
content = fp.readline()
print u"读取的内容如下：",content
fp.close()

3.fileObject.readlines( [size] )
把文件每一行作为一个list的一个成员，是一个字符串，并且结尾会有一个换行符"\n"，并返回这个list。

这个函数的内部是通过循环调用readline()来实现的。如果指定了size参数，表示读取文件指定内容的长度，此时就有可能只能读取文件的一部分，并且结尾会有一个换行符"\n"。
指定很小的数字，会不生效，python 默认8k缓存区大小，需要大于8k生效

fp = open("d:\\test.txt",'r')
content = fp.readlines()
print u"读取的内容如下：",content
for i in content:
	print i
fp.close()

小练习：读取一个文件，统计一下文件中有英文单词的行数是多少

fp = open( "d:\\test.txt",'r')  
lineslist= fp.readlines()
fp.close()
line_count=0
for line in lineslist:
    for i in line:
        if (i >='a' and i<='z') or (i>='A' and i<='Z'):
            line_count+=1
            break
print line_count

4.fileObject.write( str )

把str写到文件中，默认是不加换行符的，所以如果想换行的话，得手动加入换行符'\n'。

fp = open( "c:\\test.txt",'w')
fp.write('文件写入测试' + '\n')
#关闭文件
fp.close()

小练习：自定义一个函数，能够做1万次的字符串累加操作，计算一下耗时，将耗时写入到文件中。

import time
def str_concate():
    result=""
    for i in xrange(1000000):
        result+="a"
    return result

start_time = time.time()
str_concate()
end_time = time.time()
result = end_time - start_time
with open("e:\\1.txt","w") as fp:
    fp.write(u"函数执行的结果：".encode("gbk")+str(result)+u"秒".encode("gbk"))

如果想写到html里可以用这个模板：

#encding=utf-8
import time
def str_concate():
    result=""
    for i in xrange(1000000):
        result+="a"
    return result

start_time = time.time()
str_concate()
end_time = time.time()
result = end_time - start_time

content = u"<html><body><h1>函数执行的结果：</h1><b>%s</b></body><html/>" %str(result)
with open("e:\\1.html","w") as fp:
    fp.write(content.encode("gbk"))

5.fileObject.writelines( seq )

把seq（序列）的内容全部写到文件中（多行一次性写入）。也不会自动加入换行符。

testlist=['abc\n','123\n','this is test\n']
fp = open( "d:\\test.txt",'w')  
fp.writelines(testlist)
fp.close()

更多解释： 注意：序列中的内容也必须是 字符串类型的数据，才能成功写入文件。

6.fileObject.close()
File 对象的 close()方法刷新缓冲区里任何还没写入的信息，并关闭该文件，这之后便不能再进行写入。
当一个文件对象的引用被重新指定给另一个文件时，Python 会关闭之前的文件。用 close()方法关闭文件是一个很好的习惯。如果文件关闭后，还对文件进行操作就会产生ValueError错误，但如果不及时关闭文件，有可能产生句柄泄露，丢失数据。

7.fileObject.flush()

该函数是将缓冲区中的内容写入硬盘。

import time
fp = open("D:\\test.txt",'w')
fp.write("1,2,3,4")
fp.flush()

time.sleep(20)

8.fileObject.tell()
返回文件操作标记的当前位置，以文件的开头为基准点。

#encoding=utf-8
#打开文件准备读取
fp = open( "c:\\test.txt",'r')
print u"当前文件操作标记位置为：", fp.tell()
line = fp.readline()
print u"读取一行后文件操作标记位置为：", fp.tell()
#关闭文件
fp.close()

9.fileObject.seek( offset[, from ] )

tell()方法告诉你文件内的当前位置；换句话说，下一次的读写会发生在文件开头这么多字节之后。
seek（offset [,from]）

这是一个文件定位函数，该方法改变当前文件的位置。Offset变量表示要移动的字节数。From变量指定开始移动字节的参考位置。如果from被设为0（默认值），这意味着将文件的开头作为移动字节的参考位置。如果设为1，则使用当前的位置作为参考位置。如果它被设为2，那么该文件的末尾将作为参考位置。
需要注意，如果文件以a或a+的模式打开，每次进行写操作时，文件操作标记会自动返回到文件末尾。

小练习：用r+打开文件，最后追加写一行内容，然后读取打印全文

#encding=utf-8
import time
fp = open("e:\\1.txt","r+")
fp.seek(0,2)
print fp.tell()
fp.write("glorxxxxx")
fp.seek(0,0)
print fp.read()
fp.close()

小练习2：将boy 替换成XXX

#encding=utf-8
import time
fp = open("e:\\1.txt","r+")
content=fp.read()
content=content.replace("boy","xxx")
fp.seek(0,0)
fp.write(content)
fp.close()

10.fileObject.truncate( [size] )

把文件裁成规定的大小，默认的是裁到当前文件操作标记的位置。如果size比文件的大小还要大，依据系统的不同可能是不改变文件，也可能是用0把文件补到相应的大小，也可能是以一些随机的内容加上去。

代码示例：

#encoding=utf-8
# Open a file
fp = open(r"c:\test.txt", "r+")
print "Name of the file: ", fp.name
line = fp.readline()
print "Read Line: %s" % (line)
# Now truncate remaining file.
fp.truncate()
print fp.tell()
# Try to read file now
remainingLine = fp.readline()
print "Read Line: %s" % (remainingLine)
# Close opend file
fp.close()

小练习：每读十行，存到一个新的文件里

#encding=utf-8
fileNo=1
backup_content=""
line_count=0
fp = open("e:\\1.txt","r+")
for line in fp:
   backup_content+=line
   line_count+=1
   if line_count%10==0:
       with open("e:\\backup"+str(fileNo)+".txt","w") as fp2:
           fp2.write(backup_content)
       line_count=0
       backup_content=""
       fileNo+=1 
   
fp.close()

小练习：删除空行：

fp = open(r'test.txt')
aList = []
for item in fp:
if item.strip():
aList.append(item)
fp.close()
fp = open(r'test2.txt','w')
fp.writelines(aList)
fp.close()

11.处理数据文件

题目：

数据分析需求：

每行内容需要生成以每行首年月日为名称的文件，文件内容写入|0|后的所有行内容（也包括|0| ）

算法分析：

遍历每一行，每行取头14个字母

新建文件，文件名为首14个字母，然后把第15字符后的所有字符拷贝到文件中

关闭文件

数据文件：

数据文件：data.log

20160215 000148|0|collect info job start|success|

20160215000153|0|collect info job end|success|resultcode = 0000

20160216000120|0|collect info job start|success|

20160216000121|0|collect info job end|success|resultcode = 0000

20160217000139|0|collect info job start|success|

20160217000143|0|collect info job end|success|resultcode = 0000

fp =open("e:\\data.log")
for line in fp.readlines():
    filename = line[:14]
    content = line[14:]

    with open("e:\\"+filename+".txt","w") as fp2:
        fp2.write(content+"\n")

fp.close()

12.数据的序列化--pickle

Python提供一个标准的模块，称为pickle。pickle模块中两个主要的函数：

dump():接收一个文件句柄和一个数据对象作为参数，把数据对象以特定格式保存到给定的文件里

load():从文件中取出已保存的对象

-- 使用它你可以在一个文件中储存任何Python对象，之后你又可以把它完整无缺地取出来。这被称为持久地储存对象（序列化）。

--cPickle模块，它的功能和pickle模块完全相同，只不过它是用C语言编写的，因此要快得多（比pickle快1000倍），推荐使用。

代码实例1：

import cPickle as p
shoplistfile = 'd:\\test.txt'
shoplist=['apple','mango','carrot']
f = file(shoplistfile,'w')
p.dump(shoplist,f)
f.close()
del shoplist
f = file(shoplistfile)
storelist = p.load(f)
print u"从文件读取的列表对象：",storelist

代码实例2：

import cPickle as p
shoplistfile = 'd:\\test.txt'
shoplist=['apple','mango','carrot']
animallist=['hippo','rabbit']
f = file(shoplistfile,'w')
p.dump(shoplist,f)
p.dump(animallist,f)
f.close()
del shoplist
del animallist
f = file(shoplistfile)
storelist = p.load(f)
animallist = p.load(f)
print storelist
print animallist