小编drh*_*gen的帖子

如何比较两个极坐标DataFrames的值是否相等？看起来==只有当两个表是同一个对象时才是正确的：

import polars as pl
pl.DataFrame({"x": [1,2,3]}) == pl.DataFrame({"x": [1,2,3]})  # False

我有一个需要替换的多个变量的表达式.问题是要替换的一些表达式还包含需要替换的变量实例.

from sympy import *
from sympy.abs import a,b, x,y

expr = a + b
replace = [[a, x+y], [b, 2*a]]

expr.subs(replace) # 2*a + x + y, I want 3*x + 3*y

如果替换列表的顺序正确,它将按顺序应用每个替换,但在我的实际应用程序中,我不知道哪个顺序是合适的:

expr.subs(reversed(replace)) # 3*x + 3*y

我可以通过应用替代n次要么强制替代expr或者replace,但这似乎浪费计算:

result = expr
for _ in replace:
    # Applying n times
    result = result.subs(replace)

我希望有一个recursive选项subs,但这似乎不存在.有更好的选择吗？

我在Django中进行了一个简单的集成测试,它生成一个Celery工作者来运行一个作业,该作业将一条记录写入数据库.Django线程还将记录写入数据库.因为它是一个测试,我使用默认的内存中的sqlite3数据库.没有使用任何交易.

我经常收到这个错误:

django.db.utils.OperationalError: database table is locked

根据Django文档,由于一个连接在等待另一个完成时超时.这是"比sqlite在默认配置中可以处理的更多并发性".这看起来很奇怪,因为它是两个线程中的两个记录.尽管如此,相同的文档都说要增加超时选项以强制连接等待更长时间.好的,我将数据库设置更改为:

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
        'OPTIONS': {'timeout': 10000000},
    }
}

这没有效果.错误仍然出现,它显然没有等待1e7秒或1e7毫秒或1e7微秒才这样做.我还缺少一个额外的设置吗？

我已经尝试过Python 3.5和Python 3.6以及Django 1.11和Django 2.0.

如何输入提示参数或isinstance检查必须可迭代且可使用的对象len？我假设几乎所有具有长度的对象都是可迭代的，所以这实际上是关于什么类型（如果有的话）代表实现__len__.

def n_and_list(x: ???):
    return len(x), [y for y in x]

事实并非如此typing.Iterable，collections.Iterable因为对于没有长度的事物来说，这些都是正确的，例如zip.

In [1]: from typing import Iterable

In [2]: isinstance(zip([]), Iterable)
Out[3]: True

In [3]: from collections import Iterable

In [4]: isinstance(zip([]), Iterable)
Out[4]: True

In [5]: len(zip([]))
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-27-86d411a5426c> in <module>()
----> 1 len(zip([]))

TypeError: object of type 'zip' has no len()

它不是typing.Sequenceor collections.Sequence，因为对于有长度的东西来说，这些是错误的，比如字典键和 numpy 数组。

In …

使用PEP 563，可以from __future__ import annotations更改类型注释，以便对它们进行延迟评估，这提供了很多好处，例如前向引用。

但是，这似乎与其他功能（例如数据类）一起使用时效果很差。例如，我有一些代码检查类的__init__方法的类型参数。（真正的用例是为该类提供默认的序列化器，但这在这里并不重要。）

from dataclasses import dataclass
from typing import get_type_hints

class Foo:
    pass

@dataclass
class Bar:
    foo: Foo

print(get_type_hints(Bar.__init__))

在Python 3.6和3.7中，这可以完成预期的工作；它打印{'foo': <class '__main__.Foo'>, 'return': <class 'NoneType'>}。

但是，如果在Python 3.7中添加from __future__ import annotations，则失败并显示错误：

NameError: name 'Foo' is not defined

我想我知道为什么会这样。该__init__方法中所定义dataclasses，其不具有Foo对象在其环境，而Foo注释被传递给dataclass并连接到__init__作为字符串"Foo"而不是作为原始对象Foo，但get_type_hints对于新的注释只做一个名称查找，其中所述模块中__init__是未定义注释的定义位置。

我觉得我一定做错了。令我惊讶的是，这两个新功能一起发挥得很差。有没有适当的方法来检查方法的类型提示，__init__以便它可以像在普通类上一样在数据类上工作？

锡兰有可能都被认为是某种数组的东西几个不同的概念:List,Tuple,Sequence,Sequential,Iterable,Array,Collection,Category,等什么是这些这些类型,我应该何时使用它们有什么不同？

当Django测试用例运行时,它会创建一个独立的测试数据库,以便在每个测试完成时回滚数据库写入.我正在尝试与Celery创建集成测试,但我无法弄清楚如何将Celery连接到这个短暂的测试数据库.在天真的设置中,保存在Django中的对象对Celery是不可见的,并且保存在Celery中的对象会无限期地保留.

