tp最新版官网|sys

首页
sys

tp最新版官网|sys

作者： tp最新版官网

2024-03-07 21:20:39

Python sys 模块详解 - 知乎

Python sys 模块详解 - 知乎首发于好好学习切换模式写文章登录/注册Python sys 模块详解轩辕御龙ZGNBPython sys 模块详解1. 简介“sys”即“system”，“系统”之意。该模块提供了一些接口，用于访问 Python 解释器自身使用和维护的变量，同时模块中还提供了一部分函数，可以与解释器进行比较深度的交互。2. 常用功能2.1 sys.argv“argv”即“argument value”的简写，是一个列表对象，其中存储的是在命令行调用 Python 脚本时提供的“命令行参数”。这个列表中的第一个参数是被调用的脚本名称，也就是说，调用 Python 解释器的“命令”（python）本身并没有被加入这个列表当中。这个地方要注意一下，因为这一点跟 C 程序的行为有所不同，C 程序读取命令行参数是从头开始的。举例来说，在当前目录下新建一个 Python 文件sys_argv_example.py，其内容为： import sys

print("The list of command line arguments:\n", sys.argv)在命令行运行该脚本： $ python sys_argv_example.py

The list of command line arguments:

['example.py']

加上几个参数试试： $ python sys_argv_example.py arg1 arg2 arg3

The list of command line arguments:

['example.py', 'arg1', 'arg2', 'arg3']

利用好这个属性，可以极大增强 Python 脚本的交互性。2.2 sys.platform在《第26天： Python 标准库之 os 模块详解》中，我们提到过“查看sys模块中的sys.platform属性可以得到关于运行平台更详细的信息”，这里我们就来试试： >>> import sys

>>> sys.platform

'win32'在 Linux 上： >>> sys.platform

'linux'比较一下os.name的结果，不难发现，sys.platform的信息更加准确。2.3 sys.byteorder“byteorder”即“字节序”，指的是在计算机内部存储数据时，数据的低位字节存储在存储空间中的高位还是低位。“小端存储”时，数据的低位也存储在存储空间的低位地址中，此时sys.byteorder的值为“little”。如果不注意，在按地址顺序打印内容的时候，可能会把小端存储的内容打错。当前大部分机器都是使用的小端存储。所以不出意外的话，你的机器上执行下述交互语句也应当跟我的结果一样： >>> sys.byteorder

'little'而另外还存在一种存储顺序是“大端存储”，即数据的高位字节存储在存储空间的低位地址上，此时sys.byteorder的值为“big”。这种方式看起来好像很合理也很自然，因为我们一般在书面表示的时候都将低位地址写在左边，高位地址写在右边，大端存储的顺序就很符合人类的阅读习惯。但实际上对机器而言，内存地址并没有左右之分，所谓的“自然”其实并不存在。抱歉我并没有使用大端存储的机器可以用作演示，因此只能说如果是大端存储的机器上运行 Python，输出结果应该像下面这样，也就是说下面这个示例并非我得到的真实运行结果，仅供参考： >>> sys.byteorder

'big'2.4 sys.executable该属性是一个字符串，在正常情况下，其值是当前运行的 Python 解释器对应的可执行程序所在的绝对路径。比如在 Windows 上使用 Anaconda 安装的 Python，该属性的值就是： >>> sys.executable

'E:\\Anaconda\\Anaconda\\python.exe'2.5 sys.modules该属性是一个字典，包含的是各种已加载的模块的模块名到模块具体位置的映射。通过手动修改这个字典，可以重新加载某些模块；但要注意，切记不要大意删除了一些基本的项，否则可能会导致 Python 整个儿无法运行。关于其具体的值，由于内容过多，就不在此给出示例了，读者可以自行查看。2.6 sys.builtin_module_names该属性是一个字符串元组，其中的元素均为当前所使用的的 Python 解释器内置的模块名称。注意区别sys.modules和sys.builtin_module_names——前者的关键字（keys）列出的是导入的模块名，而后者则是解释器内置的模块名。其值示例如下：>>> sys.builtin_module_names

('_abc', '_ast', '_bisect', '_blake2', '_codecs', '_codecs_cn', '_codecs_hk', '_codecs_iso2022', '_codecs_jp', '_codecs_kr', '_codecs_tw', '_collections', '_contextvars', '_csv', '_datetime', '_functools', '_heapq', '_imp', '_io', '_json', '_locale', '_lsprof', '_md5', '_multibytecodec', '_opcode', '_operator', '_pickle', '_random', '_sha1', '_sha256', '_sha3', '_sha512', '_signal', '_sre', '_stat', '_string', '_struct', '_symtable', '_thread', '_tracemalloc', '_warnings', '_weakref', '_winapi', 'array', 'atexit', 'audioop', 'binascii', 'builtins', 'cmath', 'errno', 'faulthandler', 'gc', 'itertools', 'marshal', 'math', 'mmap', 'msvcrt', 'nt', 'parser', 'sys', 'time', 'winreg', 'xxsubtype', 'zipimport', 'zlib')

2.7 sys.path A list of strings that specifies the search path for modules. Initialized from the environment variable PYTHONPATH, plus an installation-dependent default. 该属性是一个由字符串组成的列表，其中各个元素表示的是 Python 搜索模块的路径；在程序启动期间被初始化。其中第一个元素（也就是path[0]）的值是最初调用 Python 解释器的脚本所在的绝对路径；如果是在交互式环境下查看sys.path的值，就会得到一个空字符串。命令行运行脚本（脚本代码见示例 sys_path_example.py）：$ python sys_path_example.py

The path[0] = D:\justdopython\sys_example

交互式环境查看属性第一个元素：>>> sys.path[0]

3. 进阶功能3.1 sys.stdin即 Python 的标准输入通道。通过改变这个属性为其他的类文件（file-like）对象，可以实现输入的重定向，也就是说可以用其他内容替换标准输入的内容。所谓“标准输入”，实际上就是通过键盘输入的字符。在示例（sys_stdin_example.py）中，我们尝试把这个属性的值改为一个打开的文件对象hello_python.txt，其中包含如下的内容：Hello Python!

Just do Python, go~

Go, Go, GO!

由于input()使用的就是标准输入流，因此通过修改sys.stdin的值，我们使用老朋友input()函数，也可以实现对文件内容的读取，程序运行效果如下：$ python sys_stdin_example.py

Hello Python!

Just do Python, go~

Go, Go, GO!

3.2 sys.stdout与上一个“标准输入”类似，sys.stdout则是代表“标准输出”的属性。通过将这个属性的值修改为某个文件对象，可以将本来要打印到屏幕上的内容写入文件。比如运行示例程序sys_stdout_example.py，用来临时生成日志也是十分方便的：import sys

# 以附加模式打开文件，若不存在则新建

with open("count_log.txt", 'a', encoding='utf-8') as f:

sys.stdout = f

for i in range(10):

print("count = ", i)

3.3 sys.err与前面两个属性类似，只不过该属性标识的是标准错误，通常也是定向到屏幕的，可以粗糙地认为是一个输出错误信息的特殊的标准输出流。由于性质类似，因此不做演示。此外，sys模块中还存在几个“私有”属性：sys.__stdin__，sys.__stdout__，sys.__stderr__。这几个属性中保存的就是最初定向的“标准输入”、“标准输出”和“标准错误”流。在适当的时侯，我们可以借助这三个属性将sys.stdin、sys.stdout和sys.err恢复为初始值。3.4 sys.getrecursionlimit() 和 sys.setrecursionlimit()sys.getrecursionlimit()和sys.setrecursionlimit()是成对的。前者可以获取 Python 的最大递归数目，后者则可以设置最大递归数目。因为初学阶段很少用到，因此只做了解。3.5 sys.getrefcount()在《第12天：Python 之引用》中我们其实已经用到过这个函数，其返回值是 Python 中某个对象被引用的次数。关于“引用”的知识可以回去看看这篇文章。3.6 sys.getsizeof()这个函数的作用与 C 语言中的sizeof运算符类似，返回的是作用对象所占用的字节数。比如我们就可以看看一个整型对象1在内存中的大小：>>> sys.getsizeof(1)

注意，在 Python 中，某类对象的大小并非一成不变的：>>> sys.getsizeof(2**30-1)

>>> sys.getsizeof(2**30)

3.7 sys.int_info 和 sys.float_info这两个属性分别给出了 Python 中两个重要的数据类型的相关信息。其中sys.int_info的值为：>>> sys.int_info

sys.int_info(bits_per_digit=30, sizeof_digit=4)

在文档中的解释为：属性解释bits_per_digitnumber of bits held in each digit. Python integers are stored internally in base 2**int_info.bits_per_digitsizeof_digitsize in bytes of the C type used to represent a digit指的是 Python 以 2 的sys.int_info.bits_per_digit次方为基来表示整数，也就是说它是“2 的sys.int_info.bits_per_digit次方进制”的数。这样的数每一个为都用 C 类中的 4 个字节来存储。换句话说，每“进 1 位”（即整数值增加2 的sys.int_info.bits_per_digit次方），就需要多分配 4 个字节用以保存某个整数。因此在sys.getsizeof()的示例中，我们可以看到2**30-1和2**30之间，虽然本身只差了 1，但是所占的字节后者却比前者多了 4。而sys.float_info的值则是：>>> sys.float_info

sys.float_info(max=1.7976931348623157e+308, max_exp=1024, max_10_exp=308, min=2.2250738585072014e-308, min_exp=-1021, min_10_exp=-307, dig=15, mant_dig=53, epsilon=2.220446049250313e-16, radix=2, rounds=1)

其中各项具体的含义就不在这里继续展开了，感兴趣的同学可以参看文档和《深入理解计算机系统》等讲解组成原理的书。4. 一个有趣的功能接下来让我们放松一下。每次打开 Python 的交互式界面，我们都会看到一个提示符>>>。不知道你有没有想过要把这个东西换成另外的什么呢？反正我没想过哈哈——至少在文档中看到这两个属性之前，我确实没有想过。哪两个属性呢？就这俩货：sys.ps1和sys.ps2所谓“ps”，应当是“prompts”的简写，即“提示符”。这两个属性中，sys.ps1代表的是一级提示符，也就是进入 Python 交互界面之后就会出现的那一个>>>；而第二个sys.ps2则是二级提示符，是在同一级内容没有输入完，换行之后新行行首的提示符...。当然，两个属性都是字符串。好了，知道怎么回事儿就好办了。现在我们就来一个： >>> sys.ps1 = "justdopython "

justdopython li = [1,2,3]

justdopython li[0]

justdopython

提示符已经被改变了，当然，有点长，不大美观哈哈。咱们换一下： justdopython sys.ps1 = "ILoveYou: "

ILoveYou: print("你可真是个小机灵鬼儿！")

你可真是个小机灵鬼儿！

ILoveYou:

有点儿意思吧？注意不要忘了在字符串最后加个空格，否则提示符就会和你输入的内容混杂在一起了，会十分难看的哟~示例代码：python-100-days参考资料Python3 标准库-sys 模块发布于 2020-06-26 17:10Python 3.xPythonPython 标准库赞同 936 条评论分享喜欢收藏申请转载文章被以下专栏收录好

Python 基础（二十）：sys 模块 - 知乎

Python 基础（二十）：sys 模块 - 知乎首发于Python切换模式写文章登录/注册Python 基础（二十）：sys 模块Python小二1. 简介sys 模块主要负责与 Python 解释器进行交互，该模块提供了一系列用于控制 Python 运行环境的函数和变量。之前我们说过 os 模块，该模块与 sys 模块从名称上看着好像有点类似，实际上它们之间是没有什么关系的，os 模块主要负责与操作系统进行交互。2. 使用我们先整体看一下 sys 模块都包含哪些内容，如下所示：>>> import sys

>>> dir(sys)

