Question

我有一个像这样的pandas DataFrame：

import React from 'react';
import { getUserRoles } from 'modules/api/account/user/selectors';
import { connect } from 'react-redux';
import compose from 'utility/compose';

const RestrictedOrFallBack = ({
    wrappedComponent,
    role,
    userRoles,
    fallback,
}) => {
    debugger;
    if (userRoles && userRoles.includes(role)) return wrappedComponent;
    return fallback;
};

const mapStateToProps = state => ({
    userRoles: getUserRoles(state),
});

const ConnectedRestrictedOrFallback = compose(
    connect(mapStateToProps),
    RestrictedOrFallBack,
);

export { RestrictedOrFallBack };
export default ({
    role,
    fallback = () => (<div />),
}) => wrappedComponent => ConnectedRestrictedOrFallback({
    role,
    fallback,
    wrappedComponent,
});

每行包含两个ID，这些ID反映了from_user to_user 0 123 456 1 894 135 2 179 890 3 456 123是否“跟随” from_user。如何使用熊猫计算DataFrame中的共同关注者总数？

在上面的示例中，答案应为1（用户123和456）。

Answer 1

一种方法是使用MultiIndex设置操作：

In [11]: i1 = df.set_index(["from_user", "to_user"]).index

In [12]: i2 = df.set_index(["to_user", "from_user"]).index

In [13]: (i1 & i2).levels[0]
Out[13]: Int64Index([123, 456], dtype='int64')

要获取计数，必须将该索引的长度除以2：

In [14]: len(i1 & i2) // 2
Out[14]: 1

Answer 2

另一种方法是将concat的值和sort作为字符串。然后计算值出现多少次：

# concat the values as string type
df['concat'] = df.from_user.astype(str) + df.to_user.astype(str)

# sort the string values of the concatenation
df['concat'] = df.concat.apply(lambda x: ''.join(sorted(x)))

# count the occurences of each and substract 1
count = (df.groupby('concat').size() -1).sum()

Out[64]: 1

Answer 3

这是执行此操作的另一种方法：

df.loc[df.to_user.isin(df.from_user)]
  .assign(hacky=df.from_user * df.to_user)
  .drop_duplicates(subset='hacky', keep='first')
  .drop('hacky', 1)

   from_user  to_user
0        123      456

存在整个乘法技巧，以确保我们不返回123 --> 456和456 --> 123，因为鉴于我们提供给loc的条件，这两者都是有效的

使用熊猫计算关系表中的共同关注者

3 个答案: