python主動拋異常

Ⅰ MySQL-python連接MySQL資料庫問題，總是拋異常。

不要剛開始學多線程編程就這樣玩。connection 和 cursor 都不是線程安全的。

如果測試環境用多個線程，每個線程要在線程裡面獲取自己的 connection，然後從這個connection 獲取 cursor.

如果生產環境用多個線程，建議使用線程安全的連接池。

Ⅱ Python程序出錯！求解！

錯誤分為語法錯誤和邏輯錯誤

1、語法錯誤

程序執行過程中，python解釋器會檢測你的程序是否存在語法錯誤，如果程序出錯python解釋器會指出出錯的一行，並且在最先找到的，錯誤的文職標記了一個小小的箭頭。

2、邏輯錯誤

在生活中0是不能作為被除數的，程序寫的語法可能沒問題，但是邏輯上不一定沒有問題，這就是一種邏輯錯誤。

異常處理方法：

Python內置的try...except...finally用來處理錯誤十分方便，出錯時，會分析錯誤信息並定位錯誤發生的代碼位置才是最關鍵的。

程序也可以主動拋出錯誤，讓調用者來處理相應的錯誤，但是，應該在文檔中寫清楚可能會拋出哪些錯誤，以及錯誤產生的原因。

(2)python主動拋異常擴展閱讀：

實例：下面是簡單的例子，它打開一個文件，在該文件中的內容寫入內容，但文件沒有寫入許可權，發生了異常：

#!/usr/bin/python#-*-coding:UTF-8-*-try:

fh=open("testfile","w")

fh.write("這是一個測試文件，用於測試異常!!")exceptIOError:

print"Error:沒有找到文件或讀取文件失敗"else:

print"內容寫入文件成功"

fh.close()

在執行代碼前為了測試方便，我們可以先去掉testfile文件的寫許可權，命令如下：

chmod-wtestfile

再執行以上代碼：

$pythontest.py

Error:沒有找到文件或讀取文件失敗

Ⅲ 如何解決的Python類型錯誤

1.Python異常類

Python是面向對象語言，所以程序拋出的異常也是類。常見的Python異常有以下幾個，大家只要大致掃一眼，有個映像，等到編程的時候，相信大家肯定會不只一次跟他們照面（除非你不用Python了）。

異常 描述
NameError 嘗試訪問一個沒有申明的變數
ZeroDivisionError 除數為0
SyntaxError 語法錯誤
IndexError 索引超出序列范圍
KeyError 請求一個不存在的字典關鍵字
IOError 輸入輸出錯誤（比如你要讀的文件不存在）
AttributeError 嘗試訪問未知的對象屬性
ValueError 傳給函數的參數類型不正確，比如給int()函數傳入字元串形
2.捕獲異常
Python完整的捕獲異常的語句有點像：
復制代碼 代碼如下:

try:
try_suite
except Exception1,Exception2,...,Argument:
exception_suite
...... #other exception block
else:
no_exceptions_detected_suite
finally:
always_execute_suite

額...是不是很復雜？當然，當我們要捕獲異常的時候，並不是必須要按照上面那種格式完全寫下來，我們可以丟掉else語句，或者finally語句；甚至不要exception語句，而保留finally語句。額，暈了？好吧，下面，我們就來一一說明啦。
2.1.try...except...語句
try_suite不消我說大家也知道，是我們需要進行捕獲異常的代碼。而except語句是關鍵，我們try捕獲了代碼段try_suite里的異常後，將交給except來處理。
try...except語句最簡單的形式如下：
復制代碼 代碼如下:

try:
try_suite
except:
exception block

上面except子句不跟任何異常和異常參數，所以無論try捕獲了任何異常，都將交給except子句的exception block來處理。如果我們要處理特定的異常，比如說，我們只想處理除零異常，如果其他異常出現，就讓其拋出不做處理，該怎麼辦呢？這個時候，我們就要給except子句傳入異常參數啦！那個ExceptionN就是我們要給except子句的異常類（請參考異常類那個表格），表示如果捕獲到這類異常，就交給這個except子句來處理。比如：
復制代碼 代碼如下:

try:
try_suite
except Exception:
exception block

舉個例子：
復制代碼 代碼如下:

>>> try:
... res = 2/0
... except ZeroDivisionError:
... print "Error:Divisor must not be zero!"
...
Error:Divisor must not be zero!

看，我們真的捕獲到了ZeroDivisionError異常！那如果我想捕獲並處理多個異常怎麼辦呢？有兩種辦法，一種是給一個except子句傳入多個異常類參數，另外一種是寫多個except子句，每個子句都傳入你想要處理的異常類參數。甚至，這兩種用法可以混搭呢！下面我就來舉個例子。
復制代碼 代碼如下:

try:
floatnum = float(raw_input("Please input a float:"))
intnum = int(floatnum)
print 100/intnum
except ZeroDivisionError:
print "Error:you must input a float num which is large or equal then 1!"
except ValueError:
print "Error:you must input a float num!"
[root@Cherish tmp]# python test.py
Please input a float:fjia
Error:you must input a float num!
[root@Cherish tmp]# python test.py
Please input a float:0.9999
Error:you must input a float num which is large or equal then 1!
[root@Cherish tmp]# python test.py
Please input a float:25.091
4

上面的例子大家一看都懂，就不再解釋了。只要大家明白，我們的except可以處理一種異常，多種異常，甚至所有異常就可以了。
大家可能注意到了，我們還沒解釋except子句後面那個Argument是什麼東西？別著急，聽我一一道來。這個Argument其實是一個異常類的實例（別告訴我你不知到什麼是實例），包含了來自異常代碼的診斷信息。也就是說，如果你捕獲了一個異常，你就可以通過這個異常類的實例來獲取更多的關於這個異常的信息。例如：
復制代碼 代碼如下:

>>> try:
... 1/0
... except ZeroDivisionError,reason:
... pass
...
>>> type(reason)
<type 'exceptions.ZeroDivisionError'>
>>> print reason
integer division or molo by zero
>>> reason
ZeroDivisionError('integer division or molo by zero',)
>>> reason.__class__
<type 'exceptions.ZeroDivisionError'>
>>> reason.__class__.__doc__
'Second argument to a division or molo operation was zero.'
>>> reason.__class__.__name__
'ZeroDivisionError'

上面這個例子，我們捕獲了除零異常，但是什麼都沒做。那個reason就是異常類ZeroDivisionError的實例，通過type就可以看出。
2.2try ... except...else語句
現在我們來說說這個else語句。Python中有很多特殊的else用法，比如用於條件和循環。放到try語句中，其作用其實也差不多：就是當沒有檢測到異常的時候，則執行else語句。舉個例子大家可能更明白些：
復制代碼 代碼如下:

>>> import syslog
>>> try:
... f = open("/root/test.py")
... except IOError,e:
... syslog.syslog(syslog.LOG_ERR,"%s"%e)
... else:
... syslog.syslog(syslog.LOG_INFO,"no exception caught\n")
...
>>> f.close()

2.3 finally子句
finally子句是無論是否檢測到異常，都會執行的一段代碼。我們可以丟掉except子句和else子句，單獨使用try...finally，也可以配合except等使用。
例如2.2的例子，如果出現其他異常，無法捕獲，程序異常退出，那麼文件 f 就沒有被正常關閉。這不是我們所希望看到的結果，但是如果我們把f.close語句放到finally語句中，無論是否有異常，都會正常關閉這個文件，豈不是很 妙
復制代碼 代碼如下:

>>> import syslog
>>> try:
... f = open("/root/test.py")
... except IOError,e:
... syslog.syslog(syslog.LOG_ERR,"%s"%e)
... else:
... syslog.syslog(syslog.LOG_INFO,"no exception caught\n")
... finally:
>>> f.close()

