小编Joe*_*ley的帖子

当我在诗歌中将 python 版本从 3.7 升级到 3.8 时，重新安装所有依赖项都会失败，版本如下：

ERROR: No matching distribution found for...

该版本的发行版可在 pypa 上找到，并且通常是最新版本。

简单地删除有问题的包并不能解决问题，因为其他包可能会导致诗歌失败。经过一番调查，似乎诗歌没有使用 pip3 在下面安装，而是使用 pip2.7。

事实上，这是由弃用警报支持的，并且如果我尝试使用 pip （全局或其他方式）而不是 pip3 安装相同版本，则该错误总是可重现的。

这个问题令人沮丧，单独删除 venv 似乎没有帮助。我怎样才能解决这个本来就不应该存在的依赖问题？

我正在努力弄清楚以下两个TypeVars之间的区别

from typing import TypeVar, Union

class A: pass
class B: pass

T = TypeVar("T", A, B)
T = TypeVar("T", bound=Union[A, B])

有人想启发我吗？

一个我不明白的例子......

T = TypeVar("T", bound=Union[A, B])

class AA(A):
    pass


class X(Generic[T]):
    pass


class XA(X[A]):
    pass


class XAA(X[AA]):
    pass

通过类型检查，但T = TypeVar("T", A, B)失败了

错误：“X”的类型变量“T”的值不能是“AA”

相关：this question on the difference between Union[A, B]andTypeVar("T", A, B)

有没有办法用 Python 的类型提示来表达这个 Scala 代码？

trait List[A] {
  def ::[B >: A](x: B): List[B]
}

我正在努力实现这种事情

class X: pass
class Y(X): pass

ys = MyList(Y(), Y())  # inferred as MyList[Y], I know how to do this
xs = ys.extended_by(X())  # inferred as MyList[X], I don't know how to do this

请注意，类型MyList是用初始化的，它的类型extended_by可以是任何东西。有关更多详细信息，请参阅评论。

我试过的

from __future__ import annotations
from typing import TypeVar, Generic

B = TypeVar('B')
A = TypeVar('A', bound=B)


class MyList(Generic[A]):
    def __init__(*o: A):
        ...

    def extended_by(self, …

是否typing.TypedDict允许额外的钥匙？如果某个值具有 TypedDict 定义中不存在的键，该值是否会通过类型检查器？

斯卡拉有时候只是脱毒

a += b

至

a = a + b

但不总是.例如,一些可变集合定义了一个+=方法,而不是它变成了一个方法

a.+=(b)

这是这种行为吗？

1. 完全取决于是否有合适的+=方法a？(包括有这种行为的其他例子吗？)
2. 独立于对象是val还是var？

相关的例子

改编自Scala中的编程

var s = Set("a", "b")
s += "c"

在这种情况下,第二行代码s += "c"基本上是简写:

s = s + "c"

我正在尝试实现一个用于类型之间转换的接口，但由于typing.Type是协变的，我正在努力使其保持一致

U = TypeVar('U')


class Into(Protocol[U]):
    @abstractmethod
    def into(self, t: Type[U]) -> U:
        pass

该文档给出一个类似的例子有一个关键的区别

class User: ...
class BasicUser(User): ...
class ProUser(User): ...
class TeamUser(User): ...

def make_new_user(user_class: Type[User]) -> User:
    return user_class()

他们说类型检查器应该检查所有的子类是否User应该实现一个带有有效签名的构造函数，以便像这样实例化。我的用例不同，因为我可能不会构建新类型，只是返回一个预先存在的类型。说我同意

class X: pass

class Wrapper:
    def __init__(self, x: X):
        self._x = x

    def into(self, t: Type[X]) -> X:
        return self._x

一切正常，直到有人子类化 X

w = Wrapper(X())
...
class XX(X): pass
x: XX = w.into(XX)

RHS 很好，因为 mypy cosType是协变的，但显然 …

当传递函数时，我通常用 来提示它们typing.Callable。

的文档声明collections.abc.Callable它有四种 dunder 方法：

类 collections.abc.Callable

分别提供方法__contains__()、__hash__()、__len__()和的类的 ABC __call__()。

有一次，我想检查__wrapped__函数上是否有属性。通过检查，这在运行时工作得很好hasattr(func, "__wrapped__")。

当使用 进行静态类型检查时mypy，它会报告：error: "Callable[..., Any]" has no attribute "__wrapped__" [attr-defined]。这对我来说很有意义，因为Callable不应该有__wrapped__属性。

如何正确输入Callable带有__wrapped__属性的提示 a？我可以做一些其他类型的提示或解决方法吗？

代码示例

我正在使用mypy==0.782和Python==3.8.2：

from functools import wraps
from typing import Callable


def print_int_arg(arg: int) -> None:
    """Print the integer argument."""
    print(arg)


@wraps(print_int_arg)
def wrap_print_int_arg(arg: int) -> None: …

我试图在函数调用(通过dict和关键字参数)中使用模板关键字args,同时能够覆盖一些参数.

例如,如果我们从包含该行的模块mymod开始 template_kvps = {'a': 1, 'b': 2}

我可以:

import mymod

def func(**kwargs):
    pass

func(**mymod.template_kvps)

然后我可以访问我的template_kvps内部func().但我希望能够以a最小的开销传递不同的值.

我能想到的只是在函数调用之前更改字典:kvps = {**template_kvps, 'a': 3}; func(**kvps),但这是行数的两倍,我在大约1000个测试脚本中的每一个中都使用了这个函数几次.

理想情况下func,我想要重新定义,以便我可以做到,func(**mymod.template_kvps, a=3)但事实上,Python错误与重复参数有关.

顺便说一下,我很高兴考虑改变模板kvps的格式.

后来添加的注释我问的问题有一些很好的答案(我已经接受了我认为是我问的最佳答案),但我想我已经问了一件坏事.我建议这是一个设计问题,如果我想要这样的默认参数,我认为最好用默认参数而不是模板字典创建包装器方法,如

def func_template(a=1, b=2):
    func(a, b)

func_template(a=3)

Swift for Tensorflow项目的Swift 中添加了对差分编程的本机支持。Julia 与Zygote类似。

什么是可微分编程？

• 它有什么作用？维基百科说

这些程序可以在整个过程中有所不同

但是，这是什么意思？

• 人们将如何使用它（例如一个简单的例子）？
• 以及它与自动微分有何关系（这两者在很多时候似乎混为一谈）？

我正在尝试弄清楚移动语义如何影响引用透明度。

引用透明(RT) 允许我们在不改变程序含义的情况下用其结果替换任何表达式（从Scala 中的函数式编程转述）。例如，我可以用 替换1 + 1我程序中的任何地方2，并且什么都不应该改变。这个 Python 程序是引用透明的：

@dataclass
class Bucket:
    things: List[str]

leaves = ["leaves"]

def bucket_with_sand(things: List[str]) -> Bucket:
    return Bucket(things + ["sand"])

bucket_with_sand(leaves)  # can be replaced with Bucket(["leaves", "sand"]) with no change to the program

而这个函数就地改变了它的参数

def bucket_with_sand(things: List[str]) -> Bucket:
    things += ["sand"]
    return Bucket(things)

因此用其结果替换函数调用会改变含义。它不再具有引用透明性。在像 Rust 那样具有移动语义的语言中，我们可以通过移动leaves（并依赖于Vec非Copy）来避免这个问题：

struct Bucket {
    things: Vec<&str>,
}

let leaves = …