Question

我在熊猫中有以下数据框：

     id              name categoryids    shops
5   239         Boulanger         [5]      152
3   196  Bouygues Telecom         [5]      500
4   122             Darty       [5,3]      363
1   311     Electro Dépôt         [5]       81
0  2336            Orange        [15]      578
2   194            Orange         [5]      577

我想删除第5行，因为它的名称重复，但在 categoryids 列中具有不同的值，但是由于值是数组（因为它们可以有多个值），我无法比较它们。

我的想法是检查该列的模式，并丢弃其数组中没有该值的所有行（例如，在这种情况下，该模式将为5，因此应丢弃第5列，因为值不存在于其数组中），但由于列是数组而不是单个值，因此在计算此值时遇到问题。

关于如何执行此操作的任何想法或建议？

我正在使用python 3.7和熊猫的最新版本。

谢谢。

Answer 1

首先，我们可以标记name列中的哪些行是重复的。

然后，我们可以使用this答案中的函数来unnest categoryids中的数组。

最后，我们过滤哪些行被未标记为重复的或等于mode的行：

def unnest(df, tile, explode):
    vals = df[explode].sum(1)
    rs = [len(r) for r in vals]
    a = np.repeat(df[tile].values, rs, axis=0)
    b = np.concatenate(vals.values)
    d = np.column_stack((a, b))
    return pd.DataFrame(d, columns = tile +  ['_'.join(explode)])

# Mark duplicate rows
df['dups'] = df.name.duplicated(keep=False).astype(int)
# Unnest categoryids column
df2 = unnest(df, ['id', 'name', 'shops', 'dups'], ['categoryids'])

print(df2)
     id              name shops dups categoryids
0   239         Boulanger   152    0           5
1   196  Bouygues Telecom   500    0           5
2   122             Darty   363    0           5
3   122             Darty   363    0           3
4   311     Electro Dépôt    81    0           5
5  2336            Orange   578    1          15
6   194            Orange   577    1           5

过滤不等于该模式的重复行：

mode = df2['categoryids'].mode()

df2 = df2[~df2['dups'].eq(1) | df2['categoryids'].isin(mode)].drop('dups', axis=1)

print(df2)
    id              name shops categoryids
0  239         Boulanger   152           5
1  196  Bouygues Telecom   500           5
2  122             Darty   363           5
3  122             Darty   363           3
4  311     Electro Dépôt    81           5
6  194            Orange   577           5

可选我们可以对name进行分组，以取回数组：


df2 = df2.groupby('name').agg({'id':'first',
                               'shops':'first',
                              'categoryids':list}).reset_index()

print(df2)
               name   id  shops categoryids
0         Boulanger  239    152         [5]
1  Bouygues Telecom  196    500         [5]
2             Darty  122    363      [5, 3]
3     Electro Dépôt  311     81         [5]
4            Orange  194    577         [5]

Answer 2

使用这样的DataFrame：

df = pd.DataFrame({'id': [239,196,122,311,2336,194,],
'name': ['Boulanger','Bouygues Telecom','Darty','Electro Dépôt','Orange','Orange',],
'shops': [152, 500, 363, 81, 578, 577,],
'categoryids': [[5],[5],[5,3],[5],[15],[5],]})

您可以这样做：

df.sort_values('categoryids').drop_duplicates('name', keep='first')

对categoryids列进行排序，然后将重复项放在name中，并保留第一列。

编辑：

您可以做的另一件事是检查您在categoryids列中追求的值是否存在：

df["exist"] = [int(5 in r)  for r in df["categoryids"]]

哪个会给你：

    id              name                shops   categoryids exist
0   239             Boulanger             152            [5]    1
1   196             Bouygues Telecom      500            [5]    1
2   122             Darty                 363         [5, 3]    1
3   311             Electro Dépôt          81            [5]    1
4   2336            Orange                578           [15]    0
5   194             Orange                577            [5]    1

然后您只能选择存在的那些：

df[df['exist'] == 1]

然后使用pd.duplicated()查找重复项，如@Erfan所述：

df['dups'] = df['name'].duplicated(keep=False).astype(int)


    id  name               shops     categoryids    exist   dups
0   239 Boulanger            152             [5]    1          0
1   196 Bouygues Telecom     500             [5]    1          0
2   122 Darty                363          [5, 3]    1          0
3   311 Electro Dépôt         81             [5]    1          0
4   2336    Orange           578            [15]    0          1
5   194 Orange               577             [5]    1          1


df[(
    (df['dups']!=1) | 
    (df['exist']!=0)
)].drop(['exist', 'dups'], axis=1).reset_index()

会导致：

index   id  name               shops    categoryids
0   0   239 Boulanger            152    [5]
1   1   196 Bouygues Telecom     500    [5]
2   2   122 Darty                363    [5, 3]
3   3   311 Electro Dépôt         81    [5]
4   5   194 Orange               577    [5]

Answer 3

您可以尝试：

df = df.drop_duplicates(subset = ['name'])

这将仅在列名称中查看重复项。您可以通过将其他列名称添加到子集列表来合并列。

Answer 4

我设法使用@VnC答案做了一些修改，因为我认为 categoryids 的数组是实际的整数数组（如上例所示），但我发现它们是字符串（不是字符串数组，而是纯字符串）：

retailersIds_df = get_dataframe() # external method to get the dataframe, not relevant
retailersIds_df['categoryids'] = retailersIds_df['categoryids'].str.replace('[', '')
retailersIds_df['categoryids'] = retailersIds_df['categoryids'].str.replace(']', '')
retailersIds_df['categoryids'] = retailersIds_df['categoryids'].str.split(',')
# the following lines are used to calculate the mode of all the values contained in the arrays. 

ids_aux = []
for row in retailersIds_df.itertuples():
    ids_aux = ids_aux + row.categoryids
mydict = Counter(ids_aux)
mode = [key for key, value in mydict.items() if value ==  max(mydict.values())][0] 

# the counter module returns a dict, and the key (the actual value) of the most repeated value is chosen.
#the [0] is for the case where two keys have the same value, and the first is chosen (arbitrarily)

retailersIds_df["exist"] = [int(mode in r) for r in retailersIds_df["categoryids"]]
retailersIds_df = retailersIds_df[retailersIds_df['exist'] == 1]

尽管可能存在更好的选择，但还是通过循环来计算模式（我知道循环不应该在pandas数据帧中完成，但是考虑到数组可以是一个数组，所以我想不出其他选择。任意长度）

如何基于数组列的值删除熊猫行？

4 个答案: