pythonwithas異常

⑴ python中異常重試的解決方案詳解

Python中異常重試的解決方案詳解
大家在做數據抓取的時候，經常遇到由於網路問題導致的程序保存，先前只是記錄了錯誤內容，並對錯誤內容進行後期處理。
原先的流程：
def crawl_page(url):
pass

def log_error(url):
pass

url = ""
try:
crawl_page(url)
except:
log_error(url)

改進後的流程：
attempts = 0
success = False
while attempts < 3 and not success:
try:
crawl_page(url)
success = True
except:
attempts += 1
if attempts == 3:
break

最近發現的新的解決方案：retrying

retrying是一個 Python的重試包，可以用來自動重試一些可能運行失敗的程序段。retrying提供一個裝飾器函數retry，被裝飾的函數就會在運行失敗的條件下重新執行，默認只要一直報錯就會不斷重試。
import random
from retrying import retry

@retry
def do_something_unreliable():
if random.randint(0, 10) > 1:
raise IOError("Broken sauce, everything is hosed!!!111one")
else:
return "Awesome sauce!"

print do_something_unreliable()

如果我們運行have_a_try函數，那麼直到random.randint返回5，它才會執行結束，否則會一直重新執行。

retry還可以接受一些參數，這個從源碼中Retrying類的初始化函數可以看到可選的參數：

stop_max_attempt_number：用來設定最大的嘗試次數，超過該次數就停止重試
stop_max_delay：比如設置成10000，那麼從被裝飾的函數開始執行的時間點開始，到函數成功運行結束或者失敗報錯中止的時間點，只要這段時間超過10秒，函數就不會再執行了
wait_fixed：設置在兩次retrying之間的停留時間
wait_random_min和wait_random_max：用隨機的方式產生兩次retrying之間的停留時間
wait_exponential_multiplier和wait_exponential_max：以指數的形式產生兩次retrying之間的停留時間，產生的值為2^previous_attempt_number * wait_exponential_multiplier，previous_attempt_number是前面已經retry的次數，如果產生的這個值超過了wait_exponential_max的大小，那麼之後兩個retrying之間的停留值都為wait_exponential_max。這個設計迎合了exponential backoff演算法，可以減輕阻塞的情況。
我們可以指定要在出現哪些異常的時候再去retry，這個要用retry_on_exception傳入一個函數對象：
def retry_if_io_error(exception):
return isinstance(exception, IOError)

@retry(retry_on_exception=retry_if_io_error)
def read_a_file():
with open("file", "r") as f:
return f.read()

在執行read_a_file函數的過程中，如果報出異常，那麼這個異常會以形參exception傳入retry_if_io_error函數中，如果exception是IOError那麼就進行retry，如果不是就停止運行並拋出異常。

我們還可以指定要在得到哪些結果的時候去retry，這個要用retry_on_result傳入一個函數對象：

def retry_if_result_none(result):
return result is None

@retry(retry_on_result=retry_if_result_none)
def get_result():
return None

在執行get_result成功後，會將函數的返回值通過形參result的形式傳入retry_if_result_none函數中，如果返回值是None那麼就進行retry，否則就結束並返回函數值。

⑵ python中with語句的作用

with語句相當於你定義一個類的時候定義了__enter__()和__exit__()這個兩個方法。
在我們進行文件操作的的時候會用到open方法，後面有了with open以後就不再只使用open方法了，為什麼？因為with open方法簡單，我們不用再去管關閉文件了，即使中間發生異常，with open也會幫我們把文件關閉掉，以下示例演示下with open方法；
class File(object):
"""文件操作類"""
def __init__(self, filepath, mode):
self.filepath = filepath
self.mode = mode

def __enter__(self):
"""打開文件"""
self.file = open(self.filepath, self.mode)
print("打開文件")
return self.file

def __exit__(self, exc_type, exc_val, exc_tb):
"""關閉文件"""
print("關閉文件")
self.file.close()

if __name__ == '__main__':
with File('log.log', 'r') as file:
file.write("家啊")

可以看出來有了__enter__()和__exit__()，我們自定義的類也可以使用with了

⑶ 如何解決的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中with python中with as 是什麼意思剛入門求解釋!!!

這個語法是用來代替傳統的try...finally語法的。

with EXPRESSION [ as VARIABLE] WITH-BLOCK

基本思想是with所求值的對象必須有一個__enter__()方法，一個__exit__()方法。

緊跟with後面的語句被求值後，返回對象的__enter__()方法被調用，這個方法的返回值將被賦值給as後面的變數。當with後面的代碼塊全部被執行完之後，將調用前面返回對象的__exit__()方法。

