简单介绍Python中的try和finally和with方法
分类:编程应用

简易介绍Python中的try和finally和with方法,pythonfinally

用 Python 做一件很通常的作业: 展开文件, 逐行读入, 最终关掉文件; 进一步的供给是, 那或然是程序中叁个可选的法力, 如若有任何难题, 比方文件不可能张开, 或是读抽取错, 那么在函数内要求捕获所有特别, 输出一行警告并退出. 代码只怕一开端看起来是如此的  

def read_file(): 
  try: 
    f = open('yui', 'r') 
    print ''.join(f.readlines()) 
  except: 
    print 'error occurs while reading file'
  finally: 
    f.close()

    不过那明显不能运行, 因为  f  是在  try  块中定义的, 而在  finally  中非常小概援引.

    如果将  f  提取到  try  块外部, 如  

def read_file(): 
   f = open('azusa', 'r') 
  try: 
    print ''.join(f.readlines()) 
  except: 
    print 'error occurs while reading file'
  finally: 
    f.close()

那正是说, 难点在于当张开文件战败, 抛出特别将不会被捕获.

    挫一点的艺术自然是, 再套一层  try  吧  

def read_file(): 
   try: 
    f = open('sawako', 'r') 
    try: 
      print ''.join(f.readlines()) 
    except: 
      print 'error occurs while reading file'
    finally: 
      f.close() 
   except: 
     print 'error occurs while reading file'

    当然那不唯有是多一层缩进挫了, 连警告输出都无需付费多贰次呢.

    正规一点的诀若是, 使用 Python 引进的  with  结构来解决, 如  

def readFile(): 
  try: 
     with open('mio', 'r') as f: 
      print ''.join(f.readlines()) 
  except: 
    print 'error occurs while reading file'

    当文件展开退步时, 非常自然会被  except  到; 不然, 在  with  块甘休之后, 张开的文件将电动关闭.

    除了展开文件, 还大概有别的这样能够用来  with  的东西么? 也许说, 怎么自定义贰个怎么事物, 让它能用于  with 呢?
    直接答复后三个难题吧, 秘密在于 Python 设想机在  with  块退出时会去研究目的的  __exit__  方法并调用它, 把自由能源的动作放在这几个  __exit__  函数中就可以了; 别的, 对象还索要三个  __enter__  函数, 当步入  with 块时, 这一个函数被调用, 而它的重临值将用作  as  后援引的值. 二个轻松易行的事例是  

class Test: 
  def __init__(self): 
    print 'init'

  def __enter__(self): 
    print 'enter'
    return self

  def __exit__(self, except_type, except_obj, tb): 
    print except_type 
    print except_obj 
    import traceback 
    print ''.join(traceback.format_tb(tb)) 
    print 'exit'
    return True

with Test() as t: 
  raise ValueError('kon!')

    试行这一段代码, 输出将会是  

init 
enter 
<type 'exceptions.ValueError'> 
kon! 
 File "test.py", line 17, in <module> 
  raise ValueError('kon!') 

exit

     __exit__  函数接受四个参数, 分别是那多少个对象类型, 非常对象和调用栈. 借使  with  块符合规律退出, 那么那么些参数将都以  None . 重返  True  表示产生的丰裕已被拍卖, 不再继续向外抛出.

    轻巧的介绍到此结束, 详细的图景能够参照  PEP 343  (那数字真不错, 7 3 ).

上面介绍下 with 语句的实例用法 & 高端用法:

Python高等、大气、上档案的次序的with语句

在说with语句在此以前,先看看一段轻易的代码吧  

lock = threading.Lock()
...
lock.acquire()
elem = heapq.heappop(heap)
lock.release()

非常粗大略直观,多个线程共用二个优先级队列的时候,首先先用互斥锁lock.acquire()把前期级队列锁上,然后取成分,再然后lock.release()释放这些锁。

虽说看似十二分吻合逻辑的多个经过,可是在那之中遮掩着一个品格高尚的人的bug:当heap内部没有成分的时候,会抛出叁个IndexError非凡,再然后客栈回滚,再然后lock.release()根本不会实施,那一个锁就永恒得不到释放,由此就发出了摄人心魄的死锁难题。那么些也是贪滥无厌大神们讨厌卓殊的原故。杰出Java风格的施工方案正是  

lock = threading.Lock()
...
lock.acquire()
try:
  elem = heapq.heappop(heap)
finally:
  lock.release()

其一纵然能够,可是怎么看怎么dirty,和Python优雅、轻巧的作风出入一点都不小。其实,自从Python2.5初叶引进了with语句,一切就变得特别轻松:  

lock = threading.Lock()
...
with lock:
  elem = heapq.heappop(heap)

在此无论以何种方法离开with语句的代码块,锁都会被假释。
with语句的规划指标正是为着使得以前须求经过try...finally化解的清理财富难题变得简单、清晰,它的的用法是  

with expression [as variable]:
  with-block

中间expression再次回到三个叫作「context manager」的靶子,然后这些指标被赋给variable(如若部分话)。「context manager」对象有四个点子,分别是__enter__()和__exit__(),很通晓二个在步入with-block时调用,一个偏离with-block的时候调用。

如此的靶子无需和煦去达成,在Python标准Curry面比很多API都以一度完毕了那多少个主意,最常见的三个例证正是读写文件的open语句。  

with open('1.txt', encoding = 'utf-8') as fp:
  lines = fp.readlines()

不论平日离开照旧因为特别原因离开with语句块,张开的文件财富总是会自由。
接下去探讨一下with语句配合contextlib库的部分相比实用的主意,举例供给同时开发八个文本,一个读叁个写,这一年就足以如此写:  

from contextlib import nested
...
with nested(open('in.txt'), open('out.txt', 'w')) as (fp_in, fp_out):
  ...

如此那般就能够省掉多个with的讲话的嵌套了,别的要是蒙受一些还未曾扶助「context manager」的API呢?比方urllib.request.urlopen(),这么些再次来到的对象因为不是「context manager」,甘休的时候还索要团结去调用close方法。
看似这种API,contextlib提供了贰个称作closing方法,它会在距离with语句的时候,自动调用对象的close方法,因而urlopen也足以如此写:  

from contextlib import closing
...
with closing(urllib.request.urlopen('http://www.yahoo.com')) as f:
  for line in f:
    sys.stdout.write(line)

 用 Python 做一件很平凡的事体: 展开文件, 逐行读入, 最后关掉文件; 进一步的必要是, 那大概是程序中一个可选的功用, 借使有任何难点, 比方文件不可能展开, 或是读抽取错, 那么在函数内须求捕获所有特别, 输出一行警告并退出. 代码恐怕一齐首看起来是如此的  

def read_file(): 
  try: 
    f = open('yui', 'r') 
    print ''.join(f.readlines()) 
  except: 
    print 'error occurs while reading file'
  finally: 
    f.close()

    不过这明明不能运维, 因为  f  是在  try  块中定义的, 而在  finally  中不能够援用.

    如果将  f  提取到  try  块外部, 如  

def read_file(): 
   f = open('azusa', 'r') 
  try: 
    print ''.join(f.readlines()) 
  except: 
    print 'error occurs while reading file'
  finally: 
    f.close()

那正是说, 难题在于当打开文件退步, 抛出非常将不会被捕获.

    挫一点的点子自然是, 再套一层  try  吧  

def read_file(): 
   try: 
    f = open('sawako', 'r') 
    try: 
      print ''.join(f.readlines()) 
    except: 
      print 'error occurs while reading file'
    finally: 
      f.close() 
   except: 
     print 'error occurs while reading file'

    当然那不单是多一层缩进挫了, 连警告输出都无需付费多二次呢.

    正规一点的方法是, 使用 Python 引入的  with  结构来化解, 如  

def readFile(): 
  try: 
     with open('mio', 'r') as f: 
      print ''.join(f.readlines()) 
  except: 
    print 'error occurs while reading file'

    当文件张开战败时, 格外自然会被  except  到; 否则, 在  with  块截止之后, 打开的文本将电动关闭.

    除了打开文件, 还会有别的那样能够用于  with  的东西么? 或许说, 怎么自定义一个什么事物, 让它能用于  with 呢?
    直接回答后三个题目吗, 秘密在于 Python 设想机在  with  块退出时会去搜索指标的  __exit__  方法并调用它, 把自由能源的动作放在这几个  __exit__  函数中就足以了; 其它, 对象还需求二个  __enter__  函数, 当步入  with 块时, 那个函数被调用, 而它的重临值将作为  as  后援引的值. 一个轻巧易行的例证是  

class Test: 
  def __init__(self): 
    print 'init'

  def __enter__(self): 
    print 'enter'
    return self

  def __exit__(self, except_type, except_obj, tb): 
    print except_type 
    print except_obj 
    import traceback 
    print ''.join(traceback.format_tb(tb)) 
    print 'exit'
    return True

with Test() as t: 
  raise ValueError('kon!')

    实行这一段代码, 输出将会是  

init 
enter 
<type 'exceptions.ValueError'> 
kon! 
 File "test.py", line 17, in <module> 
  raise ValueError('kon!') 

exit

     __exit__  函数接受多个参数, 分别是那些对象类型, 异常对象和调用栈. 倘诺  with  块符合规律退出, 那么这一个参数将都以  None . 重返  True  表示产生的那三个已被管理, 不再继续向外抛出.

    简单的介绍到此停止, 详细的意况能够参见  PEP 343  (那数字真不错, 7 3 ).

下边介绍下 with 语句的实例用法 & 高端用法:

Python高档、大气、上档期的顺序的with语句

在说with语句从前,先看看一段轻松的代码吧  

lock = threading.Lock()
...
lock.acquire()
elem = heapq.heappop(heap)
lock.release()

很简短直观,多个线程共用多少个优先级队列的时候,首先先用互斥锁lock.acquire()把开始时期级队列锁上,然后取成分,再然后lock.release()释放那个锁。

纵然如此看似拾分契合逻辑的二个进程,不过里面潜藏着几个壮烈的bug:当heap内部没有成分的时候,会抛出一个IndexError极度,再然后货仓回滚,再然后lock.release()根本不会施行,那个锁就永恒得不到释放,由此就发出了摄人心魄的死锁难点。这些也是广大大神们讨厌万分的由来。精彩Java风格的减轻方案正是  

lock = threading.Lock()
...
lock.acquire()
try:
  elem = heapq.heappop(heap)
finally:
  lock.release()

本条即便可以,可是怎么看怎么dirty,和Python优雅、轻便的风骨出入异常的大。其实,自从Python2.5早先引进了with语句,一切就变得特别简单:  

lock = threading.Lock()
...
with lock:
  elem = heapq.heappop(heap)

在此无论以何种格局离开with语句的代码块,锁都会被放出。
with语句的设计目标正是为着使得此前要求经过try...finally解决的清理财富难题变得简单、清晰,它的的用法是  

with expression [as variable]:
  with-block

里头expression重临一个叫做「context manager」的目的,然后那些目的被赋给variable(即便有的话)。「context manager」对象有多个点子,分别是__enter__()和__exit__(),很醒目三个在步入with-block时调用,三个偏离with-block的时候调用。

那样的对象无需团结去贯彻,在Python标准Curry面很多API都是早就达成了那三个章程,最普及的贰个事例便是读写文件的open语句。  

with open('1.txt', encoding = 'utf-8') as fp:
  lines = fp.readlines()

不论寻常离开依然因为十二分原因离开with语句块,展开的文件能源总是会放出。
接下去探讨一下with语句协作contextlib库的片段相比实用的格局,比方必要同期伸开多少个文本,一个读贰个写,那年即可如此写:  

from contextlib import nested
...
with nested(open('in.txt'), open('out.txt', 'w')) as (fp_in, fp_out):
  ...

这么就足以省掉多个with的言语的嵌套了,另外借使碰到一些还并未帮衬「context manager」的API呢?例如urllib.request.urlopen(),那一个重回的目的因为不是「context manager」,甘休的时候还亟需本身去调用close方法。
好像这种API,contextlib提供了四个堪当closing方法,它会在距离with语句的时候,自动调用对象的close方法,由此urlopen也足以那样写:  

from contextlib import closing
...
with closing(urllib.request.urlopen('http://www.yahoo.com')) as f:
  for line in f:
    sys.stdout.write(line)

用 Python 做一件很平时的职业: 展开文件, 逐行读入, 最终关掉文件; 进一步的急需是, 那也...

用 Python 做一件很平凡的职业: 展开文件, 逐行读入, 最终关掉文件; 进一步的急需是, 这恐怕是前后相继中贰个可选的效益, 借使有其余难题, 举个例子文件不能展开, 或是读抽出错, 那么在函数内须要捕获全部极度, 输出一行警告并退出. 代码大概一起首看起来是那样的  

