小编mcs*_*ini的帖子

问题陈述

我正在寻找一种有效的方法来生成完全二进制的笛卡尔乘积（具有某些列的True和False的所有组合的表），并按某些排他条件过滤。例如，对于三列/位，n=3我们将获得完整表

df_combs = pd.DataFrame(itertools.product(*([[True, False]] * n)))
       0      1      2
0   True   True   True
1   True   True  False
2   True  False   True
3   True  False  False
...

应该由字典定义互斥组合来过滤此内容，如下所示：

mutually_excl = [{0: False, 1: False, 2: True},
                 {0: True, 2: True}]

键在其中表示上表中的列。该示例将读取为：

• 如果0为False而1为False，则2不能为True
• 如果0为True，则2不能为True

基于这些过滤器，预期输出为：

       0      1      2
1   True   True  False
3   True  False  False
4  False   True   True
5  False   True  False
7  False  False  False

在我的用例中，过滤后的表格比完整的笛卡尔积小几个数量级（例如，约1000而不是2**24 (16777216)）。

下面是我目前的三个解决方案，每个解决方案各有优缺点，最后进行了讨论。

import random
import pandas as …

我有一个如下数据框：

    A
1   1000
2   1000
3   1001
4   1001
5   10
6   1000
7   1010
8   9
9   10
10  6
11  999
12  10110
13  10111
14  1000 

我正在尝试通过以下方式清理数据框：对于具有大于前一行值的1.5倍或小于前一行值的0.5倍的每一行，请将其删除。但是，如果前一行是拖放行，则必须与紧邻的前一个非拖放行进行比较。（例如，我的数据帧中的索引9、10或13）因此，最终的数据帧应类似于：

    A
1   1000
2   1000
3   1001
4   1001
6   1000
7   1010
11  999
14  1000

我的数据框确实很大，因此性能值得赞赏。

我正在尝试找出如何从 中获取可能解决方案的完整列表ortools.sat.python.cp_model。我知道我可以打印它们，如下例所示，但我不清楚如何获取这些值，例如作为嵌套列表或字典列表。我尝试通过修改 并将解决方案附加到列表属性来编写自己的回调类VarArraySolutionPrinter，但由于某种原因，这始终导致 python 内核崩溃。无论如何，必须有更直接的方法。我不认为解析打印输出是一个选项。

from ortools.sat.python import cp_model

model = cp_model.CpModel()

x00 = model.NewBoolVar('x00')
x01 = model.NewBoolVar('x01')
x02 = model.NewBoolVar('x02')

model.AddBoolOr([x00, x01, x02.Not()])
model.AddBoolOr([x00.Not(), x02.Not()])

# Create a solver and solve.
solver = cp_model.CpSolver()
solution_printer = cp_model.VarArraySolutionPrinter([x00, x01, x02])
solver.SearchForAllSolutions(model, solution_printer)

## Prints:
Solution 0, time = 0.00 s
  x00 = 0   x01 = 1   x02 = 0 
Solution 1, time = 0.01 s
  x00 = 0   x01 = 0   x02 = 0 
Solution 2, …

我正在将大量（100 到 1000）的镶木地板文件读取到单个 dask 数据帧（单台机器，全部本地）中。我意识到

files = ['file1.parq', 'file2.parq', ...]
ddf = dd.read_parquet(files, engine='fastparquet')
ddf.groupby(['col_A', 'col_B']).value.sum().compute()

效率比​

from dask import delayed
from fastparquet import ParquetFile

@delayed
def load_chunk(pth):
    return ParquetFile(pth).to_pandas()

ddf = dd.from_delayed([load_chunk(f) for f in files])
ddf.groupby(['col_A', 'col_B']).value.sum().compute()

对于我的特定应用程序，第二种方法 ( from_delayed) 需要 6 秒才能完成，第一种方法需要 39 秒。在这种dd.read_parquet情况下，在工作人员开始做某事之前似乎就有很多开销，并且有相当多的transfer-...操作分散在任务流图中。我想了解这里发生了什么事。read_parquet该方法速度如此之慢的原因可能是什么？它与仅仅读取文件并将它们分成块有什么不同？

from scipy import integrate
import numpy as np
from mpmath import coth

DvDc = 6.5
dens = 5.65
Vs = 4.6e3
a = 3.3e-9
w0 = np.sqrt(2)*Vs/a
T = 50 
kb = 1.38064852e-5  # in eV`
j0 = (DvDc)**2 / ((2*np.pi)**2 *dens*Vs**5)

def func(x):
    return x*np.exp(-(x/w0)**2)*coth(x/(2*kb*T))
S = j0*integrate.quad(func, 0, np.inf)[0]
print(S)

嗨，所以我没有使用数值积分的经验，但我想知道是否有人可以提供帮助。在这里，我定义了一些变量，并有一个要集成的函数。但是我得到了“积分可能是发散的，或者慢慢收敛的。” 尽管我在 coth 的分母中添加了内容，但几乎得到了相同的结果。

有谁知道我是否犯了一个错误，或者我只是不能做到这一点。

谢谢！