小编Bro*_*ark的帖子

在Python中，有没有办法区分字符串和其他字符串的可迭代对象？

Astr作为Iterable[str]类型是有效的，但这可能不是函数的正确输入。例如，在这个简单的示例中，旨在对文件名序列进行操作：

from typing import Iterable

def operate_on_files(file_paths: Iterable[str]) -> None:
    for path in file_paths:
        ...

传入单个文件名会产生错误的结果，但不会被类型检查捕获。我知道我可以在运行时检查字符串或字节类型，但我想知道是否可以使用类型检查工具捕获类似的愚蠢错误。

我查看了该collections.abc模块，似乎没有任何 abc 包含典型的可迭代对象（例如列表、元组）但排除字符串。同样，对于typing模块来说，似乎没有不包含字符串的迭代类型。

我很难找到满足的返回类型mypy。我有两个功能。第一个返回一个Union类型，因为该类型取决于赋予函数的参数。第二个函数使用默认参数调用第一个函数。因此，该类型不是一种Union类型——它可以缩小到Union.

让我给你举一个我的问题的一个非常简单的例子：

from typing import Union


def first(as_string: bool) -> Union[str, int]:
    if as_string:
        return "42"
    else:
        return 42


def second(as_string: bool) -> str:
    return first(True)

这会导致错误：

Incompatible return value type (got "str", expected "Union[str, int]")

如何mypy在仍然使用类型提示的同时防止抛出错误？

如果您想建议拆分第一个函数，请记住这只是一个简化。我的（第一个）函数接收一个函数（sklearn.metricsfunction）并且大多数时候会返回一个标量。仅当应用混淆矩阵时，类型才会发生变化。第一个函数进行一些预处理，然后应用度量。我只是想为混淆矩阵提供一个不同名称的函数，因为我认为它是度量的特殊情况。

根据 PEP8 风格指南，格式化类型别名 \xe2\x80\x94 的名称的正确方法是什么？

# mymodule.py\nfrom typing import TypeAlias\n\nmytype: TypeAlias = int\n\ndef f() -> mytype:\n    return mytype()\n\ndef g() -> mytype:\n    return mytype()\n

应该mytype格式化，CapWords因为它引入了类似于创建新类的新类型？或者，应该mytype全部大写格式化，因为它的处理方式与常量类似？

有没有办法区分在程序的整个生命周期中保持不变（常量）的类型别名和可以更改的类型别名（类似于Final常量的注释）？

另外，应该mytype用下划线作为前缀（如_mytype）以指示类型别名不应在该模块之外使用？

给定一个列表列表（即嵌套列表），我想从外部列表的开头和结尾删除所有长度为1的内部列表。例如

d = [[3], [1,5], [3], [3,2,4], [8], [3]]应该变成：[1,5], [3], [3,2,4]。

对于列表的开头，我使用以下代码：

i = 0
while len(d[i]) == 1:
    d.remove(d[i])
    n = n -1

最后，我使用以下代码：

 while len(d[n-1]) == 1:
    d.remove(d[n-1])
    n = n - 1

其中 n = 列表数。

当我运行这个时，我得到：

[[1, 5], [3, 2, 4]]

所以它还删除了中间长度为 1 的列表。我怎样才能更改代码以使其不这样做？

因此，对于许多n列表，我想删除开头的所有长度为 1 的列表，直到有一个列表的长度不为 1。我想对列表的末尾执行相同的操作。

如果函数可以返回None，那么不应该使用类型注释吗NoneType？

例如，我们不应该使用这个：

from types import NoneType

def my_function(num: int) -> int | NoneType:

    if num > 0:
        return num

    return None

代替：

def my_function(num: int) -> int | None:

    if num > 0:
        return num

    return None

？

所以我有一个字符串，在该字符串中，某些单词中的某些字符被其他字符替换（typo_text）。例如：“美国、德国、欧盟委员会、日本和加拿大资助测试的开发和公平推广。” 这将是正确的格式，但我得到的却是“XSX、Gxrmxny、欧盟委员会、Jxpxn 和 Cxnxdx，为结束新冠肺炎急性期所需的测试、治疗和疫苗的开发和公平推广提供资金” -19 大流行。我一直在创建一个需要for循环来纠正拼写错误的脚本：

