Python --文件和输入输出

目录

1， 打开文件

1-1， 文本文件打开模式

1-1-1， 读模式(r)

1-1-2， 写模式(w)

1-1-3， 追加模式(a)

1-1-3， 读写模式(r+)

1-1-3， 读写模式(w+)

1-1-3， 追加模式(a+)

1-2， 二进制文件打开模式

1-2-1， 读模式(rb)

1-2-2， 读写模式(wb)

1-2-3， 追加模式(ab)

1-2-4， 追加模式(rb+)

1-2-5， 追加模式(wb+)

1-2-6， 追加模式(ab+)

2， 文件内建方法

2-1， 从文件读取

2-1-1， 指定长度读取(read)

2-1-2， 读取一行(readline)

2-1-3， 读取多行(readlines)

2-2， 输入到文件

2-2-1， 写入字符串(write)

2-2-2， 列表形式写入(writelines)

2-3， 文件内移动(seek)

2-4， 其他

3， 文件的内建属性

4， 命令行参数      

5， os模块中操作文件常用方法

6， os.path模块的常用方法

7， os模块中垮平台属性

---

1， 打开文件

通过file_object = open(filepath, acess_mode, buffering)， 可打开一个文件

filepath为文件路径、可以是绝对路径或者相对路径

acess_mode为文件打开模式

buffering为访问文件的缓存方式： 0表示不缓存， -1表示使用系统默认缓存机制，默认值， 1表示缓存一行

任何大于1的值代表使用给定的值作为缓冲区大小

1-1， 文本文件打开模式

1-1-1， 读模式(r)

通过设置acess_mode='r'(为r时， 可不写)， 文本文件以读模式打开， 若文件路径不存在，则报错

In [97]: path
Out[97]: 'C:\\Users\\Administrator\\Desktop\\test.txt'

# 读方式打开文件
In [98]: f = open(path, 'r')

# 当文件以读方式打开时，打开方式r可以省略 
In [102]: f = open(path)

In [103]: f.close()

1-1-2， 写模式(w)

通过设置acess_mode='w'， 文本文件以写模式打开， 若文件路径不存在，则新建该文件

若打开文件已存在，则会清空现有文件的内容

In [7]: path1 = r'C:\Users\Administrator\Desktop\1234.txt'

# 写模式打开，若文件存在，则内容会被清空；若文件不存在，则新建；
In [9]: f = open(path1, 'w')

In [10]: f.close()

1-1-3， 追加模式(a)

通过设置acess_mode='a'， 文本文件以追加模式打开， 若文件路径不存在，则新建该文件

若打开文件已存在，则在文件的最后添加新增的内容

In [7]: path1 = r'C:\Users\Administrator\Desktop\1234.txt'

# 以追加模式打开文件
In [11]: f = open(path1, 'a')

In [12]: f.close()

1-1-3， 读写模式(r+)

通过设置acess_mode='r+'， 文本文件以读写模式打开， 若文件路径不存在，则报错

In [23]: path
Out[23]: 'C:\\Users\\Administrator\\Desktop\\123.txt'
In [24]: f = open(path, 'r+')
In [25]: f.close()

# 打开文件不存在时，则会报错
In [26]: f = open(path1, 'r+')
---------------------------------------------------------------------------
FileNotFoundError                         Traceback (most recent call last)
 in 
----> 1 f = open(path1, 'r+')

FileNotFoundError: [Errno 2] No such file or directory: 'C:\\Users\\Administrator\\Desktop\\1234.txt'

1-1-3， 读写模式(w+)

通过设置acess_mode='w+'， 文本文件以读写模式打开， 若文件路径不存在，则新建该文件

若打开文件已存在，则会清空现有文件的内容

In [28]: path1
Out[28]: 'C:\\Users\\Administrator\\Desktop\\1234.txt'
In [29]: f = open(path1, 'w+')

In [31]: f.close()

1-1-3， 追加模式(a+)

通过设置acess_mode='a+'， 文本文件以读写模式打开， 若文件路径不存在，则新建该文件

若打开文件已存在，则在文件的最后添加新增的内容

In [32]: path2
Out[32]: 'C:\\Users\\Administrator\\Desktop\\12345.txt'

In [33]: f = open(path2, 'a+')

