1. os模块介绍

os 模块是Python 内置的与操作系统中的文件系统相关的模块，该模块依赖于操作系统。通常情况下，如不特别指出，该模块提供的方法、属性在Windows 和UNIX 系统上都是可用的。其中，UNIX 系统包括Linux 和Mac OS X

说明:本章的内容都是以Windows 操作系统为例进行介绍的，所有代码的执行结果也都是在Windows操作系统下显示的。关于UNIX 系统上特有的方法、属性在本章中未列出，如果需要，请查阅Python 的API 文档。本章中介绍的使用os 模块操作文件只是针对一些基本操作，对于高级文件和目录处理，需要使用第11 章介绍的shutil 模块。另外，如果想要操作路径，请使用第10 章介绍的os.path 模块。

用于定位一个文件或者目录的字符串被称为路径。在程序开发时，通常涉及到两种路径：一种是相对路径，另一种是绝对路径。

相对路径

在学习相对路径之前，需要先了解什么是当前工作目录，当前工作目录是指当前文件所在的目录。在Python 中，可以通过os 模块提供的getcwd() 方法获取当前工作目录。例如，在E:\program\Python\Code\demo.py 文件中，编写以下代码：

import os

print(os.getcwd())                                                                                         
# 打印当前目录

执行上面的代码后，将显示以下目录，该目录就是当前工作目录。

E:\program\Python\Code

相对路径是依赖于当前工作目录的。如果在当前工作目录下，有一个名称为message.txt 的文件，那么在打开这个文件时，就可以直接写文件名，这时采用的就是相对路径。message.txt 文件的实际路径就是当前工作目录“E:\program\Python\Code”+ 相对路径“message.txt”，即“E:\program\Python\Code\message.txt”。

如果在当前工作目录下，有一个子目录demo，并且在该子目录下保存着文件message.txt，那么在打开这个文件时就可以写为“demo/message.txt”，代码如下：

with open(“demo/message.txt”) as file:                                                               
# 通过相对路径打开文件

pass

说明:在Python 中，指定文件路径时需要对路径分隔符“\”进行转义，即将路径中的“\”替换为“\”。例如，对于相对路径“demo\message.txt”，需要用“demo\message.txt”代替。另外，也可以将路径分隔符“\”用“/”代替。

说明：在指定文件路径时，也可以在表示路径的字符串前面加上字母r（或R），那么该字符串将原样输出，这时路径中的分隔符就不需要再转义了。例如，上面的代码也可以修改为以下内容：

with open(r”demo\message.txt”) as file:                                                                         
# 通过相对路径打开文件

pass

绝对路径

绝对路径是指文件的实际完整路径，它不依赖于当前工作目录。在Python 中，可以通过os.path模块提供的abspath() 方法获取一个文件的绝对路径。例如，获取相对路径“demo\message.txt”的绝对路径，代码如下：

import os

print(os.path.abspath(r”demo\message.txt”))                                                              
# 打印绝对路径

如果当前工作目录为“E:\program\Python\Code”，则程序运行结果如下：

E:\program\Python\Code\demo\message.txt

使用os 模块

os 模块属于内置模块，不需要安装，直接导入即可使用。在Python 程序中导入os 模块，需要使用import 语句，代码如下：

import os

导入os 模块后，就可以使用该模块提供的属性和方法了。如果不确定该模块都提供了哪些属性和方法，可以使用Python 的内置函数dir() 获取全部的方法列表，代码如下：

import os                                               # 导入文件与操作系统相关模块

print(dir(os))

2. environb属性——获取当前环境变量的值（字节）

environb 属性用于返回以字节表示的当前操作系统的环境变量的值。语法格式如下：

os.environb

参数说明：

返回值：返回字节串，表示当前环境变量的值。

判断当前系统的supports_bytes_environ 属性值是否为真，如果为真，则获取以字节表示的当前系统的环境变量的映射对象并输出；否则输出“当前系统不支持os.environb 属性！”，代码如下：

import os                                          	# 导入文件与操作系统相关模块

if os.supports_bytes_environ:

print(os.environb)                              	# 打印以字节串表示的当前环境变量的映射对象

else:

