标签: method-chaining

对不起,如果这个问题引起任何混淆,我希望实现这一点,并且不知道正确的方法来处理这样的事情.

对于我的一个项目,我想实现方法链.我想要包含以下功能:

.toVector()
.toArray()
.toBool()
...

我曾想过将这些放在命名空间中,例如:

namespace Misc {
   template<typename T, typename Inverse>

   vector<T> toVector(Inverse begin, Inverser end) {
      // ...
      // ..
   }

   // ...
   // ...
}

这是因为可能有多个类,这些类可以使用这些函数,因此,它必须是OO而不是在不同的类中一次又一次地实现每个函数.

假设我有以下类Wav读取wav文件中包含的数据:

class Wav {
   public:
     Wav();
     Wav(string theFileName);
     void getWaveData();
  protected:
     vector<double> data;
};

data 显式存储为类的向量.

在我的主要内容中,我希望能够做到以下几点:

int main()
{
    Wav wave("file.wav");

    int* data = wave.getWaveData().toArray(); // Method chaining to store as an array
}

我不知道这是否可能,如果是这样的话,如果不在Misc每个类中反复实现所有函数,我将如何处理这个问题.有没有办法在命名空间和类之间进行通信而不必反复包含所有函数？

我希望有人有一个建议,我会尽力回答任何问题.

编辑:

我写了以下函数:

template<typename T, typename Inverse>
T* toArray(Inverse …

调用函数链有开销吗？例如，在以下 for 循环中：

for(int i = 0; i < n; i++)
{
  var=object.method1().method2().method3();
}

第一个效率是否比第二个低？

var = object.method1().method2();
for(int i = 0; i < n; i++)
{
  var.method3();
}

我关心的是知道函数调用/返回是否有开销，而不是函数内部的功能。

谢谢。

函数注释：PEP-3107

背景：我是 Linux 上使用 CPython 3.4x 的 PyCharm 用户。我发现注释函数参数和返回类型很有帮助。当我使用这些方法时，IDE 可以更好地提示。

问题：对于自链方法，如何注释方法返回值？如果我使用类名，Python 会在编译时抛出异常：NameError: name 'X' is not defined

示例代码：

class X:
    def yaya(self, x: int):
        # Do stuff here
        pass

    def chained_yaya(self, x: int) -> X:
        # Do stuff here
        return self

作为一个技巧，如果我把X = None它放在类声明之前，它就可以工作。但是，我不知道这种技术是否有不可预见的负面影响。

我有一个由几个值组成的Python集,我想使用这样的方法链:

>>> f = {1, 2, 3}
>>> g = f.copy().discard(3)
>>> g
>>>

但是g变空了.但是,它没有链接:

>>> g = f.copy()
>>> g
{1, 2, 3}
>>> g.discard(3)
>>> g
{1, 2}

有人能解释一下这种行为吗？

对于单级索引列，我会执行以下操作

arrays = [['one', 'two', ]]
tuples = list(zip(*arrays))
index = pd.MultiIndex.from_tuples(tuples, names=['first', 'second'])
df = pd.DataFrame(pd.np.random.randn(3, 2), index=['A', 'B', 'C'], columns=index)
print(df)


first   one two
A   0.919921    -1.407321
B   1.100169    -0.927249
C   -0.520308   0.619783

print(df.assign(one=lambda x: x.one * 100))

first   one         two
A       144.950877  0.633516
B       -0.593133   -0.630641
C       -5.661949   -0.738884

现在，当我有一个 MultiIndex 列时，我可以使用访问所需的列，.loc但我无法将其分配给任何内容，因为它出现了错误SyntaxError: keyword can't be an expression。

这是一个例子，

arrays = [['bar', 'bar'],
          ['one', 'two']]

tuples = list(zip(*arrays))
index = pd.MultiIndex.from_tuples(tuples, names=['first', 'second'])
df …

我想在 Java 中调用一系列 API 调用。要求是在后续的 API 调用请求中会用到一些 API 的响应。我可以使用某些循环来实现这一点。但我想以实现通用的方式使用设计模式。有什么帮助吗？

责任链不能满足我的需要，因为一开始我不知道我的请求上下文是什么。

String out = null;
Response res = execute(req);
out += res.getOut();
req.setXYZ(res.getXYZ);
Response res = execute(req);
out += res.getOut();
req.setABC(res.getABC);
Response res = execute(req);
out += res.getOut();

System.out.println("Final response::"+out);

RxJS v4 曾经有一种Observable.transduce方法可以使用转换器。这允许使用在过去具有重大性能优势的独立于库的传感器运算符。

来源

• https://github.com/Reactive-Extensions/RxJS/blob/master/doc/api/core/operators/transduce.md
• https://github.com/Reactive-Extensions/RxJS/blob/master/doc/gettingstarted/transducers.md
• https://medium.com/front-end-hacking/rxjs-transducers-vs-method-chaining-performance-87561cf4ce65
• https://github.com/ReactiveX/rxjs/pull/1323

RxJS v5.5 和 v6 具有可管道操作符和 v6 删除了方法链。因此，我假设 RxJS 操作符是标准的转换器。查看源代码，情况似乎并非如此。

RxJS v6 操作符的功能就像一个转换器，其中每个值在下一个值通过之前完全通过链传递，但 RxJS v6 操作符没有使用我在其他库中看到的标准转换器方法，这意味着，我不认为它们是便携式的。

关于传感器的整个事情是他们对集合本身一无所知。您可以编写 100 个普遍适用于任何集合或流类型的运算符，而不是专门为 observable 编写 100 个运算符。

在 RxJS v5 中是否.pipe一致.transduce或完全删除了这种方法？

假设我想以相反的顺序ArrayList对字段height中的对象进行排序，如果两个值相同，我想以相反的顺序进一步对字段宽度进行排序。有没有办法使用类似的东西

 Comparator<Test> comparator = Comparator
            .comparingInt((Test t) -> t.height).reversed()
            .thenComparingInt((Test t ) -> t.width).reversed();

我知道我可以使用类似的东西：

Collections.sort(list, new Comparator<Test>() {

        public int compare(Test o1, Test o2) {

            Integer x1 =  o1.height;
            Integer x2 =  o2.height;
            int sComp = x2.compareTo(x1);

            if (sComp != 0) {
                return sComp;
            }

            x1 = o1.width;
            x2 = o2.width;
            return x2.compareTo(x1);
        }});

但我真的很好奇是否有一行解决方案

所以关于这个小例子

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;

public class Main {

    public static void main(String[] args) {
        Test one = …

我有几个映射链，其中一个需要为每个数组元素执行数据库操作，所以我使用 async await。

const resultsAsPromises = arr
  .map(syncDouble)
  .map(asyncMapper)

如果它是链中的最后一个项目，这不是问题，因为我可以用 Promise.all

console.log('results', await Promise.all(resultsAsPromises))

但是，之后我还需要执行其他同步操作，因此我希望在继续执行下一个.map.

有没有办法做到这一点？我想也许只是制作一个提取映射器

function extractPromiseValues(value) {
  return value.then(v => v);
}

会工作，但唉，没有。

const resultsAsPromises = arr
  .map(syncDouble)
  .map(asyncMapper)

如何在数组方法链中解开一组 Promise

来自 SQL 开发背景，目前正在学习 pyspark/python 我对使用 python 查询数据/链接方法有点困惑。

例如下面的查询（取自“Learning Spark 2nd Edition”）：

fire_ts_df.               
 select("CallType")
 .where(col("CallType").isNotNull())
 .groupBy("CallType")
 .count()
 .orderBy("count", ascending=False)
 .show(n=10, truncate=False)

会执行得很好。

我不明白的是，如果我写了这样的代码：（将调用移动到 'count()' 更高）

fire_ts_df.               
 select("CallType")
 .count()
 .where(col("CallType").isNotNull())
 .groupBy("CallType")
 .orderBy("count", ascending=False)
 .show(n=10, truncate=False)

这行不通。问题是我不想记住订单，但我想了解它。我觉得这与 Python / Pyspark 中的正确方法链有关，但我不确定如何证明它的合理性。换句话说，在这种情况下，应该使用 (.) 调用和链接多个方法，正确的顺序是什么，是否有任何特定的规则要遵循？

非常感谢提前