?

1
2
3
4
5
6
7
8
def read_file():
  try:
    f = open('yui', 'r')
    print ''.join(f.readlines())
  except:
    print 'error occurs while reading file'
  finally:
    f.close()

    可是那眼看不可能运维, 因为  f  是在  try  块中定义的, 而在  finally  中不能够援用.

    如果将  f  提取到  try  块外部, 如  

?

1
2
3
4
5
6
7
8
def read_file():
   f = open('azusa', 'r')
  try:
    print ''.join(f.readlines())
  except:
    print 'error occurs while reading file'
  finally:
    f.close()

那么, 难题在于当展开文件战败, 抛出特别将不会被捕获.

    挫一点的主意自然是, 再套一层  try  吧  

?

1
2
3
4
5
6
7
8
9
10
11
def read_file():
   try:
    f = open('sawako', 'r')
    try:
      print ''.join(f.readlines())
    except:
      print 'error occurs while reading file'
    finally:
      f.close()
   except:
     print 'error occurs while reading file'

    当然那不只是多一层缩进挫了, 连警告输出都无条件多贰遍呢.

    正规一点的方法是, 使用 Python 引入的  with  结构来化解, 如  

?

1
2
3
4
5
6
def readFile():
  try:
     with open('mio', 'r') as f:
      print ''.join(f.readlines())
  except:
    print 'error occurs while reading file'

    当文件张开退步时, 非常自然会被  except  到; 不然, 在  with  块甘休将来, 展开的文本将活动关闭.

    除了展开文件, 还大概有任何那样能够用来  with  的东西么? 或许说, 怎么自定义三个怎么着事物, 让它能用来  with 呢?
    直接回答后一个标题呢, 秘密在于 Python 虚构机在  with  块退出时会去搜求目的的  __exit__  方法并调用它, 把自由能源的动作放在这么些  __exit__  函数中就能够了; 别的, 对象还须求贰个  __enter__  函数, 当步入  with 块时, 那么些函数被调用, 而它的再次回到值将用作  as  后援用的值. 三个回顾的例证是  

?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class Test:
  def __init__(self):
    print 'init'
  
  def __enter__(self):
    print 'enter'
    return self
  
  def __exit__(self, except_type, except_obj, tb):
    print except_type
    print except_obj
    import traceback
    print ''.join(traceback.format_tb(tb))
    print 'exit'
    return True
  
with Test() as t:
  raise ValueError('kon!')

    施行这一段代码, 输出将会是  

?

1
2
3
4
5
6
7
8
init
enter
<type 'exceptions.ValueError'>
kon!
 File "test.py", line 17, in <module>
  raise ValueError('kon!')
  
exit

     __exit__  函数接受八个参数, 分别是十三分对象类型, 万分对象和调用栈. 纵然  with  块经常退出, 那么这个参数将都以  None . 重回  True  表示爆发的十三分已被拍卖, 不再接续向外抛出.

    轻便的牵线到此甘休, 详细的场地能够参见  PEP 343  (那数字真不错, 7 3 ).

上边介绍下 with 语句的实例用法 & 高端用法:

Python高等、大气、上档案的次序的with语句

在说with语句在此以前,先看看一段轻巧的代码吧  

?

1
2
3
4
5
lock = threading.Lock()
...
lock.acquire()
elem = heapq.heappop(heap)
lock.release()

很简短直观,多少个线程共用二个预先级队列的时候,首先先用互斥锁lock.acquire()把开始的一段时期级队列锁上,然后取成分,再然后lock.release()释放那个锁。

就算如此看似特别符合逻辑的贰个进度,可是里面潜藏着三个豪杰的bug:当heap中间未有成分的时候,会抛出八个IndexError分外,再然后货仓回滚,再然后lock.release()根本不会实行,那么些锁就长久得不到自由,由此就时有发生了可喜的死锁难题。那么些也是成都百货上千大神们讨厌十分的由来。卓绝Java风格的缓慢解决方案就是  

?

1
2
3
4
5
6
7
lock = threading.Lock()
...
lock.acquire()
try:
  elem = heapq.heappop(heap)
finally:
  lock.release()

那几个即便能够,可是怎么看怎么dirty,和Python优雅、轻松的品格出入相当的大。其实,自从Python2.5上马引进了with语句,一切就变得极其轻便:  

?

