文件读写

读写文件（文件是由字节组成的信息，在磁盘永久保存）是最常见的IO操作。文件分为文本文件和二进制文件。文本文件可以使用任何文本编辑器进行编辑，阅读起来比较容易，但对于程序来说却是困难的，需要相应的分析程序来解读，它通常比二进制的文件大，在网络传输方面是个严重问题。而二进制文件占据空间小，程序读起来比较容易，但人为阅读比较困难，在文本编辑器中打开会显示乱码。

文件对象

Python内置了读写文件的函数，用法和C是兼容的。读写文件前，我们先必须了解一下，在磁盘上读写文件的功能都是由操作系统提供的，现代操作系统不允许普通的程序直接操作磁盘。而是通过“管道”来实现文件在磁盘和程序之间的传递，这个管道就是一个文件对象。所以，读写文件本质就是请求操作系统打开一个文件对象（通常称为文件描述符），然后通过操作系统提供的接口从这个文件对象中读取数据（读文件），或者把数据写入这个文件对象（写文件）。文件对象在建立连接时生成，由于信息在磁盘和程序之间移动，文件对象使用计算机主存来存储数据。

       有两种内建函数可以获取文件对象：open和file。他们的用法完全一样。下面以open()为例子讲解。获取一个文件对象（打开文件）的语法如下：

fileObj = open(filename,access_mode='r',buffering=-1)

其中filename要打开文件的路径（可以使用相对路径，相对于当前执行脚本）。access_mode用来标识文件打开的模式，默认为r(只读)。

常用的模式如下表所示：

文件模式                    解释

r                        以只读方式打开

w                        以写方式打开，文件不为空时清空文件;文件不存在时新建文件。

a                        追加模式，没有则创建

r+,w+,a+            以读写模式打开，a+:写在文件末尾，w+:写之前先清空文件内容，r+：写到文件任何位置

r、w、a为打开文件的基本模式，对应着只读、只写、追加模式；此外有b、t、+、U四个字符，可与以上的文件打开模式组合使用，分别表示二进制模式，文本模式，读写模式、通用换行符，根据实际情况组合使用。

其中b表示二进制模式访问，但是对于Linux或者unix系统来说这个模式没有任何意义，因为他们把所有文件都看作二进制文件，包括文本文件。第三个参数不经常用到，标识访问文件的缓冲方式，0代表不缓冲，1代表缓冲一行，-1代表使用系统默认缓冲方式。只要使用系统默认就好。

>>>fp=file("/root/filetest.txt",'w')

>>>dir(fp)

['__class__','__delattr__', '__doc__', '__getattribute__', '__hash__', '__init__','__iter__', '__new__', '__reduce__', '__reduce_ex__', '__repr__','__setattr__', '__str__', 'close', 'closed', 'encoding', 'fileno', 'flush','isatty', 'mode', 'name', 'newlines', 'next', 'read', 'readinto', 'readline','readlines', 'seek', 'softspace', 'tell', 'truncate', 'write', 'writelines','xreadlines']

>>> help(fp.write)

Help on built-in function write:

 

write(...)

   write(str) -> None.  Writestring str to file.

   

   Note that due to buffering, flush() or close() may be needed before

   the file on disk reflects the data written.

如果文件不存在，open()函数就会抛出一个IOError的错误，并且给出错误码和详细的信息告诉你文件不存在。文件使用完毕后必须关闭，因为文件对象会占用操作系统的资源，并且操作系统同一时间能打开的文件数量也是有限的，由于文件读写时都有可能产生IOError，一旦出错，资源很可能得不到释放。如

>>>fp=file('/root/test.txty','r')

Traceback (most recent call last):

 File "", line 1, in

IOError: [Errno 2] No such file ordirectory: '/root/test.txty'

>>> fp

所以为了保证无论是否出错都能正确地关闭文件，我们可以使用try ... finally机制调用close()方法正确关闭（销毁）文件对象，但是每次都这么写实在太繁琐，所以，Python引入了with语句来自动帮我们调用close()方法。如

>>> withopen('/root/test.txty','r') as f:

...     f

...

Traceback (most recent call last):

 File "", line 1, in

IOError: [Errno 2] No such file ordirectory: '/root/test.txty'

>>> f

Traceback (most recent call last):

 File "", line 1, in

NameError: name 'f' is not defined

with语句给被使用到的文件创建了一个上下文环境，with控制块结束时，文件会自动关闭。

python中文件对象是一个迭代器（实现了next方法），这是因为Python的Iterator对象表示的是一个数据流。

>>> from collectionsimport Iterable

>>>

>>>

fp=open("/root/test.txt",'r')

>>>isinstance(fp,Iterable)

True

>>> 

>>>from collections import Iterator

>>>isinstance(fp,Iterator)

True

Python程序和文件之间建立连接后，即创造了所谓的“流”数据。流的一个重要组成部分是缓冲区，它位于主存中。流由操作系统管理，操作系统会确保当迭代需要使用下一行时，改行已经在内存中的缓冲区里，即使用流式传输的操作符每次只（从管道的前一部分）获取它所需要的数据来给出下一条结果。

