1、random模塊

程序中有很多地方需要用到隨機字符，比如登錄網站的隨機驗證碼，通過random模塊可以很容易生成隨機字符串

# randrange #返回1-3之間的一個隨機數，不包含3  
# randint #返回1-3之間的一個隨機數，包含3

In [32]: random.randrange(1,3)
Out[32]: 2

In [33]: random.randrange(1,3)
Out[33]: 2

In [34]: random.randrange(1,3)
Out[34]: 1

In [35]: random.randrange(1,3)
Out[
 
35]: 1

In [36]: random.randint(1,3)
Out[36]: 3

In [37]: random.randint(1,3)
Out[37]: 2

In [38]: random.randint(1,3)
Out[38]: 1

>>> random.randrange(0, 100, 2) #隨機選取0到100間的偶數

# random 0-1直接的浮點數
In [39]: random.random()
Out[39]: 0.6654421359097369

In [40]: random.random()
Out[
 
40]: 0.1015447178963047

>>> random.choice(‘abce3#$@1‘) #返回一個給定數據集合中的隨機字符
‘#‘

>>> random.sample(‘abcdefghij‘,3)  #從多個字符中選取特定數量的字符
[‘a‘, ‘d‘, ‘b‘]

# 洗牌
In [51]: d = [i for i in range(12)]

In [52]: d
Out[52]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]

In [53]: random.shuffle(d)

In [
 
54]: d
Out[54]: [3, 10, 8, 1, 9, 2, 7, 11, 5, 6, 4, 0]

2.生成隨機驗證碼 ：string模塊

In [57]: string.digits   # 整數
Out[57]: ‘0123456789‘

In [58]: string.ascii_letters  # 大小寫字母
Out[58]: ‘abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ‘
 
In [62]: string.punctuation    # 特殊字符
Out[62]: ‘!"#$%&\‘()*+,-./:;<=>?@[\\]^_`{|}~‘

In [59]: string.hexdigits  # 16進制數
Out[59]: ‘0123456789abcdefABCDEF‘

In [60]: string.octdigits  # 8進制數
Out[60]: ‘01234567‘

# 隨機驗證碼
In [61]: string.digits + string.ascii_letters
Out[61]: ‘0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ‘    

In [63]: string.digits + string.ascii_letters + string.punctuation
Out[63]: ‘0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!"#$%&\‘()*+,-./:;<=>?@[\\]^_`{|}~‘

In [64]: s = string.digits + string.ascii_letters + string.punctuation
In [66]: ‘‘.join(random.sample(s,4))
Out[66]: ‘_K{Y‘

In [67]: ‘‘.join(random.sample(s,4))
Out[67]: ‘WIBN‘

In [68]: ‘‘.join(random.sample(s,4))
Out[68]: ‘j,^~‘

In [69]: ‘‘.join(random.sample(s,4))
Out[69]: ‘W)1"‘

3、os 模塊

os 模塊提供了很多允許你的程序與操作系統直接交互的功能

os模塊的主要功能：系統相關、目錄及文件操作、執行命令和管理進程

在使用os模塊的時候，如果出現了問題，會拋出OSError異常，表明無效的路徑名或文件名，或者路徑名(文件名)無法訪問，或者當前操作系統不支持該操作。

>>> import os
>>> os.chdir("d:\11")
Traceback (most recent call last):
  File "<pyshell#2>", line 1, in <module>
    os.chdir("d:\11")
OSError: [WinError 123] 文件名、目錄名或卷標語法不正確。: ‘d:\t‘

（1）系統相關

方法和變量	用途
os.name	查看當前操作系統的名稱。windows平臺下返回‘nt’，Linux則返回‘posix’。
os.environ	獲取系統環境變量
os.sep	當前平臺的路徑分隔符。在windows下，為‘\’，在POSIX系統中，為‘/’。
os.altsep	可替代的路徑分隔符，在Windows中為‘/’。
os.extsep	文件名和文件擴展名之間分隔的符號，在Windows下為‘.’。
os.pathsep	PATH環境變量中的分隔符，在POSIX系統中為‘:’，在Windows中為‘;’。
os.linesep	行結束符。在不同的系統中行尾的結束符是不同的，例如在Windows下為‘\r\n’。
os.devnull	在不同的系統上null設備的路徑，在Windows下為‘nul’，在POSIX下為‘/dev/null’。
os.defpath	當使用exec函數族的時候，如果沒有指定PATH環境變量，則默認會查找os.defpath中的值作為子進程PATH的值。