['__displayhook__', '__doc__', '__excepthook__', '__interactivehook__', '__loader__', '__name__', '__package__', '__spec__', '__stderr__', '__stdin__', '__stdout__', '_clear_type_cache', '_current_frames', '_debugmallocstats', '_enablelegacywindowsfsencoding', '_getframe', '_git', '_home', '_xoptions', 'api_version', 'argv', 'base_exec_prefix', 'base_prefix', 'builtin_module_names', 'byteorder', 'call_tracing', 'callstats', 'copyright', 'displayhook', 'dllhandle', 'dont_write_bytecode', 'exc_info', 'excepthook', 'exec_prefix', 'executable', 'exit', 'flags', 'float_info', 'float_repr_style', 'get_asyncgen_hooks', 'get_coroutine_wrapper', 'getallocatedblocks', 'getcheckinterval', 'getdefaultencoding', 'getfilesystemencodeerrors', 'getfilesystemencoding', 'getprofile', 'getrecursionlimit', 'getrefcount', 'getsizeof', 'getswitchinterval', 'gettrace', 'getwindowsversion', 'hash_info', 'hexversion', 'implementation', 'int_info', 'intern', 'is_finalizing', 'maxsize', 'maxunicode', 'meta_path', 'modules', 'path', 'path_hooks', 'path_importer_cache', 'platform', 'prefix', 'set_asyncgen_hooks', 'set_coroutine_wrapper', 'setcheckinterval', 'setprofile', 'setrecursionlimit', 'setswitchinterval', 'settrace', 'stderr', 'stdin', 'stdout', 'thread_info', 'version', 'version_info', 'warnoptions', 'winver']对于一些相对常用的变量和函数，我们下面再来具体看一下。argv 返回传递给 Python 脚本的命令行参数列表。看下示例：import sys

if __name__ == '__main__':

args = sys.argv

print(args)

print(args[1])上面文件名为：test.py，我们在控制台使用命令：python test.py 123 abc 执行一下，执行结果如下：['test.py', '123', 'abc']

123version 返回 Python 解释器的版本信息。winver返回 Python 解释器主版号。platform 返回操作系统平台名称。path返回模块的搜索路径列表。maxsize返回支持的最大整数值。maxunicode返回支持的最大 Unicode 值。copyright 返回 Python 版权信息。modules 以字典类型返回系统导入的模块。byteorder返回本地字节规则的指示器。executable返回 Python 解释器所在路径。import sys

print(sys.version)

print(sys.winver)

print(sys.platform)

print(sys.path)

print(sys.maxsize)

print(sys.maxunicode)

print(sys.copyright)

print(sys.modules)

print(sys.byteorder)

print(sys.executable)stdout 标准输出。看下示例：import sys

# 下面两行代码等价

sys.stdout.write('Hi' + '\n')

print('Hi')stdin 标准输入。看下示例：import sys

s1 = input()

s2 = sys.stdin.readline()

print(s1)

print(s2)stderr 错误输出。看下示例：import sys

sys.stderr.write('this is a error message')exit()退出当前程序。看下示例：import sys

print('Hi')

sys.exit()

print('Jhon')getdefaultencoding()返回当前默认字符串编码的名称。getrefcount(obj)返回对象的引用计数。getrecursionlimit()返回支持的递归深度。getsizeof(object[, default])以字节为单位返回对象的大小。setswitchinterval(interval)设置线程切换的时间间隔。getswitchinterval()返回线程切换时间间隔。import sys

print(sys.getdefaultencoding())

print(sys.getrefcount('123456'))

print(sys.getrecursionlimit())

print(sys.getsizeof('abcde'))

sys.setswitchinterval(1)

print(sys.getswitchinterval())发布于 2020-05-25 19:45PythonPython 入门Python 开发赞同 2添加评论分享喜欢收藏申请转载文章被以下专栏收录Python分享基础、实用、有趣的 Python

Python 标准库之 sys 模块详解_sys函数-CSDN博客

Python 标准库之 sys 模块详解

最新推荐文章于 2024-01-27 14:09:39 发布

轩辕御龙

最新推荐文章于 2024-01-27 14:09:39 发布

阅读量6.4k

点赞数

分类专栏：

Python

文章标签：

Python

本文链接：https://blog.csdn.net/w573719227/article/details/102527967

版权

Python

专栏收录该内容

16 篇文章

1 订阅

订阅专栏

Python sys 模块详解

1. 简介

“sys”即“system”，“系统”之意。该模块提供了一些接口，用于访问 Python 解释器自身使用和维护的变量，同时模块中还提供了一部分函数，可以与解释器进行比较深度的交互。

2. 常用功能

2.1 sys.argv

“argv”即“argument value”的简写，是一个列表对象，其中存储的是在命令行调用 Python 脚本时提供的“命令行参数”。

这个列表中的第一个参数是被调用的脚本名称，也就是说，调用 Python 解释器的“命令”（python）本身并没有被加入这个列表当中。这个地方要注意一下，因为这一点跟 C 程序的行为有所不同，C 程序读取命令行参数是从头开始的。

举例来说，在当前目录下新建一个 Python 文件sys_argv_example.py，其内容为：

import sys

print("The list of command line arguments:\n", sys.argv)

在命令行运行该脚本：

$ python sys_argv_example.py

The list of command line arguments:

['example.py']

加上几个参数试试：

$ python sys_argv_example.py arg1 arg2 arg3

The list of command line arguments:

['example.py', 'arg1', 'arg2', 'arg3']

利用好这个属性，可以极大增强 Python 脚本的交互性。

2.2 sys.platform

在《第26天： Python 标准库之 os 模块详解》中，我们提到过“查看sys模块中的sys.platform属性可以得到关于运行平台更详细的信息”，这里我们就来试试：

>>> import sys

>>> sys.platform

'win32'

在 Linux 上：

>>> sys.platform

'linux'

比较一下os.name的结果，不难发现，sys.platform的信息更加准确。

2.3 sys.byteorder

“byteorder”即“字节序”，指的是在计算机内部存储数据时，数据的低位字节存储在存储空间中的高位还是低位。

“小端存储”时，数据的低位也存储在存储空间的低位地址中，此时sys.byteorder的值为“little”。如果不注意，在按地址顺序打印内容的时候，可能会把小端存储的内容打错。当前大部分机器都是使用的小端存储。

所以不出意外的话，你的机器上执行下述交互语句也应当跟我的结果一样：

>>> sys.byteorder

'little'

而另外还存在一种存储顺序是“大端存储”，即数据的高位字节存储在存储空间的低位地址上，此时sys.byteorder的值为“big”。

这种方式看起来好像很合理也很自然，因为我们一般在书面表示的时候都将低位地址写在左边，高位地址写在右边，大端存储的顺序就很符合人类的阅读习惯。但实际上对机器而言，内存地址并没有左右之分，所谓的“自然”其实并不存在。

抱歉我并没有使用大端存储的机器可以用作演示，因此只能说如果是大端存储的机器上运行 Python，输出结果应该像下面这样，也就是说下面这个示例并非我得到的真实运行结果，仅供参考：

>>> sys.byteorder

'big'

2.4 sys.executable

该属性是一个字符串，在正常情况下，其值是当前运行的 Python 解释器对应的可执行程序所在的绝对路径。

比如在 Windows 上使用 Anaconda 安装的 Python，该属性的值就是：

>>> sys.executable

'E:\\Anaconda\\Anaconda\\python.exe'

2.5 sys.modules

该属性是一个字典，包含的是各种已加载的模块的模块名到模块具体位置的映射。

通过手动修改这个字典，可以重新加载某些模块；但要注意，切记不要大意删除了一些基本的项，否则可能会导致 Python 整个儿无法运行。

关于其具体的值，由于内容过多，就不在此给出示例了，读者可以自行查看。

2.6 sys.builtin_module_names

该属性是一个字符串元组，其中的元素均为当前所使用的的 Python 解释器内置的模块名称。

注意区别sys.modules和sys.builtin_module_names——前者的关键字（keys）列出的是导入的模块名，而后者则是解释器内置的模块名。

其值示例如下：

>>> sys.builtin_module_names

2.7 sys.path

A list of strings that specifies the search path for modules. Initialized from the environment variable PYTHONPATH, plus an installation-dependent default.

该属性是一个由字符串组成的列表，其中各个元素表示的是 Python 搜索模块的路径；在程序启动期间被初始化。

其中第一个元素（也就是path[0]）的值是最初调用 Python 解释器的脚本所在的绝对路径；如果是在交互式环境下查看sys.path的值，就会得到一个空字符串。

命令行运行脚本（脚本代码见示例 sys_path_example.py）：

$ python sys_path_example.py

The path[0] = D:\justdopython\sys_example

交互式环境查看属性第一个元素：

>>> sys.path[0]

3. 进阶功能

3.1 sys.stdin

即 Python 的标准输入通道。通过改变这个属性为其他的类文件（file-like）对象，可以实现输入的重定向，也就是说可以用其他内容替换标准输入的内容。

所谓“标准输入”，实际上就是通过键盘输入的字符。

在示例（sys_stdin_example.py）中，我们尝试把这个属性的值改为一个打开的文件对象hello_python.txt，其中包含如下的内容：

Hello Python!

Just do Python, go~

Go, Go, GO!

由于input()使用的就是标准输入流，因此通过修改sys.stdin的值，我们使用老朋友input()函数，也可以实现对文件内容的读取，程序运行效果如下：

$ python sys_stdin_example.py

Hello Python!

Just do Python, go~

Go, Go, GO!

3.2 sys.stdout

与上一个“标准输入”类似，sys.stdout则是代表“标准输出”的属性。

通过将这个属性的值修改为某个文件对象，可以将本来要打印到屏幕上的内容写入文件。

比如运行示例程序sys_stdout_example.py，用来临时生成日志也是十分方便的：

import sys

# 以附加模式打开文件，若不存在则新建

with open("count_log.txt", 'a', encoding='utf-8') as f:

sys.stdout = f

for i in range(10):

print("count = ", i)

3.3 sys.err

与前面两个属性类似，只不过该属性标识的是标准错误，通常也是定向到屏幕的，可以粗糙地认为是一个输出错误信息的特殊的标准输出流。由于性质类似，因此不做演示。

此外，sys模块中还存在几个“私有”属性：sys.__stdin__，sys.__stdout__，sys.__stderr__。这几个属性中保存的就是最初定向的“标准输入”、“标准输出”和“标准错误”流。在适当的时侯，我们可以借助这三个属性将sys.stdin、sys.stdout和sys.err恢复为初始值。

3.4 sys.getrecursionlimit() 和 sys.setrecursionlimit()

sys.getrecursionlimit()和sys.setrecursionlimit()是成对的。前者可以获取 Python 的最大递归数目，后者则可以设置最大递归数目。因为初学阶段很少用到，因此只做了解。

3.5 sys.getrefcount()

在《第12天：Python 之引用》中我们其实已经用到过这个函数，其返回值是 Python 中某个对象被引用的次数。关于“引用”的知识可以回去看看这篇文章。

3.6 sys.getsizeof()

这个函数的作用与 C 语言中的sizeof运算符类似，返回的是作用对象所占用的字节数。

比如我们就可以看看一个整型对象1在内存中的大小：

>>> sys.getsizeof(1)

注意，在 Python 中，某类对象的大小并非一成不变的：

>>> sys.getsizeof(2**30-1)

>>> sys.getsizeof(2**30)

3.7 sys.int_info 和 sys.float_info

这两个属性分别给出了 Python 中两个重要的数据类型的相关信息。

其中sys.int_info的值为：

>>> sys.int_info

sys.int_info(bits_per_digit=30, sizeof_digit=4)

在文档中的解释为：

属性解释bits_per_digitnumber of bits held in each digit. Python integers are stored internally in base 2**int_info.bits_per_digitsizeof_digitsize in bytes of the C type used to represent a digit

指的是 Python 以 2 的sys.int_info.bits_per_digit次方为基来表示整数，也就是说它是“2 的sys.int_info.bits_per_digit次方进制”的数。这样的数每一个为都用 C 类中的 4 个字节来存储。

换句话说，每“进 1 位”（即整数值增加2 的sys.int_info.bits_per_digit次方），就需要多分配 4 个字节用以保存某个整数。

因此在sys.getsizeof()的示例中，我们可以看到2**30-1和2**30之间，虽然本身只差了 1，但是所占的字节后者却比前者多了 4。

而sys.float_info的值则是：

>>> sys.float_info

其中各项具体的含义就不在这里继续展开了，感兴趣的同学可以参看文档和《深入理解计算机系统》等讲解组成原理的书。

4. 一个有趣的功能

接下来让我们放松一下。

每次打开 Python 的交互式界面，我们都会看到一个提示符>>>。不知道你有没有想过要把这个东西换成另外的什么呢？

反正我没想过哈哈——至少在文档中看到这两个属性之前，我确实没有想过。哪两个属性呢？

就这俩货：sys.ps1和sys.ps2

所谓“ps”，应当是“prompts”的简写，即“提示符”。

这两个属性中，sys.ps1代表的是一级提示符，也就是进入 Python 交互界面之后就会出现的那一个>>>；而第二个sys.ps2则是二级提示符，是在同一级内容没有输入完，换行之后新行行首的提示符...。当然，两个属性都是字符串。

好了，知道怎么回事儿就好办了。

现在我们就来一个：

>>> sys.ps1 = "justdopython "

justdopython li = [1,2,3]

justdopython li[0]

justdopython

提示符已经被改变了，当然，有点长，不大美观哈哈。

咱们换一下：

justdopython sys.ps1 = "ILoveYou: "

ILoveYou: print("你可真是个小机灵鬼儿！")

你可真是个小机灵鬼儿！

ILoveYou:

有点儿意思吧？

注意不要忘了在字符串最后加个空格，否则提示符就会和你输入的内容混杂在一起了，会十分难看的哟~

示例代码：python-100-days

参考资料

Python3 标准库-sys 模块

优惠劵

轩辕御龙

关注

踩

觉得还不错?

一键收藏

知道了

Python 标准库之 sys 模块详解

Python sys 模块详解1. 简介“sys”即“system”，“系统”之意。该模块提供了一些接口，用于访问 Python 解释器自身使用和维护的变量，同时模块中还提供了一部分函数，可以与解释器进行比较深度的交互。2. 常用功能2.1 sys.argv“argv”即“argument value”的简写，是一个列表对象，其中存储的是在命令行调用 Python 脚本时提供的“命令行参...

复制链接

扫一扫

专栏目录

python之sys模块详解_(转)python之os,sys模块详解

weixin_35436076的博客

03-02

276

python之sys模块详解原文：http://www.cnblogs.com/cherishry/p/5725184.htmlsys模块功能多，我们这里介绍一些比较实用的功能，相信你会喜欢的，和我一起走进python的模块吧！sys模块的常见函数列表sys.argv: 实现从程序外部向程序传递参数。 sys.exit([arg]): 程序中间的退出，arg=0为正常退出。 sys.getde...

盘点Python编程语言sys库中的7个常用函数

pdcfighting的博客

10-08

542

点击上方“Go语言进阶学习”，进行关注回复“Go语言”即可获赠Python从入门到进阶共10本电子书今日鸡汤青泥何盘盘，百步九折萦岩峦。一、概念这是一个跟 Python 解释器关系密切的...

参与评论

您还未登录，请先

后发表或查看评论

【Python】sys库的介绍及用法

最新文章

Python一时爽，一直Python一直爽

再谈Python的引用和变量

你的代码长啥样？

2020年16篇

2019年28篇

2018年1篇

分类专栏

工具

4篇

Python

16篇

Flutter

1篇

移动开发

1篇

汇编语言

2篇

计算机基础知识

22篇

C语言

1篇

阅读

18篇

轩辕诗集

个人网站

2篇

数学之美

1篇

深度学习

3篇

被折叠的条评论

为什么被折叠?

到【灌水乐园】发言

查看更多评论

添加红包

祝福语

请填写红包祝福语或标题

红包数量

个

红包个数最小为10个

红包总金额

元

红包金额最低5元

余额支付

当前余额3.43元

前往充值 >

需支付：10.00元

取消

确定

下一步

知道了

成就一亿技术人!

领取后你会自动成为博主和红包主的粉丝

规则

hope_wisdom 发出的红包

实付元

使用余额支付

点击重新获取

扫码支付

钱包余额

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值

sys — System-specific parameters and functions — Python 3.12.2 documentation

Theme

Auto

Light

Dark

Previous topic

Python Runtime Services

Next topic

sys.monitoring — Execution event monitoring

This Page

Report a Bug

Show Source

Navigation

index

modules |

next |

previous |

Python »

3.12.2 Documentation »

The Python Standard Library »

Python Runtime Services »

sys — System-specific parameters and functions

Theme

Auto

Light

Dark

sys — System-specific parameters and functions¶

This module provides access to some variables used or maintained by the

interpreter and to functions that interact strongly with the interpreter. It is

always available.

sys.abiflags¶

On POSIX systems where Python was built with the standard configure

script, this contains the ABI flags as specified by PEP 3149.

New in version 3.2.

Changed in version 3.8: Default flags became an empty string (m flag for pymalloc has been

removed).

Availability: Unix.

sys.addaudithook(hook)¶

Append the callable hook to the list of active auditing hooks for the

current (sub)interpreter.

When an auditing event is raised through the sys.audit() function, each

hook will be called in the order it was added with the event name and the

tuple of arguments. Native hooks added by PySys_AddAuditHook() are

called first, followed by hooks added in the current (sub)interpreter. Hooks

can then log the event, raise an exception to abort the operation,

or terminate the process entirely.

Note that audit hooks are primarily for collecting information about internal

or otherwise unobservable actions, whether by Python or libraries written in

Python. They are not suitable for implementing a “sandbox”. In particular,

malicious code can trivially disable or bypass hooks added using this

function. At a minimum, any security-sensitive hooks must be added using the

C API PySys_AddAuditHook() before initialising the runtime, and any

modules allowing arbitrary memory modification (such as ctypes) should

be completely removed or closely monitored.

Calling sys.addaudithook() will itself raise an auditing event

named sys.addaudithook with no arguments. If any

existing hooks raise an exception derived from RuntimeError, the

new hook will not be added and the exception suppressed. As a result,

callers cannot assume that their hook has been added unless they control

all existing hooks.

See the audit events table for all events raised by

CPython, and PEP 578 for the original design discussion.

New in version 3.8.

Changed in version 3.8.1: Exceptions derived from Exception but not RuntimeError

are no longer suppressed.

CPython implementation detail: When tracing is enabled (see settrace()), Python hooks are only

traced if the callable has a __cantrace__ member that is set to a

true value. Otherwise, trace functions will skip the hook.

sys.argv¶

The list of command line arguments passed to a Python script. argv[0] is the

script name (it is operating system dependent whether this is a full pathname or

not). If the command was executed using the -c command line option to

the interpreter, argv[0] is set to the string '-c'. If no script name

was passed to the Python interpreter, argv[0] is the empty string.

To loop over the standard input, or the list of files given on the

command line, see the fileinput module.

See also

The sys.unraisablehook() function handles unraisable exceptions

and the threading.excepthook() function handles exception raised

by threading.Thread.run().

sys.__breakpointhook__¶

sys.__displayhook__¶

sys.__excepthook__¶

sys.__unraisablehook__¶

These objects contain the original values of breakpointhook,

displayhook, excepthook, and unraisablehook at the start of the

program. They are saved so that breakpointhook, displayhook and

excepthook, unraisablehook can be restored in case they happen to

get replaced with broken or alternative objects.

New in version 3.7: __breakpointhook__

New in version 3.8: __unraisablehook__

sys.exception()¶

This function, when called while an exception handler is executing (such as

an except or except* clause), returns the exception instance that

was caught by this handler. When exception handlers are nested within one

another, only the exception handled by the innermost handler is accessible.

If no exception handler is executing, this function returns None.

New in version 3.11.

sys.exc_info()¶

This function returns the old-style representation of the handled

exception. If an exception e is currently handled (so

exception() would return e), exc_info() returns the

tuple (type(e), e, e.__traceback__).

That is, a tuple containing the type of the exception (a subclass of

BaseException), the exception itself, and a traceback

object which typically encapsulates the call

stack at the point where the exception last occurred.

If no exception is being handled anywhere on the stack, this function

return a tuple containing three None values.

Changed in version 3.11: The type and traceback fields are now derived from the value

(the exception instance), so when an exception is modified while it is

being handled, the changes are reflected in the results of subsequent

calls to exc_info().

sys.exec_prefix¶

A string giving the site-specific directory prefix where the platform-dependent

Python files are installed; by default, this is also '/usr/local'. This can

be set at build time with the --exec-prefix argument to the

configure script. Specifically, all configuration files (e.g. the

pyconfig.h header file) are installed in the directory

exec_prefix/lib/pythonX.Y/config, and shared library modules are

installed in exec_prefix/lib/pythonX.Y/lib-dynload, where X.Y

is the version number of Python, for example 3.2.

Note

If a virtual environment is in effect, this

value will be changed in site.py to point to the virtual environment.

The value for the Python installation will still be available, via

base_exec_prefix.

sys.executable¶

A string giving the absolute path of the executable binary for the Python

interpreter, on systems where this makes sense. If Python is unable to retrieve

the real path to its executable, sys.executable will be an empty string

or None.

sys.exit([arg])¶

Raise a SystemExit exception, signaling an intention to exit the interpreter.

The optional argument arg can be an integer giving the exit status

(defaulting to zero), or another type of object. If it is an integer, zero

is considered “successful termination” and any nonzero value is considered

“abnormal termination” by shells and the like. Most systems require it to be

in the range 0–127, and produce undefined results otherwise. Some systems

have a convention for assigning specific meanings to specific exit codes, but

these are generally underdeveloped; Unix programs generally use 2 for command

line syntax errors and 1 for all other kind of errors. If another type of

object is passed, None is equivalent to passing zero, and any other

object is printed to stderr and results in an exit code of 1. In

particular, sys.exit("some error message") is a quick way to exit a

program when an error occurs.

Since exit() ultimately “only” raises an exception, it will only exit

the process when called from the main thread, and the exception is not

intercepted. Cleanup actions specified by finally clauses of try statements

are honored, and it is possible to intercept the exit attempt at an outer level.

Changed in version 3.6: If an error occurs in the cleanup after the Python interpreter

has caught SystemExit (such as an error flushing buffered data

in the standard streams), the exit status is changed to 120.

sys.flags¶

The named tuple flags exposes the status of command line

flags. The attributes are read only.

flags.debug¶

-d

flags.inspect¶

-i

flags.interactive¶

-i

flags.isolated¶

-I

flags.optimize¶

-O or -OO

flags.dont_write_bytecode¶

-B

flags.no_user_site¶

-s

flags.no_site¶

-S

flags.ignore_environment¶

-E

flags.verbose¶

-v

flags.bytes_warning¶

-b

flags.quiet¶

-q

flags.hash_randomization¶

-R

flags.dev_mode¶

-X dev (Python Development Mode)

flags.utf8_mode¶

-X utf8

flags.safe_path¶

-P

flags.int_max_str_digits¶

-X int_max_str_digits

(integer string conversion length limitation)

flags.warn_default_encoding¶

-X warn_default_encoding

Changed in version 3.2: Added quiet attribute for the new -q flag.

New in version 3.2.3: The hash_randomization attribute.

Changed in version 3.3: Removed obsolete division_warning attribute.

Changed in version 3.4: Added isolated attribute for -I isolated flag.

Changed in version 3.7: Added the dev_mode attribute for the new Python Development

Mode and the utf8_mode attribute for the new -X

utf8 flag.

Changed in version 3.10: Added warn_default_encoding attribute for -X warn_default_encoding flag.

Changed in version 3.11: Added the safe_path attribute for -P option.

Changed in version 3.11: Added the int_max_str_digits attribute.

sys.float_info¶

A named tuple holding information about the float type. It

contains low level information about the precision and internal

representation. The values correspond to the various floating-point

constants defined in the standard header file float.h for the ‘C’

programming language; see section 5.2.4.2.2 of the 1999 ISO/IEC C standard

[C99], ‘Characteristics of floating types’, for details.

Attributes of the float_info named tuple¶

attribute

float.h macro

explanation

float_info.epsilon¶

DBL_EPSILON

difference between 1.0 and the least value greater than 1.0 that is

representable as a float.

See also

importlib.abc.MetaPathFinderThe abstract base class defining the interface of finder objects on

meta_path.

importlib.machinery.ModuleSpecThe concrete class which

find_spec() should return

instances of.

Changed in version 3.4: Module specs were introduced in Python 3.4, by

PEP 451.

Changed in version 3.12: Removed the fallback that looked for a find_module() method

if a meta_path entry didn’t have a

find_spec() method.

sys.modules¶

This is a dictionary that maps module names to modules which have already been

loaded. This can be manipulated to force reloading of modules and other tricks.

However, replacing the dictionary will not necessarily work as expected and

deleting essential items from the dictionary may cause Python to fail. If

you want to iterate over this global dictionary always use

sys.modules.copy() or tuple(sys.modules) to avoid exceptions as its

size may change during iteration as a side effect of code or activity in

other threads.

sys.orig_argv¶

The list of the original command line arguments passed to the Python

executable.

The elements of sys.orig_argv are the arguments to the Python interpreter,

while the elements of sys.argv are the arguments to the user’s program.

Arguments consumed by the interpreter itself will be present in sys.orig_argv

and missing from sys.argv.

New in version 3.10.

sys.path¶

A list of strings that specifies the search path for modules. Initialized from

the environment variable PYTHONPATH, plus an installation-dependent

default.

By default, as initialized upon program startup, a potentially unsafe path

is prepended to sys.path (before the entries inserted as a result

of PYTHONPATH):

python -m module command line: prepend the current working

directory.

python script.py command line: prepend the script’s directory.

If it’s a symbolic link, resolve symbolic links.

python -c code and python (REPL) command lines: prepend an empty

string, which means the current working directory.

To not prepend this potentially unsafe path, use the -P command

line option or the PYTHONSAFEPATH environment variable.

A program is free to modify this list for its own purposes. Only strings

should be added to sys.path; all other data types are

ignored during import.

See also

Module site This describes how to use .pth files to

extend sys.path.

sys.path_hooks¶

A list of callables that take a path argument to try to create a

finder for the path. If a finder can be created, it is to be

returned by the callable, else raise ImportError.

Originally specified in PEP 302.

sys.path_importer_cache¶

A dictionary acting as a cache for finder objects. The keys are

paths that have been passed to sys.path_hooks and the values are

the finders that are found. If a path is a valid file system path but no

finder is found on sys.path_hooks then None is

stored.

Originally specified in PEP 302.

sys.platform¶

This string contains a platform identifier that can be used to append

platform-specific components to sys.path, for instance.

For Unix systems, except on Linux and AIX, this is the lowercased OS name as

returned by uname -s with the first part of the version as returned by

uname -r appended, e.g. 'sunos5' or 'freebsd8', at the time

when Python was built. Unless you want to test for a specific system

version, it is therefore recommended to use the following idiom:

if sys.platform.startswith('freebsd'):

# FreeBSD-specific code here...

elif sys.platform.startswith('linux'):

# Linux-specific code here...

elif sys.platform.startswith('aix'):

# AIX-specific code here...

For other systems, the values are:

System

platform value

AIX

'aix'

Emscripten

'emscripten'

Linux

'linux'

WASI

'wasi'

Windows

'win32'

Windows/Cygwin

'cygwin'

macOS

'darwin'

Changed in version 3.3: On Linux, sys.platform doesn’t contain the major version anymore.

It is always 'linux', instead of 'linux2' or 'linux3'. Since

older Python versions include the version number, it is recommended to

always use the startswith idiom presented above.

Changed in version 3.8: On AIX, sys.platform doesn’t contain the major version anymore.

It is always 'aix', instead of 'aix5' or 'aix7'. Since

older Python versions include the version number, it is recommended to

always use the startswith idiom presented above.

See also

os.name has a coarser granularity. os.uname() gives

system-dependent version information.

The platform module provides detailed checks for the

system’s identity.

sys.platlibdir¶

Name of the platform-specific library directory. It is used to build the

path of standard library and the paths of installed extension modules.

It is equal to "lib" on most platforms. On Fedora and SuSE, it is equal

to "lib64" on 64-bit platforms which gives the following sys.path

paths (where X.Y is the Python major.minor version):

/usr/lib64/pythonX.Y/:

Standard library (like os.py of the os module)

/usr/lib64/pythonX.Y/lib-dynload/:

C extension modules of the standard library (like the errno module,

the exact filename is platform specific)

/usr/lib/pythonX.Y/site-packages/ (always use lib, not

sys.platlibdir): Third-party modules

/usr/lib64/pythonX.Y/site-packages/:

C extension modules of third-party packages

New in version 3.9.

sys.prefix¶

A string giving the site-specific directory prefix where the platform

independent Python files are installed; on Unix, the default is

/usr/local. This can be set at build time with the --prefix

argument to the configure script. See

Installation paths for derived paths.

Note

If a virtual environment is in effect, this

value will be changed in site.py to point to the virtual

environment. The value for the Python installation will still be

available, via base_prefix.

sys.ps1¶

sys.ps2¶

Strings specifying the primary and secondary prompt of the interpreter. These

are only defined if the interpreter is in interactive mode. Their initial

values in this case are '>>> ' and '... '. If a non-string object is

assigned to either variable, its str() is re-evaluated each time the

interpreter prepares to read a new interactive command; this can be used to

implement a dynamic prompt.

sys.setdlopenflags(n)¶

Set the flags used by the interpreter for dlopen() calls, such as when

the interpreter loads extension modules. Among other things, this will enable a

lazy resolving of symbols when importing a module, if called as

sys.setdlopenflags(0). To share symbols across extension modules, call as

sys.setdlopenflags(os.RTLD_GLOBAL). Symbolic names for the flag values

can be found in the os module (RTLD_xxx constants, e.g.

os.RTLD_LAZY).

Availability: Unix.

sys.set_int_max_str_digits(maxdigits)¶

Set the integer string conversion length limitation used by this interpreter. See also

get_int_max_str_digits().

New in version 3.11.

sys.setprofile(profilefunc)¶

Set the system’s profile function, which allows you to implement a Python source

code profiler in Python. See chapter The Python Profilers for more information on the

Python profiler. The system’s profile function is called similarly to the

system’s trace function (see settrace()), but it is called with different events,

for example it isn’t called for each executed line of code (only on call and return,

but the return event is reported even when an exception has been set). The function is

thread-specific, but there is no way for the profiler to know about context switches between

threads, so it does not make sense to use this in the presence of multiple threads. Also,

its return value is not used, so it can simply return None. Error in the profile

function will cause itself unset.

Note

The same tracing mechanism is used for setprofile() as settrace().

To trace calls with setprofile() inside a tracing function

(e.g. in a debugger breakpoint), see call_tracing().

Profile functions should have three arguments: frame, event, and

arg. frame is the current stack frame. event is a string: 'call',

'return', 'c_call', 'c_return', or 'c_exception'. arg depends

on the event type.

The events have the following meaning:

'call'A function is called (or some other code block entered). The

profile function is called; arg is None.

'return'A function (or other code block) is about to return. The profile

function is called; arg is the value that will be returned, or None

if the event is caused by an exception being raised.

'c_call'A C function is about to be called. This may be an extension function or

a built-in. arg is the C function object.

'c_return'A C function has returned. arg is the C function object.

'c_exception'A C function has raised an exception. arg is the C function object.

Raises an auditing event sys.setprofile with no arguments.

sys.setrecursionlimit(limit)¶

Set the maximum depth of the Python interpreter stack to limit. This limit

prevents infinite recursion from causing an overflow of the C stack and crashing

Python.

The highest possible limit is platform-dependent. A user may need to set the

limit higher when they have a program that requires deep recursion and a platform

that supports a higher limit. This should be done with care, because a too-high

limit can lead to a crash.

If the new limit is too low at the current recursion depth, a

RecursionError exception is raised.

Changed in version 3.5.1: A RecursionError exception is now raised if the new limit is too

low at the current recursion depth.

sys.setswitchinterval(interval)¶

Set the interpreter’s thread switch interval (in seconds). This floating-point

value determines the ideal duration of the “timeslices” allocated to

concurrently running Python threads. Please note that the actual value

can be higher, especially if long-running internal functions or methods

are used. Also, which thread becomes scheduled at the end of the interval

is the operating system’s decision. The interpreter doesn’t have its

own scheduler.

New in version 3.2.

sys.settrace(tracefunc)¶

Set the system’s trace function, which allows you to implement a Python

source code debugger in Python. The function is thread-specific; for a

debugger to support multiple threads, it must register a trace function using

settrace() for each thread being debugged or use threading.settrace().

Trace functions should have three arguments: frame, event, and

arg. frame is the current stack frame. event is a string: 'call',

'line', 'return', 'exception' or 'opcode'. arg depends on

the event type.

The trace function is invoked (with event set to 'call') whenever a new

local scope is entered; it should return a reference to a local trace

function to be used for the new scope, or None if the scope shouldn’t be

traced.

The local trace function should return a reference to itself, or to another

function which would then be used as the local trace function for the scope.

If there is any error occurred in the trace function, it will be unset, just

like settrace(None) is called.

Note

Tracing is disabled while calling the trace function (e.g. a function set by

settrace()). For recursive tracing see call_tracing().

The events have the following meaning:

'call'A function is called (or some other code block entered). The

global trace function is called; arg is None; the return value

specifies the local trace function.

'line'The interpreter is about to execute a new line of code or re-execute the

condition of a loop. The local trace function is called; arg is

None; the return value specifies the new local trace function. See

Objects/lnotab_notes.txt for a detailed explanation of how this

works.

Per-line events may be disabled for a frame by setting

f_trace_lines to False on that

frame.

'return'A function (or other code block) is about to return. The local trace

function is called; arg is the value that will be returned, or None

if the event is caused by an exception being raised. The trace function’s

return value is ignored.

'exception'An exception has occurred. The local trace function is called; arg is a

tuple (exception, value, traceback); the return value specifies the

new local trace function.

'opcode'The interpreter is about to execute a new opcode (see dis for

opcode details). The local trace function is called; arg is

None; the return value specifies the new local trace function.

Per-opcode events are not emitted by default: they must be explicitly

requested by setting f_trace_opcodes to True on the

frame.

Note that as an exception is propagated down the chain of callers, an

'exception' event is generated at each level.

For more fine-grained usage, it’s possible to set a trace function by

assigning frame.f_trace = tracefunc explicitly, rather than relying on

it being set indirectly via the return value from an already installed

trace function. This is also required for activating the trace function on

the current frame, which settrace() doesn’t do. Note that in order

for this to work, a global tracing function must have been installed

with settrace() in order to enable the runtime tracing machinery,

but it doesn’t need to be the same tracing function (e.g. it could be a

low overhead tracing function that simply returns None to disable

itself immediately on each frame).

For more information on code and frame objects, refer to The standard type hierarchy.

Raises an auditing event sys.settrace with no arguments.

CPython implementation detail: The settrace() function is intended only for implementing debuggers,

profilers, coverage tools and the like. Its behavior is part of the

implementation platform, rather than part of the language definition, and

thus may not be available in all Python implementations.

Changed in version 3.7: 'opcode' event type added; f_trace_lines and

f_trace_opcodes attributes added to frames

Changed in version 3.12: 'opcode' event will only be emitted if f_trace_opcodes

