Python3.3为改进代码中的异常处理所做的工作

探索异常处理和其他未被充分利用但仍然有用的 Python 特性。

这是 Python 3.x 首发特性系列文章的第四篇。Python 3.3 于 2012 年首次发布，尽管它已经发布了很长时间，但它引入的许多特性都没有得到充分利用，而且相当酷。下面是其中的三个。

yield from

yield 关键字使 Python 更加强大。可以预见的是，人们都开始使用它来创建整个迭代器的生态系统。itertools 模块和 more-itertools PyPI 包就是其中两个例子。

有时，一个新的生成器会想要使用一个现有的生成器。作为一个简单的（尽管有点故意设计）的例子，设想你想枚举所有的自然数对。

一种方法是按照“自然数对的和，自然数对的第一项”的顺序生成所有的自然数对。用 yield from 来实现这个方法是很自然的。

yield from  关键字是以下的简称：

 
 
 
    
  
  
  
  1. for item in x:
    2. 
  
  
  
  2.     yield item
    3. 
 
 
 
 
 
 
    
  
  
  
  1. import itertools
    2. 
  
  
  
  2.  
    3. 
  
  
  
  3. def pairs():
    4. 
  
  
  
  4.  for n in itertools.count():
    5. 
  
  
  
  5.  yield from ((i, n-i) for i in range(n+1))
    6. 
 
 
 
 
 
 
    
  
  
  
  1. list(itertools.islice(pairs(), 6))
    2. 
 
 
 
 
 
 
    
  
  
  
  1.  [(0, 0), (0, 1), (1, 0), (0, 2), (1, 1), (2, 0)]
    2.

隐式命名空间包

假设有一个叫 Parasol 的虚构公司，它制造了一堆东西。它的大部分内部软件都是用 Python 编写的。虽然 Parasol 已经开源了它的一些代码，但其中一些代码对于开源来说过于专有或专业。

该公司使用内部 DevPI 服务器来管理内部软件包。对于 Parasol 的每个 Python 程序员来说，在 PyPI 上找一个未使用的名字是没有意义的，所以所有的内部包都被称为 parasol..。遵守最佳实践，开发人员希望包的名字能反映出这个命名系统。

这一点很重要！如果 parasol.accounting.numeric_tricks 包安装了一个名为 numeric_tricks 的顶层模块，这意味着依赖这个包的人将无法使用名为 numeric_tricks 的 PyPI 包，不管它写的有多好。

然而，这给开发者留下了一个两难的选择：哪个包拥有 parasol/__init__.py 文件？从 Python 3.3 开始，最好的解决办法是把 parasol，可能还有 parasol.accounting，变成没有 __init__.py 文件的 命名空间包。

抑制异常的上下文

有时，在从异常中恢复的过程中出现的异常是一个问题，有上下文来跟踪它是很有用的。然而，有时却不是这样：异常已经被处理了，而新的情况是一个不同的错误状况。

例如，想象一下，在字典中查找一个键失败后，如果不能分析它，则希望失败并返回 ValueError()。

 
 
 
    
  
  
  
  1. import time
    2. 
  
  
  
  2.  
    3. 
  
  
  
  3. def expensive_analysis(data):
    4. 
  
  
  
  4.     time.sleep(10)
    5. 
  
  
  
  5.     if data[0:1] == ">":
    6. 
  
  
  
  6.         return data[1:]
    7. 
  
  
  
  7.     return None
    8.

这个函数需要很长的时间，所以当你使用它时，想要对结果进行缓存：

 
 
 
    
  
  
  
  1. cache = {}
    2. 
  
  
  
  2.  
    3. 
  
  
  
  3. def last_letter_analyzed(data):
    4. 
  
  
  
  4.     try:
    5. 
  
  
  
  5.         analyzed = cache[data]
    6. 
  
  
  
  6.     except KeyError:
    7. 
  
  
  
  7.         analyzed = expensive_analysis(data)
    8. 
  
  
  
  8.         if analyzed is None:
    9. 
  
  
  
  9.             raise ValueError("invalid data", data)
    10. 
  
  
  
  10.         cached[data] = analyzed
    11. 
  
  
  
  11.     return analyzed[-1]
    12.

