100天精通Python（基础篇）——第29天：标准库sys常用函数、方法（基础+代码实战）

一、sys作用

Python的sys模块就像是一个万能钥匙，它提供了访问解释器内部的各种变量的接口，就像是你能够窥探到Python的内心世界一样。同时，它还提供了一些函数，就像是你能够和Python解释器进行互动，像是跟它打招呼、问好一样。它就像是Python运行时环境的指挥官，你可以通过它来操控整个Python的舞台。

想象一下，你是一位掌控全局的大神，sys模块就是你的法宝，让你能够轻松地掌握Python的运行时环境。无论是获取命令行参数、查看Python的版本信息，还是控制程序的退出，sys模块都能帮你一把。它就像是一把神奇的钥匙，能够打开Python的各种秘密之门。

所以，别小看这个sys模块，它虽然只是一个模块，但它的作用却是无穷的。它就像是一位忠实的助手，时刻准备为你服务，让你在Python的世界中游刃有余。让我们一起来探索sys模块的奥秘吧！

>>> import sys

二、常用变量

sys.version

嘿，这个小家伙可以告诉你Python解释器的版本号哦！就像是一个时髦的时装秀，每个版本都有自己独特的风格和特点。有时候，你可能需要用指定版本号来运行某个程序，就像是要穿上一件特定的衣服一样。

使用sys.version这个魔法咒语，你可以轻松地获取到Python解释器的版本号。它就像是一个时光机，带你回到过去或者未来的Python世界。无论你是想追溯历史，还是想预测未来，这个小家伙都能满足你的需求。

所以，别犹豫了！快来试试sys.version这个魔法咒语，让你的程序在正确的版本下翩翩起舞吧！记住，时尚总是与时俱进的，所以保持更新，保持潮流！

>>> import sys
>>> sys.version
3.8.5 (tags/v3.8.5:580fbb0, Jul 20 2020, 15:57:54) [MSC v.1924 64 bit (AMD64)]

sys.maxsize

sys.maxsize就像是操作系统的超级英雄，它代表着操作系统所能承载的最大整数值。它就像是一座巨大的数字巨塔，高耸入云，让其他整数都望尘莫及。

想象一下，你是一个勇敢的程序员，正在编写一段代码，需要处理非常大的整数。你需要一个变量来存储这个巨大的数字，但是你不确定操作系统能否承受得住。这时，sys.maxsize就像是一个超级英雄的披风，保护着你的代码免受整数溢出的威胁。

当你使用sys.maxsize时，你可以放心地处理大到令人发指的整数，而不用担心它们会超出操作系统的极限。它就像是一把无敌的剑，让你在整数世界中游刃有余。

所以，记住，当你需要处理大整数时，sys.maxsize就是你的超级英雄伙伴，它会保护你的代码免受整数溢出的威胁，让你的程序在操作系统的庇护下安全运行。

>>> import sys
>>> sys.maxsize
9223372036854775807

sys.maxunicode

sys.maxunicode它就像是一把打开了通往神奇世界的钥匙！它告诉你们，Unicode世界中最大的代码点值是多少。

你知道吗？这个最大的代码点值是1114111，用十六进制表示就是0x10FFFF。简直就像是一个巨大的宇宙门，通向了无尽的字符宇宙！

想象一下，每个Unicode字符都有自己独特的代码点，就像是宇宙中的一个星球。而sys.maxunicode就是告诉你，这个星球的最大坐标是多少。当你知道了这个最大值，你就可以在Unicode宇宙中尽情探索，发现更多有趣的字符！

所以，小伙伴们，拿起你们的键盘，打开Python的大门，使用sys.maxunicode来探索Unicode的奇妙世界吧！让我们一起去发现那些隐藏在代码点背后的神奇字符吧！

>>> import sys
>>> sys.maxunicode
1114111

sys.path

sys.path就像是脚本的导航系统，它告诉Python解释器在哪里寻找模块和库。如果你的脚本需要使用某个模块或库，但是Python解释器找不到它，那么它就会在sys.path中寻找答案。

可以把sys.path想象成是一张地图，上面标有各种路径。当你导入一个模块时，Python解释器会按照sys.path中的路径顺序进行搜索，直到找到所需的模块或库为止。

