Python内置模块-Sys

精选原创

亦已焉哉 2024-10-22 14:45:46 博主文章分类：Python内置模块 ©著作权

文章标签 python sys python内置模块 文章分类 Python 后端开发 yyds干货盘点

©著作权归作者所有：来自51CTO博客作者亦已焉哉的原创作品，请联系作者获取转载授权，否则将追究法律责任

Python内置模块-Sys

一、模块介绍

sys模块是Python内置模块，它提供了一些简单的函数和变量，用于访问与Python解释器和Python环境相关的变量和功能。

二、模块导入

import sys

三、模块函数

1.sys.exit()

作用从Python程序中退出，调用sys.exit()会导致程序立即终止。如果传递了一个整数或字符串参数，它将用作退出状态码；如果不传递任何参数，则默认退出状态码为0。

语法

sys.exit([arg])

参数

arg：整数或字符串，整数：用作程序的退出状态码；字符串，打印到stderr，并且程序将以非零状态退出

示例

无参数退出

import sys

# 程序执行到这里时退出，退出状态码为 0
sys.exit()

带整数参数退出

import sys

# 程序执行到这里时退出，退出状态码为 1
sys.exit(1)

带字符串参数退出

import sys

# 程序执行到这里时退出，打印消息到 stderr 并以非零状态退出
sys.exit("程序遇到了错误，现在退出。")

捕获退出异常

import sys

try:
    sys.exit(1)
except SystemExit:
    print("捕获到退出异常，程序不会立即退出。")
    # 可以在这里进行清理工作

2.sys.getrecursionlimit()

作用获取Python解释器当前设置的最大递归深度，递归深度是指一个函数可以递归调用自己的最大次数，当递归超过这个限制时，Python会抛出一个RecursionError异常。

语法

sys.getrecursionlimit()

示例

获取当前的递归限制

import sys

# 获取当前的递归限制
current_limit = sys.getrecursionlimit()
print("当前的递归限制是:", current_limit)

结果

当前的递归限制是: 1000

在递归函数中获取递归限制

import sys


def recursive_function(level):
    print("递归级别:", level)
    if level == 0:
        return
    recursive_function(level - 1)


# 获取当前的递归限制
current_limit = sys.getrecursionlimit()
print("当前的递归限制是:", current_limit)

# 尝试递归调用，直到达到递归限制
try:
    recursive_function(current_limit)
except RecursionError:
    print("达到了递归限制，抛出 RecursionError 异常。")

结果

当前的递归限制是: 1000
递归级别: 1000
递归级别: 999
递归级别: 998
...
达到了递归限制，抛出 RecursionError 异常。

3.sys.setrecursionlimit()

作用设置Python解释器的最大递归深度，这个函数可以更改默认的递归限制，以允许更深层次的递归调用，但是，修改这个值需要谨慎，因为设置得太高可能会导致程序崩溃或耗尽系统资源。

语法

sys.setrecursionlimit(limit)

参数

limit：整数，表示新的递归限制值

示例

import sys

# 获取当前的递归限制
current_limit = sys.getrecursionlimit()
print("原始递归限制是:", current_limit)

# 设置新的递归限制
new_limit = 1500
sys.setrecursionlimit(new_limit)
print("新的递归限制是:", sys.getrecursionlimit())


# 定义一个简单的递归函数
def recursive_function(level):
    print("递归级别:", level)
    if level == 0:
        return
    recursive_function(level - 1)


# 尝试使用新的递归限制进行递归调用
try:
    recursive_function(new_limit)
except RecursionError:
    print("达到了递归限制，抛出 RecursionError 异常。")

结果

当前的递归限制是: 1000
递归级别: 1500
递归级别: 1499
递归级别: 1498
...
达到了递归限制，抛出 RecursionError 异常。

4.sys.getdefaultencoding()

作用用于获取Python解释器的默认编码格式，默认编码通常用于将字节字符串转换为Unicode字符串，或者将Unicode字符串转换为字节字符串。

语法

sys.getdefaultencoding()

示例

import sys

# 获取当前默认的编码格式
default_encoding = sys.getdefaultencoding()
print("当前默认编码是:", default_encoding)

# 使用默认编码将 Unicode 字符串转换为字节字符串
unicode_string = "你好，世界"
byte_string = unicode_string.encode(default_encoding)
print("编码后的字节字符串是:", byte_string)

# 使用默认编码将字节字符串转换回 Unicode 字符串
decoded_string = byte_string.decode(default_encoding)
print("解码后的 Unicode 字符串是:", decoded_string)

结果

当前默认编码是: utf-8
编码后的字节字符串是: b'\xe4\xbd\xa0\xe5\xa5\xbd\xef\xbc\x8c\xe4\xb8\x96\xe7\x95\x8c'
解码后的 Unicode 字符串是: 你好，世界