1
2
3
4
lock = threading.Lock()
...
with lock:
  elem = heapq.heappop(heap)

在此无论以何种格局离开with语句的代码块,锁都会被释放。
with语句的陈设性指标正是为了使得从前需求通过try...finally消除的清理财富难题变得简单、清晰,它的的用法是  

?

1
2
with expression [as variable]:
  with-block

内部expression重返三个誉为「context manager」的目的,然后这么些目的被赋给variable(假使局地话)。「context manager」对象有两个方法,分别是__enter__()和__exit__(),很显然二个在步向with-block时调用,四个相距with-block的时候调用。

如此的靶子不要求自个儿去落到实处,在Python标准Curry面非常多API都以早就落到实处了那七个法子,最广泛的三个例子即是读写文件的open语句。  

?

1
2
with open('1.txt', encoding = 'utf-8') as fp:
  lines = fp.readlines()

任由不奇怪离开依然因为特别原因离开with语句块,张开的公文能源总是会自由。
接下去钻探一下with语句协作contextlib库的片段相比较实用的形式,比如供给同临时间张开三个文件,叁个读贰个写,那个时候就能够这么写:  

?

1
2
3
4
from contextlib import nested
...
with nested(open('in.txt'), open('out.txt', 'w')) as (fp_in, fp_out):
  ...

如此那般就足以省掉多少个with的言辞的嵌套了,另外如果蒙受一些还并未有支持「context manager」的API呢?比方urllib.request.urlopen(),那个重临的对象因为不是「context manager」,甘休的时候还索要团结去调用close方法。
附近这种API,contextlib提供了三个叫做closing方法,它会在距离with语句的时候,自动调用对象的close方法,因而urlopen也足以如此写:  

?

1
2
3
4
5
from contextlib import closing
...
with closing(urllib.request.urlopen('http://www.yahoo.com')) as f:
  for line in f:
    sys.stdout.write(line)

 用 Python 做一件很平凡的事务: 张开文件, 逐行读入, 最终关掉文件; 进一步的供给是, 那大概是程序中贰个可选的功力, 假诺有任何难点, 例如文件无法开发, 或是读抽出错, 那么在函数内亟待捕获全数非常, 输出一银行警卫告并退出. 代码大概一开始看起来是那般的  

?

1
2
3
4
5
6
7
8
def read_file():
  try:
    f = open('yui', 'r')
    print ''.join(f.readlines())
  except:
    print 'error occurs while reading file'
  finally:
    f.close()

    可是那明摆着不大概运营, 因为  f  是在  try  块中定义的, 而在  finally  中不可能引用.

    如果将  f  提取到  try  块外部, 如  

?

1
2
3
4
5
6
7
8
def read_file():
   f = open('azusa', 'r')
  try:
    print ''.join(f.readlines())
  except:
    print 'error occurs while reading file'
  finally:
    f.close()

那么, 难题在于当展开文件战败, 抛出相当将不会被捕获.

    挫一点的格局自然是, 再套一层  try  吧  

?

1
2
3
4
5
6
7
8
9
10
11
def read_file():
   try:
    f = open('sawako', 'r')
    try:
      print ''.join(f.readlines())
    except:
      print 'error occurs while reading file'
    finally:
      f.close()
   except:
     print 'error occurs while reading file'

    当然那不仅仅是多一层缩进挫了, 连警告输出都无条件多贰回呢.

    正规一点的措施是, 使用 Python 引进的  with  结构来解决, 如  

?

1
2
3
4
5
6
def readFile():
  try:
     with open('mio', 'r') as f:
      print ''.join(f.readlines())
  except:
    print 'error occurs while reading file'

    当文件打开失利时, 分外自然会被  except  到; 不然, 在  with  块停止以往, 展开的文本将自动关闭.

    除了打开文件, 还应该有任何那样能够用来  with  的东西么? 或然说, 怎么自定义二个怎么东西, 让它能用来  with 呢?
    直接回复后三个难题呢, 秘密在于 Python 设想机在  with  块退出时会去搜索目的的  __exit__  方法并调用它, 把自由资源的动作放在那一个  __exit__  函数中就足以了; 别的, 对象还索要一个  __enter__  函数, 当走入  with 块时, 这一个函数被调用, 而它的再次来到值将作为  as  后援引的值. 贰个简练的例子是  

