小编jar*_*red的帖子

我有一个很大的DataFrame，我需要在其上计算滚动行加权平均值。

我知道我可以执行以下操作：

import numpy as np
import pandas as pd

df = pd.DataFrame(np.random.rand(20000, 50))
weights = [1/9, 2/9, 1/3, 2/9, 1/9]  
rolling_mean = df.rolling(5, axis=1).apply(lambda seq: np.average(seq, weights=weights))

问题是在我的电脑上这大约需要 40 秒。有什么办法可以加快这个计算速度吗？

我是 Python 新手，尝试在 x 轴上绘制持续时间为 300 秒的正弦曲线，但我只能在短时间内绘制正确的正弦曲线。

微量元素：

import numpy as np
import matplotlib.pyplot as plt

in_array = np.linspace(0, 2*np.pi, 300)
out_array = np.sin(in_array)

print("in_array : ", in_array)
print("\nout_array : ", out_array)

# red for numpy.sin()
plt.plot(in_array, out_array, color = 'red')
plt.title("numpy.sin()")
plt.xlabel("X")
plt.ylabel("Y")
plt.show()

上面的代码能够绘制所需的正弦曲线，如下所示：

如果我将np.linspace上面代码中的行更改为

in_array = np.linspace(0, 6*np.pi, 300)

...然后我就能够得到正弦曲线的3个周期，这也可以。

问题：如果我尝试使用上面的代码在 x 轴上绘制 300 秒（大约）的正弦曲线in_array = np.linspace(0, 90*np.pi, 300)，则曲线包含不同的幅度（如下所示），为什么以及如何纠正它？

我正在使用 python + Nest.js 开发一个图形绘制和微积分执行计算器应用程序。我正在使用 SymPy 带来微积分功能，但微分时存在严重问题。

derivative.py：

from latex2sympy2 import latex2sympy, latex2latex
import sympy as smp

def derivative(latex):
  ...
  x = smp.symbols('x', real=True)
  f = latex2sympy(latex)
  dfdx = smp.diff(f, x)
  return smp.latex(dfdx)

一切都运转良好，除了sympy.diff()；它总是返回0（例如f = sin(x)会导致dfdx = 0）。

我发现，由于latex2sympy()返回一个没有库名称的函数，smp.diff()因此不认为它是来自 SymPy 的函数。当我在 Google Colab 上测试完全相同的代码时，它运行得很好。

f = latex2sympy(latex)
# latex = '$$ \sin x $$'
# f = sin(x)

dfdx = smp.diff(f, x)
# dfdx = 0

所以我觉得 …

在我的代码中，我有某些值，例如

my_list = [725.998474, 0.0, 0.0, 0.0, 0.0, 789.507934, 792.585388, 801.612916, 799.38916, 809.280518, 809.186036, 811.899414, .... , 412.314528]

在我的代码中，我想对列表为 0.0 的点进行插值，因为它们是异常值。但它不起作用，因为插值仅适用于空值。

如何删除那些 0.0 值并进行插值？

我读到 scipy 中的 linprog 返回最小解决方案，并且可以通过将目标函数乘以 -1 来获得最佳解决方案。

我在这里读到它： https: //realpython.com/linear-programming-python/ 我已经测试了他们提供的示例，看看我是否也能得到最小的解决方案——我可以。


关于我试图解决的问题，我希望解决方案是：

opt_sol1.x = [0.61538462 0.38461538]
opt_sol2.x = [0.0, 1.0]

但在两种情况下我都得到相同的结果 [0.61538462 0.38461538] 为什么？-- 我的猜测是它与我的目标函数中的值相互接近有关，但只是猜测有没有一种方法可以得到我正在寻找的第二个解决方案？

from scipy.optimize import linprog

obj_fct1 = [0.5, 0.5]
obj_fct2 = [-0.5, -0.5]
lhs_ineq = [[1.5, 0.2]]
rhs_ineq = [1]
lhs_eq = [[1,1]]
rhs_eq = [1]
bnds = [(0, 1),
          (0, 1)]

opt_sol1 = linprog(c=obj_fct1,
                  A_ub=lhs_ineq,
                  b_ub=rhs_ineq,
                  A_eq=lhs_eq,
                  b_eq=rhs_eq,
                  bounds=bnds)
print(opt_sol1.x)
print("------------------------------------------")
opt_sol2 = linprog(c=obj_fct2,
                  A_ub=lhs_ineq,
                  b_ub=rhs_ineq,
                  A_eq=lhs_eq,
                  b_eq=rhs_eq,
                  bounds=bnds)
print(opt_sol2.x)


>>> [0.61538462 0.38461538]
>>> ------------------------------------------ …

max(some2Ddata,key=np.abs)有效，但仅适用于一维复数数组

np.max(abs(some2Ddata))返回最大复数值的大小，但不返回该值本身

我期待着：

some2Ddata = ((1+2j, 5+1j), (4+4j, 2+3j))

complexmax(some2Data)

哪个应该返回4+4j，而不是5.657（绝对不是5+1j）。

我很难相信这个操作没有内置的标准。