3 个到今天仍然有用的 Python 3.2 特性

探索一些未被充分利用但仍然有用的 Python 特性。

目前成都创新互联公司已为上1000+的企业提供了网站建设、域名、雅安服务器托管、网站托管、服务器托管、企业网站设计、向阳网站维护等服务，公司将坚持客户导向、应用为本的策略，正道将秉承"和谐、参与、激情"的文化，与客户和合作伙伴齐心协力一起成长，共同发展。

这是Python 3.x 首发特性系列文章中的第三篇。其中一些 Python 版本已经推出了一段时间。例如，Python 3.2 是在 2011 年首次发布的，但其中引入的一些很酷、很有用的特性仍然没有被使用。下面是其中的三个。

argparse 子命令

argparse 模块首次出现在 Python 3.2 中。有许多用于命令行解析的第三方模块。但是内置的 argparse 模块比许多人认为的要强大。

要记录所有的 argparse 的特性，那需要专门写系列文章。下面是一个例子，说明如何用 argparse 做子命令。

想象一下，一个命令有两个子命令：negate，需要一个参数，multiply，需要两个参数：

 
 
 
      
  
  
  1. $ computebot negate 5
    2.   
  
  
  2. -5
    3.   
  
  
  3. $ computebot multiply 2 3
    4.   
  
  
  4. 6
    5.  
 

 
 
 
      
  
  
  1. import argparse
    2.   
  
  
  2.  
    3.   
  
  
  3. parser = argparse.ArgumentParser()
    4.   
  
  
  4. subparsers = parser.add_subparsers()
    5.

add_subparsers() 方法创建一个对象，你可以向其添加子命令。唯一需要记住的技巧是，你需要添加通过 set_defaults() 调用的子命令：

 
 
 
      
  
  
  1. negate = subparsers.add_parser("negate")
    2.   
  
  
  2. negate.set_defaults(subcommand="negate")
    3.   
  
  
  3. negate.add_argument("number", type=float)
    4.  
 

 
 
 
      
  
  
  1. multiply = subparsers.add_parser("multiply")
    2.   
  
  
  2. multiply.set_defaults(subcommand="multiply")
    3.   
  
  
  3. multiply.add_argument("number1", type=float)
    4.   
  
  
  4. multiply.add_argument("number2", type=float)
    5.

我最喜欢的一个 argparse 功能是，因为它把解析和运行分开，测试解析逻辑特别令人愉快。

 
 
 
      
  
  
  1. parser.parse_args(["negate", "5"])
    2.  
 

 
 
 
      
  
  
  1.  Namespace(number=5.0, subcommand='negate')
    2.  
 

 
 
 
      
  
  
  1. parser.parse_args(["multiply", "2", "3"])
    2.  
 

 
 
 
      
  
  
  1.  Namespace(number1=2.0, number2=3.0, subcommand='multiply')
    2.

contextlib.contextmanager

上下文是 Python 中一个强大的工具。虽然很多人 使用 它们，但编写一个新的上下文常常看起来像一门黑暗艺术。有了 contextmanager 装饰器，你所需要的只是一个一次性的生成器。

编写一个打印出做某事所需时间的上下文，就像这样简单：

 
 
 
      
  
  
  1. import contextlib, timeit
    2.   
  
  
  2.  
    3.   
  
  
  3. @contextlib.contextmanager
    4.   
  
  
  4. def timer():
    5.   
  
  
  5.  before = timeit.default_timer()
    6.   
  
  
  6.  try:
    7.   
  
  
  7.  yield
    8.   
  
  
  8.  finally:
    9.   
  
  
  9.  after = timeit.default_timer()
    10.   
  
  
  10.  print("took", after - before)
    11.

你可以这样使用：

 
 
 
      
  
  
  1. import time
    2.   
  
  
  2.  
    3.   
  
  
  3. with timer():
    4.   
  
  
  4.  time.sleep(10.5)
    5.  
 

 
 
 
      
  
  
  1.  took 10.511025413870811`
    2.

functools.lru_cache

有时，在内存中缓存一个函数的结果是有意义的。例如，想象一下经典的问题：“有多少种方法可以用 25 美分、1 美分、2 美分和 3 美分可以来换取 1 美元？”

这个问题的代码可以说是非常简单：

 
 
 
      
  
  
  1. def change_for_a_dollar():
    2.   
  
  
  2.  def change_for(amount, coins):
    3.   
  
  
  3.  if amount == 0:
    4.   
  
  
  4.  return 1
    5.   
  
  
  5.  if amount < 0 or len(coins) == 0:
    6.   
  
  
  6.  return 0
    7.   
  
  
  7.  some_coin = next(iter(coins))
    8.   
  
  
  8.  return (
    9.   
  
  
  9.  change_for(amount, coins - set([some_coin]))
    10.   
  
  
  10.  +
    11.   
  
  
  11.  change_for(amount - some_coin, coins)
    12.   
  
  
  12.  )
    13.   
  
  
  13.  return change_for(100, frozenset([25, 10, 5, 1]))
    14.

在我的电脑上，这需要 13ms 左右：

 
 
 
      
  
  
  1. with timer():
    2.   
  
  
  2.  change_for_a_dollar()
    3.  
 

 
 
 
      
  
  
  1.  took 0.013737603090703487`
    2.

事实证明，当你计算有多少种方法可以做一些事情，比如用 50 美分找钱，你会重复使用相同的硬币。你可以使用 lru_cache 来避免重复计算。

 
 
 
      
  
  
  1. import functools
    2.   
  
  
  2.  
    3.   
  
  
  3. def change_for_a_dollar():
    4.   
  
  
  4.  @functools.lru_cache
    5.   
  
  
  5.  def change_for(amount, coins):
    6.   
  
  
  6.  if amount == 0:
    7.   
  
  
  7.  return 1
    8.   
  
  
  8.  if amount < 0 or len(coins) == 0:
    9.   
  
  
  9.  return 0
    10.   
  
  
  10.  some_coin = next(iter(coins))
    11.   
  
  
  11.  return (
    12.   
  
  
  12.  change_for(amount, coins - set([some_coin]))
    13.   
  
  
  13.  +
    14.   
  
  
  14.  change_for(amount - some_coin, coins)
    15.   
  
  
  15.  )
    16.   
  
  
  16.  return change_for(100, frozenset([25, 10, 5, 1]))
    17.  
 

 
 
 
      
  
  
  1. with timer():
    2.   
  
  
  2.  change_for_a_dollar()
    3.  
 

 
 
 
      
  
  
  1.  took 0.004180959425866604`
    2.

一行的代价是三倍的改进。不错。

欢迎来到 2011 年

尽管 Python 3.2 是在 10 年前发布的，但它的许多特性仍然很酷，而且没有得到充分利用。如果你还没使用，那么将他们添加到你的工具箱中。

文章标题：3 个到今天仍然有用的 Python 3.2 特性
浏览地址：http://www.36103.cn/qtweb/news39/8239.html

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

广告

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

猜你还喜欢下面的内容

网站策划知识

同城分类信息

虚拟主机　　 　东电技服　　 　合江网站建设　　 　成都app软件开发公司　　 　吉安网站建设　　 　合江网站建设　　 　网络推广外包　　 　造型师设计　　 　西云服务器托管　　 　电信服务器托管　　 　整合营销　　 　鸿程源茂　　 　邛崃做网站　　 　广汉锦华建材　　 　汕尾凯敏网站　　 　腾讯云香港虚拟主机　　 　IDC机房托管　　 　托管服务器　　 　成都网站推广　　 　手机网站建设套餐