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

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

@ 操作符

@ 操作符在 Python 中是独一无二的，因为在标准库中没有任何对象可以实现它！它是为了在有矩阵的数学包中使用而添加的。

矩阵有两个乘法的概念。元素积是用 * 运算符完成的。但是矩阵组合（也被认为是乘法）需要自己的符号。它是用 @ 完成的。

例如，将一个“八转”矩阵（将轴旋转 45 度）与自身合成，就会产生一个四转矩阵。

import numpy

hrt2 = 2**0.5 / 2
eighth_turn = numpy.array([
    [hrt2, hrt2],
    [-hrt2, hrt2]
])
eighth_turn @ eighth_turn

    array([[ 4.26642159e-17,  1.00000000e+00],
           [-1.00000000e+00, -4.26642159e-17]])

浮点数是不精确的，这比较难以看出。从结果中减去四转矩阵，将其平方相加，然后取其平方根，这样就比较容易检查。

这是新运算符的一个优点：特别是在复杂的公式中，代码看起来更像基础数学：

almost_zero = ((eighth_turn @ eighth_turn) - numpy.array([[0, 1], [-1, 0]]))**2
round(numpy.sum(almost_zero) ** 0.5, 10)

    0.0

参数中的多个关键词字典

Python 3.5 使得调用具有多个关键字-参数字典的函数成为可能。这意味着多个默认值的源可以与更清晰的代码”互操作“。

例如，这里有个可笑的关键字参数的函数：

def show_status(
    *,
    the_good=None,
    the_bad=None,
    the_ugly=None,
    fistful=None,
    dollars=None,
    more=None
):
    if the_good:
        print("Good", the_good)
    if the_bad:
        print("Bad", the_bad)
    if the_ugly:
        print("Ugly", the_ugly)
    if fistful:
        print("Fist", fistful)
    if dollars:
        print("Dollars", dollars)
    if more:
        print("More", more)

当你在应用中调用这个函数时，有些参数是硬编码的：

defaults = dict(
    the_good="You dig",
    the_bad="I have to have respect",
    the_ugly="Shoot, don't talk",
)

从配置文件中读取更多参数：

import json

others = json.loads("""
{
"fistful": "Get three coffins ready",
"dollars": "Remember me?",
"more": "It's a small world"
}
""")

你可以从两个源一起调用这个函数，而不必构建一个中间字典：

show_status(**defaults, **others)

    Good You dig
    Bad I have to have respect
    Ugly Shoot, don't talk
    Fist Get three coffins ready
    Dollars Remember me?
    More It's a small world

os.scandir

os.scandir 函数是一种新的方法来遍历目录内容。它返回一个生成器，产生关于每个对象的丰富数据。例如，这里有一种打印目录清单的方法，在目录的末尾跟着 /：

for entry in os.scandir(".git"):
    print(entry.name + ("/" if entry.is_dir() else ""))

    refs/
    HEAD
    logs/
    index
    branches/
    config
    objects/
    description
    COMMIT_EDITMSG
    info/
    hooks/

欢迎来到 2015 年

Python 3.5 在六年前就已经发布了，但是在这个版本中首次出现的一些特性非常酷，而且没有得到充分利用。如果你还没使用，那么将他们添加到你的工具箱中。

via: https://opensource.com/article/21/5/python-35-features

作者：Moshe Zadka 选题：lujun9972 译者：geekpi 校对：wxy

本文由 LCTT 原创编译，Linux中国 荣誉推出

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

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

枚举

我最喜欢的逻辑谜题之一是自我描述的 史上最难的逻辑谜题。在其中，它谈到了三个“神”，他们被称为 A、B 和 C，他们的身份是真、假和随机，按一定顺序排列。你可以问他们问题，但他们只用神的语言回答，其中 “da” 和 “ja” 表示 “是” 和 “不是”，但你不知道哪个是哪个。

如果你决定使用 Python 来解决这个问题，你将如何表示神的名字和身份以及神的语言中的词语？传统的答案是使用字符串。然而，字符串的拼写错误可能会带来灾难性的后果。

如果在解题的关键部分，你用字符串 “jaa” 而不是 “ja” 进行比较，你就会得到一个错误的答案。虽然谜题没有说明风险是什么，但这可能是最好的避免方式。

enum 模块让你能够以一种可调试但安全的方式来定义这些东西：

import enum

@enum.unique
class Name(enum.Enum):
    A = enum.auto()
    B = enum.auto()
    C = enum.auto()
   
@enum.unique
class Identity(enum.Enum):
    RANDOM = enum.auto()
    TRUE = enum.auto()
    FALSE = enum.auto()

       
@enum.unique
class Language(enum.Enum):
    ja = enum.auto()
    da = enum.auto()

枚举的一个好处是，在调试日志或异常中，枚举的呈现方式是有帮助的：

name = Name.A
identity = Identity.RANDOM
answer = Language.da
print("I suspect", name, "is", identity, "because they answered", answer)

    I suspect Name.A is Identity.RANDOM because they answered Language.da

functools.singledispatch

在开发游戏的“基础设施”层时，你想通用地处理各种游戏对象，但仍然允许这些对象自定义动作。为了使这个例子更容易解释，假设这是一个基于文本的游戏。当你使用一个对象时，大多数情况下，它只会打印 You are using <x>。但是使用一把特殊的剑可能需要随机滚动，否则会失败。

当你获得一个物品时，它通常会被添加到库存中。然而，一块特别重的石头会砸碎一个随机物品。如果发生这种情况，库存中会失去该物体。

处理这个问题的一个方法是在物品上设置 use 和 acquire 方法。随着游戏复杂性的增加，这些方法会越来越多，使游戏对象变得难以编写。

相反，functools.singledispatch 允许你以安全和尊重命名空间的方式追溯性地添加方法。

你可以定义没有行为的类：

class Torch:
    name="torch"

class Sword:
    name="sword"

class Rock:
    name="rock"

import functools

@functools.singledispatch
def use(x):
    print("You use", x.name)

@functools.singledispatch
def acquire(x, inventory):
    inventory.add(x)

对于火炬来说，这些通用的实现已经足够了：

inventory = set()

def deploy(thing):
    acquire(thing, inventory)
    use(thing)
    print("You have", [item.name for item in inventory])

deploy(Torch())

    You use torch
    You have ['torch']

然而，剑和石头需要一些专门的功能：

import random

@use.register(Sword)
def use_sword(sword):
    print("You try to use", sword.name)
    if random.random() < 0.9:
        print("You succeed")
    else:
        print("You fail")

deploy(sword)

    You try to use sword
    You succeed
    You have ['sword', 'torch']

import random

@acquire.register(Rock)
def acquire_rock(rock, inventory):
    to_remove = random.choice(list(inventory))
    inventory.remove(to_remove)
    inventory.add(rock)

deploy(Rock())

    You use rock
    You have ['sword', 'rock']

岩石可能压碎了火炬，但你的代码更容易阅读。

pathlib

从一开始，Python 中文件路径的接口就是“智能字符串操作”。现在，通过 pathlib，Python 有了一种面向对象的方法来操作路径。

import pathlib

gitconfig = pathlib.Path.home() / ".gitconfig"
text = gitconfig.read_text().splitlines()

诚然，用 / 作为操作符来生成路径名有点俗气，但在实践中却不错。像 .read_text() 这样的方法允许你从小文件中获取文本，而不需要手动打开和关闭文件句柄。

这使你可以集中精力处理重要的事情：

for line in text:
    if not line.strip().startswith("name"):
        continue
    print(line.split("=")[1])

     Moshe Zadka

欢迎来到 2014 年

Python 3.4 大约在七年前就发布了，但是在这个版本中首次出现的一些功能非常酷，而且没有得到充分利用。如果你还没使用，那么将他们添加到你的工具箱中。

via: https://opensource.com/article/21/5/python-34-features

作者：Moshe Zadka 选题：lujun9972 译者：geekpi 校对：wxy

本文由 LCTT 原创编译，Linux中国 荣誉推出

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

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

yield from

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

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

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

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

for item in x:
    yield item

import itertools

def pairs():
    for n in itertools.count():
        yield from ((i, n-i) for i in range(n+1))

list(itertools.islice(pairs(), 6))

    [(0, 0), (0, 1), (1, 0), (0, 2), (1, 1), (2, 0)]

隐式命名空间包

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

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

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

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

抑制异常的上下文

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

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

import time

def expensive_analysis(data):
    time.sleep(10)
    if data[0:1] == ">":
        return data[1:]
    return None

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

cache = {}

def last_letter_analyzed(data):
    try:
        analyzed = cache[data]
    except KeyError:
        analyzed = expensive_analysis(data)
        if analyzed is None:
            raise ValueError("invalid data", data)
        cached[data] = analyzed
    return analyzed[-1]

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

last_letter_analyzed("stuff")

    ---------------------------------------------------------------------------

    KeyError                                  Traceback (most recent call last)

    <ipython-input-16-a525ae35267b> in last_letter_analyzed(data)
          4     try:
    ----> 5         analyzed = cache[data]
          6     except KeyError:


    KeyError: 'stuff'

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

    ValueError                                Traceback (most recent call last)

    <ipython-input-17-40dab921f9a9> in <module>
    ----> 1 last_letter_analyzed("stuff")
   

    <ipython-input-16-a525ae35267b> in last_letter_analyzed(data)
          7         analyzed = expensive_analysis(data)
          8         if analyzed is None:
    ----> 9             raise ValueError("invalid data", data)
         10         cached[data] = analyzed
         11     return analyzed[-1]


    ValueError: ('invalid data', 'stuff')

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

