1. sys模塊介紹

什么是Python 解釋器

當(dāng)編寫Python 代碼時，通常都會得到一個包含Python 代碼的以.py 為擴(kuò)展名的文件。要運行編寫的代碼，就需要使用Python 解釋器去執(zhí)行.py 文件。因此，Python 解釋器就是用來執(zhí)行Python 代碼的一種工具。常見的Python 解釋器有以下幾種：

• CPython：Python 的官方解釋器。當(dāng)我們從Python 官方網(wǎng)站下載并安裝好Python 后，就直接獲得了CPython 解釋器，該解釋器是使用C 語言開發(fā)的，所以叫CPython。我們在CMD 命令窗口中運行python 命令就是啟動CPython 解釋器，如圖1 所示。

• IPython ：IPython 是基于CPython 之上的一個交互式解釋器，它執(zhí)行Python 代碼的功能和CPython 是完全一樣的，唯一的區(qū)別是：CPython 用“>>>”作為提示符，而IPython 用“In[ 序號]:”作為提示符。

• PyPy ：PyPy 解釋器的目標(biāo)是執(zhí)行速度，它采用JIT 技術(shù)，對Python 代碼進(jìn)行動態(tài)編譯，所以可以顯著提高Python 代碼的執(zhí)行速度。

• Jython：運行在Java 平臺上的Python 解釋器，可以直接把Python 代碼編譯成Java 字節(jié)碼執(zhí)行。

• IronPython ：運行在微軟.NET平臺上的Python解釋器，可以直接把Python代碼編譯成.NET的中間代碼。

sys 模塊的作用

sys 模塊提供訪問Python 解釋器使用或維護(hù)的屬性，以及與Python 解釋器進(jìn)行交互的方法。簡單來講，sys 模塊負(fù)責(zé)程序與Python 解釋器的交互，并提供了一系列的屬性和方法，用于操控Python 運行時的環(huán)境。

在Python 程序中使用sys 模塊，首先需要使用import 導(dǎo)入，代碼如下：

import sys

導(dǎo)入sys 模塊后，就可以使用該模塊提供的屬性和方法了。

2. argv屬性——程序命令行參數(shù)列表

argv 屬性表示傳遞給Python 腳本的命令行參數(shù)列表。argv[0] 是腳本名稱（取決于操作系統(tǒng)是否為完整路徑名）。語法格式如下：

sys.argv

注意:在Unix 系統(tǒng)中，命令行參數(shù)是從OS 傳遞的字節(jié)。Python 使用文件系統(tǒng)編碼和“surrogateescape”錯誤處理程序?qū)λ鼈冞M(jìn)行解碼。

通過使用argv 屬性獲取Python 解釋器的命令行參數(shù)列表，并使用argv[0] 獲取Python 腳本的完整路徑，代碼如下：

import sys

print(sys.argv)

print(sys.argv[0])

3. __breakpointhook__屬性——breakpointhook()方法的初始值

__breakpointhook__ 屬性用于獲取程序啟動時breakpointhook() 方法的初始值。在breakpointhook()方法發(fā)生重寫時，可以使用__breakpointhook__ 對其初始值進(jìn)行設(shè)置。語法格式如下：

sys.__breakpointhook__

說明:breakpointhook 是Python 3.7 版中新增的。

使用__breakpointhook__ 屬性獲取__breakpointhook__ 對象的類型，代碼如下：

import sys

print(sys.__breakpointhook__)

程序運行結(jié)果如下：

<built-in function breakpointhook>

說明:上面的運行結(jié)果說明__breakpointhook__ 是一個內(nèi)置函數(shù)，它是breakpointhook() 方法的默認(rèn)形式。

4. base_exec_pref?ix屬性——獲取Python安裝目錄

在site.py 運行之前，Python 啟動時，base_exec_prefix 屬性被設(shè)置為與exec_prefix 屬性同樣的值。如果不是運行在虛擬環(huán)境中，base_exec_prefix 屬性和exec_prefix 屬性的值會保持相同；如果site.py發(fā)現(xiàn)處于一個虛擬環(huán)境中，prefix 和exec_prefix 屬性將會指向虛擬環(huán)境，而base_exec_prefix 屬性將仍然會指向基礎(chǔ)的Python 環(huán)境（用來創(chuàng)建虛擬環(huán)境的Python 環(huán)境）。語法格式如下：

sys.base_exec_prefix

通過使用base_exec_prefix 屬性輸出Python 的安裝目錄，代碼如下：

import sys

print(sys.base_exec_prefix)

程序運行結(jié)果如下：

D:\Python\Python37

通過使用base_exec_prefix 屬性輸出Python 的安裝目錄，并判斷是否安裝在C 盤上，代碼如下：

import sys

