100 个鲜为人知的 Python 高级技巧 41-60

痛定思痛。 2024-03-23 18:52 110阅读 0赞

系列的第 3 节 41-60 snippet code

1.  webbrowser.open()

如果要在默认浏览器（由操作系统定义）中打开 URL，请执行以下操作

import webbrowser
    
    webbrowser.open("http://localhost:8080")

1.  `copy()` 深浅的区别

doesn’t always really copy 并不总是复制

要复制一个 list 或 dict，你可以写 my\_list.copy() 或 my\_dict.copy()。

到此为止，一切顺利。但是，如果你认为对原始版本的更改不会影响到副本，那么我很遗憾地告诉你，你错了。

copy()会创建一个新的列表，但列表中的每个 dict 都是对原始列表中同一对象的引用。

下图显示了对 list-of-dicts 进行浅复制和深复制（真正进行复制）的区别。

from copy import deepcopy
    
    my_list = [{
        "one": 1}]
    
    # # 创建两个地址并不同的副本
    shallow_copy = my_list.copy()
    deep_copy = deepcopy(my_list)
    
    # 更改原始数据
    my_list.append({
        "two": 2})
    my_list[0]["one"] = 77 
    
    # 查看更改
    assert my_list == [{
        "one": 77}, {
        "two": 2}]
    assert shallow_copy == [{
        "one": 77}]  # Mutated!
    assert deep_copy == [{
        "one": 1}]

复制模块文档有更详细的解释。

https://docs.python.org/3/library/copy.html

我们也有案例代码：

1.  dict.keys() 和集合比较

有三件事了解：

a) 如果从一个集合中减去另一个集合，那么只剩下第一个集合中的项目。

b) 可以使用 < 来检查一个集合中是否没有另一个集合中的所有元素。 c) dict.keys() 类似于集合。

结合这些想法，我们可以得到下面的示例：如果您期望字典具有特定的键集，您可以检查并警告键集丢失。

user_info = {
        
        "name": "Sam",
        "age": 6,
    }
    
    required_keys = {
        "name", "age", "weight"}  # A set
    # "姓名"、"年龄"、"体重"
    
    if user_info.keys() < required_keys:
        print(f"Missing info:", *required_keys.difference(user_info.keys()))

也有集合用法的汇总： set

1.  用 sum 使列表扁平化

您可以用 "+"组合两个列表，这个符号（您可能听说过）也有 "和 "的意思。

根据这一思路，你可以用 sum 函数合并多个列表，只要告诉它你想从一个空列表开始就可以了。

list_of_lists = [
        [1, 2, 3],
        [3, 4, 5],
        [5, 6, 7],
    ]
    
    flat_list = sum(list_of_lists, start=[])
    
    assert flat_list == [1, 2, 3, 3, 4, 5, 5, 6, 7] (1, 2, 3, 4, 5, 6, 7)

这对于扁平化一个由几个列表组成的列表很方便，但如果快速代码是你的强项，而且你有成千上万个列表，那么你应该知道使用列表推导式要快十倍：

flat_list = [item for row in list_of_lists for item in row] 
    
    (列表行中的项目)

理解式中嵌套的 for 循环可能会让人眼花缭乱，但如果你记住，for 循环的出现顺序与嵌套形式中的顺序相同，它们就不会那么糟糕了。

itertools.chain(*list_of_lists)

也能做到这一点，而且在速度上与理解式程序不相上下。

说到列表和快速性...... 又是一个可以深入到 C 的话题。

1.  deque：有时是快速的列表

如果你有一个列表，并发现自己经常要在开头插入项目，那么 deque，读作 "deck"可以在大约 1% 的时间内完成同样的工作。

import collections
    my_list = []
    my_list.insert(0, "left") 
    # 慢
    
    my_deque = collections.deque()
    my_deque.appendleft("left") 
    # 快

下面是集合文档中的 deque。

题外话：如果你只读了文档中的一页，那就读集合页吧。接下来是数学、`itertools` 和 `functools`

我不想为阅读官方文档的建议提供任何理由。

https://docs.python.org/3/library/collections.html\#collections.deque

https://docs.python.org/3/library/functools.html

https://docs.python.org/3/library/math.html

https://docs.python.org/3/library/itertools.html

1.  all 和 any

使用 `any()` 和 `all()` 可以将布尔值序列简化为一个布尔值。

比方说，你有一个消息列表和一个你关心的事情列表，你想知道消息列表中是否有你关心的事情。

concerns = ["money", "time", "cat"]
    messages = ["The cat is sick", "The dog ran away", "The fish is bloated"]

9 种组合中有1种为 True，因此 `any()` 返回`True`

assert any(concern in message for message in messages for concern in concerns)

如果你喜欢函数式风格，可以使用 `itertools.product`、`itertools.starmap` 和 `operator.contains` 得到同样的结果：

from itertools import product, starmap
    #导入itertools包含product, starmap
    
    concerns = ["money", "time", "cat"]
    messages = ["The cat is sick", "The dog ran away", "The fish is bloated"]
    
    assert any(starmap(contains, product(messages, concerns)))

以下是内置函数官方文档的 all 和 any

https://docs.python.org/3/library/functions.html\#all

https://docs.python.org/3/library/functions.html\#any

1.  可选参数并不能使参数成为可选参数

假设你有一个参数可选的类。我有时会看到这样的代码，试图说明 `short_name` 是可选的。

from typing import Optional

\#糟糕的写法