这是一个示例测试用例:

import json
from rest_framework.test import APITestCase
from myapp.models import MyModel
from myapp.util import get_result_from_response

class MyTestCase(APITestCase):
    @classmethod
    def setUpTestData(cls):
        # This object is not visible to Celery
        MyModel(id='test_object').save()

    def test_celery_integration(self):
        # This view spawns a Celery task
        # Task should see MyModel.objects.get(id='test_object'), but can't
        http_response = self.client.post('/', 'test_data', format='json')

        result = get_result_from_response(http_response)
        result.get()  # Wait for task to finish before ending test case
        # Objects saved by Celery task should be deleted, but persist

我有两个问题:

1. 如何让Celery可以看到Django测试用例的对象？

2. 如何确保Celery保存的所有对象在测试完成后自动回滚？

如果无法自动执行此操作,我愿意手动清理对象,但是 …

如果我有一个随机数Z，它被定义为另外两个随机数 和 的总和，X那么Y的概率分布是和Z的概率分布的卷积。卷积基本上是分布函数乘积的积分。卷积中的积分通常没有解析解，因此必须使用基本求积算法来计算。在伪代码中：XY

prob_z(z) = integrate(lambda t: prob_x(t) * prob_y(z-t), -inf, inf)\n

举一个具体的例子，可以使用以下Python/Scipy代码计算Z正态分布变量X和对数正态分布变量的总和：Y

from scipy.integrate import quad\nfrom scipy.stats import norm, lognorm\nfrom scipy import log\n\nprob_x = lambda x: norm.pdf(x, 0, 1)  # N(mu=0, sigma=1)\nprob_y = lambda y: lognorm.pdf(y, 0.1, scale=10)  # LogN(mu=log(10), sigma=0.1)\ndef prob_z(z):\n    return quad(lambda t: prob_x(t)*prob_y(z-t), -inf, inf)\n

现在我想计算对数概率。天真的解决方案是简单地执行以下操作：

def log_prob_z(z):\n    return log(prob_z(z))\n

然而，这在数值上是不稳定的。在大约 39 个标准差之后，概率分布在数值上为 …

在 Polars 0.13.14 中，我可以创建一个DataFrame带有全常数列的列，如下所示：

import polars as pl\n\npl.DataFrame(dict(x=pl.repeat(1, 3)))\n\n# shape: (3, 1)\n# \xe2\x94\x8c\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\x90\n# \xe2\x94\x82 x   \xe2\x94\x82\n# \xe2\x94\x82 --- \xe2\x94\x82\n# \xe2\x94\x82 i64 \xe2\x94\x82\n# \xe2\x95\x9e\xe2\x95\x90\xe2\x95\x90\xe2\x95\x90\xe2\x95\x90\xe2\x95\x90\xe2\x95\xa1\n# \xe2\x94\x82 1   \xe2\x94\x82\n# \xe2\x94\x9c\xe2\x95\x8c\xe2\x95\x8c\xe2\x95\x8c\xe2\x95\x8c\xe2\x95\x8c\xe2\x94\xa4\n# \xe2\x94\x82 1   \xe2\x94\x82\n# \xe2\x94\x9c\xe2\x95\x8c\xe2\x95\x8c\xe2\x95\x8c\xe2\x95\x8c\xe2\x95\x8c\xe2\x94\xa4\n# \xe2\x94\x82 1   \xe2\x94\x82\n# \xe2\x94\x94\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\x98\n

但在 Polars 0.13.15 中，这是一个错误

ValueError: Series constructor not called properly.\n

如何用极坐标值填充列？

通常,在收集与特定类型匹配的序列的所有元素时,生成的集合既具有原始集合的类型,又具有为以下类型选择的类型:

trait Foo
trait Bar

trait Baz {
  // Works
  def def1(foo: Seq[Foo]): Seq[Foo with Bar] = 
    foo collect {case foobar: Bar => foobar}
}

当输入类型由有界成员类型参数化并且我想要的全部是由绑定类型(而不是成员类型)参数化的序列时,这甚至有效:

trait Baz {
  type memberType <: Foo

  // Works
  def2(foo: Seq[memberType]): Seq[Foo with Bar] =
    foo collect {case foobar: Bar => foobar}
}

但是,当我真的想要返回由成员类型参数化的序列时,这会失败:

trait Baz {
  type memberType <: Foo

  // Fails
  def def3(foo: Seq[memberType]): Seq[memberType with Bar] =
    foo collect {case foobar: Bar => foobar}
}

错误信息:

error: type mismatch;
 found   : …