of at least one frame has been set to True before settrace()

is called. This behavior will be changed back in 3.13 to be consistent with

previous versions.

sys.set_asyncgen_hooks([firstiter] [, finalizer])¶

Accepts two optional keyword arguments which are callables that accept an

asynchronous generator iterator as an argument. The firstiter

callable will be called when an asynchronous generator is iterated for the

first time. The finalizer will be called when an asynchronous generator

is about to be garbage collected.

Raises an auditing event sys.set_asyncgen_hooks_firstiter with no arguments.

Raises an auditing event sys.set_asyncgen_hooks_finalizer with no arguments.

Two auditing events are raised because the underlying API consists of two

calls, each of which must raise its own event.

New in version 3.6: See PEP 525 for more details, and for a reference example of a

finalizer method see the implementation of

asyncio.Loop.shutdown_asyncgens in

Lib/asyncio/base_events.py

Note

This function has been added on a provisional basis (see PEP 411

for details.)

sys.set_coroutine_origin_tracking_depth(depth)¶

Allows enabling or disabling coroutine origin tracking. When

enabled, the cr_origin attribute on coroutine objects will

contain a tuple of (filename, line number, function name) tuples

describing the traceback where the coroutine object was created,

with the most recent call first. When disabled, cr_origin will

be None.

To enable, pass a depth value greater than zero; this sets the

number of frames whose information will be captured. To disable,

pass set depth to zero.

This setting is thread-specific.

New in version 3.7.

Note

This function has been added on a provisional basis (see PEP 411

for details.) Use it only for debugging purposes.

sys.activate_stack_trampoline(backend, /)¶

Activate the stack profiler trampoline backend.

The only supported backend is "perf".

Availability: Linux.

New in version 3.12.

See also

Python support for the Linux perf profiler

https://perf.wiki.kernel.org

sys.deactivate_stack_trampoline()¶

Deactivate the current stack profiler trampoline backend.

If no stack profiler is activated, this function has no effect.

Availability: Linux.

New in version 3.12.

sys.is_stack_trampoline_active()¶

Return True if a stack profiler trampoline is active.

Availability: Linux.

New in version 3.12.

sys._enablelegacywindowsfsencoding()¶

Changes the filesystem encoding and error handler to ‘mbcs’ and

‘replace’ respectively, for consistency with versions of Python prior to

3.6.

This is equivalent to defining the PYTHONLEGACYWINDOWSFSENCODING

environment variable before launching Python.

See also sys.getfilesystemencoding() and

sys.getfilesystemencodeerrors().

Availability: Windows.

New in version 3.6: See PEP 529 for more details.

sys.stdin¶

sys.stdout¶

sys.stderr¶

File objects used by the interpreter for standard

input, output and errors:

stdin is used for all interactive input (including calls to

input());

stdout is used for the output of print() and expression

statements and for the prompts of input();

The interpreter’s own prompts and its error messages go to stderr.

These streams are regular text files like those

returned by the open() function. Their parameters are chosen as

follows:

The encoding and error handling are is initialized from

PyConfig.stdio_encoding and PyConfig.stdio_errors.

On Windows, UTF-8 is used for the console device. Non-character

devices such as disk files and pipes use the system locale

encoding (i.e. the ANSI codepage). Non-console character

devices such as NUL (i.e. where isatty() returns True) use the

value of the console input and output codepages at startup,

respectively for stdin and stdout/stderr. This defaults to the

system locale encoding if the process is not initially attached

to a console.

The special behaviour of the console can be overridden

by setting the environment variable PYTHONLEGACYWINDOWSSTDIO

before starting Python. In that case, the console codepages are

used as for any other character device.

Under all platforms, you can override the character encoding by

setting the PYTHONIOENCODING environment variable before

starting Python or by using the new -X utf8 command

line option and PYTHONUTF8 environment variable. However,

for the Windows console, this only applies when

PYTHONLEGACYWINDOWSSTDIO is also set.

When interactive, the stdout stream is line-buffered. Otherwise,

it is block-buffered like regular text files. The stderr stream

is line-buffered in both cases. You can make both streams unbuffered

by passing the -u command-line option or setting the

PYTHONUNBUFFERED environment variable.

Changed in version 3.9: Non-interactive stderr is now line-buffered instead of fully

buffered.

Note

To write or read binary data from/to the standard streams, use the

underlying binary buffer object. For example, to

write bytes to stdout, use sys.stdout.buffer.write(b'abc').

However, if you are writing a library (and do not control in which

context its code will be executed), be aware that the standard streams

may be replaced with file-like objects like io.StringIO which

do not support the buffer attribute.

sys.__stdin__¶

sys.__stdout__¶

sys.__stderr__¶

These objects contain the original values of stdin, stderr and

stdout at the start of the program. They are used during finalization,

and could be useful to print to the actual standard stream no matter if the

sys.std* object has been redirected.

It can also be used to restore the actual files to known working file objects

in case they have been overwritten with a broken object. However, the

preferred way to do this is to explicitly save the previous stream before

replacing it, and restore the saved object.

Note

Under some conditions stdin, stdout and stderr as well as the

original values __stdin__, __stdout__ and __stderr__ can be

None. It is usually the case for Windows GUI apps that aren’t connected

to a console and Python apps started with pythonw.

sys.stdlib_module_names¶

A frozenset of strings containing the names of standard library modules.

It is the same on all platforms. Modules which are not available on

some platforms and modules disabled at Python build are also listed.

All module kinds are listed: pure Python, built-in, frozen and extension

modules. Test modules are excluded.

For packages, only the main package is listed: sub-packages and sub-modules

are not listed. For example, the email package is listed, but the

email.mime sub-package and the email.message sub-module are not

listed.

See also the sys.builtin_module_names list.

New in version 3.10.

sys.thread_info¶

A named tuple holding information about the thread

implementation.

thread_info.name¶

The name of the thread implementation:

"nt": Windows threads

"pthread": POSIX threads

"pthread-stubs": stub POSIX threads

(on WebAssembly platforms without threading support)

"solaris": Solaris threads

thread_info.lock¶

The name of the lock implementation:

"semaphore": a lock uses a semaphore

"mutex+cond": a lock uses a mutex and a condition variable

None if this information is unknown

thread_info.version¶

The name and version of the thread library.

It is a string, or None if this information is unknown.

New in version 3.3.

sys.tracebacklimit¶

When this variable is set to an integer value, it determines the maximum number

of levels of traceback information printed when an unhandled exception occurs.

The default is 1000. When set to 0 or less, all traceback information

is suppressed and only the exception type and value are printed.

sys.unraisablehook(unraisable, /)¶

Handle an unraisable exception.

Called when an exception has occurred but there is no way for Python to

handle it. For example, when a destructor raises an exception or during

garbage collection (gc.collect()).

The unraisable argument has the following attributes:

exc_type: Exception type.

exc_value: Exception value, can be None.

exc_traceback: Exception traceback, can be None.

err_msg: Error message, can be None.

object: Object causing the exception, can be None.

The default hook formats err_msg and object as:

f'{err_msg}: {object!r}'; use “Exception ignored in” error message

if err_msg is None.

sys.unraisablehook() can be overridden to control how unraisable

exceptions are handled.

See also

excepthook() which handles uncaught exceptions.

Warning

Storing exc_value using a custom hook can create a reference cycle.

It should be cleared explicitly to break the reference cycle when the

exception is no longer needed.

Storing object using a custom hook can resurrect it if it is set to an

object which is being finalized. Avoid storing object after the custom

hook completes to avoid resurrecting objects.

Raise an auditing event sys.unraisablehook with arguments

hook, unraisable when an exception that cannot be handled occurs.

The unraisable object is the same as what will be passed to the hook.

If no hook has been set, hook may be None.

New in version 3.8.

sys.version¶

A string containing the version number of the Python interpreter plus additional

information on the build number and compiler used. This string is displayed

when the interactive interpreter is started. Do not extract version information

out of it, rather, use version_info and the functions provided by the

platform module.

sys.api_version¶

The C API version for this interpreter. Programmers may find this useful when

debugging version conflicts between Python and extension modules.

sys.version_info¶

A tuple containing the five components of the version number: major, minor,

micro, releaselevel, and serial. All values except releaselevel are

integers; the release level is 'alpha', 'beta', 'candidate', or

'final'. The version_info value corresponding to the Python version 2.0

is (2, 0, 0, 'final', 0). The components can also be accessed by name,

so sys.version_info[0] is equivalent to sys.version_info.major

and so on.

Changed in version 3.1: Added named component attributes.

sys.warnoptions¶

This is an implementation detail of the warnings framework; do not modify this

value. Refer to the warnings module for more information on the warnings

framework.

sys.winver¶

The version number used to form registry keys on Windows platforms. This is

stored as string resource 1000 in the Python DLL. The value is normally the

major and minor versions of the running Python interpreter. It is provided in the sys

module for informational purposes; modifying this value has no effect on the

registry keys used by Python.

Availability: Windows.

sys.monitoring

Namespace containing functions and constants for register callbacks

and controlling monitoring events.

See sys.monitoring for details.

sys._xoptions¶

A dictionary of the various implementation-specific flags passed through

the -X command-line option. Option names are either mapped to

their values, if given explicitly, or to True. Example:

$ ./python -Xa=b -Xc

Python 3.2a3+ (py3k, Oct 16 2010, 20:14:50)

[GCC 4.4.3] on linux2

Type "help", "copyright", "credits" or "license" for more information.

>>> import sys

>>> sys._xoptions

{'a': 'b', 'c': True}

CPython implementation detail: This is a CPython-specific way of accessing options passed through

-X. Other implementations may export them through other

means, or not at all.

New in version 3.2.

Citations

[C99]

ISO/IEC 9899:1999. “Programming languages – C.” A public draft of this standard is available at https://www.open-std.org/jtc1/sc22/wg14/www/docs/n1256.pdf.

Previous topic

Python Runtime Services

Next topic

sys.monitoring — Execution event monitoring

This Page

Report a Bug

Show Source

Navigation

index

modules |

next |

previous |

Python »

3.12.2 Documentation »

The Python Standard Library »

Python Runtime Services »

sys — System-specific parameters and functions

Theme

Auto

Light

Dark

This page is licensed under the Python Software Foundation License Version 2.

Examples, recipes, and other code in the documentation are additionally licensed under the Zero Clause BSD License.

See History and License for more information.

The Python Software Foundation is a non-profit corporation.

Please donate.

Last updated on Mar 06, 2024 (20:51 UTC).

Found a bug?

Created using Sphinx 7.2.6.

Python 中5个必须了解的sys模块的用法 - 知乎

Python 中5个必须了解的sys模块的用法 - 知乎切换模式写文章登录/注册Python 中5个必须了解的sys模块的用法高小虎可以说 sys 是 python 中的解释器模块，因为它提供了一些变量和函数，这些变量可被解释器(interpreter)使用，也可由解释器提供，它们之间由此产生交互功能。1. 命令行参数传递给 Python 程序的命令行参数由 sys 模块存储在名为 argv 的列表中。默认情况下，argv 的长度为1，由程序名称组成。假如我写了一个名为 test.py 程序，内容如下：from sys import argv

# 打印 'argv' 中所有参数

for i in range(len(argv)):

print(argv[i])然后我在命令行下运行这个程序：它输出了该程序的名称，如果我在其后面添加几个参数：它会该程序名称和后面所有的参数。2.退出 Python 程序在某些情况下，sys 模块的退出功能可用于终止程序并从程序退出。传递给exit的参数是可选的。例如：import sys

password = input()

if(password == '错误的密码'):

print('密码错误')

sys.exit()

else:

print('欢迎光临')3.设置并获取Python解释器堆栈的深度我们可以通过"setrecursionlimit"功能设置解释器堆栈深度。此限制可防止无限递归导致 C 堆栈溢出和 Python 崩溃。 sys 模块中的"getrecursionlimit"函数返回递归限制的当前值，即 Python 解释器堆栈的最大深度。import sys

