Python文件操作

文件操作方式

方式一

#打开文件，得到文件句柄并赋值给一个变量，默认打开模式就为r，encoding打开编码模式
f = open('d:\文件路径.txt',mode='r',encoding='utf-8')  
content = f.read()  #通过句柄对文件进行操作
print(content)
f.close()  #关闭文件

上面的参数解释：

f: 就是一个变量，一般都会将它写成f,f_obj,file,f_handler,fh,等，它被称作文件句柄。

open：是Python调用的操作系统（windows,linux,等）的功能。

'd:\文件路径.txt': 这个是文件的路径。

mode： 就是定义你的操作方式：r为读模式。

encoding: 不是具体的编码或者解码，他就是声明：此次打开文件使用什么编码本。一般来说：你的文件用什么编码保存的，就用什么方法打开，一般都是用utf-8（有些使用的是gbk）。

f.read():你想操作文件，比如读文件，给文件写内容，等等，都必须通过文件句柄进行操作。

close(): 关闭文件句柄（可以把文件句柄理解成一个空间，这个空间存在内存中，必须要主动关闭）。

方式二

with open() as .... 的形式

# 1,利用with上下文管理这种方式，它会自动关闭文件句柄。
with open('文件',encoding='utf-8') as f1:
    f1.read()
    
# 2，一个with 语句可以操作多个文件，产生多个文件句柄。
with open('文件1',encoding='utf-8') as f1,\
        open('文件2', encoding='utf-8', mode = 'w') as f2:
    f1.read()
    f2.write('啦啦，德玛西亚')

这里要注意一个问题，虽然使用with语句方式打开文件，不用你手动关闭文件句柄，比较省事儿，但是依靠其自动关闭文件句柄，是有一段时间的，这个时间不固定，所以这里就会产生问题，如果你在with语句中通过r模式打开t1文件，那么你在下面又以a模式打开t1文件，此时有可能你第二次打开t1文件时，第一次的文件句柄还没有关闭掉，可能就会出现错误,他的解决方式只能在你第二次打开此文件前，手动关闭上一个文件句柄。

文件的打开模式

mode 参数有：

模式	描述
r	以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb	以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。一般用于非文本文件如图片等。
r+	打开一个文件用于读写。文件指针将会放在文件的开头。
rb+	以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。一般用于非文本文件如图片等。
w	打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb	以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
w+	打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb+	以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
a	打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
ab	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+	打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
ab+	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。

默认为文本模式，如果要以二进制模式打开，加上 b 

文件操作：读

read()：读取所有内容

将文件中的内容全部读取出来;弊端 如果文件很大就会非常的占用内存,容易导致内存奔溃

with open('文件操作的读.txt', encoding='utf-8') as f:
    print(f.read())


结果：
千古绝句最美句子：
1、愿得一心人，白头不相离
2、在天愿作比翼鸟，在地愿为连理枝。
3、东边日出西边雨，道是无晴却有晴。
4、问世间，情为何物，直教生死相许？
5、两情若是久长时，又岂在朝朝暮暮。
6、月上柳梢头，人约黄昏后。
7、金风玉露一相逢，便胜却人间无数。
8、身无彩凤双飞翼，心有灵犀一点通。
9、心似双丝网，中有千千结。

read(n)：n按照字符读取

 读取的时候指定读取到什么位置， 在r模式下,n按照字符读取

with open('文件操作的读.txt', encoding='utf-8') as f:
    print(f.read(15))

结果：
千古绝句最美句子：
1、愿得一

readline()：每次只读取一行

readline()读取每次只读取一行,注意点:readline()读取出来的数据在后面都有一个\n

with open('文件操作的读.txt', encoding='utf-8') as f:
    print(f.readline())
    print(f.readline())
    print(f.readline())

结果：
千古绝句最美句子：

1、愿得一心人，白头不相离

2、在天愿作比翼鸟，在地愿为连理枝。