print(‘当前系统不支持os.environb属性！')

3. environ属性——获取当前环境变量的值（字符串）

environ 属性用于返回以字符串表示的当前操作系统的环境变量的值。语法格式如下：

os.environ

参数说明：

返回值：返回字符串，表示当前环境变量的值。

使用environ 属性获取当前操作系统的环境变量的映射对象，代码如下：

import os                                          		# 导入文件与操作系统相关模块

print(os.environ)                                  		# 打印当前操作系统的环境变量的映射对象

先输出指定环境变量的值，并且应用try…except 语句捕获异常，如果出现异常，说明还没有该环境变量，再创建它，并且输出创建后的环境变量的值，代码如下：

import os                                             	# 导入文件与操作系统相关模块

newvar = ‘JAVA_HOME’                                    # 环境变量名称

try:

print(newvar+’已经存在！值为：')

print(os.environ[newvar])                           	# 打印环境变量的值

except:

os.environ[newvar] = r’C:\Java\jdk1.8.0_181’            # 创建环境变量

print(os.environ[newvar])                           	# 打印环境变量的值

4. _exit()方法——退出指定状态的进程

_exit() 方法用于退出状态为n 的进程。语法格式如下：

os._exit(n)

参数说明：

n ：用于指定状态码。
返回值：无。

使用_exit() 方法重新启动Python Shell，代码如下：

import os                                       # 导入文件与操作系统相关模块

print(‘重新启动前')

os._exit(1)                                     # 重新启动Python Shell

print(‘重新启动后')

5. abort()方法——发送一个程序请求异常终止信号

abort() 方法用于向调用该方法的进程发送一个程序请求异常终止（SIGABRT）信号。语法格式如下：

os.abort()

参数说明：

返回值：无。

说明:在Unix 系统中，默认行为是生成核心转储；在Windows 系统中，该进程立即返回退出代码3。

发送一个程序请求异常终止信号，代码如下：

import os                                                # 导入文件与操作系统的相关模块

os.abort()

6. exec族方法——执行新程序

exec() 方法用于执行一个新程序，取代当前进程。语法格式如下：

语法一：

os.execl(path,arg0,arg1,...)

语法二：

os.execle(path,arg0,arg1,...,env)

语法三：

os.execlp(file,arg0,arg1,...)

语法四：

os.execlpe(file,arg0,arg1,...,env)

语法五：

os.execv(path,args)

语法六：

os.execve(path,args,env)

语法七：

os.execvp(file,args)

语法八：

os.execvpe(file,args,env)

参数说明：

path：用于指定要执行程序的路径。
arg0、arg1 ：字符串表示的路径。
args ：不为空的列表或元组，其元素为字符串表示的路径。
env ：定义新处理的环境变量（将被用来代替当前进程的环境）的映射，可以使用os.environ指定。
file ：用于指定执行程序的文件路径（包括文件名）。
返回值：无。

说明:在上面的语法中，execl()、execle()、execv() 和execve() 方法不会使用环境变量中的path 变量来定位可执行文件，参数path 必须包含适当的绝对路径或相对路径，而execlp()、execlpe()、execvp() 和execvpe() 方法将使用环境变量中的path 定位程序文件的环境变量。

使用execl() 方法打开Windows 系统自带的画图程序，代码如下：

import os                                      			# 导入文件与操作系统的相关模块

os.execv(r’c:/WINDOWS/system32/mspaint.exe’,[‘/’])   	# 执行系统自带的画图程序

说明:运行上面的代码，将打开系统自带的画图程序。

使用execl() 方法打开Windows 系统自带的计算器程序，代码如下：

import os                                                		# 导入文件与操作系统的相关模块

os.execve(r’c:/WINDOWS/system32/calc.exe’,[‘/’] ,os.environ)   	# 执行系统自带的计算器程序

7. fsdecode()方法——对文件系统路径进行解码

fsdecode() 方法用于对Path-like 对象的路径进行解码，以确保获取字符串类型的结果。语法格式如下：

os.fsdecode(filename)

参数说明：

filename：字符串类型的路径。
返回值：返回解码后的路径，在Windows 系统上会返回str字符串类型。

说明:

类路径对象可以是一个表示路径的字符串（str）或者字节（bytes）对象，还可以是一个实现了os.PathLike 协议的对象。一个支持os.PathLike 协议的对象可通过调用os.fspath() 方法转换为字符串或者字节类型的文件系统路径，os.fsdecode() 和os.fsencode() 方法用来获取字符串或者字节类型的结果。
fsdecode() 方法和fsencode() 方法是互逆方法。

定义一个保存文件路径的字符串，然后先应用fsencode() 方法对其进行编码，再对其进行解码，并且分别输出编码和解码后的路径及类型，代码如下：

import os                                  		# 导入文件与操作系统的相关模块

filename = r’C:/cba.txt’                        # 文件绝对路径

encodefn = os.fsencode(filename)              	# 对路径进行编码

print(‘原路径：',filename)                     	# 打印原路径

print(‘编码后的类型：',type(encodefn))            	# 打印编码后的类型

print(‘编码后的路径：',encodefn)                	# 打印编码后的路径

decodefn = os.fsdecode(encodefn)              	# 对编码后的路径进行解码

print(‘解码后的类型：',type(decodefn))        		# 打印解码后的类型

print(‘解码后的路径：',decodefn)                	# 打印解码后的路径

filename1 = r’cba.txt’                         	# 文件相对路径

encodefn = os.fsencode(filename1)             	# 对路径进行编码

print(‘原路径：',filename1)                    	# 打印原路径

print(‘编码后的类型：',type(encodefn))           	# 打印编码后的类型

print(‘编码后的路径：',encodefn)                	# 打印编码后的路径

decodefn = os.fsdecode(encodefn)              	# 对编码后的路径进行解码

print(‘解码后的类型：',type(decodefn))            	# 打印解码后的类型

print(‘解码后的路径：',decodefn)                	# 打印解码后的路径

8. fsencode()方法——对文件系统路径进行编码

fsencode() 方法用于对Path-like 对象的路径进行编码，以确保获取字符串或者字节类型的结果。语法格式如下：

os.fsencode(filename)

参数说明：

filename：字符串类型的路径。
返回值：返回编码后的路径，在Windows 系统上会返回bytes字节类型路径对象。

说明:

Path-like 对象可以是一个表示路径的字符串（str）或者字节（bytes）对象，还可以是一个实现
了os.PathLike 协议的对象。一个支持os.PathLike 协议的对象可通过调用os.fspath() 方法转换为
字符串或者字节类型的文件系统路径，os.fsdecode() 和os.fsencode() 方法用来获得字符串或者字
节类型的结果。
fsencode() 方法和fsdecode() 方法是互逆方法。

定义一个保存文件路径的字符串，然后分别输出该路径、调用fsencode() 方法编码后的路径和编码后的路径类型，代码如下：

import os                                                    		# 导入文件与操作系统相关模块

filename1 = r’C:/cba.txt’                                                                           # 文件绝对路径

print(‘原路径：',filename1)                                     		# 打印原路径

print(‘编码后：',os.fsencode(filename1))                          	# 打印编码后的路径

print(‘编码后的类型：',type(os.fsencode(filename1)))               	# 打印编码后的路径类型

filename2 = ‘cba.txt’                                                                                   # 文件相对路径

print(‘原路径：',filename2)                                     		# 打印原路径

print(‘编码后：',os.fsencode(filename2))                          	# 打印编码后的路径

print(‘编码后的类型：',type(os.fsencode(filename2)))               	# 打印编码后的路径类型

9. fspath()方法——获得路径的文件系统表示形式

fspath() 方法用于返回路径的文件系统表示形式。语法格式如下：

os.fspath(path)

参数说明：

path：文件路径。
返回值：如果传入的path 是str 或bytes 类型的字符串，将原样返回，否则调用__fspath__()方法。如果可以获得一个str 或bytes 类型的对象，则返回该对象，否则抛出TypeError 异常。

使用fspath() 方法将文件路径转换为文件系统的表示形式并且输出，代码如下：

import os                                  		# 导入文件与操作系统相关模块

path1 = r’C:/temp/cba.txt’                      # 文件路径

spath1 = os.fspath(path1)                    	# 获取路径的文件系统表示形式

print(spath1)

path2 = b’C:/temp/cba.txt’                      # 文件路径

spath2 = os.fspath(path2)                    	# 获取路径的文件系统表示形式

print(spath2)

path3 = [‘C:/temp/cba.txt’]                   	# 文件路径

if isinstance(path3, (str, bytes)):           	# 如果输入的路径是str或者bytes对象

spath3 = os.fspath(path3)                		# 获取路径的文件系统表示形式

print(spath3)

else:

print(‘路径不是字符串或者字节对象！')

10. get_exec_path()方法——获取搜索可执行文件的目录列表

get_exec_path() 方法用于返回搜索可执行文件的目录列表。语法格式如下：

os.get_exec_path(env=None)

参数说明：

env ：指定要获取的环境变量，必须是环境变量的字典或none。如果env 为none，将使用os.environ 属性值（即当前环境变量的映射对象）。
返回值：返回系统搜索可执行文件的目录列表。

使用get_exec_path() 方法输出搜索可执行文件的目录列表，代码如下：

import os                                                		# 导入文件与操作系统相关模块

print(‘指定参数为空字典：‘,os.get_exec_path({}))                	# 指定参数为空字典

print(‘不指定参数：‘,os.get_exec_path())                      	# 不指定参数

print(‘指定非空字典：’,os.get_exec_path({‘PATH‘：‘C:\Windows‘})    # 指定参数为非空字典

11. getenv()方法——获取环境变量的值

getenv() 方法用于获取环境变量的值。语法格式如下：

os.getenv(key,default=None)

参数说明：

key ：字符串类型，用于指定要查询的环境变量的键（key），不区分字母大小写。
default：字符串类型。如果指定，当key不存在时，返回该值；如果不指定，默认返回None。
返回值：返回字符串类型。如果指定的key存在，返回环境变量key的变量值，否则返回default参数指定的值。

说明:os.getenv() 方法的作用类似于os.path.expandvars() 方法，都可以获取环境变量的值。

使用getenv() 方法获取已经存在的系统环境变量windir 的值和不存在的环境变量wind1 的值，代码如下：

import os                                             		# 导入文件与操作系统相关模块

print(os.getenv(‘windir’, default=None))                  	# 打印系统环境变量windir的值

print(os.getenv(‘wind1’, default=’未定义该环境变量！'))       	# 打印一个不存在的系统环境变量wind1的值

程序运行结果如下：

C:\WINDOWS

未定义该环境变量！

在计算机中创建系统环境变量JAVA_HOME，它的值为Java 的安装路径。在Java 安装路径的bin 目录下，存在一个jmc.ini 配置文件，下面将获取该文件的完整路径，代码如下：

import os                                                		# 导入文件与操作系统相关模块

path = os.path.join(os.getenv(‘JAVA_HOME’), r’bin\jmc.ini’)     # 组合配置文件的完整路径

print(path)                                                  	# 打印路径

程序运行结果如下：

C:\Java\jdk1.7.0_75\bin\jmc.ini

注意:在使用IDLE 或者PyCharm 等开发工具编写代码时，配置或者修改环境变量的值后，需要重新启动相应的开发工具，才能获取最新的环境变量信息。

12. getlogin()方法——获取系统的登录用户名

getlogin() 方法用于返回当前系统的登录用户名。语法格式如下：

os.getlogin()

参数说明：

返回值：返回当前系统的登录用户名。

使用getlogin() 方法输出当前系统的登录用户名，代码如下：

import os                                      		# 导入文件与操作系统相关模块

print(os.getlogin( ))                           	# 打印当前系统的登录用户名

13. getpid()方法——获取当前进程ID

getpid() 方法用于获取当前进程ID。语法格式如下：

os.getpid()

参数说明：

返回值：返回当前进程ID。

使用getpid() 方法获取当前的进程ID，代码如下：

import os                               	# 导入文件与操作系统相关模块

print(os.getpid( ))                      	# 打印当前进程ID

14. getppid()方法——获取父进程ID

getppid() 方法用于获取父进程ID。语法格式如下：

os.getppid()

参数说明：

返回值：返回当前进程的父进程ID。当父进程已经结束，在Unix 系统中返回的ID 是初始进程（1）中的一个；在Windows 系统中仍然是同一个进程ID，该进程ID 有可能已经被运行进程所占用。

使用getppid() 方法获取父进程ID，代码如下：

import os                           		# 导入文件与操作系统相关模块

print(os.getppid( ))                 		# 打印父进程ID

15. kill()方法——杀死进程

kill() 方法用于杀死进程，并且将sig 作为退出代码。语法格式如下：

os.kill(pid,sig)

参数说明：

pid：用于指定当前进程ID，可以使用os.getpid() 方法获取。
sig：用于指定退出代码。
返回值：无。

使用kill() 方法杀死当前进程，并将9 作为退出代码，代码如下：

import os                 		# 导入文件与操作系统相关模块

os.kill(os.getpid(),9)     		# 杀死当前进程

16. popen()方法——打开文件

popen() 方法用于打开cmd 命令或使用cmd 命令在子进程中打开文件。语法格式如下：

os.popen(cmd,mode='r',buffering=-1)

参数说明：

cmd：表示要执行的CMD命令或者要通过CMD命令打开的文件路径。
mode：可选参数，用于指定文件的打开模式，其参数值如表1所示。默认的打开模式为只读（即r）。

在这里插入图片描述

buffering ：可选参数，用于指定读写文件的缓冲模式。值为0 表示不缓存；值为1 表示缓存；如果大于1，则表示缓冲区的大小。默认为缓存模式。
返回值：返回os._wrap_close对象。

采用系统默认的编辑器打开文本文件、图片文件、Word 文件和PDF 文件，代码如下：

import os                                  			# 导入文件与操作系统相关模块

print(os.popen(r’e:/mot.txt’,’r’))              	# 采用系统默认的编辑器打开文本文件

print(os.popen(r’e:/qrcode.png’,’r’))               # 采用系统默认的编辑器打开图片文件

print(os.popen(r’e:/第1章 初识Python.docx’,’r’)) 	# 采用系统默认的编辑器打开Word文件

print(os.popen(r’e:/零基础学Python.pdf’,’r’))    	# 采用系统默认的编辑器打开PDF文件

17. startf ile()方法——使用关联的应用程序启动文件

startfile() 方法用于使用关联的应用程序启动文件。语法格式如下：

os.startfile(path[,operation])

参数说明：

path：表示要启动文件的路径。
operation：可选参数。如果未指定，则相当于在Windows 资源管理器中双击该文件，或者将文件名作为参数提供给交互式Shell 的start 命令中，文件将以关联的应用程序打开；否则必须是一个“命令动词”，用来指定对文件做什么。常见动词有print 和edit（要在文件中使用），以及explore 和find（要在目录中使用）。
返回值：无。

使用系统默认的程序打开文本文件、图片文件、Word 文件和PDF 文件，代码如下：

import os                               		# 导入文件与操作系统相关模块

os.startfile(r’e:/mot.txt’)               		# 采用系统默认的编辑器打开文本文件

os.startfile(r’e:/qrcode.png’)             		# 采用系统默认的编辑器打开图片文件

os.startfile(r’e:/第1章 初识Python.docx’)    	# 采用系统默认的编辑器打开Word文件

os.startfile(r’e:/零基础学Python.pdf’)       	# 采用系统默认的编辑器打开PDF文件

说明:运行上面的代码，将采用系统默认的编辑器打开各个文件。

应用input() 函数输入要打开的应用程序名称，然后在if 语句中使用startfile() 方法打开相应的应用程序，代码如下：

import os 																# 导入文件与操作系统相关模块

project = input(‘请输入要打开的应用程序名称(如Word、MediaPlayer等)：')

if project.lower() == 'mediaplayer':

os.startfile(r’C:\Program Files\Windows Media Player\wmplayer.exe’)		# 打开Media Player

elif project.lower() == 'word':

os.startfile(r’C:\Program Files\Microsoft Office\Office16\WINWORD.EXE’)	# 打开Word

elif project.lower() == 'excel':

os.startfile(r’C:\Program Files\Microsoft Office\Office16\EXCEL.EXE’) 	# 打开Excel

else:

print(‘没有找到相应的程序！')

18. strerror()方法——根据错误码返回错误信息

strerror() 方法用于根据指定的错误码返回错误信息。语法格式如下：

os.strerror(code)

参数说明：

code：表示一个整数值，用于指定错误码。
返回值：返回字符串类型的错误信息。如果输入未知错误码，则返回Unknown error 异常。

说明:在某些平台上，当给出未知错误码时，strerror() 方法将返回NULL 并会引发ValueError 异常。

使用strerror() 方法输出错误码2 和10 对应的错误信息，代码如下：

import os                                         		# 导入文件与操作系统相关模块

print(‘错误码 2对应的错误信息：',os.strerror(2))         	# 错误码2对应的错误信息

print(‘错误码 10对应的错误信息：',os.strerror(10))       	# 错误码10对应的错误信息

no = int(input(‘请输入错误码：'))                      	# 输入错误码

print(‘错误码%d对应的错误信息：%s’%(no,os.strerror(no))) 	# 获取并打印输入的错误码对应的错误信息

19. supports_bytes_environ属性——判断原生环境类型是否为字节型

supports_bytes_environ 属性用于获取操作系统中的原生环境类型是否为字节型。语法格式如下：

os.supports_bytes_environ

参数说明：

返回值：如果操作系统的原生环境类型为字节型，则返回True，否则返回False。Windows 系统返回False。

使用supports_bytes_environ 属性判断当前系统的原生环境类型是否为字节型，代码如下：

import os 			# 导入文件与操作系统相关模块

print(‘当前系统的原生环境类型是否为字节型：',os.supports_bytes_environ)

20. system()方法——在子Shell中执行字符串命令

system() 方法用于在子Shell 中执行字符串命令。语法格式如下：

os.system(command)

参数说明：

command：表示字符串，用于指定要执行的命令。
返回值：返回运行命令后系统Shell返回的值。其中值为0表示成功，为1表示失败，为2表示错误。

在CMD 命令行窗口中执行打开文件命令，使用系统自带的记事本程序打开“e:/mr/wgh/test.txt”文件，代码如下：

import os                             		# 导入文件与操作系统相关模块

print(os.system(r’e:/mr/wgh/test.txt’))   	# 打开test.txt文件

说明:运行上面的代码，将在CMD 命令行窗口中执行打开文件命令，从而使用系统自带的记事本程序打开test.txt 文件。

应用input() 函数输入要打开的CMD 命令，然后在if 语句中使用system() 方法执行相应的命令，代码如下：

import os                             	# 导入文件与操作系统相关模块

project = input(‘请输入要执行的CMD命令(如osk、calc、eudcedit、mmc等)：')

try:

os.startfile(project)               	# 执行相应的CMD命令

except:

print(‘不是有效的CMD命令！')

21. times()方法——返回当前的全局进程时间

times() 方法用于返回当前的全局进程时间。语法格式如下：

os.times()

参数说明：

返回值：返回times_result对象，用于记录当前的全局进程时间。其中包括如表2所示的5个属性。

使用times() 方法获取当前的全局进程时间并输出，代码如下：

import os                    	# 导入文件与操作系统相关模块

times = os.times()            	# 获取当前的全局进程时间

print(times)                 	# 打印当前的全局进程时间

print(‘用户时间：',times.user)

print(‘系统时间：',times.system)

print(‘所有子进程的用户时间：',times.children_user)

22. umask()方法——设置用户创建文件的默认权限

umask() 方法用于设置用户创建文件的默认权限掩码，并返回原来的权限掩码。语法格式如下：

os.umask(mask)

参数说明：

mask：表示指定数值类型的权限掩码。默认为0，表示没有任何权限；设置为0o777，表示拥有所有权限。
返回值：返回原来的权限掩码。

使用umask() 方法设置用户创建文件的默认权限为所有权限，并且输出设置之前的权限，代码如下：

import os                    	# 导入文件与操作系统相关模块

mask = 0o777                 	# 要设置的权限为八进制数777

previous = os.umask(mask)      	# 设置为所有权限

print(‘原来的权限：',previous)   	# 打印原来的权限

print(‘现在的权限：',mask)       	# 打印现在的权限

程序运行结果如下：

原来的权限： 0

现在的权限： 511

使用umask() 方法设置用户创建文件的默认权限，再恢复为默认权限，代码如下：

import os      		# 导入文件与操作系统相关模块

os.umask(0o22) 		# 设置权限

os.umask(0)    		# 设置为默认

23. access()方法——测试对路径的访问权限

access() 方法用于测试对路径的访问权限。语法格式如下：

os.access(path,mode,*,dir_fd=None,effective_ids=False,follow_symlinks=True)

参数说明：

path：用于指定文件路径。
mode：用于指定测试权限。指定为os.F_OK，表示测试路径是否存在；指定为os.X_OK，表示测试路径是否可执行；指定为os.W_OK，表示测试路径是否可写；指定为os.R_OK，表示测试路径是否可读。
dir_fd ：表示指定打开文件描述符的路径。默认值为None。
effective_ids：表示是否使用有效的IDS，如果为True，access()将使用有效的uid/gid而不是真实的uid/gid 执行其访问检查。如果想检查当前平台是否支持effective_ids，可用os.supports_effective_ids 获取。如果它不可用，使用它会引发一个NotImplementedError 异常。
follow_symlinks：表示是否跟踪符号链接，是一个布尔值。如果为False，并且要操作的路径的最后一个元素是符号链接，则该方法将对符号链接本身而不是链接指向的文件进行操作。可以使用os.supports_follow_symlinks 检查平台是否支持follow_symlinks，如果不支持，使用它会引发一个NotImplementedError 异常。
返回值：返回布尔值，返回True 表示拥有权限；返回False表示没有权限。

测试指定路径是否存在以及对此路径是否拥有执行权限、写权限、读权限等，并输出相应的结果，代码如下：

import os                                         			# 导入文件与操作系统相关模块

print(‘路径是否存在：', os.access(r’test.txt’, os.F_OK)) 		# 测试路径是否存在

print(‘路径是否可执行：', os.access(r’test.txt’, os.X_OK)) 	# 测试路径是否可执行

print(‘路径是否可写：', os.access(r’test.txt’, os.W_OK)) 		# 测试路径是否可写

print(‘路径是否可读：', os.access(r’test.txt’, os.R_OK)) 		# 测试路径是否可读

24. chdir()方法——更改当前工作目录

chdir() 方法用于更改当前工作目录为指定的路径。语法格式如下：

os.chdir(path)

参数说明：

path：用于指定文件路径。
返回值：无。

使用chdir() 方法将当前工作目录更改到E 盘根目录下，代码如下：

import os       		# 导入文件与操作系统相关模块

print(‘更改前的当前工作目录：',os.getcwd())

os.chdir(r’E:/’) 		# 将当前工作目录更改到E盘根目录

print(‘更改后的当前工作目录：',os.getcwd())

25. chmod()方法——更改路径的权限

chmod() 方法用于将路径模式更改为数值控制模式，即用于更改路径的权限。语法格式如下：

os.chmod(path,mode,*,dir_fd=None,follow_symlinks=True)

参数说明：

path：用于指定文件路径。
mode：用于指定模式。指定为stat.S_IWRITE，表示写权限；指定为stat.S_IREAD，表示读权限。

在这里插入图片描述

dir_fd ：指定打开文件描述符的路径。默认值为None。
follow_symlinks：表示是否跟踪符号链接，是一个布尔值。如果为False，并且要操作的路径的最后一个元素是符号链接，则该方法将对符号链接本身而不是链接指向的文件进行操作。
返回值：无。

在Windows 系统中，使用chmod() 方法将路径模式更改为写模式，代码如下：

import os                           		# 导入文件与操作系统相关模块

import stat                         		# 导入stat模块

os.chmod(r’cba.txt’, stat.S_IWRITE)     	# 将路径模式更改为写模式

26. close()方法——关闭打开的文件描述符

close() 方法用于关闭打开的文件描述符。语法格式如下：

os.close(fd)

参数说明：

fd ：表示打开的文件描述符，也就是通过os.open() 或者pipe() 方法返回的对象。
返回值：无。

注意:该功能适用于低级I/O 操作，必须用于os.open() 或pipe() 方法返回的文件描述符。若关闭由内置函数open()、popen() 或fdopen() 方法返回的文件对象，则需要使用其相应的close() 方法。

使用open() 方法打开一个文件描述对象，然后再应用close() 方法关闭，代码如下：

import os                                      		# 导入文件与操作系统相关模块

fd = os.open(r’test.txt’,os.O_RDONLY)              	# 导入打开文件描述符

os.close(fd)                                   		# 导入关闭文件描述符

27. closerange()方法——关闭连续多个文件描述符

closerange() 方法用于关闭连接的多个文件描述符，即从fd_low（包括）到fd_high（排除）间的文件描述符，并且忽略错误。语法格式如下：

os.closerange(fd_low,fd_high)

参数说明：

fd_low ：整数，用于指定要关闭的文件描述符的起点，包括该值。
fd_high ：整数，用于指定要关闭的文件描述符的结束点，不包括该值。
返回值：无。

使用closerange() 方法关闭从1~5 的文件描述符，代码如下：

import os             		# 导入文件与操作系统相关模块

os.closerange(1, 6)    		# 关闭从1~5的文件描述符

28. device_encoding()方法——返回设备编码

device_encoding() 方法用于在连接到终端时，返回一个与文件描述符关联的设备编码；如果没有连接到终端，则返回None。语法格式如下：

os.device_encoding(fd)

参数说明：

fd ：表示打开的文件描述符。
返回值：如果连接到终端，则返回一个与文件描述符关联的设备编码，否则返回None。

打开一个文件描述符，并且获取与文件描述符关联的设备编码，代码如下：

import os                           		# 导入文件与操作系统相关模块

fd = os.open(r’test.txt’,os.O_RDONLY)   	# 打开文件描述符

print(os.device_encoding(fd) )        		# 返回设备描述字符

在Windows 10 操作系统中运行，由于未连接到终端，所以程序运行结果如下：

None

说明:在Linux 系统中，可以使用os 模块的openpty() 方法打开一个伪终端，然后连接到该伪终端获取设备编码，代码如下：

import os                                      		# 导入文件与操作系统相关模块

fd = os.open(r’test.txt’,os.O_RDWR | os.O_CREAT)    # 打开文件描述符

print(os.device_encoding(fd) )                   	# 返回设备编码

master, slave = os.openpty()                     	# 打开一个伪终端（在Windows系统上不支持该语句）

print(‘设备编码:’, os.device_encoding(master))      	# 重新获取设备编码

29. dup()方法——返回一个文件描述符的副本

dup() 方法用于返回一个文件描述符的副本，该文件描述符的副本是不可继承的。语法格式如下：

os.dup(fd)

参数说明：

fd ：表示打开的文件描述符，也就是通过os.open() 或者pipe() 方法返回的对象。
返回值：返回一个新的文件描述符。

打开一个文件描述符，再使用dup() 方法创建它的副本，代码如下：

import os                               		# 导入文件与操作系统相关模块

fd = os.open(r’test.txt’,os.O_RDONLY)       	# 打开文件描述符

print(‘原fd对象：',fd)

fd2 = os.dup(fd)

print(‘生成的副本：',fd2)

30. dup2()方法——复制文件描述符

dup2() 方法用于将文件描述符fd 复制为fd2，并返回fd2。新的文件描述符默认是可继承的，只

有在inheritable 的值为False 时，才不可继承。语法格式如下：

os.dup2(fd,fd2,inheritable=True)

参数说明：

fd ：表示打开的文件描述符，也就是通过os.open() 或者pipe() 方法返回的对象。
fd2 ：表示复制后的文件描述符。
inheritable：表示指定是否可继承。默认值为True，可继承；值为False时，不可继承。
返回值：从Python 3.7 开始，成功时返回fd2，在之前的版本中，总是返回None。

打开两个文件描述符，并且使用dup2() 方法复制第一个文件描述符为第二个文件描述符，代码如下：

import os                                		# 导入文件与操作系统相关模块

fd = os.open(r’test.txt’,os.O_RDONLY)        	# 打开文件描述符

print(‘fd：',os.fstat(fd))                  	# 打印fd的状态

fd2 = os.open(r’temp.py’,os.O_CREAT)         	# 打开文件描述符

print(‘fd2：',os.fstat(fd2))                	# 打印fd2的状态

print(os.dup2(fd,fd2) )                    		# 复制文件描述符

print(‘fd2：',os.fstat(fd2))                	# 打印复制后的fd2的状态

打开两个文件描述符，并且读取它们的文件内容，然后使用dup2() 方法复制第一个文件描述符为第二个文件描述符，再次读取第二个文件描述符的文件内容，代码如下：

import os                                  		# 导入文件与操作系统相关模块

fd = os.open(r’test.txt’,os.O_RDONLY)          	# 打开文件描述符

print(‘fd：',os.read(fd,100).decode(‘gbk’))    	# 读取fd中的文件内容

fd2 = os.open(r’lift.txt’,os.O_CREAT)          	# 打开文件描述符

print(‘fd2：',os.read(fd2,100).decode(‘gbk’)) 	# 读取fd2中的文件内容

os.dup2(fd,fd2)                             	# 复制文件描述符

os.lseek(fd2,0,0)                           	# 定义到文件开始

print(‘复制后再次读取fd2：',os.read(fd2,100).decode(‘gbk’))       		# 读取fd2中的文件内容

os.closerange(fd,fd2)                       	# 关闭原fd对象和其副本

31. fdopen()方法——返回文件描述符对应的文件对象

fdopen() 方法用于返回打开的文件描述符对应的文件对象。它类似于内置函数open()，二者接受同样的参数。不同之处在于fdopen() 方法的第一个参数应该为整数。语法格式如下：

os.fdopen(fd,*args,**kwargs)

参数说明：

fd ：表示打开的文件描述符。可以通过os.open() 方法创建。
*args ：可选参数，用于指定打开模式，其参数值如表4所示。默认的打开模式为只读（即r）。
**kwargs：可选参数，用于指定读写文件的缓冲模式。值为0表示不缓存，值为1表示缓存，如果大于1，则表示缓冲区的大小。默认为缓存模式。

通过fdopen() 方法获取文件对象，并且调用文件对象的tell() 方法、write() 方法、flush() 方法和close() 方法向文件中写入内容后，再读取并显示，代码如下：

import os                                  		# 导入文件与操作系统相关模块

fd = os.open(r’test.txt’,os.O_RDWR)            	# 打开文件描述符

print(fd)                                  		# 输出文件描述对象

f = os.fdopen(fd,’w+’)                       	# 返回文件描述对象所对应的文件对象

print(‘文件对象：',f)

print(‘当前输入点：',f.tell())                 	# 当前输入点的位置

f.write(‘愿你的青春不负梦想！')                 	# 写入内容到文件

f.flush()                                  		# 输出缓冲区

os.lseek(fd,0,0)                            	# 定义到文件开始

content = os.read(fd,100)                    	# 读取前100个字符

print(content)

print(content.decode(‘gbk’))                  	# 转为GBK编码输出

f.close()                                  		# 关闭文件对象

32. fstat()方法——获取文件描述符的状态

fstat() 方法用于获取文件描述符fd 的状态.。语法格式如下：

os.fstat(fd)

参数说明：

fd ：表示打开的文件描述符，也就是通过os.open() 或者pipe() 方法返回的对象。
返回值：返回os.stat_result对象，用于表示文件描述符的状态。

说明:从Python 3.3 开始，os.fstat() 方法等价于os.stat() 方法。

打开一个文件描述符，再使用fstat() 方法输出该文件描述符的状态信息，代码如下：

import os                                             		# 导入文件与操作系统相关模块

fd = os.open(r’test.txt’,os.O_RDONLY)                     	# 打开文件描述符

print(‘通过os.open()方法打开的文件描述符：\n’,os.fstat(fd))   	# 打印文件描述符的状态

r,w = os.pipe()                                       		# 创建管道

print(‘通过os.pipe()方法打开的文件描述符：\n’,os.fstat(r))    	# 打印文件描述符的状态

33. fsync()方法——强制将文件描述符文件写入磁盘

fsync() 方法用于强制将文件描述符文件写入磁盘。语法格式如下：

os.fsync(fd)

参数说明：

fd ：表示打开的文件描述符，也就是通过os.open() 方法返回的对象。
返回值：无。

打开一个文件对应的文件描述符，并且向该文件中写入文本内容，再强制将其写入磁盘，代码如下：

import os                                  		# 文件与操作系统相关模块

fd = os.open(r’test.txt’,os.O_RDWR)            	# 打开文件描述符

os.write(fd,’愿你的青春不负梦想！'.encode())     	# 向文件中写入文字，将替换原文件的内容

os.fsync(fd)                               		# 强制写入到文件

os.close(fd)                               		# 关闭文件描述符

34. get_handle_inheritable()方法——获取句柄的可继承标志

get_handle_inheritable() 方法用于获取指定句柄的可继承标志（布尔值）。语法格式如下：

os.get_handle_inheritable(handle)

参数说明：

handle：表示指定文件的句柄。
返回值：返回布尔值，值为True 表示可继承；值为False表示不可继承。

创建用于读写的文件描述符(r,w)，并且获取w 句柄的可继承标志再输出，代码如下：

import os                                  		# 文件与操作系统相关模块

r ,w= os.pipe()                             	# 创建用于读写的文件描述符(r,w)

print(os.get_handle_inheritable(w))           	# 打印指定句柄的可继承标志

35. get_inheritable()方法——获取文件描述符的可继承标志

get_inheritable() 方法用于获取指定文件描述符的inheritable（可继承）标志。语法格式如下：

os.get_inheritable(fd)

参数说明：

fd ：表示打开的文件描述符，也就是通过os.open() 或者pipe() 方法返回的对象。
返回值：返回布尔值，返回True 时表示可继承；返回False时表示不可继承。

使用get_inheritable() 方法获取文件描述符的可继承标志并输出，代码如下：

import os                           		# 导入文件与操作系统相关模块

fd = os.open(r’test.txt’, os.O_RDWR)    	# 打开文件描述符

print(os.get_inheritable( fd ))        		# 打印fd是否可继承

os.close(fd)                        		# 关闭文件描述符

36. getcwd()方法——获取当前工作目录（字符串）

getcwd() 方法用于返回表示当前工作目录的字符串。语法格式如下：

os.getcwd()

参数说明：

使用getcwd() 方法获取字符串类型的当前工作目录并输出，代码如下：

import os             	# 导入文件与操作系统相关模块

print(os.getcwd())     	# 打印表示当前工作目录的字符串

37. getcwdb()方法——获取当前工作目录（字节字符串）

getcwdb() 方法用于返回表示当前工作目录的字节字符串。语法格式如下：

os.getcwdb()

参数说明：

返回值：返回表示当前工作目录的字节字符串。

使用getcwdb() 方法获取当前工作目录的字节字符串，代码如下：

import os                    	# 导入文件与操作系统相关模块

print(os.getcwdb())           	# 打印表示当前工作目录的字节字符串

38. isatty()方法——判断是否连接到TTY设备

isatty() 方法用于判断打开的文件描述符是否连接到一个类似TTY 的设备。语法格式如下：

os.isatty(fd)

参数说明：

fd ：表示打开的文件描述符，也就是通过os.open() 方法返回的对象。
返回值：返回布尔值。如果文件描述符是打开的，并且连接到一个类似TTY 的设备，则返回True，否则返回False。

使用isatty() 方法判断打开的文件描述符是否连接到TTY 设备，代码如下：

import os                               	# 导入文件与操作系统相关模块

fd = os.open(r’test.txt’,os.O_RDWR)        	# 打开文件描述符

print(os.isatty(fd))                     	# 打印是否连接到类似TTY设备

os.close(fd)                            	# 关闭文件描述符

程序运行结果如下：

False

说明:在Linux 系统中，可以使用os 模块的openpty() 方法打开一个伪终端，然后连接到该伪终端获取设备编码，代码如下：

import os 							# 导入文件与操作系统相关模块

master, slave = os.openpty() 		# 打开一个伪终端（在Windows系统上不支持该语句）

print(os.isatty(master)) 			# 判断是否连接到TTY设备，返回值为True

39. link()方法——创建硬链接

link() 方法用于创建一个硬链接，常用于创建现有文件的副本。语法格式如下：

os.link(src,dst,*,src_dir_fd=None,dst_dir_fd=None,follow_symlinks=True)

参数说明：

src：表示字符串类型的路径，用于指定创建硬链接的源地址。
dst：表示字符串类型的路径，用于指定创建硬链接的目标地址。
src_dir_fd ：可选参数，用于指定源地址的相对于目录描述符的路径，而不是遵循符号链接（软链接）。
dst_dir_fd ：可选参数，用于指定目标地址的相对于目录描述符的路径，而不是遵循符号链接（软链接）。
follow_symlinks：表示是否跟踪符号链接，是一个布尔值。如果为False，并且要操作的路径的最后一个元素是符号链接，则该方法将对符号链接本身而不是链接指向的文件进行操作。
返回值：无。

注意:在使用os.link() 方法创建硬链接时，只能在相同的磁盘驱动器上进行，不能在不同磁盘驱动器间移动。

使用link() 方法创建“e:/mot.txt”文件的拷贝，代码如下：

import os                 			# 导入文件与操作系统相关模块

src = r’e:/mot.txt’                	# 源路径

dst = r’e:/mr/mot.txt’           	# 目标路径

os.link(src,dst)          			# 创建硬链接

说明:运行上面的代码，将在e:/mr/ 目录下创建一个mot.txt 文件的拷贝。

40. listdir()方法——返回指定路径下的目录名和文件名

listdir() 方法用于返回指定路径下的文件和目录的名称（不包括子目录）。语法格式如下：

os.listdir(path='.')

参数说明：

path：表示一个路径，用于指定要获取的文件和目录的根目录，不能是文件路径。
返回值：返回一个列表，其中包含path 路径下的目录和文件的名称（按字母顺序排列），但不包括“.”和“…”。

使用listdir() 方法获取指定路径下的目录和文件，代码如下：

import os                               		# 导入文件与操作系统相关模块

path = os.listdir(r’D:/Python已出版图书')    		# 获取指定路径下的目录和文件列表

print(‘目录下包括：',path)

41. lseek()方法——设置文件描述符的当前位置

lseek() 方法用于设置文件描述符的当前位置。语法格式如下：

os.lseek(fd,pos,how)

参数说明：

fd ：表示打开的文件描述符，也就是通过os.open() 方法返回的对象。
pos：表示相对于参数how在文件中的位置。
how：表示文件内位置计算方式。设置为os.SEEK_SET（或0），表示从文件开始计算；设置为os.SEEK_CUR（或1），表示从当前位置计算；设置为os.SEEK_END（或2），表示从文件尾部开始计算。
返回值：无。

打开文件描述符，使用lseek() 方法设置当前位置为文件开始的第2 个汉字，并且读取指定个数的文字，代码如下：

import os                                  		# 导入文件与操作系统相关模块

fd = os.open(r’test.txt’,os.O_RDWR)            	# 打开文件描述符

os.lseek(fd,3,0)                            	# 设置当前位置为文件开始的第2个字（1个汉字占3字节）

print(os.read(fd,24).decode(‘utf-8’))          	# 读取并打印文件内容

42. lstat()方法——返回文件信息

lstat() 方法用于返回文件信息，但是没有符号链接。语法格式如下：

os.lstat(path,*,dir_fd=None)

参数说明：

path：表示一个路径，用于指定要返回信息的文件。
dir_fd ：表示指定打开文件描述符的路径。默认值为None。
返回值：返回os.stat_result对象，用于记录文件信息。

在这里插入图片描述
使用lstat() 方法获取指定文件的信息并输出，代码如下：

import os                                   		# 导入文件与操作系统相关模块

info = os.lstat(r’D:/Python已出版图书/cba.txt’)   	# 获取指定文件的信息

print(‘文件信息：',info)

程序运行结果如下：

文件信息： os.stat_result(st_mode=33206, st_ino=281474976732575, st_dev=3166320548, st_

nlink=1, st_uid=0, st_gid=0, st_size=58, st_atime=1566180994, st_mtime=1561700477, st_

ctime=1566180994)

使用lstat() 方法分别获取文件的相关信息，代码如下：

import os                            		# 导入文件与操作系统相关模块

info = os.lstat(r’E:/test.txt’)          	# 获取指定文件的信息

print(‘文件类型和权限：',info.st_mode)

print(‘inode编号：',info.st_ino)

print(‘文件的设备ID：',info.st_dev)

print(‘硬链接数：',info.st_nlink)

print(‘所有者的用户ID：',info.st_uid)

print(‘所有者的组ID：',info.st_gid)

print(‘总大小：',info.st_size,’字节')

print(‘上次访问的时间：',info.st_atime)

print(‘上次修改的时间：',info.st_mtime)

print(‘上次状态更改的时间：',info.st_ctime)

43. makedirs()方法——递归创建目录

makedirs() 方法用于采用递归方式创建多级目录。语法格式如下：

os.makedirs(name,mode=0o777,exist_ok=False)

参数说明：

name：用于指定要创建目录的路径。
mode：指定目录的模式，默认模式为八进制的777。类似于chmod() 方法。
exist_ok：可选参数，如果值为False，当要创建的目录已经存在时，抛出FileExistsError异常；如果值为True，当要创建的目录已经存在时，不会抛出异常。默认值为False。
返回值：无。

使用makedirs() 方法创建多级目录，代码如下：

import os                        		# 导入文件与操作系统相关模块

os.makedirs(r’e:/mr/qq/11’)        		# 创建目录

44. mkdir()方法——创建一级目录

mkdir() 方法用于创建一级目录。语法格式如下：

os.mkdir(path,mode=0o777,*,dir_fd=None)

参数说明：

path：用于指定要创建目录的路径。
mode：表示指定目录的模式，默认模式为八进制的777。类似于chmod() 方法。
dir_fd ：表示指定打开文件描述符的路径。默认值为None。
返回值：无。

说明:使用mkdir() 方法只能创建一级目录，即创建目录e:/mr/wgh/11，且目录e:/mr/wgh 必须是存在的。

使用mkdir() 方法创建指定的一级目录，代码如下：

import os                 	# 导入文件与操作系统相关模块

os.mkdir(r’e:/mr/wgh’)      # 创建目录

说明:运行上面的代码，将创建e:/mr/wgh 目录。

使用mkdir() 方法在当前目录下创建一个名称为mr 的子目录，代码如下：

import os          	# 导入文件与操作系统相关模块

os.mkdir(r’mr’)     # 创建目录

说明:运行上面的代码，将在当前目录下创建一个名称为mr 的子目录。例如，当前目录为f:/python，那么将自动创建f:/python/mr 目录。

45. open()方法——打开文件描述符

open() 方法用于根据指定的模式打开文件描述符。语法格式如下：

os.open(path,flags,mode=0o777,*,dir_fd=None)

参数说明：

path：表示要打开文件的路径。
flags：用于指定文件的打开模式，其值如表6 所示。打开模式时，用多个“|”分隔。
mode：类似于chmod() 方法。
dir_fd ：表示指定打开文件描述符的路径，默认值为None。
返回值：返回打开的文件描述符。

在这里插入图片描述
使用open() 方法打开文件描述符，向文件中写入英文文字，再读取其内容输出并关闭文件，代码如下：

import os                                         	# 文件与操作系统相关模块

fd = os.open(r’test2.txt’,os.O_RDWR)

print(fd)                                         	# 打印文件描述符

os.write(fd,’Our destiny offers not the cup of despair , but the chalice of opportunity’.encode())

os.lseek(fd,0,0)                                   	# 定义到文件开始

print(‘文件内容：',os.read(fd,1000).decode())      	# 读取fd中的文件内容

os.close(fd)                                      	# 关闭文件描述符

程序运行结果如下：

3


文件内容： Our destiny offers not the cup of despair , but the chalice of opportunity

使用open() 方法打开文件描述符，向文件中写入GBK 编码的中文文字，再读取其内容输出（这里同时演示转码与不转码的区别），并关闭文件，代码如下：

import os                                          	# 导入文件与操作系统相关模块

fd = os.open(r’test2.txt’,os.O_RDWR)

os.write(fd,’命运给予我们的不是失望之酒，而是机会之杯。'.encode(‘gbk’))

os.lseek(fd,0,0)                                   	# 定义到文件开始

print(‘未解码：\n’,os.read(fd,100))

os.lseek(fd,0,0)                                   	# 定义到文件开始

print(‘文件内容：',os.read(fd,100).decode(‘gbk’))   	# 读取fd中的文件内容

os.close(fd)                                      	# 关闭文件描述符

46. pipe()方法——创建一个管道

pipe() 方法用于创建一个管道，返回一对可用于读写的文件描述符(r,w)，新文件描述符是不可继承的。语法格式如下：

os.pipe()

参数说明：

返回值：返回一对可用于读写的文件描述符(r,w)。

使用pipe() 方法创建一个管道并输出，代码如下：

import os             	# 导入文件与操作系统相关模块

r,w = os.pipe()        	# 创建管道

print(r,w)            	# 打印

47. read()方法——从文件描述符读取指定字符

read() 方法用于从文件描述符读取最多n 个字节的内容。语法格式如下：

os.read(fd,n)

参数说明：

fd ：表示打开的文件描述符，也就是通过os.open() 或者pipe() 方法返回的对象。
n ：表示一个整数，用于指定要读取的字节数。如果文件内容为中文汉字，则一个汉字占3（UTF-8 编码）或2（GBK 编码）个字节。
返回值：返回一个字节字符串，包含读取出的内容。

使用read() 方法打开一个文件描述符，读取其中的18 个英文字符内容，代码如下：

import os                               	# 导入文件与操作系统相关模块

fd = os.open(r’mot_en.txt’, os.O_RDWR)      # 打开文件描述符

context = os.read(fd,18)                 	# 读取指定内容

print(context)                          	# 打印读取到的字符

print(context.decode())                  	# 转码输出

os.close(fd)                            	# 关闭文件描述符

程序运行结果如下：

b'Our destiny offers'

Our destiny offers

说明:mot_en.txt 的文件内容为“Our destiny offers not the cup of despair , but the chalice of opportunity.”。

打开一个文件描述符，使用read() 方法读取其中的15 个字节（5 个汉字）的UTF-8 编码的汉字内容，代码如下：

import os                               	# 导入文件与操作系统相关模块

fd = os.open(r’mot_cn.txt’, os.O_RDWR)      # 打开文件描述符

context = os.read(fd,15)                 	# 读取指定内容

print(context)                          	# 打印读取到的字符

print(context.decode(‘utf-8’))             	# 转换为UTF-8编码输出

os.close(fd)                            	# 关闭文件描述符

48. readlink()方法——获取表示符号链接的指向路径

readlink() 方法用于返回表示符号链接指向路径的字符串。语法格式如下：

os.readlink(path,*,dir_fd=None)

参数说明：

path：表示一个路径，用于指定要返回信息的文件。
dir_fd ：表示指定打开文件描述符的路径。默认值为None。
返回值：返回字符串，用于表示符号链接指向的路径。

说明：在方法中，如果出现“*,”，则表示其后面的参数为命名关键字参数，这是一个特殊的分隔符。在调用时，命名关键字参数必须传入参数名。

先创建一个符号链接，再使用readlink() 方法获取该符号链接的指向路径，代码如下：

import os                                      			# 导入文件与操作系统相关模块

os.symlink(r’e:/mr/mot.txt’,r’e:/learn/mot.txt’)     	# 创建符号链接（软链接）

print(os.readlink(r’e:/learn/mot.txt’))            		# 获取符号链接的指向路径

49. remove()方法——删除文件

remove() 方法用于删除指定路径的文件。语法格式如下：

os.remove(path,*,dir_fd=None)

参数说明：

path：用于指定要删除的路径（不能是目录，如果是目录，则抛出IsADirectoryError 异常。目录需要使用os.rmdir() 方法删除）。
dir_fd ：表示指定打开文件描述符的路径。默认值为None。
返回值：无。

使用remove() 方法删除指定路径下的文件，代码如下：

import os                                      		# 导入文件与操作系统相关模块

os.remove(r’e:/learn/mot.txt’)                    	# 删除文件

50. removedirs()方法——递归删除目录

removedirs() 方法用于递归删除目录，即删除多级目录。语法格式如下：

os.removedirs(name)

参数说明：

name：用于指定要删除目录的路径。该目录中，最后一级目录必须为空，否则将抛出“OSError:[WinError 145] 目录不是空的”异常。
返回值：无。

说明：在调用removedirs() 方法递归删除目录时，只有要删除的目录为空时，才会被删除。

使用removedirs() 方法删除多级目录“e:/mr/wgh/11”，代码如下：

import os                               	# 导入文件与操作系统相关模块

os.removedirs(r’e:/mr/wgh/11’)             	# 删除多级目录

51. rename()方法——重命名文件或目录

rename() 方法用于将文件或目录重命名。语法格式如下：

os.rename(src,dst,*,src_dir_fd=None,dst_dir_fd=None)

参数说明：

src ：表示字符串类型的路径，用于指定需要进行重命名的文件或目录的路径。
dst：表示字符串类型的路径，用于指定新的文件或目录名称。如果指定的路径已经存在，则多数系统下将抛出FileExistsError 异常。
src_dir_fd ：可选参数，用于指定源地址的相对于目录描述符的路径，而不是遵循符号链接（软链接）。
dst_dir_fd ：可选参数，用于指定目标地址的相对于目录描述符的路径，而不是遵循符号链接（软链接）。
返回值：无。

说明:在方法中，如果出现“*,”则表示其后面的参数为命名关键字参数，这是一个特殊的分隔符。在调用时，命名关键字参数必须传入参数名。

使用rename() 方法将e:/mr/wgh 目录下的aa.txt 文件重命名为test.txt，代码如下：

import os                                             			# 导入文件与操作系统相关模块

print(os.rename(r’e:/mr/wgh/aa.txt’,r’e:/mr/wgh/test.txt’))  	# 重命名文件

52. renames()方法——递归重命名目录或文件

renames() 方法用于递归重命名目录或文件。语法格式如下：

os.renames(old,new)

参数说明：

src：表示字符串类型的路径，用于指定需要进行重命名的文件或目录的路径。
dst：表示字符串类型的路径，用于指定新的文件或目录名称。如果指定的路径已经存在，则多数系统将抛出FileExistsError 异常。
返回值：无。

说明：在使用renames() 方法重命名目录或文件时，如果指定的新的文件或者目录名称已经存在，则抛出“FileExistsError: [WinError 183] 当文件已存在时，无法创建该文件。”异常。

使用renames() 方法重命名目录，代码如下：

import os                               		# 导入文件与操作系统相关模块

os.renames(r’e:/mr/wgh/11’,r’e:/mr/wgh1/qq’) 	# 重命名目录

53. replace()方法——重命名文件或目录

replace() 方法用于重命名文件或目录。语法格式如下：

os.replace(src,dst,*,src_dir_fd=None,dst_dir_fd=None)

参数说明：

src ：表示字符串类型的路径，用于指定需要进行重命名的文件或目录的路径。
dst：表示字符串类型的路径，用于指定新的文件或目录名称。
src_dir_fd ：可选参数，用于指定源地址的相对于目录描述符的路径，而不是遵循符号链接（软链接）。
dst_dir_fd ：可选参数，用于指定目标地址的相对于目录描述符的路径，而不是遵循符号链接（软链接）。
返回值：无。

说明：

在使用replace() 方法重命名目录或文件时，如果指定的新的文件或者目录名称已经存在，则会替换已经存在的文件。
在该方法中，如果出现“*,”则表示其后面的参数为命名关键字参数，这是一个特殊的分隔符。在调用时，命名关键字参数必须传入参数名。

将e:/mr/wgh/11 目录下的111.txt 文件重命名为e:/mr/wgh/test.txt，代码如下：

import os                                                			# 导入文件与操作系统相关模块

print(os.replace(r’e:/mr/wgh/11/111.txt’,r’e:/mr/wgh/test.txt’)) 	# 重命名文件

54. rmdir()方法——删除空目录

rmdir() 方法用于删除空目录。语法格式如下：

os.rmdir(path,*,dir_fd=None)

参数说明：

path：表示要删除的目录，可以使用相对路径，也可以使用绝对路径。
dir_fd ：可选参数，用于指定要删除目录的相对于目录描述符的路径，而不是遵循符号链接（软链接）。
返回值：无。

说明:使用rmdir() 方法只能删除空的目录，如果想要删除非空的目录，则需要使用Python 内置的标准模块shutil 的rmtree() 方法实现。

使用rmdir() 方法删除c:/demo/test/dir/mr 目录，代码如下：

import os

os.rmdir(r’c:/demo/test/dir/mr’) 		# 删除c:/demo/test/dir/mr目录

说明：运行上面的代码，c:/demo/test/dir 目录下的mr 目录将被删除。

注意：如果要删除的目录不存在，那么将抛出“FileNotFoundError: [WinError 2] 系统找不到指定的文件”异常。因此，在执行os.rmdir() 方法前，建议先判断该路径是否存在，可以使用os.path.exists() 方法判断，代码如下：

import os

path = r’c:/demo/test/dir/mr’                    	# 指定要删除的目录

if os.path.exists(path):              				# 判断目录是否存在

os.rmdir(r’c:/demo/test/dir/mr’)    				# 删除目录

print(‘目录删除成功！')

else:

print(‘该目录不存在！')

55. scandir()方法——返回目录条目迭代器

scandir() 方法用于返回指定目录下的一级子目录和文件的迭代器（不包括二级子目录）。语法格式如下：

os.scandir(path='.')

参数说明：

path：用于指定要获取的目录条目的路径（必须是目录，不能是文件）。
返回值：返回os.DirEntry 对象，表示目录条目迭代器。

在这里插入图片描述
使用scandir() 方法遍历指定目录，并输出完整的子目录或文件路径，代码如下：

import os                               	# 导入文件与操作系统相关模块

for file in os.scandir(r’e:/mr/’):         	# 遍历目录条目迭代器

print(file.path)                        	# 打印完整的路径

程序运行结果如下：

e:/mr/mot.txt

e:/mr/test

e:/mr/wgh

使用scandir() 方法遍历指定目录，并输出全部文本文件的完整路径，代码如下：

import os                           		# 导入文件与操作系统相关模块

 """方法一"""
filelist = []

for file in os.scandir(r’e:/mr/’):      	# 遍历目录条目迭代器
	if file.name.endswith(‘.txt’):
	filelist.append(file.path)
print(filelist)

 """方法二"""
filelist2 = [f.path for f in os.scandir(r’e:/mr/’) if f.name.endswith(‘.txt’)]
print(filelist2)

56. set_handle_inheritable()方法——设置句柄的可继承标志

set_handle_inheritable() 方法用于设置句柄的可继承标志。语法格式如下：

os.set_handle_inheritable(handle,inheritable)

参数说明：

handle：表示指定文件的句柄。
inheritable：表示布尔值，如果设置为可继承，则使用True ；否则使用False。
返回值：无。

创建用于读写的文件描述符(r,w)，并且设置w 句柄的可继承标志为True，再获取该句柄的可继承标志并输出，代码如下：

import os                           	# 文件与操作系统相关模块

r ,w= os.pipe()                      	# 创建用于读写的文件描述符(r,w)

os.set_handle_inheritable( w ,True)    	# 设置指定句柄的可继承标志

print(os.get_handle_inheritable(w))    	# 获取指定句柄的可继承标志

57. set_inheritable()方法——设置文件描述符的可继承标志

set_inheritable() 方法用于设置指定文件描述符的inheritable（可继承）标志。语法格式如下：

os.set_inheritable(fd,inheritable)

参数说明：

fd ：表示打开的文件描述符，也就是通过os.open() 或者pipe() 方法返回的对象。
inheritable：表示布尔值，如果设置为可继承，则使用True ；否则使用False。
返回值：无。

打开文件描述符，并设置为可继承，再使用get_inheritable() 方法输出可继承标志，代码如下：

import os                               	# 导入文件与操作系统相关模块

fd = os.open(r’test.txt’, os.O_RDWR)       	# 打开文件描述符

os.set_inheritable(fd,True)               	# 设置fd可继承

print(os.get_inheritable(fd))             	# 输出fd是否可继承

os.close(fd)                            	# 关闭文件描述符

58. stat()方法——获取文件或文件描述符的状态

stat() 方法用于获取文件或文件描述符的状态。语法格式如下：

os.stat(path,*,dir_fd=None,follow_symlinks=True)

参数说明：

path：用于指定要获取状态的路径。
dir_fd ：表示指定打开文件描述符的路径。默认值为None。
follow_symlinks：表示是否跟踪符号链接，是一个布尔值。如果为False，并且要操作的路径的最后一个元素是符号链接，则该方法将对符号链接本身而不是链接指向的文件进行操作。
返回值：返回os.stat_result对象，用于记录文件信息。

在这里插入图片描述
使用stat() 方法获取指定文件的信息并输出，代码如下：

import os                                      		# 导入文件与操作系统相关模块

info = os.stat(r’D:/Python已出版图书/cba.txt’)      	# 获取指定文件的信息

print(‘文件信息：',info)

程序运行结果如下：

文件信息： os.stat_result(st_mode=33206, st_ino=281474976732575, st_dev=3166320548,

st_nlink=1, st_uid=0, st_gid=0, st_size=58, st_atime=1566180994, st_mtime=1561700477,

st_ctime=1566180994)

使用stat() 方法获取文件的基本信息，并逐条输出，代码如下：

import os                                      		# 导入文件与操作系统相关模块

fileinfo = os.stat(“mr.png”)                     	# 获取文件的基本信息

print(“文件完整路径：", os.path.abspath(“mr.png”))   	# 获取文件的完整数路径

# 打印文件的基本信息

print(“索引号：",fileinfo.st_ino)

print(“设备名：",fileinfo.st_dev)

print(“文件大小：",fileinfo.st_size,” 字节")

print(“最后一次访问时间：",fileinfo.st_atime)

print(“最后一次修改时间：",fileinfo.st_mtime)

print(“最后一次状态变化时间：",fileinfo.st_ctime)

59. supports_dir_fd属性——返回允许使用 dir_fd参数的方法的集合

supports_dir_fd 属性用于返回允许使用dir_fd 参数的方法的集合。语法格式如下：

os.supports_dir_fd

参数说明：

返回值：返回一个集合（Set）对象，表示os 模块中的哪些方法允许使用dir_fd 参数。不同的平台提供不同的功能，在一个平台上工作的选项可能在另一个平台上不受支持。为了保持一致性，支持dir_fd 的方法总是允许指定参数，但如果功能实际上不可用，则会引发异常。

说明:dir_fd 仅适用于Unix 平台，在Windows 平台上不起作用。

返回允许使用dir_fd 参数的方法的集合，代码如下：

import os # 导入文件与操作系统相关模块

print(os.supports_dir_fd)

60. supports_effective_ids属性——返回允许使用effective_ids参数的方法的集合

supports_effective_ids 属性用于返回允许使用effective_ids 参数的方法的集合。语法格式如下：

os.supports_effective_ids

参数说明：

返回值：返回一个集合（Set）对象，表示os模块中的哪些方法允许使用其effective_ids参数。不同的平台提供不同的功能，在一个平台上工作的选项可能在另一个平台上不受支持。为了保持一致性，支持effective_ids 的方法总是允许指定参数，但如果功能实际上不可用，则会引发异常。

说明：effective_ids 仅适用于Unix 平台，在Windows 系统上不起作用。

返回哪些方法时允许使用effective_ids 参数，代码如下：

import os 			# 导入文件与操作系统相关模块

print(os.supports_effective_ids)

61. supports_fd属性——返回允许将其path参数指定为打开文件描述符的方法的集合

supports_fd 属性用于返回允许将其path 参数指定为打开文件描述符的方法的集合。语法格式如下：

os.supports_fd

参数说明：

返回值：返回一个集合（Set）对象，表示os模块中的哪些方法允许将其path参数指定为打开文件描述符。不同的平台提供不同的功能，在一个平台上可以工作的选项可能在另一个平台上不受支持。为了保持一致性，支持fd 的方法总是允许指定参数，但如果功能实际上不可用，则会引发异常。

判断os.open() 方法和os.truncate() 方法是否允许将其path 参数指定为打开文件描述符，代码如下：

import os # 导入文件与操作系统相关模块

print(os.open in os.supports_fd)

print(os.truncate in os.supports_fd)

62. supports_follow_symlinks属性——返回允许使用follow_symlinks参数的方法的集合

supports_follow_symlinks 属性用于返回允许使用follow_symlinks 参数的方法的集合。语法格式如下：

os.get_inheritable(fd)

参数说明：

返回值：返回一个Set对象，表示os模块中的哪些方法允许使用follow_symlinks参数。不同的平台提供不同的功能，在一个平台上可以工作的选项可能在另一个平台上不受支持。为了保持一致性，支持follow_symlinks 的函数总是允许指定参数，但如果功能实际上不可用，则会引发异常。

判断os.open() 方法是否允许使用follow_symlinks 参数，代码如下：

import os 		# 导入文件与操作系统相关模块

print(os.open in os.supports_follow_symlinks)

63. symlink()方法——创建符号链接

symlink() 方法用于创建符号链接（也称为软链接）。语法格式如下：

os.symlink(src,dst,target_is_directory=False,*,dir_fd=None)

参数说明：

src：用于指定创建符号链接的源路径。
dst：用于指定目标的符号链接地址，必须是一个不存在的路径，否则将抛出FileExistsError异常。
target_is_directory：在Windows 系统中，如果设置target_is_directory 值为True，则将创建的符号链接作为目录；否则将创建文件符号链接（默认值）。在非Windows 系统中，将忽略target_is_directory 参数。
dir_fd ：用于指定打开文件描述符的路径。默认值为None。
返回值：无。

说明:在Windows 系统中，要有SeCreateSymbolicLinkPrivilege 权限才能成功创建符号链接。此权限通常不会授予常规用户，只有升级到管理员级别的账户才可使用。获取该权限或者以管理员身份运行应用程序都可以成功创建符号链接。如果没有此权限，将会抛出“OSError: symbolic link privilege notheld”异常。

使用symlink() 方法创建一个符号链接，代码如下：

import os                                      			# 导入文件与操作系统相关模块

os.symlink(r’e:/mr/mot.txt’,r’e:/learn/mot.txt’)     	# 创建符号链接（软链接）

print(os.readlink(r’e:/learn/mot.txt’))            		# 获取符号链接的指向路径

64. truncate()方法——截断文件为指定大小

truncate() 方法用于截断文件为指定大小（单位为字节）。语法格式如下：

os.truncate(path,length)

参数说明：

path：用于指定要截断文件的路径（必须是文件，不能是目录）。
length：表示要截取的长度，单位为字节。
返回值：无。

使用truncate() 方法将某个文件截断为大小为10 字节的文件，代码如下：

import os                           		# 导入文件与操作系统相关模块

os.truncate( r’e:/mr/wgh/test.txt’, 10 ) 	# 截断文件

65. unlink()方法——删除指定文件

unlink() 方法用于删除指定文件。语法格式如下：

os.unlink(path,*,dir_fd=None)

参数说明：

path：用于指定要删除的文件路径（必须是文件，不能是目录）。
dir_fd ：用于指定打开文件描述符的路径。默认值为None。
返回值：无。

更改当前工作目录，然后获取当前目录下的文件和目录并输出；再使用unlink() 方法删除一个文件，最后再次获取当前目录下的文件和目录并输出，代码如下：

import os                    	# 导入文件与操作系统相关模块

os.chdir(r’E:/mr’)             	# 切换当前工作目录

print(os.listdir(os.getcwd())) 	# 显示当前工作目录下的全部文件及目录

os.unlink( r’mot_cn.txt’)       # 删除文件

print(os.listdir(os.getcwd())) 	# 显示当前工作目录下的全部文件及目录

66. utime()方法——设置文件的访问和修改时间

utime() 方法用于设置文件的访问时间和修改时间。语法格式如下：

os.utime(path,times=None,*,[ns,]dir_fd=None,follow_symlinks=True)

参数说明：

path：用于指定要操作的文件路径（必须是文件，不能是目录）。
times：表示一个包括两个整型元素的元组：第一个元素表示访问时间（单位为秒），第二个元素表示修改时间（单位为秒）。如果不设置times 参数，或者值为None，并且也未指定ns，则相当于指定两个时间都是当前时间。
ns：表示一个包括两个整型元素的元组：第一个元素表示访问时间（单位为纳秒），第二个元素表示修改时间（单位为纳秒）。
dir_fd ：用于指定打开文件描述符的路径，默认值为None。
follow_symlinks：表示是否跟踪符号链接，是一个布尔值。如果为False，并且要操作的路径的最后一个元素是符号链接，则该方法将对符号链接本身而不是链接指向的文件进行操作。
返回值：无。

使用utime() 方法设置文件的访问和修改时间都为1 小时前，即当前时间减1 小时，代码如下：

import os             # 导入文件与操作系统相关模块

import time           # 导入时间模块

# 设置访问和修改时间

os.utime( r’e:/mr/wgh/test.txt’,times = (int(time.time())-3600,int(time.time())-3600)

67. walk()方法——遍历目录树

walk() 方法用于遍历目录树。语法格式如下：

os.walk(top,topdown=True,onerror=None,followlinks=False)

参数说明：

top：用于指定要遍历内容的根目录。
topdown：可选参数，用于指定遍历的顺序。如果值为True，表示自上而下遍历（即先遍历根目录）；如果值为False，表示自下而上遍历（即先遍历最后一级子目录）。默认值为True。
onerror ：可选参数，用于指定错误处理方式，默认为忽略。如果不想忽略，也可以指定一个错误处理函数。通常情况下采用默认。
followlinks：可选参数，默认情况下，walk() 方法不会向下转换成解析到目录的符号链接。将该参数值设置为True，表示用于指定在支持的系统上访问由符号链接指向的目录。
返回值：返回一个包括3 个元素（dirpath, dirnames, filenames）的元组生成器对象。其中，dirpath 表示当前遍历的路径，是一个字符串；dirnames 表示当前路径下包含的子目录，是一个列表；filenames 表示当前路径下包含的文件，也是一个列表。

使用walk() 方法遍历指定目录“f:/program/Python/Code/01”，代码如下：

import os                                      		# 导入文件与操作系统相关模块

tuples = os.walk(‘f:/program/Python/Code/01’)      	# 遍历“f:/program/Python/Code/01”目录

for tuple1 in tuples:                           	# 通过for循环输出遍历结果

print(tuple1 ,’\n’)                          		# 打印每一级目录的元组

68. write()方法——写入数据到文件

write() 方法用于将字节类型的字符串写入到文件描述符所指定的文件。语法格式如下：

os.write(fd,str)

参数说明：

fd ：表示打开的文件描述符，也就是通过os.open() 或者pipe() 方法返回的对象。
str：表示要写入的内容，需要使用字符串的encode() 方法进行编码。
返回值：返回实际写入的字节数。

打开文件描述符，使用write() 方法向文件中写入英文，再关闭，代码如下：

import os                               		# 导入文件与操作系统相关模块

fd = os.open(r’mot_en.txt’, os.O_RDWR)      	# 打开文件描述符

# 向_s+耞s+耞s+耞_文件中写入英文，将替换原文件中部分内容

os.write(fd, ‘Our destiny offers not the cup of despair , but the chalice of opportunity.’.encode())

os.close(fd)                            		# 关闭文件描述符

打开文件描述符，使用write() 方法向文件中写入UTF-8 编码的汉字，再关闭，代码如下：

import os                                  		# 导入文件与操作系统相关模块

fd = os.open(r’test.txt’, os.O_RDWR)        	# 打开文件描述符

os.write(fd, ‘我命由我不由天'.encode(‘UTF-8’)) 	# 向文件中写入文字，将替换原文件中部分内容

os.close(fd)                               		# 关闭文件描述符

69. altsep属性——操作系统中备用的路径分隔符

altsep 属性表示操作系统中备用的路径分隔符。语法格式如下：

os.altsep

参数说明：

返回值：返回操作系统中备用的路径分隔符的字符串。

使用altsep 属性获取操作系统中备用的路径分隔符并输出，代码如下：

import os                 # 导入文件与操作系统相关模块

print(os.altsep)          # 打印操作系统中备用的路径分隔符

70. cpu_count()方法——获取系统中的 CPU数量

cpu_count() 方法用于返回系统中的CPU 数量。语法格式如下：

os.cpu_count()

参数说明：

返回值：返回整型数值，表示CPU的数量。

使用cpu_count() 方法获取系统中CPU 的数量并输出，代码如下：

import os                 	# 导入文件与操作系统相关模块

print(os.cpu_count())      	# 获取CPU的数量

71. curdir属性——操作系统中引用当前目录的常量

curdir 属性用于表示操作系统中引用当前目录的常量字符串。语法格式如下：

os.curdir

参数说明：

返回值：返回操作系统中引用当前目录的常量字符串。例如，Windows操作系统中返回的是“.”。

使用curdir 属性获取操作系统中引用当前目录的常量字符串并输出，代码如下：

import os                 	# 导入文件与操作系统相关模块

print(os.curdir)          	# 打印操作系统中引用当前目录的常量字符串

72. defpath属性——系统的默认搜索路径

defpath 属性表示系统的默认搜索路径。语法格式如下：

os.defpath

参数说明：

返回值：返回系统的默认搜索路径。

使用defpath 属性获取操作系统中默认的搜索路径并输出，代码如下：

import os          	# 导入文件与操作系统相关模块

print(os.defpath)   # 打印操作系统中默认的搜索路径的字符串

73. devnull属性——空设备的文件路径

devnull 属性表示操作系统中空设备的文件路径。语法格式如下：

os.devnull

参数说明：

返回值：返回操作系统中空设备的文件路径。

使用devnull 属性获取操作系统中空设备的文件路径并输出，代码如下：

import os             	# 导入文件与操作系统相关模块

print(os.devnull)      	# 打印操作系统中空设备的文件路径

74. extsep属性——将基本文件名与扩展名分开的字符

extsep 属性表示将基本文件名与扩展名分开的字符。语法格式如下：

os.extsep

参数说明：

返回值：返回将基本文件名与扩展名分开的字符。

使用extsep 属性获取将基本文件名与扩展名分开的字符并输出，代码如下：

import os                 	# 导入文件与操作系统相关模块

print(os.extsep)          	# 打印将基本文件名与扩展名分开的字符

75. get_terminal_size()方法——获取终端窗口的大小

get_terminal_size() 方法用于返回终端窗口的大小，类型为元组。语法格式如下：

os.get_terminal_size(fd=STDOUT_FILENO)

参数说明：

fd ：可选参数，用于指定终端。
返回值：返回表示终端窗口大小的元组。

使用get_terminal_size() 方法获取终端窗口的大小并输出，代码如下：

import os                    	# 导入文件与操作系统相关模块

print(os.get_terminal_size()) 	# 打印终端大小

76. linesep属性——操作系统中分隔行的字符串

linesep 属性表示操作系统中分隔行的字符串。语法格式如下：

os.linesep

参数说明：

返回值：返回操作系统中分隔行的字符串。

使用linesep 属性获取操作系统中分隔行的字符串并输出，代码如下：

import os                           	# 导入文件与操作系统相关模块

linesep = os.linesep                 	# 获取操作系统中分隔行的字符串

print(linesep)                       	# 直接输出

print(‘不转义输出：',linesep.encode())   	# 编码后输出

77. name属性——获取依赖操作系统的模块名称

name 属性用于获取依赖于特定操作系统的模块的名称。语法格式如下：

os.name

参数说明：

返回值：返回当前操作系统对应的模块名称。目前已经注册的模块名称有“posix”“nt”和“java”等。

使用name 属性显示当前操作系统对应的模块名称，代码如下：

import os             	# 导入文件与操作系统相关模块

print(os.name)         	# 获取当前操作系统对应的模块名称

在Windows 10 操作系统下运行程序，将显示以下运行结果：

nt

在不同的操作系统下，文件路径的形式不同。这里通过name 属性获取当前的操作系统，再使用if…elif 语句实现针对不同操作系统设置不同的文件默认路径，代码如下：

import os                           	# 导入文件与操作系统相关模块

if os.name == ‘nt’:                   	# 判断是否为Windows操作系统

defaultpath = ‘D:/python/mr’            # 设置默认路径

elif os.name == ‘posix’:               	# 判断是否为Linux/Unix操作系统

defaultpath = ‘/home/python/mr’         # 设置默认路径

else:

defaultpath = ‘未知路径'

print(‘默认路径为：',defaultpath)        	# 打印默认路径

78. pardir属性——操作系统中引用父目录的常量

pardir 属性用于表示操作系统中引用父目录的常量字符串。语法格式如下：

os.pardir

参数说明：

返回值：返回操作系统中引用父目录的常量字符串。例如，Windows操作系统中返回的是“…”。

使用pardir 属性获取操作系统中引用父目录的常量字符串并输出，代码如下：

import os                    	# 导入文件与操作系统相关模块

print(os.pardir)              	# 打印操作系统中引用父目录的常量字符串

79. pathsep属性——操作系统中分隔搜索路径的字符

pathsep 属性表示操作系统中用于分隔搜索路径（如环境变量中的path）的字符。语法格式如下：

os.pathsep

参数说明：

返回值：返回操作系统中用于分隔搜索路径的字符。

使用pathsep 属性获取操作系统中分隔搜索路径的字符并输出，代码如下：

import os             	# 导入文件与操作系统相关模块

print(os.pathsep)      	# 打印操作系统中分隔搜索路径的字符

80. sep属性——操作系统中使用的路径分隔符

sep 属性用于表示操作系统中使用的路径分隔符。语法格式如下：

os.sep

参数说明：

返回值：返回操作系统中使用的路径分隔符的字符串。

使用sep 属性获取操作系统中使用的路径分隔符并输出，代码如下：

import os          	# 导入文件与操作系统相关模块

print(os.sep)      	# 打印操作系统中使用的路径分隔符

81. urandom()方法——生成随机字节字符串

urandom() 方法用于返回一串指定大小的随机字节字符串，可以作为随机加密的Key 使用。语法格式如下：

os.urandom(size)

参数说明：

size：表示整型数值，用于指定要生成的字节数。
返回值：返回生成的随机字节字符串。

说明:由于使用urandom() 方法返回的数据应该是不可预测的，所以就有可能出现重复的随机数。当字节数适当调高时，可以减少重复的机率。

使用urandom() 方法生成多个长度为10 字节的随机字符串并输出，代码如下：

import os             	# 导入文件与操作系统相关模块

print(os.urandom(10)) 	# 生成10个字节的随机数

print(os.urandom(10)) 	# 生成10个字节的随机数

print(os.urandom(10)) 	# 生成10个字节的随机数

程序运行结果如下：

b"[\x02\x14\x8c.'<4OQ"

b'/P3\r\xa2\xd0\x81\xe2\xde#'

b'\xab\\(\xe6\xea\x94\x9fY\x9f\x1c'

结合base64 模块生成一串可作为软件序列号的随机字符串，代码如下：

import os                        	# 导入文件与操作系统相关模块

import base64                    	# 导入进行base64编码和解码的模块

key = os.urandom(32)

print(base64.b64encode(key))       	# 进行base64编码