读方法

python文件对象提供了三个“读”方法read()、readline()和readlines()。每种方法可以接受一个变量以限制每次读取的数据量。如对于一个文件

[root@localhost ~]# cat test.txt

test1 28 apple

test2 23 good

test3 34 bad

test4 26 apple

read() 每次读取整个文件中剩余的内容，它通常用于将读取的文件内容放到一个字符串变量中返回。默认无参数，即不限定返回字节数，如果文件大于可用内存，为了保险起见，可以反复调用read(size)方法，这样每次最多读取size个字节的内容。

>>> withopen('/root/test.txt','r') as fp:

...     retstr=fp.read(4)

...

>>> retstr

'test'

>>> 

readlines()，调用readlines()一次读取所有内容并按行返回一个list，各行内容作为其元素，该列表可以由Python 的for ... in ... 结构进行处理。

>>> withopen('/root/test.txt','r') as fp:

...     retlist=fp.readlines()

...

>>> retlist

['test1 28 apple\n', 'test2 23good\n', 'test3 34 bad\n', 'test4 26 apple\n']

>>> 

readline() 每次只读取一行，通常比readlines()慢得多。仅当没有足够内存可以一次读取整个文件时，才应该使用 readline()。

>>> withopen('/root/test.txt','r') as fp:

...     retstr=fp.readline()

...

>>> retstr

'test1 28 apple\n'

>>> 

因为文件对象是个迭代器，我们可以直接遍历文件对象获取每行，如

>>> fp=open('/root/test.txt','r')

>>> fp.readline()

'test1 28 apple\n'

>>> fp.readline()

'test2 23 good\n'

>>> fp.read()

'test3 34 bad\ntest4 26 apple\n'

>>> 

注意：这三种方法是把每行末尾的'\n'也读进来了，它并不会默认的把'\n'去掉，需要我们手动去掉。

如何读取大文件

如何操作大文件，比如10G一个文件，显然不能使用read()和readlines()，就算你的内存够大，这样一个文件都读取到内存里显然不是一个好办法，太浪费了内存了，另外从磁盘加载到内存页需要时间。是不是可以使用readline()，可以一行行读取，不过读的时候虽然是一行，可是不断的读取到内存最终还是会占用很大内存。

有两种方法可以达到节省内存的目的，要么每次控制读入的量，要么每次从文件对象中按行读入一条，内存占用比较稳定。

第一种方法是使用readlines(sizehint) 函数，通过指定读取的大小，大多数情况下，返回的数据的字节数会稍微比sizehint 指定的值大一点（除最后一次调用readlines(sizehint) 函数的时候）。通常情况下，Python会自动将用户指定的sizehint 的值调整成内部缓存大小的整数倍。

第二种方法是利用文件对象是迭代器的特性，每次读取一行到内存，处理后，然后再读取一行，也就是内存只保留一行。

>>>with open(FILE_PATH,encoding="utf-8", mode="r") asFILE_HANDLER:

# 这里并没有调用文件对象的read方法，此时这里这个文件对象是一个迭代器

 for line in FILE_HANDLER:

                  print(line)

Iterator对象可以被next()函数调用，并不断返回下一个数据，直到没有数据时抛出StopIteration错误。可以把这个数据流看做是一个有序序列，但我们却不能提前知道序列的长度，只能不断通过next()函数实现按需计算下一个数据（只能前进，不能后退），所以Iterator的计算是惰性的，只有在需要返回下一个数据时它才会计算。

>>>fp=open('/root/test.txt','r')

>>>next(fp)

'test128 apple\n'

>>>next(fp)

'test223 good\n'

>>> 

>>> 

Iterator甚至可以表示一个无限大的数据流，例如全体自然数。而使用list是永远不可能存储全体自然数的。迭代器就是以时间换取空间，节省了空间，但是取值时间较长。

写文件

python文件对象提供了两个写方法：write() 和writelines()。

其中，write()方法和read()、readline()方法对应，是将字符串写入到文件中。writelines()方法和readlines()方法对应，也是针对列表的操作。它接收一个字符串列表作为参数，将他们写入到文件中，

写入文件时，换行符不会自动的加入，因此，需要显式的加入换行符。如

>>>with open('/root/test.txt','w') as f:

...     f.write('hello world'+'\n')

...     f.write('my world')

...

>>>f

       查看写入文件

[root@localhost~]# cat test.txt

helloworld

myworld[root@localhost ~]#

我们可以反复调用write()来写入文件，可见为了换行，必需显式的加入换行符。

当我们写文件时，操作系统往往不会立刻把数据写入磁盘，而是放到内存缓存起来，空闲的时候再慢慢写入。只有调用close()方法时，操作系统才保证把没有写入的数据全部写入磁盘。忘记调用close()的后果是数据可能只写了一部分到磁盘，剩下的丢失了。如

>>>fw=open('/root/test.txt','w')         #新创建一个文件对象

>>>fw.write('hello world'+'\n')

>>> 

>>>fr=open('/root/test.txt','r')         #读文件对象

>>>fr.readline()

''

>>>fw.close()

>>>fr.readline()

'helloworld\n'

>>>