file=open("/tmp/foo.txt")
try:
data=file.read()
finally:
file.close()

使用with...as...的方式替換，修改後的代碼是：

withopen("/tmp/foo.txt")asfile:
data=file.read()

#!/usr/bin/envpython
#with_example01.py


classSample:
def__enter__(self):
print"In__enter__()"
return"Foo"

def__exit__(self,type,value,trace):
print"In__exit__()"


defget_sample():
returnSample()


withget_sample()assample:
print"sample:",sample

執行結果為

In__enter__()
sample:Foo
In__exit__()

1. __enter__()方法被執行

2. __enter__()方法返回的值 - 這個例子中是"Foo"，賦值給變數'sample'

3. 執行代碼塊，列印變數"sample"的值為 "Foo"

4. __exit__()方法被調用with真正強大之處是它可以處理異常。可能你已經注意到Sample類的__exit__方法有三個參數- val, type 和 trace。這些參數在異常處理中相當有用。

請採納！

⑸ Python with as為什麼無法捕獲異常

with在打開文件的這個操作中的作用是保證每次正常打開文件後，不論遇到什麼，最後都會執行文件的關閉操作，避免腳本中遺漏。但是他自身並沒有抓取異常的處理機制。

with open("asdasdas") as a:

print("打開成功")

do_something()

這段代碼的含義，相當於打開了文件「asdasdas」後列印了「打開成功」的字樣後，又處理了do_something()這段邏輯。不論do_something()這段邏輯正常執行結束，還是拋出異常，都會保證最終「asdasdas」這個文件都會被關閉。避免因為文件未被關閉而導致的種種問題。

你的代碼可以改為以下部分，這樣就可以catch到讀取文件中的異常了。

try:

with open("asdasdas") as a:

print("打開成功")

except:

print("打開失敗")

⑹ python with...as

簡單的說with/as語句的設計是作為常見的try/finally用法的模式替代方案.
用於定義必須執行的終止或清理行為.
例如下面的用法可以確保文件打開之後一定自動關閉,無論是否發生異常

withopen(r'c:\mis.data')as myfile:
do something

⑺ mysql 中能使用with as 嗎

with as 是 python 的語法 如下：

比較繁瑣 也失去了 python 語言本身的優雅

mysql 裡面並沒有類似的用法

⑻ Python在with open as語句之外，將讀取的CSV文件內容轉為列表，報錯：對已關閉的文件進行操作

你用CSV模塊讀的時候，返回的是一個對象，這個對象關閉了就沒了。

直接讀取文件，非csv模塊方式，返回的則是str或list

⑼ python針對關鍵字with/as怎樣使用

改變數名，不要把變數名和關鍵字重名，變數名前可加_來區分，比如_type = "xxx"

⑽ Python中的with...as用法介紹

這篇文章主要介紹了Python中的with...as用法介紹,本文直接給出用法實例,需要的朋友可以參考下
這個語法是用來代替傳統的try...finally語法的。
代碼如下:
with
EXPRESSION
[
as
VARIABLE]
WITH-BLOCK
基本思想是with所求值的對象必須有一個__enter__()方法，一個__exit__()方法。
緊跟with後面的語句被求值後，返回對象的__enter__()方法被調用，這個方法的返回值將被賦值給as後面的變數。當with後面的代碼塊全部被執行完之後，將調用前面返回對象的__exit__()方法。

代碼如下:
file
=
open("/tmp/foo.txt")
try:
data
=
file.read()
finally:
file.close()
使用with...as...的方式替換，修改後的代碼是：
代碼如下:
with
open("/tmp/foo.txt")
as
file:
data
=
file.read()
#!/usr/bin/env
python
#
with_example01.py
class
Sample:
def
__enter__(self):
print
"In
__enter__()"
return
"Foo"
def
__exit__(self,
type,
value,
trace):
print
"In
__exit__()"
def
get_sample():
return
Sample()
with
get_sample()
as
sample:
print
"sample:",
sample
執行結果為

代碼如下:
In
__enter__()
sample:
Foo
In
__exit__()
1.
__enter__()方法被執行
2.
__enter__()方法返回的值
-
這個例子中是"Foo"，賦值給變數'sample'
3.
執行代碼塊，列印變數"sample"的值為
"Foo"
4.
__exit__()方法被調用with真正強大之處是它可以處理異常。可能你已經注意到Sample類的__exit__方法有三個參數-
val,
type
和
trace。這些參數在異常處理中相當有用。我們來改一下代碼，看看具體如何工作的。