该pandas.DataFrame.query()方法在加载或绘图时非常适用于(前/后)过滤数据.它对于方法链尤特别方便.

我发现自己经常想要将相同的逻辑应用于a pandas.Series,例如在完成了df.value_counts返回a之类的方法之后pandas.Series.

例

让我们假设有一个巨大的列表,Player, Game, Points我想绘制超过14次3分的玩家直方图.我首先必须总结每个球员(groupby -> agg)的积分,这将返回一系列约1000名球员及其总得分.应用.query逻辑它看起来像这样:

df = pd.DataFrame({
    'Points': [random.choice([1,3]) for x in range(100)], 
    'Player': [random.choice(["A","B","C"]) for x in range(100)]})

(df
     .query("Points == 3")
     .Player.values_count()
     .query("> 14")
     .hist())

我找到的唯一解决方案迫使我做一个不必要的任务并打破方法链:

(points_series = df
     .query("Points == 3")
     .groupby("Player").size()
points_series[points_series > 100].hist()

方法链接以及查询方法有助于保持代码清晰,同时子集化过滤可以很快变得混乱.

# just to make my point :)
series_bestplayers_under_100[series_prefiltered_under_100 > 0].shape

请帮助我摆脱困境!谢谢

我有一堆有用的功能,这些功能是我一生中收集的.

function one(num){
    return num+1;
}

function two(num){
    return num+2;
}

我可以打电话给他们 two(two(one(5)))

但我更愿意使用 (5).one().two().two()

如何在不使用原型的情况下实现此目的？

我试图看看下划线链是如何工作的,但是他们的代码太强烈而无法理解它

考虑:

// member data omitted for brevity

// assume that "setAngle" needs to be implemented separately
// in Label and Image, and that Button does need to inherit
// Label, rather than, say, contain one (etc)

struct Widget {
    Widget& move(Point newPos) { pos = newPos; return *this; }
};

struct Label : Widget {
    Label& setText(string const& newText) { text = newText; return *this; }
    Label& setAngle(double newAngle) { angle = newAngle; return *this; }
};

struct Button : …

我从来没有弄清楚如何使Intellij正确处理链式方法的延续缩进,显然今天是让我烦恼的那一天,可以咨询你可爱的人.

我想要的是这个:

makeAThing(
  "with",  
  "params"
)
.setProperty("with some more params")
.start();

我得到的是这个:

makeAThing(
  "with", 
  "params"
)
  .setProperty("with some more params")
  .start();

我在Java,Groovy,JavaScript和其他一些地方得到这个.如何说服Intellij在链式方法调用后不添加延续缩进？

以下表达式通常用于演示未定义的未指定行为:

f() + g()

如果f()和g()都有一些共享对象的副作用,则行为是不确定的不确定,因为执行的顺序是未知的.f()可以在之前评估,g()反之亦然.

现在我想知道当你在一个对象上链接成员函数时会发生什么.比方说,我有一个类,叫做实例的实例obj,它有两个成员函数,foo()而bar()这两个修改的对象.这些函数的执行顺序不是可交换的.在一个接一个之前调用一个的效果与用另一个方式调用它们的效果不同.这两个方法都返回一个引用,*this以便它们可以像这样链接:

obj.foo().bar()

但这是不明确的行为吗？我在标准中找不到任何东西(不可否认只是扫描),区分了这个表达式和我在帖子顶部给出的表达.两个函数调用都是full-expression的子表达式,因此它们的执行顺序是未指定的.但肯定foo() 必须先评估,以便bar()知道要修改哪个对象.

也许我错过了一些明显的东西,但我无法看到序列点的创建位置.

假设我有一个模拟对象,我不想存根任何方法,但是我想要存根它返回的对象的方法.例如,

when(mockObject.method1()).thenReturn(returnValue)

它是如何正常完成的,但我正在寻找,

when(mockObject.method1().method2()).thenReturn(returnValue)

那可能吗？如果我这样做,我会得到一个NullPointerException.目前我有第一个返回模拟对象的方法,然后使用返回的模拟对象,存根第二个方法.但是,这些临时模拟对象对我来说是无用的,并且在将许多方法链接在一起之后,会导致很多无用的模拟对象.

编辑:实际上,链接可能有效,但我的对象正在引起NPE.这段代码(第一行)导致NPE:

when(graphDb.index().getNodeAutoIndexer()).thenReturn(nodeAutoIndexer);
when(graphDb.index().getRelationshipAutoIndexer()).thenReturn(relAutoIndexer);

但是这段代码有效:

IndexManager indexManager = mock(IndexManager.class);
when(graphDb.index()).thenReturn(indexManager);
when(indexManager.getNodeAutoIndexer()).thenReturn(nodeAutoIndexer);
when(graphDb.index().getRelationshipAutoIndexer()).thenReturn(relAutoIndexer);

所以链接不适用于getNodeAutoIndexer(),它返回一个AutoIndexer对象,同时它对getRelationshipAutoIndexer()有效,返回一个RelationshipAutoIndexer.两个返回值都被模拟如下:

nodeAutoIndexer = (AutoIndexer<Node>) mock(AutoIndexer.class);
relAutoIndexer = mock(RelationshipAutoIndexer.class);

那么可能导致问题的原因是什么？

我已经开始学习函数式编程，虽然在正常情况下链接方法看起来很棒（在我看来），但在处理 async/await 时它真的变得很难看

await (await (await CosmosDbRepository<ApplicationProcess>
    .GetItemAsync(param.ProcessId))
.Historize(() => _analyseFinanciereService.ProcessAsync(), 
    ProcessStepEnum.Application))
.Notify(p => p.GetLastStep());

有什么办法可以消除这种噪音吗？

编辑 ：

public static async Task<ApplicationProcess> Historize(
this ApplicationProcess process, 
Func<Task> fn, 
ProcessStepEnum stepEnum)
{
    var dateStart = DateTime.UtcNow;
    var error = string.Empty;
    try
    {
        await fn();
        return process;
    }
    …

public static async Task Notify<TResult>(
    this ApplicationProcess process, 
    Func<ApplicationProcess, TResult> fn)
...

Edit2：使用扩展方法接受任务

await CosmosDbRepository<ApplicationProcess>
    .GetItemAsync(param.ProcessId)
    .HistorizeAsync(() => _analyseFinanciereService.ProcessAsync(), ProcessStepEnum.Application)
    .NotifyAsync(p => p.GetLastStep());

所以这就是我一直在寻找的，即使我对最新的评论感到困惑

我对番石榴有点新鲜,它的风格.我肯定在挖掘它,但我不断绊倒的一件事是链式方法的顺序.我似乎有这个问题的地方最多的是使用复合物Ordering.我不得不一直问自己这样的问题:

• natural去哪儿了？
• 在什么地方nullFirst(或上次)去？
• 哪个nullsFirst做什么？(在下面的示例中,一个用于主机,一个用于姓氏,一个用于名字？)

这是我刚刚开始研究的一个例子.它看起来很麻烦,我只是不确定我是否把它放在一起.我有一些JUnits来测试它,看起来没问题,但总有那些奇怪的边界情况.

Ordering<Host> lastNameThenFirstNameOrdering = Ordering.natural().nullsFirst().onResultOf(new Function<Host, String>() {
    public String apply(Host host) {
        return host.getLastName();
    }}).compound(Ordering.natural().nullsFirst().onResultOf(new Function<Host, String>() {
    public String apply(Host host) {
        return host.getFirstName();
    }})).nullsFirst();

至于一个实际的问题:这些事情是如何被执行的,是否有明确的规则？它似乎是倒数第一,但我很难说出来.

编辑:只是想指出我试图替换的大而丑陋的代码:

    Ordering<Host> ordering2 = new Ordering<Host>() {
        public int compare(Host host1, Host host2) {
            if (host1 == null || host2 == null) {
                return host1 == host2 ? 0 : ((host1 == null) ? -1 : 1); 
            }
            if(host1.getLastName() != …

我想知道是否有本地方式这样做:

Object.prototype.chain = function(f) { return f.call(this) }


function fun1() {
    doSomethingWithObject(this)
    return this
}

function fun2() {
    doSomethingElse(this)
    return this
}

someObject
    .method1('something')
    .method2()
    .chain(checkSomething() ? fun1 : fun2)
    .method3()

但我不想改变原型Object.有没有办法在不修改Objects我使用的原型或其他构造函数的情况下执行此操作(并且不是开发人员)

编辑:

我觉得我没解释得很好,所以让我们添加一些细节:

我想做的是使用一些我没有定义的API.someObject使用可链接方法定义如下:

var someObject = {
    method1: function(val) {
        // do something
        return this
    },
    method2: function() {
        // do something
        return this
    },
    method3: function() {
        // do something
        return this
    }
}

现在假设我无法更改此代码,因为此对象来自库,因此我不想这样做.然后,假设我想链接方法和一些自定义函数(请参阅我的第一个代码段)以获取更多不同的对象.最简单的chain方法是附加一个方法Object.prototype.

但我认为它可能导致未来的冲突.我正在寻找一种方法来做同样的事情而不触及原型.

我正在使用IntelliJ IDEA 13.1.5编写使用流畅API的Java代码,我注意到当我关闭一个"流畅"代码部分的块时,IDEA会自动将"流畅"代码扁平化为一行.

例如,如果我有这个方法:

public int sendMessage(Message message) {
  Response response = JerseyClientHelper.target(serverUrl)
            .header("User-Agent", userAgent)
            .post(Entity.entity(message));
  return response.getStatus();
}

我尝试将其包装在一个新的'if'块中,然后我将输入if条件并打开块:

public int sendMessage(Message message) {
  if (message != null) {
    Response response = JerseyClientHelper.target(serverUrl)
              .header("User-Agent", userAgent)
              .post(Entity.entity(message));
    return response.getStatus();
    // Didn't type the '}' to close the block yet
}

但是只要我键入}以关闭块,IntelliJ就会将代码展平为一行:

public int sendMessage(Message message) {
  if (message != null) {
    Response response = JerseyClientHelper.target(serverUrl).header("User-Agent", userAgent).post(Entity.entity(message));
    return response.getStatus();
  }
}

有没有办法禁用流畅的API自动展平？我查看了"代码样式 - > Java"和"代码样式 - >常规"部分,但找不到任何与此特别相关的内容.