?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class Test:
  def __init__(self):
    print 'init'
  
  def __enter__(self):
    print 'enter'
    return self
  
  def __exit__(self, except_type, except_obj, tb):
    print except_type
    print except_obj
    import traceback
    print ''.join(traceback.format_tb(tb))
    print 'exit'
    return True
  
with Test() as t:
  raise ValueError('kon!')

    实践这一段代码, 输出将会是  

?

1
2
3
4
5
6
7
8
init
enter
<type 'exceptions.ValueError'>
kon!
 File "test.py", line 17, in <module>
  raise ValueError('kon!')
  
exit

     __exit__  函数接受多少个参数, 分别是老大对象类型, 非常对象和调用栈. 要是  with  块日常退出, 那么这个参数将都以  None . 重回  True  表示发生的那多少个已被管理, 不再接续向外抛出.

    轻便的牵线到此停止, 详细的景况能够参谋  PEP 343  (那数字真不错, 7 3 ).

上面介绍下 with 语句的实例用法 & 高端用法:

Python高档、大气、上等级次序的with语句

在说with语句此前,先看看一段简单的代码吧  

?

1
2
3
4
5
lock = threading.Lock()
...
lock.acquire()
elem = heapq.heappop(heap)
lock.release()

很轻易直观,三个线程共用多个事先级队列的时候,首先先用互斥锁lock.acquire()把初期级队列锁上,然后取成分,再然后lock.release()释放那几个锁。

固然看似十一分吻合逻辑的一个进度,然而中间遮蔽着一个受人尊敬的人的bug:当heap内部未有成分的时候,会抛出二个IndexError非常,再然后货仓回滚,再然后lock.release()根本不会执行,这几个锁就永世得不到自由,因而就发出了摄人心魄的死锁难点。这几个也是众多大神们讨厌十分的缘由。杰出Java风格的应用方案正是  

?

1
2
3
4
5
6
7
lock = threading.Lock()
...
lock.acquire()
try:
  elem = heapq.heappop(heap)
finally:
  lock.release()

其一即使能够,不过怎么看怎么dirty,和Python优雅、轻巧的品格出入非常大。其实,自从Python2.5发端引进了with语句,一切就变得非常轻便:  

?

1
2
3
4
lock = threading.Lock()
...
with lock:
  elem = heapq.heappop(heap)

在此无论以何种措施离开with语句的代码块,锁都会被放飞。
with语句的设计目标正是为着使得以前需求经过try...finally化解的清理财富难题变得轻巧、清晰,它的的用法是  

?

1
2
with expression [as variable]:
  with-block

里头expression重临一个名叫「context manager」的靶子,然后那么些指标被赋给variable(假诺部分话)。「context manager」对象有八个法子,分别是__enter__()和__exit__(),很掌握八个在步向with-block时调用,三个偏离with-block的时候调用。

那样的目的无需团结去贯彻,在Python标准Curry面非常多API都以早就完成了这多少个点子,最常见的四个事例正是读写文件的open语句。  

?

1
2
with open('1.txt', encoding = 'utf-8') as fp:
  lines = fp.readlines()

不论是平常离开还是因为十一分原因离开with语句块,展开的文件能源总是会释放。
接下去斟酌一下with语句同盟contextlib库的部分相比实用的措施,比如须要同期张开四个公文,叁个读一个写,这年就足以那样写:  

?

1
2
3
4
from contextlib import nested
...
with nested(open('in.txt'), open('out.txt', 'w')) as (fp_in, fp_out):
  ...

这么就能够省掉三个with的语句的嵌套了,其它如果碰到某些还未曾接济「context manager」的API呢?比方urllib.request.urlopen(),那一个重回的指标因为不是「context manager」,甘休的时候还亟需本人去调用close方法。
恍如这种API,contextlib提供了二个叫作closing方法,它会在离开with语句的时候,自动调用对象的close方法,因而urlopen也能够那样写:  

?

1
2
3
4
5
from contextlib import closing
...
with closing(urllib.request.urlopen('http://www.yahoo.com')) as f:
  for line in f:
    sys.stdout.write(line)

本文由正版必中一肖图发布于编程应用,转载请注明出处:简单介绍Python中的try和finally和with方法

上一篇:知晓Python垃圾回收机制,浅谈python垃圾回收 下一篇:没有了
猜你喜欢
热门排行
精彩图文