Question

我想在数据框的每一行中找到与所选行相似的行列表，然后将这些行潜在地放入相关行下的同一数据框中。基本上，我有一段时间会消耗电力，我想根据我定义的标准从过去找到匹配的电力。我的数据框标题已附加。这可能吗？

timestamp     power  daytype  ...  dayofweek weekday  quarter
0 2014-10-15 12:30:00  0.031707  weekday  ...          2       2        4
1 2014-10-15 12:45:00  0.140829  weekday  ...          2       2        4
2 2014-10-15 13:00:00  1.703882  weekday  ...          2       2        4
3 2014-10-15 13:15:00  0.032661  weekday  ...          2       2        4
4 2014-10-15 13:30:00  0.032939  weekday  ...          2       2        4

根据我从@brentertainer收到的回复，我尝试了以下操作：

dfNew = pd.DataFrame()
for index, row in dfAll.iterrows:
    mask = np.logical_and.reduce([
            dfAll['date']== row['date'],
            dfAll['hour']==row['hour']
            ])
    dfNew.append(dfAll.loc[mask,:])`

我想为每行添加新的数据框，并在其中附加这些过滤后的值。另外，我可以以某种方式附加一个额外的列，该列将包含要对其进行过滤的行的索引吗？

Answer 1

我认为您的问题的答案是“是”，但您所描述的场景相当抽象。我正在提供一个类似的抽象示例，说明一些可能性，希望您知道如何将其应用于您的情况。

根据“相似”的组成，更改函数内的mask定义。

创建虚拟数据：

import pandas as pd
import numpy as np

# make example repeatable
np.random.seed(0)

# make dummy data
N = 100
df = pd.DataFrame(data=np.random.choice(range(5), size=(N, 8)))
df.columns = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']

更新建议：

def similar_rows(idx, row, df):
    mask = np.logical_and.reduce([
        df['a'] == row['a'],
        abs(df['b'] - row['b']) <= 1,
        df['h'] == (3 - row['h'])
    ])
    df_tmp = df.loc[mask, :]
    df_tmp.insert(0, 'original_index', idx)
    return df_tmp

# create result
df_new = pd.concat([similar_rows(idx, row, df) for idx, row in df.iterrows()])
df_new.reset_index(inplace=True)
df_new.rename({'index': 'similar_index'}, axis=1, inplace=True)
print(df_new.head(10))

结果：

   similar_index  original_index  a  b  c  d  e  f  g  h
0              1               0  4  0  0  4  2  1  0  1
1             88               0  4  1  4  0  0  2  3  1
2              0               1  4  0  3  3  3  1  3  2
3             59               1  4  1  4  1  4  1  2  2
4             82               1  4  0  2  3  4  3  0  2
5              4               2  1  1  1  0  2  4  3  3
6              7               2  1  1  3  3  2  3  0  3
7             37               2  1  0  2  4  4  2  4  3
8             14               3  2  3  1  2  1  4  2  3
9             16               3  2  3  0  4  0  0  2  3

原始建议：

# get row at random
row = df.loc[np.random.choice(N), :]
print('Randomly Selected Row:')
print(pd.DataFrame(row).T)

# create and apply a mask for arbitrarily similar rows
mask = np.logical_and.reduce([
    df['a'] == row['a'],
    abs(df['b'] - row['b']) <= 1,
    df['h'] == (3 - row['h'])
])

print('"Similar" Results:')
df_filtered = df.loc[mask, :]
print(df_filtered)

结果：

Randomly Selected Row:
    a  b  c  d  e  f  g  h
23  3  2  4  3  3  0  3  0
"Similar" Results:
    a  b  c  d  e  f  g  h
26  3  2  2  4  3  1  2  3
60  3  1  2  2  4  2  2  3
86  3  2  4  1  3  0  4  3

根据条件从同一数据框中查找行

1 个答案: