1、文件读写

在 Python 中要操作文件需要记住 1 个函数和 3 个方法

函数/方法 说明
open 打开文件，并且返回文件操作对象
read 将文件内容读取到内存
write 将指定内容写入文件
close 关闭文件
  • open 函数负责打开文件，并且返回文件对象
  • read/write/close 三个方法都需要通过 文件对象 来调用

1.1 打开文件

open()函数用于打开一个文件，创建一个 file 对象。
open(文件名，访问模式)
示例如下：

  1. f = open('test.txt', 'w')

说明：

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

1.2 关闭文件

close( )

示例如下：

  1. # 新建一个文件，文件名为:test.txt
  2. f = open('test.txt', 'w')
  4. # 关闭这个文件
  5. f.close()

1.3 with语句

最后一步是调用close()方法关闭文件。文件使用完毕后必须关闭，因为文件对象会占用操作系统的资源，
并且操作系统同一时间能打开的文件数量也是有限的：
f.close()
由于文件读写时都有可能产生IOError，一旦出错，后面的f.close()就不会调用。所以，为了保证无论是否出错都能正确地关闭文件，我们可以使用try ... finally来实现：

  1. try:
  2.     f = open('/path/to/file', 'r')
  3.     print(f.read())
  4. finally:
  5.     if f:
  6.         f.close()

但是每次都这么写实在太繁琐，所以，Python引入了with语句来自动帮我们调用close()方法:

  1. with open('/path/to/file', 'r') as f:
  2.     print(f.read())

这和前面的try ... finally是一样的，但是代码更佳简洁，并且不必调用f.close()方法。

1.4 读数据 (read)

使用read(num)可以从文件中读取数据，num表示要从文件中读取的数据的长度（单位是字节），
如果没有传入num，那么就表示读取文件中所有的数据

demo:

  2. f = open('test.txt', 'r')
  4. content = f.read(5)
  6. print(content)
  8. print("-"*30)
  10. content = f.read()
  12. print(content)
  14. f.close()
  17. Hello
  18. ------------------------------
  19.  world，I am hc!

注意：

  • 如果open是打开一个文件，那么可以不用写打开的模式，即只写 open('test.txt')
  • 如果使用读了多次，那么后面读取的数据是从上次读完后的位置开始的

调用read()会一次性读取文件的全部内容，如果文件有10G，内存就爆了，所以，要保险起见，可以反复调用read(size)方法，每次最多读取size个字节的内容。另外，调用readline()可以每次读取一行内容，调用readlines()一次读取所有内容并按行返回list。因此，要根据需要决定怎么调用。

1.5 写数据(write)

使用write()可以完成向文件写入数据

demo:

  2. f = open('test.txt', 'w')
  3. f.write('hello world, i am here!')
  4. f.close()
  6. #------------------------------------
  7. f = open("output.txt","w+")
  8. ls = ["语雀","文档","写入"]
  9. fo.writelines(ls) # 将列表每个值拼接后一起写入文件
  10. # fo.seek(0)  更改文件指针位置后再逐行遍历
  11. for line in fo:
  12.     print(line) # 当前不会输出任何内容
  13. fo.close

1.6 常用的函数

方法 描述
file.close() 关闭文件。关闭后文件不能再进行读写操作。
file.flush() 刷新文件内部缓冲，直接把内部缓冲区的数据立刻写入文件, 而不是被动的等待输出缓冲区写入。
file.fileno() 返回一个整型的文件描述符(file descriptor FD 整型), 可以用在如os模块的read方法等一些底层操作上。
file.isatty() 如果文件连接到一个终端设备返回 True，否则返回 False。
file.next() 返回文件下一行。
file.read() 从文件读取指定的字节数，如果未给定或为负则读取所有。
file.readline() 读取整行，包括 “\n” 字符。
file.readlines() 读取所有行并返回列表，若给定sizeint>0，返回总和大约为sizeint字节的行, 实际读取值可能比 sizeint 较大, 因为需要填充缓冲区。
file.seek() 设置文件当前位置
file.tell() 返回文件当前位置。
file.truncate() 从文件的首行首字符开始截断，截断文件为 size 个字符，无 size 表示从当前位置截断；截断之后后面的所有字符被删除，其中 Widnows 系统下的换行代表2个字符大小。
file.write() 将字符串写入文件，返回的是写入的字符长度。
file.writelines() 向文件写入一个序列字符串列表，如果需要换行则要自己加入每行的换行符。

2、内存读写

2.1 StringIO

很多时候，数据读写不一定是文件，也可以在内存中读写。
StringIO顾名思义就是在内存中读写str。

要把str写入StringIO，我们需要先创建一个StringIO，然后，像文件一样写入即可：

  2. >>> from io import StringIO
  3. >>> f = StringIO()
  4. >>> f.write('hello')
  5. 5
  6. >>> f.write(' ')
  7. 1
  8. >>> f.write('world!')
  9. 6
  10. >>> print(f.getvalue())
  11. hello world!

getvalue()方法用于获得写入后的str。
要读取StringIO，可以用一个str初始化StringIO，然后，像读文件一样读取：

  1. >>> from io import StringIO
  2. >>> f = StringIO('Hello!\nHi!\nGoodbye!')
  3. >>> while True:
  4. ...     s = f.readline()
  5. ...     if s == '':
  6. ...         break
  7. ...     print(s.strip())
  8. ...
  9. Hello!
  10. Hi!
  11. Goodbye!

2.2 BytesIO

StringIO操作的只能是str，如果要操作二进制数据，就需要使用BytesIO。

BytesIO实现了在内存中读写bytes，我们创建一个BytesIO，然后写入一些bytes：

  1. >>> from io import BytesIO
  2. >>> f = BytesIO()
  3. >>> f.write('中文'.encode('utf-8'))
  4. 6
  5. >>> print(f.getvalue())
  6. b'\xe4\xb8\xad\xe6\x96\x87'

请注意，写入的不是str，而是经过UTF-8编码的bytes。

和StringIO类似，可以用一个bytes初始化BytesIO，然后，像读文件一样读取：

  1. >>> from io import StringIO
  2. >>> f = BytesIO(b'\xe4\xb8\xad\xe6\x96\x87')
  3. >>> f.read()
  4. b'\xe4\xb8\xad\xe6\x96\x87'

3、文件操作

3.1 文件重命名

os模块中的rename()可以完成对文件的重命名操作

rename(需要修改的文件名, 新的文件名)

  1.     import os
  3.     os.rename("语雀文档.txt", "语雀文档-最终版.txt")

3.2 删除文件

os模块中的remove()可以完成对文件的删除操作

remove(待删除的文件名)

  1.     import os
  3.     os.remove("语雀文档.txt")

3.3 文件夹操作

实际开发中，有时需要用程序的方式对文件夹进行一定的操作，比如创建、删除等
就像对文件操作需要os模块一样，如果要操作文件夹，同样需要os模块

3.3.1 创建文件夹

  1.     import os
  3.     os.mkdir("语雀")

3.3.2 获取当前目录

  1.     import os
  3.     os.getcwd()

3.3.3 改变默认目录

  1.     import os
  3.     os.chdir("../")

3.3.4 获取目录列表

  1.     import os
  3.     os.listdir("./")

3.3.5 删除文件夹

  1.     import os
  3.     os.rmdir("张三")