如果你的脚本在某个路径下找不到所需的模块或库，那么你可以通过修改sys.path来告诉Python解释器去其他路径寻找。就像是你在导航系统中输入一个新的目的地，它会为你找到最佳的路径。

所以，记住，sys.path是你的脚本的导航系统，它能帮助你找到你需要的模块和库，就像是一位忠实的导航员。

>>> import sys
>>> sys.path
['', 'D:\\Python3.8\\python38.zip', 'D:\\Python3.8\\DLLs', 'D:\\Python3.8\\lib', 'D:\\Python3.8', 'D:\\Python3.8\\lib\\site-packages']

sys.platform

sys.platform就像是一个间谍，它会告诉你当前操作系统的真实身份。它就像是一个秘密特工，你可以在编写跨平台应用时向它询问：“你是谁？”然后它会回答：“我是Windows！”，或者：“我是MacOS！”，甚至可能是：“我是Linux！”这样你就可以根据它的回答来调整你的应用程序，让它在不同的操作系统上都能正常运行。所以，记住，sys.platform是你的得力助手，让你的应用程序成为一个真正的跨平台大师！

>>> import sys
>>> sys.platform
win32

sys.argv

sys.argv它就像是一个神奇的魔法盒子，可以帮助我们从程序外部向程序内部传递参数。

你可以把sys.argv想象成一张魔术卡片，上面写着你的程序名和参数。当你运行Python脚本时，这张卡片就会被自动创建，并且以列表的形式呈现在你的程序中。

这个列表的第一个元素是你的脚本名，就像是一张身份证，告诉大家你是谁。而剩下的元素则是你传递给程序的参数，就像是一堆小礼物，让你的程序可以根据不同的参数来执行不同的操作。

让我们来看个例子吧。假设你有一个名为hello.py的脚本，你可以在命令行中输入以下命令来运行它：

python hello.py Alice Bob Charlie

当你运行这个命令时，sys.argv就会被创建，并且它的值将是['hello.py', 'Alice', 'Bob', 'Charlie']。这就像是一个魔法的传送门，把你输入的参数传递给了你的程序。

现在，你可以在你的程序中使用sys.argv来获取这些参数，并根据需要进行处理。比如，你可以这样做：

import sys

script_name = sys.argv[0]
args = sys.argv[1:]

print("脚本名：", script_name)
print("参数：", args)

运行这段代码，你将会看到输出：

脚本名： hello.py
参数： ['Alice', 'Bob', 'Charlie']

哇！是不是很神奇？sys.argv就像是一个程序与外界沟通的桥梁，让你的程序可以灵活地接收来自外部的指令。

所以，记住，当你想要从程序外部向程序内部传递参数时，sys.argv就是你的好朋友。它会帮助你实现你的愿望，就像是一个忠实的小精灵，时刻准备着为你服务。

希望这个小魔法盒子能给你带来更多的乐趣和便利！快去尝试一下吧！🎩✨

演示：

import sys

print(sys.argv)

E:\Python> python 2.py hello python
['2.py', 'hello', 'python']

sys.executable

Python解释器的可执行二进制文件的绝对路径，就像是一只迷路的小猫咪，我们得帮它找到回家的路。不过有时候，这只小猫咪可能会迷失在茫茫的路径中，找不到回家的路，那么sys.executable就会变成一个空字符串或者None，就像是小猫咪躲起来了一样。

所以，我们要怎么找到这只迷路的小猫咪呢？其实很简单，我们只需要使用sys.executable这个魔法咒语，就能找到它的可执行文件的真实路径啦！如果它能找到回家的路，那么sys.executable就会显示出它的绝对路径，就像是小猫咪找到了回家的路标一样。

但是，如果这只小猫咪找不到回家的路，那么sys.executable就会变成一个空字符串或者None，就像是小猫咪躲起来了一样。这时候，我们就需要想办法帮助它，让它重新找到回家的路。

所以，记住，如果你想知道Python解释器的可执行二进制文件的绝对路径，就使用sys.executable这个魔法咒语吧！它会告诉你这只迷路的小猫咪的下落，让你能够找到它并帮助它回家。加油！

>>> import sys
>>> sys.executable
'D:\\Python3.8\\python.exe'

sys.byteorder

sys.byteorder 是一个有趣的属性，它告诉你当前操作系统使用的是大端序还是小端序。大端序就像一个吃西瓜的人，从西瓜的最高有效位（也就是最上面的那一块）开始吃起，而小端序则像是一个吃西瓜的人，从西瓜的最低有效位（也就是最下面的那一块）开始吃起。

当你在大端序的操作系统上运行Python时，sys.byteorder 的值就是 'big'，就像那个吃西瓜的人一样，他们总是先吃最上面的那一块。而在小端序的操作系统上，sys.byteorder 的值就是 'little'，就像那个吃西瓜的人一样，他们总是先吃最下面的那一块。

所以，通过检查 sys.byteorder 的值，你可以知道当前操作系统是怎么吃西瓜的，也就是字节的顺序是如何排列的。这对于处理二进制数据非常有用，因为不同的字节顺序可能会导致数据解析错误。

希望你现在明白了 sys.byteorder 的意思，就像明白了吃西瓜的人的习惯一样。记住，不管是大端序还是小端序，只要能吃到西瓜，就是好操作系统！

>>> import sys
>>> sys.byteorder
'little'

sys.version_info

sys.version_info 这个东东。它其实就是一个元组，里面包含了五个组件，分别是：major（主要版本号），minor（次要版本号），micro（微小版本号），releaselevel（发布级别）和 serial（序列号）。

嗯，就像是一家五星级酒店的门牌号一样，这五个组件组合起来，就是 Python 的版本号。你可以通过 sys.version_info 来获取当前 Python 解释器的版本信息，这样你就能知道你在用的是哪个版本的 Python 啦！

比如说，如果你的 Python 版本是 3.7.2，那么 sys.version_info 的值就是 (3, 7, 2, 'final', 0)。是不是很有趣呢？就像是在看一本关于 Python 版本的小说，每个组件都有自己的故事，而 sys.version_info 就是这本小说的目录页。

所以，如果你想知道你的 Python 版本是什么，就快快调用 sys.version_info 吧！它会告诉你一个关于 Python 版本的故事，让你更了解这个神奇的编程语言。加油！

>>> import sys
>>> sys.version_info
sys.version_info(major=3, minor=7, micro=3, releaselevel='final', serial=0)

sys.api_version

这个属性告诉你当前解释器的C API版本，就像是告诉你一辆汽车的引擎型号一样。它是一个数字，代表着解释器的功能和特性。你可以把它想象成一把解释器的"身份证"，告诉你它的能力和性格。

在Python的世界里，每个解释器都有自己独特的C API版本。就像是一群不同品种的狗一样，它们有着各自的特点和技能。了解解释器的C API版本，就像是了解一只狗的品种一样，可以帮助你更好地理解和使用它。

所以，如果你想知道当前解释器的C API版本，只需要查看sys.api_version属性。它会告诉你解释器的"身份证"号码，让你更好地了解它的能力和特性。

>>> import sys
>>> sys.api_version
1013

sys.stdin/sys.stdout/sys.stderr

让我来给你讲讲这些标准输入、输出和错误的家伙们吧！它们就像是你在编程世界中的三个好朋友，总是陪伴着你的Python代码。

首先，让我介绍一下sys.stdin，这家伙就像是一个聪明的接收器，它负责接收你从键盘输入的数据。你可以把它想象成一个魔法的魔盒，只要你往里面输入数据，它就会把它们传递给你的代码。

接下来，我们有sys.stdout，这个家伙就像是一个忠实的信使，它负责把你的代码的输出送到屏幕上。它就像是一个小小的邮递员，把你的结果递送给你，让你看到你的代码的成果。

最后，我们有sys.stderr，这个家伙就像是一个警察局，负责处理你的代码中的错误信息。当你的代码出现问题时，它会把错误信息传递给你，让你知道哪里出了问题。

这三个家伙就像是你的编程小伙伴，帮助你处理输入、输出和错误。记住他们的名字，因为他们会在你的编程旅程中一直陪伴着你！

>>> import sys
>>> sys.stdin
<_io.TextIOWrapper name='<stdin>' mode='r' encoding='utf-8'>
>>> sys.stdout
<_io.TextIOWrapper name='<stdout>' mode='w' encoding='utf-8'>
>>> sys.stderr
<_io.TextIOWrapper name='<stderr>' mode='w' encoding='utf-8'>

三、常用方法

sys.exit()

sys.exit() 就像是程序的最后一道门，当你走到这里的时候，就意味着你要离开这个程序的舞台了。它就像是一个魔法指令，当你调用它的时候，程序会立即停止运行，就像是按下了一个大红按钮，所有的代码都会停止执行，正常退出时exit(0)。

想象一下，你正在玩一个游戏，突然遇到了一个无法解决的难题，你只能选择放弃。sys.exit() 就像是你在游戏中按下了退出按钮，你离开了游戏世界，回到了现实生活中。

当然，退出程序也可以是一件正常的事情。就像是你吃完一顿丰盛的大餐后，满足地拍拍肚子，然后站起来离开餐厅。sys.exit() 也可以让你的程序以正常的方式结束，就像是吃完一顿美味的代码盛宴后，满足地拍拍键盘，然后程序就会优雅地退出。

所以，记住，当你想要结束程序的时候，不管是因为遇到了无法解决的问题，还是因为程序已经完成了它的使命，sys.exit() 就是你的好朋友，它会帮助你离开程序的舞台，让你继续前进。

import sys

print(sys.exit(0))
print(sys.exit(1))

sys.modules

sys.modules，你可以看作是一个记录着系统导入的模块的大名册。就像是一个图书馆管理员，记住了每本书的名字和位置。在这个名册里，每个模块的名字都是一个键（key），而对应的模块就是值（value）。

当你需要使用某个模块的时候，你可以来找它，它会告诉你位置。就像是你要借一本书，你只需要告诉我书的名字，我就能帮你找到它所在的位置。

所以，sys.modules 就是一个非常方便的工具，让你可以轻松地查找和使用已经导入的模块。

>>> import sys
>>> sys.modules
{'sys': <module 'sys' (built-in)>, 'builtins': <module 'builtins' (built-in)>, '_frozen_importlib': <module 'importlib._bootstrap' (frozen)>, '_imp': <module '_imp' (built-in)>, '_warnings': <module '_warnings' (built-in)>, '_frozen_importlib_external': <module 'importlib._bootstrap_external' (frozen)>, '_io': <module 'io' (built-in)>, 'marshal': <module 'marshal' (built-in)>, 'nt': <module 'nt' (built-in)>, '_thread': <module '_thread' (built-in)>, '_weakref': <module '_weakref' (built-in)>, 'winreg': <module 'winreg' (built-in)>, 'time': <module 'time' (built-in)>, 'zipimport': <module 'zipimport' (frozen)>, '_codecs': <module '_codecs' (built-in)>, 'codecs': <module 'codecs' from 'D:\\Python3.8\\lib\\codecs.py'>, 'encodings.aliases': <module 'encodings.aliases' from 'D:\\Python3.8\\lib\\encodings\\aliases.py'>, 'encodings': <module 'encodings' from 'D:\\Python3.8\\lib\\encodings\\__init__.py'>, 'encodings.utf_8': <module 'encodings.utf_8' from 'D:\\Python3.8\\lib\\encodings\\utf_8.py'>, '_codecs_cn': <module '_codecs_cn' (built-in)>, '_multibytecodec': <module '_multibytecodec' (built-in)>, 'encodings.gbk': <module 'encodings.gbk' from 'D:\\Python3.8\\lib\\encodings\\gbk.py'>, '_signal': <module '_signal' (built-in)>, '__main__': <module '__main__' (built-in)>, 'encodings.latin_1': <module 'encodings.latin_1' from 'D:\\Python3.8\\lib\\encodings\\latin_1.py'>, '_abc': <module '_abc' (built-in)>, 'abc': <module 'abc' from 'D:\\Python3.8\\lib\\abc.py'>, 'io': <module 'io' from 'D:\\Python3.8\\lib\\io.py'>, '_stat': <module '_stat' (built-in)>, 'stat': <module 'stat' from 'D:\\Python3.8\\lib\\stat.py'>, '_collections_abc': <module '_collections_abc' from 'D:\\Python3.8\\lib\\_collections_abc.py'>, 'genericpath': <module 'genericpath' from 'D:\\Python3.8\\lib\\genericpath.py'>, 'ntpath': <module 'ntpath' from 'D:\\Python3.8\\lib\\ntpath.py'>, 'os.path': <module 'ntpath' from 'D:\\Python3.8\\lib\\ntpath.py'>, 'os': <module 'os' from 'D:\\Python3.8\\lib\\os.py'>, '_sitebuiltins': <module '_sitebuiltins' from 'D:\\Python3.8\\lib\\_sitebuiltins.py'>, '_locale': <module '_locale' (built-in)>, '_bootlocale': <module '_bootlocale' from 'D:\\Python3.8\\lib\\_bootlocale.py'>, 'types': <module 'types' from 'D:\\Python3.8\\lib\\types.py'>, 'importlib._bootstrap': <module 'importlib._bootstrap' (frozen)>, 'importlib._bootstrap_external': <module 'importlib._bootstrap_external' (frozen)>, 'warnings': <module 'warnings' from 'D:\\Python3.8\\lib\\warnings.py'>, 'importlib': <module 'importlib' from 'D:\\Python3.8\\lib\\importlib\\__init__.py'>, 'importlib.machinery': <module 'importlib.machinery' from 'D:\\Python3.8\\lib\\importlib\\machinery.py'>, 'importlib.abc': <module 'importlib.abc' from 'D:\\Python3.8\\lib\\importlib\\abc.py'>, '_operator': <module '_operator' (built-in)>, 'operator': <module 'operator' from 'D:\\Python3.8\\lib\\operator.py'>, 'keyword': <module 'keyword' from 'D:\\Python3.8\\lib\\keyword.py'>, '_heapq': <module '_heapq' (built-in)>, 'heapq': <module 'heapq' from 'D:\\Python3.8\\lib\\heapq.py'>, 'itertools': <module 'itertools' (built-in)>, 'reprlib': <module 'reprlib' from 'D:\\Python3.8\\lib\\reprlib.py'>, '_collections': <module '_collections' (built-in)>, 'collections': <module 'collections' from 'D:\\Python3.8\\lib\\collections\\__init__.py'>, '_functools': <module '_functools' (built-in)>, 'functools': <module 'functools' from 'D:\\Python3.8\\lib\\functools.py'>, 'contextlib': <module 'contextlib' from 'D:\\Python3.8\\lib\\contextlib.py'>, 'importlib.util': <module 'importlib.util' from 'D:\\Python3.8\\lib\\importlib\\util.py'>, 'mpl_toolkits': <module 'mpl_toolkits' (namespace)>, 'site': <module 'site' from 'D:\\Python3.8\\lib\\site.py'>, 'atexit': <module 'atexit' (built-in)>}

sys.modules.keys()

你可以把 sys.modules.keys() 想象成一个魔法宝箱，它会给你一个列表，里面装满了已经导入的模块的名字。就像你打开宝箱，里面装满了各种宝贝一样！

这个方法非常有用，因为它可以让你知道当前环境中都有哪些模块可供使用。就像是你在一个大商场里，你可以用这个方法来查看所有的店铺，然后决定去哪个店铺购物。

使用 sys.modules.keys() 可以帮助你更好地了解你的Python程序中已经导入的模块，让你更加方便地使用它们。所以，记得经常打开这个魔法宝箱，看看里面都有哪些宝贝吧！

>>> import sys
>>> sys.modules.keys()
dict_keys(['sys', 'builtins', '_frozen_importlib', '_imp', '_warnings', '_frozen_importlib_external', '_io', 'marshal', 'nt', '_thread', '_weakref', 'winreg', 'time', 'zipimport', '_codecs', 'codecs', 'encodings.aliases', 'encodings', 'encodings.utf_8', '_codecs_cn', '_multibytecodec', 'encodings.gbk', '_signal', '__main__', 'encodings.latin_1', '_abc', 'abc', 'io', '_stat', 'stat', '_collections_abc', 'genericpath', 'ntpath', 'os.path', 'os', '_sitebuiltins', '_locale', '_bootlocale', 'types', 'importlib._bootstrap', 'importlib._bootstrap_external', 'warnings', 'importlib', 'importlib.machinery', 'importlib.abc', '_operator', 'operator', 'keyword', '_heapq', 'heapq', 'itertools', 'reprlib', '_collections', 'collections', '_functools', 'functools', 'contextlib', 'importlib.util', 'mpl_toolkits', 'site', 'atexit'])

sys.getdefaultencoding()

这个函数就像是一个魔法师，它能告诉你当前默认的字符串编码是什么。它就像是一个编码的指南针，指引着你在Python的世界中航行。

当你调用这个函数时，它会返回一个字符串，告诉你当前默认的编码名称。这个编码名称就像是一种密码，用来解锁Python中的字符串。它决定了Python如何处理和表示文本数据。

你可以把这个函数想象成一个探险家，它带着你探索Python编码的奥秘。它会告诉你当前的编码是什么，就像是在一个迷宫中指引你的方向一样。

所以，当你想知道Python中默认的字符串编码是什么时，不要犹豫，调用sys.getdefaultencoding()函数，让它为你揭开编码的神秘面纱！

>>> import sys
>>> sys.getdefaultencoding()
'utf-8'

sys.getfilesystemencoding()

嘿，这个函数就像是一个翻译官，专门负责在Unicode文件名和字节文件名之间进行转换。它告诉你使用的是哪种编码名称，就像是告诉你使用的是哪种语言一样。

想象一下，你正在处理一堆文件，有些文件名是用Unicode编码表示的，有些文件名是用字节编码表示的。这就像是你面前有一堆来自不同国家的人，有些人说的是中文，有些人说的是英文。你需要一个翻译官来帮助你与他们沟通。

这个函数就是你的翻译官，它告诉你当前使用的是哪种编码名称，这样你就知道该如何正确地转换文件名了。就像是翻译官告诉你当前使用的是中文还是英文，这样你就知道该使用哪种语言来与对方交流了。

所以，当你需要在Unicode文件名和字节文件名之间进行转换时，记得调用这个函数，它会告诉你使用的是哪种编码名称，让你的文件操作更加顺畅。就像是有了一个翻译官，你可以轻松地与不同语言的人交流一样。

希望这个比喻能帮助你更好地理解这个函数的作用！记住，这个函数是Python中的关键字，所以在代码中使用它的时候要注意哦！

>>> import sys
>>> sys.getfilesystemencoding()
utf-8

sys.getrecursionlimit()

这个函数就像是一个递归的极限挑战！它告诉你，你能够在Python中递归多少次，就像是告诉你，你能够吃多少块巧克力一样。它返回的是最大递归次数，也就是你的递归能力的极限。

当你调用sys.getrecursionlimit()时，它会回答你的问题，告诉你你的递归能力有多强。这个函数返回一个整数，表示Python解释器允许的最大递归次数。

想象一下，你是一个递归的冒险者，你的目标是探索递归的深渊。但是，你不能无限制地递归下去，就像你不能无限制地吃巧克力一样。Python解释器设置了一个限制，告诉你最多可以递归多少次。这个限制就是通过sys.getrecursionlimit()来获取的。

所以，当你想知道你的递归能力有多强时，不妨调用一下sys.getrecursionlimit()，看看它会告诉你什么吧！记住，递归是一项强大的技能，但也要小心不要陷入无尽的循环中哦！

>>> import sys
>>> sys.getrecursionlimit()  # 查看当前解释器的最大递归深度
1000

sys.setrecursionlimit(num)

这个函数就像是给递归设了个“上限”，就像是给一只会无限叫的青蛙戴上了一顶“沉默帽子”。它可以帮助我们设置最大递归次数，避免递归过程中的无限循环，就像是给一只会无限跳的袋鼠限制了跳跃的次数。

当我们使用递归函数时，有时候可能会遇到递归次数过多的问题。这就好像是一只会无限叫的青蛙，它会一直叫下去，直到我们手动给它戴上一顶“沉默帽子”，让它闭嘴为止。在Python中，我们可以使用sys.setrecursionlimit(num)来设置最大递归次数，就像是给这只青蛙戴上了一顶“沉默帽子”。

这个函数的作用就是告诉Python，当递归次数达到了设定的上限时，就停止递归。它可以帮助我们避免递归过程中的无限循环，就像是给一只会无限跳的袋鼠限制了跳跃的次数。

所以，如果你遇到了递归次数过多的问题，不妨试试这个函数，给你的递归函数戴上一顶“沉默帽子”，让它在适当的时候闭嘴。记住，递归是一把双刃剑，用得好可以解决很多问题，用得不好就可能陷入无限循环的泥潭。所以，掌握好这个函数，让你的递归函数在适当的时候保持沉默，避免无限循环的困扰。

>>> import sys
>>> sys.setrecursionlimit(1100)  # 将解释器的最大递归深度设置为1100
>>> sys.getrecursionlimit()  # 再次查看当前解释器的最大递归深度
1100

sys.getsizeof()

这个函数就像是一个内存探测器，可以告诉你一个对象占用了多少内存空间，就像是一个魔法秤一样。它会把对象的大小用字节来表示，就像是给对象戴上了一个小小的尺码衣服。

使用sys.getsizeof()，让你知道它占用了多少内存空间。这个函数就像是一个内存探测器，可以告诉你对象的大小，就像是给你的对象戴上了一个小小的尺码衣服。

这个函数就像是一个内存探测器，可以告诉你对象占用了多少内存空间，就像是给你的对象戴上了一个小小的尺码衣服。你可以使用sys.getsizeof()来获取对象的大小，它会以字节为单位告诉你对象占用了多少内存空间。

>>> import sys
>>> for obj in [int(), float(), list(), tuple(), set(), dict(), object]:
...     print(str(obj.__class__).ljust(20), sys.getsizeof(obj))
...
<class 'int'>        24
<class 'float'>      24
<class 'list'>       56
<class 'tuple'>      40
<class 'set'>        216
<class 'dict'>       232
<class 'type'>       416

sys.getrefcount(obj)

这个函数就像是一个调查员，它会告诉你一个对象被引用了多少次。它会像一只侦探一样，悄悄地搜寻着对象的每个角落，数一数有多少个引用。但是它有一个小小的问题，就是它会把一些临时的引用也算进去，所以返回的计数通常会比你预期的多一个。就像是你在数鸡蛋的时候，突然有一颗蛋从篮子里滚出来，你就多数了一颗蛋一样。

这个函数就像是一个魔术师，它可以帮你找出一个对象被引用了多少次。它会像一只蜜蜂一样，飞到对象的周围，数一数有多少个引用。但是它有一个小小的问题，就是它会把一些临时的引用也算进去，所以返回的计数通常会比你预期的多一个。就像是你在数花瓣的时候，突然有一朵花从地上长出来，你就多数了一片花瓣一样。

希望这个比喻能帮助你更好地理解这个函数的作用！

>>> import sys
>>> a = [1,2,3]
>>> b = a
>>> c = b
>>> sys.getrefcount(a)
4

sys.exc_info()

有一种神奇的方法可以帮助我们获取当前正在处理的异常类和详细信息！它就是sys.exc_info()。

这个方法就像是一个超级侦探，总能找到正在发生的异常的蛛丝马迹。它会告诉你异常的类型（exc_type）、异常的值（exc_value）和异常的追踪信息（exc_traceback）。简直就像是给你一张异常的全套调查报告！

使用sys.exc_info()就像是在调查一起犯罪案件一样。你可以通过这个方法来追踪异常的来源，找到罪魁祸首。就像是在查看一张犯罪嫌疑人的档案一样，你可以了解到异常的类型、值和追踪信息，从而更好地理解问题所在。

所以，当你遇到异常时，不要慌张！调用sys.exc_info()，它会给你提供一切你需要的信息，帮助你解决问题。记住，它就像是你的超级侦探朋友，总能帮你找到答案！

>>> import sys
>>> sys.exc_info()
(None, None, None)

sys.getwindowsversion()

这个函数就像是一个窥探Windows系统内心的小间谍，它会告诉你Windows的版本号。它就像是一个瑞士军刀，可以帮助你了解你所面对的Windows系统的特性和功能。它就像是一本魔法书，可以揭示Windows系统的神秘面纱。它就像是一位卧底特工，可以为你搜集关于Windows系统的情报。

使用这个函数，你可以轻松地获取Windows系统的版本信息，从而更好地了解你的操作环境。无论你是在开发软件还是进行系统维护，这个函数都会是你的得力助手。它可以告诉你Windows的主要版本号、次要版本号、构建号、平台和服务包信息，让你对Windows系统了如指掌。

所以，不要再猜测Windows的版本了，让sys.getwindowsversion()来告诉你答案吧！它就像是一位可靠的情报员，会为你揭示Windows系统的秘密。快来使用这个函数，探索Windows的奥秘吧！

>>> import sys
>>> sys.getwindowsversion()
sys.getwindowsversion(major=10, minor=0, build=19041, platform=2, service_pack='')

sys.stdin.readline()

sys.stdin.readline() 就像是一位饥饿的大厨，它会从标准输入中一口气读取一整行，就像是一口吃掉一整块美味的披萨！但是，它还会贪婪地吞下末尾的换行符，就像是吃披萨时不小心吞下了披萨盒子一样。

这个函数非常方便，因为它可以一次性读取整行输入，而不需要像其他函数一样逐个字符地读取。它就像是一把魔法的剪刀，可以快速地剪断输入流中的一行。

但是记住，sys.stdin.readline() 只读取一行，所以如果你的输入有多行，你需要多次使用它。就像是一位饥饿的大厨需要多次咀嚼才能吃完一整个披萨一样。

所以，当你需要从标准输入中读取一行时，不妨让 sys.stdin.readline() 来帮你，它会像一位饥饿的大厨一样，迅速而贪婪地吞下整行输入，让你的代码更加高效！

使用 sys.stdin.readline() 方法的一般用法是：

python复制代码import sys

input_str = sys.stdin.readline()

在上面的代码中，sys.stdin.readline() 会等待用户在命令行中输入一行内容，然后将输入的内容作为字符串返回给 input_str 变量。请注意，默认情况下，sys.stdin.readline() 会包含输入行的换行符，你可能需要使用 .strip() 方法去掉换行符：

python复制代码import sys

input_str = sys.stdin.readline().strip()

由于 sys.stdin.readline() 读取的是一行内容，因此在继续读取下一行之前，需要再次调用 sys.stdin.readline()。

需要注意的是，使用 sys.stdin.readline() 方法时，程序会一直等待用户输入，直到用户按下回车键。如果需要读取多行输入，你可以使用循环来不断读取，直到达到预期的结束条件。

python复制代码import sys

lines = []
while True:
    line = sys.stdin.readline().strip()
    if not line:
        break
    lines.append(line)

# 打印输入的所有行
for line in lines:
    print(line)

请注意，当使用 sys.stdin.readline() 读取用户输入时，输入的数据会作为字符串进行处理，如果需要处理其他类型的数据，需要进行相应的转换操作。

sys.stdout.write()

sys.stdout.write()就像是你的写作助手，它可以帮助你向标准输出写入内容。它就像是一把魔法笔，你只需要告诉它你想要写什么，它就会把你的想法变成文字，展现给世界。

想象一下，你正在写一篇文章，但是你没有纸和笔。这时，你的好朋友sys.stdout.write()走了进来，他递给你一张看不见的纸和一支看不见的笔。你只需要告诉他你想写什么，他就会把你的文字写在纸上，让大家都能看到。

这个函数就像是你的文字传送带，它会把你的文字送到标准输出，让它们在控制台上展现出来。它就像是一只忠实的信使，把你的信息传递给世界。

使用sys.stdout.write()的方式很简单，只需要在括号里面写上你想要输出的内容，它就会帮你实现。不过要记住，它只能输出字符串类型的内容，所以如果你想输出其他类型的数据，记得先把它们转换成字符串哦。

让我们来看一个例子吧：

>>> import sys
>>> sys.stdout.write("hello world")
hello world

这段代码会在控制台上输出"Hello, World!"，让你的问候传达给全世界。

所以，记住，当你想要向标准输出写入内容时，sys.stdout.write()就是你的得力助手，它会帮你把想法变成文字，让你的声音传遍天下！