4

这是我的输入：

import pandas as pd
import numpy as np

list1 = [10,79,6,38,4,557,12,220,46,22,45,22]
list2 = [4,3,23,6,234,47,312,2,426,42,435,23]

df = pd.DataFrame({'A' : list1, 'B' : list2}, columns = ['A', 'B'])
df['C'] = np.where (df['A'] > df['B'].shift(-2), 1, np.nan)
print (df)

产生这个输出：

      A    B    C
0    10    4  NaN
1    79    3  1.0
2     6   23  NaN
3    38    6  NaN
4     4  234  NaN
5   557   47  1.0
6    12  312  NaN
7   220    2  1.0
8    46  426  NaN
9    22   42  NaN
10   45  435  NaN
11   22   23  NaN

我需要做的是将“C”列更改为一组三个连续的 1，不重叠。所需的输出是：

      A    B    C
0    10    4  NaN
1    79    3  1.0
2     6   23  1.0
3    38    6  1.0
4     4  234  NaN
5   557   47  1.0
6    12  312  1.0
7   220    2  1.0
8    46  426  NaN
9    22   42  NaN
10   45  435  NaN
11   22   23  NaN

因此，第 2、3 和 6 行从 NaN 变为 1.0。第 7 行已经有一个 1.0，它被忽略了。第 8 行和第 9 行需要保持 NaN，因为第 7 行是前一组的最后一个条目。

我不知道是否有更好的方法来构建可以在创建时执行此操作的列“C”。

我尝试了几个版本的 fillna 和 ffill，没有一个对我有用。

看起来很复杂，但我尝试用这一行隔离每个 1.0 的行 ID：

print (df.loc[df['C'] == 1])

哪个正确输出：

     A   B    C
1   79   3  1.0
5  557  47  1.0
7  220   2  1.0

尽管我知道这些信息，但我不知道如何从那里着手。

非常感谢您提前提供的帮助，大卫

4

2 回答 2

4

编辑：

更快的版本（感谢 b2002）：

ii = df[pd.notnull(df.C)].index
dd = np.diff(ii)
jj = [ii[i] for i in range(1,len(ii)) if dd[i-1] > 2]
jj = [ii[0]] + jj

for ci in jj:
    df.C.values[ci:ci+3] = 1.0

首先通过查看列中不为空的点之间的差异（默认情况下包含第一个索引）来获取所有起点的索引，即所有为 1.0 且具有两个 NaN 的点C，然后迭代这些索引并用于loc更改C列的切片：

ii = df[pd.notnull(df.C)].index
dd = np.diff(ii)
jj = [ii[i] for i in range(1,len(ii)) if dd[i-1] > 2]
jj = [ii[0]] + jj

for ci in jj:
    df.loc[ci:ci+2,'C'] = 1.0

结果：

      A    B    C
0    10    4  NaN
1    79    3  1.0
2     6   23  1.0
3    38    6  1.0
4     4  234  NaN
5   557   47  1.0
6    12  312  1.0
7   220    2  1.0
8    46  426  NaN
9    22   42  NaN
10   45  435  NaN
11   22   23  NaN
于 2017-02-22T07:28:54.633 回答
2 
list1 = [10,79,6,38,4,557,12,220,46,22,45,22]
list2 = [4,3,23,6,234,47,312,2,426,42,435,23]

df = pd.DataFrame({'A' : list1, 'B' : list2}, columns = ['A', 'B'])
df['C'] = np.where (df['A'] > df['B'].shift(-2), 1, np.nan)

      A    B    C
0    10    4  NaN
1    79    3  1.0
2     6   23  NaN
3    38    6  NaN
4     4  234  NaN
5   557   47  1.0
6    12  312  NaN
7   220    2  1.0
8    46  426  NaN
9    22   42  NaN
10   45  435  NaN
11   22   23  NaN

从序列中创建一个数组：

a = np.array(df.C)

此函数将测试数组的段是否匹配模式，并将替换与另一个模式匹配的段。以前匹配的片段将不会被考虑用于未来的匹配（填充数大于一）。

def fill_segments(a, test_patterns, fill_patterns):
    # replace nans with zeros so fast numpy array_equal will work
    nan_idx = np.where(np.isnan(a))[0]
    np.put(a, nan_idx, 0.)
    col_index = list(np.arange(a.size))
    # loop forward through sequence comparing segment patterns
    for j in np.arange(len(test_patterns)):
        this_pattern = test_patterns[j]
        snip = len(this_pattern)
        rng = col_index[:-snip + 1]
        for i in rng:
            seg = a[col_index[i: i + snip]]
            if np.array_equal(seg, this_pattern):
                # when a match is found, replace values in array segment
                # with fill pattern
                pattern_indexes = col_index[i: i + snip]
                np.put(a, pattern_indexes, fill_patterns[j])
    # convert all fillers to ones
    np.put(a, np.where(a > 1.)[0], 1.)
    # convert zeros back to nans
    np.put(a, np.where(a == 0.)[0], np.nan)

    return a

要替换的模式：

p1 = [1., 1., 1.]
p2 = [1., 0., 1.]
p3 = [1., 1., 0.]
p4 = [1., 0., 0.]

以及相应的填充模式：

f1 = [5., 5., 5.]
f2 = [4., 4., 4.]
f3 = [3., 3., 3.]
f4 = [2., 2., 2.]

制作 test_patterns 和 fill_patterns 输入

patterns = [p1, p2, p3, p4]
fills = [f1, f2, f3, f4]

运行功能：

a = fill_segments(a, patterns, fills)

将 a 分配给 C 列

df.C = a

东风：

      A    B    C
0    10    4  NaN
1    79    3  1.0
2     6   23  1.0
3    38    6  1.0
4     4  234  NaN
5   557   47  1.0
6    12  312  1.0
7   220    2  1.0
8    46  426  NaN
9    22   42  NaN
10   45  435  NaN
11   22   23  NaN

根据最初填充输入列的方式和特定的结果顺序规则，可能需要调整/添加模式和填充。

于 2017-02-22T06:24:04.880 回答