>>> import os
>>> os.name
‘nt‘
>>> os.environ
environ({‘ALLUSERSPROFILE‘: ‘C:\\ProgramData‘, ‘APPDATA‘: ‘C:\\Users\\Administrator\\AppData\\Roaming‘, ‘ASL.LOG‘: ‘Destination=file‘, ......
>>> os.sep
‘\\‘
>>> os.altsep
‘/‘
>>> os.extsep
‘.‘
>>> os.pathsep
‘;‘
>>> os.linesep
‘\r\n‘
>>> os.devnull
‘nul‘
>>> os.defpath
‘.;C:\\bin‘

（2）文件和目錄操作

方法和變量	用途
os.getcwd()	獲取當前工作目錄，即當前python腳本工作的目錄路徑
os.chdir("dirname")	改變當前腳本工作目錄；相當於shell下cd
os.curdir	返回當前目錄: (‘.‘)
os.pardir	獲取當前目錄的父目錄字符串名：(‘..‘)
os.makedirs(‘dir1/dir2‘)	可生成多層遞歸目錄
os.removedirs(‘dirname1’)	遞歸刪除空目錄（要小心）
os.mkdir(‘dirname‘)	生成單級目錄
os.rmdir(‘dirname‘)	刪除單級空目錄，若目錄不為空則無法刪除並報錯
os.listdir(‘dirname‘)	列出指定目錄下的所有文件和子目錄，包括隱藏文件
os.remove(‘filename‘)	刪除一個文件
os.rename("oldname","new")	重命名文件/目錄
os.stat(‘path/filename‘)	獲取文件/目錄信息
os.path.abspath(path)	返回path規範化的絕對路徑
os.path.split(path)	將path分割成目錄和文件名二元組返回
os.path.dirname(path)	返回path的目錄。其實就是os.path.split(path)的第一個元素
os.path.basename(path)	返回path最後的文件名。如果path以／或\結尾，那麽就會返回空值。
os.path.exists(path或者file)	如果path存在，返回True；如果path不存在，返回False
os.path.isabs(path)	如果path是絕對路徑，返回True
os.path.isfile(path)	如果path是一個存在的文件，返回True。否則返回False
os.path.isdir(path)	如果path是一個存在的目錄，則返回True。否則返回False
os.path.join(path1[, path2[, ...]])	將多個路徑組合後返回，第一個絕對路徑之前的參數將被忽略
os.path.getatime(path)	返回path所指向的文件或者目錄的最後存取時間
os.path.getmtime(path)	返回path所指向的文件或者目錄的最後修改時間
os.path.getsize(filename)	返回文件包含的字符數量

　　在Python中，使用windows的文件路徑時一定要小心，比如你要引用d盤下的1.txt文件，那麽路徑要以字符串的形式寫成‘d:\\1.txt‘或者r‘d:\1.txt。前面的方式是使用windwos的雙斜杠作為路徑分隔符，後者是使用原生字符串的形式，以r開始的字符串都被認為是原始字符串，表示字符串裏所有的特殊符號都以本色出演，不進行轉義，此時可以使用普通windows下的路徑表示方式。這兩種方法使用哪種都可以，但不可混用。

>>> os.getcwd()
‘C:\\Python36‘
>>> os.chdir("d:")
>>> os.getcwd()
‘D:\\‘
>>> os.curdir
‘.‘
>>> os.pardir
‘..‘
>>> os.makedirs("1\\2")
>>> os.removedirs("1\\2")
>>> os.listdir()
[‘$360Section‘, ‘$RECYCLE.BIN‘, ‘1.txt‘, ‘MobileFile‘, ‘pymysql_test.py‘, ‘System Volume Information‘, ‘用戶目錄‘]
>>> os.mkdir("1")
>>> os.listdir()
[‘$360Section‘, ‘$RECYCLE.BIN‘, ‘1‘, ‘1.txt‘, ‘MobileFile‘, ‘pymysql_test.py‘, ‘System Volume Information‘, ‘用戶目錄‘]
>>> os.rmdir("1")
>>> os.rename(‘1.txt‘,‘2.txt‘)
>>> os.listdir()
[‘$360Section‘, ‘$RECYCLE.BIN‘, ‘2.txt‘, ‘MobileFile‘, ‘pymysql_test.py‘, ‘System Volume Information‘, ‘用戶目錄‘]
>>> os.remove(‘1.txt‘)
Traceback (most recent call last):
  File "<pyshell#22>", line 1, in <module>
    os.remove(‘1.txt‘)
FileNotFoundError: [WinError 2] 系統找不到指定的文件。: ‘1.txt‘
>>> os.remove(‘2.txt‘)
>>> os.stat()
Traceback (most recent call last):
  File "<pyshell#24>", line 1, in <module>
    os.stat()
TypeError: Required argument ‘path‘ (pos 1) not found
>>> os.stat(os.getcwd())
os.stat_result(st_mode=16895, st_ino=1407374883553285, st_dev=2431137650, st_nlink=1, st_uid=0, st_gid=0, st_size=32768, st_atime=1505824872, st_mtime=1505824872, st_ctime=1445187376)

>>> import os
>>> os.chdir("d:")
>>> os.getcwd()
‘D:\\‘
>>> os.mkdir(‘test‘)
>>> os.listdir()
[‘$360Section‘, ‘$RECYCLE.BIN‘, ‘MobileFile‘, ‘pymysql_test.py‘, ‘System Volume Information‘, ‘test‘, ‘用戶目錄‘]
>>> os.chdir(‘test‘)
>>> os.getcwd()
‘D:\\test‘
>>> os.path.abspath(os.getcwd())
‘D:\\test‘
>>> os.path.split(os.getcwd())
(‘D:\\‘, ‘test‘)
>>> cp = os.getcwd()
>>> os.path.dirname(cp)
‘D:\\‘
>>> os.path.basename(cp)
‘test‘
>>> os.path.exists(cp)
True
>>> os.path.exists("d:\\123\123")
False
>>> os.path.isabs(cp)
True
>>> os.path.isabs("11\\1.py")
False
>>> os.path.isfile(cp)
False
>>> os.path.isfile("d:\\1.txt")
False
>>> os.path.isdir(cp)
True
>>> os.path.join(cp, "test.py")
‘D:\\test\\test.py‘
>>> os.path.getatime(cp)
1505825113.4970243
>>> os.path.getmtime(cp)
1505825113.4970243
>>> os.path.getsize(cp)
0

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

walk方法是os模塊中非常重要和強大的一個方法。可以幫助我們非常便捷地以遞歸方式自頂向下或者自底向上的方式遍歷目錄樹，對每一個目錄都返回一個三元元組(dirpath, dirnames, filenames)。

三元元組(dirpath，dirnames，filenames)：

dirpath - 遍歷所在目錄樹的位置，是一個字符串對象
dirnames - 目錄樹中的子目錄組成的列表，不包括("."和"..")
filenames - 目錄樹中的文件組成的列表

如果可選參數topdown = True或者沒有指定，則采用自頂向下的方式進行目錄遍歷，也就是從父目錄向子目錄逐步深入遍歷，如果topdown = False，則采用自底向上的方式遍歷目錄，也就是先打印子目錄再打印父目錄的方式。

如果可選參數onerror被指定，則onerror必須是一個函數，該函數有一個OSError實例的參數，這樣可以允許在運行的時候即使出現錯誤的時候不會打斷os.walk()的執行，或者拋出一個異常並終止os.walk()的運行。通俗的講，就是定義這個參數用於指定當發生了錯誤時的處理方法。

默認情況下，os.walk()遍歷的時候不會進入符號鏈接，如果設置了可選參數followlinks = True，則會進入符號鏈接。註意，這可能會出現遍歷死循環，因為符號鏈接可能會出現自己鏈接自己的情況，而os.walk()沒有那麽高的智商，無法發現這一點。

• 下面的例子會將c:\python36目錄中的所有文件和子目錄打印出來。

import os

try:
    for root, dirs, files in os.walk(r"c:\python36"):
        print("\033[1;31m-"*8, "directory", "<%s>\033[0m" % root, "-"*10)
        for directory in dirs:
            print("\033[1;34m<DIR>    %s\033[0m" % directory)
        for file in files:
            print("\t\t%s" % file)
except OSError as ex:
    print(ex)

運行結果：

-------- directory <c:\python36> ----------
<DIR>    DLLs
<DIR>    Doc
<DIR>    include
<DIR>    Lib
<DIR>    libs
<DIR>    Scripts
<DIR>    share
<DIR>    tcl
<DIR>    Tools
        LICENSE.txt
        NEWS.txt
        python.exe
        python3.dll
        python36.dll
        pythonw.exe
        vcruntime140.dll
-------- directory <c:\python36\DLLs> ----------
        py.ico
        pyc.ico
...

• 下面的例子會統計c:/python36/Lib/email目錄下所有子目錄的大小，但是CVS目錄除外。

import os
from os.path import join, getsize
for root, dirs, files in os.walk(‘c:/python36/Lib/email‘):
    print(root, "consumes", end=" ")
    print(sum(getsize(join(root, name)) for name in files), end=" ")
    print("bytes in", len(files), "non-directory files")
    if ‘CVS‘ in dirs:
        dirs.remove(‘CVS‘)  # 不遍歷CVS目錄

運行結果：

C:\Python36\python.exe F:/Python/pycharm/201705/1.py -
c:/python36/Lib/email consumes 377849 bytes in 21 non-directory files
c:/python36/Lib/email\mime consumes 12205 bytes in 9 non-directory files
c:/python36/Lib/email\mime\__pycache__ consumes 30289 bytes in 27 non-directory files
c:/python36/Lib/email\__pycache__ consumes 741924 bytes in 60 non-directory files

• 下面的例子會遞歸刪除目錄的所有內容，危險，請勿隨意嘗試！

import os
for root, dirs, files in os.walk(top, topdown=False):
    for name in files:
        os.remove(os.path.join(root, name))
    for name in dirs:
        os.rmdir(os.path.join(root, name))

(4) 執行命令

在早期的Python版本中，通常使用os模塊的system或者popen等方法執行操作系統的命令。但是，最近Python官方逐漸棄用了這些命令，而是改用內置的subprocess模塊執行操作系統相關命令。

由於目前還有很多人仍然在使用os的system和popen方法，在此簡要介紹一下。

os.system(command)

運行操作系統命令，直接顯示結果。但返回值是0或-1，不能獲得顯示在屏幕上的數據。 command是要執行的命令字符串

In [1]: import os

In [2]: ret = os.system("ifconfig")
eth0      Link encap:Ethernet  HWaddr 02:16:3e:31:ff:3b  
          inet addr:176.17.230.109  Bcast:176.17.230.255  Mask:255.255.255.0
          UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
          RX packets:274674 errors:0 dropped:0 overruns:0 frame:0
          TX packets:260923 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:1000 
          RX bytes:62664341 (62.6 MB)  TX bytes:83842737 (83.8 MB)

lo        Link encap:Local Loopback  
          inet addr:127.0.0.1  Mask:255.0.0.0
          UP LOOPBACK RUNNING  MTU:65536  Metric:1
          RX packets:244020 errors:0 dropped:0 overruns:0 frame:0
          TX packets:244020 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:1 
          RX bytes:376137873 (376.1 MB)  TX bytes:376137873 (376.1 MB)
In [3]: ret
Out[3]: 0

可以看到運行的返回值是0，而不是我們期望的輸出信息。

如果我們是在windows環境下使用IDLE運行os.system(‘ipconfig /all‘)，你會發現命令終端界面一閃而過，根本啥都來不及看。這時候，你最好進入cmd環境使用python命令進入交互式界面才可以看到屏幕上的信息。

另外，請嘗試在不同環境下執行os.system(‘python3‘)。

os.popen(command, [mode, [bufsize]])

開啟一個子進程執行command參數指定的命令，在父進程和子進程之間建立一個管道pipe，用於在父子進程間通信。該方法返回一個文件對象，可以對這個文件對象進行讀或寫，取決於參數mode，如果mode指定了只讀，那麽只能對文件對象進行讀，如果mode參數指定了只寫，那麽只能對文件對象進行寫操作。

簡而言之，popen也可以運行操作系統命令，並通過read()方法將命令的結果返回，不像system只能看不能存，這個能存！

>>> os.popen(‘ipconfig‘)
<os._wrap_close object at 0x0000000002BB8EF0>
>>> ret = os.popen(‘ipconfig‘)
>>> ret.read()
‘\nWindows IP 配置\n\n\n以太網適配器 Bluetooth 網絡連接 2:\n\n   
媒體狀態  . . . . . . . . . . . . : 媒體已斷開\n  
 連接特定的 DNS 後綴 . . . . . . . : \n\n無線局域網適配器 無線網絡連接 2:\n\n   媒體狀態  . . . . . . . . . . . . : 媒體已斷開\n 
  連接特定的 DNS 後綴 . . . . . . . : \n\n無線局域網適配器 無線網絡連接:\n\n   
連接特定的 DNS 後綴......

試試運行類似python3這種會進入交互式界面的命令看看，結果不是很理想，無法進入想要的交互式界面：

>>> ret = os.popen(‘python3‘)
>>> ret
<os._wrap_close object at 0x0000000002BB8E80>
>>> ret.read()
‘‘

4.sys模塊

sys模塊主要是針對與Python解釋器相關的變量和方法，不是主機操作系統。

屬性及方法	使用說明
sys.argv	獲取命令行參數列表，第一個元素是程序本身
sys.exit(n)	退出Python程序，exit(0)表示正常退出。當參數非0時，會引發一個SystemExit異常，可以在程序中捕獲該異常
sys.version	獲取Python解釋程器的版本信息
sys.maxsize	最大的Int值，64位平臺是2**63 - 1
sys.path	返回模塊的搜索路徑，初始化時使用PYTHONPATH環境變量的值
sys.platform	返回操作系統平臺名稱
sys.stdin	輸入相關
sys.stdout	輸出相關
sys.stderr	錯誤相關
sys.exc_info()	返回異常信息三元元組
sys.getdefaultencoding()	獲取系統當前編碼，默認為utf-8
sys.setdefaultencoding()	設置系統的默認編碼
sys.getfilesystemencoding()	獲取文件系統使用編碼方式，默認是utf-8
sys.modules	以字典的形式返回所有當前Python環境中已經導入的模塊
sys.builtin_module_names	返回一個列表，包含所有已經編譯到Python解釋器裏的模塊的名字
sys.copyright	當前Python的版權信息
sys.flags	命令行標識狀態信息列表。只讀。
sys.getrefcount(object)	返回對象的引用數量
sys.getrecursionlimit()	返回Python最大遞歸深度，默認1000
sys.getsizeof(object[, default])	返回對象的大小
sys.getswitchinterval()	返回線程切換時間間隔，默認0.005秒
sys.setswitchinterval(interval)	設置線程切換的時間間隔，單位秒
sys.getwindowsversion()	返回當前windwos系統的版本信息
sys.hash_info	返回Python默認的哈希方法的參數
sys.implementation	當前正在運行的Python解釋器的具體實現，比如CPython
sys.thread_info	當前線程信息

（1）sys.argv

sys.argv是一個腳本執行參數列表，列表的第一個元素是腳本名稱，從第二個元素開始才是真正的參數。

# test.py
import sys
for index, arg in enumerate(sys.argv):
    print("第%d個參數是： %s" % (index, arg))
　　

運行python test.py 1 2 3 4，結果：

第0個參數是： test.py
第1個參數是： 1
第2個參數是： 2
第3個參數是： 3
第4個參數是： 4 

（2）sys.getrefcount(object)

我們都知道Python有自動的垃圾回收機制，讓我們不用費力去進行內存管理。那麽Python怎麽知道一個對象可以被當做垃圾回收呢？Python使用‘引用計數’的方式，追蹤每個對象 的引用次數，每對這個對象的一次引用，這個計數就加一，每刪除一個該對象的引用，這個計數就減一。當引用為0的時候，就表示沒有任何變量指向這個對象，那麽就可以回收這個對象，騰出它所占用的內存空間。

sys.getrefcount(object)這個方法可以返回一個對象被引用的次數。註意，這個次數默認從1開始，因為你在使用sys.getrefcount(object)方法的時候就已經引用了它一次（該引用是臨時性的，調用結束後，自動解除引用。）。如果不好理解，可以簡單地認為它自帶被動光環：引用+1。

>>> a = "I like Python!"
>>> sys.getrefcount(a)
2
>>> b = a
>>> sys.getrefcount(a)
3
>>> c = a
>>> sys.getrefcount(a)
4
>>> del c
>>> sys.getrefcount(a)
3
>>> del b
>>> sys.getrefcount(a)
2
>>> sys.getrefcount(1)
902
>>> sys.getrefcount("a")
36
>>> sys.getrefcount(True)
581
>>> sys.getrefcount(None)
6918

註意實例中的1、"a"、True、None，Python內部環境運行過程中已經引用了它們很多次，None甚至被使用了6918次。

（3）sys.modules

sys.modules保存有當前Python環境中已經導入的模塊記錄，這是一個全局字典，當Python啟動後就加載在內存中。每當導入新的模塊，sys.modules將自動記錄該模塊，當第二次試圖再次導入該模塊時，Python會先到這個字典中查找是否曾經導入過該模塊。是則忽略，否則導入，從而加快了程序運行的速度。同時，它擁有字典的基本方法。例如sys.modules.keys()查看字典的所有鍵，sys.modules.values()查看字典的所有值，sys.modules[‘sys‘]查看sys鍵對應的值。

>>> import sys
>>> sys.modules
{‘builtins‘: <module ‘builtins‘ (built-in)>, ‘sys‘: <module ‘sys‘ (built-in)>, ‘_frozen_importlib‘: 
<module ‘importlib._bootstrap‘ (frozen)>, ‘_imp‘: <module ‘_imp‘ (built-in)>, ‘_warnings‘: 
<module ‘_warnings‘ (built-in)>, ‘_thread‘: 
.......截取部分
>>> sys.modules.keys()
dict_keys([‘builtins‘, ‘sys‘, ‘_frozen_importlib‘, ‘_imp‘, ‘_warnings‘, ‘_thread‘, ‘_weakref‘, ‘_frozen_importlib_external‘, ‘_io‘, 
‘marshal‘, ‘nt‘, ‘winreg‘, ‘zipimport‘, ‘encodings‘, ‘codecs‘, ‘_codecs‘, ‘encodings.aliases‘, 
...截取部分
>>> sys.modules.values()
dict_values([<module ‘builtins‘ (built-in)>, <module ‘sys‘ (built-in)>, <module ‘importlib._bootstrap‘ (frozen)>,
 <module ‘_imp‘ (built-in)>, <module ‘_warnings‘ (built-in)>, <module ‘_thread‘ (built-in)>,
 <module ‘_weakref‘ module ‘urllib.parse‘ from ‘C:\\Python36\\lib\\urllib\\parse.py‘>])
.......截取部分
>>> sys.modules[‘sys‘]
<module ‘sys‘ (built-in)>

（4）sys.builtin_module_names

sys.builtin_module_names是一個字符串元組，包含了所有已經編譯在Python解釋器內的模塊名稱。

import sys

def find_module(module):
    if module in sys.builtin_module_names:
        print(module, " 內置於=> ", "__builtin__")
    else:
        print(module, "模塊位於=> ", __import__(module).__file__)


find_module(‘os‘)
find_module(‘sys‘)
find_module(‘time‘)
find_module(‘zlib‘)
find_module(‘string‘)

#----------
運行結果：
os 模塊位於=>  C:\Python36\lib\os.py
sys  內置於=>  __builtin__
time  內置於=>  __builtin__
zlib  內置於=>  __builtin__
string 模塊位於=>  C:\Python36\lib\string.py

（5）sys.path

path是一個目錄列表，供Python從中查找模塊。在Python啟動時，sys.path根據內建規則和PYTHONPATH變量進行初始化。sys.path的第一個元素通常是個空字符串，表示當前目錄。

>>> sys.path
[‘‘, ‘C:\\Python36\\Lib\\idlelib‘, ‘C:\\Python36\\python36.zip‘, ‘C:\\Python36\\DLLs‘, ‘C:\\Python36\\lib‘, ‘C:\\Python36‘, ‘C:\\Python36\\lib\\site-packages‘]

sys.path本質上是一個列表，可以進行append、insert、pop、remove等各種列表相關的操作，但通常都進行append操作，添加自己想要的查找路徑。在做修改、刪除類型的操作之前，請務必確認你的行為！

（5）sys.platform

獲取當前執行環境的平臺名稱，不同的平臺返回值如下表所示：

（6）sys.stdin、sys.stdout、sys.stderr

stdin用於所有的交互式輸入（包括input()函數）。

stdout用於print()的打印輸出或者input()函數的提示符。

stderr用於解釋器自己的提示信息和錯誤信息。

簡而言之，這三個屬性就是操作系統的標準輸入、輸出和錯誤流，它們返回的都是一個“文件類型”對象，支持read()、write()和flush()等操作，就像用open()方法打開的文件對象那樣！

>>> import sys
>>> s = sys.stdin.read()        # 使用ctrl+d結束輸入
i like python
end



>>> s
‘i like python\nend\n\n\n\n‘
>>> sys.stdout.write(s)
i like python
end

• sys.stdout 與 print()

當我們print(obj)的時候，事實上是調用了sys.stdout.write(obj+‘\n‘)，將內容打印到控制臺（默認是顯示器），然後追加一個換行符。以下兩行等價：

sys.stdout.write(‘hello‘+‘\n‘) 
print(‘hello‘)

• sys.stdin 與 input()

當我們用input(‘Please input something！‘)時，事實上是先輸出提示信息，然後捕獲輸入。 以下兩組等價：

s = input(‘Please input something！‘)


print(‘Please input something！‘,)  # 逗號表示不換行
s = sys.stdin.readline()[:-1]  # -1 可以拋棄輸入流中的‘\n‘ 換行符，自己琢磨一下為什麽。

• 從控制臺重定向到文件

默認情況下sys.stdout指向控制臺。如果把文件對象賦值給sys.stdout，那麽print ()調用的就是文件對象的write()方法。

f_handler = open(‘out.log‘, ‘w‘) 
sys.stdout = f_handler 
print(‘hello‘)
# 你無法在屏幕上看到“hello”
# 因為它被寫到out.log文件裏了

如果你還想同時在控制臺打印的話，最好先將原始的控制臺對象引用保存下來，向文件中打印之後再恢復 sys.stdout

__console__ = sys.stdout    # 保存控制臺
# redirection start #       # 去幹點別的，比如寫到文件裏
... 
# redirection end           # 幹完別的了，恢復原來的控制臺
sys.stdout = __console__

（7）實例：帶百分比的進度條

利用sys.stdout的功能，可以實現一個簡易的進度條。

import sys
import time


def bar(num, total):
    rate = num / total
    rate_num = int(rate * 100)
    r = ‘\r[%s%s]%d%%‘ % ("="*num, " "*(100-num), rate_num, )
    sys.stdout.write(r)
    sys.stdout.flush()


if __name__ == ‘__main__‘:
    for i in range(0, 101):
        time.sleep(0.1)
        bar(i, 100)

18-[模塊]-random&os&sys