解决这个问题只需要在我们读取出来的文件后边加一个strip()就OK了

readlines()

readlines() 返回一个列表，列表里面每个元素是原文件的每一行，如果文件很大，占内存，容易崩盘。

with open('文件操作的读.txt', encoding='utf-8') as f:
    print(f.readlines())

#  ['千古绝句最美句子：\n', '1、愿得一心人，白头不相离\n', '2、在天愿作比翼鸟，在地愿为连理枝。\n', '3、东边日出西边雨，道是无晴却有晴。\n', '4、问世间，情为何物，直教生死相许？\n', '5、两情若是久长时，又岂在朝朝暮暮。\n', '6、月上柳梢头，人约黄昏后。\n', '7、金风玉露一相逢，便胜却人间无数。\n', '8、身无彩凤双飞翼，心有灵犀一点通。\n', '9、心似双丝网，中有千千结。\n']

for循环读取

上面这四种都太好，因为如果文件较大，他们很容易撑爆内存，可以通过for循环去读取，文件句柄是一个迭代器，他的特点就是每次循环只在内存中占一行的数据，非常节省内存。

with open('文件操作的读.txt', encoding='utf-8') as f:
    for line in f:
        print(line)  # 这种方式就是在一行一行的进行读取,它就执行了下边的功能

结果：
千古绝句最美句子：

1、愿得一心人，白头不相离

2、在天愿作比翼鸟，在地愿为连理枝。

3、东边日出西边雨，道是无晴却有晴。

4、问世间，情为何物，直教生死相许？

5、两情若是久长时，又岂在朝朝暮暮。

6、月上柳梢头，人约黄昏后。

7、金风玉露一相逢，便胜却人间无数。

8、身无彩凤双飞翼，心有灵犀一点通。

9、心似双丝网，中有千千结。

rb模式读

rb模式：以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。记住下面讲的也是一样，带b的都是以二进制的格式操作文件，他们主要是操作非文字文件：图片，音频，视频等,并且如果你要是带有b的模式操作文件，那么不用声明编码方式。

举例：

 rb模式也有read read(n) readline(),readlines() for循环这几种方法

文件操作：写

write()

w模式

如果文件不存在，利用w模式操作文件，那么它会先创建文件，然后写入内容

如果文件存在，利用w模式操作文件，先清空原文件内容，在写入新内容。

wb模式

wb模式：以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如：图片，音频，视频等。

举例说明：

我先以rb的模式将一个图片的内容以bytes类型全部读取出来，然后在以wb将全部读取出来的数据写入一个新文件，这样我就完成了类似于一个图片复制的流程。具体代码如下：

 文件操作：追加

a模式

打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。

如果文件不存在，利用a模式操作文件，那么它会先创建文件，然后写入内容。

如果文件存在，利用a模式操作文件，那么它会在文件的最后面追加内容。

 文件操作的其他功能

seek(n)：光标操作

seek(n)光标移动到n位置,注意: 移动单位是byte,所有如果是utf-8的中文部分要是3的倍数

通常我们使用seek都是移动到开头或者结尾

移动到开头:seek(0)

移动到结尾:seek(0,2) seek的第二个参数表示的是从哪个位置进行偏移,默认是0,表示开头,1表示当前位置,2表示结尾

with open('文件操作的其他功能.txt', mode='r+', encoding='utf-8') as f:
    f.seek(0)  # 光标移动到开头
    print(f.read())  # 读取内容, 此时光标移动到结尾

    f.seek(0)  # 再次将光标移动到开头
    f.seek(0, 2)  # 将光标移动到结尾
    print(f.read())  # 读取内容. 什么都没有

    f.seek(0)  # 移动到开头
    f.write('啦啦啦')  # 写入信息.

tell()：获取光标位置

使用tell()可以帮我们获取当前光标在什么位置

