我們提供的服務有：網(wǎng)站制作、網(wǎng)站建設、微信公眾號開發(fā)、網(wǎng)站優(yōu)化、網(wǎng)站認證、饒陽ssl等。為近1000家企事業(yè)單位解決了網(wǎng)站和推廣的問題。提供周到的售前咨詢和貼心的售后服務，是有科學管理、有技術的饒陽網(wǎng)站制作公司
n=0時執(zhí)行到了for i in range(2,n),這個range是個空列表[],故一次也不會進入for循環(huán)執(zhí)行“ fibs.append(fibs[-1] + fibs[-2])”，，直接返回[1,1],故不報錯
n=1返回[1]
n=2返回[1,1]
n=3及以上，進入for循環(huán)，fibs每次增加一個元素，其值為倒數(shù)第1個和倒數(shù)第2個元素之和
改為if?...?elif...else可以如下：
def?fib(n):
if?n1:
return?None
elif?n?==?1:
return?[1]
elif?n?==?2:
return?[1,?1]
else:
fibs?=?[1,?1]
for?i?in?range(2,?n):
fibs.append(fibs[-1]?+?fibs[-2])
return?fibs
print?(fib(10))
可以使用一個標志變量來控制程序的啟動和結束。
首先，在主程序中設置一個標志變量，例如 running，用于指示程序是否處于運行狀態(tài)。在程序開始時，running 應設置為 False。
然后，在每次循環(huán)中檢查 running 的值。如果 running 為 True，則執(zhí)行 auto() 函數(shù)；如果 running 為 False，則等待用戶輸入命令。
當用戶輸入 qd 命令時，將 running 設置為 True，并執(zhí)行 auto() 函數(shù)。當用戶輸入 tz 命令時，將 running 設置為 False，并執(zhí)行 reset() 函數(shù)。
示例代碼如下：
running
running = False
while True:
cmd = input("請輸入命令:")
if cmd == 'qd':
running = True
elif cmd == 'tz':
running = False
if running:
auto()
else:
reset()
在這段代碼中，我們使用了一個 while 循環(huán)來不斷接收用戶的命令。在每次循環(huán)中，我們會讀入用戶的命令，并根據(jù)命令的不同設置 running 的值。如果 running 為 True，則執(zhí)行 auto() 函數(shù)；如果 running 為 False，則執(zhí)行 reset() 函數(shù)。
這樣，用戶就可以隨時輸入 tz 命令來停止程序，也可以輸入 qd 命令來重新啟動程序。
希望這些信息能夠幫助您。
在各種變量中保存的數(shù)據(jù)都是臨時的，隨著程序運行結束都會丟失。要做到數(shù)據(jù)長期有效，必須建立在磁盤中建立文件，將數(shù)據(jù)輸入到文件中并保存。需要獲取數(shù)據(jù)時需要打開文件讀取。
而我們自己建立的程序都是應用程序，從本質上講，應用程序是無法直接操作計算機的硬件的，譬如讀寫磁盤中文件，這就需要調用操作系統(tǒng)中的相應命令。接下來我們使用的Python內置函數(shù)open()、write()都是通過調用操作系統(tǒng)的相關命令才實現(xiàn)文件讀寫的，至于其中的細節(jié)，我們就不需要考慮了。
15.1創(chuàng)建和打開文件
在Python 中創(chuàng)建或打開文件，實際上是建立一個對象，該對象通過調用內置的open()函數(shù)創(chuàng)建或打開一個文件。
語法：
file object = open(filename [, mode][, buffering])
參數(shù)說明如下：
filename：file_name變量是一個包含了你要訪問的文件名稱的字符串值；
mode：mode決定了打開文件的模式：只讀，寫入，追加等。所有可取值見如下的完全列表。這個參數(shù)是非強制的，默認文件訪問模式為只讀(r)。
Buffering：如果buffering的值被設為0，就不會有寄存；如果buffering的值取1，訪問文件時會寄存行；如果將buffering的值設為大于1的整數(shù)，表明了這就是的寄存區(qū)的緩沖大小；如果取負值，寄存區(qū)的緩沖大小則為系統(tǒng)默認。
mode參數(shù)的參數(shù)值及說明
對于其中最難區(qū)別的r、r+、w、w+、a、a+幾個參數(shù)的區(qū)別總結如下，要特別注意指針的位置：
下面舉例說明open( )函數(shù)的使用方法。
例1：
file=open('1.py')
如果文件“1.py”存在，則可以打開此文件；如果文件“1.py”不存在，則會出現(xiàn)如下提示：
Traceback (most recent call last):
File " ", line 1, in
file=open('1.py')
FileNotFoundError: [Errno 2] No such file or directory: '1.py'
例2：
file=open('4.py',’a+’)
雖然文件“4.py”不存在，但運行并未出現(xiàn)錯誤，參見上表，“a+”的含義是以讀寫模式打開文件，如果該文件已經(jīng)存在，新內容將以追加方式寫入；如果該文件不存在，則新建文件用于寫入。查看文件夾，發(fā)現(xiàn)已經(jīng)生成了一個新的文件4.py。
例3：
file=open('python.png','rb')
print(file)
運行結果：
這就是說，雖然Python可以打開一個圖片格式的文件，但print()并不能將其輸出，還需要第三方庫中模塊的相應方法去處理，如PIL中的open()f方法。
例4：
file = open("f.txt", "w",encoding='utf-8')
# 以只寫模式打開文件f.txt，編碼方式為utf-8
print( "文件名: ", file.name) # 輸出文件名
print( "是否已關閉 : ", file.closed) # 文件是否打開
print( "訪問模式 : ", file.mode) # 文件訪問模式
運行結果：
文件名: f.txt
是否已關閉 : False
訪問模式 : w
例5：
15.2關閉文件
打開文件使用后要及時關閉，以免造成不必要的破壞，同時也可以釋放內存。在Python中使用close()方法可以關閉文件。
語法格式：
file.close()
其中，file為文件對象。
15.3 with語句
with 語句適用于對資源進行訪問的場合，確保不管使用過程中是否發(fā)生異常都會執(zhí)行必要的“清理”操作，釋放資源，比如文件使用后自動關閉、線程中鎖的自動獲取和釋放等。
with語句的語法格式如下：
with expression as target:
with-body
其中，expression用于指定一個表達式，譬如打開文件的open()函數(shù)。target用于指定一個變量，并且將expression的結果保存到該變量中，譬如文件對象file。with-body用于指定with語句體，譬如一些文件操作的相關語句，如果沒有要執(zhí)行的語句體，則直接用pass語句代替。
假設python當前目錄下存在一個test.txt文件，其內容如下：
Python是一種解釋型語言： 這意味著開發(fā)過程中沒有了編譯這個環(huán)節(jié)。類似于PHP和Perl語言。
Python是交互式語言： 這意味著，您可以在一個 Python 提示符 后直接執(zhí)行代碼。
Python是面向對象語言: 這意味著Python支持面向對象的風格或代碼封裝在對象的編程技術。
Python是初學者的語言：Python 對初級程序員而言，是一種偉大的語言，它支持廣泛的應用程序開發(fā)。
舉例如下：
with open('test.txt','r',encoding='utf-8') as file:
line=file.readline() # readline()方法可以讀取文件一行數(shù)據(jù)，接下來就會講到。
print(line)
運行結果如下：
Python是一種解釋型語言： 這意味著開發(fā)過程中沒有了編譯這個環(huán)節(jié)。類似于PHP和Perl語言。
而此時，我們給該段代碼with語句之外再增加一個讀取文件的語句，代碼如下：
with open('test.txt','r',encoding='utf-8') as file:
line=file.readline()
print(line)
line2=file.readline()
print(line2)
發(fā)現(xiàn)出現(xiàn)了如下錯誤提示：
Traceback (most recent call last):
File "C:/Users/zym/AppData/Local/Programs/Python/Python39/3.py", line 5, in
line2=file.readline()
ValueError: I/O operation on closed file.
意思是要讀取的文件已經(jīng)被關閉了。
由此可知，當with語句運行結束后，被打開的test.txt文件就自動關閉了。
15.4讀取文件
在Python 中讀取文件的方法有：
1、讀取指定個數(shù)的字符
格式如下：
File.read([size])
其中，file為打開的文件對象。size為可選參數(shù)，可以指定要讀取的字符個數(shù)，省缺表示讀取所有內容。
在調用read()方法讀取文件內容時，文件必須是以r（只讀）或者r+(讀寫）方式打開。
如：
with open('test.txt','r',encoding='utf-8') as file:
txt=file.read() （或txt=file.read(10)）
print(txt)
將讀取、輸出test.txt文件的全部內容（或前10個字符）。
2、移動文件的指針
對于剛打開的文件，文件指針總是指向文件頭的。也可以通過seek()方法將文件的指針移動到新的位置。
格式如下：
file.seek(offset[,whence])
其中，file表示已經(jīng)打開的文件對象；offset用于指定移動的字符個數(shù)；whence表示從哪個位置起始計算個數(shù)，其值為0表示從文件頭開始計算，其值為1表示從當前位置開始計算，其值為2表示從文件尾開始計算，默認值為0。
例如：
with open('test.txt','r',encoding='utf-8') as file:
string=file.read(9)
print('取9個字符： '+string)
file.seek(2) #指針從文件頭開始移動2個字符
string=file.read(9) #從當前位置讀取10個字符
輸出結果：
取9個字符：
Python是一種
取9個字符：
thon是一種解釋
而下面的代碼會拋出錯誤：
with open('test.txt','r',encoding='utf-8') as file:
file.seek(2,1) #指針從當前位置開始移動2個字符
string=file.read(10) #從當前位置讀取10個字符
print('取10個字符： '+string)
錯誤提示為：
Traceback (most recent call last):
File "C:UserszymAppDataLocalProgramsPythonPython393.py", line 7, in
file.seek(2,1) #指針從當前位置開始移動2個字符
io.UnsupportedOperation: can't do nonzero cur-relative seeks
原因在于，必須使用b模式（即rb）打開文件，才能使用whence參數(shù)。但是，b模式（二進制）不適合文本文件。對于test.txt這樣的文本文件，為了解決通過改變指針讀取任意位置字符，可以采用加一個位置變量的方法來存儲指針的值。
例如：
with open('test.txt','r',encoding='utf-8') as file:
#utf-8漢字與英文字符都占一個字符
string='' #設置一個空字符串
pointer=0 #當前指針為0
str1=file.read(6) #讀取6個字符
pointer+=6 #指針變量后移6個字符
string+=str1 #string用來存放已讀取的字符
print('取6個字符： ',str1)
file.seek(pointer) #指針從文件頭開始移動2個字符
str1=file.read(8) #從當前位置讀取10個字符
pointer+=8 #指針跳過已讀取的字符
string+=str1
print('再取8個字符： ',str1)
print('所有讀取的字符： ',string)
print('當前指針所處的位置： ',pointer)
str1=file.read(1)
print('當前指針所處的字符： ',str1)
運行結果如下：
取6個字符：
Python
再取8個字符：
是一種解釋型語言
所有讀取的字符：
Python是一種解釋型語言
當前指針所處的位置：
14
當前指針所處的字符：
：
3、讀取一行數(shù)據(jù)readline()方法
語法格式：
file.readline()
例：
with open('test.txt','r',encoding='utf-8') as f:
string=f.read(1) # 讀取文件的第一個字符
if string != '': # 防止文件為空文件
lineno=0
while True:
line=f.readline()
if line != '':
lineno+=1
print('第'+str(lineno)+'行：'+line,end='')
# 因為每行都有自帶的分行符，print()語句不允許換行
else:
break # 出現(xiàn)空行時停止讀取
else:
print('要讀取的文件為空文件！')
運行結果：
第1行：ython是一種解釋型語言： 這意味著開發(fā)過程中沒有了編譯這個環(huán)節(jié)。類似于PHP和Perl語言。
第2行：Python是交互式語言： 這意味著，您可以在一個 Python 提示符 后直接執(zhí)行代碼。
第3行：Python是面向對象語言: 這意味著Python支持面向對象的風格或代碼封裝在對象的編程技術。
第4行：Python是初學者的語言：Python 對初級程序員而言，是一種偉大的語言，它支持廣泛的應用程序開發(fā)。
4、讀取全部行命令readlines()方法
語法格式：
File.readlines()
該方法與read()方法一樣，在調用read()方法讀取文件內容時，文件必須是以r（只讀）或者r+(讀寫）方式打開。
例：
with open('test.txt','r',encoding='utf-8') as f:
txt=f.readlines()
print(txt)
運行結果：
['Python是一種解釋型語言： 這意味著開發(fā)過程中沒有了編譯這個環(huán)節(jié)。類似于PHP和Perl語言。 ', 'Python是交互式語言： 這意味著，您可以在一個 Python 提示符 后直接執(zhí)行代碼。 ', 'Python是面向對象語言: 這意味著Python支持面向對象的風格或代碼封裝在對象的編程技術。 ', 'Python是初學者的語言：Python 對初級程序員而言，是一種偉大的語言，它支持廣泛的應用程序開發(fā)。 ']
從上面的運行結果可以看出，readlines()方法的返回值為一個字符串列表。所以，也可以以讀取列表元素的方法輸出。如下所示：
with open('test.txt','r',encoding='utf-8') as f:
txt=f.readlines()
for line in txt:
print(line,end='')
運行結果：
Python是一種解釋型語言： 這意味著開發(fā)過程中沒有了編譯這個環(huán)節(jié)。類似于PHP和Perl語言。
Python是交互式語言： 這意味著，您可以在一個 Python 提示符 后直接執(zhí)行代碼。
Python是面向對象語言: 這意味著Python支持面向對象的風格或代碼封裝在對象的編程技術。
Python是初學者的語言：Python 對初級程序員而言，是一種偉大的語言，它支持廣泛的應用程序開發(fā)。
15.5 寫入文件內容
語法格式如下：
file.write(string)
其中，file為打開的文件對象，string為要寫入的字符串。
寫入文件內容時，文件必須以w（可寫）或a（追加）模式打開。否則，會拋出如下異常提示：
Traceback (most recent call last):
File "C:UsersAdministratorAppDataLocalProgramsPythonPython383.py", line 2, in
f.write('人生苦短，我用Python！')
io.UnsupportedOperation: not writable
關于write()方法的用法舉例如下：
with open('test.txt','a',encoding='utf-8') as f:
f.write('人生苦短，我用Python！')
with open('test.txt','r',encoding='utf-8') as f:
txt=f.read()
print(txt)
運行結果：
Python是一種解釋型語言： 這意味著開發(fā)過程中沒有了編譯這個環(huán)節(jié)。類似于PHP和Perl語言。
Python是交互式語言： 這意味著，您可以在一個 Python 提示符 后直接執(zhí)行代碼。
Python是面向對象語言: 這意味著Python支持面向對象的風格或代碼封裝在對象的編程技術。
Python是初學者的語言：Python 對初級程序員而言，是一種偉大的語言，它支持廣泛的應用程序開發(fā)。
人生苦短，我用Python！
可以看出，由于文件的打開方式為a模式（追加模式），寫入的內容被寫入到文件的末尾。
在Python中，文件操作方法里沒有類似于字符串內的計算長度、查找、替換、截取、分隔等方法，為什么沒有？原因可能是文件的類型太復雜，譬如說二進制文件，上述操作的意義不大。如果僅僅要對文本文件進行上述操作，完全可以先把文件的內容讀取到字符串中，再用相應的字符串函數(shù)或方法去操作就可以了。譬如，要將test.txt文件中的字符串‘Python’替換為’PHP’，則可以用如下代碼完成：
txt1=''
with open('test.txt','r',encoding='utf-8') as f:
txt1=f.read() #先將文件內容存入字符串txt1中
txt2=txt1.replace('Python','PHP') #將txt1中的'Python'替換為'PHP'，并存入txt2
with open('test.txt','w',encoding='utf-8') as f:
f.write(txt2) #將字符串txt2的內容寫回到文件中
這里之所以分兩步打開文件（第一次為r模式，第二次為w模式），而沒有采用一次讀寫（r+、w+方式），因為那樣比較容易出錯。實踐證明，將文件的讀操作和寫操作分開其實是非常正確的選擇。
目錄
眾所周知，CPU是計算機的核心，它承擔了所有的計算任務。而操作系統(tǒng)是計算機的管理者，是一個大管家，它負責任務的調度，資源的分配和管理，統(tǒng)領整個計算機硬件。應用程序是具有某種功能的程序，程序運行與操作系統(tǒng)之上
在很早的時候計算機并沒有線程這個概念，但是隨著時代的發(fā)展，只用進程來處理程序出現(xiàn)很多的不足。如當一個進程堵塞時，整個程序會停止在堵塞處，并且如果頻繁的切換進程，會浪費系統(tǒng)資源。所以線程出現(xiàn)了
線程是能擁有資源和獨立運行的最小單位，也是程序執(zhí)行的最小單位。一個進程可以擁有多個線程，而且屬于同一個進程的多個線程間會共享該進行的資源
① 200 多本 Python 電子書（和經(jīng)典的書籍）應該有
② Python標準庫資料（最全中文版）
③ 項目源碼（四五十個有趣且可靠的練手項目及源碼）
④ Python基礎入門、爬蟲、網(wǎng)絡開發(fā)、大數(shù)據(jù)分析方面的視頻（適合小白學習）
⑤ Python學習路線圖（告別不入流的學習）
私信我01即可獲取大量Python學習資源
進程時一個具有一定功能的程序在一個數(shù)據(jù)集上的一次動態(tài)執(zhí)行過程。進程由程序，數(shù)據(jù)集合和進程控制塊三部分組成。程序用于描述進程要完成的功能，是控制進程執(zhí)行的指令集；數(shù)據(jù)集合是程序在執(zhí)行時需要的數(shù)據(jù)和工作區(qū)；程序控制塊（PCB）包含程序的描述信息和控制信息，是進程存在的唯一標志
在Python中，通過兩個標準庫 thread 和 Threading 提供對線程的支持, threading 對 thread 進行了封裝。 threading 模塊中提供了 Thread , Lock , RLOCK , Condition 等組件
在Python中線程和進程的使用就是通過 Thread 這個類。這個類在我們的 thread 和 threading 模塊中。我們一般通過 threading 導入
默認情況下，只要在解釋器中，如果沒有報錯，則說明線程可用
守護模式：
現(xiàn)在我們程序代碼中，有多個線程， 并且在這個幾個線程中都會去 操作同一部分內容，那么如何實現(xiàn)這些數(shù)據(jù)的共享呢？
這時，可以使用 threading庫里面的鎖對象 Lock 去保護
Lock 對象的acquire方法 是申請鎖
每個線程在操作共享數(shù)據(jù)對象之前，都應該申請獲取操作權，也就是調用該共享數(shù)據(jù)對象對應的鎖對象的acquire方法，如果線程A 執(zhí)行了 acquire() 方法，別的線程B 已經(jīng)申請到了這個鎖， 并且還沒有釋放，那么 線程A的代碼就在此處 等待 線程B 釋放鎖，不去執(zhí)行后面的代碼。
直到線程B 執(zhí)行了鎖的 release 方法釋放了這個鎖， 線程A 才可以獲取這個鎖，就可以執(zhí)行下面的代碼了
如：
到在使用多線程時，如果數(shù)據(jù)出現(xiàn)和自己預期不符的問題，就可以考慮是否是共享的數(shù)據(jù)被調用覆蓋的問題
使用 threading 庫里面的鎖對象 Lock 去保護
Python中的多進程是通過multiprocessing包來實現(xiàn)的，和多線程的threading.Thread差不多，它可以利用multiprocessing.Process對象來創(chuàng)建一個進程對象。這個進程對象的方法和線程對象的方法差不多也有start(), run(), join()等方法，其中有一個方法不同Thread線程對象中的守護線程方法是setDeamon，而Process進程對象的守護進程是通過設置daemon屬性來完成的
守護模式：
其使用方法和線程的那個 Lock 使用方法類似
Manager的作用是提供多進程共享的全局變量，Manager()方法會返回一個對象，該對象控制著一個服務進程，該進程中保存的對象運行其他進程使用代理進行操作
語法：
線程池的基類是 concurrent.futures 模塊中的 Executor ， Executor 提供了兩個子類，即 ThreadPoolExecutor 和 ProcessPoolExecutor ，其中 ThreadPoolExecutor 用于創(chuàng)建線程池，而 ProcessPoolExecutor 用于創(chuàng)建進程池
如果使用線程池/進程池來管理并發(fā)編程，那么只要將相應的 task 函數(shù)提交給線程池/進程池，剩下的事情就由線程池/進程池來搞定
Exectuor 提供了如下常用方法：
程序將 task 函數(shù)提交（submit）給線程池后，submit 方法會返回一個 Future 對象，F(xiàn)uture 類主要用于獲取線程任務函數(shù)的返回值。由于線程任務會在新線程中以異步方式執(zhí)行，因此，線程執(zhí)行的函數(shù)相當于一個“將來完成”的任務，所以 Python 使用 Future 來代表
Future 提供了如下方法：
使用線程池來執(zhí)行線程任務的步驟如下：
最佳線程數(shù)目 = （（線程等待時間+線程CPU時間）/線程CPU時間 ）* CPU數(shù)目
也可以低于 CPU 核心數(shù)
使用線程池來執(zhí)行線程任務的步驟如下：
關于進程的開啟代碼一定要放在 if __name__ == '__main__': 代碼之下，不能放到函數(shù)中或其他地方
開啟進程的技巧
開啟進程的數(shù)量最好低于最大 CPU 核心數(shù)
假如有一個py文件如下
另一個py文件如下
他們的 執(zhí)行順序 是這樣的：
并且！
config.py 里面的全局變量 parser 是一直存在的！可以被 get_config() 調用的！
目錄
許多編程語言都有一個特殊的函數(shù)，當操作系統(tǒng)開始運行程序時會自動執(zhí)行該函數(shù)。這個函數(shù)通常被命名為main()，并且依據(jù)語言標準具有特定的返回類型和參數(shù)。另一方面，Python解釋器從文件頂部開始執(zhí)行腳本，并且沒有自動執(zhí)行的特殊函數(shù)。
盡管如此，為程序的執(zhí)行定義一個起始點有助于理解程序是如何運行的。Python程序員提出了幾種方式對此進行實現(xiàn)。
本文結束時，您將了解以下內容：
Python中的基本main()函數(shù)
一些Python腳本中，包含一個函數(shù)定義和一個條件語句，如下所示：
此代碼中，包含一個main()函數(shù)，在程序執(zhí)行時打印Hello World!。此外，還包含一個條件（或if）語句，用于檢查__name__的值并將其與字符串"__main__"進行比較。當if語句為True時，Python解釋器將執(zhí)行main()函數(shù)。更多關于Python條件語句的信息可以由此獲得。
這種代碼模式在Python文件中非常常見，它將作為腳本執(zhí)行并導入另一個模塊。為了幫助理解這段代碼的執(zhí)行方式，首先需要了解Python解釋器如何根據(jù)代碼的執(zhí)行方式設置__name__。
Python中的執(zhí)行模式
Python解釋器執(zhí)行代碼有兩種方式：
更多內容可參考如何運行Python腳本。無論采用哪種方式，Python都會定義一個名為__name__的特殊變量，該變量包含一個字符串，其值取決于代碼的使用方式。
本文將如下示例文件保存為execution_methods.py，以 探索 代碼如何根據(jù)上下文改變行為：
在此文件中，定義了三個對print()函數(shù)的調用。前兩個打印一些介紹性短語。第三個print()會先打印短語The value __name__ is，之后將使用Python內置的repr()函數(shù)打印出__name__變量。
在Python中，repr()函數(shù)將對象轉化為供解釋器讀取的形式。上述示例通過使用repr()函數(shù)來強調__name__的值為字符串。更多關于repr()的內容可參考Python文檔。
在本文中，您將隨處可見文件(file)，模塊(module)和腳本(script)這三個字眼。實際上，三者之間并無太大的差別。不過，在強調代碼目的時，還是存在細微的差異：
“如何運行Python腳本”一文也討論了三者的差別。
基于命令行執(zhí)行
在這類方法中，Python腳本將通過命令行來執(zhí)行。
執(zhí)行腳本時，無法與Python解釋器正在執(zhí)行的代碼交互。關于如何通過命令行執(zhí)行代碼的詳細信息對本文而言并不重要，但您可以通過展開下框閱讀更多有關Windows，Linux和macOS之間命令行差異的內容。
命令行環(huán)境
不同的操作系統(tǒng)在使用命令行執(zhí)行代碼時存在細微的差異。
在Linux和macOS中，通常使用如下命令：
美元符號($)之前的內容可能有所不同，具體取決于您的用戶名和計算機名稱。您鍵入的命令位于$之后。在Linux或macOS上，Python3的可執(zhí)行文件名為python3，因此可以通過輸入python3 script_name.py來運行python腳本。
在Windows上，命令提示符通常如下所示：
根據(jù)您的用戶名，之前的內容可能會有所不同，您輸入的命令位于之后。在Windows上，Python3的可執(zhí)行文件通常為python。因此可以通過輸入python script_name.py來運行python腳本。
無論哪種操作系統(tǒng)，本文的Python腳本的輸出結果都是相同的。因此本文以Linux和macOS為例。
使用命令行執(zhí)行execution_methods.py，如下所示：
在這個示例中，__name__具有值'__main__'，其中引號(')表明該值為字符串類型。
請記住，在Python中，使用單引號(')和雙引號(")定義的字符串沒有區(qū)別。更多關于字符串的內容請參考Python的基本數(shù)據(jù)類型。
如果在腳本中包含"shebang行"并直接執(zhí)行它(./execution_methods.py)，或者使用IPython或Jupyter Notebook的%run，將會獲取相同的結果。
您還可以通過向命令行添加-m參數(shù)的方法實現(xiàn)以模塊的方式執(zhí)行。通常情況下，推薦如下方式pip: python3 -m pip install package_name。
添加-m參數(shù)將會運行包中__main__.py的代碼。更多關于__main__.py文件的內容可參考如何將開源Python包發(fā)布到PyPI中。
在三種情況中，__name__都具有相同的值：字符串'__main__'。
技術細節(jié)：Python文檔中具體定義了__name__何時取值為'__main__'。
當通過標準輸入，腳本或者交互提示中讀取數(shù)據(jù)時，模塊的__name__將取值為'__main__'。（來源）
__name__與__doc__，__package__和其他屬性一起存儲在模塊的全局命名空間。更多關于屬性的信息可參考Python數(shù)據(jù)模型文檔，特別是關于模塊和包的信息，請參閱Python Import文檔。
導入模塊或解釋器
接下來是Python解釋器執(zhí)行代碼的第二種方式：導入。在開發(fā)模塊或腳本時，可以使用import關鍵字導入他人已經(jīng)構建的模塊。
在導入過程中，Python執(zhí)行指定模塊中定義的語句（但僅在第一次導入模塊時）。要演示導入execution_methods.py文件的結果，需要啟動Python解釋器，然后導入execution_methods.py文件：
在此代碼輸出中，Python解釋器執(zhí)行了三次print()函數(shù)調用。前兩行由于沒有變量，在輸出方面與在命令行上作為腳本執(zhí)行時完全相同。但是第三個輸出存在差異。
當Python解釋器導入代碼時，__name__的值與要導入的模塊的名稱相同。您可以通過第三行的輸出了解這一點。__name__的值為'execution_methods'，是Python導入的.py文件。
注意如果您在沒有退出Python時再次導入模塊，將不會有輸出。
注意：更多關于導入在Python中如何工作的內容請參考官方文檔和Python中的絕對和相對導入。
Main函數(shù)的最佳實踐
既然您已經(jīng)了解兩種執(zhí)行方式上的差異，那么掌握一些最佳實踐方案還是很有用的。它們將適用于編寫作為腳本運行的代碼或者在另一個模塊導入的代碼。
如下是四種實踐方式：
將大部分代碼放入函數(shù)或類中
請記住，Python解釋器在導入模塊時會執(zhí)行模塊中的所有代碼。有時如果想要實現(xiàn)用戶可控的代碼，會導致一些副作用，例如：
在這種情況下，想要實現(xiàn)用戶控制觸發(fā)此代碼的執(zhí)行，而不是讓Python解釋器在導入模塊時執(zhí)行代碼。
因此，最佳方法是將大部分代碼包含在函數(shù)或類中。這是因為當Python解釋器遇到def或class關鍵字時，它只存儲這些定義供以后使用，并且在用戶通知之前不會實際執(zhí)行。
將如下代碼保存在best_practices.py以證明這個想法：
在此代碼中，首先從time模塊中導入sleep()。
在這個示例中，參數(shù)以秒的形式傳入sleep()函數(shù)中，解釋器將暫停一段時間再運行。隨后，使用print()函數(shù)打印關于代碼描述的語句。
之后，定義一個process_data()函數(shù)，執(zhí)行如下五項操作：
在命令行中執(zhí)行
當你將此文件作為腳本用命令行執(zhí)行時會發(fā)生什么呢？
Python解釋器將執(zhí)行函數(shù)定義之外的from time import sleep和print()，之后將創(chuàng)建函數(shù)process_data()。然后，腳本將退出而不做任何進一步的操作，因為腳本沒有任何執(zhí)行process_data()的代碼。
如下是這段腳本的執(zhí)行結果：
我們在這里看到的輸出是第一個print()的結果。注意，從time導入和定義process_data()函數(shù)不產(chǎn)生結果。具體來說，調用定義在process_data()內部的print()不會打印結果。
導入模塊或解釋器執(zhí)行
在會話（或其他模塊）中導入此文件時，Python解釋器將執(zhí)行相同的步驟。
Python解釋器導入文件后，您可以使用已導入模塊中定義的任何變量，類或函數(shù)。為了證明這一點，我們將使用可交互的Python解釋器。啟動解釋器，然后鍵入import best_practices：
導入best_practices.py后唯一的輸出來自process_data()函數(shù)外定義的print()。導入模塊或解釋器執(zhí)行與基于命令行執(zhí)行類似。
使用__name__控制代碼的執(zhí)行
如何實現(xiàn)基于命令行而不使用Python解釋器導入文件來執(zhí)行呢？
您可以使用__name__來決定執(zhí)行上下文，并且當__name__等于"__main__"時才執(zhí)行process_data()。在best_practices.py文件中添加如下代碼：
這段代碼添加了一個條件語句來檢驗__name__的值。當值為"__main__"時，條件為True。記住當__name__變量的特殊值為"__main__"時意味著Python解釋器會執(zhí)行腳本而不是將其導入。
條件語塊內添加了四行代碼（第12，13，14和15行）：
現(xiàn)在，在命令行中運行best_practices.py，并觀察輸出的變化：
首先，輸出顯示了process_data()函數(shù)外的print()的調用結果。
之后，data的值被打印。因為當Python解釋器將文件作為腳本執(zhí)行時，變量__name__具有值"__main__"，因此條件語句被計算為True。
接下來，腳本將調用process_data()并傳入data進行修改。當process_data執(zhí)行時，將輸出一些狀態(tài)信息。最終，將輸出modified_data的值。
現(xiàn)在您可以驗證從解釋器（或其他模塊）導入best_practices.py后發(fā)生的事情了。如下示例演示了這種情況：
注意，當前結果與將條件語句添加到文件末尾之前相同。因為此時__name__變量的值為"best_practices"，因此條件語句結果為False，Python將不執(zhí)行process_data()。
創(chuàng)建名為main()的函數(shù)來包含要運行的代碼
現(xiàn)在，您可以編寫作為腳本由從命令行執(zhí)行并導入且沒有副作用的Python代碼。接下來，您將學習如何編寫代碼并使其他程序員能輕松地理解其含義。
許多語言，如C，C++，Java以及其他的一些語言，都會定義一個叫做main()的函數(shù)，當編譯程序時，操作系統(tǒng)會自動調用該函數(shù)。此函數(shù)通常被稱為入口點(entry point)，因為它是程序進入執(zhí)行的起始位置。
相比之下，Python沒有一個特殊的函數(shù)作為腳本的入口點。實際上在Python中可以將入口點定義成任何名稱。
盡管Python不要求將函數(shù)命名為main()，但是最佳的做法是將入口點函數(shù)命名為main()。這樣方便其他程序員定位程序的起點。
此外，main()函數(shù)應該包含Python解釋器執(zhí)行文件時要運行的任何代碼。這比將代碼放入條件語塊中更好，因為用戶可以在導入模塊時重復使用main()函數(shù)。
修改best_practices.py文件如下所示：
在這個示例中，定義了一個main()函數(shù)，它包含了上面的條件語句塊。之后修改條件語塊執(zhí)行main()。如果您將此代碼作為腳本運行或導入，將獲得與上一節(jié)相同的輸出。
在main()中調用其他函數(shù)
另一種常見的實現(xiàn)方式是在main()中調用其他函數(shù)，而不是直接將代碼寫入main()。這樣做的好處在于可以實現(xiàn)將幾個獨立運行的子任務整合。
例如，某個腳本有如下功能：
如果在單獨的函數(shù)中各自實現(xiàn)這些子任務，您（或其他用戶）可以很容易地實現(xiàn)代碼重用。之后您可以在main()函數(shù)中創(chuàng)建默認的工作流。
您可以根據(jù)自己的情況選擇是否使用此方案。將任務拆分為多個函數(shù)會使重用更容易，但會增加他人理解代碼的難度。
修改best_practices.py文件如下所示：
在此示例代碼中，文件的前10行具有與之前相同的內容。第12行的第二個函數(shù)創(chuàng)建并返回一些示例數(shù)據(jù)，第17行的第三個函數(shù)模擬將修改后的數(shù)據(jù)寫入數(shù)據(jù)庫。
第21行定義了main()函數(shù)。在此示例中，對main()做出修改，它將調用數(shù)據(jù)讀取，數(shù)據(jù)處理以及數(shù)據(jù)寫入等功能。
首先，從read_data_from_web()中創(chuàng)建data。將data作為參數(shù)傳入process_data()，之后將返回modified_data。最后，將modified_data傳入write_data_to_database()。
腳本的最后兩行是條件語塊用于驗證__name__，并且如果if語句為True，則執(zhí)行main()。
在命令行中運行如下所示：
根據(jù)執(zhí)行結果，Python解釋器在執(zhí)行main()函數(shù)時，將依次執(zhí)行read_data_from_web()，process_data()以及write_data_to_database()。當然，您也可以導入best_practices.py文件并重用process_data()作為不同的數(shù)據(jù)輸入源，如下所示：
在此示例中，導入了best_practices并且將其簡寫為bp。
導入過程會導致Python解釋器執(zhí)行best_practices.py的全部代碼，因此輸出顯示解釋文件用途的信息。
然后，從文件中存儲數(shù)據(jù)而不是從Web中讀取數(shù)據(jù)。之后，可以重用best_practices.py文件中的process_data()和write_data_to_database()函數(shù)。在此情況下，可以利用代碼重寫來取代在main()函數(shù)中實現(xiàn)全部的代碼邏輯。
實踐總結
以下是Python中main()函數(shù)的四個關鍵最佳實踐：
結論
恭喜！您現(xiàn)在已經(jīng)了解如何創(chuàng)建Python main()函數(shù)了。
本文介紹了如下內容：
現(xiàn)在，您可以開始編寫一些非常棒的關于Python main()函數(shù)代碼啦！
重慶分公司
重慶分公司
