python腳本運行錯誤

❶ Jenkins運行python腳本報錯

一、Jenkins定時運行python腳本

1、10分鍾運行一次：

2、運行python腳本：

二、構建報錯

1、報錯如下：

2、原因：Jenkins啟動的時候，用戶名是SYSTEM，而我們安裝Python默認添加的環境變數是在用戶變數中的。所以Jenkins拿不到我們用戶配置的環境變數。

3、解決：在系統變數Path添加如下路徑，然後重啟Jenkins：

4、參考鏈接： https://blog.csdn.net/bihansheng2010/article/details/51259849

三、輸出中文亂碼

1、亂碼如下：

2、原因：Jenkins找的python編碼格式不支持中文輸出。

3、解決：添加系統環境變數PYTHONIOENCODING，值為UTF-8

4、這個時候Jenkins的環境變數就會多了以下一行，重啟Jenkins即可：

5、重新構建：輸出中文正常。

6、參考鏈接： https://www.cnblogs.com/zhangyesmile/p/11195656.html

❷ python程序運行時報錯，怎麼處理

1.異常種類

python中的異常種類非常多，每個異常專門用於處理某一項異常！！！

下面是一些常用的異常：

❸ 我執行一段python腳本報錯了，怎麼解決

在程序運行的過程中，如果發生了錯誤，可以事先約定返回一個錯誤代碼，這樣，就可以知道是否有錯，以及出錯的原因。在操作系統提供的調用中，返回錯誤碼非常常見。比如打開文件的函數open()，成功時返迴文件描述符（就是一個整數），出錯時返回-1。
用錯誤碼來表示是否出錯十分不便，因為函數本身應該返回的正常結果和錯誤碼混在一起，造成調用者必須用大量的代碼來判斷是否出錯：

復制代碼代碼如下:

def foo():
r = some_function()
if r==(-1):
return (-1)
# do something
return r

def bar():
r = foo()
if r==(-1):
print 'Error'
else:
pass

一旦出錯，還要一級一級上報，直到某個函數可以處理該錯誤（比如，給用戶輸出一個錯誤信息）。

所以高級語言通常都內置了一套try...except...finally...的錯誤處理機制，Python也不例外。
try
讓我們用一個例子來看看try的機制：

復制代碼代碼如下:

try:
print 'try...'
r = 10 / 0
print 'result:', r
except ZeroDivisionError, e:
print 'except:', e
finally:
print 'finally...'
print 'END'

當我們認為某些代碼可能會出錯時，就可以用try來運行這段代碼，如果執行出錯，則後續代碼不會繼續執行，而是直接跳轉至錯誤處理代碼，即except語句塊，執行完except後，如果有finally語句塊，則執行finally語句塊，至此，執行完畢。

上面的代碼在計算10 / 0時會產生一個除法運算錯誤：

復制代碼代碼如下:

try...
except: integer division or molo by zero
finally...
END

從輸出可以看到，當錯誤發生時，後續語句print 'result:', r不會被執行，except由於捕獲到ZeroDivisionError，因此被執行。最後，finally語句被執行。然後，程序繼續按照流程往下走。

如果把除數0改成2，則執行結果如下：

復制代碼代碼如下:

try...
result: 5
finally...
END

由於沒有錯誤發生，所以except語句塊不會被執行，但是finally如果有，則一定會被執行（可以沒有finally語句）。

你還可以猜測，錯誤應該有很多種類，如果發生了不同類型的錯誤，應該由不同的except語句塊處理。沒錯，可以有多個except來捕獲不同類型的錯誤：

復制代碼代碼如下:

try:
print 'try...'
r = 10 / int('a')
print 'result:', r
except ValueError, e:
print 'ValueError:', e
except ZeroDivisionError, e:
print 'ZeroDivisionError:', e
finally:
print 'finally...'
print 'END'

int()函數可能會拋出ValueError，所以我們用一個except捕獲ValueError，用另一個except捕獲ZeroDivisionError。

此外，如果沒有錯誤發生，可以在except語句塊後面加一個else，當沒有錯誤發生時，會自動執行else語句：

復制代碼代碼如下:

try:
print 'try...'
r = 10 / int('a')
print 'result:', r
except ValueError, e:
print 'ValueError:', e
except ZeroDivisionError, e:
print 'ZeroDivisionError:', e
else:
print 'no error!'
finally:
print 'finally...'
print 'END'

Python的錯誤其實也是class，所有的錯誤類型都繼承自BaseException，所以在使用except時需要注意的是，它不但捕獲該類型的錯誤，還把其子類也「一網打盡」。比如：

復制代碼代碼如下:

try:
foo()
except StandardError, e:
print 'StandardError'
except ValueError, e:
print 'ValueError'

第二個except永遠也捕獲不到ValueError，因為ValueError是StandardError的子類，如果有，也被第一個except給捕獲了。

Python所有的錯誤都是從BaseException類派生的
使用try...except捕獲錯誤還有一個巨大的好處，就是可以跨越多層調用，比如函數main()調用foo()，foo()調用bar()，結果bar()出錯了，這時，只要main()捕獲到了，就可以處理：

復制代碼代碼如下:

def foo(s):
return 10 / int(s)

def bar(s):
return foo(s) * 2
def main():
try:
bar('0')
except StandardError, e:
print 'Error!'
finally:
print 'finally...'

也就是說，不需要在每個可能出錯的地方去捕獲錯誤，只要在合適的層次去捕獲錯誤就可以了。這樣一來，就大大減少了寫try...except...finally的麻煩。

調用堆棧
如果錯誤沒有被捕獲，它就會一直往上拋，最後被Python解釋器捕獲，列印一個錯誤信息，然後程序退出。來看看err.py：

復制代碼代碼如下:

# err.py:
def foo(s):
return 10 / int(s)

def bar(s):
return foo(s) * 2
def main():
bar('0')
main()

執行，結果如下：

復制代碼代碼如下:

$ python err.py
Traceback (most recent call last):
File "err.py", line 11, in <mole>
main()
File "err.py", line 9, in main
bar('0')
File "err.py", line 6, in bar
return foo(s) * 2
File "err.py", line 3, in foo
return 10 / int(s)
ZeroDivisionError: integer division or molo by zero

出錯並不可怕，可怕的是不知道哪裡出錯了。解讀錯誤信息是定位錯誤的關鍵。我們從上往下可以看到整個錯誤的調用函數鏈：

錯誤信息第1行：

復制代碼代碼如下:

Traceback (most recent call last):

告訴我們這是錯誤的跟蹤信息。

第2行：

復制代碼代碼如下:

File "err.py", line 11, in <mole>
main()

調用main()出錯了，在代碼文件err.py的第11行代碼，但原因是第9行：

復制代碼代碼如下:

File "err.py", line 9, in main
bar('0')

調用bar('0')出錯了，在代碼文件err.py的第9行代碼，但原因是第6行：

復制代碼代碼如下:

File "err.py", line 6, in bar
return foo(s) * 2

原因是return foo(s) * 2這個語句出錯了，但這還不是最終原因，繼續往下看：

復制代碼代碼如下:

File "err.py", line 3, in foo
return 10 / int(s)

原因是return 10 / int(s)這個語句出錯了，這是錯誤產生的源頭，因為下面列印了：

復制代碼代碼如下:

ZeroDivisionError: integer division or molo by zero

根據錯誤類型ZeroDivisionError，我們判斷，int(s)本身並沒有出錯，但是int(s)返回0，在計算10 / 0時出錯，至此，找到錯誤源頭。

記錄錯誤
如果不捕獲錯誤，自然可以讓Python解釋器來列印出錯誤堆棧，但程序也被結束了。既然我們能捕獲錯誤，就可以把錯誤堆棧列印出來，然後分析錯誤原因，同時，讓程序繼續執行下去。
Python內置的logging模塊可以非常容易地記錄錯誤信息：

復制代碼代碼如下:

# err.py
import logging

def foo(s):
return 10 / int(s)
def bar(s):
return foo(s) * 2
def main():
try:
bar('0')
except StandardError, e:
logging.exception(e)
main()
print 'END'

同樣是出錯，但程序列印完錯誤信息後會繼續執行，並正常退出：

復制代碼代碼如下:

$ python err.py
ERROR:root:integer division or molo by zero
Traceback (most recent call last):
File "err.py", line 12, in main
bar('0')
File "err.py", line 8, in bar
return foo(s) * 2
File "err.py", line 5, in foo
return 10 / int(s)
ZeroDivisionError: integer division or molo by zero
END

通過配置，logging還可以把錯誤記錄到日誌文件里，方便事後排查。

