Python编程

Python 是一种强烈惯用语的语言：通常做某件事有一个最佳的方式（编程惯用法），而不是多种方式：“There’s more than one way to do it” 并不是 Python 的座右铭。

本节开始介绍一些基本原则，然后逐步讲解语言中的惯用法，重点介绍如何惯用地使用操作、数据类型和标准库中的模块。

原则

• 使用异常进行错误检查，遵循 EAFP（It's Easier to Ask Forgiveness than Permission），而不是 LBYL（Look Before You Leap）：将可能失败的操作放入 try...except 块中。
• 使用上下文管理器来管理资源，如文件。使用 finally 进行临时清理，但建议编写上下文管理器来封装这些操作。
• 使用属性而非 getter/setter 方法。
• 使用字典表示动态记录，使用类表示静态记录（对于简单的类，使用 collections.namedtuple）：如果记录总是有相同的字段，则在类中显式定义这些字段；如果字段可能会变化（存在或不存在），则使用字典。
• 使用 _ 表示一次性变量，如丢弃返回值时使用元组返回，或表示参数被忽略（在需要接口时）。你也可以使用 *_, **__ 来丢弃传递给函数的位置参数或关键字参数：这些对应于通常的 *args, **kwargs 参数，但被显式丢弃。你也可以在使用的位置参数或命名参数之后使用它们，允许你使用一些参数并丢弃多余的参数。
• 使用隐式的 True/False（真值/假值），除非需要区分假值，如 None、0 和 []，此时应使用显式检查，如 is None 或 == 0。
• 使用可选的 else 子句，在 try、for 和 while 后都可以使用，而不仅仅是 if。

导入

为了提高代码的可读性和健壮性，只导入模块，而不是名称（如函数或类），因为这样会创建一个新的（名称）绑定，而这个绑定不一定与现有绑定同步。例如，给定一个定义了函数 f 的模块 m，通过 from m import f 导入该函数时，如果对 m.f 或 f 进行赋值，它们的值会不一致，因为它们分别创建了新的绑定。

在实际开发中，这通常被忽略，特别是在小规模代码中，因为修改导入后模块的内容很少见，所以这通常不是问题，模块中的类和函数被导入后可以直接使用，无需前缀。但是，在健壮的大规模代码中，这条规则很重要，因为它可能会引发非常细微的错误。

对于健壮的代码且减少键入，可以使用重命名导入来简化长模块名：

import module_with_very_long_name as vl
vl.f()  # 比module_with_very_long_name.f 更简洁，但依然健壮

请注意，从包中导入子模块（或子包）使用 from 是完全可以的：

from p import sm  # 完全可以
sm.f()

操作

• 交换值

  b, a = a, b
  

• 对可能为 null 的值进行属性访问
  要访问一个可能是对象，也可能是 None 的值的属性（特别是调用方法），可以使用 and 的布尔短路特性：

  a and a.x
  a and a.f()
  

  特别有用的是正则表达式匹配：

  match and match.group(0)
  

• 使用 in 进行子字符串检查
  使用 in 检查子字符串。

数据类型

• 所有序列类型

  • 在迭代过程中进行索引
    如果你需要跟踪迭代周期，可以使用 enumerate()：

    for i, x in enumerate(l):
        # ...
    

    不推荐的做法：

    for i in range(len(l)):
        x = l[i]  # 为什么从列表转到数字，再转回列表？
        # ...
    

  • 找到第一个匹配的元素
    Python 的序列有一个 index 方法，但它返回的是序列中指定值的第一次出现的位置。要找到满足条件的第一个值，应该使用 next 和生成器表达式：

    try:
        x = next(i for i, n in enumerate(l) if n > 0)
    except StopIteration:
        print('No positive numbers')
    else:
        print('The index of the first positive number is', x)
    

    如果你需要的是值，而不是它的索引，可以直接通过以下方式获取：

    try:
        x = next(n for n in l if n > 0)
    except StopIteration:
        print('No positive numbers')
    else:
        print('The first positive number is', x)
    

    这样做的原因有两个：

    1. 异常允许你标示“没有找到匹配项”（解决了半谓词问题）：因为你返回的是一个值（而不是索引），所以无法将其作为值返回。
    2. 生成器表达式让你使用一个表达式而不需要引入 lambda 或新的语法。

  • 截断
    对于可变序列，使用 del 而不是重新分配给一个切片：

    del l[j:]
    del l[:i]
    

    不推荐的做法：

    l = l[:j]
    l = l[i:]
    

    最简单的原因是，del 可以清晰地表达你的意图：你正在截断数据。

    更微妙的是，切片会创建对同一个列表的另一个引用（因为列表是可变的），然后无法访问的数据可以被垃圾回收，但通常这是稍后才发生的。使用 del 则会立即就地修改列表（这比创建一个切片然后将其分配给现有变量要快），并允许 Python 立即释放已删除的元素，而不是等待垃圾回收。

    在某些情况下，你确实需要对同一个列表进行两个切片——虽然在基本编程中这种情况很少见，除非是在 for 循环中迭代切片，但通常你不会想先切出整个列表的一个切片，然后替换原来的列表变量为切片（但不更改其他切片！），例如下面这个看起来有点奇怪的代码：

    m = l
    l = l[i:j]  # 为什么不直接是 m = l[i:j]？
    

    从可迭代对象创建排序列表

    你可以直接从任何可迭代对象创建一个排序的列表，而无需先创建列表然后再排序。这些包括集合和字典（在字典上迭代时默认是迭代键）：

    s = {1, 'a', ...}
    l = sorted(s)
    d = {'a': 1, ...}
    l = sorted(d)
    

    元组

    对于常量序列使用元组。通常这不是必须的（主要是在用作字典键时），但能明确表达意图。

    字符串

    • 子字符串检查

      使用 in 来检查子字符串。

      但是，不要使用 in 来检查一个字符串是否是单个字符的匹配，因为它会匹配子字符串并可能返回虚假的匹配——应使用有效值的元组。例如，下面的代码是错误的：

      def valid_sign(sign):
          return sign in '+-'  # 错误，会在 sign == '+-' 时返回 True
      

      正确的做法是使用元组：

      def valid_sign(sign):
          return sign in ('+', '-')
      

    • 构建字符串

      为了逐步构建一个长字符串，应该先构建一个列表，然后用 ''（或换行符，如果你在构建文本文件的话）将它们连接起来。这样比在字符串上反复追加要快而且清晰。字符串追加通常是慢的，原则上可能会是 O(nk) 复杂度，其中 n 是字符串的总长度，k 是追加的次数（如果每次追加的字符串大小相似，那么时间复杂度可能是 O(n²)）。

      然而，在某些版本的 CPython 中，简单的字符串追加已经变得很快——在 CPython 2.5+ 和 CPython 3.0+ 中，字节串的追加非常快，但对于构建 Unicode 字符串（Python 2 中的 unicode，Python 3 中的 string），使用 join 更快。如果进行大量字符串操作，请留意这一点并对代码进行性能分析。

      不要这样做：

      s = ''
      for x in l:
          # 每次迭代都会创建一个新字符串，因为字符串是不可变的
          s += x
      

      改成这样：

      s = ''.join(l)
      

      你甚至可以使用生成器表达式，这非常高效：

      s = ''.join(f(x) for x in l)
      

      如果你需要一个可变的类字符串对象，你可以使用 StringIO。

    字典

    • 迭代字典

      可以通过字典的键、值或两者来迭代：

      • 迭代键：

        for k in d:
            ...
        

      • 迭代值（Python 3）：

        for v in d.values():
            ...
        

      • 迭代值（Python 2）：

        for v in d.itervalues():
            ...
        

      • 迭代键和值（Python 3）：

        for k, v in d.items():
            ...
        

      • 迭代键和值（Python 2）：

        for k, v in d.iteritems():
            ...
        

      反模式：

      • 如果只需要键，避免使用 for k, _ in d.items()，改为 for k in d:。
      • 如果只需要值，避免使用 for _, v in d.items()，改为 for v in d.values()。

      FIXME：

      • 使用 setdefault 时，通常最好使用 collections.defaultdict。
      • dict.get 是有用的，但如果将其与 None 进行比较作为测试键是否存在的方法，这是反惯用法，因为 None 是一个潜在的值，检查键是否存在可以直接使用 in 来做。

      简单做法：

      if 'k' in d:
          # ... d['k']
      

      反惯用法（除非 None 不是潜在值）：

      v = d.get('k')
      if v is not None:
          # ... v
      

    • 从并行的键和值序列创建字典

      使用 zip 创建字典：

      dict(zip(keys, values))
      

    模块

    • re

      如果匹配成功，则返回匹配对象，否则返回 None：

      match = re.match(r, s)
      return match and match.group(0)
      

      如果没有匹配，返回 None，如果有匹配，则返回匹配的内容。