def last_letter_analyzed(data):
    try:
        analyzed = cache[data]
    except KeyError:
        analyzed = expensive_analysis(data)
        if analyzed is None:
            raise ValueError("invalid data", data) from None
        cached[data] = analyzed
    return analyzed[-1]

last_letter_analyzed("stuff")

    ---------------------------------------------------------------------------

    ValueError                                Traceback (most recent call last)

    <ipython-input-21-40dab921f9a9> in <module>
    ----> 1 last_letter_analyzed("stuff")
   

    <ipython-input-20-5691e33edfbc> in last_letter_analyzed(data)
          5         analyzed = expensive_analysis(data)
          6         if analyzed is None:
    ----> 7             raise ValueError("invalid data", data) from None
          8         cached[data] = analyzed
          9     return analyzed[-1]


    ValueError: ('invalid data', 'stuff')

欢迎来到 2012 年

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

via: https://opensource.com/article/21/5/python-33

作者：Moshe Zadka 选题：lujun9972 译者：wxy 校对：wxy

本文由 LCTT 原创编译，Linux中国 荣誉推出

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

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

argparse 子命令

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

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

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

$ computebot negate 5
-5
$ computebot multiply 2 3
6

import argparse

parser = argparse.ArgumentParser()
subparsers = parser.add_subparsers()

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

negate  = subparsers.add_parser("negate")
negate.set_defaults(subcommand="negate")
negate.add_argument("number", type=float)

multiply  = subparsers.add_parser("multiply")
multiply.set_defaults(subcommand="multiply")
multiply.add_argument("number1", type=float)
multiply.add_argument("number2", type=float)

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

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

    Namespace(number=5.0, subcommand='negate')

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

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

contextlib.contextmanager

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

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

import contextlib, timeit

@contextlib.contextmanager
def timer():
    before = timeit.default_timer()
    try:
        yield
    finally:
        after = timeit.default_timer()
        print("took", after - before)

你可以这样使用：

import time

with timer():
    time.sleep(10.5)

    took 10.511025413870811`

functools.lru\_cache

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

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

def change_for_a_dollar():
    def change_for(amount, coins):
        if amount == 0:
            return 1
        if amount < 0 or len(coins) == 0:
            return 0
        some_coin = next(iter(coins))
        return (
            change_for(amount, coins - set([some_coin]))
            +
            change_for(amount - some_coin, coins)
        )
    return change_for(100, frozenset([25, 10, 5, 1]))

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

with timer():
    change_for_a_dollar()

    took 0.013737603090703487`

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

import functools

def change_for_a_dollar():
    @functools.lru_cache
    def change_for(amount, coins):
        if amount == 0:
            return 1
        if amount < 0 or len(coins) == 0:
            return 0
        some_coin = next(iter(coins))
        return (
            change_for(amount, coins - set([some_coin]))
            +
            change_for(amount - some_coin, coins)
        )
    return change_for(100, frozenset([25, 10, 5, 1]))