大家看到了沒，我們上面那個例子竟然用到了try,except,else,finally這四個子句！:-)，是不是很有趣？到現在，你就基本上已經學會了如何在Python中捕獲常規異常並處理之。
3.兩個特殊的處理異常的簡便方法
3.1斷言（assert）
什麼是斷言，先看語法：
復制代碼 代碼如下:

assert expression[,reason]

其中assert是斷言的關鍵字。執行該語句的時候，先判斷表達式expression，如果表達式為真，則什麼都不做；如果表達式不為真，則拋出異常。reason跟我們之前談到的異常類的實例一樣。不懂？沒關系，舉例子！最實在！
復制代碼 代碼如下:

>>> assert len('love') == len('like')
>>> assert 1==1
>>> assert 1==2,"1 is not equal 2!"
Traceback (most recent call last):
File "<stdin>", line 1, in <mole>
AssertionError: 1 is not equal 2!

我們可以看到，如果assert後面的表達式為真，則什麼都不做，如果不為真，就會拋出AssertionErro異常，而且我們傳進去的字元串會作為異常類的實例的具體信息存在。其實，assert異常也可以被try塊捕獲：
復制代碼 代碼如下:

>>> try:
... assert 1 == 2 , "1 is not equal 2!"
... except AssertionError,reason:
... print "%s:%s"%(reason.__class__.__name__,reason)
...
AssertionError:1 is not equal 2!
>>> type(reason)
<type 'exceptions.AssertionError'>

3.2.上下文管理（with語句）
如果你使用try,except,finally代碼僅僅是為了保證共享資源（如文件，數據）的唯一分配，並在任務結束後釋放它，那麼你就有福了！這個with語句可以讓你從try,except,finally中解放出來！語法如下：
復制代碼 代碼如下:

with context_expr [as var]:
with_suite

是不是不明白？很正常，舉個例子來！
復制代碼 代碼如下:

>>> with open('/root/test.py') as f:
... for line in f:
... print line

上面這幾行代碼幹了什麼？
（1）打開文件/root/test.py
（2）將文件對象賦值給 f
（3）將文件所有行輸出
（4）無論代碼中是否出現異常，Python都會為我們關閉這個文件，我們不需要關心這些細節。
這下，是不是明白了，使用with語句來使用這些共享資源，我們不用擔心會因為某種原因而沒有釋放他。但並不是所有的對象都可以使用with語句，只有支持上下文管理協議（context management protocol）的對象才可以，那哪些對象支持該協議呢？如下表：
file
decimal.Context
thread.LockType
threading.Lock
threading.RLock
threading.Condition
threading.Semaphore
threading.BoundedSemaphore
至於什麼是上下文管理協議，如果你不只關心怎麼用with,以及哪些對象可以使用with，那麼我們就不比太關心這個問題：）
4.拋出異常(raise)
如果我們想要在自己編寫的程序中主動拋出異常，該怎麼辦呢？raise語句可以幫助我們達到目的。其基本語法如下：
復制代碼 代碼如下:

raise [SomeException [, args [,traceback]]

第一個參數，SomeException必須是一個異常類，或異常類的實例
第二個參數是傳遞給SomeException的參數，必須是一個元組。這個參數用來傳遞關於這個異常的有用信息。
第三個參數traceback很少用，主要是用來提供一個跟中記錄對象（traceback）
下面我們就來舉幾個例子。
復制代碼 代碼如下:

>>> raise NameError
Traceback (most recent call last):
File "<stdin>", line 1, in <mole>
NameError
>>> raise NameError() #異常類的實例
Traceback (most recent call last):
File "<stdin>", line 1, in <mole>
NameError
>>> raise NameError,("There is a name error","in test.py")
Traceback (most recent call last):
File "<stdin>", line 1, in <mole>
>>> raise NameError("There is a name error","in test.py") #注意跟上面一個例子的區別
Traceback (most recent call last):
File "<stdin>", line 1, in <mole>
NameError: ('There is a name error', 'in test.py')
>>> raise NameError,NameError("There is a name error","in test.py") #注意跟上面一個例子的區別
Traceback (most recent call last):
File "<stdin>", line 1, in <mole>
NameError: ('There is a name error', 'in test.py')

其實，我們最常用的還是，只傳入第一個參數用來指出異常類型，最多再傳入一個元組，用來給出說明信息。如上面第三個例子。
5.異常和sys模塊
另一種獲取異常信息的途徑是通過sys模塊中的exc_info()函數。該函數回返回一個三元組:(異常類，異常類的實例，跟中記錄對象)
復制代碼 代碼如下:

>>> try:
... 1/0
... except:
... import sys
... tuple = sys.exc_info()
...
>>> print tuple
(<type 'exceptions.ZeroDivisionError'>, ZeroDivisionError('integer division or molo by zero',), <traceback object at 0x7f538a318b48>)
>>> for i in tuple:
... print i
...
<type 'exceptions.ZeroDivisionError'> #異常類
integer division or molo by zero #異常類的實例
<traceback object at 0x7f538a318b48> #跟蹤記錄對象

Ⅳ python的異常處理

可能觸發異常產生的代碼會放到try語句塊里，而處理異常的代碼會在except語句塊里實現。例如：

我們可以使用三種方法來處理多個異常。

第一種方法需要把所有可能發生的異常放到一個元組里。像這樣：

另外一種方式是對每個單獨的異常在單獨的except語句塊中處理。我們想要多少個except語句塊都可以：

最後一種方式會捕獲 所有 異常：

注意，捕獲所有異常可能會造成意外的結果，比如，通常我們使用CTRL+C來終止程序，但如果程序中捕獲了所有異常，CTRL+C就無法終止程序了。

包裹到finally從句中的代碼不管異常是否觸發都將會被執行。這可以被用來在腳本執行之後做清理工作：

如果想在沒有觸發異常的時候執行一些代碼，可以使用else從句。

有人也許問了：如果你只是想讓一些代碼在沒有觸發異常的情況下執行，為啥你不直接把代碼放在try裡面呢？回答是，那樣的話這段代碼中的任意異常都還是會被try捕獲，而你並不一定想要那樣。

else從句只會在沒有異常的情況下執行，而且它會在finally語句之前執行。

Ⅳ python出錯，請問是什麼問題

要把代碼發現來才知道，以下是常見的錯誤
下面終於要講到當你用到更多的Python的功能（數據類型，函數，模塊，類等等）時可能碰到的問題了。由於篇幅有限，這里盡量精簡，尤其是對一些高級的概念。要想了解更多的細節，敬請閱讀Learning Python, 2nd Edition的「小貼士」以及「Gotchas」章節。

打開文件的調用不使用模塊搜索路徑
當你在Python中調用open()來訪問一個外部的文件時，Python不會使用模塊搜索路徑來定位這個目標文件。它會使用你提供的絕對路徑，或者假定這個文件是在當前工作目錄中。模塊搜索路徑僅僅為模塊載入服務的。
不同的類型對應的方法也不同
列表的方法是不能用在字元串上的，反之亦然。通常情況下，方法的調用是和數據類型有關的，但是內部函數通常在很多類型上都可以使用。舉個例子來說，列表的reverse方法僅僅對列表有用，但是len函數對任何具有長度的對象都適用
不能直接改變不可變數據類型
記住你沒法直接的改變一個不可變的對象（例如，元組，字元串）：

T = (1, 2, 3)
T[2] = 4 # 錯誤

用切片，聯接等構建一個新的對象，並根據需求將原來變數的值賦給它。因為Python會自動回收沒有用的內存，因此這沒有看起來那麼浪費：

T = T[:2] + (4,) # 沒問題了: T 變成了 (1, 2, 4)

使用簡單的for循環而不是while或者range
當你要從左到右遍歷一個有序的對象的所有元素時，用簡單的for循環（例如，for x in seq:）相比於基於while-或者range-的計數循環而言會更容易寫，通常運行起來也更快。除非你一定需要，盡量避免在一個for循環里使用range：讓Python來替你解決標號的問題。在下面的例子中三個循環結構都沒有問題，但是第一個通常來說更好；在Python里，簡單至上。

S = "lumberjack"

for c in S: print c # 最簡單

for i in range(len(S)): print S[i] # 太多了

i = 0 # 太多了
while i < len(S): print S[i]; i += 1

不要試圖從那些會改變對象的函數得到結果
諸如像方法list.append()和list.sort()一類的直接改變操作會改變一個對象，但不會將它們改變的對象返回出來（它們會返回None）；正確的做法是直接調用它們而不要將結果賦值。經常會看見初學者會寫諸如此類的代碼：

mylist = mylist.append(X)

目的是要得到append的結果，但是事實上這樣做會將None賦值給mylist，而不是改變後的列表。更加特別的一個例子是想通過用排序後的鍵值來遍歷一個字典里的各個元素，請看下面的例子：

D = {...}
for k in D.keys().sort(): print D[k]

差一點兒就成功了——keys方法會創建一個keys的列表，然後用sort方法來將這個列表排序——但是因為sort方法會返回None，這個循環會失敗，因為它實際上是要遍歷None（這可不是一個序列）。要改正這段代碼，將方法的調用分離出來，放在不同的語句中，如下：

Ks = D.keys()
Ks.sort()
for k in Ks: print D[k]

只有在數字類型中才存在類型轉換
在Python中，一個諸如123+3.145的表達式是可以工作的——它會自動將整數型轉換為浮點型，然後用浮點運算。但是下面的代碼就會出錯了：

S = "42"
I = 1
X = S + I # 類型錯誤

這同樣也是有意而為的，因為這是不明確的：究竟是將字元串轉換為數字（進行相加）呢，還是將數字轉換為字元串（進行聯接）呢？在Python中，我們認為「明確比含糊好」（即，EIBTI（Explicit is better than implicit）），因此你得手動轉換類型：

X = int(S) + I # 做加法: 43
X = S + str(I) # 字元串聯接: "421"

循環的數據結構會導致循環
盡管這在實際情況中很少見，但是如果一個對象的集合包含了到它自己的引用，這被稱為循環對象（cyclic object）。如果在一個對象中發現一個循環，Python會輸出一個[…]，以避免在無限循環中卡住：

>>> L = ['grail'] # 在 L中又引用L自身會
>>> L.append(L) # 在對象中創造一個循環
>>> L
['grail', [...]]

除了知道這三個點在對象中表示循環以外，這個例子也是很值得借鑒的。因為你可能無意間在你的代碼中出現這樣的循環的結構而導致你的代碼出錯。如果有必要的話，維護一個列表或者字典來表示已經訪問過的對象，然後通過檢查它來確認你是否碰到了循環。
賦值語句不會創建對象的副本，僅僅創建引用
這是Python的一個核心理念，有時候當行為不對時會帶來錯誤。在下面的例子中，一個列表對象被賦給了名為L的變數，然後L又在列表M中被引用。內部改變L的話，同時也會改變M所引用的對象，因為它們倆都指向同一個對象。

>>> L = [1, 2, 3] # 共用的列表對象
>>> M = ['X', L, 'Y'] # 嵌入一個到L的引用
>>> M
['X', [1, 2, 3], 'Y']

>>> L[1] = 0 # 也改變了M
>>> M
['X', [1, 0, 3], 'Y']

通常情況下只有在稍大一點的程序里這就顯得很重要了，而且這些共用的引用通常確實是你需要的。如果不是的話，你可以明確的給他們創建一個副本來避免共用的引用；對於列表來說，你可以通過使用一個空列表的切片來創建一個頂層的副本：

>>> L = [1, 2, 3]
>>> M = ['X', L[:], 'Y'] # 嵌入一個L的副本

>>> L[1] = 0 # 僅僅改變了L，但是不影響M
>>> L
[1, 0, 3]
>>> M
['X', [1, 2, 3], 'Y']

切片的范圍起始從默認的0到被切片的序列的最大長度。如果兩者都省略掉了，那麼切片會抽取該序列中的所有元素，並創造一個頂層的副本（一個新的，不被公用的對象）。對於字典來說，使用字典的dict.()方法。
靜態識別本地域的變數名
Python默認將一個函數中賦值的變數名視作是本地域的，它們存在於該函數的作用域中並且僅僅在函數運行的時候才存在。從技術上講，Python是在編譯def代碼時，去靜態的識別本地變數，而不是在運行時碰到賦值的時候才識別到的。如果不理解這點的話，會引起人們的誤解。比如，看看下面的例子，當你在一個引用之後給一個變數賦值會怎麼樣：

>>> X = 99
>>> def func():
... print X # 這個時候還不存在
... X = 88 # 在整個def中將X視作本地變數
...
>>> func( ) # 出錯了！

你會得到一個「未定義變數名」的錯誤，但是其原因是很微妙的。當編譯這則代碼時，Python碰到給X賦值的語句時認為在這個函數中的任何地方X會被視作一個本地變數名。但是之後當真正運行這個函數時，執行print語句的時候，賦值語句還沒有發生，這樣Python便會報告一個「未定義變數名」的錯誤。
事實上，之前的這個例子想要做的事情是很模糊的：你是想要先輸出那個全局的X，然後創建一個本地的X呢，還是說這是個程序的錯誤？如果你真的是想要輸出這個全局的X，你需要將它在一個全局語句中聲明它，或者通過包絡模塊的名字來引用它。
默認參數和可變對象
在執行def語句時，默認參數的值只被解析並保存一次，而不是每次在調用函數的時候。這通常是你想要的那樣，但是因為默認值需要在每次調用時都保持同樣對象，你在試圖改變可變的默認值（mutable defaults）的時候可要小心了。例如，下面的函數中使用一個空的列表作為默認值，然後在之後每一次函數調用的時候改變它的值：

>>> def saver(x=[]): # 保存一個列表對象
... x.append(1) # 並每次調用的時候
... print x # 改變它的值
...
>>> saver([2]) # 未使用默認值
[2, 1]
>>> saver() # 使用默認值
[1]
>>> saver() # 每次調用都會增加！
[1, 1]
>>> saver()
[1, 1, 1]

有的人將這個視作Python的一個特點——因為可變的默認參數在每次函數調用時保持了它們的狀態，它們能提供像C語言中靜態本地函數變數的類似的一些功能。但是，當你第一次碰到它時會覺得這很奇怪，並且在Python中有更加簡單的辦法來在不同的調用之間保存狀態（比如說類）。
要擺脫這樣的行為，在函數開始的地方用切片或者方法來創建默認參數的副本，或者將默認值的表達式移到函數裡面；只要每次函數調用時這些值在函數里，就會每次都得到一個新的對象：

>>> def saver(x=None):

... if x is None: x = [] # 沒有傳入參數？
... x.append(1) # 改變新的列表
... print x
...
>>> saver([2]) # 沒有使用默認值
[2, 1]
>>> saver() # 這次不會變了
[1]
>>> saver()
[1]

其他常見的編程陷阱
下面列舉了其他的一些在這里沒法詳述的陷阱：
在頂層文件中語句的順序是有講究的：因為運行或者載入一個文件會從上到下運行它的語句，所以請確保將你未嵌套的函數調用或者類的調用放在函數或者類的定義之後。
reload不影響用from載入的名字：reload最好和import語句一起使用。如果你使用from語句，記得在reload之後重新運行一遍from，否則你仍然使用之前老的名字。
在多重繼承中混合的順序是有講究的：這是因為對superclass的搜索是從左到右的，在類定義的頭部，在多重superclass中如果出現重復的名字，則以最左邊的類名為准。
在try語句中空的except子句可能會比你預想的捕捉到更多的錯誤。在try語句中空的except子句表示捕捉所有的錯誤，即便是真正的程序錯誤，和sys.exit()調用，也會被捕捉到。

Ⅵ python異常值處理

如果你用 Python 編程，那麼你就無法避開異常，因為異常在這門語言里無處不在。打個比方，當你在腳本執行時按 ctrl+c 退出，解釋器就會產生一個 KeyboardInterrupt 異常。而 KeyError、ValueError、TypeError 等更是日常編程里隨處可見的老朋友。

異常處理工作由「捕獲」和「拋出」兩部分組成。「捕獲」指的是使用 try ... except 包裹特定語句，妥當的完成錯誤流程處理。而恰當的使用 raise 主動「拋出」異常，更是優雅代碼里必不可少的組成部分。

異常分類

BaseException所有異常的基類
Exception常見錯誤的基類
ArithmeticError所有數值計算錯誤的基類
Warning警告的基類

AssertError斷言語句（assert）失敗
AttributeError嘗試訪問未知的對象屬性
DeprecattionWarning關於被棄用的特徵的警告
EOFError用戶輸入文件末尾標志EOF（Ctrl+d）
FloattingPointError浮點計算錯誤
FutureWarning關於構造將來語義會有改變的警告
GeneratorExitgenerator.close()方法被調用的時候
ImportError導入模塊失敗的時候
IndexError索引超出序列的范圍
KeyError字典中查找一個不存在的關鍵字
KeyboardInterrupt用戶輸入中斷鍵（Ctrl+c）
MemoryError內存溢出（可通過刪除對象釋放內存）
NamerError嘗試訪問一個不存在的變數
NotImplementedError尚未實現的方法
OSError操作系統產生的異常（例如打開一個不存在的文件）
OverflowError數值運算超出最大限制
OverflowWarning舊的關於自動提升為長整型（long）的警告
PendingDeprecationWarning關於特徵會被遺棄的警告
ReferenceError弱引用（weakreference）試圖訪問一個已經被垃圾回收機制回收了的對象
RuntimeError一般的運行時錯誤
RuntimeWarning可疑的運行行為（runtimebehavior）的警告
StopIteration迭代器沒有更多的值
SyntaxErrorPython的語法錯誤
SyntaxWarning可疑的語法的警告
IndentationError縮進錯誤
TabErrorTab和空格混合使用
SystemErrorPython編譯器系統錯誤
SystemExitPython編譯器進程被關閉
TypeError不同類型間的無效操作
UnboundLocalError訪問一個未初始化的本地變數（NameError的子類）
UnicodeErrorUnicode相關的錯誤（ValueError的子類）
UnicodeEncodeErrorUnicode編碼時的錯誤（UnicodeError的子類）
UnicodeDecodeErrorUnicode解碼時的錯誤（UnicodeError的子類）
UserWarning用戶代碼生成的警告
ValueError傳入無效的參數
ZeroDivisionError除數為零

Ⅶ python中用來拋出異常的關鍵字是

python中用來拋出異常的關鍵字是1.拋出異常和自定義異常 Python用異常對象(exception object)表
raise 語句 Python中的raise 關鍵字用於引發一個異常,基本上和C#和
自定義異常類型 Python中也可以自定義自己的特殊類型的異常,只需要要從Excepti
2.捕捉異常 和C#中的try/catch類似,Python中使用try/excep

Ⅷ python 怎麼 throw exception

raise Exception("hello")

Ⅸ python pexpect拋出eof異常

編輯「/usr/local/python269/lib/python2.6/site-packages/pexpect/__init__.py」，將「raiseEOF(str(err)+'\n'+str(self))」這段代碼注釋掉，程序正常運行有些UNIX平台，當你讀取一個處於EOF狀態的文件描述符時，會拋出異常，注釋掉就可以了

Ⅹ python的assertraises什麼意思

assert,斷言。。用於某個地方執行的時候，檢查是否滿足某種條件
raise,主動拋出異常，讓外面的異常檢測代碼捕捉到，因為這種是主動拋出，一般可以自定義異常提示信息