with open('文件操作的其他功能.txt', mode='r', encoding='utf-8') as f:
    print( f.tell())  # 获取当前光标位置
    f.seek(9)
    print(f.tell())  # 获取当前光标位置,光标位置9

readable()：检查文件是否可读

with open('文件操作的其他功能.txt', mode='r', encoding='utf-8') as f:
    print(f.readable())  # 检查文件是否可读,如果文件是可读的，则 返回 True，否则返回 False。

writeable()：检查文件是否可写

如果使用 "a" 追加或使用 "w" 写入来打开文件，则该文件是可写的。

with open('文件操作的其他功能.txt', mode='r', encoding='utf-8') as f:
    print(f.writable())  # 检查文件是否可写,如果文件可写，则 writable() 方法返回 True，否则返回 False

class TextIOWrapper(_TextIOBase):
    """
    Character and line based layer over a BufferedIOBase object, buffer.
    
    encoding gives the name of the encoding that the stream will be
    decoded or encoded with. It defaults to locale.getpreferredencoding(False).
    
    errors determines the strictness of encoding and decoding (see
    help(codecs.Codec) or the documentation for codecs.register) and
    defaults to "strict".
    
    newline controls how line endings are handled. It can be None, '',
    '\n', '\r', and '\r\n'.  It works as follows:
    
    * On input, if newline is None, universal newlines mode is
      enabled. Lines in the input can end in '\n', '\r', or '\r\n', and
      these are translated into '\n' before being returned to the
      caller. If it is '', universal newline mode is enabled, but line
      endings are returned to the caller untranslated. If it has any of
      the other legal values, input lines are only terminated by the given
      string, and the line ending is returned to the caller untranslated.
    
    * On output, if newline is None, any '\n' characters written are
      translated to the system default line separator, os.linesep. If
      newline is '' or '\n', no translation takes place. If newline is any
      of the other legal values, any '\n' characters written are translated
      to the given string.
    
    If line_buffering is True, a call to flush is implied when a call to
    write contains a newline character.
    """
    def close(self, *args, **kwargs): # real signature unknown
        关闭文件
        pass

    def fileno(self, *args, **kwargs): # real signature unknown
        文件描述符  
        pass

    def flush(self, *args, **kwargs): # real signature unknown
        刷新文件内部缓冲区
        pass

    def isatty(self, *args, **kwargs): # real signature unknown
        判断文件是否是同意tty设备
        pass

    def read(self, *args, **kwargs): # real signature unknown
        读取指定字节数据
        pass

    def readable(self, *args, **kwargs): # real signature unknown
        是否可读
        pass

    def readline(self, *args, **kwargs): # real signature unknown
        仅读取一行数据
        pass

    def seek(self, *args, **kwargs): # real signature unknown
        指定文件中指针位置
        pass

    def seekable(self, *args, **kwargs): # real signature unknown
        指针是否可操作
        pass

    def tell(self, *args, **kwargs): # real signature unknown
        获取指针位置
        pass

    def truncate(self, *args, **kwargs): # real signature unknown
        截断数据，仅保留指定之前数据
        pass

    def writable(self, *args, **kwargs): # real signature unknown
        是否可写
        pass

    def write(self, *args, **kwargs): # real signature unknown
        写内容
        pass

    def __getstate__(self, *args, **kwargs): # real signature unknown
        pass

    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    @staticmethod # known case of __new__
    def __new__(*args, **kwargs): # real signature unknown
        """ Create and return a new object.  See help(type) for accurate signature. """
        pass

    def __next__(self, *args, **kwargs): # real signature unknown
        """ Implement next(self). """
        pass

    def __repr__(self, *args, **kwargs): # real signature unknown
        """ Return repr(self). """
        pass

    buffer = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default

    closed = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default

    encoding = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default

    errors = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default

    line_buffering = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default

    name = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default

    newlines = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default

    _CHUNK_SIZE = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default

    _finalizing = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default