拋出錯誤
因為錯誤是class，捕獲一個錯誤就是捕獲到該class的一個實例。因此，錯誤並不是憑空產生的，而是有意創建並拋出的。Python的內置函數會拋出很多類型的錯誤，我們自己編寫的函數也可以拋出錯誤。
如果要拋出錯誤，首先根據需要，可以定義一個錯誤的class，選擇好繼承關系，然後，用raise語句拋出一個錯誤的實例：

復制代碼代碼如下:

# err.py
class FooError(StandardError):
pass

def foo(s):
n = int(s)
if n==0:
raise FooError('invalid value: %s' % s)
return 10 / n

執行，可以最後跟蹤到我們自己定義的錯誤：

復制代碼代碼如下:

$ python err.py
Traceback (most recent call last):
...
__main__.FooError: invalid value: 0

只有在必要的時候才定義我們自己的錯誤類型。如果可以選擇Python已有的內置的錯誤類型（比如ValueError，TypeError），盡量使用Python內置的錯誤類型。

最後，我們來看另一種錯誤處理的方式：

復制代碼代碼如下:

# err.py
def foo(s):
n = int(s)
return 10 / n

def bar(s):
try:
return foo(s) * 2
except StandardError, e:
print 'Error!'
raise
def main():
bar('0')
main()

在bar()函數中，我們明明已經捕獲了錯誤，但是，列印一個Error!後，又把錯誤通過raise語句拋出去了，這不有病么？

其實這種錯誤處理方式不但沒病，而且相當常見。捕獲錯誤目的只是記錄一下，便於後續追蹤。但是，由於當前函數不知道應該怎麼處理該錯誤，所以，最恰當的方式是繼續往上拋，讓頂層調用者去處理。
raise語句如果不帶參數，就會把當前錯誤原樣拋出。此外，在except中raise一個Error，還可以把一種類型的錯誤轉化成另一種類型：

復制代碼代碼如下:

try:
10 / 0
except ZeroDivisionError:
raise ValueError('input error!')

只要是合理的轉換邏輯就可以，但是，決不應該把一個IOError轉換成毫不相乾的ValueError。

小結
Python內置的try...except...finally用來處理錯誤十分方便。出錯時，會分析錯誤信息並定位錯誤發生的代碼位置才是最關鍵的。
程序也可以主動拋出錯誤，讓調用者來處理相應的錯誤。但是，應該在文檔中寫清楚可能會拋出哪些錯誤，以及錯誤產生的原因。

❹ linux python運行報編碼錯誤

一次重啟伺服器後，supervisor接管的python腳本中的函數 open() 和 print() 都會報下面的編碼錯誤：
UnicodeEncodeError: 'ascii' codec can't encode

使用的是python3，按理說編碼都會默認utf-8，而且本地運行的python腳本並沒有這個問題。

經大佬指點，增加環境變數 export LC_ALL="en_US.UTF-8" 後，再重啟supervisor，問題解決

下面是復制的： https://www.cnblogs.com/badboy200800/p/11215981.html

Locale是一個軟體在運行時的語言環境,。是根據計算機用戶所使用的語言，所在國家或者地區，以及當地的文化傳統所定義的。它包括語言(Language), 地域 (Territory) 和字元集(Codeset)。