# 请不要设置负数或者将值设置的过低

limit = int(input('Python 解释器堆栈的深度应该是多少 '))

sys.setrecursionlimit(limit)

print('堆栈的深度应该是', sys.getrecursionlimit())4.获取解释器版本在Python中，解释器的高级版本具有一些高级功能，较旧版本的解释器可能不支持。在这种情况下，我们必须确定解释器的版本是否可以使用某些较新的功能。 sys.hexversion 可用于查找解释器的版本。import sys

# 检查解释器的版本是否至少为1.5.2

if sys.hexversion >= 0x010502F0:

# 这有些高级的功能

# ...

else:

# 给它个吓人的提示

# ...5.确定系统(OS)版本程序中某些功能的实现可能因平台而异。在 Linux上运行的代码可能无法在 Windows 上运行，反之亦然。在这种情况下，我们需要根据平台编写单独的代码。为此，我们可以使用 sys.platform 标识主机操作系统。import sys

platform = sys.platform

if platform == 'linux':

# Linux 的代码

print('这是 linux 系统')

elif platform == 'win32':

# Windows 的代码

print('这是 windows 系统')

elif platform == 'darwin':

# macOS 的代码

print('这是苹果系统')发布于 2021-02-04 15:19Python虚拟机Python解释器赞同 4添加评论分享喜欢收藏申请

Python中的sys模块详解_python sys模块详解-CSDN博客

Python中的sys模块详解

Rocky006

于 2023-11-03 17:02:59 发布

阅读量527

点赞数

文章标签：

python

开发语言

本文链接：https://blog.csdn.net/Rocky006/article/details/134182779

版权

1. 简介

sys模块是Python标准库中的一个内置模块，提供了与Python解释器和运行环境相关的功能。它包含了一些与系统操作和交互相关的函数和变量，可以用于获取命令行参数、控制程序的执行、管理模块和包、处理异常等。

2. 常用函数和变量

2.1 命令行参数

sys模块提供了一些函数和变量用于获取和处理命令行参数。

sys.argv：是一个包含命令行参数的列表，其中第一个元素是脚本的名称。可以使用sys.argv[1:]来获取除脚本名称外的所有参数。

sys.argv[0]：是脚本的名称。 sys.argv[1:]：是除脚本名称外的所有参数。

示例：

import sys

# 获取脚本的名称

script_name = sys.argv[0]

print("脚本名称：", script_name)

# 获取除脚本名称外的所有参数

args = sys.argv[1:]

print("参数列表：", args)

2.2 系统相关

sys模块还提供了一些函数和变量用于与系统相关的操作。 sys.platform：是一个字符串，表示当前运行的操作系统平台。 sys.version：是一个字符串，表示当前Python解释器的版本。 sys.exit([arg])：用于退出程序，可选地指定一个整数参数作为退出状态码。

示例：

import sys

# 获取当前操作系统平台

platform = sys.platform

print("操作系统平台：", platform)

# 获取当前Python解释器的版本

version = sys.version

print("Python版本：", version)

# 退出程序

sys.exit(0)

2.3 模块和包

sys模块还提供了一些函数和变量用于管理模块和包。

sys.modules：是一个字典，包含了当前已导入的所有模块。 sys.path：是一个列表，包含了Python解释器在搜索模块时要查找的路径。 sys.meta_path：是一个列表，包含了当前已注册的所有导入钩子。

示例：

import sys

# 获取已导入的所有模块

modules = sys.modules

print("已导入的模块：", modules)

# 获取模块搜索路径

path = sys.path

print("模块搜索路径：", path)

# 获取已注册的导入钩子

meta_path = sys.meta_path

print("已注册的导入钩子：", meta_path)

2.4 异常处理

sys模块还提供了一些函数和变量用于处理异常。

sys.exc_info()：返回当前异常的相关信息，包括异常类型、异常值和异常追踪信息。 sys.exc_clear()：清除当前异常。 sys.exc_type：是一个变量，保存了当前异常的类型。 sys.exc_value：是一个变量，保存了当前异常的值。 sys.exc_traceback：是一个变量，保存了当前异常的追踪信息。示例：

import sys

try:

# 产生一个异常

raise ValueError("发生了一个错误")

except:

# 获取当前异常的相关信息

exc_type, exc_value, exc_traceback = sys.exc_info()

print("异常类型：", exc_type)

print("异常值：", exc_value)

print("异常追踪信息：", exc_traceback)

# 清除当前异常

sys.exc_clear()

3. 总结

sys模块是Python标准库中的一个内置模块，提供了与Python解释器和运行环境相关的功能。它包含了一些与系统操作和交互相关的函数和变量，可以用于获取命令行参数、控制程序的执行、管理模块和包、处理异常等。通过使用sys模块，我们可以更好地了解和控制程序的运行环境，提高程序的灵活性和可靠性。

优惠劵

Rocky006

关注

踩

觉得还不错?

一键收藏

打赏

知道了

Python中的sys模块详解

复制链接

扫一扫

Python中sys模块功能与用法实例详解

12-20

本文实例讲述了Python中sys模块功能与用法。分享给大家供大家参考，具体如下：

sys-系统特定的参数和功能

该模块提供对解释器使用或维护的一些变量的访问，以及与解释器强烈交互的函数。它始终可用。

sys.argv

传递给Python脚本的命令行参数列表。argv[0]是脚本名称（依赖于操作系统，无论这是否是完整路径名）。如果使用-c解释器的命令行选项执行命令，argv[0]则将其设置为字符串’-c’。如果没有脚本名称传递给Python解释器，argv[0]则为空字符串。

要循环标准输入或命令行上给出的文件列表，请参阅fileinput模块。

sys.byteorder

本机字节顺序的

python之sys模块

最新文章

Python 语法高亮显示和格式化库之pygments使用详解

Python 异步文件操作库之aiofiles使用详解

Python 机器学习模型库之lazypredict使用详解

2024

03月

12篇

02月

37篇

01月

58篇

2023年413篇

最新文章

Python 语法高亮显示和格式化库之pygments使用详解

Python 异步文件操作库之aiofiles使用详解

Python 机器学习模型库之lazypredict使用详解

2024

03月

12篇

02月

37篇

01月

58篇

2023年413篇

被折叠的条评论

为什么被折叠?

到【灌水乐园】发言

查看更多评论

添加红包

祝福语

请填写红包祝福语或标题

红包数量

个

红包个数最小为10个

红包总金额

元

红包金额最低5元

余额支付

当前余额3.43元

前往充值 >

需支付：10.00元

取消

确定

下一步

知道了

成就一亿技术人!

领取后你会自动成为博主和红包主的粉丝

规则

hope_wisdom 发出的红包

打赏作者

Rocky006

你的鼓励将是我创作的最大动力

¥1

¥2

¥4

¥6

¥10

¥20

扫码支付：¥1

获取中

扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元

使用余额支付

点击重新获取

扫码支付

钱包余额

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值

【Python】sys库介绍-CSDN博客

【Python】sys库介绍

姚路遥遥

已于 2023-03-07 23:52:15 修改

阅读量1.6w

111

点赞数

分类专栏：

Python

文章标签：

python

linux

window

深度学习

神经网络

于 2021-02-03 00:09:24 首次发布

本文链接：https://blog.csdn.net/Roaddd/article/details/113576837

版权

Python

专栏收录该内容

12 篇文章

8 订阅

订阅专栏

sys库

sys模块是最常用的和python解释器交互的模块,sys模块可供访问由解释器(interpreter)使用或维护的变量和与解释器进行交互的函数。sys 模块提供了许多函数和变量来处理 Python 运行时环境的不同部分。

sys.argv命令行参数List，第一个元素是程序本身路径sys.path返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值sys.modules.keys()返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值sys.modules返回系统导入的模块字段，key是模块名，value是模块sys.modules.keys()返回所有已经导入的模块列表sys.exc_info()获取当前正在处理的异常类,exc_type、exc_value、exc_traceback当前处理的异常详细信息sys.exit(n)退出程序，正常退出时exit(0)sys.hexversion获取Python解释程序的版本值，16进制格式如：0x020403F0sys.version获取Python解释程序的版本信息sys.platform返回操作系统平台名称sys.stdout标准输出sys.stdout.write(‘aaa‘)标准输出内容sys.stdout.writelines()无换行输出sys.stdin标准输入sys.stdin.read()输入一行sys.stderr错误输出sys.exc_clear()用来清除当前线程所出现的当前的或最近的错误信息sys.exec_prefix返回平台独立的python文件安装的位置sys.byteorder本地字节规则的指示器，big-endian平台的值是‘big‘,little-endian平台的值是‘little‘sys.copyright记录python版权相关的东西sys.api_version解释器的C的API版本sys.version_info‘final‘表示最终,也有‘candidate‘表示候选，表示版本级别，是否有后继的发行sys.getdefaultencoding()返回当前你所用的默认的字符编码格式sys.getfilesystemencoding()返回将Unicode文件名转换成系统文件名的编码的名字sys.builtin_module_namesPython解释器导入的内建模块列表sys.executablePython解释程序路径sys.getwindowsversion()获取Windows的版本sys.stdin.readline()从标准输入读一行，sys.stdout.write(“a”) 屏幕输出asys.setdefaultencoding(name)用来设置当前默认的字符编码(详细使用参考文档)sys.displayhook(value)如果value非空，这个函数会把他输出到sys.stdout(详细使用参考文档)

关注博主即可阅读全文

优惠劵

姚路遥遥

关注

踩

111

觉得还不错?

一键收藏

知道了

【Python】sys库介绍

sys库 sys模块是最常用的和python解释器交互的模块,sys模块可供访问由解释器(interpreter)使用或维护的变量和与解释器进行交互的函数。sys 模块提供了许多函数和变量来处理 Python 运行时环境的不同部分。sys.argv命令行参数List，第一个元素是程序本身路径sys.path返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值sys.modules

复制链接

扫一扫

专栏目录

Python标准库之Sys模块使用详解

09-22

主要介绍了Python标准库之Sys模块使用详解,本文讲解了使用sys模块获得脚本的参数、处理模块、使用sys模块操作模块搜索路径、使用sys模块查找内建模块、使用sys模块查找已导入的模块等使用案例,需要的朋友可以参考下

python常用库

10-17

通过分析github上5000多个开源python项目，找出最常用的库，例如os、os.path、glob、sys、re、logging、subprocess、time、datetime、urllib、random、telnetlib、paramiko

2 条评论

您还未登录，请先

后发表或查看评论

【Python】sys库的介绍及用法

最新文章

【自监督学习】对比学习（Contrastive Learning）介绍

【机器学习】什么是监督学习、半监督学习、无监督学习、自监督学习以及弱监督学习

【数据结构与算法】数据结构有哪些？算法有哪些？

2023年15篇

2022年11篇

2021年123篇

2020年16篇

分类专栏

机器学习

21篇

人脸识别

19篇

Python

12篇

激活函数

7篇

数据结构与算法

2篇

注意力机制

2篇

图像分类

4篇

知识蒸馏

1篇

人脸检测

2篇

bug记录

6篇

正则化

3篇

Pytorch

4篇

AI面试题

14篇

深度学习环境

2篇

语义分割

1篇

目标检测

13篇

被折叠的条评论

为什么被折叠?

到【灌水乐园】发言

查看更多评论

添加红包

祝福语

请填写红包祝福语或标题

红包数量

个

红包个数最小为10个

红包总金额

元

红包金额最低5元

余额支付

当前余额3.43元

前往充值 >

需支付：10.00元

取消

确定

下一步

知道了

成就一亿技术人!

领取后你会自动成为博主和红包主的粉丝

规则

hope_wisdom 发出的红包

实付元

使用余额支付

点击重新获取

扫码支付

钱包余额

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值

操作系统实用工具 — Python 3.12.2 文档

Theme

Auto

Light

Dark

操作系统实用工具

系统功能

过程控制

上一主题

工具