def corrected_text(text):
    newstring=""
    for i in text:
        if i not in "aeiouAEIOU":
            newstring=newstring+i
    text=newstring
    return text

我知道当我运行这个时，它只会从文本中删除所有元音。然而，这似乎是朝着正确方向迈出的一步，有助于纠正拼写错误并了解for基于循环的方法。

我有两个存在此问题的单词列表：

name_G7_countries = ['Canada', 'France', 'Germany', 'Italy', 'Japan', 'UK', 'USA']
mistake =  ['Cxnxdx', 'Frxncx', 'Gxrmxny', 'Xtxly', 'Jxpxn','XK', 'XSX']

我知道使用类似的东西'Jxpxn'.replace('x', 'a')可能会起作用；但是，对于其他短语，可能不会，所以我不确定如何从这里继续。

我正在试验该typing模块，我想知道如何正确输入像九角形（9 点多边形）这样的东西，它应该是元组而不是列表，因为它应该是不可变的。

在 2D 空间中，它会是这样的：

Point2D = Tuple[float, float]
Nonagon = Tuple[Point2D, Point2D, Point2D, Point2D, Point2D, Point2D, Point2D, Point2D, Point2D]

nine_points: Nonagon = (
    (0.0, 0.0),
    (6.0, 0.0),
    (6.0, 2.0),
    (2.0, 2.0),
    (6.0, 5.0),
    (2.0, 8.0),
    (6.0, 8.0),
    (6.0, 10.0),
    (0.0, 10.0),
)

是否有任何语法糖可以使 Nonagon 声明更短或更容易阅读？

这不是有效的Python，但我正在寻找与此类似的东西：

Nonagon = Tuple[*([Point2D] * 9)]  # Not valid Python

或者使用NamedTuple

# Not properly detected by static type analysers
Nonagon = NamedTuple('Nonagon', [(f"point_{i}", Point2D) for i in range(9)])  

这不是我想要的：

# Valid …

我想知道是否有一种简单的方法可以在字典中为一个值提供多个键。我想实现的一个例子如下：

class test:
    key="test_key"
    
    def __str__(self):
        return self.key

tester = test()

dictionary = {}
dictionary[tester] = 1

print(dictionary[tester])
print(dictionary["test_key"])

输出将是：

>>> 1
>>> 1

我正在寻找一种在将对象用作键之前自动将其转换为字符串的方法。这可能吗？

所以我需要生成一个10位的密码（需要使用random模块），每次必须包含2个小写字母，2个大写字母，3个特殊符号和3个数字，并且每次都是随机顺序。我已经完成了随机密码生成器部分，但我不知道如何将其限制为 2 个小写字母、2 个大写字母、3 个特殊符号和 3 个数字。

这是我到目前为止所拥有的：

import random
import string
lc_letter = ["a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z"]
uc_letter = ["A","B","C","D","E","F","G","H","I","J","K","L","M","N","O","P","Q","R","S","T","U","V","W","X","Y","Z"]
symbols = ["!","@","#","$","%","^","&","*","(",")","_","+","=","-","/",">","<",",",".","?","\\"]
numbers = ["0","1","2","3","4","5","6","7","8","9"]
options = [lc_letter,uc_letter,symbols,numbers]
for i in range(10):
    choice = random.choice(options)
    digit = random.choice(choice)
    print(digit, end = '')

我编写了一个defaultdict可以default_factory使用 key 作为参数进行调用的子类。

from collections import defaultdict
from typing import TypeVar, Any, Callable, Generic

K = TypeVar('K')


class keydefaultdict(defaultdict, Generic[K]):
    ''' Drop-in replacement for defaultdict accepting key as argument '''

    default_factory: Callable[[], Any] | Callable[[K], Any] | None

    def __missing__(self, key: K) -> Any:
        if self.default_factory is None:
            raise KeyError(key)
        else:
            try:
                ret = self[key] = self.default_factory(key)
            except TypeError:  # try no-key signature
                ret = self[key] = self.default_factory()
            # if failed, let the error propagate as …