python学习十--文件操作

爱被打了一巴掌 2022-06-02 04:06 173阅读 0赞

文件处理  
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'