class Config:
        def __init__(
            self,
            port: int,
            host: str,
            short_name: Optional[str] = None,
        ):
            self.port = port
            self.host = host
            self.short_name = short_name
    But Optional doesn’t mean optional (seriously

但是，Optional 并不意味着可有可无，说真的！，而是意味着允许使用 `None`。

具体来说，`Optional[str]` 是 `str | None` 的简写。(使用管道运算符表示联合是在 Python 3.10 中添加的）。

下面显示了参数设置不同含义：

"required"、
    "required, 
    None is acceptable "
    "not required "

之间的区别

class SomeClass:
        def __init__(
            self,
            required: str,
            required_none_is_ok: Optional[str],
            not_required: str = None,
        ):
            ...

我倾向于不使用 `Optiona`l。

如果 `None` 是一个可接受的值，我几乎总是将其作为默认值，从而使参数成为可选值。

在极少数情况下，如果我想强制用户提供一个值，即使它是 None，我也会使用 `str | None` 而不是 `Optional[str]`，因为 `Optional` 会引起混淆。

下面是关于 Optional 的文档，其中解释说 "这与可选参数的概念不同"。

https://docs.python.org/3/library/typing.html\#typing.Optional

1.  打印多行文本的 6 种方法

比方说，你想打印一条多行信息，每行开头不加缩进，并且在源代码中也能很好地对齐。你有几种选择。

我推荐最后一种，其他几种是为了说明为什么这是一个棘手的问题。

import textwrap
    
    def function_that_prints_things():
        # 使用三重引号并手动删除. Gross.
        print(
            """line 1 Lorem ipsum dolor sit amet, consectetur adipiscing
    line 2 Lorem ipsum dolor sit amet, consectetur adipiscing
    line 3 Lorem ipsum dolor sit amet, consectetur adipiscing"""
        )
    
        # 用反斜杠加三重引号，并手动删除，也是粗体。
        print(
            """\
    line 1 Lorem ipsum dolor sit amet, consectetur adipiscing
    line 2 Lorem ipsum dolor sit amet, consectetur adipiscing
    line 3 Lorem ipsum dolor sit amet, consectetur adipiscing"""
        )
    
        # 依靠自动转换字符串和手动换行
        print(
            "line 1 Lorem ipsum dolor sit amet, consectetur adipiscing\n"
            "line 2 Lorem ipsum dolor sit amet, consectetur adipiscing\n"
            "line 3 Lorem ipsum dolor sit amet, consectetur adipiscing"
        )
    
        # 以反斜线为起始的文本换行模块，虽然还不太完善，但已初见成效
        print(
            textwrap.dedent(
                """\
                line 1 Lorem ipsum dolor sit amet, consectetur adipiscing
                line 2 Lorem ipsum dolor sit amet, consectetur adipiscing
                line 3 Lorem ipsum dolor sit amet, consectetur adipiscing"""
            )
        )
    
        # 带有起始/尾部反斜线的文本换行模块
        print(
            textwrap.dedent(
                """\
                line 1 Lorem ipsum dolor sit amet, consectetur adipiscing
                line 2 Lorem ipsum dolor sit amet, consectetur adipiscing
                line 3 Lorem ipsum dolor sit amet, consectetur adipiscing\
                """
            )
        )
    
        #用 textwrap 模块和 strip() 来处理前导空格，没问题
        print(
            textwrap.dedent(
                """
                line 1 Lorem ipsum dolor sit amet, consectetur adipiscing
                line 2 Lorem ipsum dolor sit amet, consectetur adipiscing
                line 3 Lorem ipsum dolor sit amet, consectetur adipiscing
                """
            ).strip()
        )
    
    
    function_that_prints_things()

文档中的 textwrap.dedent

https://docs.python.org/3/library/textwrap.html\#textwrap.dedent

1.  装饰器非常简单

你肯定见过装饰器，但可能没有意识到它们非常容易创建。比方说，我们需要一个装饰器来打印函数运行所需的时间。

from functools import wraps
    from timeit import default_timer
    
    # 装饰器的定义
    def time_function(func)：
        # 使用 wraps() 保留原始函数签名
        @wraps(func)
        def wrapped(*args, **kwargs)：
            # 启动计时器
            start_time = default_timer()
    
            # 运行函数，存储结果
            result = func(*args, **kwargs)
    
            # 计算/打印所用时间
            elapsed = default_timer() - start_time
            print(f"{func.__name__}() ran in {elapsed:g}s")
    
            return result
        return wrapped

## 使用装饰器 ##

@time_function
    def do_something()：
        return sum(x for x in range(1_000_000))
    
    do_something()
    
    # 打印：do_something() 运行了 0.016040s

要研究的东西还真不少，不过一旦你用过几个装饰器，你就会怀疑自己是怎么熬过来的。

或许不会。我不知道你在想什么。你想知道什么？

装饰器可以添加到函数或类的定义中。

1.  创建格式化函数

在某些情况下，为了定义数值的格式，需要提供一个函数，例如

Pandas display.float_format

您可以为此编写一个 lambda，但更好的方法是利用所有字符串都具有的 .format 方法。

format_percent = "{:.1%}".format
    assert format_percent(0.1234) == "12.3%" 
    #断言 format_percent(0.1234) == "12.3%"

以下是 str.format 的文档：

https://docs.python.org/3/library/stdtypes.html\#str.format

本文由[ mdnice ][mdnice]多平台发布

[mdnice]: https://mdnice.com/?platform=4