In [34]: f.close()

1-2， 二进制文件打开模式

1-2-1， 读模式(rb)

通过设置acess_mode='r'(为r时， 可不写)， 二进制文件以读模式打开， 若文件路径不存在，则报错

In [36]: f = open(path, 'rb')
In [37]: f
Out[37]: <_io.BufferedReader name='C:\\Users\\Administrator\\Desktop\\123.txt'>

In [38]: f.close()

1-2-2， 读写模式(wb)

通过设置acess_mode='wb'，二进制文件以写模式打开， 若文件路径不存在，则新建该文件

若打开文件已存在，则会清空现有文件的内容

In [40]: f = open(path1, 'wb')

In [41]: f
Out[41]: <_io.BufferedWriter name='C:\\Users\\Administrator\\Desktop\\1234.txt'>

In [42]: f.close()

1-2-3， 追加模式(ab)

通过设置acess_mode='ab'， 二进制文件以追加模式打开， 若文件路径不存在，则新建该文件

若打开文件已存在，则在文件的最后添加新增的内容

In [43]: path2
Out[43]: 'C:\\Users\\Administrator\\Desktop\\12345.txt'
In [44]: f = open(path2, 'ab')

In [45]: f
Out[45]: <_io.BufferedWriter name='C:\\Users\\Administrator\\Desktop\\12345.txt'>

In [46]: f.close()

1-2-4， 追加模式(rb+)

通过设置acess_mode='rb+'， 二进制文件以读写模式打开， 若文件路径不存在，则报错

In [48]: path
Out[48]: 'C:\\Users\\Administrator\\Desktop\\123.txt'
In [49]: f = open(path, 'rb+')

In [50]: f
Out[50]: <_io.BufferedRandom name='C:\\Users\\Administrator\\Desktop\\123.txt'>

In [51]: f.close()

# 打开的文件不存在时，会报错
In [53]: f = open(path1, 'rb+')
---------------------------------------------------------------------------
FileNotFoundError                         Traceback (most recent call last)
 in 
----> 1 f = open(path1, 'rb+')

FileNotFoundError: [Errno 2] No such file or directory: 'C:\\Users\\Administrator\\Desktop\\1234.txt'

1-2-5， 追加模式(wb+)

通过设置acess_mode='w+'， 二进制文件以读写模式打开， 若文件路径不存在，则新建该文件

若打开文件已存在，则会清空现有文件的内容

In [54]: path1
Out[54]: 'C:\\Users\\Administrator\\Desktop\\1234.txt'
In [55]: f = open(path1, 'wb+')

In [56]: f
Out[56]: <_io.BufferedRandom name='C:\\Users\\Administrator\\Desktop\\1234.txt'>

In [57]: f.close()

1-2-6， 追加模式(ab+)

通过设置acess_mode='ab+'， 二进制文件以读写模式打开， 若文件路径不存在，则新建该文件

若打开文件已存在，则在文件的最后添加新增的内容

In [58]: path2
Out[58]: 'C:\\Users\\Administrator\\Desktop\\12345.txt'
In [59]: f = open(path2, 'ab+')

In [60]: f
Out[60]: <_io.BufferedRandom name='C:\\Users\\Administrator\\Desktop\\12345.txt'>

In [61]: f.close()

2， 文件内建方法

2-1， 从文件读取

2-1-1， 指定长度读取(read)

通过f.read(size)， 可读取指定size字节字符串， 若没有指定或size为-1，则读取整个文件

In [65]: path
Out[65]: 'C:\\Users\\Administrator\\Desktop\\123.txt'
In [66]: f = open(path)

# 没有给定size，读取整个文件内容
In [67]: f.read()
Out[67]: 'line1\nline2\nline3\nline4'

# 再次读取时，因为上次读取已经在文件末尾，所以这时返回空串
In [68]: f.read()
Out[68]: ''

In [69]: f.close()

In [74]: f = open(path)

# 这里指定size=3， 所以读取了3字符内容
In [75]: f.read(3)
Out[75]: 'lin'

2-1-2， 读取一行(readline)

通过f.readline()， 读取文件一行，包含行结束符，返回一个字符串

In [78]: f = open(path)

# 读取文件一行
In [79]: f.readline()
Out[79]: 'line1\n'

# 再次调用，读取接下来的一行
In [80]: f.readline()
Out[80]: 'line2\n'

In [82]: f.close()

2-1-3， 读取多行(readlines)

通过f.readlines()， 读取剩余的行，返回一个由行组成的列表，包含行结束符

In [84]: f = open(path)

# 通过f.readlines()读取文件剩余行
In [85]: f.readlines()
Out[85]: ['line1\n', 'line2\n', 'line3\n', 'line4']

In [86]: f.close()

2-2， 输入到文件

2-2-1， 写入字符串(write)

通过f.write(str)， 将'str'字符串或二进制数据块，写入到文件中

In [87]: path
Out[87]: 'C:\\Users\\Administrator\\Desktop\\123.txt'

In [88]: f = open(path, 'w')

# 返回写入字符串的长度，单位为字节
In [89]: f.write(path)
Out[89]: 38

# 这里由于缓存的原因，需要关闭文件后，才能看到文件中写入的内容
In [91]: f.close()

2-2-2， 列表形式写入(writelines)

通过f.writelines(列表1)， 接收一个列表，把列表中的所有元素写入到文件中

In [137]: my_list
Out[137]: ['line1\n', 'line2\n', 'line3\n']

In [138]: f = open(path, 'w')

# 将列表的my_list的内容写入到文件句柄f中
In [139]: f.writelines(my_list)

In [140]: f.close()

2-3， 文件内移动(seek)

通过f.seek(offset, whence)， 可以移动文件中的指针位置，offset为偏移量， whence表示文件指针的位置， whence=0表示文件起始、whence=1表示当前位置、whence=2表示文件末尾

通过f.tell()， 可知道文件指针在当前文件中的位置，从文件起始算起，单位为字节

In [189]: f = open(path, 'wb+')
# 注意：以b形式打开的文件，写入内容需要byte形式；否则会报错
In [190]: f.write('test line1\n')
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
 in 
----> 1 f.write('test line1\n')

TypeError: a bytes-like object is required, not 'str'

# 以byte形式写入内容， 将b'test line1\n'写入到文件句柄中
In [191]: f.write(b'test line1\n')
Out[191]: 11

# f.tell()返回文件指针当前位置 
In [192]: f.tell()
Out[192]: 11

In [193]: f.write(b'test line2\n')
Out[193]: 11

In [194]: f.tell()
Out[194]: 22

# 注意：在使用seek移动文件指针时，文件的打开方式需要以二进制(b)的形式
# 文件指针从当前位置，回退11个字节
In [195]: f.seek(-11, 1)
Out[195]: 11

In [196]: f.tell()
Out[196]: 11

In [197]: f.readline()
Out[197]: b'test line2\n'

2-4， 其他

通过f.close()， 可关闭文件，缓存区的内容立即刷新到文件中

通过f.fileno()， 返回一个文件描述符

In [214]: f.fileno()
Out[214]: 5

通过f.flush()， 缓存区的内容立即刷新到文件中

通过f.isatty()， 判读一个设备是否是类tty， 是返回True，否返回False

In [216]: f.isatty()
Out[216]: False

通过f.truncate(size)， 删除文件的内容，若没有指定size， 则删除文件全部的内容

In [236]: f = open(path, 'r+')
In [237]: f.read()
Out[237]: 'test line1\ntest line2\n'

# 注意：使用truncate方法时，文件需要以写方式打开，所以上面用了r+
In [238]: f.truncate()
Out[238]: 22

3， 文件的内建属性

通过f.closed， 返回文件是否被关闭，关闭返回True， 否则返回False

In [240]: f.closed
Out[240]: False

通过f.encoding， 返回文件的编码方式

In [242]: f.encoding
Out[242]: 'cp936'

通过f.mode， 返回文件的打开模式

In [256]: f.mode
Out[256]: 'r+'

通过f.name， 返回文件路径

In [258]: f.name
Out[258]: 'C:\\Users\\Administrator\\Desktop\\123.txt'

4， 命令行参数      

sys模块通过sys.argv属性提供了对命令行参数的访问

import sys

# sys.argv就是命令行参数列表
print("you enterd %s arguments" % len(sys.argv))
print("they are", sys.argv)