下一主题

导入模块

当前页面

报告 Bug

显示源码

导航

索引

模块 |

下一页 |

上一页 |

Python »

3.12.2 Documentation »

Python/C API 参考手册 »

工具 »

操作系统实用工具

Theme

Auto

Light

Dark

操作系统实用工具¶

PyObject *PyOS_FSPath(PyObject *path)¶

返回值：新的引用。属于稳定 ABI 自 3.6 版开始.返回 path 在文件系统中的表示形式。如果该对象是一个 str 或 bytes 对象，则返回一个新的 strong reference。如果对象实现了 os.PathLike 接口，则只要它是一个 str 或 bytes 对象就将返回 __fspath__()。在其他情况下将引发 TypeError 并返回 NULL。

在 3.6 版本加入.

int Py_FdIsInteractive(FILE *fp, const char *filename)¶

如果名称为 filename 的标准Return true (nonzero) if the standard I/O 文件 fp 被确认为可交互的则返回真（非零）值。所有 isatty(fileno(fp)) 为真值的文件都属于这种情况。如果 PyConfig.interactive 为非零值，此函数在 filename 指针为 NULL 或者其名称等于字符串 '' 或 '???' 之一时也将返回真值。

此函数不可在 Python 被初始化之前调用。

void PyOS_BeforeFork()¶

属于稳定 ABI on platforms with fork() 自 3.7 版开始.在进程分叉之前准备某些内部状态的函数。此函数应当在调用 fork() 或者任何类似的克隆当前进程的函数之前被调用。只适用于定义了 fork() 的系统。

警告

C fork() 调用应当只在 "main" 线程 (位于 "main" 解释器) 中进行。对于 PyOS_BeforeFork() 来说也是如此。

在 3.7 版本加入.

void PyOS_AfterFork_Parent()¶

属于稳定 ABI on platforms with fork() 自 3.7 版开始.在进程分叉之后更新某些内部状态的函数。此函数应当在调用 fork() 或任何类似的克隆当前进程的函数之后被调用，无论进程克隆是否成功。只适用于定义了 fork() 的系统。

警告

C fork() 调用应当只在 "main" 线程 (位于 "main" 解释器) 中进行。对于 PyOS_AfterFork_Parent() 来说也是如此。

在 3.7 版本加入.

void PyOS_AfterFork_Child()¶

属于稳定 ABI on platforms with fork() 自 3.7 版开始.在进程分叉之后更新内部解释器状态的函数。此函数必须在调用 fork() 或任何类似的克隆当前进程的函数之后在子进程中被调用，如果该进程有机会回调到 Python 解释器的话。只适用于定义了 fork() 的系统。

警告

C fork() 调用应当只在 "main" 线程 (位于 "main" 解释器) 中进行。对于 PyOS_AfterFork_Child() 来说也是如此。

在 3.7 版本加入.

参见

os.register_at_fork() 允许注册可被 PyOS_BeforeFork(), PyOS_AfterFork_Parent() 和 PyOS_AfterFork_Child() 调用的自定义 Python 函数。

void PyOS_AfterFork()¶

属于稳定 ABI on platforms with fork().在进程分叉之后更新某些内部状态的函数；如果要继续使用 Python 解释器则此函数应当在新进程中被调用。如果已将一个新的可执行文件载入到新进程中，则不需要调用此函数。

自 3.7 版本弃用: 此函数已被 PyOS_AfterFork_Child() 取代。

int PyOS_CheckStack()¶

属于稳定 ABI on platforms with USE_STACKCHECK 自 3.7 版开始.当解释器耗尽栈空间时返回真值。这是一个可靠的检测，但仅在定义了 USE_STACKCHECK 时可用（目前是在使用 Microsoft Visual C++ 编译器的特定 Windows 版本上）。 USE_STACKCHECK 将被自动定义；你绝不应该在你自己的代码中改变此定义。

typedef void (*PyOS_sighandler_t)(int)¶

属于稳定 ABI.

PyOS_sighandler_t PyOS_getsig(int i)¶

属于稳定 ABI.返回信号 i 当前的信号处理句柄。这是一个对 sigaction() 或 signal() 的简单包装器。请不要直接调用这两个函数！

PyOS_sighandler_t PyOS_setsig(int i, PyOS_sighandler_t h)¶

属于稳定 ABI.将信号 i 的信号处理句柄设为 h；返回原来的信号处理句柄。这是一个对 sigaction() 或 signal() 的简单包装器。请不要直接调用这两个函数！

wchar_t *Py_DecodeLocale(const char *arg, size_t *size)¶

属于稳定 ABI 自 3.7 版开始.

警告

此函数不应当被直接调用：请使用 PyConfig API 以及可确保对 Python 进行预初始化的 PyConfig_SetBytesString() 函数。

此函数不可在This function must not be called before 对 Python 进行预初始化之前被调用以便正确地配置 LC_CTYPE 语言区域：请参阅 Py_PreInitialize() 函数。

使用 filesystem encoding and error handler 来解码一个字节串。如果错误处理句柄为 surrogateescape 错误处理句柄，则不可解码的字节将被解码为 U+DC80..U+DCFF 范围内的字符；而如果一个字节序列可被解码为代理字符，则其中的字节会使用 surrogateescape 错误处理句柄来转义而不是解码它们。

返回一个指向新分配的由宽字符组成的字符串的指针，使用 PyMem_RawFree() 来释放内存。如果 size 不为 NULL，则将排除了 null 字符的宽字符数量写入到 *size

在解码错误或内存分配错误时返回 NULL。如果 size 不为 NULL，则 *size 将在内存错误时设为 (size_t)-1 或在解码错误时设为 (size_t)-2。

filesystem encoding and error handler 是由 PyConfig_Read() 来选择的: 参见 PyConfig 的 filesystem_encoding 和 filesystem_errors 等成员。

解码错误绝对不应当发生，除非 C 库有程序缺陷。

请使用 Py_EncodeLocale() 函数来将字符串编码回字节串。

参见

PyUnicode_DecodeFSDefaultAndSize() 和 PyUnicode_DecodeLocaleAndSize() 函数。

在 3.5 版本加入.

在 3.7 版本发生变更: 现在此函数在 Python UTF-8 模式下将使用 UTF-8 编码格式。

在 3.8 版本发生变更: 现在如果在 Windows 上 PyPreConfig.legacy_windows_fs_encoding 为零则此函数将使用 UTF-8 编码格式；

char *Py_EncodeLocale(const wchar_t *text, size_t *error_pos)¶

属于稳定 ABI 自 3.7 版开始.将一个由宽字符组成的字符串编码为 filesystem encoding and error handler。如果错误处理句柄为 surrogateescape 错误处理句柄，则在 U+DC80..U+DCFF 范围内的代理字符会被转换为字节值 0x80..0xFF。

返回一个指向新分配的字节串的指针，使用 PyMem_Free() 来释放内存。当发生编码错误或内存分配错误时返回 NULL。

如果 error_pos 不为 NULL，则成功时会将 *error_pos 设为 (size_t)-1，或是在发生编码错误时设为无效字符的索引号。

filesystem encoding and error handler 是由 PyConfig_Read() 来选择的: 参见 PyConfig 的 filesystem_encoding 和 filesystem_errors 等成员。

请使用 Py_DecodeLocale() 函数来将字节串解码回由宽字符组成的字符串。

警告

此函数不可在This function must not be called before 对 Python 进行预初始化之前被调用以便正确地配置 LC_CTYPE 语言区域：请参阅 Py_PreInitialize() 函数。

参见

PyUnicode_EncodeFSDefault() 和 PyUnicode_EncodeLocale() 函数。

在 3.5 版本加入.

在 3.7 版本发生变更: 现在此函数在 Python UTF-8 模式下将使用 UTF-8 编码格式。

在 3.8 版本发生变更: 现在如果在 Windows 上 PyPreConfig.legacy_windows_fs_encoding 为零则此函数将使用 UTF-8 编码格式。

系统功能¶

这些是使来自 sys 模块的功能可以让 C 代码访问的工具函数。它们都可用于当前解释器线程的 sys 模块的字典，该字典包含在内部线程状态结构体中。

PyObject *PySys_GetObject(const char *name)¶

返回值：借入的引用。属于稳定 ABI.返回来自 sys 模块的对象 name 或者如果它不存在则返回 NULL，并且不会设置异常。

int PySys_SetObject(const char *name, PyObject *v)¶

属于稳定 ABI.将 sys 模块中的 name 设为 v 除非 v 为 NULL，在此情况下 name 将从 sys 模块中被删除。成功时返回 0，发生错误时返回 -1。

void PySys_ResetWarnOptions()¶

属于稳定 ABI.将 sys.warnoptions 重置为空列表。此函数可在 Py_Initialize() 之前被调用。

void PySys_AddWarnOption(const wchar_t *s)¶

属于稳定 ABI.此 API 被保留用于向下兼容：应当改为采用设置 PyConfig.warnoptions，参见 Python 初始化配置。

将 s 添加到 sys.warnoptions。此函数必须在 Py_Initialize() 之前被调用以便影响警告过滤器列表。

自 3.11 版本弃用.

void PySys_AddWarnOptionUnicode(PyObject *unicode)¶

属于稳定 ABI.此 API 被保留用于向下兼容：应当改为采用设置 PyConfig.warnoptions，参见 Python 初始化配置。

将 unicode 添加到 sys.warnoptions。

注意：目前此函数不可在 CPython 实现之外使用，因为它必须在 Py_Initialize() 中的 warnings 显式导入之前被调用，但是要等运行时已初始化到足以允许创建 Unicode 对象时才能被调用。

自 3.11 版本弃用.

void PySys_SetPath(const wchar_t *path)¶

属于稳定 ABI.此 API 被保留用于向下兼容：应当改为采用设置 PyConfig.module_search_paths 和 PyConfig.module_search_paths_set，参见 Python 初始化配置。

将 sys.path 设为由在 path 中找到的路径组成的列表对象，该参数应为使用特定平台的搜索路径分隔符 (在 Unix 上为 :，在 Windows 上为 ;) 分隔的路径的列表。

自 3.11 版本弃用.

void PySys_WriteStdout(const char *format, ...)¶

属于稳定 ABI.将以 format 描述的输出字符串写入到 sys.stdout。不会引发任何异常，即使发生了截断（见下文）。

format 应当将已格式化的输出字符串的总大小限制在 1000 字节以下 -- 超过 1000 字节后，输出字符串会被截断。特别地，这意味着不应出现不受限制的 "%s" 格式；它们应当使用 "%.s" 来限制，其中是一个经计算使得与其他已格式化文本的最大尺寸之和不会超过 1000 字节的十进制数字。还要注意 "%f"，它可能为非常大的数字打印出数以百计的数位。

如果发生了错误，sys.stdout 会被清空，已格式化的消息将被写入到真正的 (C 层级) stdout。

void PySys_WriteStderr(const char *format, ...)¶

属于稳定 ABI.类似 PySys_WriteStdout()，但改为写入到 sys.stderr 或 stderr。

void PySys_FormatStdout(const char *format, ...)¶

属于稳定 ABI.类似 PySys_WriteStdout() 的函数将会使用 PyUnicode_FromFormatV() 来格式化消息并且不会将消息截短至任意长度。

在 3.2 版本加入.

void PySys_FormatStderr(const char *format, ...)¶

属于稳定 ABI.类似 PySys_FormatStdout()，但改为写入到 sys.stderr 或 stderr。

在 3.2 版本加入.

void PySys_AddXOption(const wchar_t *s)¶

属于稳定 ABI 自 3.7 版开始.此 API 被保留用于向下兼容：应当改为采用设置 PyConfig.xoptions，参见 Python 初始化配置。

将 s 解析为一个由 -X 选项组成的集合并将它们添加到 PySys_GetXOptions() 所返回的当前选项映射。此函数可以在 Py_Initialize() 之前被调用。

在 3.2 版本加入.

自 3.11 版本弃用.