with timer():
    change_for_a_dollar()

    took 0.004180959425866604`

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

欢迎来到 2011 年

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

via: https://opensource.com/article/21/5/python-32

作者：Moshe Zadka 选题：lujun9972 译者：geekpi 校对：wxy

本文由 LCTT 原创编译，Linux中国 荣誉推出

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

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

千位数格式化

在格式化大数时，通常是每三位数放置逗号，使数字更易读（例如，1,048,576 比 1048576 更容易读）。从 Python 3.1 开始，可以在使用字符串格式化函数时直接完成：

"2 to the 20th power is {:,d}".format(2**20)

'2 to the 20th power is 1,048,576'

,d 格式符表示数字必须用逗号格式化。

Counter 类

collections.Counter 类是标准库模块 collections 的一部分，是 Python 中的一个秘密超级武器。它经常在 Python 的面试题的简单解答中首次遇到，但它的价值并不限于此。

例如，在 Humpty Dumpty 的歌 的前八行中找出五个最常见的字母：

hd_song = """
In winter, when the fields are white,
I sing this song for your delight.

In Spring, when woods are getting green,
I'll try and tell you what I mean.

In Summer, when the days are long,
Perhaps you'll understand the song.

In Autumn, when the leaves are brown,
Take pen and ink, and write it down.
"""

import collections

collections.Counter(hd_song.lower().replace(' ', '')).most_common(5)

[('e', 29), ('n', 27), ('i', 18), ('t', 18), ('r', 15)]

执行软件包

Python 允许使用 -m 标志来从命令行执行模块。甚至一些标准库模块在被执行时也会做一些有用的事情；例如，python -m cgi 是一个 CGI 脚本，用来调试网络服务器的 CGI 配置。

然而，直到 Python 3.1，都不可能像这样执行 软件包。从 Python 3.1 开始，python -m package 将执行软件包中的 __main__ 模块。这是一个放调试脚本或命令的好地方，这些脚本主要是用工具执行的，不需要很短。

Python 3.0 在 11 年前就已经发布了，但是在这个版本中首次出现的一些功能是很酷的，而且没有得到充分利用。如果你还没使用，那么将它们添加到你的工具箱中。

via: https://opensource.com/article/21/5/python-31-features

作者：Moshe Zadka 选题：lujun9972 译者：geekpi 校对：wxy

本文由 LCTT 原创编译，Linux中国 荣誉推出

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

这是 Python 3.x 首发特性系列文章的第一篇。Python 3.0 于 2008 年首次发布，尽管它已经发布了一段时间，但它引入的许多特性都没有被充分利用，而且相当酷。这里有三个你应该知道的。

仅限关键字参数

Python 3.0 首次引入了仅限关键字参数参数的概念。在这之前，不可能指定一个只通过关键字传递某些参数的 API。这在有许多参数，其中一些参数可能是可选的函数中很有用。

请看一个特意设计的例子：

def show_arguments(base, extended=None, improved=None, augmented=None):
    print("base is", base)
    if extended is not None:
        print("extended is", extended)
    if improved is not None:
        print("improved is", improved)
    if augmented is not None:
        print("augmented is", augmented)

当阅读调用该函数的代码时，有时很难理解发生了什么：

show_arguments("hello", "extra")

    base is hello
    extended is extra

show_arguments("hello", None, "extra")

    base is hello
    improved is extra

虽然可以用关键字参数来调用这个函数，但这明显不是最好的方法。相反，你可以将这些参数标记为仅限关键字：

def show_arguments(base, *, extended=None, improved=None, augmented=None):
    print("base is", base)
    if extended is not None:
        print("extended is", extended)
    if improved is not None:
        print("improved is", improved)
    if augmented is not None:
        print("augmented is", augmented)

现在，你不能用位置参数传入额外的参数：

show_arguments("hello", "extra")
    ---------------------------------------------------------------------------

    TypeError                                 Traceback (most recent call last)

    <ipython-input-7-6000400c4441> in <module>
    ----> 1 show_arguments("hello", "extra")
   

    TypeError: show_arguments() takes 1 positional argument but 2 were given

对该函数的有效调用更容易预测：

show_arguments("hello", improved="extra")
    base is hello
    improved is extra

nonlocal

有时，函数式编程的人根据编写累加器的难易程度来判断一种语言。累加器是一个函数，当它被调用时，返回目前为止发给它的所有参数的总和。

在 3.0 之前，Python 的标准答案是：

class _Accumulator:
    def __init__(self):
        self._so_far = 0
    def __call__(self, arg):
        self._so_far += arg
        return self._so_far

def make_accumulator():
    return _Accumulator()

虽然我承认有些啰嗦，但这确实有效：

acc = make_accumulator()
print("1", acc(1))
print("5", acc(5))
print("3", acc(3))

这样做的输出结果将是：

1 1
5 6
3 9

在 Python 3.x 中，nonlocal 关键字可以用少得多的代码实现同样的行为。

def make_accumulator():
    so_far = 0
    def accumulate(arg):
        nonlocal so_far
        so_far += arg
        return so_far
    return accumulate

虽然累加器是人为的例子，但使用 nonlocal 关键字使内部函数拥有具有状态的的能力是一个强大的工具。

扩展析构

想象一下，你有一个 CSV 文件，每一行由几个元素组成：

• 第一个元素是年份
• 第二个元素是月
• 其他元素是该月发表的全部文章数，每天一个条目

请注意，最后一个元素是 文章总数，而不是 每天发表的文章。例如，一行的开头可以是：

2021,1,5,8,10

这意味着在 2021 年 1 月，第一天发表了 5 篇文章。第二天，又发表了三篇文章，使总数达到 8 篇。第三天，又发表了两篇文章。

一个月可以有 28 天、30 天或 31 天。提取月份、日期和文章总数有多难？

在 3.0 之前的 Python 版本中，你可能会这样写：

year, month, total = row[0], row[1], row[-1]

这是正确的，但它掩盖了格式。使用扩展析构，同样可以这样表达：

year, month, *rest, total = row

这意味着如果该格式改为前缀了一个描述，你可以把代码改成：

_, year, month, *rest, total = row

而不需要在每个索引中添加 1。

接下来是什么？

Python 3.0 和它的后期版本已经推出了 12 年多，但是它的一些功能还没有被充分利用。在本系列的下一篇文章中，我将会写另外三个。

via: https://opensource.com/article/21/5/python-30-features

作者：Moshe Zadka 选题：lujun9972 译者：geekpi 校对：wxy

本文由 LCTT 原创编译，Linux中国 荣誉推出