一個locale的書寫格式為: 語言[ 地域[.字元集]]。完全的locale表達方式是 [語言[ 地域][.字元集] [@修正值]。例如：

zh_CN.GB2312 ＝> 中文_中華人民共和國＋國標2312字元集。

（1）locale把按照所涉及到的文化傳統的各個方面分成12個大類

（2）查看標准字元集列表

常用字元集：en_US.utf8、zh_CN.gb2312、zh_CN.gbk、zh_CN.utf8等

3.Locale的設定

LC_ALL和LANG優先順序的關系：LC_ALL > LC_* >LANG
（1）如果需要一個純中文的系統的話，設定LC_ALL= zh_CN.XXXX即可。或者設定LANG=zh_CN.XXXX也可以，但是LC_ 不要有任何特殊設定才可以（因為LC_ 優先順序高）。
（2）如果需要個性化的環境，例如只想要一個可以輸入中文的環境，而保持菜單、標題，系統信息等等為英文界面，那麼只需要設定LANG=en_US.XXXX，然後 LC_CTYPE＝zh_CN.XXXX就可以了。
（3）假如什麼也不做的話，也就是LC_ALL，LANG和LC_*均不指定特定值的話，系統將採用POSIX作為lcoale，也就是C locale。

4.查看與設定字元集實踐

（1）查看當前系統字元集三種方式（LC_ALL、LC_CTYPE和LANG），以查看LANG為例：

（2）更改系統字元集

備註：直接執行上述命令，可以臨時修改系統字元集。如果寫入環境變數可以永久改變字元集。

（3）取消當前系統字元集（設定為空）

備註：直接執行上述命令，可以臨時修改系統字元集。如果寫入環境變數可以永久改變字元集。

❺ python腳本運行錯誤原因是什麼

shelve是一個對象持久化保辯盯存方法，將對象保存到文件裡面，一般來說對象的保存和恢復都是通過shelve來進行虧灶爛的。x0dx0a你的銷漏問題是test.txt已經存在，並且格式與shelve不符，所以提示 "db type could not be determined"x0dx0a解決方法: 刪除/home/luo/python/test.txt文件，首次運行後會自動生成該文件。x0dx0a另外，預設方式數據文件是二進制的，最好不要用txt結尾來誤導別人。x0dx0ax0dx0a下面是運行結果x0dx0ax0dx0a[zx@zx-linux test]$ ./test.pyx0dx0aEner command (? for help): storex0dx0aEnter unique ID number: 1x0dx0aEnter name: 2x0dx0aEnter age: 3x0dx0aEnter phone number: 4x0dx0aEner command (? for help): quit

❻ ue5.1執行py失敗

下面是一些可能導致UE的Python執行失敗的常見原因和解決方法：

1. Python環境未正確配置：在使用Python腳本之前，請確保已將Python環境正確配置為與UE一起使用的版本，並將環境變數設置為正確的Python路徑。

2. Python腳本文件路徑錯誤：請確保您的Python腳本文件路徑正確，並且相對於UE項目或絕對路徑正確。如果不確定，請嘗試直接從命令行運行腳本以確保它有效。

3. Python腳本語法錯誤：如果您的Python腳本存在語法錯誤，則可能會春頃導致無法在UE中執行。請務必檢查腳本並修復任何語法錯誤。可以使用Python IDE（如PyCharm）來幫助檢測和修復這些錯誤。

4. 缺少所需的Python模塊：如果您的灶核Python腳本依賴於特定的Python模塊，則必須將這些模隱森掘塊導入到您的UE項目中。使用pip安裝缺少的模塊，並在UE中添加所需的模塊路徑以確保能夠在UE中使用它們。

希望這些解決方案能夠幫助您解決問題。

❼ python運行錯誤怎麼辦

1. 一、python的錯誤處理：
   
   在程序運行的過程中，如果發生了錯誤，可以事先約定返回一個錯誤代碼，這樣，就可以知道是否有錯以及出錯的原因。
   在操作系統提供的調用中，返回錯誤碼非常常見。比如打開文件的函數open()，成功時返迴文件的描述符（就是一個整數），出錯時返回-1用錯誤碼來表示是否出錯十分不便，因為函數本身應該返回的正常結果和錯誤碼混在一起，造成調用者必須大量的代碼來判斷是否出錯：def foo():
   r = somefunction() if r == (-1): return (-1) return rdef bar():
   r = foo() if r == (-1): print("Error") else: pass一旦出錯，還要一級一級上報，直到某個函數可以處理該錯誤（比如，給用戶輸出一個錯誤信息）
   
   所以，高級語言通常都內置了一套try...except...finally...的錯誤處理機制，python也不例外。try
   讓我們用一個例子來看看try的機制try: print("try....")
   r = 10 / 0 print("result", r)except ZeroDivisionError as e: print("except:", e)finally: print("finally...")print("END....")
   
   當我們認為某些代碼可能會出錯時，就可以用try來運行這段代碼，如果執行出錯，則後續代碼不會繼續執行
   而是直接跳轉至錯誤處理代碼，即except語句塊
   執行完except後，如果有finally語句塊，則執行finally語句塊，至此，執行完畢。
   
   上面的代碼在計算10 / 0時 會產生一個除法運算錯誤：try....except: division by zerofinally...
   END....>>>從輸出可以看到，當錯誤發生時，後續語句print("result:", r)不會被執行，except由於捕獲到ZeroDivisionError因此被執行。
   最後，finally語句被執行。然後，程序繼續按照流程往下走。
   
   如果把除數0 變成2，則執行結果如下try....
   result 5.0finally...
   END....>>>由於沒有錯誤發生，所以except語句塊不會被執行，但是finally如果有則一定會被執行，當然finally也可以沒有
   你還可以猜測，錯誤應該有很多種類，日過發生了不同類型的錯誤，應該由不同的except語句塊處理。
   沒錯，可以有多個except來捕獲不同類型的錯誤：try: print("try.....")
   r = 10 / int("a") print("result:", r)except ValueError as e: print("ValueError:", e)except ZeroDivisionError as e: print("ZeroDivisionError:", e)finally: print("finally...")print("END...")
   
   int()函數可能會拋出ValueError,所以我們用一個except捕獲ValueError，用另一個except捕獲ZeroDivisionError
   此外，如果沒有錯誤發生，可以再except語句塊後面加一個else，當沒有錯誤發生時，會自動執行else語句。try: print("try...")
   r = 10 / int("2") print("result:", r)except ValueError as e: print("ValueError:", e)except ZeroDivisionError as e: print("ZeroDivisionError:", e)else: print("No error!")finally: print("finally...")print("END")
   
   python的錯誤其實也是class，所有的錯誤類型都繼承自BaseException,
   所以在使用except時需要注意的是，它不但捕獲該類型的錯誤，還把其子類也「一網打盡」。
   比如：try:
   foo()except ValueError as e: print("ValueError")except UnicodeError as e: print("UnicodeError")
   
   第二個except永遠也捕獲不到UnicodeError, 因為UnicodeError是ValueError的子類
   如果有，也是被第一個except給捕獲了。
   python所有的錯誤都是BaseException類派生的。
   
   所有常見的錯誤類型和繼承關系看這里：
   https://docs.python.org/3/library/exceptions.html#exception-hierarchy使用try...exccept捕獲錯誤還有一個巨大的好處，就是可以跨越多層調用，比如函數main（）調用foo（）
   foo（）調用bar（），結果bar（）出錯了，這時，只要main（）捕獲到了，就可以處理：def foo(s): return 10 / int(s)def bar(s): return foo(s) * 2def main(): try:
   bar("0") except Exception as e: print("Error:", e) finally: print("finally...")
   
   也就是說，不需要在每個可能出錯的地方去捕獲異常，只要在合適的層次去捕獲就可以了。
   這樣一來，就大大減少了寫 try...except...finally的麻煩。
   
   
   二、調用堆棧
   
   如果錯誤沒有被捕獲，他就會一直往上拋，最後被python解釋器捕獲，列印一個錯誤信息，然後程序退出。def foo(s): return 10 / int(s)def bar(s): return foo(s) * 2def main():
   bar("0")
   
   main()
   
   執行結果為：
   
   Traceback (most recent call last):
   File "C:/Python36/test.py", line 10, in <mole>
   main()
   File "C:/Python36/test.py", line 8, in main
   bar("0")
   File "C:/Python36/test.py", line 5, in bar return foo(s) * 2
   File "C:/Python36/test.py", line 2, in foo return 10 / int(s)
   ZeroDivisionError: division by zero
   
   出錯並不可怕，可怕的時不知道哪裡出錯了。解讀錯誤信息時定位錯誤的關鍵。
   我們從上往下可以看到整個錯誤的調用函數鏈。
   
   錯誤第一行：
   Traceback (most recent call last):
   這告訴我們的是錯誤的跟蹤信息。
   
   File "C:/Python36/test.py", line 10, in < mole >main()
   說明調用main（）出錯了，在代碼文件test.py中第10行，但是原因是第8行：
   
   File"C:/Python36/test.py", line8, in main
   bar("0")
   調用bar("0")出錯了，在代碼文件test.py中第8行，但原因是第5行：
   
   
   File"C:/Python36/test.py", line5, in barreturn foo(s) * 2調用return foo(s) * 2時出錯了，在test.py中第5行，但原因是第2行
   
   
   File "C:/Python36/test.py", line 2, in foo return 10 / int(s)
   ZeroDivisionError: division by zero
   
   這時我們找到了源頭，原來在第2行調用return 10 / int(s)出錯了，錯誤為ZeroDivisionError
   
   
   三、記錄錯誤
   
   如果不捕獲錯誤，自然可以讓python解釋器來列印出錯誤堆棧，但是程序也被結束了。
   既然我們能捕獲錯誤，就可以把錯誤堆棧列印出來，然後分析錯誤原因，同時，讓程序繼續執行下去。
   
   python內置的logging模塊可以非常容易地記錄錯誤信息：import loggingdef foo(s): return 10 / int(s)def bar(s): return foo(s) * 2def main(): try:
   bar("0") except Exception as e:
   logging.exception(e)
   
   main()print("END")
   
   輸出結果為：
   ERROR:root:division by zero
   Traceback (most recent call last):
   File "C:/Python36/test.py", line 12, in main
   bar("0")
   File "C:/Python36/test.py", line 8, in bar return foo(s) * 2
   File "C:/Python36/test.py", line 5, in foo return 10 / int(s)
   ZeroDivisionError: division by zero
   END
   
   同樣是出錯，但程序列印完錯誤信息後會繼續執行，並正常退出。
   
   通過配置，logging還可以把錯誤記錄到日誌文件里，方便事後排查。
   
   
   四、拋出錯誤
   
   因為錯誤是class，捕獲一個錯誤就是捕獲到該class的一個實例。
   因此，錯誤並不是憑空產生的，而是有意創建並拋出的。
   
   python的內置函數會拋出很多類型的錯誤，我們自己編寫的函數也可以拋出錯誤。
   
   如果要拋出錯誤，首先根據需要，可以定義一個錯誤的class，選擇好繼承關系，然後用raise語句拋出一個錯誤的實例：class FooError(ValueError): passdef foo(s):
   n = int(s) if n == 0: raise FooError("invalid value: %s" % s) return 10 / n
   
   foo("0")
   
   輸出結果：
   Traceback (most recent call last):
   File "C:/Python36/test.py", line 10, in <mole>
   foo("0")
   File "C:/Python36/test.py", line 7, in foo raise FooError("invalid value: %s" % s)
   FooError: invalid value: 0
   
   只有在必要的時候才定義我們自己的錯誤類型。
   如果可以選擇python已有的內置錯誤類型（比如ValueError, TypeError）,盡量使用python內置的錯誤類型。
   
   最後，我們來看另一種錯誤處理方式：def foo(s):
   n = int(s) if n == 0: raise ValueError("invalid value: %s" % s) return 10 / ndef bar(): try:
   foo("0") except ValueError as e: print("ValieError") raisebar()
   
   在bar（）函數中，我們明明已經捕獲了錯誤，但是，列印一個ValueError之後
   又通過raise語句拋出去了。這不是有病嗎
   
   其實，這種錯誤處理方式不但沒病，而且相當常見。
   捕獲錯誤目的只是記錄一下，便於或許追蹤。
   
   但是，由於當前函數不知道應該怎麼處理該錯誤，所以，最恰當的方式是繼續往上拋，讓頂層調用者去處理。
   好比一個員工處理不了一個問題時，就把問題一直往上拋，最終會拋給CEO去解決。
   
   注意：raise語句如果不帶參數，就會把當前錯誤原樣拋出。
   此外，在except中raise一個Error，還可以改寫錯誤類型try: 10 / 0except ZeroDivisionError: raise ValueError("do not input zero!")
   
   輸出結果：
   Traceback (most recent call last):
   File "C:/Python36/test.py", line 4, in <mole> raise ValueError("do not input zero!")
   ValueError: do not input zero!>>>只要是合理的轉換邏輯就可以，但是，絕不應該把一個IOError轉成毫不相乾的valueError.
   
   總結：
   
   python內置的 try...except...finally 用來處理錯誤十分方便。
   出錯時，會分析錯誤信息並定位錯誤發生的代碼位置才是關鍵的。
   
   程序也可以主動拋出錯誤，讓調用者來處理相應的錯誤。
   但是應該在文檔中寫清楚可能會拋出哪些錯誤，以及錯誤產生的原因。
   

❽ 為什麼python運行失敗

python運行失敗，可能包含多方面原因，建議從以下方面檢測：
1、Python開發環境沒有正確配置
2、Python代碼語法錯誤，如大小寫、縮進等
3、腳本文件的路徑存在問題
4、網路問題，如斷網，網線插口松動等
當然，運行失敗的原因遠不止這些，很多問題還需要在實際的項目中去解決，更多學習內容，請點擊Python學習網！