不幸的是，当出现缓存没有命中时，回溯看起来很难看：

 
 
 
    
  
  
  
  1. last_letter_analyzed("stuff")
    2. 
 
 
 
 
 
 
    
  
  
  
  1.  ---------------------------------------------------------------------------
    2. 
  
  
  
  2.  
    3. 
  
  
  
  3.  KeyError Traceback (most recent call last)
    4. 
  
  
  
  4.  
    5. 
  
  
  
  5.   in last_letter_analyzed(data)
    6. 
  
  
  
  6.  4 try:
    7. 
  
  
  
  7.  ----> 5 analyzed = cache[data]
    8. 
  
  
  
  8.  6 except KeyError:
    9. 
  
  
  
  9.  
    10. 
  
  
  
  10.  
    11. 
  
  
  
  11.  KeyError: 'stuff'
    12.

在处理上述异常的过程中，发生了另一个异常：

 
 
 
    
  
  
  
  1.  ValueError Traceback (most recent call last)
    2. 
  
  
  
  2.  
    3. 
  
  
  
  3.   in 
    4. 
  
  
  
  4.  ----> 1 last_letter_analyzed("stuff")
    5. 
  
  
  
  5.  
    6. 
  
  
  
  6.  
    7. 
  
  
  
  7.   in last_letter_analyzed(data)
    8. 
  
  
  
  8.  7 analyzed = expensive_analysis(data)
    9. 
  
  
  
  9.  8 if analyzed is None:
    10. 
  
  
  
  10.  ----> 9 raise ValueError("invalid data", data)
    11. 
  
  
  
  11.  10 cached[data] = analyzed
    12. 
  
  
  
  12.  11 return analyzed[-1]
    13. 
  
  
  
  13.  
    14. 
  
  
  
  14.  
    15. 
  
  
  
  15.  ValueError: ('invalid data', 'stuff')
    16.

如果你使用 raise ... from None，你可以得到更多可读的回溯：

 
 
 
    
  
  
  
  1. def last_letter_analyzed(data):
    2. 
  
  
  
  2.  try:
    3. 
  
  
  
  3.  analyzed = cache[data]
    4. 
  
  
  
  4.  except KeyError:
    5. 
  
  
  
  5.  analyzed = expensive_analysis(data)
    6. 
  
  
  
  6.  if analyzed is None:
    7. 
  
  
  
  7.  raise ValueError("invalid data", data) from None
    8. 
  
  
  
  8.  cached[data] = analyzed
    9. 
  
  
  
  9.  return analyzed[-1]
    10. 
 
 
 
 
 
 
    
  
  
  
  1. last_letter_analyzed("stuff")
    2. 
 
 
 
 
 
 
    
  
  
  
  1.  ---------------------------------------------------------------------------
    2. 
  
  
  
  2.  
    3. 
  
  
  
  3.  ValueError Traceback (most recent call last)
    4. 
  
  
  
  4.  
    5. 
  
  
  
  5.   in 
    6. 
  
  
  
  6.  ----> 1 last_letter_analyzed("stuff")
    7. 
  
  
  
  7.  
    8. 
  
  
  
  8.  
    9. 
  
  
  
  9.   in last_letter_analyzed(data)
    10. 
  
  
  
  10.  5 analyzed = expensive_analysis(data)
    11. 
  
  
  
  11.  6 if analyzed is None:
    12. 
  
  
  
  12.  ----> 7 raise ValueError("invalid data", data) from None
    13. 
  
  
  
  13.  8 cached[data] = analyzed
    14. 
  
  
  
  14.  9 return analyzed[-1]
    15. 
  
  
  
  15.  
    16. 
  
  
  
  16.  
    17. 
  
  
  
  17.  ValueError: ('invalid data', 'stuff')
    18.

欢迎来到 2012 年

尽管 Python 3.3 在十年前就已经发布了，但它的许多功能仍然很酷，而且没有得到充分利用。如果你还没有，就把它们添加到你的工具箱中吧。 

分享文章：Python3.3为改进代码中的异常处理所做的工作
文章出自：http://www.hantingmc.com/qtweb/news16/456616.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

网站设计公司知识

同城分类信息

成都移动服务器托管　　 　成都app软件开发　　 　网站搜索引擎优化　　 　营山网站建设　　 　成都艺考培训　　 　高端网站设计　　 　成都二枢机房　　 　一带一路　　 　成都户外广告牌设计　　 　绵阳服务器托管　　 　成都封阳台　　 　香港四川國際商會　　 　微博营销　　 　小谭网创广告　　 　郫县封阳台　　 　成都宣传海报　　 　小谭网创广告　　 　成都定制网站开发　　 　网站运营　　 　成都西信服务器托管