PyObject *PySys_GetXOptions()¶

返回值：借入的引用。属于稳定 ABI 自 3.7 版开始.返回当前 -X 选项的字典，类似于 sys._xoptions。发生错误时，将返回 NULL 并设置一个异常。

在 3.2 版本加入.

int PySys_Audit(const char *event, const char *format, ...)¶

引发一个审计事件并附带任何激活的钩子。成功时返回零值或在失败时返回非零值并设置一个异常。

如果已添加了任何钩子，则将使用 format 和其他参数来构造一个用入传入的元组。除 N 以外，在 Py_BuildValue() 中使用的格式字符均可使用。如果构建的值不是一个元组，它将被添加到一个单元素元组中。（格式选项 N 会消耗一个引用，但是由于没有办法知道此函数的参数是否将被消耗，因此使用它可能导致引用泄漏。）

请注意 # 格式字符应当总是被当作 Py_ssize_t 来处理，无论是否定义了 PY_SSIZE_T_CLEAN。

sys.audit() 会执行与来自 Python 代码的函数相同的操作。

在 3.8 版本加入.

在 3.8.2 版本发生变更: 要求 Py_ssize_t 用于 # 格式字符。在此之前，会引发一个不可避免的弃用警告。

int PySys_AddAuditHook(Py_AuditHookFunction hook, void *userData)¶

将可调用对象 hook 添加到激活的审计钩子列表。在成功时返回零而在失败时返回非零值。如果运行时已经被初始化，还会在失败时设置一个错误。通过此 API 添加的钩子会针对在运行时创建的所有解释器被调用。

userData 指针会被传入钩子函数。因于钩子函数可能由不同的运行时调用，该指针不应直接指向 Python 状态。

此函数可在 Py_Initialize() 之前被安全地调用。如果在运行时初始化之后被调用，现有的审计钩子将得到通知并可能通过引发一个从 Exception 子类化的错误静默地放弃操作（其他错误将不会被静默）。

钩子函数总是会由引发异常的 Python 解释器在持有 GIL 的情况下调用。

请参阅 PEP 578 了解有关审计的详细描述。在运行时和标准库中会引发审计事件的函数清单见审计事件表。更多细节见每个函数的文档。

如果解释器已被初始化，此函数将引发一个审计事件 sys.addaudithook 且不附带任何参数。如果有任何现存的钩子引发了一个派生自 Exception 的异常，新的钩子将不会被添加且该异常会被清除。因此，调用方不可假定他们的钩子已被添加除非他们能控制所有现存的钩子。

typedef int (*Py_AuditHookFunction)(const char *event, PyObject *args, void *userData)¶

钩子函数的类型。 event 是传给 PySys_Audit() 的 C 字符串事件参数。 args 会确保为一个 PyTupleObject。 userData 是传给 PySys_AddAuditHook() 的参数。

在 3.8 版本加入.

过程控制¶

void Py_FatalError(const char *message)¶

属于稳定 ABI.打印一个致命错误消息并杀死进程。不会执行任何清理。此函数应当仅在检测到可能令继续使用 Python 解释器会有危险的情况时被发起调用；例如对象管理已被破坏的时候。在 Unix 上，会调用标准 C 库函数 abort() 并将由它来尝试生成一个 core 文件。

The Py_FatalError() function is replaced with a macro which logs

automatically the name of the current function, unless the

Py_LIMITED_API macro is defined.

在 3.9 版本发生变更: 自动记录函数名称。

void Py_Exit(int status)¶

属于稳定 ABI.退出当前进程。这将调用 Py_FinalizeEx() 然后再调用标准 C 库函数 exit(status)。如果 Py_FinalizeEx() 提示错误，退出状态将被设为 120。

在 3.6 版本发生变更: 来自最终化的错误不会再被忽略。

int Py_AtExit(void (*func)())¶

属于稳定 ABI.注册一个由 Py_FinalizeEx() 调用的清理函数。调用清理函数将不传入任何参数且不应返回任何值。最多可以注册32 个清理函数。当注册成功时，Py_AtExit() 将返回 0；失败时，它将返回 -1。最后注册的清理函数会最先被调用。每个清理函数将至多被调用一次。由于 Python 的内部最终化将在清理函数之前完成，因此 Python API 不应被 func 调用。

操作系统实用工具

系统功能

过程控制

上一主题

工具

下一主题

导入模块

当前页面

报告 Bug

显示源码

导航

索引

模块 |

下一页 |

上一页 |

Python »

3.12.2 Documentation »

Python/C API 参考手册 »

工具 »

操作系统实用工具

Theme

Auto

Light

Dark

This page is licensed under the Python Software Foundation License Version 2.

Examples, recipes, and other code in the documentation are additionally licensed under the Zero Clause BSD License.

See History and License for more information.

The Python Software Foundation is a non-profit corporation.

Please donate.

最后更新于 Mar 06, 2024 (12:34 UTC).

Found a bug?

由 Sphinx 7.2.6创建。

28.1. sys — 系统相关的参数和函数 — Python 2.7.18 文档

This document is for an old version of Python that is no longer supported.

You should upgrade and read the

Python 当前稳定版本的文档.

导航

索引

模块 |

下一页 |

上一页 |

Python »

Python 2.7.18 文档 »

Python 标准库 »

28. Python运行时服务 »

28.1. sys — 系统相关的参数和函数¶

该模块提供了一些变量和函数。这些变量可能被解释器使用，也可能由解释器提供。这些函数会影响解释器。本模块总是可用的。

sys.argv¶

一个列表，其中包含了被传递给 Python 脚本的命令行参数。 argv[0] 为脚本的名称（是否是完整的路径名取决于操作系统）。如果是通过 Python 解释器的命令行参数 -c 来执行的， argv[0] 会被设置成字符串 '-c' 。如果没有脚本名被传递给 Python 解释器， argv[0] 为空字符串。

为了遍历标准输入，或者通过命令行传递的文件列表，参照 fileinput 模块

sys.byteorder¶

本地字节顺序的指示符。在大端序（最高有效位优先）操作系统上值为 'big' ，在小端序（最低有效位优先）操作系统上为 'little' 。

2.0 新版功能.

sys.builtin_module_names¶

一个元素为字符串的元组。包含了所有的被编译进 Python 解释器的模块。（这个信息无法通过其他的办法获取， modules.keys() 只包括被导入过的模块。）

sys.call_tracing(func, args)¶

在启用跟踪时调用 func(*args) 来保存跟踪状态，然后恢复跟踪状态。这将从检查点的调试器调用，以便递归地调试其他的一些代码。

sys.copyright¶

一个字符串，包含了 Python 解释器有关的版权信息

sys._clear_type_cache()¶

清除内部的类型缓存。类型缓存是为了加速查找方法和属性的。在调试引用泄漏的时候调用这个函数只会清除不必要的引用。

这个函数应该只在内部为了一些特定的目的使用。

2.6 新版功能.

sys._current_frames()¶

返回一个字典，将每个线程的标识符映射到调用函数时该线程中当前活动的最顶层堆栈帧。注意 traceback 模块中的函数可以在给定帧的情况下构建调用堆栈。

这对于调试死锁最有用：本函数不需要死锁线程的配合，并且只要这些线程的调用栈保持死锁，它们就是冻结的。在调用本代码来检查栈顶的帧的那一刻，非死锁线程返回的帧可能与该线程当前活动的帧没有任何关系。

这个函数应该只在内部为了一些特定的目的使用。

2.5 新版功能.

sys.dllhandle¶

Integer specifying the handle of the Python DLL. Availability: Windows.

sys.displayhook(value)¶

If value is not None, this function prints it to sys.stdout, and saves

it in __builtin__._.

sys.displayhook is called on the result of evaluating an expression

entered in an interactive Python session. The display of these values can be

customized by assigning another one-argument function to sys.displayhook.

sys.dont_write_bytecode¶

If this is true, Python won’t try to write .pyc or .pyo files on the

import of source modules. This value is initially set to True or

False depending on the -B command line option and the

PYTHONDONTWRITEBYTECODE environment variable, but you can set it

yourself to control bytecode file generation.

2.6 新版功能.

sys.excepthook(type, value, traceback)¶

This function prints out a given traceback and exception to sys.stderr.

When an exception is raised and uncaught, the interpreter calls

sys.excepthook with three arguments, the exception class, exception

instance, and a traceback object. In an interactive session this happens just

before control is returned to the prompt; in a Python program this happens just

before the program exits. The handling of such top-level exceptions can be

customized by assigning another three-argument function to sys.excepthook.

sys.__displayhook__¶

sys.__excepthook__¶

These objects contain the original values of displayhook and excepthook

at the start of the program. They are saved so that displayhook and

excepthook can be restored in case they happen to get replaced with broken

objects.

sys.exc_info()¶

This function returns a tuple of three values that give information about the

exception that is currently being handled. The information returned is specific

both to the current thread and to the current stack frame. If the current stack

frame is not handling an exception, the information is taken from the calling

stack frame, or its caller, and so on until a stack frame is found that is

handling an exception. Here, “handling an exception” is defined as “executing

or having executed an except clause.” For any stack frame, only information

about the most recently handled exception is accessible.

If no exception is being handled anywhere on the stack, a tuple containing three

None values is returned. Otherwise, the values returned are (type, value,

traceback). Their meaning is: type gets the exception type of the exception

being handled (a class object); value gets the exception parameter (its

associated value or the second argument to raise, which is

always a class instance if the exception type is a class object); traceback

gets a traceback object (see the Reference Manual) which encapsulates the call

stack at the point where the exception originally occurred.

If exc_clear() is called, this function will return three None values

until either another exception is raised in the current thread or the execution

stack returns to a frame where another exception is being handled.

警告

Assigning the traceback return value to a local variable in a function that is

handling an exception will cause a circular reference. This will prevent

anything referenced by a local variable in the same function or by the traceback

from being garbage collected. Since most functions don’t need access to the

traceback, the best solution is to use something like exctype, value =

sys.exc_info()[:2] to extract only the exception type and value. If you do

need the traceback, make sure to delete it after use (best done with a

try … finally statement) or to call exc_info() in

a function that does not itself handle an exception.

注解

Beginning with Python 2.2, such cycles are automatically reclaimed when garbage

collection is enabled and they become unreachable, but it remains more efficient

to avoid creating cycles.

sys.exc_clear()¶

This function clears all information relating to the current or last exception

that occurred in the current thread. After calling this function,

exc_info() will return three None values until another exception is

raised in the current thread or the execution stack returns to a frame where

another exception is being handled.

This function is only needed in only a few obscure situations. These include

logging and error handling systems that report information on the last or

current exception. This function can also be used to try to free resources and

trigger object finalization, though no guarantee is made as to what objects will

be freed, if any.

2.3 新版功能.

sys.exc_type¶

sys.exc_value¶

sys.exc_traceback¶

1.5 版后已移除: Use exc_info() instead.

Since they are global variables, they are not specific to the current thread, so

their use is not safe in a multi-threaded program. When no exception is being

handled, exc_type is set to None and the other two are undefined.

sys.exec_prefix¶

A string giving the site-specific directory prefix where the platform-dependent

Python files are installed; by default, this is also '/usr/local'. This can

be set at build time with the --exec-prefix argument to the

configure script. Specifically, all configuration files (e.g. the

pyconfig.h header file) are installed in the directory

exec_prefix/lib/pythonX.Y/config, and shared library modules are

installed in exec_prefix/lib/pythonX.Y/lib-dynload, where X.Y

is the version number of Python, for example 2.7.

sys.executable¶

A string giving the absolute path of the executable binary for the Python

interpreter, on systems where this makes sense. If Python is unable to retrieve

the real path to its executable, sys.executable will be an empty string

or None.

sys.exit([arg])¶

从Python中退出。实现方式是抛出一个 SystemExit 异常。异常抛出后 try 声明的 finally 分支语句的清除动作将被出发。此动作有可能打断更外层的退出尝试。