C:\Users\Administrator\Desktop>python test_argv.py abc ef 75 haha
you enterd 5 arguments
they are ['test_argv.py', 'abc', 'ef', '75', 'haha']

5， os模块中操作文件常用方法

通过os.remove(path)或os.unlink(path)， 可删除文件，path为文件的绝对路径

# 通过os.remove删除文件
In [300]: os.remove(path1)

# 通过os.unlink删除文件
In [303]: os.unlink(path1)

通过os.rename(src, dst)， 重命名文件或目录；src为原名称，dst为目标名称， srt, dst都为绝对路径

In [297]: path1
Out[297]: 'C:\\Users\\Administrator\\Desktop\\1234.txt'

In [309]: path2
Out[309]: 'C:\\Users\\Administrator\\Desktop\\12345.txt'

# 文件名将会被修改成path2对应的名称
In [310]: os.rename(path1, path2)

# 重命名目录
In [310]: dir_path = r'C:\Users\Administrator\Desktop\test_os'
In [311]: dir_path1 = r'C:\Users\Administrator\Desktop\test_os_1'

# 目录将被重命名为dir_path1对应的名称
# 就算目录下不为空，也可以修改目录
In [312]: os.rename(dir_path, dir_path1)

通过os.renames(old， new)， 能重命名文件或目录，还可以重命名上级目录

In [325]: path1 =  r'C:\Users\Administrator\Desktop\test_os_1\test3.txt'
In [326]: path2 = r'C:\Users\Administrator\Desktop\test_os_2\test33.txt'

# 通过os.renames方法，可以文件名和上层目录一起修改
In [327]: os.renames(path1, path2)


In [328]: path1 =  r'C:\Users\Administrator\Desktop\test_os_2'
In [329]: path2 = r'C:\Users\Administrator\Desktop\test_os_3'
# 仅修改目录
In [330]: os.renames(path1, path2)

通过os.stats(path)， 返回文件或目录的信息

In [331]: os.stat(path2)
Out[331]: os.stat_result(st_mode=16895, st_ino=437130638831648804, st_dev=284134485, st_nlink=1, st_uid=0, st_gid=0, st_size=0, st_atime=1689838092, st_mtime=1689838092, st_ctime=1689838092)

通过os.utime(path, time)， 可更新时间戳，times不设置则更新当前时间为访问和修改时间
times设置是一个 (atime, mtime)元组

# 将文件的访问和修改时间修改为当前的时间戳
In [338]: os.utime(path2)

In [339]: os.stat(path2)
Out[339]: os.stat_result(st_mode=16895, st_ino=437130638831648804, st_dev=284134485, st_nlink=1, st_uid=0, st_gid=0, st_size=0, st_atime=1689838525, st_mtime=1689838525, st_ctime=1689838092)

# 将文件的访问和修改时间修改为指定的时间戳
In [340]: os.utime(path2, (1000000000, 1000000000))

In [341]: os.stat(path2)
Out[341]: os.stat_result(st_mode=16895, st_ino=437130638831648804, st_dev=284134485, st_nlink=1, st_uid=0, st_gid=0, st_size=0, st_atime=1000000000, st_mtime=1000000000, st_ctime=1689838092)

通过os.walk(path)， 遍历指定目录，返回一个生成器，该生成器包含指定目录下所有文件和目录

# 遍历path2目录， 并返回一个生成器
In [363]: os.walk(path2)
Out[363]: 

# 每个元素为：(当前目录， 当前目录子目录列表， 当前目录文件列表)形式的元组， 如
('C:\\Users\\Administrator\\Desktop\\test_os_3', [], ['test33.txt'])
In [364]: for i in os.walk(path2):
     ...:     print(i)
     ...:

通过os.chdir(path)， 修改当前工作目录为path

# 修改当前的工作目录为path2
In [368]: os.chdir(path2)

In [369]: os.getcwd()
Out[369]: 'C:\\Users\\Administrator\\Desktop\\test_os_3'

通过os.listdir(dir)， 列出当前目录中的文件，子目录，以列表形式返回

In [371]: os.listdir(path2)
Out[371]: ['test33.txt']

通过os.getcwd()/os.getcwdb()， 返回当前的工作目录

# 以字符串形式返回
In [373]: os.getcwd()
Out[373]: 'C:\\Users\\Administrator\\Desktop\\test_os_3'

# 以byte形式返回
In [374]: os.getcwdb()
Out[374]: b'C:\\Users\\Administrator\\Desktop\\test_os_3'

通过os.mkdir(目录名)， 创建目录

# 在当前工作目录下创建目录
In [375]: os.mkdir('haha')

# 在当前目录的子目录中创建目录
In [376]: os.mkdir('haha/dasf')

# 指定路径创建目录
os.mkdir(r'C:\\Users\\Administrator\\Desktop\\test_os_1')

通过os.makedirs(path)， 递归创建目录

In [392]: os.makedirs(r'C:\\Users\\Administrator\\Desktop\\test_os_2\1\2')

通过os.rmdir(path)， 删除空目录， 若删除目录不为空，否则会报错

# 删除C:\Users\Administrator\Desktop\test_os_2\1\1这个目录
In [406]: os.rmdir(r'C:\Users\Administrator\Desktop\test_os_2\1\1')

通过os.removedirs(path)， 递归删除目录， 直到上层目录不为空目录位置

# 因为目录：5，1，test_os_2是空目录，所以这些都被删除
# 因为Desktop不是空目录，所以删除到Desktop层为止
In [419]: os.removedirs(r'C:\Users\Administrator\Desktop\test_os_2\1\5')

通过os.acess(path, mode)， 检验权限模式，返回bool值

# mode=os.F_OK:测试是否存在
In [426]: os.access(path, mode=os.F_OK)
Out[426]: True

# mode=os.R_OK:测试是否可读
In [428]: os.access(path, mode=os.R_OK)
Out[428]: True

# mode=os.W_OK:测试是否可写
In [429]: os.access(path, mode=os.W_OK)
Out[429]: True

# mode=os.X_OK：测试是否可读执行
In [430]: os.access(path, mode=os.X_OK)
Out[430]: True

通过os.chmod(path, mode)， 修改文件或目录的权限， 仅适用于unix

# 修改文件的权限为777， mode是八进制
In [445]: os.chmod(path, mode=0O666)

# 查询修改后的文件权限
In [26]: oct(os.stat(path).st_mode)
Out[26]: '0o100666'

In [27]: oct(os.stat(path).st_mode)[-3:]
Out[27]: '666'

通过os.read(fd)， 根据文件描述符读取

# os.O_RDONLY：以只读方式打开文件
In [10]: fd = os.open(path, os.O_RDONLY)

# 设置读取文件的字节数
In [11]: n = 10

# 从文件描述符fd中读取10字节并返回
In [12]: os.read(fd, n)
Out[12]: b'test line1'

# 关闭文件描述符
In [14]: os.close(fd)

通过os.write(fd)， 根据文件描述符写入

# 打开一个文件，没有则创建
In [31]: fd = os.open(path, os.O_WRONLY | os.O_CREAT)

# 写入的数据需要为byte形式
In [33]: data = b'Python 3 os.write example'

# 写入数据
In [34]: os.write(fd, data)
Out[34]: 25

# 关闭文件描述符
In [35]: os.close(fd)

通过os.dup(fd)， 复制文件描述符号

# 1：表示标准输出， 复制标准输出的文件描述符，赋值给fd
In [40]: fd = os.dup(1)

# 向fd中输出byte形式的字符串
In [41]: os.write(fd, b'hello python\n')
hello python
Out[41]: 13

# 关闭文件描述符
In [43]: os.close(fd)

通过os.dup2(fd, fd2)， 将一个文件描述符fd复制到另一个fd2

In [5]: path = r'C:\Users\Administrator\Desktop\123.txt'
In [6]: path1 =  r'C:\Users\Administrator\Desktop\1234.txt'

# os.O_RDWR | os.O_CREAT：以读写模式打开文件，文件不存在，则创建
In [9]: old_fd = os.open(path, os.O_RDWR | os.O_CREAT)

In [10]: new_fd = os.open(path1, os.O_RDWR | os.O_CREAT)

# 复制文件描述符
In [11]: os.dup2(old_fd, new_fd)
Out[11]: 4

# 对new_fd文件描述符的写入，会映射到old_fd中
In [12]: os.write(new_fd, b'hello python123')
Out[12]: 15

In [13]: os.close(old_fd)

In [14]: os.close(new_fd)

6， os.path模块的常用方法

通过os.path.basename(path)， 去掉路径名，返回文件名

In [16]: path
Out[16]: 'C:\\Users\\Administrator\\Desktop\\123.txt'

In [17]: os.path.basename(path)
Out[17]: '123.txt'

通过os.path.dirname(path)， 去掉文件名，返回路径名

In [16]: path
Out[16]: 'C:\\Users\\Administrator\\Desktop\\123.txt'

In [18]: os.path.dirname(path)
Out[18]: 'C:\\Users\\Administrator\\Desktop'

通过os.path.join(dirname, filename)， 将dirname和filename组成一个路径名

In [19]: path
Out[19]: 'C:\\Users\\Administrator\\Desktop\\123.txt'

In [20]: dirname = os.path.dirname(path)

In [21]: filename = os.path.basename(path)

In [22]: os.path.join(dirname, filename)
Out[22]: 'C:\\Users\\Administrator\\Desktop\\123.txt'

通过os.path.split(path)， 返回(路径名，文件名)元组

In [24]: os.path.split(path)
Out[24]: ('C:\\Users\\Administrator\\Desktop', '123.txt')

通过os.path.splitdrive(path)， 返回(磁盘， 磁盘以后的路径)元组

In [23]: path
Out[23]: 'C:\\Users\\Administrator\\Desktop\\123.txt'

In [25]: os.path.splitdrive(path)
Out[25]: ('C:', '\\Users\\Administrator\\Desktop\\123.txt')

通过os.path.splitext(path)， 返回(路径， 文件后缀)元组

In [26]: os.path.splitext(path)
Out[26]: ('C:\\Users\\Administrator\\Desktop\\123', '.txt')

通过os.path.getatime(path)， 返回最近的访问时间戳

In [33]: os.path.getatime(path)
Out[33]: 1689910493.490247

通过os.path.getctime(path)， 返回文件创建时间戳

In [34]: os.path.getctime(path)
Out[34]: 1689668643.0259793

通过os.path.getmtime(path)， 返回文件修改时间戳

In [35]: os.path.getmtime(path)
Out[35]: 1689910493.490247

通过os.path.getsize(path)， 返回文件大小，单位为字节

In [36]: os.path.getsize(path)
Out[36]: 29

通过os.path.exists(path)， 判断文件是否存在，存在返回True，否则返回False

In [38]: os.path.exists(path)
Out[38]: True

通过os.path.isabs(path)， 判断path是否是绝对路径，是返回True，否则返回False

In [41]: os.path.isabs(path)
Out[41]: True

通过os.path.isdir(path)， 判断path是否是一个存在的目录，是返回True，否则返回False

In [42]: os.path.isdir(path)
Out[42]: False

通过os.path.isfile(path)， 判断path是否是一个存在的文件，是返回True，否则返回False

In [43]: os.path.isfile(path)
Out[43]: True

通过os.path.islink(path)， 判断path是否是一个符号链接，是返回True，否则返回False

In [45]: os.path.islink(path)
Out[45]: False

通过os.path.ismount(path)， 判断path是否是一个挂载，是返回True，否则返回False

In [46]: os.path.ismount(path)
Out[46]: False

通过os.path.samefile(path1, path2)， 判断path1，path2是否是同一个文件

In [47]: path
Out[47]: 'C:\\Users\\Administrator\\Desktop\\123.txt'

In [48]: path1
Out[48]: 'C:\\Users\\Administrator\\Desktop\\1234.txt'

In [49]: os.path.samefile(path, path1)
Out[49]: False

7， os模块中垮平台属性

通过os.linesep， 行分割符字符串显示

In [59]: os.linesep
Out[59]: '\r\n'

通过os.sep， 路径分割符字符串显示

In [60]: os.sep
Out[60]: '\\'

通过os.pathsep， 文件路径分割符字符串显示

In [61]: os.pathsep
Out[61]: ';'

通过os.curdir， 当前目录字符串显示

In [62]: os.curdir
Out[62]: '.'

通过os.pardir， 上层目录字符串显示

In [63]: os.pardir
Out[63]: '..'