版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/yujin2010good/article/details/78957120
文件处理
Python2建议不要用file， 始终用open。
Python3 已经没有这个file 内置函数了。
file(name[, mode[, buffering]])
open(name[, mode[, buffering]])
说明：
1. 函数功能打开一个文件，返回一个文件读写对象，然后可以对文件进行相应读写操作。
2. file参数表示的需要打开文件的相对路径(当前工作目录)或者一个绝对路径，当传入路径不存在此文件会报错。或者传入文件的句柄。
---------------------------------------
模式 描述
r 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
w 打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
a 打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有
wb 以二进制格式打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
w+ 打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
wb+ 以二进制格式打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
rb 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。
r+ 打开一个文件用于读写。文件指针将会放在文件的开头。
rb+ 以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。
---------------------------------------
打开文件的模式有：
r ，只读模式【默认】
w，只写模式【不可读；不存在则创建；存在则清空内容；】
x， 只写模式【不可读；不存在则创建，存在则报错】
a， 追加模式【可读； 不存在则创建；存在则只追加内容；】
"+" 表示可以同时读写某个文件
r+， 读写【可读，可写】
w+，写读【可读，可写】
x+ ，写读【可读，可写】
a+， 写读【可读，可写】
"b"表示以字节的方式操作
rb 或 r+b
wb 或 w+b
xb 或 w+b
ab 或 a+b
注：以b方式打开时，读取到的内容是字节类型，写入时也需要提供字节类型
--------------------------------------
File对象的属性
一个文件被打开后，你有一个file对象，你可以得到有关该文件的各种信息。
以下是和file对象相关的所有属性的列表：
属性 描述
file.closed 返回true如果文件已被关闭，否则返回false。
file.mode 返回被打开文件的访问模式。
file.name 返回文件的名称。
file.softspace 如果用print输出后，必须跟一个空格符，则返回false。否则返回true。
---------------------------------------
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的内容全部写到文件中(多行一次性写入)。这个函数也只是忠实地写入，不会在每行后面加上任何东西。
f.writelines不会输出换行符。
f.close() #关闭文件。python会在一个文件不用后自动关闭文件，不过这一功能没有保证，最好还是养成自己关闭的习惯。
如果一个文件在关闭后还对其进行操作会产生ValueError
f.closed() #一个保护机制，保证只有一个写。
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把文件补到相应的大小，也可能是以一些随机的内容加上去。
f.encoding #字符集
-----------------------------------------
读写文件是最常见的IO操作。Python内置了读写文件的函数，用法和C是兼容的。
读写文件前，我们先必须了解一下，在磁盘上读写文件的功能都是由操作系统提供的，现代操作系
统不允许普通的程序直接操作磁盘，所以，读写文件就是请求操作系统打开一个文件对象（通常称
为文件描述符），然后，通过操作系统提供的接口从这个文件对象中读取数据（读文件），或者把
数据写入这个文件对象（写文件）。
读文件
例子1：
[root@node01 python]# vi file01.txt
#!/usr/bin/env python
#_*_ coding:utf-8 _*_
import sys
f = file('test.txt','r') #只读方式打开文件
for line in f.readlines(): #循环文件里的每一行
line = line.strip('\n').split(':') # line.strip('\n')去掉换行符，split按:分割成列
print line
[root@node01 python]# python file01.txt
['root', 'x', '0', '0', 'root', '/root', '/bin/bash']
['bin', 'x', '1', '1', 'bin', '/bin', '/sbin/nologin']
['daemon', 'x', '2', '2', 'daemon', '/sbin', '/sbin/nologin']
['adm', 'x', '3', '4', 'adm', '/var/adm', '/sbin/nologin']
['lp', 'x', '4', '7', 'lp', '/var/spool/lpd', '/sbin/nologin']
['sync', 'x', '5', '0', 'sync', '/sbin', '/bin/sync']
['shutdown', 'x', '6', '0', 'shutdown', '/sbin', '/sbin/shutdown']
['halt', 'x', '7', '0', 'halt', '/sbin', '/sbin/halt']
['mail', 'x', '8', '12', 'mail', '/var/spool/mail', '/sbin/nologin']
for line in f.readlines():
print(line.strip()) # 把末尾的'\n'删掉
-----------------------------------------
如果文件不存在，open()函数就会抛出一个IOError的错误，并且给出错误码和详细的信息告诉你文件不存在：
>>> f = file('wolf.txt','r')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IOError: [Errno 2] No such file or directory: 'wolf.txt'
如果文件打开成功，接下来，调用read()方法可以一次读取文件的全部内容，Python把内容读到内存，用一个str对象表示：
>>> f = file('test.txt','r')
>>> f = file('wolf.txt','r')
>>> f = file('wolf.txt','r')
>>> f.readline()
'laolang\n'
>>> f.readline()
'\n'
>>> f.readline()
'wolf\n'
>>> f.readline()
'nannan\n'
>>> f.readline()
'\n'
>>> f.readline()
'\n'
>>> f.readline()
''
>>> f.readline()
最后一步是调用close()方法关闭文件
>>> f.close()
>>>
由于文件读写时都有可能产生IOError，一旦出错，后面的f.close()就不会调用。所以，为了保证无论是否出错都能正确
地关闭文件，我们可以使用try ... finally来实现：
----------------------------------------------
写文件
>>> f = file('wolf.txt','w')
>>> f.write('')
KeyboardInterrupt
>>> f.read()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IOError: File not open for reading
>>> f.write('laolang hello')
>>> f.close()
[root@node01 python]# cat wolf.txt 这里看到之前的内容被清空
laolang hello
>>> file('test.txt', 'w')
<open file 'test.txt', mode 'w' at 0x7f3079da2d20>
>>> file('test.txt', 'w').write('df')
第二次不能在用此，会覆盖之前的
>>> file('test.txt', 'w').write('dfffff') 第二次不能在用此，会覆盖之前的
如下
[root@node1 day2]# ls
test.txt
[root@node1 day2]# cat test.txt
df
[root@node1 day2]# cat test.txt
dfffff
[root@node1 day2]#
正确方法如下
先写入一个文件
>>>
[root@node1 day2]# cat test.txt
[root@node1 day2]#
写入内容，并保存
>>>
>>> f.write('Today weather is go good.\n')
查看
[root@node1 day2]# cat test.txt
[root@node1 day2]# ls
test.txt
写完之后要保存，并保存。
>>> f.close()
[root@node1 day2]# cat test.txt
Today is a good day
Today weather is go good.
再写入报错
>>> f.write('The guy with blue T-shirt, i have no fuckcing idea what are you doning in there.\n')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: I/O operation on closed file
因为文件已经关闭，需要打开才能写入。
>>> f = file('test.txt', 'w')
>>> f.write('The guy with blue T-shirt, i have no fuckcing idea what are you doning in there.\n')
>>> f.close()
在查看，但是之前的内容被覆盖了，因为用w会新建一个文件的意思
[root@node1 day2]# cat test.txt
The guy with blue T-shirt, i have no fuckcing idea what are you doning in there.
强制写入硬盘的方法
1、 f.flush()
2、 f.close()
3、 with open('/etc/passwd') as f: with”语句对 “f” 文件对象调用在Python中称作“上下文管理器”的方法。
也就是说，它指定 “f” 为指向 /etc/passwd 内容的新的文件实例。在 “with” 打开的代码块内，文件是打开的，而且可以自由读取。
然而，一旦Python代码从 “with” 负责的代码段退出，文件会自动关闭。
with open('/etc/passwd') as f:
for line in f:
print(line)
---------------------------------------------
追加
>>> f = file('wolf.txt','a')
>>> f.write('wolf hello')
>>> f.write('nannan hello')
>>> f.write('\nnannan hello')
这时候去看文件
[root@node01 python]# cat wolf.txt
laolang hello
这里发现文件没有写入到文件，因为首先未关闭，如果在未关闭的时候要写入磁盘，必须要大于1024字节，小于的话先存到内存缓冲区。
如果一定要写入磁盘，就强制刷新
>>> f.flush()
laolang hello[root@node01 python]# cat wolf.txt
laolang hellowolf hellonannan hello 没有加\n，不换行
nannan hello
>>> f.read() 追加模式也不能读
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IOError: File not open for reading
---------------------------------------------
readline() 一行一行读 读到内存
tell() 查看指针
read() 全部读
seek() 指针
写入一个文件
[root@node01 python]# cat test.txt
yes
yes
n
>>> f = file('test.txt','r')
>>> f.read()
'\nyes\nyes\nno'
>>> f = file('test.txt','r')
>>> f.readline()
'\n'
>>> f.readline()
'yes\n'
>>> f.readline()
'yes\n'
>>> f.readline()
'no'
>>> f.readline()
''
指针在末尾
>>> f.tell()
11
把指针指向0
>>> f.seek(0)
>>> f.tell()
0
如果想要内容在内存里长期呆着，不然他就丢掉了
方法一赋予变量
>>> f.seek(0)
>>> contents = f.read()
>>> contents
>>> contents
'\nyes\nyes\nno'
取第一行
>>> contents.split('\n')[0]
''
>>> contents.split('\n')[1]
'yes'
方法二 以列表的方法读出来
>>> f.seek(0)
>>> c = f.readlines()
>>> c0
>>> c[0]
'\n'
>>> c[1]
'yes\n'
Python2建议不要用file， 始终用open。
Python3 已经没有这个file 内置函数了。
file(name[, mode[, buffering]])
open(name[, mode[, buffering]])
说明：
1. 函数功能打开一个文件，返回一个文件读写对象，然后可以对文件进行相应读写操作。
2. file参数表示的需要打开文件的相对路径(当前工作目录)或者一个绝对路径，当传入路径不存在此文件会报错。或者传入文件的句柄。
---------------------------------------
模式 描述
r 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
w 打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
a 打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有
wb 以二进制格式打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
w+ 打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
wb+ 以二进制格式打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
rb 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。
r+ 打开一个文件用于读写。文件指针将会放在文件的开头。
rb+ 以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。
---------------------------------------
打开文件的模式有：
r ，只读模式【默认】
w，只写模式【不可读；不存在则创建；存在则清空内容；】
x， 只写模式【不可读；不存在则创建，存在则报错】
a， 追加模式【可读； 不存在则创建；存在则只追加内容；】
"+" 表示可以同时读写某个文件
r+， 读写【可读，可写】
w+，写读【可读，可写】
x+ ，写读【可读，可写】
a+， 写读【可读，可写】
"b"表示以字节的方式操作
rb 或 r+b
wb 或 w+b
xb 或 w+b
ab 或 a+b
注：以b方式打开时，读取到的内容是字节类型，写入时也需要提供字节类型
--------------------------------------
File对象的属性
一个文件被打开后，你有一个file对象，你可以得到有关该文件的各种信息。
以下是和file对象相关的所有属性的列表：
属性 描述
file.closed 返回true如果文件已被关闭，否则返回false。
file.mode 返回被打开文件的访问模式。
file.name 返回文件的名称。
file.softspace 如果用print输出后，必须跟一个空格符，则返回false。否则返回true。
---------------------------------------
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的内容全部写到文件中(多行一次性写入)。这个函数也只是忠实地写入，不会在每行后面加上任何东西。
f.writelines不会输出换行符。
f.close() #关闭文件。python会在一个文件不用后自动关闭文件，不过这一功能没有保证，最好还是养成自己关闭的习惯。
如果一个文件在关闭后还对其进行操作会产生ValueError
f.closed() #一个保护机制，保证只有一个写。
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把文件补到相应的大小，也可能是以一些随机的内容加上去。
f.encoding #字符集
-----------------------------------------
读写文件是最常见的IO操作。Python内置了读写文件的函数，用法和C是兼容的。
读写文件前，我们先必须了解一下，在磁盘上读写文件的功能都是由操作系统提供的，现代操作系
统不允许普通的程序直接操作磁盘，所以，读写文件就是请求操作系统打开一个文件对象（通常称
为文件描述符），然后，通过操作系统提供的接口从这个文件对象中读取数据（读文件），或者把
数据写入这个文件对象（写文件）。
读文件
例子1：
[root@node01 python]# vi file01.txt
#!/usr/bin/env python
#_*_ coding:utf-8 _*_
import sys
f = file('test.txt','r') #只读方式打开文件
for line in f.readlines(): #循环文件里的每一行
line = line.strip('\n').split(':') # line.strip('\n')去掉换行符，split按:分割成列
print line
[root@node01 python]# python file01.txt
['root', 'x', '0', '0', 'root', '/root', '/bin/bash']
['bin', 'x', '1', '1', 'bin', '/bin', '/sbin/nologin']
['daemon', 'x', '2', '2', 'daemon', '/sbin', '/sbin/nologin']
['adm', 'x', '3', '4', 'adm', '/var/adm', '/sbin/nologin']
['lp', 'x', '4', '7', 'lp', '/var/spool/lpd', '/sbin/nologin']
['sync', 'x', '5', '0', 'sync', '/sbin', '/bin/sync']
['shutdown', 'x', '6', '0', 'shutdown', '/sbin', '/sbin/shutdown']
['halt', 'x', '7', '0', 'halt', '/sbin', '/sbin/halt']
['mail', 'x', '8', '12', 'mail', '/var/spool/mail', '/sbin/nologin']
for line in f.readlines():
print(line.strip()) # 把末尾的'\n'删掉
-----------------------------------------
如果文件不存在，open()函数就会抛出一个IOError的错误，并且给出错误码和详细的信息告诉你文件不存在：
>>> f = file('wolf.txt','r')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IOError: [Errno 2] No such file or directory: 'wolf.txt'
如果文件打开成功，接下来，调用read()方法可以一次读取文件的全部内容，Python把内容读到内存，用一个str对象表示：
>>> f = file('test.txt','r')
>>> f = file('wolf.txt','r')
>>> f = file('wolf.txt','r')
>>> f.readline()
'laolang\n'
>>> f.readline()
'\n'
>>> f.readline()
'wolf\n'
>>> f.readline()
'nannan\n'
>>> f.readline()
'\n'
>>> f.readline()
'\n'
>>> f.readline()
''
>>> f.readline()
最后一步是调用close()方法关闭文件
>>> f.close()
>>>
由于文件读写时都有可能产生IOError，一旦出错，后面的f.close()就不会调用。所以，为了保证无论是否出错都能正确
地关闭文件，我们可以使用try ... finally来实现：
----------------------------------------------
写文件
>>> f = file('wolf.txt','w')
>>> f.write('')
KeyboardInterrupt
>>> f.read()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IOError: File not open for reading
>>> f.write('laolang hello')
>>> f.close()
[root@node01 python]# cat wolf.txt 这里看到之前的内容被清空
laolang hello
>>> file('test.txt', 'w')
<open file 'test.txt', mode 'w' at 0x7f3079da2d20>
>>> file('test.txt', 'w').write('df')
第二次不能在用此，会覆盖之前的
>>> file('test.txt', 'w').write('dfffff') 第二次不能在用此，会覆盖之前的
如下
[root@node1 day2]# ls
test.txt
[root@node1 day2]# cat test.txt
df
[root@node1 day2]# cat test.txt
dfffff
[root@node1 day2]#
正确方法如下
先写入一个文件
>>>
[root@node1 day2]# cat test.txt
[root@node1 day2]#
写入内容，并保存
>>>
>>> f.write('Today weather is go good.\n')
查看
[root@node1 day2]# cat test.txt
[root@node1 day2]# ls
test.txt
写完之后要保存，并保存。
>>> f.close()
[root@node1 day2]# cat test.txt
Today is a good day
Today weather is go good.
再写入报错
>>> f.write('The guy with blue T-shirt, i have no fuckcing idea what are you doning in there.\n')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: I/O operation on closed file
因为文件已经关闭，需要打开才能写入。
>>> f = file('test.txt', 'w')
>>> f.write('The guy with blue T-shirt, i have no fuckcing idea what are you doning in there.\n')
>>> f.close()
在查看，但是之前的内容被覆盖了，因为用w会新建一个文件的意思
[root@node1 day2]# cat test.txt
The guy with blue T-shirt, i have no fuckcing idea what are you doning in there.
[root@node1 day2]#
1、 f.flush()
2、 f.close()
3、 with open('/etc/passwd') as f: with”语句对 “f” 文件对象调用在Python中称作“上下文管理器”的方法。
也就是说，它指定 “f” 为指向 /etc/passwd 内容的新的文件实例。在 “with” 打开的代码块内，文件是打开的，而且可以自由读取。
然而，一旦Python代码从 “with” 负责的代码段退出，文件会自动关闭。
with open('/etc/passwd') as f:
for line in f:
print(line)
---------------------------------------------
追加
>>> f = file('wolf.txt','a')
>>> f.write('wolf hello')
>>> f.write('nannan hello')
>>> f.write('\nnannan hello')
这时候去看文件
[root@node01 python]# cat wolf.txt
laolang hello
这里发现文件没有写入到文件，因为首先未关闭，如果在未关闭的时候要写入磁盘，必须要大于1024字节，小于的话先存到内存缓冲区。
如果一定要写入磁盘，就强制刷新
>>> f.flush()
laolang hello[root@node01 python]# cat wolf.txt
laolang hellowolf hellonannan hello 没有加\n，不换行
nannan hello
>>> f.read() 追加模式也不能读
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IOError: File not open for reading
---------------------------------------------
readline() 一行一行读 读到内存
tell() 查看指针
read() 全部读
seek() 指针
写入一个文件
[root@node01 python]# cat test.txt
yes
yes
n
>>> f = file('test.txt','r')
>>> f.read()
'\nyes\nyes\nno'
>>> f = file('test.txt','r')
>>> f.readline()
'\n'
>>> f.readline()
'yes\n'
>>> f.readline()
'yes\n'
>>> f.readline()
'no'
>>> f.readline()
''
指针在末尾
>>> f.tell()
11
把指针指向0
>>> f.seek(0)
>>> f.tell()
0
如果想要内容在内存里长期呆着，不然他就丢掉了
方法一赋予变量
>>> f.seek(0)
>>> contents = f.read()
>>> contents
>>> contents
'\nyes\nyes\nno'
取第一行
>>> contents.split('\n')[0]
''
>>> contents.split('\n')[1]
'yes'
方法二 以列表的方法读出来
>>> f.seek(0)
>>> c = f.readlines()
>>> c0
>>> c[0]
'\n'
>>> c[1]
'yes\n'
----------------------------------------
实时处理日志文件生产环境遇到log特别大的，需要记住当前位置，下一次读取的时候从上一次记录的位置读取，不然log太大，会太慢。
>>> f = open('test.txt','r+') 获得句柄
>>> f.read()
'1\nyes\nyes\nno\n2\n'
[root@node01 python]# echo 7 >>test.txt
>>> f.read()
'7\n'
[root@node01 python]# echo 8 >>test.txt
>>> f.read()
'8\n'
[root@node01 python]# echo dfdf >>test.txt
>>> f.read()
'dfdf\n'