print(‘Python安裝目錄：'+sys.base_exec_prefix)

if sys.base_exec_prefix[0:1]==’C’: 					# 判斷是否安裝在C盤

	print(‘Python安裝在系統(tǒng)盤C盤中，請謹(jǐn)慎！')

else:

	print(‘Python沒有安裝在系統(tǒng)盤C盤中，這個習(xí)慣不錯哦！')

5. base_pref?ix屬性——獲取Python虛擬環(huán)境目錄

在site.py 運行之前，Python 啟動時，base_prefix 屬性被設(shè)置為與prefix 屬性同樣的值。如果不是運行在虛擬環(huán)境中，base_prefix 屬性和prefix 屬性的值會保持相同；如果site.py 發(fā)現(xiàn)處于一個虛擬環(huán)境中，prefix 和exec_prefix 屬性將會指向虛擬環(huán)境，而base_prefix 屬性將仍然指向基礎(chǔ)的Python 環(huán)境（用來創(chuàng)建虛擬環(huán)境的Python 環(huán)境）。語法格式如下：

sys.base_prefix

通過使用base_prefix 屬性輸出Python 的虛擬環(huán)境目錄，代碼如下：

import sys

print(sys.base_prefix)

6. byteorder屬性——本機(jī)字節(jié)順序指示器

byteorder 屬性表示本機(jī)字節(jié)順序指示器。big-endian（最高有效字節(jié)在第一位）值為“big”，little-endian（最低有效字節(jié)在第一位）值為“l(fā)ittle”。語法格式如下：

sys.byteorder

通過使用byteorder 屬性獲取本機(jī)的字節(jié)順序指示器，代碼如下：

import sys

print(sys.byteorder)

程序運行結(jié)果如下：

little

說明:上面結(jié)果為little，說明本機(jī)的字節(jié)存儲順序是小端序，小端序是權(quán)值低的在前面，大端序是權(quán)值高的在前面，比如0x12345678 在小端序下是按照78563412 存儲的, 而大端序是按照12345678存儲的。

7. builtin_module_names屬性——獲取Python解釋器中的所有模塊名稱

通過builtin_module_names 屬性可以得到一個字符串元組，它包含了Python 解釋器中的所有模塊的名稱（不包括導(dǎo)入的模塊）。語法格式如下：

sys.builtin_module_names

獲取并輸出Python 中的所有內(nèi)置模塊，代碼如下：

import sys

print(sys.builtin_module_names)

8. copyright屬性——Python版權(quán)信息

copyright 屬性用于獲取與Python 解釋器相關(guān)的版權(quán)信息的字符串，語法格式如下：

sys.copyright

使用copyright 屬性輸出Python 解釋器的版權(quán)信息，代碼如下：

import sys

print(sys.copyright)

9. dont_write_bytecode屬性——是否寫字節(jié)碼文件

dont_write_bytecode 屬性用來表示是否寫字節(jié)碼文件，其值是一個布爾值，標(biāo)識在導(dǎo)入模塊時，Python 是否寫入字節(jié)碼文件（.pyc 或.pyo 文件）。初始值是True 或False，取決于-B 命令行選項和PYTHONDONTWRITEBYTECODE 環(huán)境變量的設(shè)置。開發(fā)人員可以在自己的程序中根據(jù)需要修改該設(shè)置。語法格式如下：

sys.dont_write_bytecode[=True/False]

說明:.pyc 文件是由.py 文件經(jīng)過編譯后生成的字節(jié)碼文件，其加載速度相對于之前的.py 文件有所提高，而且還可以實現(xiàn)源碼隱藏，以及一定程度上的反編譯；而.pyo 文件是優(yōu)化編譯后的程序（相比于.pyc文件更?。部梢蕴岣呒虞d速度。對于嵌入式系統(tǒng)，它可將所需模塊編譯成.pyo 文件以減少容量。

使用dont_write_bytecode 屬性獲取本機(jī)Python 模塊導(dǎo)入時是否自動生成字節(jié)碼文件的標(biāo)識并輸出，代碼如下：

import sys

print(sys.dont_write_bytecode)

程序運行結(jié)果如下：

False

說明:上面代碼返回值為False，說明默認(rèn)不生成字節(jié)碼文件，因為.pyc 文件只有在工程目錄下同時有
__main__.py 文件和其他將要調(diào)用的模塊時才會生成。如果只有當(dāng)前運行的腳本"__main__"，則不會生成.pyc 的文件。

10. dllhandle屬性——獲取Python DLL的整數(shù)句柄

dllhandle 屬性用于獲取Python DLL 的整數(shù)句柄，僅限于Windows 系統(tǒng)中使用。語法格式如下：

sys.dllhandle

使用dllhandle 屬性獲取Python DLL 組件句柄的整數(shù)表示形式并打印，代碼如下：

import sys

print(sys.dllhandle)

11. __excepthook__屬性——excepthook()方法的初始值

__excepthook__ 屬性表示程序啟動時excepthook() 方法的初始值。在excepthook() 方法發(fā)生重寫時，可以使用__excepthook__ 對其進(jìn)行重置。語法格式如下：

sys.__excepthook__

輸出__excepthook__ 對象的類型，代碼如下：

import sys

print(sys.__excepthook__)

程序運行結(jié)果如下：

<built-in function excepthook>

說明:上面的運行結(jié)果說明__excepthook__ 是一個內(nèi)置函數(shù)，它是excepthook() 方法的默認(rèn)形式。

12. exec_pref?ix屬性——獲取Python安裝文件目錄

exec_prefix 屬性用于獲取一個字符串，表示特定的目錄，其中安裝了與平臺相關(guān)的Python 文件。語法格式如下：

sys.exec_prefix

說明:可以在構(gòu)建程序時，使用configure 腳本的–exec-prefix 參數(shù)對其進(jìn)行設(shè)置，其中，所有的配置文件被安裝在“exec_prefix/lib/pythonX.Y/config”路徑下，所有的共享模塊被安裝在“exec_prefix/lib/pythonX.Y/lib-dynload”路徑下，X、Y 是Python 的版本號。

注意:如果虛擬環(huán)境生效，則exec_prefix 屬性為虛擬環(huán)境的目錄。

使用exec_prefix 屬性獲取Python 安裝文件的目錄，代碼如下：

import sys

print(sys.exec_prefix)

程序運行結(jié)果如下：

J:\PythonDemo\venv

說明:上面代碼運行后的返回結(jié)果是一個虛擬目錄，這是在PyCharm 中創(chuàng)建項目時創(chuàng)建的虛擬目錄。

13. executable屬性——Python解釋器的絕對路徑

executable 屬性用于返回一個字符串，表示Python 解釋器的可執(zhí)行文件的絕對路徑。如果Python無法檢索其可執(zhí)行文件的真實路徑，executable 屬性將返回空字符串或None。語法格式如下：

sys.executable

獲取并輸出Python 解釋器的絕對路徑，代碼如下：

import sys

print(sys.executable)

14. flags屬性——啟動Python時的命令行選項

flags 屬性返回一個只讀的結(jié)構(gòu)序列，其保存并導(dǎo)出了啟動Python 時的命令行選項。語法格式如下：

sys.flags

flags 屬性包含的屬性及對應(yīng)命令行選項如表

說明:1. 版本3.2 中為quiet 屬性增加了-q 選項。2. 版本3.2.3 新增了hash_randomization 屬性。3. 版本3.3 中刪除了過時的division_warning 屬性。4. 版本3.4 中為isolated 屬性增加了-I 選項。5. 版本3.7 中為dev_mode 屬性增加了-X dev 選項，為utf8_mode 屬性增加了-X utf8 選項。

在CMD 命令窗口中，輸入如下命令：

python

>>> import sys

>>> sys.flags

15. float_info屬性——包含浮點類型的信息

float_info 屬性返回包含有關(guān)浮點類型信息的結(jié)構(gòu)序列，它包含有關(guān)精度和內(nèi)部表示的低級信息，這些值對應(yīng)于C 語言的float.h 標(biāo)準(zhǔn)頭文件中定義的各種浮點常量。語法格式如下：

sys.float_info

浮點類型屬性及說明如表

獲取并輸出Python 中浮點類型的相關(guān)信息，代碼如下：

import sys

print(sys.float_info)

程序運行結(jié)果如下：

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)

通過使用float_info 對象中的max 屬性顯示最大浮點數(shù)，代碼如下：

import sys

print(sys.float_info.max)

16. float_repr_style屬性——表示repr()函數(shù)輸出的浮點數(shù)類型

float_repr_style 屬性用于返回一個表示repr() 函數(shù)輸出的浮點數(shù)類型的字符串，如果返回值為“short”，那么對于有限浮點數(shù)x，repr(x) 旨在生成具有該屬性的短字符串。例如，float(repr(x)) == x。語法格式如下：

sys.float_repr_style

說明:float_repr_style 屬性是Python 3.1 版本中新增的，因此只能在Python 3.1 及以上版本使用。

使用float_repr_style 屬性獲取repr() 函數(shù)輸出的浮點數(shù)，代碼如下：

import sys

print(sys.float_repr_style)

程序運行結(jié)果如下：

Short

說明:返回值為short，說明本機(jī)輸出浮點數(shù)時，默認(rèn)精度為16。例如，在使用下面代碼輸出浮點數(shù)時，print(repr(3.1415926542354543324))輸出結(jié)果為：3.1415926542354544。

17. hash_info屬性——獲取哈希信息

hash_info 屬性返回一個表示數(shù)字散列執(zhí)行參數(shù)的結(jié)構(gòu)序列，即哈希相關(guān)的信息。語法格式如下：

sys.hash_info

數(shù)字散列執(zhí)行參數(shù)及說明如表

說明:

1. hash_info 屬性是Python 3.2 版本中新增的，因此只能在Python 3.2 及以上版本使用。
2. 在Python 3.4 版本中添加了hash_bits 屬性和seed_bits 屬性。

獲取Python 中與哈希相關(guān)的信息并輸出，代碼如下：

import sys

print(sys.hash_info)

18. hexversion屬性——十六進(jìn)制表示的版本號

hexversion 屬性獲取使用十六進(jìn)制整數(shù)表示的版本號。該整數(shù)值總是隨著更新的解釋器版本而增大，包括對非生產(chǎn)版本的適當(dāng)支持。語法格式如下：

sys.hexversion

說明:可以使用hex() 函數(shù)獲取hexversion 版本號的十六進(jìn)制表示形式。

獲取并輸出本機(jī)上當(dāng)前正在運行的Python 解釋器的十六進(jìn)制版本號，代碼如下：

import sys

print(sys.hexversion)

程序運行結(jié)果如下：

50790896

使用hexversion 屬性判斷當(dāng)前使用的Python 解釋器版本是不是3.7.1，代碼如下：

import sys

if sys.hexversion == 0x030701F0:

print(‘您當(dāng)前使用的是Python 3.7.1版本')

else:

print(‘您使用的Python不匹配')

19. implementation屬性——當(dāng)前運行的解釋器的信息

implementation 屬性用于返回一個包含當(dāng)前運行的Python 解釋器實現(xiàn)信息的對象。語法格式如下：

sys.implementation

包含Python 解釋器信息的屬性及說明如表

說明:implementation 屬性是Python 3.3 版本中新增的，因此只能在Python 3.3 及以上版本使用。

使用implementation 屬性獲取當(dāng)前Python 解釋器的信息并輸出，代碼如下：

import sys

print(sys.implementation)

20. int_info屬性——Python內(nèi)部整數(shù)表示的信息

int_info 屬性返回一個包含有關(guān)Python 內(nèi)部整數(shù)相關(guān)信息的結(jié)構(gòu)序列。語法格式如下：

sys.int_info

int_info 屬性是只讀的，它所獲取到的int 相關(guān)屬性如下：

• bits_per_digit：每個數(shù)字中保持的位數(shù)。

• sizeof_digit：用于表示數(shù)字的C語言類型的字節(jié)大小。

使用int_info 屬性獲取Python 中整數(shù)類型的相關(guān)信息并輸出，代碼如下：

import sys

print(sys.int_info)

21. __interactivehook__屬性——交互模式下啟動解釋器

__interactivehook__ 屬性用于在交互模式下啟動解釋器。當(dāng)此屬性存在，并在交互模式下啟動解釋器時，將自動調(diào)用其值（不帶參數(shù)）。該操作在PYTHONSTARTUP 文件被讀取之后進(jìn)行，所以開發(fā)人員可以在那之前設(shè)置此鉤子函數(shù)，鉤子函數(shù)在site 模塊中進(jìn)行設(shè)置。語法格式如下：

sys.__interactivehook__

使用__interactivehook__ 屬性獲取__interactivehook__ 對象原型，代碼如下：

import sys

print(sys.__interactivehook__)

程序運行結(jié)果如下：

<function enablerlcompleter.<locals>.register_readline at 0x0000015C7FDAD9D8>

使用sys.interactivehook() 獲取__interactivehook__ 對象的初始值，代碼如下：

import sys

print(sys.__interactivehook__())

22. maxsize屬性——最大整數(shù)值

maxsize 屬性表示Python 中理論上支持的最大整數(shù)值，該數(shù)值與系統(tǒng)有關(guān)。如果是32 位系統(tǒng)，最大整數(shù)值為231-1 ；如果是64 位系統(tǒng)，最大整數(shù)值為263-1。語法格式如下：

sys.maxsize

打印當(dāng)前系統(tǒng)中Python 支持的最大整數(shù)值，代碼如下：

import sys

print(sys.maxsize)

程序運行結(jié)果如下：

9223372036854775807

說明:雖然使用maxsize 屬性獲取到的Python 中的最大整數(shù)值理論上是9223372036854775807，但實際上，Python 中支持的最大整數(shù)值是無限大的，比如下面的整數(shù)也可以正常輸出。

23. maxunicode屬性——能夠表示的最大Unicode碼的整數(shù)

maxunicode 屬性用于表示最大Unicode 碼的整數(shù)。UCS-2 編碼的默認(rèn)值是65535，UCS-4 編碼的默認(rèn)值為1114111（0x10FFFF 十六進(jìn)制）。語法格式如下：

sys.maxunicode

使用maxunicode 屬性獲取本機(jī)的Unicode 編碼的最大整數(shù)表示并輸出，代碼如下：

import sys

print(sys.maxunicode)

24. meta_path屬性——獲取元路徑查找器對象的列表

meta_path 屬性用于獲取元路徑查找器對象的列表，其find_spec() 方法用來查看某對象是否可以找到要導(dǎo)入的模塊。語法格式如下：

sys.meta_path

說明:

1. find_spec() 方法調(diào)用時，第一個參數(shù)必須是要導(dǎo)入模塊的絕對名稱；如果要導(dǎo)入的模塊包含在包中，則父包的__path__ 屬性為第二個參數(shù)。該方法返回模塊規(guī)范，如果未找到模塊，返回None。
2. 在Python 3.4 版本之前，使用find_module() 方法來實現(xiàn)與find_spec() 方法相同的功能。實際應(yīng)用時，如果meta_path 中沒有find_spec() 方法，則仍然可以使用find_module() 方法。

使用meta_path 屬性獲取Python 的默認(rèn)元路徑查找對象列表，代碼如下：

import sys

print(sys.meta_path)

25. modules屬性——將模塊名稱映射到已加載模塊的字典

modules 屬性返回一個將模塊名稱映射到已加載模塊的字典。語法格式如下：

sys.modules

參數(shù)說明：

• 返回值：返回一個字典。

使用modules 屬性獲取本機(jī)所有已安裝的模塊及所在模塊文件，代碼如下：

import sys

for k, v in sys.modules.items(): 		# 遍歷所有模塊字典

	print(k,’:’, v)                  	# 打印模塊及所在模塊文件

程序運行結(jié)果如下：

sys : <module 'sys' (built-in)>builtins : <module 'builtins' (built-in)>_frozen_importlib : <module 'importlib._bootstrap' (frozen)>_imp : <module '_imp' (built-in)>_thread : <module '_thread' (built-in)>

_warnings : <module '_warnings' (built-in)>_weakref : <module '_weakref' (built-in)>

zipimport : <module 'zipimport' (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)>

……

說明:上面運行結(jié)果中的“(built-in)”表示該模塊為內(nèi)置模塊。

26. path屬性——指定模塊搜索路徑

path 屬性用于獲取一個字符串列表，它指定模塊的搜索路徑。在程序啟動時，此列表的第一項path[0] 通常是Python 腳本（.py 文件）所在的目錄。如果腳本目錄不可用（例如，交互式調(diào)用解釋器或者從標(biāo)準(zhǔn)輸入讀取腳本），則path[0] 為空字符串，它指示Python 首先搜索當(dāng)前目錄中的模塊。語法格式如下：

sys.path

使用path 屬性獲取Python 解釋器的模塊搜索路徑，并遍歷輸出，代碼如下：

import sys

for i in sys.path: 		# 遍歷所有路徑列表

print(i)       			# 打印遍歷到的路徑

27. path_hooks屬性——為路徑創(chuàng)建f?inder

path_hooks 屬性用來為路徑創(chuàng)建finder，它的屬性值是一個callables 列表。如果可以創(chuàng)建一個finder，它將由callable 返回，否則拖出ImportError 異常。語法格式如下：

sys.path_hooks

獲取并打印path_hooks 屬性的值，代碼如下：

import sys

print(sys.path_hooks)

28. path_importer_cache屬性——查找程序?qū)ο缶彺娴淖值?/h2>

path_importer_cache 屬性用于返回查找程序?qū)ο缶彺娴淖值?，鍵是已傳遞到sys.path_hooks 的路徑，值是找到的查找程序。如果路徑是有效的文件系統(tǒng)路徑但未在sys.path_hooks 中找到查找器，則值為None。語法格式如下：

sys.path_importer_cache

使用path_importer_cache 屬性獲取Python 程序及其對象緩存的字典，并打印輸出，代碼如下：

import sys

print(sys.path_importer_cache)

29. platform屬性——獲取系統(tǒng)標(biāo)識符

platform 屬性返回一個表示系統(tǒng)標(biāo)識符的字符串。語法格式如下：

sys.platform

操作系統(tǒng)及對應(yīng)的platform 值如表

說明:從Python 3.3 版開始，在Linux 上使用platform 屬性獲取系統(tǒng)標(biāo)識符時，獲取到的系統(tǒng)標(biāo)識符不再包含主要版本，即得到的結(jié)果是“l(fā)inux”，而不是“l(fā)inux2”或“l(fā)inux3”。

使用platform 屬性獲取當(dāng)前系統(tǒng)的標(biāo)識符，代碼如下：

import sys

print(sys.platform)

程序運行結(jié)果如下：

win32

30. pref?ix屬性——表示特定于站點的目錄前綴

prefix 屬性返回一個特定于站點的目錄前綴的字符串，其中安裝了與平臺無關(guān)的Python 文件。語法格式如下：

sys.prefix

說明：如果虛擬環(huán)境生效，則site.py 文件中的此值將會指向虛擬環(huán)境，而Python 安裝文件的值仍然可以通過base_prefix 得到。

使用prefix 屬性可以獲取與平臺無關(guān)的Python 文件的安裝目錄，這里使用該屬性獲取Python 虛擬環(huán)境的安裝目錄（在PyCharm 中創(chuàng)建項目，然后在項目中創(chuàng)建Python 文件來存儲下面代碼），代碼如下：

import sys

print(sys.prefix)

31. ps1屬性——解釋器的主要提示

ps1 屬性用于指定解釋器的主要提示字符串，該屬性只有在Python 解釋器處于交互模式時才可用。ps1 屬性的默認(rèn)值為“>>>”。語法格式如下：

sys.ps1[=value]

參數(shù)說明：

• value：表示要設(shè)置的解釋器主要提示。

在CMD 命令窗口中使用ps1 屬性獲取主提示符的值，代碼如下：

>>> import sys

>>> sys.ps1

輸出運行結(jié)果如下：

'>>> '

在CMD 命令窗口中設(shè)置ps1 屬性的值為“<<<”，并重新輸出主提示符的值，代碼如下：

>>> import sys

>>> sys.ps1='<<<'

<<<sys.ps1

輸出運行結(jié)果如下：

'<<<'

32. ps2屬性——解釋器的輔助提示

ps2 屬性用于指定解釋器的輔助提示字符串，該屬性只有在Python 解釋器處于交互模式時才可用。ps2 默認(rèn)值為“…”。語法格式如下：

sys.ps2[=value]

參數(shù)說明：

• value：可選參數(shù)，表示可以為ps2設(shè)置的特定值。

在CMD 命令窗口中使用ps2 屬性獲取輔助提示符的值，代碼如下：

>>> import sys

>>> sys.ps2

輸出運行結(jié)果如下：

'... '

在CMD 命令窗口中設(shè)置ps2 屬性的值為“***”，并重新輸出輔助提示符的值，代碼如下：

>>> import sys

>>> sys.ps2='***'

>>> sys.ps2

輸出運行結(jié)果如下：

'***'

33. stderr屬性——標(biāo)準(zhǔn)錯誤對象

stderr 屬性表示Python 解釋器的標(biāo)準(zhǔn)錯誤對象，主要顯示Python 解釋器自己的提示及其錯誤消息。語法格式如下：

sys.stderr[=value]

參數(shù)說明：

• value：可選參數(shù)，表示可以為stderr 設(shè)置特定的標(biāo)準(zhǔn)錯誤輸出對象。

手動改變stderr 輸出形式，將錯誤信息寫入log.txt 日志文件中，代碼如下：

import sys

saveerr = sys.stderr                 	# 在重定向前保存stderr

# 打開一個新文件用于寫入。如果文件不存在，將會被創(chuàng)建。如果文件存在，將被覆蓋

info = open(‘log.txt’, ‘w’)

sys.stderr = info                    	# 所有后續(xù)的錯誤信息都會被重定向到剛才打開的新文件上

print(‘change stderr’)                	# 將錯誤“打印”到日志文件中

sys.stderr = saveerr                 	# 重置stderr

info.close()                        	# 關(guān)閉日志文件

34. stderr.write()方法——標(biāo)準(zhǔn)錯誤輸出

stderr 是sys 模塊中的標(biāo)準(zhǔn)錯誤輸出流，可以實現(xiàn)將錯誤信息向屏幕、文件等進(jìn)行輸出。stderr通過write() 方法實現(xiàn)錯誤的標(biāo)準(zhǔn)輸出。stderr.write() 方法的基本用法如下：

sys.stderr.write(obj)

參數(shù)說明：

• obj：表示輸出的錯誤信息。

分別使用stderr.write() 方法和stdout.write() 方法在控制臺中輸出標(biāo)準(zhǔn)錯誤提示和正確的信息，對它們進(jìn)行比較，代碼如下：

import sys

sys.stderr.write(‘錯誤提示\n’)

sys.stdout.write(‘正確信息')

35. stdin屬性——標(biāo)準(zhǔn)輸入對象

stdin 屬性表示Python 解釋器的標(biāo)準(zhǔn)輸入對象，它可用于所有交互式輸入，包括調(diào)用input() 方法。語法格式如下：

sys.stdin[=value]

參數(shù)說明：

• value：可選參數(shù)，表示可以為stdin設(shè)置特定的標(biāo)準(zhǔn)輸入對象。

獲取標(biāo)準(zhǔn)輸入流中輸入的內(nèi)容并打印輸出。在標(biāo)準(zhǔn)輸入流中獲取輸入內(nèi)容時，需要使用sys.stdin.readline() 方法，代碼如下：

import sys

sys.stdout.write(‘請輸入字符串：')   	# 提示用戶輸入字符串

str=sys.stdin.readline()          		# 記錄用戶輸入

sys.stdout.write(str)             		# 輸出字符串

36. stdin.read()方法——獲取輸入的前n個字符

stdin 是sys 模塊中的標(biāo)準(zhǔn)輸入流，其stdin.read() 方法用來獲取標(biāo)準(zhǔn)輸入流中的前n 個字符。語法格式如下：

sys.stdin.read(n)

參數(shù)說明：

• n ：表示要獲取的字符數(shù)。

• 返回值：返回獲取到的字符。

stdin.read() 方法可以從標(biāo)準(zhǔn)輸入流中獲取參數(shù)指定的前n 個字符。下面是一些常用的獲取內(nèi)容，可以獲取中文、英文、數(shù)字或者各種混合字符串的前5 個字符，代碼如下：

import sys

sys.stdout.write(‘用戶輸入：')

str=sys.stdin.read(5) 			# 讀取輸入的前5個字符

sys.stdout.write(str) 			# 輸出字符串

37. stdin.readline()方法——標(biāo)準(zhǔn)輸入流輸入

stdin 是sys 模塊中的標(biāo)準(zhǔn)輸入流，可以讀取用戶的輸入。stdin 通過readline() 方法實現(xiàn)數(shù)據(jù)的標(biāo)準(zhǔn)輸入。stdout.readline() 方法的語法格式如下：

sys.stdout.readline()

參數(shù)說明：

• 返回值：返回輸入的內(nèi)容。

事實上，使用input() 方法進(jìn)行輸入時，其實是將內(nèi)容傳遞給stdin 標(biāo)準(zhǔn)輸入流，然后通過stdout.readline() 方法進(jìn)行輸入；但使用stdin.readline( ) 會將標(biāo)準(zhǔn)輸入全部獲取，包括末尾的“\n”。因此如果想只獲取輸入內(nèi)容，而不包括最后的換行符“\n”，應(yīng)該使用如下代碼：

import sys 						# 調(diào)用sys模塊

sys.stdin.readline()[:-1]

stdout.write() 方法可以直接進(jìn)行輸出，配合轉(zhuǎn)義字符可以進(jìn)行換行、對齊等操作，但在使用前一定先導(dǎo)入sys 模塊。下面舉例列出一些常規(guī)的輸出，代碼如下：

import sys

sys.stdout.write(‘請輸入字符串：')          	# 提示用戶輸入字符串
str=sys.stdin.readline()                 	# 記錄用戶輸入
sys.stdout.write(str)                    	# 輸出字符串
sys.stdout.write(‘請輸入數(shù)字：')            	# 提示用戶輸入數(shù)字
str=sys.stdin.readline()                 	# 記錄用戶輸入
sys.stdout.write(str)                    	# 輸出數(shù)字
sys.stdout.write(‘請輸入字母：')            	# 提示用戶輸入字母
str=sys.stdin.readline()                 	# 記錄用戶輸入
sys.stdout.write(str)                    	# 輸出字母
sys.stdout.write(‘請輸入混合字符串：')       	# 提示用戶輸入混合字符串
str=sys.stdin.readline()                 	# 記錄用戶輸入
sys.stdout.write(str)                    	# 輸出混合字符串

輸入數(shù)據(jù)時，有時可能輸入了空格等非法字符，可以使用strip()、lstrip()、rstrip() 等方法去除空格，代碼如下：

import sys

sys.stdout.write(‘請輸入您的姓名：')     		# 提示用戶輸入字符串

name =sys.stdin.readline().strip(‘ ‘)

sys.stdout.write(‘請輸入您的年齡：')     		# 提示用戶輸入字符串

age =sys.stdin.readline().lstrip(‘ ‘)

sys.stdout.write(name)                		# 輸出字符串

sys.stdout.write(age)                		# 輸出字符串

程序運行結(jié)果如下：

請輸入您的姓名：小 王 子

請輸入您的年齡： 10

小王子

10

input() 支持多個參數(shù)數(shù)據(jù)輸入，輸入的時候通常用split() 函數(shù)進(jìn)行分割。如同時輸入某一地點的坐標(biāo)值，代碼如下：

import sys

sys.stdout.write(‘請輸入出發(fā)地點的橫、縱坐標(biāo)值:’)        		# 提示用戶輸入字符串

x,y=sys.stdin.readline().split(‘,’)                   		# 一行輸入兩個不限定類型的值

sys.stdout.write(‘請輸入你的姓名、年齡和身高：\n’)        		# 提示用戶輸入字符串

name,age,height=sys.stdin.readline().split(‘,’)        		# 一行輸入3個不限定類型的值

a,b=map(int,sys.stdin.readline().split())             		# 一行輸入兩個限定類型為int的值

print(x,y)

print(age)

print(a,b)

程序運行結(jié)果如下：

請輸入出發(fā)地點的橫、縱坐標(biāo)值:123,210

請輸入你的姓名、年齡和身高：

mike,15,1.75

27 89

123 210

15

27 89

通過循環(huán)語句也可以實現(xiàn)多數(shù)據(jù)輸入，也需要使用split() 函數(shù)對輸入的數(shù)據(jù)進(jìn)行分割，代碼如下：

import sys

sum = 0

sys.stdout.write(‘請輸入多位加數(shù)，中間用空格分開：') 			# 提示用戶輸入

for x in sys.stdin.readline().split(' '):

sum = sum+int(x)

print(sum)

程序運行結(jié)果如下：

請輸入多位加數(shù)，中間用空格分開：1 2 3 4 5 6 7 8

36

有時候輸入的數(shù)據(jù)需要強(qiáng)制轉(zhuǎn)化，如輸入后轉(zhuǎn)成整型、字符型、日期型等。下面用強(qiáng)制轉(zhuǎn)數(shù)字int（integer）修改輸出文字類型，代碼如下：

import sys

sys.stdout.write(‘a(chǎn)ge：') 				# 提示用戶輸入

age = int(sys.stdin.readline())

程序運行結(jié)果如下：

age：20

強(qiáng)制轉(zhuǎn)換字符串時，可以使用lower()、upper()、capitalize()、title() 等方法強(qiáng)制轉(zhuǎn)換字符串為小寫、大寫、句子大寫、單詞大寫等形式，代碼如下：

import sys

sys.stdout.write(‘請輸入您的密碼：')

password = sys.stdin.readline().upper()

sys.stdout.write(‘請輸入您的姓名：')

name = sys.stdin.readline().capitalize()

sys.stdout.write(‘請輸入您的學(xué)校：')

school = sys.stdin.readline().title()

print(password,name,school)

程序運行結(jié)果如下：

請輸入您的密碼：abcdefg

請輸入您的姓名：Mike

請輸入您的學(xué)校：harvard

ABCDEFG Mike Harvard

在Python 中，提供了對字符串操作非常有用的驗證方法，可以非常方便地判斷輸入文字是大寫字母、小寫字母、數(shù)字，或是空白。主要方法如下：

• str.isalnum()：所有字符都是數(shù)字或者字母。

• str.isalpha()：所有字符都是字母。

• str.isdigit()：所有字符都是數(shù)字。

• str.islower() ：所有字符都是小寫。

• str.isupper() ：所有字符都是大寫。

• str.istitle()：所有單詞都是首字母大寫，像標(biāo)題。

• str.isspace() ：所有字符都是空白字符、\t、\n、\r。

使用str.isdigit() 可以驗證輸入是否為數(shù)字，例如，需要輸入為純數(shù)字方可進(jìn)入系統(tǒng)，否則退出系統(tǒng)重新進(jìn)入，代碼如下：

import sys

sys.stdout.write(‘請輸入數(shù)字驗證碼：')

if sys.stdin.readline()[:-1].isdigit():

print(‘正在登錄程序員之家商務(wù)系統(tǒng)！')

else:

print(‘輸入了非數(shù)字字符，請重新輸入！')

在編寫程序時，有時需要動態(tài)輸出一些提示性文字，如程序加載、聯(lián)網(wǎng)或殺毒時，如果需要用戶等待一點時間，可以輸出提示用戶并顯示進(jìn)度。下面代碼將實現(xiàn)在提示文字后動態(tài)輸出程序加載進(jìn)度的功能。

import sys

sys.stdout.write(‘請輸入字符串：')                     		# 提示用戶輸入字符串

str1=sys.stdin.readline()                           		# 記錄用戶輸入

str2=input()

sys.stdout.write(‘str1長度：'+str(len(str1))+’\n’)       	# 輸出字符串長度

sys.stdout.write(‘str2長度：'+str(len(str2)))          		# 輸出字符串長度

程序運行結(jié)果如下：

請輸入字符串：我和我的祖國

我和我的祖國

str1長度：7

str2長度：6

說明：從上文的運行結(jié)果中可以看出，兩個字符串輸入的內(nèi)容雖然一樣，但獲取的長度卻不一樣。這是因為，stdin.readline( ) 會將標(biāo)準(zhǔn)輸入全部獲取，包括末尾的“\n”，因此用len 計算長度時，是把換行符“\n”算進(jìn)去了；但是input( ) 獲取輸入時，返回的結(jié)果是不包含末尾的換行符“\n”的。

38. stdout屬性——標(biāo)準(zhǔn)輸出對象

stdout 屬性表示Python 解釋器的標(biāo)準(zhǔn)輸出對象。語法格式如下：

sys.stdout[=value]

參數(shù)說明：

• value：可選參數(shù)，表示可以為stdout設(shè)置特定的標(biāo)準(zhǔn)輸出對象。

注意:要從標(biāo)準(zhǔn)流讀取二進(jìn)制數(shù)據(jù)，或者向標(biāo)準(zhǔn)流寫入二進(jìn)制數(shù)據(jù)，請使用二進(jìn)制buffer對象。例如，要使用stdout寫入字節(jié)，請使用“sys.stdout.buffer.write(b’abc’)”代碼。

手動改變stdout 輸出形式，將提示信息寫入log.txt 日志文件中，代碼如下：

import sys

saveout = sys.stdout                            	# 在重定向前保存stdout


# 打開一個新文件用于寫入。如果文件不存在，將會被創(chuàng)建。如果文件存在，將被覆蓋

info = open(‘log.txt’, ‘w’)

sys.stdout = info                               	# 所有后續(xù)的輸出都會被重定向到剛才打開的新文件上

print(‘change stdout’)                           	# 將輸出結(jié)果“打印”到日志文件中，屏幕上不會看到輸出

sys.stdout = saveout                            	# 重置stdout

info.close()                                   		# 關(guān)閉日志文件

39. stdout.write()方法——標(biāo)準(zhǔn)輸出流輸出

stdout 是sys 模塊中的標(biāo)準(zhǔn)輸出流，可以實現(xiàn)將數(shù)據(jù)向屏幕、文件等進(jìn)行輸出。stdout 通過write() 方法實現(xiàn)數(shù)據(jù)的標(biāo)準(zhǔn)輸出。語法格式如下：

sys.stdout.write(obj)

參數(shù)說明：

• obj：表示輸出的內(nèi)容或文件。

事實上，使用print() 方法進(jìn)行打印輸出時，其實是將內(nèi)容傳遞給stdout 標(biāo)準(zhǔn)輸出流，然后通過stdout.write() 方法進(jìn)行輸出，輸出完光標(biāo)會停留在輸出內(nèi)容的最后位置；而print() 方法輸出后，光標(biāo)會自動跳到下一行行首。所以要實現(xiàn)等同效果，需要在stdout.write() 輸出時追加一個換行符，代碼如下：

print('hello')

等同于：

import sys         # 調(diào)用sys模塊

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

stdout.write() 方法可以直接進(jìn)行輸出，配合轉(zhuǎn)義字符可以進(jìn)行換行、對齊等操作，但在使用前一定先導(dǎo)入sys 模塊。下面舉例列出一些常規(guī)的輸出，代碼如下：

import sys                       		# 調(diào)用sys模塊

sys.stdout.write(‘用戶名稱：')       		# 正常輸出，光標(biāo)在最后一個字符后面

sys.stdout.write(‘張三豐')          		# 在上一個光標(biāo)處輸出

sys.stdout.write(‘\n用戶密碼：')     		# 先換行輸出，光標(biāo)在最后一個字符后面

sys.stdout.write(‘********\n’)      	# 在上一個光標(biāo)處輸出，輸出完內(nèi)容后換行到下一行行首

sys.stdout.write(‘確認(rèn)密碼：')

sys.stdout.write(‘********\n’)      	# 輸出完內(nèi)容后換行到下一行行首

sys.stdout.write(‘商品名稱\t’)      		# 輸出完內(nèi)容后增加一個制表符距離

sys.stdout.write(‘商品價格\t’)      		# 輸出完內(nèi)容后增加一個制表符距離

sys.stdout.write(‘采購數(shù)量\t’)      		# 輸出完內(nèi)容后增加一個制表符距離

sys.stdout.write(‘商品金額')

程序運行結(jié)果如下：

用戶名稱：張三豐

用戶密碼：********

確認(rèn)密碼：********

商品名稱 商品價格 采購數(shù)量 商品金額

在編寫程序時，有時需要動態(tài)輸出一些提示性文字。如程序加載、聯(lián)網(wǎng)或殺毒時，如果需要用戶等待一點時間，可以輸出提示信息并顯示進(jìn)度。如要實現(xiàn)在提示文字輸出后再動態(tài)輸出程序加載進(jìn)度，代碼如下：

import sys

import time

sys.stdout.write(‘程序正在連接網(wǎng)絡(luò)，請稍后')

sys.stdout.write(“\n”)

for i in range(20):

sys.stdout.write('#')

time.sleep(0.3)

如果動態(tài)輸出的文字希望在原始位置跑馬燈似的循環(huán)輸出，需要將開始文字先定位到行首，然后再輸出并刷新。轉(zhuǎn)義字符“\r”可以使光標(biāo)回到行首，代碼如下：

sys.stdout.write("\r")

使用stdout 不但可以將內(nèi)容輸出到屏幕，還可以輸出到文件，代碼如下：

import sys            				# 調(diào)入系統(tǒng)模塊

sys.stdout=open('mingri.txt','w')

sys.stdout.write('hello world ')

40. stdout.flush()方法——刷新輸出

在標(biāo)準(zhǔn)輸出流中輸出內(nèi)容時，使用flush() 方法可以刷新輸出。語法格式如下：

sys.stdout.flush()

實現(xiàn)動態(tài)跑馬燈輸出效果，每次循環(huán)輸出1 到6 個狀態(tài)，往復(fù)進(jìn)行，代碼如下：

import sys 								# 調(diào)用sys模塊

import time

sys.stdout.write(‘動態(tài)輸出跑馬燈文字\n’)

for i in range(20):

for j in range(6):

sys.stdout.write('.')

sys.stdout.flush()

time.sleep(0.3)

在某些程序開發(fā)中，經(jīng)常需要在某位置動態(tài)重復(fù)輸出一些內(nèi)容，如殺毒軟件、計數(shù)程序、倒計時程序等。輸出殺毒軟件殺毒時提示用戶殺毒時間的動態(tài)模擬顯示，代碼如下：

import sys     					# 調(diào)用sys模塊

import time

sys.stdout.write(‘殺毒程序正在全盤檢查，請稍后\n’)

for i in range(20):

sys.stdout.write("\r")

if i%2==1 :

sys.stdout.write("\\")

else:

sys.stdout.write("/")

sys.stdout.flush()

time.sleep(0.3)

41. __stderr__屬性——獲取stderr值的文件對象

在Python 解釋器啟動時，使用__stderr__ 屬性獲取包含stderr 值的文件對象，主要用于將實際文件還原到已知的工作文件對象，以防被破壞。但是，執(zhí)行此操作的首選方法是在替換之前顯式保存先前的流，并還原已保存的對象。語法格式如下：

sys.__stderr__

注意:在某些情況下，stderr 以及原始值__stderr__ 可以為None。例如，那些沒有連接到控制臺的Windows GUI 應(yīng)用程序以及使用pythonw 啟動的Python 應(yīng)用程序。

獲取__stderr__ 屬性的原始對象信息并輸出，代碼如下：

import sys

print(sys.__stderr__)

42. __stdin__屬性——獲取stdin值的文件對象

在Python 解釋器啟動時，使用__stdin__ 屬性獲取包含stdin 值的文件對象，主要用于將實際文件還原到已知的工作文件對象，以防被破壞。但是，執(zhí)行此操作的首選方法是在替換之前顯式保存先前的流，并還原已保存的對象。語法格式如下：

sys.__stdin__

注意:在某些情況下，stdin 以及原始值__stdin__ 可以為None。例如，那些沒有連接到控制臺的Windows GUI 應(yīng)用程序以及使用pythonw 啟動的Python 應(yīng)用程序。

獲取__stdin__ 屬性的原始對象信息并輸出，代碼如下：

import sys

print(sys.__stdin__)

43. __stdout__屬性——獲取stdout值的文件對象

在Python 解釋器啟動時，使用__stdout__ 屬性獲取包含stdout 值的文件對象，主要用于將實際文件還原到已知的工作文件對象，以防被破壞。但是，執(zhí)行此操作的首選方法是在替換之前顯式保存先前的流，并還原已保存的對象。語法格式如下：

sys.__stdout__

注意:在某些情況下，stdout 以及原始值__stdout__ 可以為None。例如，那些沒有連接到控制臺的Windows GUI 應(yīng)用程序以及使用pythonw 啟動的Python 應(yīng)用程序。

獲取__stdout__ 屬性的原始對象信息并輸出，代碼如下：

import sys

print(sys.__stdout__)

44. thread_info屬性——包含有關(guān)線程實現(xiàn)信息的結(jié)構(gòu)序列

thread_info 屬性表示包含有關(guān)線程實現(xiàn)信息的結(jié)構(gòu)序列。語法格式如下：

sys.thread_info

thread_info 屬性中的屬性及說明如表

獲取當(dāng)前線程的相關(guān)信息并輸出，代碼如下：

import sys

print(sys.thread_info)

45. tracebacklimit屬性——發(fā)生未處理異常時打印的最大回溯信息級別數(shù)

tracebacklimit 屬性用來獲取發(fā)生未處理異常時打印的最大回溯信息級別數(shù)。當(dāng)其值設(shè)置為整數(shù)值時，表示發(fā)生未處理的異常時打印的最大回溯信息級別數(shù)，默認(rèn)為1000 ；當(dāng)設(shè)置為0 或更小時，將禁止所有回溯信息，并僅打印異常類型和值。語法格式如下：

sys.tracebacklimit=value

設(shè)置發(fā)生未處理異常時，打印的最大回溯信息級別數(shù)為100，并輸出該值，代碼如下：

import sys

sys.tracebacklimit=100 				# 設(shè)置最大遞歸（回溯）層級為100級

print(sys.tracebacklimit) 			# 打印遞歸（回溯）層級

46. version屬性——Python解釋器的版本號等信息

version 屬性返回一個包含Python 解釋器的版本號、內(nèi)部版本號和編譯器的附加信息的字符串。語法格式如下：

sys.version

說明:不要從version 屬性獲取的值中提取版本信息，而應(yīng)該使用version_info。

使用version 屬性獲取Python 解釋器的版本號等信息并輸出，代碼如下：

import sys

print(sys.version)

程序運行結(jié)果如下：

3.7.1 (v3.7.1:260ec2c36a, Oct 20 2018, 14:57:15) [MSC v.1915 64 bit (AMD64)]

47. api_version屬性——Python解釋器的C API版本號

api_version 屬性返回Python 解釋器的C API 版本號，語法格式如下：

sys.api_version

說明:api_version 屬性主要用于調(diào)試Python 和擴(kuò)展模塊之間的版本沖突。

使用api_version 屬性獲取本機(jī)安裝的Python 解釋器的C 語言版的API 版本號并輸出，代碼如下：

import sys

print(sys.api_version)

48. version_info屬性——包含Python版本信息5個組件的元組

version_info 屬性用于返回一個包含Python 版本信息的元組，這個元組包含了版本信息的5 個值。語法格式如下：

sys.version_info

使用version_info 屬性得到的版本信息元組中的5 個值分別為：

• major ：一個整數(shù)，表示主版本號。

• minor ：一個整數(shù)，表示次版本號。

• micro ：一個整數(shù)，表示生成號。

• releaselevel ：版本級別，返回值為alpha（內(nèi)測版）、beta（公測版）、candidate（候選版）、final（最版）。

• serial ：一個整數(shù)，表示修訂號。

獲取并輸出Python 解釋器的版本信息，代碼如下：

import sys

print(sys.version_info)

49. warnoptions屬性——警告框架的實現(xiàn)細(xì)節(jié)

warnoptions 屬性用于獲取使用命令行選項-W 時提供給解釋器的警告選項列表。語法格式如下：

sys.warnoptions

說明:默認(rèn)的警告選項列表為空，即[ ]。

以交互方式啟動Python 解釋器，啟動時使用-W 指定一個警告選項。命令如下：

python -W warning

>>> import sys

>>> sys.warnoptions

輸出運行結(jié)果如下：

['warning']

以交互方式啟動Python 解釋器，啟動時使用-W 指定多個警告選項。命令如下：

python -W warning1,warning2,warning3

>>> import sys

>>> sys.warnoptions

輸出運行結(jié)果如下：

['warning1,warning2,warning3']

50. winver屬性——Windows平臺上形成注冊表項的版本號

winver 屬性用于返回Python 解釋器在Windows 平臺上生成注冊表項的版本號，它作為字符串存

儲在Python DLL 中，該值通常是version 屬性的前3 個字符。語法格式如下：

sys.winver

說明:winver 屬性只能用于Windows 系統(tǒng)中。

使用winver 屬性獲取Python 解釋器在Windows 平臺上生成注冊表項的版本號并打印，代碼如下：

import sys

print(sys.winver)

51. _xoptions屬性——獲取-X命令行選項的字典

_xoptions 屬性用于獲取通過-X 命令行選項傳遞的各種指定參數(shù)標(biāo)志的字典，如果明確指定了選項的值，則選項名稱可以映射到指定的值，否則，映射到True。語法格式如下：

sys._xoptions

以交互方式啟動Python 解釋器，啟動時使用-X 設(shè)置一個命令行選項，名稱為test ；然后使用ys._xoptions 屬性輸出命令行選項test 及其對應(yīng)的默認(rèn)值，命令如下：

python -X test

>>> import sys

>>> sys._xoptions

輸出運行結(jié)果如下：

{'test': True}

以交互方式啟動Python 解釋器，啟動時使用-X 分別指定x 坐標(biāo)和y 坐標(biāo)的值都為1 ；然后使用_xoptions 屬性輸出命令行選項參數(shù)列表，命令如下：

python -X x=1 -X y=1

>>> import sys

>>> sys._xoptions

輸出運行結(jié)果如下：

{'x': '1', 'y': '1'}

52. call_tracing()方法——遞歸調(diào)用/調(diào)試代碼

call_tracing() 方法用于啟用跟蹤時調(diào)用函數(shù)func(*args) 并保存跟蹤狀態(tài)。語法格式如下：

sys.call_tracing(func,args)

參數(shù)說明：

• func ：表示要調(diào)用的方法名。

• args ：方法中要傳遞的參數(shù)，如果有多個參數(shù)，使用元組傳遞。

• 返回值：與要調(diào)用的方法的返回值一致。

定義一個add() 函數(shù)，計算兩個數(shù)的和；然后使用call_tracing() 方法調(diào)用自定義的add() 函數(shù)，并傳入兩個整數(shù)；最后打印結(jié)果，代碼如下：

import sys

def add(a,b):                 		# 定義一個函數(shù)，用來計算兩個數(shù)的和

return a+b                			# 返回值為兩個數(shù)的和

# 使用call_tracing調(diào)用定義的add()函數(shù)，并傳入相應(yīng)的參數(shù)

result = sys.call_tracing(add, (3,4))

print(result)                 		# 打印結(jié)果

53. _clear_type_cache()方法——清除內(nèi)部類型緩存

_clear_type_cache() 方法用于清除內(nèi)部類型緩存，類型緩存用于加速屬性和方法的查找。語法格式如下：

sys._clear_type_cache()

說明:通常情況下，不必要清空緩存；但在一些特殊情況下，比如調(diào)試，可以使用該方法刪除不必要的引用。

使用_clear_type_cache() 方法清除內(nèi)部類型緩存，代碼如下：

import sys

sys._clear_type_cache()

 

說明:_clear_type_cache() 方法是一個性能優(yōu)化方法，因此執(zhí)行時，沒有運行結(jié)果。

54. _current_frames()方法——將線程標(biāo)識符映射到最頂層堆棧

_current_frames() 方法用于返回將每個線程的標(biāo)識符映射到調(diào)用該方法時該線程中當(dāng)前活動的最頂層堆棧幀的字典。語法格式如下：

sys._current_frames()

參數(shù)說明：

• 返回值：返回一個字典，表示當(dāng)前線程標(biāo)識符的最頂層堆棧幀信息。

說明:_current_frames() 方法對于調(diào)試死鎖非常有用：此函數(shù)不需要死鎖線程的協(xié)作，只要這些線程的調(diào)用堆棧保持死鎖，它們就會被凍結(jié)；對于非死鎖線程返回的幀，在調(diào)用代碼檢查幀時可能與該線程的當(dāng)前活動沒有關(guān)系。

使用_current_frames() 方法獲取當(dāng)前線程標(biāo)識符的最頂層堆棧幀信息，代碼如下：

import sys

print(sys._current_frames())

55. breakpointhook()方法——breakpoint()的鉤子函數(shù)

breakpointhook() 方法是一個鉤子函數(shù)，這個鉤子函數(shù)由內(nèi)置函數(shù)breakpoint() 調(diào)用。默認(rèn)情況下，它會進(jìn)入pdb 調(diào)試器中，但可以將其設(shè)置為任何其他函數(shù)，以便可以選擇使用哪個調(diào)試器。法格式如下：

sys.breakpointhook(*args, **kws)

參數(shù)說明：

• args ：可變參數(shù)，它是一個元組，允許傳入0 個或者任意一個參數(shù)。

• kws：關(guān)鍵字參數(shù)，它是一個字典，允許傳入0 個或者任意一個含參數(shù)名的參數(shù)。

• 返回值：根據(jù)PYTHONBREAKPOINT 環(huán)境變量的值而定，具體說明如下：
  breakpointhook() 作為breakpoint() 的鉤子函數(shù)，是真正實現(xiàn)具體功能的地方。它會訪問環(huán)境變量
  PYTHONBREAKPOINT，從而確定hook 的引用對象，也就是說，PYTHONBREAKPOINT 的狀態(tài)對 執(zhí)行結(jié)果有決定性的作用。具體而言，PYTHONBREAKPOINT 存在如下幾種狀態(tài)：
  ? 完全不設(shè)置該環(huán)境變量：此時，hook 會引用pdb.set_trace，所以最終會進(jìn)入pdb 調(diào)試器（提示：由于pdb.set_trace(*,header=None) 只接受關(guān)鍵字參數(shù)header，因此不要向breakpoint() 傳遞任何其他參數(shù)）。PYTHONBREAKPOINT= ：此時，環(huán)境變量的值為空字符串，這與完全不設(shè)置該環(huán)境變量的效果相同。
  ? PYTHONBREAKPOINT=0 ：此時，breakpointhook() 會立即返回None，從而禁用調(diào)試。
  ? PYTHONBREAKPOINT=some.importable.callable ： 此時，breakpointhook() 將導(dǎo)入some.importable模塊，然后通過hook 引用模塊中的callable 對象。
  ? PYTHONBREAKPOINT=callable ：此時，callable 表示一個內(nèi)置可調(diào)用對象，PYTHONBREAKPOINT=print。

每次調(diào)用breakpointhook() 時，都會訪問PYTHONBREAKPOINT 變量。如果在程序執(zhí)行期間改變了PYTHONBREAKPOINT 的值，breakpointhook() 便會讀取變化后的值。例如：

os.environ[‘PYTHONBREAKPOINT’] = ‘foo.bar.baz’

breakpoint() 									# 導(dǎo)入foo.bar并且自動調(diào)用foo.bar.baz()

注意:如果使用-E 命令行選項啟動Python 解釋器，會忽略所有PYTHON*環(huán)境變量（包括PYTHONBREAKPOINT），這意味著breakpoint() 會遵守默認(rèn)行為，即中斷當(dāng)前程序并進(jìn)入pdb 調(diào)試器。

說明:breakpointhook() 方法是Python 3.7 版本中新增的功能。

Python 官方給出的breakpointhook() 方法的原始實現(xiàn)代碼如下：

def breakpointhook(*args, **kws):

	import importlib, os, warnings

	hookname = os.getenv('PYTHONBREAKPOINT')

	if hookname is None or len(hookname) == 0:

		hookname = 'pdb.set_trace'

	elif hookname == '0':

		return None

	modname, dot, funcname = hookname.rpartition('.')

	if dot == ‘‘:

		modname = ‘builtins’

	try:

		# 模塊導(dǎo)入失敗，或funcname不可調(diào)用都會引發(fā)RuntimeWarning

		module = importlib.import_module(modname)

		hook = getattr(module, funcname)

	except:

		# 如果拋出異常，則不會執(zhí)行hook(*args, **kws)
		warnings.warn(‘Ignoring unimportable $PYTHONBREAKPOINT: {}’.format(hookname),RuntimeWarning)
		# 如果實參與函數(shù)簽名中的參數(shù)不匹配，則會拋出TypeError
		return hook(*args, **kws)


__breakpointhook__ = breakpointhook
import sys
print(sys.breakpointhook())

56. _debugmallocstats()方法——打印關(guān)于 CPython內(nèi)存分配器狀態(tài)的低級信息

_debugmallocstats() 方法用于向stderr 打印關(guān)于CPython 內(nèi)存分配器狀態(tài)的低級信息。如果Python配置為-with-pydebug，它還會執(zhí)行一些內(nèi)部一致性檢查。語法格式如下：

sys._debugmallocstats()

參數(shù)說明：

• 返回值：返回一個字符串，記錄了關(guān)于CPython內(nèi)存分配器狀態(tài)的低級信息。

說明:_debugmallocstats() 方法特定于CPython，并且是在Python 3.3 中新增的方法，因此只能用于Python 3.3 及以上版本。

使用_debugmallocstats() 方法獲取CPython 內(nèi)存分配器狀態(tài)的低級信息，并使用print() 函數(shù)打印，代碼如下：

import sys

print(sys._debugmallocstats())

57. displayhook()方法——打印表達(dá)式結(jié)果

displayhook() 方法用于打印表達(dá)式結(jié)果，語法格式如下：

sys.displayhook(value)

參數(shù)說明：

• value：表示要打印的值。

• 返回值：如果值不為None，這個函數(shù)打印repr(value) 到sys.stdout，并將值保存到builtins._中。如果repr(value) 無法編碼為sys.stdout.encoding，使用sys.stdout.errors 錯誤處理程序；如果可以編碼為sys.stdout.encoding，則使用backslashreplace 錯誤處理程序。

說明:Python 官方給出的displayhook() 方法的原始實現(xiàn)代碼如下：

def displayhook(value):

	if value is None:

		return

	# 將“_”設(shè)置為None，以防止遞歸

	builtins._ = None

	text = repr(value)

	try:

		sys.stdout.write(text)

	except UnicodeEncodeError:

		bytes = text.encode(sys.stdout.encoding, 'backslashreplace')

	if hasattr(sys.stdout, 'buffer'):

		sys.stdout.buffer.write(bytes)

	else:
		text = bytes.decode(sys.stdout.encoding, 'strict')

		sys.stdout.write(text)
		sys.stdout.write("\n")
		builtins._ = value

displayhook() 方法只有一個參數(shù)，但參數(shù)的類型可以任意，即可傳入任意類型的值。例如：

import sys
sys.displayhook(2)            			# 傳入整數(shù)值
sys.displayhook(‘Test’)         		# 傳入字符串
sys.displayhook(True)         			# 傳入bool值
sys.displayhook([‘python’,’c’]) 		# 傳入列表
sys.displayhook((‘python’,’c’)) 		# 傳入元組

程序運行結(jié)果如下：

2

'Test'

True

['python', 'c']

('python', 'c')

說明:上面代碼中并沒有使用print() 函數(shù)打印輸出，但還是可以正常地輸出displayhook() 方法中傳入的參數(shù)值，這說明displayhook() 方法的實現(xiàn)效果就是將參數(shù)打印到標(biāo)準(zhǔn)輸出。

58. excepthook()方法——發(fā)生未捕獲異常時調(diào)用

發(fā)生未捕獲異常時調(diào)用該方法，默認(rèn)行為是打印該異常并回溯到標(biāo)準(zhǔn)錯誤。但是，可以通過為其分配另一個包含三個參數(shù)的函數(shù)來自定義這種頂級異常的excepthook() 方法處理。語法格式如下：

sys.excepthook(type,value,traceback)

參數(shù)說明：

• type：表示異常類。

• value：表示異常實例。

• traceback：表示回溯對象。

• 返回值：返回未捕獲的異常信息。

使用exc_info() 方法捕獲除數(shù)為0 的異常信息，然后使用excepthook() 方法打印異常信息，代碼如下：

import sys

try:

	result = 1/0

except:

	types, value, back = sys.exc_info()       # 捕獲異常

	sys.excepthook(types, value, back)        # 打印異常

59. exec_info()方法——捕獲正在處理的 異常信息

exec_info() 方法用于捕獲正在處理的異常信息，它的返回值是一個包含三個值的元組，這些值提供有關(guān)當(dāng)前正在處理的異常信息，返回的信息僅針對當(dāng)前線程和當(dāng)前堆棧幀。如果當(dāng)前堆棧幀未處理異常，則從調(diào)用堆棧幀或其調(diào)用者那里獲取信息，依此類推，直到找到正在處理異常的堆棧幀。這里，“處理異常”被定義為“執(zhí)行except 子句”，對于任何堆棧幀，只能訪問有關(guān)當(dāng)前處理的異常信息。語法格式如下：

sys.exc_info()

參數(shù)說明：

• 返回值：返回一個包含了三個值的元組，存儲正在處理的異常信息。

使用try…except 捕獲除數(shù)為0 的異常，并使用exc_info() 方法輸出異常相關(guān)類、實例及回溯對象，代碼如下：

import sys

try:

	print(1/0)

except:

	print(sys.exc_info()) 				# 捕獲并打印異常相關(guān)信息

60. exit()方法——退出Python

exit() 方法用于退出Python 解釋器，即退出正在運行的程序。語法格式如下：

sys.exit([arg])

參數(shù)說明：

• arg ：可選參數(shù)，該參數(shù)是一個整數(shù)，表示退出狀態(tài)。0 表示正常退出，非0 表示異常終止。如果指定為一個非整數(shù)值，則將它打印到sys.stderr，并使用退出碼1。

• 返回值：返回退出碼，0 表示正常退出，1 表示異常退出。

說明:arg 參數(shù)的取值范圍通常在0~127 范圍內(nèi)，否則會產(chǎn)生不確定的結(jié)果。

正常退出程序的代碼如下：

import sys

sys.exit()

程序運行結(jié)果如下：

Process finished with exit code 0

通過為exit() 方法指定非0 參數(shù)異常終止程序，代碼如下：

import sys

sys.exit(1)

程序運行結(jié)果如下：

Process finished with exit code 1

61. getallocatedblocks分配的內(nèi)存塊數(shù)量

getallocatedblocks() 方法用于返回Python 解釋器當(dāng)前分配的內(nèi)存塊數(shù)量。該功能主要用于跟蹤和調(diào)試內(nèi)存泄漏。如果Python 構(gòu)建或?qū)崿F(xiàn)無法合理地計算此信息，getallocatedblocks() 方法則返回0。語法格式如下：

sys.getallocatedblocks()

參數(shù)說明：

• 返回值：返回當(dāng)前分分配的內(nèi)存塊數(shù)量。

說明:1. 由于Python 解釋器的內(nèi)部緩存等原因，結(jié)果可能會因調(diào)用而不同，這時最好調(diào)用_clear_type_cache() 方法和gc.collect() 方法獲得更為準(zhǔn)確的結(jié)果。2. getallocatedblocks() 方法是Python 3.4 版本中新增加的，因此只能在Python 3.4 及以上版本中才可以使用。

使用getallocatedblocks() 方法獲取Python 解釋器當(dāng)前分配的內(nèi)存塊數(shù)量，并使用print() 方法打印輸出，代碼如下：

import sys

print(sys.getallocatedblocks())

62. getcheckinterval()方法——獲取解釋器的檢查間隔

getcheckinterval() 方法用于返回檢査間隔值（以毫秒為單位）。語法格式如下：

sys.getcheckinterval()

參數(shù)說明：

• 返回值：返回解釋器的檢查間隔值。

說明:從Python 3.2 版本開始，不推薦使用getcheckinterval() 方法，而應(yīng)該使用getswitchinterval() 方法

使用getcheckinterval() 方法獲取Python 解釋器的默認(rèn)檢查間隔，代碼如下：

import sys

print(sys.getcheckinterval()) 			# 打印默認(rèn)檢查間隔

程序運行結(jié)果如下：

100

J:/PythonDemo/Python速查手冊/sysDemo.py:49: DeprecationWarning: sys.getcheckinterval()and sys.setcheckinterval() are deprecated. Use sys.getswitchinterval() instead.print(sys.getcheckinterval()) 			# 打印默認(rèn)檢查間隔

說明:上面的運行結(jié)果中輸出了默認(rèn)檢查間隔為100，但同時下面有個警告，提示getcheckinterval() 方法已經(jīng)過期，推薦使用sys.getswitchinterval()。

63. getdefaultencoding()方法——獲取默認(rèn)字符串編碼名稱

getdefaultencoding() 方法用于返回當(dāng)前默認(rèn)字符串編碼的名稱，語法格式如下：

sys.getdefaultencoding()

參數(shù)說明：

• 返回值：返回類似“ascii”“utf-8”或者“gbk”等的字符串，具體的值根據(jù)site.py 模塊中設(shè)置的默認(rèn)編碼而定。

使用etdefaultencoding() 方法獲取本地Python 解釋器使用的默認(rèn)字符串編碼，代碼如下：

import sys

print(sys.getdefaultencoding())

64. getf?ilesystemencoding()方法——獲取文件系統(tǒng)使用的編碼名稱

getfilesystemencoding() 方法用于返回將Unicode 文件名映射到底層操作系統(tǒng)使用的文件名的編碼名稱，即文件系統(tǒng)使用的編碼名稱。語法格式如下：

sys.getfilesystemencoding()

參數(shù)說明：

• 返回值：有以下4 種情況：
  ? 在UTF-8 模式下，在任何平臺上都是utf-8 編碼。
  ? 在Mac OS X 平臺上，編碼是utf-8。
  ? 在Unix 平臺上，編碼是本地設(shè)置的編碼。
  ? 在Windows 平臺上，編碼可能是utf-8 或mbcs，取決于用戶配置。

說明:為了確保使用正確的編碼和解碼模式，應(yīng)該使用os.fsencode() 和os.fsdecode() 對文件名進(jìn)行編碼和解碼。

使用getfilesystemencoding() 方法獲取本地文件系統(tǒng)的編碼名稱并輸出，代碼如下：

import sys

print(sys.getfilesystemencoding())

65. getf?ilesystemencodeerrors()方法——獲取 文件名轉(zhuǎn)換時的錯誤模式名稱

getfilesystemencodeerrors() 方法用于返回在Unicode 文件名和字節(jié)文件名之間進(jìn)行轉(zhuǎn)換時產(chǎn)生的錯誤模式名稱。語法格式如下：

sys.getfilesystemencodeerrors()

參數(shù)說明：

• 返回值：返回文件名轉(zhuǎn)換時的錯誤模式名稱。

使用getfilesystemencodeerrors() 方法獲取本地Unicode 文件名和字節(jié)文件名之間轉(zhuǎn)換時產(chǎn)生的錯誤模式名稱，并使用print() 輸出，代碼如下：

import sys

print(sys.getfilesystemencodeerrors())

66. getrefcount()方法——獲取對象的引用計數(shù)

getrefcount() 方法用于返回對象的引用計數(shù)。語法格式如下：

sys.getrefcount(object)

參數(shù)說明：

• object：表示任意一個對象。

• 返回值：返回object 的引用計數(shù)。返回的計數(shù)通常比預(yù)期的高一個，因為使用參數(shù)引用時，參數(shù)會引用一次，同時參數(shù)會自動產(chǎn)生一個臨時引用。

定義一個測試類，分別以構(gòu)造函數(shù)直接創(chuàng)建對象的方式和對象的方式向getrefcount() 方法中傳入?yún)?shù)，并分別輸出它們的引用計數(shù)，代碼如下：

import sys

class Test:                      		# 定義一個類

pass

t = Test()                       		# 創(chuàng)建類的對象

print(sys.getrefcount(Test()))     		# Test()作為參數(shù)

print(sys.getrefcount(t))         		# 對象t作為參數(shù)

程序運行結(jié)果如下：

1

2

說明:使用Test() 作為參數(shù)，返回1，因為Test() 不是引用；而使用對象t 作為參數(shù)，t 本身就是引用Test()，但是它又引用了一次Test()，所以輸出為2。

分別向getrefcount() 方法中傳入幾個不同大小的整數(shù)，并輸入它們的引用計數(shù)，比較輸出結(jié)果，代碼如下：

import sys

print(‘參數(shù)為1：',sys.getrefcount(1))

print(‘參數(shù)為256：',sys.getrefcount(256))

print(‘參數(shù)為257：',sys.getrefcount(257))

print(‘參數(shù)為1111111：',sys.getrefcount(1111111))

print(‘參數(shù)為-5439：',sys.getrefcount(-5439))

程序運行結(jié)果如下：

參數(shù)為1： 1587
參數(shù)為256： 75
參數(shù)為257： 3
參數(shù)為1111111： 3
參數(shù)為-5439： 3

說明:在Python 啟動解釋器時，會創(chuàng)建一個小整數(shù)池，-5~256 之間的整數(shù)對象會被自動創(chuàng)建并加載到內(nèi)存中等待調(diào)用，所以會根據(jù)值的不同，輸出不同的計數(shù)；而在此范圍之外的所有整數(shù)作為參數(shù)時，getrefcount() 返回固定值3。

67. getrecursionlimit()方法——獲取遞歸限制的值

getrecursionlimit() 方法返回遞歸限制的當(dāng)前值，即Python 解釋器可遞歸的最大深度。該功能可防止無限遞歸引起堆棧溢出并導(dǎo)致Python 崩潰。語法格式如下：

sys.getrecursionlimit()

參數(shù)說明：

• 返回值：返回一個整數(shù)，表示Python 解釋器可遞歸的最大深度，默認(rèn)為1000，可以使用setrecursionlimit() 方法改變該值。

使用getrecursionlimit() 方法獲取Python 解釋器的默認(rèn)遞歸限制值并輸出，代碼如下：

import sys

print(‘默認(rèn)遞歸次數(shù)：',sys.getrecursionlimit()) 			# 打印默認(rèn)遞歸深度

68. getsizeof()方法——返回對象占用的內(nèi)存大小

getsizeof() 方法用于查看python 對象的內(nèi)存占用，單位為字節(jié)（byte）。語法格式如下：

sys.getsizeof(object[,default])

參數(shù)說明：

• object：表示要檢測的對象。

• default：可選參數(shù)。若指定了該參數(shù)，如果對象未提供檢索大小的方法，則返回default，否則拋出TypeError 異常。

• 返回值：返回對象占用的內(nèi)存大小。

使用getsizeof() 方法獲取不同類型對象所占用的內(nèi)存大小，代碼如下：

import sys

print(‘列表：',sys.getsizeof([]))

print(‘元組：',sys.getsizeof(()))

print(‘字典：',sys.getsizeof({}))

print(‘字符串：',sys.getsizeof(‘‘))

print(‘字節(jié)：',sys.getsizeof(b’bytes’))

print(‘整數(shù)：',sys.getsizeof(1))

print(‘小數(shù)：',sys.getsizeof(3.14))

程序運行結(jié)果如下：

列表： 64
元組： 48
字典： 240
字符串： 49
字節(jié)： 38
整數(shù)： 28
小數(shù)： 24

說明:getsizeof() 方法實際上是調(diào)用了__sizeof__() 方法。例如，獲取字符串占用的內(nèi)存大小可以使用下面代碼：print(‘’.__sizeof__())

69. getswitchinterval()方法——獲取線程切換間隔

getswitchinterval() 方法用于返回Python 解釋器的線程切換間隔，單位為秒。語法格式如下：

sys.getswitchinterval()

參數(shù)說明：

• 返回值：返回以秒為單位表示的線程的切換間隔。

說明:在Python 3.2 及以上的版本中，使用getswitchinterval() 方法代替了原來的getcheckinterval() 方法。

使用getswitchinterval() 方法獲取Python 解釋器默認(rèn)的線程切換間隔，代碼如下：

import sys

print(sys.getswitchinterval()) 				# 打印默認(rèn)線程間隔

70. _getframe()方法——返回一個框架對象

_getframe() 方法用于從調(diào)用堆棧返回一個框架對象。語法格式如下：

sys._getframe([depth])

參數(shù)說明：

• depth：可選參數(shù)。如果省略depth 或depth 為0，返回頂層幀；否則，返回堆棧頂部下方多次調(diào)用的框架對象。如果它比調(diào)用堆棧更深，則引發(fā)ValueError 異常。depth 的默認(rèn)值為零，表示返回調(diào)用堆棧頂部的框架。

• 返回值：返回框架對象。

說明:_getframe([depth]) 方法僅用于內(nèi)部和專用目的，并不保證在Python 的所有實現(xiàn)中都存在。

為_getframe() 方法傳入?yún)?shù)0，以獲取調(diào)用堆棧頂部的框架對象，代碼如下：

import sys

print(sys._getframe(0))

71. getprof?ile()方法——獲取探查器函數(shù)

getprofile() 方法用于獲取由setprofile() 方法設(shè)置的探查器函數(shù)。語法格式如下：

sys.getprofile()

參數(shù)說明：

• 返回值：返回設(shè)置的探查器函數(shù)。

首先獲取默認(rèn)的探查器函數(shù)，然后使用setprofile() 函數(shù)設(shè)置一個自定義的探查器函數(shù)，最后使用getprofile() 獲取設(shè)置之后的探查器函數(shù)，代碼如下：

import sys

# 定義一個函數(shù)，用來作為探查器函數(shù)，必須定義三個參數(shù)

def Test(frame,event,arg):
	caller=frame.f_back                  		# 獲取當(dāng)前堆棧
	print(‘call’,caller)                   		# 返回調(diào)用的堆棧信息

def testA():                            		# 測試輸出
	print('testA')

def testB():                            		# 測試輸出
	print(‘testB’)

testA()                             			# 調(diào)用testA()
print(‘默認(rèn)探查器函數(shù)：', sys.getprofile()) 		# 獲取默認(rèn)探查器函數(shù)
sys.setprofile(Test)                     		# 設(shè)置探查器函數(shù)
testB()                                			# 調(diào)用testB()
print(‘設(shè)置的探查器函數(shù)：',sys.getprofile()) 		# 獲取設(shè)置的探查器函數(shù)

72. gettrace()方法——獲取設(shè)置的跟蹤函數(shù)

gettrace() 方法用于獲取由settrace() 方法設(shè)置的跟蹤函數(shù)。語法格式如下：

sys.gettrace()

參數(shù)說明：

• 返回值：返回設(shè)置的跟蹤函數(shù)。

說明:gettrace() 方法僅用于實現(xiàn)調(diào)試器、分析器、覆蓋工具等，它是實現(xiàn)平臺的一部分，而不是語言定義的一部分，因此，該方法并非在所有Python 實現(xiàn)中都可用。

首先獲取默認(rèn)的跟蹤函數(shù)，然后使用settrace() 函數(shù)設(shè)置一個自定義的跟蹤函數(shù)，最后使用gettrace() 獲取設(shè)置之后的跟蹤函數(shù)，代碼如下：

import sys


# 定義一個函數(shù)，用來作為跟蹤函數(shù)，必須定義3個參數(shù)
def Test(frame,event,arg):
	caller=frame.f_back                  	# 獲取當(dāng)前堆棧
	print(‘call’,caller)                  	# 返回調(diào)用的堆棧信息

def testA():                            	# 測試輸出
	print('testA')

def testB():                            	# 測試輸出
	print(‘testB’)

testA()                             		# 調(diào)用testA()
print(‘默認(rèn)跟蹤函數(shù)：', sys.gettrace())      	# 獲取默認(rèn)跟蹤函數(shù)
sys.settrace(Test)                       	# 設(shè)置跟蹤函數(shù)
testB()                                		# 調(diào)用testB()
print(‘設(shè)置的跟蹤函數(shù)：',sys.gettrace())     	# 獲取設(shè)置的跟蹤函數(shù)

73. getwindowsversion()方法——獲取Windows版本信息

getwindowsversion() 方法用于返回一個描述當(dāng)前正在運行的Windows 版本的元組，該元組包括五個元素，分別是major、minor、build、platform 和text。其中，major 是主版本號；minor 是次版本號；build 是Windows 編譯號；platform 是平臺標(biāo)識，值可以為0（表示W(wǎng)indow 3.1 上的Win32）、1（表示W(wǎng)indows 95、98 或Me）、2（表示W(wǎng)indows NT，如Window XP、Windows 10 等）；text 是Windows的SP 補(bǔ)丁信息。語法格式如下：

sys.getwindowsversion()

參數(shù)說明：

• 返回值：返回Windows 的版本信息。

說明:getwindowsversion() 方法只能在Windows 操作系統(tǒng)中使用。

使用getwindowsversion() 方法獲取當(dāng)前的Windows 版本信息，并輸出到屏幕中，代碼如下：

import sys

print(sys.getwindowsversion())

程序運行結(jié)果如下：

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

使用getwindowsversion() 方法獲取當(dāng)前的Windows 版本信息，并分別輸出到屏幕中，代碼如下：

import sys

# 檢測Windows版本號

__MAJOR, __MINOR, __MICRO = sys.getwindowsversion()[0], sys.getwindowsversion()[1],sys.getwindowsversion()[2]

print(‘Windows主版本號:’ + str(__MAJOR))

print(‘Windows次版本號:’ + str(__MINOR))

print(‘Windows編譯號:’ + str(__MICRO))

74. get_asyncgen_hooks()方法——返回 asyncgen_hooks對象

get_asyncgen_hooks() 方法用于返回一個asyncgen_hooks 對象，它類似于一個命名元組（firstiter，finalizer），其中，firstiter 和finalizer 應(yīng)該是None，或者采用異步迭代器作為參數(shù)的函數(shù)。語法格式如下：

sys.get_asyncgen_hooks()

參數(shù)說明：

• 返回值：返回asyncgen_hooks對象。

說明:get_asyncgen_hooks() 方法是Python 3.6 版本中新增的功能，因此只能在Python 3.6 及以上版本中使用。

使用get_asyncgen_hooks() 方法獲取asyncgen_hooks 對象默認(rèn)值并輸出，代碼如下：

import sys

print(sys.get_asyncgen_hooks())

75. get_coroutine_origin_tracking_depth()方法 ——獲取當(dāng)前的協(xié)程源跟蹤深度

get_coroutine_origin_tracking_depth() 方法用于獲取當(dāng)前的協(xié)程源跟蹤深度。語法格式如下：

sys.get_coroutine_origin_tracking_depth()

參數(shù)說明：

• 返回值：返回當(dāng)前的協(xié)程源跟蹤深度。

說明:get_coroutine_origin_tracking_depth() 方法是Python 3.7 版本中新增的功能，因此只能在Python 3.7及以上版本中使用。

先獲取當(dāng)前的協(xié)程源跟蹤深度，然后使用set_coroutine_origin_tracking_depth() 設(shè)置該值，設(shè)置完成后再次獲取，進(jìn)行比較，代碼如下：

import sys

print(‘默認(rèn)：',sys.get_coroutine_origin_tracking_depth())

sys.set_coroutine_origin_tracking_depth(10)

print(‘設(shè)置后：',sys.get_coroutine_origin_tracking_depth())

76. get_coroutine_wrapper()方法——返回None或一個包裝器

get_coroutine_wrapper() 方法用于返回None 或由set_coroutine_wrapper() 設(shè)置的包裝器。語法格式如下：

sys.get_coroutine_wrapper()

參數(shù)說明：

• 返回值：返回一個包裝器或None值。

說明:get_coroutine_wrapper() 方法是Python 3.5 版本中新增的功能，但從Python 3.7 開始不推薦使用，因為協(xié)程包裝器功能已被棄用，而且將在Python 3.8 中刪除，所以了解即可。

首先使用get_coroutine_wrapper() 方法獲取默認(rèn)包裝器，然后設(shè)置一個自定義的包裝器后，再次獲取，比較兩次獲取的結(jié)果，代碼如下：

import sys

print(‘默認(rèn)包裝器',sys.get_coroutine_wrapper())

def wrapper(coro):

	async def wrap(coro): 				# 異步函數(shù)

return await coro 						# 程序掛起

return wrap(coro)

sys.set_coroutine_wrapper(wrapper) 		# 設(shè)置包裝器

print(‘設(shè)置的包裝器',sys.get_coroutine_wrapper())

程序運行結(jié)果如下：

默認(rèn)包裝器 NoneJ:/PythonDemo/Python速查手冊/sysDemo.py:20: DeprecationWarning: get_coroutine_wrapperis deprecated

設(shè)置的包裝器 <function wrapper at 0x0000026AF10ED2F0>print('默認(rèn)包裝器',sys.get_coroutine_wrapper())

J:/PythonDemo/Python速查手冊/sysDemo.py:25: DeprecationWarning: set_coroutine_wrapperis deprecated

sys.set_coroutine_wrapper(wrapper) 			# 設(shè)置包裝器

J:/PythonDemo/Python速查手冊/sysDemo.py:26: DeprecationWarning: get_coroutine_wrapperis deprecated

print('設(shè)置的包裝器',sys.get_coroutine_wrapper())

說明:上面的輸出結(jié)果中，每調(diào)用一次get_coroutine_wrapper() 方法或者set_coroutine_wrapper() 方法，都會提示該方法已經(jīng)過時，所以，這里只需要了解這兩個方法即可，因為在Python 3.8 版本中，這兩個方法就會被徹底刪除。

77. intern()方法——獲取字符串或副本

intern() 方法用于返回字符串本身或副本。該方法的主要作用在于性能優(yōu)化，它會維護(hù)一個內(nèi)部字符串表，這個內(nèi)部字符串表的意義在于：當(dāng)你試圖實現(xiàn)一個字符串時，函數(shù)會優(yōu)先在表中查找它，如果字符串存在，直接返回；如果不存在，intern() 方法會將其保存，并從中返回。語法格式如下：

sys.intern(string)

參數(shù)說明：

• string：表示字符串。

• 返回值：返回字符串本身或副本。

使用intern() 方法獲取字符串的實現(xiàn)代碼如下：

import sys

print(sys.intern('hello'))

78. is_f?inalizing()方法——獲取是否關(guān)閉Python解釋器

is_finalizing() 方法用于獲取是否關(guān)閉Python 解釋器。如果Python 解釋器正在關(guān)閉，返回True，否則返回False。語法格式如下：

sys.is_finalizing()

參數(shù)說明：

• 返回值：返回一個布爾值，True 表示Python解釋器關(guān)閉，F(xiàn)alse表示Python解釋器未關(guān)閉。

說明:is_finalizing() 方法是Python 3.5 版本中新增的功能，因此只能在Python 3.5 及以上版本中使用。

使用is_finalizing() 方法獲取Python 解釋器是否正在關(guān)閉，并使用print() 函數(shù)輸出得到的結(jié)果，代碼如下：

import sys

print(sys.is_finalizing())

79. set_asyncgen_hooks()方法——設(shè)置事件循環(huán)中的 異步生成器終結(jié)器和迭代攔截器

set_asyncgen_hooks() 方法用于設(shè)置事件循環(huán)中的異步生成器終結(jié)器和迭代攔截器，允許事件循環(huán)攔截異步生成器的迭代和終結(jié)，這樣最終用戶就不需要關(guān)心終結(jié)問題，一切都可以正常工作。語法格式如下：

sys.set_asyncgen_hooks(firstiter, finalizer)

參數(shù)說明：

• firstiter：表示一個可調(diào)用函數(shù)，當(dāng)異步生成器第一次迭代時被調(diào)用。

• finalizer：表示一個可調(diào)用函數(shù)，當(dāng)異步生成器即將被垃圾回收時調(diào)用。

說明:set_asyncgen_hooks(firstiter, finalizer) 方法是Python 3.6 版本中新增的功能，因此只能在Python 3.6及以上版本中使用。

使用set_asyncgen_hooks() 方法修改asyncio 異步IO，以便允許異步生成器的安全終結(jié)，代碼如下：

class BaseEventLoop:

def run_forever(self):
	...
	old_agen_hooks = sys.get_asyncgen_hooks()            	# 獲取默認(rèn)的異步生成器函數(shù)
	# 設(shè)置新的異步生成器終結(jié)器和攔截迭代器
	sys.set_asyncgen_hooks(firstiter=self._asyncgen_firstiter_hook,
	finalizer=self._asyncgen_finalizer_hook)
	try:
		...
	finally:
		...
		sys.set_asyncgen_hooks(*old_agen_hooks)           	# 如果出現(xiàn)異常，設(shè)置默認(rèn)的異步生成器

# 定義異步生成器即將被垃圾回收時調(diào)用的函數(shù)
def _asyncgen_finalizer_hook(self, agen):
	self._asyncgens.discard(agen)
	if not self.is_closed():
		self.call_soon_threadsafe(self.create_task, agen.aclose())

# 定義異步生成器第一次迭代時使用的函數(shù)
def _asyncgen_firstiter_hook(self, agen):
	if self._asyncgens_shutdown_called:
		...

說明:上面代碼位于Python 安裝路徑下的Lib\asyncio 文件夾中的base_events.py 文件中。

80. set_coroutine_origin_tracking_depth()方法 ——允許啟用或禁用協(xié)同源跟蹤

set_coroutine_origin_tracking_depth() 方法用于允許啟用或禁用協(xié)同源跟蹤。啟用時，coroutine_origin對象上的屬性將包含(filename,line number,function name) 元組，這個元組描述創(chuàng)建協(xié)同程序?qū)ο蟮幕厮?，最先調(diào)用最近的調(diào)用；禁用時，coroutine_origin 將為None。語法格式如下：

sys.set_coroutine_origin_tracking_depth(depth)

參數(shù)說明：

• depth：表示要設(shè)置的協(xié)同源跟蹤深度，為0 表示禁用協(xié)同源跟蹤。

說明:set_coroutine_origin_tracking_depth(depth) 方法是Python 3.7 版本中新增的功能， 因此只能在Python 3.7 及以上版本中使用。

獲取當(dāng)前的協(xié)程源默認(rèn)跟蹤深度，然后使用set_coroutine_origin_tracking_depth() 設(shè)置深度值為10，設(shè)置完成后，再次獲取協(xié)程源跟蹤深度，代碼如下：

import sys

print(‘默認(rèn)：',sys.get_coroutine_origin_tracking_depth())

sys.set_coroutine_origin_tracking_depth(10)

print(‘設(shè)置后：',sys.get_coroutine_origin_tracking_depth())

81. set_coroutine_wrapper()方法——允許攔截協(xié)同程序?qū)ο蟮膭?chuàng)建

set_coroutine_wrapper() 方法用于允許攔截協(xié)同程序?qū)ο蟮膭?chuàng)建（只有由async def 定義的函數(shù)、由types.coroutine() 或者asyncio.coroutine() 創(chuàng)建的裝飾器可以不被攔截）。語法格式如下：

sys.set_coroutine_wrapper(wrapper)

參數(shù)說明：

• wrapper ：必須是以下兩種情況之一：一是接受一個參數(shù)（一個協(xié)程對象）的回調(diào)函數(shù)；二是None，用來重置包裝器。

如果調(diào)用兩次，則新包裝器將替換前一個包裝器，該函數(shù)是特定于線程的。

說明:set_coroutine_wrapper(wrapper) 方法是Python 3.5 版本中新增的功能，但從Python 3.7 開始不推薦使用，因為協(xié)程包裝器功能已被棄用，而且將在Python 3.8 中刪除，所以了解即可。

定義一個wrapper() 函數(shù)，在該函數(shù)中嵌套一個異步函數(shù)，執(zhí)行程序的掛起操作；然后使用set_coroutine_wrapper() 方法設(shè)置包裝器，代碼如下：

import sys

def wrapper(coro):

async def wrap(coro):                	# 異步函數(shù)

return await coro                    	# 程序掛起

return wrap(coro)

sys.set_coroutine_wrapper(wrapper)     	# 設(shè)置包裝器

程序運行結(jié)果如下：

J:/PythonDemo/Python速查手冊/sysDemo.py:24: DeprecationWarning: set_coroutine_wrapper isdeprecated

sys.set_coroutine_wrapper(wrapper) 		# 設(shè)置包裝器

說明:上面的輸出結(jié)果中，提示set_coroutine_wrapper() 方法已經(jīng)過時，所以，這里只需要了解這個方法即可，因為在Python 3.8 版本中，這個方法就會被徹底刪除。

82. setcheckinterval()方法——設(shè)置解釋器的檢查間隔

setcheckinterval() 方法用于設(shè)置解釋器的“檢查間隔”，此整數(shù)值確定解釋器檢查周期性事物（如線程切換和信號處理程序）的頻率。默認(rèn)值是100，意味著每100 條Python 虛擬指令執(zhí)行一次檢查。將其設(shè)置為更大的值，可以提高使用線程的程序的性能；而如果將其設(shè)置為小于等于0 的值，將檢查每個虛擬指令，從而最大限度地提高響應(yīng)速度和開銷。語法格式如下：

sys.setcheckinterval(interval)

參數(shù)說明：

• interval：表示要設(shè)置的檢查間隔。

說明:從Python 3.2 版本開始，不推薦使用setcheckinterval() 方法，而應(yīng)該使用setswitchinterval() 方法。

首先獲取Python 解釋器的默認(rèn)檢查間隔，然后使用setcheckinterval() 將檢查間隔設(shè)置為10，再次獲取設(shè)置之后的Python 解釋器檢查間隔，代碼如下：

import sys

print(sys.getcheckinterval())      		# 打印默認(rèn)檢查間隔

sys.setcheckinterval(10)          		# 手動設(shè)置檢查間隔為10

print(sys.getcheckinterval())      		# 打印設(shè)置完的檢查間隔

程序運行結(jié)果如下：

100

10

print(sys.getcheckinterval())J:/PythonDemo/Python速查手冊/sysDemo.py:20: DeprecationWarning: sys.getcheckinterval()and sys.setcheckinterval() are deprecated. Use sys.setswitchinterval() instead.

sys.setcheckinterval(10)J:/PythonDemo/Python速查手冊/sysDemo.py:21: DeprecationWarning: sys.getcheckinterval()

and sys.setcheckinterval() are deprecated. Use sys.getswitchinterval() instead.print(sys.getcheckinterval())

 

說明:上面的運行結(jié)果中輸出了檢查間隔為100 和手動設(shè)置后的檢查間隔10，但同時下面有兩個警告，提示setcheckinterval() 和getcheckinterval() 方法已經(jīng)過期，推薦使用getswitchinterval() 和setswitchinterval()。

83. setprof?ile()方法——設(shè)置函數(shù)以允許對Python源碼分析

setprofile() 方法用于設(shè)置系統(tǒng)的配置文件函數(shù)，允許您在Python 中實現(xiàn)Python 源代碼分析器。系統(tǒng)配置文件函數(shù)的調(diào)用類似于系統(tǒng)的跟蹤函數(shù)（請參考settrace() 方法），但它是使用不同的事件調(diào)用的。例如，不會為每個執(zhí)行的代碼行調(diào)用它，而是在調(diào)用和返回時調(diào)用它，但會報告返回事件。setprofile() 方法是特定于線程的，但是探查器無法知道線程之間的上下文切換，因此存在多個線程時，使用它是沒有意義的。另外，它的返回值沒有使用，所以它可以簡單地返回None。語法格式如下：

setprofile(profilefunc)

參數(shù)說明：

• profilefunc：表示要設(shè)置的系統(tǒng)配置文件函數(shù)名稱。系統(tǒng)配置文件函數(shù)應(yīng)該有三個參數(shù)：frame、event 和arg，它們的含義如下：
  ? frame ：當(dāng)前的堆棧幀。
  ? event ：一個字符串，可以是“call”“return”“c_call”“c_return”或“c_exception”，它們的含義如下：
  ? call：一個函數(shù)（或輸入的代碼塊）被調(diào)用，配置文件函數(shù)將訪問它，arg 是None。
  ? return ：返回一個函數(shù)（或代碼塊），配置文件函數(shù)將訪問它，arg 是要返回的值，或者
  ? None（如果事件引發(fā)異常）。
  ? c_call：一個C函數(shù)將被調(diào)用，這個函數(shù)可以是擴(kuò)展函數(shù)或內(nèi)置函數(shù)。 arg是C函數(shù)對象。
  ? c_return ：返回一個C函數(shù)，arg 是C函數(shù)對象。
  ? c_exception：一個C函數(shù)引發(fā)的異常，arg 是C函數(shù)對象。
  ? arg ：取決于事件類型。

使用setprofile() 函數(shù)設(shè)置一個自定義的探查器函數(shù)，以便在程序執(zhí)行過程中，對代碼進(jìn)行分析，代碼如下：

import sys

# 定義一個函數(shù)，用來作為探查器函數(shù)，必須定義3個參數(shù)
def Test(frame,event,arg):
	caller=frame.f_back               	# 獲取當(dāng)前堆棧
	print(‘call’,caller)               	# 返回調(diào)用的堆棧信息

def testA():                        	# 測試輸出
	print('testA')

def testB():                        	# 測試輸出
	print('testB')

testA()                         		# 調(diào)用testA()
sys.setprofile(Test)                 	# 設(shè)置探查器函數(shù)
testB()                             	# 調(diào)用testB()

84. setrecursionlimit()方法——設(shè)置遞歸限制的值

setrecursionlimit() 方法用于設(shè)置Python 解釋器的最大遞歸深度，該限制可防止無限遞歸引發(fā)Python解釋器本身的棧溢出，從而導(dǎo)致崩潰。語法格式如下：

sys.setrecursionlimit(limit)

參數(shù)說明：

• limit：一個整數(shù)，表示要設(shè)置的遞歸深度，默認(rèn)值是1000。

使用setrecursionlimit() 設(shè)置遞歸深度為10，然后定義一個遞歸函數(shù)，執(zhí)行該遞歸函數(shù)，并在達(dá)到遞歸限制時，產(chǎn)生RuntimeError 異常，代碼如下：

import sys

print(‘默認(rèn)遞歸次數(shù)：',sys.getrecursionlimit())      	# 打印默認(rèn)遞歸深度
sys.setrecursionlimit(10)                       	# 手動設(shè)置遞歸深度為10
print(‘修改后遞歸次數(shù)：',sys.getrecursionlimit())    	# 打印修改后遞歸深度
# 定義一個遞歸函數(shù)

def Test(i):
	print(‘第 {} 次數(shù)’.format(i))                  	# 打印執(zhí)行次數(shù)

	Test(i+1)                                  		# 函數(shù)遞歸執(zhí)行

# 捕獲異常信息
try:
	Test(1) # 調(diào)用遞歸函數(shù)
except RuntimeError as err:                      	# 捕捉異常
	print(err)                                 		# 打印異常信息

85. setswitchinterval()方法——設(shè)置線程切換間隔

setswitchinterval() 方法用于設(shè)置解釋器的線程切換間隔（以秒為單位）。語法格式如下：

sys.setswitchinterval(interval)

參數(shù)說明：

• interval：一個浮點值，表示分配給并發(fā)運行的Python線程的理想持續(xù)時間。但在該時間結(jié)束后，要調(diào)度的線程是由操作系統(tǒng)決定的，因為Python 解釋器沒有自己的調(diào)度程序。

說明:在Python 3.2 及以上的版本中，使用setswitchinterval() 方法替換了原來的setcheckinterval() 方法。

首先獲取Python 解釋器的默認(rèn)線程切換間隔，然后使用setswitchinterval() 將線程切換間隔設(shè)置為0.1 秒，再次獲取設(shè)置之后的Python 解釋器線程切換間隔，代碼如下：

import sys

print(sys.getswitchinterval()) 			# 打印默認(rèn)線程間隔

sys.setswitchinterval(0.1) 				# 手動設(shè)置線程間隔為0.1秒

print(sys.getswitchinterval()) 			# 打印設(shè)置后的線程間隔

86. settrace()方法——設(shè)置系統(tǒng)的跟蹤功能

settrace() 方法用于設(shè)置系統(tǒng)的跟蹤功能，允許在Python 中實現(xiàn)Python 源代碼調(diào)試器，該函數(shù)是特定于線程的，語法格式如下：

sys.settrace(tracefunc)

參數(shù)說明：

• ? tracefunc：表示要設(shè)置的跟蹤函數(shù)名稱。跟蹤函數(shù)應(yīng)該有3 個參數(shù)：frame、event 和arg，它們的含義如下：
  ? frame ：當(dāng)前的堆棧幀。
  ? event ：一個字符串，可以是“call”“l(fā)ine”“return”“exception”或“opcode”，它們的含義如下：
  ? call：如果全局跟蹤函數(shù)被調(diào)用或者一個函數(shù)被調(diào)用，或輸入一些其他代碼塊，arg 是
  ? None，返回值為本地跟蹤功能。
  ? line：解釋器即將執(zhí)行新的代碼行或重新執(zhí)行循環(huán)的條件。如果調(diào)用本地跟蹤功能，arg是None，返回值指定新的本地跟蹤功能。
  ? return ：函數(shù)（或其他代碼塊）即將返回。如果調(diào)用本地跟蹤功能，arg 是將返回的值；或者是None，跟蹤函數(shù)的返回值將被忽略。
  ? exception：發(fā)生了異常。如果調(diào)用本地跟蹤功能，arg 是一個(exception,value,traceback)元組，返回值指定新的本地跟蹤功能。
  ? opcode ：解釋器即將執(zhí)行新的操作碼。如果調(diào)用本地跟蹤功能，arg 是None，返回值指定新的本地跟蹤功能。默認(rèn)情況下不會發(fā)出操作碼事件，必須通過設(shè)置f_trace_opcodes為True，來顯式請求它們。
  ? arg ：取決于事件類型。

注意:settrace() 方法僅用于實現(xiàn)調(diào)試器、分析器、覆蓋工具等，它的行為是實現(xiàn)平臺的一部分，而不是語言定義的一部分，因此不是在所有Python 實現(xiàn)中都可用。

使用settrace() 方法設(shè)置一個自定義的跟蹤函數(shù)，跟蹤程序執(zhí)行過程中的訪問，代碼如下：

import sys

# 定義一個函數(shù)，用來作為跟蹤函數(shù)，必須定義3個參數(shù)
def Test(frame,event,arg):
	caller=frame.f_back               		# 獲取當(dāng)前堆棧
	print(‘call’,caller)               		# 返回調(diào)用的堆棧信息

def testA():                        		# 測試輸出
	print('testA')

def testB():                        		# 測試輸出
	print(‘testB’)

testA()                         			# 調(diào)用testA()
sys.settrace(Test)                   		# 設(shè)置跟蹤函數(shù)
testB()                             		# 調(diào)用testB()

87. _enablelegacywindowsfsencoding()方法——改變 默認(rèn)文件系統(tǒng)編碼和錯誤模式

_enablelegacywindowsfsencoding() 方法用于將默認(rèn)文件系統(tǒng)編碼和錯誤模式分別更改為“mbcs”和“replace”，以便與Python 3.6 之前的版本保持一致，這相當(dāng)于在啟動Python 之前定義了PYTHONLEGACYWINDOWSFSENCODING 環(huán)境變量。語法格式如下：

sys._enablelegacywindowsfsencoding()

說明:

1. _enablelegacywindowsfsencoding() 方法只能在Windows 操作系統(tǒng)中使用。
2. _enablelegacywindowsfsencoding() 方法是Python 3.6 版本中新增的功能，因此只能在Python 3.6及以上版本中使用。

使用_enablelegacywindowsfsencoding() 方法改變默認(rèn)的文件系統(tǒng)編碼和錯誤模式，然后分別使用getfilesystemencoding() 方法和getfilesystemencodeerrors() 方法獲取改變之后的文件系統(tǒng)編碼和錯誤模式，代碼如下：文章來源地址http://www.zghlxwxcb.cn/news/detail-492777.html

import sys

sys._enablelegacywindowsfsencoding()                     		# 改變默認(rèn)文件系統(tǒng)編碼和錯誤模式
print(‘文件系統(tǒng)編碼：',sys.getfilesystemencoding())         		# 打印文件系統(tǒng)編碼
print(‘文件名轉(zhuǎn)換錯誤模式：',sys.getfilesystemencodeerrors()) 		# 打印文件名轉(zhuǎn)換時的錯誤模式名稱

到了這里，關(guān)于第十二章 sys模塊的文章就介紹完了。如果您還想了解更多內(nèi)容，請在右上角搜索TOY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！