小编pte*_*han的帖子

我正在使用一个pandas DataFrame,其中一列包含numpy数组.当试图通过聚合对该列求和时,我得到一个错误,指出"必须产生聚合值".

例如

import pandas as pd
import numpy as np

DF = pd.DataFrame([[1,np.array([10,20,30])],
               [1,np.array([40,50,60])], 
               [2,np.array([20,30,40])],], columns=['category','arraydata'])

这按照我期望的方式工作:

DF.groupby('category').agg(sum)

输出:

             arraydata
category 1   [50 70 90]
         2   [20 30 40]

但是,由于我的实际数据框有多个数字列,因此不选择arraydata作为聚合的默认列,我必须手动选择它.这是我尝试过的一种方法:

g=DF.groupby('category')
g.agg({'arraydata':sum})

这是另一个:

g=DF.groupby('category')
g['arraydata'].agg(sum)

两者都给出相同的输出:

Exception: must produce aggregated value

但是,如果我有一个使用数字而不是数组数据的列,它可以正常工作.我可以解决这个问题,但这很令人困惑,我想知道这是一个错误,还是我做错了什么.我觉得在这里使用数组可能有点边缘,确实不确定它们是否得到支持.想法？

谢谢

我的小组使用data.table编写了大量代码,我们偶尔会被'检测到无效的.internal.selfref并通过获取整个表的副本来修复...'警告.当通过引用函数传递数据表时,此行为可能会破坏我们的代码,我试图弄清楚如何解决它.

假设我有一个函数,它将一个列添加到data.table作为副作用 - 请注意,不返回原始的data.table.

foo <- function(mydt){
   mydt[, c := c("a", "b")]
   return(123)
)

> x<- data.table(a=c(1,2), b=c(3,4))
> foo(x) 
[1] 123
> x
   a b c
1: 1 3 a
2: 2 4 b

x已使用新列更新.这是期望的行为.

现在假设发生的事情破坏了x中的内部自我引用:

> x<- data.table(a=c(1,2), b=c(3,4))
> x[["a"]] <- c(7,8)
> foo(x)
[1] 123
Warning message:
In `[.data.table`(mydt, , `:=`(c, c("a", "b"))) :
Invalid .internal.selfref detected and fixed by taking a copy ...

 > x
    a b
 1: 7 3
 2: 8 4

我明白发生了什么(大部分).[["a"]]结构不是data.table友好; x被转换为数据框,然后返回到数据表,这在某种程度上搞砸了内部工作.然后在foo()内部,在添加列的引用操作期间,检测到该问题,并且制作了mydt的副本; …

我有一个自定义类,我想重载几个artihmetic操作符,并想知道是否有办法避免必须单独写出每个代码.我无法找到任何不明确地逐个过载每个运算符的示例.

class Foo(object):
    a=0 

    def __init__(self, a):
        self.a=a            

    def __add__(self, other):
        #common logic here
        return Foo(self.a+other.a)

    def __sub__(self, other):
        #common logic here  
        return Foo(self.a-other.a)

    def __mul__(self, other):
        #common logic here
        return Foo(self.a*other.a)

#etc...

逻辑稍微复杂一点,但常见的模式是每个运算符重载方法都包含一些相同的代码来检查操作是否允许,然后使用类成员构造一个操作.我想减少冗余代码.这有效:

class Foo(object):
    a=0 

    def __init__(self, a):
        self.a=a            

    def operate(self, other, operator):
        #common logic here
        a = constructOperation(self.a, other.a, operator)
        return Foo(a)

    def __add__(self, other):
        return self.operate(other, "+")

    def __sub__(self, other):       
        return self.operate(other, "-")     


def constructOperation(operand0, operand1, operator):
    if operator=="+": 
        return operand0 + operand1
    if operator=="-": 
        return …