5.sys.getfilesystemencoding()

作用获取文件系统编码，这个编码用于将Unicode字符串转换为系统文件名所需的字节字符串，以及将文件名从字节字符串转换回Unicode字符串。

语法

sys.getfilesystemencoding()

示例

import sys
import os

# 获取当前文件系统的编码格式
filesystem_encoding = sys.getfilesystemencoding()
print("当前文件系统编码是:", filesystem_encoding)

# 使用文件系统编码将 Unicode 字符串转换为文件名
unicode_filename = "文件_测试.txt"
byte_filename = unicode_filename.encode(filesystem_encoding)
print("编码后的文件名字节字符串是:", byte_filename)

# 创建一个文件来测试
with open(byte_filename, 'w') as f:
    f.write("这是一个测试文件。")

# 使用文件系统编码将文件名从字节字符串转换回 Unicode 字符串
decoded_filename = byte_filename.decode(filesystem_encoding)
print("解码后的文件名 Unicode 字符串是:", decoded_filename)

# 确认文件存在
if os.path.exists(decoded_filename):
    print("文件存在:", decoded_filename)
else:
    print("文件不存在。")

# 删除测试文件
os.remove(decoded_filename)

结果

当前文件系统编码是: utf-8
编码后的文件名字节字符串是: b'\xe6\x96\x87\xe4\xbb\xb6_\xe6\xb5\x8b\xe8\xaf\x95.txt'
解码后的文件名 Unicode 字符串是: 文件_测试.txt
文件存在: 文件_测试.txt

7.sys.modules.keys()

作用返回sys.modules字典中的所有键，即所有已导入的模块名，这是一个视图对象，可以用来迭代所有已导入模块的名称。

语法

sys.modules.keys()

示例

import sys

# 打印已导入的模块名列表
print("已导入的模块名列表:")
for module_name in sys.modules.keys():
    print(module_name)

# 查找特定模块名的模块对象
if 'os' in sys.modules.keys():
    os_module = sys.modules['os']
    print(f"操作系统模块(os)的 __file__ 属性: {os_module.__file__}")
else:
    print("操作系统模块(os)尚未被导入。")

# 导入一个新模块，并确认其键出现在 sys.modules.keys() 视图中
import datetime

if 'datetime' in sys.modules.keys():
    print("日期时间模块(datetime)现在已经被导入。")
else:
    print("日期时间模块(datetime)尚未被导入。")

结果

已导入的模块名列表:
sys
builtins
_frozen_importlib
_imp
...
操作系统模块(os)的 __file__ 属性: D:\SoftWare\Python-3.8.10\lib\os.py
日期时间模块(datetime)现在已经被导入。

8.sys.getswitchinterval()

作用获取解释器当前设置的线程切换时间间隔，间隔以秒为单位，这个间隔决定了在Python代码执行期间，线程在执行多长时间后会自动让出控制权，允许其他线程运行。

语法

sys.getswitchinterval()

示例

import sys
import time

# 获取当前的线程切换时间间隔
current_switch_interval = sys.getswitchinterval()
print(f"Current thread switch interval: {current_switch_interval} seconds")

# 假设我们想要执行一个长时间的运算，并在这段时间内不希望线程切换
# 这通常不是一个好的做法，因为可能会导致程序响应变慢，这里仅作为示例
try:
    # 设置线程切换时间间隔为很高的值，以减少线程切换
    sys.setswitchinterval(10.0)  # 设置为10秒

    # 执行一些计算密集型的任务
    start_time = time.time()
    result = sum(i * i for i in range(10000000))
    end_time = time.time()

    print(f"Calculation result: {result}")
    print(f"Calculation took {end_time - start_time} seconds")

finally:
    # 恢复线程切换时间间隔到原来的值
    sys.setswitchinterval(current_switch_interval)
    print(f"Restored thread switch interval: {sys.getswitchinterval()} seconds")

结果

Current thread switch interval: 0.005 seconds
Calculation result: 333333283333335000000
Calculation took 0.678563117980957 seconds
Restored thread switch interval: 0.005 seconds

9.sys.setswitchinterval()

作用设置解释器中线程切换的间隔时间，函数定义了线程在Python中的抢占式多任务处理的行为，即一个线程愿意让出控制权之前可以连续运行的时间量。

语法

sys.setswitchinterval(interval)

参数

interval：浮点数，表示线程切换的时间间隔，单位是秒

示例

import sys
import threading
import time

# 设置线程切换时间间隔为 0.1 秒（100 毫秒）
sys.setswitchinterval(0.1)

# 定义一个简单的线程运行函数
def thread_function(name):
    print(f"Thread {name}: starting")
    time.sleep(1)
    print(f"Thread {name}: finishing")

# 创建并启动线程
thread1 = threading.Thread(target=thread_function, args=("A",))
thread2 = threading.Thread(target=thread_function, args=("B",))

thread1.start()
thread2.start()

# 等待线程完成
thread1.join()
thread2.join()

print("Main thread: finishing")

结果

Thread A: starting
Thread B: starting
Thread B: finishingThread A: finishing

Main thread: finishing

10.sys.exc_info()

作用返回当前处理的异常的信息。

语法

sys.exc_info()

其他

函数返回一个三元组(type, value, traceback)，其中type是异常的类型，value是异常的实例(异常对象)，traceback是一个traceback对象，用于追踪异常发生的位置。

示例

import sys

try:
    # 这里故意制造一个除以零的异常
    x = 1 / 0
except:
    # 获取异常信息
    exc_type, exc_value, exc_traceback = sys.exc_info()

    # 打印异常类型
    print(f"Exception type: {exc_type.__name__}")

    # 打印异常值
    print(f"Exception value: {exc_value}")

    # 打印异常的调用栈
    traceback_details = {
        'filename': exc_traceback.tb_frame.f_code.co_filename,
        'lineno': exc_traceback.tb_lineno,
        'name': exc_traceback.tb_frame.f_code.co_name,
        'line': exc_traceback.tb_frame.f_code.co_code,
    }
    print(f"Traceback details: {traceback_details}")

结果

Exception type: ZeroDivisionError
Exception value: division by zero
Traceback details: {'filename': 'D:\\Project\\Pytest\\test3.py', 'lineno': 5, 'name': '<module>', 'line': b'd\x00d\x01l\x00Z\x00z\x0cd\x02d\x00\x1b\x00Z\x01W\x00nh\x01\x00\x01\x00\x01\x00e\x00\xa0\x02\xa1\x00\\\x03Z\x03Z\x04Z\x05e\x06d\x03e\x03j\x07\x9b\x00\x9d\x02\x83\x01\x01\x00e\x06d\x04e\x04\x9b\x00\x9d\x02\x83\x01\x01\x00e\x05j\x08j\tj\ne\x05j\x0be\x05j\x08j\tj\x0ce\x05j\x08j\tj\rd\x05\x9c\x04Z\x0ee\x06d\x06e\x0e\x9b\x00\x9d\x02\x83\x01\x01\x00Y\x00n\x020\x00d\x01S\x00'}

四、模块属性

1.sys.argv

作用 argv是一个列表，它包含了命令行参数的列表。

语法

sys.argv

示例

import sys

# 打印所有的命令行参数
print("命令行参数列表:", sys.argv)

# 打印脚本名称
print("脚本名称:", sys.argv[0])

# 检查是否有额外的命令行参数
if len(sys.argv) > 1:
    # 打印第一个命令行参数
    print("第一个参数:", sys.argv[1])
else:
    print("没有提供额外的命令行参数")

仅运行脚本，没有额外参数：

(venv) PS D:\Project\test> python .\test.py 
命令行参数列表: ['.\\test.py']
脚本名称: .\test.py
没有提供额外的命令行参数

运行脚本并传递两个参数：

(venv) PS D:\Project\test> python .\test.py a b c
命令行参数列表: ['.\\test.py', 'a', 'b', 'c']
脚本名称: .\test.py
第一个参数: a

2.sys.version

作用返回一个字符串，包含了当前运行的Python解释器的版本信息。

语法

sys.version

示例

import sys

# 打印当前 Python 解释器的版本信息
print("当前 Python 解释器版本:", sys.version)

结果

当前 Python 解释器版本: 3.8.10 (tags/v3.8.10:3d8993a, May  3 2021, 11:48:03) [MSC v.1928 64 bit (AMD64)]

3.sys.platform

作用返回一个字符串，表示当前运行的操作系统平台。

语法

sys.platform

其他在命令行中运行此脚本，根据当前所在的操作系统，输出可能会有以下几种情况：

Windows 32位系统: win32
Windows 64位系统: win64
MacOS系统：darwin
Linux系统: linux

示例

import sys

# 打印当前操作系统平台
print("当前操作系统平台:", sys.platform)

结果

当前操作系统平台: win32

4.sys.copyright

作用返回Python解释器的版权信息。

语法

sys.copyright

示例

import sys

# 打印 Python 解释器的版权信息
print("Python 解释器的版权信息:", sys.copyright)

结果

Python 解释器的版权信息: Copyright (c) 2001-2021 Python Software Foundation.
All Rights Reserved.

Copyright (c) 2000 BeOpen.com.
All Rights Reserved.

Copyright (c) 1995-2001 Corporation for National Research Initiatives.
All Rights Reserved.

Copyright (c) 1991-1995 Stichting Mathematisch Centrum, Amsterdam.
All Rights Reserved.

5.sys.hexversion

作用返回Python解释器的版本信息，以十六进制的形式表示。

语法

sys.hexversion

示例

import sys

# 打印 Python 解释器的十六进制版本信息
print("Python 解释器的十六进制版本信息:", hex(sys.hexversion))

结果

Python 解释器的十六进制版本信息: 0x3080af0

十六进制数通常用于比较Python版本，因为它可以精确地表示出主版本、次版本和修订版本号，便于进行版本检查。

import sys

# 假设我们想要检查 Python 版本是否大于等于 3.8.0
required_version = 0x030800F0  # 对应于 3.8.0 的十六进制版本号

if sys.hexversion >= required_version:
    print("当前 Python 版本大于等于 3.8.0")
else:
    print("当前 Python 版本小于 3.8.0")

6.sys.modules

作用 modules是sys模块中的一个字典，存储了当前运行的Python程序已导入的所有模块，字典的键是模块名，值是模块对象。

语法

sys.modules

示例

import sys

# 打印已导入的模块列表
print("已导入的模块列表:")
for module_name in sys.modules:
    print(module_name)

# 检查特定的模块是否已经被导入
if 'math' in sys.modules:
    print("数学模块(math)已经被导入。")
else:
    print("数学模块(math)尚未被导入。")

# 导入一个新的模块，并检查它是否出现在 sys.modules 中
import json

if 'json' in sys.modules:
    print("JSON模块(json)现在已经被导入。")
else:
    print("JSON模块(json)尚未被导入。")

# 获取特定模块的属性
if 'json' in sys.modules:
    json_module = sys.modules['json']
    print(f"JSON模块的 __file__ 属性: {json_module.__file__}")

结果

已导入的模块列表:
sys
builtins
_frozen_importlib
...
数学模块(math)已经被导入。
JSON模块(json)现在已经被导入。
JSON模块的 __file__ 属性: D:\SoftWare\Python-3.8.10\lib\json\__init__.py

7.sys.path

作用定义了Python解释器的模块搜索路径，当尝试导入一个模块时，Python会在sys.path列表中的每个目录里查找该模块。

语法

sys.path

示例

import sys

# 打印模块搜索路径列表
print("Python 解释器的模块搜索路径:")
for path in sys.path:
    print(path)

# 将一个新的路径添加到 sys.path 中
new_path = '/path/to/my/modules'
if new_path not in sys.path:
    sys.path.append(new_path)
    print(f"新路径 {new_path} 已添加到 sys.path")
else:
    print(f"路径 {new_path} 已经存在于 sys.path 中")

# 现在可以导入位于新路径下的模块
# 假设新路径下有一个名为 my_module.py 的文件
try:
    import my_module

    print("成功导入 my_module")
except ImportError:
    print("未能导入 my_module")

# 移除之前添加的路径
if new_path in sys.path:
    sys.path.remove(new_path)
    print(f"路径 {new_path} 已从 sys.path 中移除")

结果

Python 解释器的模块搜索路径:
D:\Project\test
D:\Project\test
D:\SoftWare\Pycharm\PyCharm 2023.2.5\plugins\python\helpers\pycharm_display
D:\SoftWare\Python-3.8.10\python38.zip
D:\SoftWare\Python-3.8.10\DLLs
D:\SoftWare\Python-3.8.10\lib
D:\SoftWare\Python-3.8.10
D:\Project\test\venv
D:\Project\test\venv\lib\site-packages
D:\SoftWare\Pycharm\PyCharm 2023.2.5\plugins\python\helpers\pycharm_matplotlib_backend
新路径 /path/to/my/modules 已添加到 sys.path
未能导入 my_module
路径 /path/to/my/modules 已从 sys.path 中移除

8.sys.builtin_module_names

作用返回一个元组，包含了所有由C编写的内置模块的名称。

语法

sys.builtin_module_names

示例

import sys

# 打印所有内置模块的名称
for module_name in sys.builtin_module_names:
    print(module_name)

结果

_abc
_ast
_bisect
...

9.sys.byteorder

作用表示当前系统的字节序(也称为端序)，字节序定义了多字节数据类型的存储顺序，它可以是little(小端字节序)或big(大端字节序)。

语法

sys.byteorder

示例

import sys

# 获取并打印系统的字节序
print(f"当前系统的字节序是: {sys.byteorder}")

结果

当前系统的字节序是: little

上一篇：Python内置模块-Math

下一篇：Python内置模块-Json

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