0

我有以下结构的数据框

transaction | customer | week | amount
12551       | ieeamo   | 32   | €23.54
12553       | ieeamo   | 33   | €17.00

我想在以下结构中得到它(所有星期)

week | customer | activity last week | activity 2 weeks ago
32   | ieeamo   | €0.00              | €0.00
33   | ieeamo   | €23.54             | €0.00
34   | ieeamo   | €17.00             | €23.54             
35   | ieeamo   | €0.00              | €17.00 

本质上,我正在尝试将事务数据转换为相关数据。

我的想法是,最好的方法是使用循环生成许多数据帧,然后在最后将它们全部 rbind。但是,这种方法似乎效率不高,我不确定它是否会扩展到我正在使用的数据。

有没有更合适的解决方案?

4

1 回答 1

1

Rbinding 对此是个坏主意,因为每个rbind都会在内存中创建数据帧的新副本。我们可以通过主要是矢量化的方法更快地得到答案,使用循环只是为了使代码更简洁。对 OP 的支持,以识别效率低下并寻找解决方案。

注意:以下解决方案适用于任意数量的客户,但需要稍作修改才能使用更多滞后列。

设置:首先我们需要生成一些数据来处理。我将使用两个不同的客户,每个客户都有几周的交易数据,如下所示:

data <- read.table(text="
    transaction customer week amount
    12551       cOne     32   1.32
    12552       cOne     34   1.34
    12553       cTwo     34   2.34
    12554       cTwo     35   2.35
    12555       cOne     36   1.36
    12556       cTwo     37   1.37
    ", header=TRUE)

步骤1:计算一些变量并初始化新的数据框。为了让编程变得非常简单,我们首先想知道两件事:有多少客户和多少周?我们这样计算这些答案:

customer_list <- unique(data$customer)
# cOne cTwo

week_span <- min(data$week):max(data$week)
# 32 33 34 35 36 37

接下来,我们需要根据刚刚计算的变量来初始化新的数据框。在这个新的数据框中,我们需要每个星期的条目,而不仅仅是数据中的星期。这就是我们的“week_span”变量有用的地方。

new_data <- data.frame(
    week=sort(rep(week_span,length(customer_list))),
    customer=customer_list,
    activity_last_week=NA,
    activity_2_weeks_ago=NA)

#    week customer activity_last_week activity_2_weeks_ago
# 1    32     cOne                 NA                   NA
# 2    32     cTwo                 NA                   NA
# 3    33     cOne                 NA                   NA
# 4    33     cTwo                 NA                   NA
# 5    34     cOne                 NA                   NA
# 6    34     cTwo                 NA                   NA
# 7    35     cOne                 NA                   NA
# 8    35     cTwo                 NA                   NA
# 9    36     cOne                 NA                   NA
# 10   36     cTwo                 NA                   NA
# 11   37     cOne                 NA                   NA
# 12   37     cTwo                 NA                   NA

您会注意到我们为每个客户重复周列表并对其进行排序,因此我们得到一个类似于 1,1,2,2,3,3,4,4...n,n 的列表,重复次数等于数据中的客户数量。这使得我们可以将“客户”数据指定为客户列表,因为列表将重复以填满空间。滞后列现在保留为 NA。

第 2 步:填写滞后值。现在,事情很简单。我们只需要获取每个客户的行子集,并找出每周是否有任何交易。我们通过使用“匹配”函数来提取每周的值来做到这一点。如果数据不存在,我们将得到一个 NA 值并需要用零替换它们(假设没有活动意味着零交易)。然后,对于滞后列,我们只需根据滞后的周数用 NA 偏移值。

# Loop through the customers.
for (i in 1:length(customer_list)){
    # Select the next customer's data.
    subset <- data[data$customer==customer_list[i],]

    # Extract the data values for each week.
    subset_amounts <- subset$amount[match(week_span, subset$week)]

    # Replace NA with zero.
    subset_amounts <- ifelse(is.na(subset_amounts),0,subset_amounts)

    # Loop through the lag columns.   
    for (lag in 1:2){

        # Write in the data values with the appropriate
        # number of offsets according to the lag.
        # Truncate the extra values.
        new_data[new_data$customer==customer_list[i], (2+lag)] <- c(rep(NA,lag), subset_amounts[1:(length(subset_amounts)-lag)])
    }
}

#    week customer activity_last_week activity_2_weeks_ago
# 1    32     cOne                 NA                   NA
# 2    32     cTwo                 NA                   NA
# 3    33     cOne               1.32                   NA
# 4    33     cTwo               0.00                   NA
# 5    34     cOne               0.00                 1.32
# 6    34     cTwo               0.00                 0.00
# 7    35     cOne               1.34                 0.00
# 8    35     cTwo               2.34                 0.00
# 9    36     cOne               0.00                 1.34
# 10   36     cTwo               2.35                 2.34
# 11   37     cOne               1.36                 0.00
# 12   37     cTwo               0.00                 2.35

在其他情况下......如果您有一系列有序的时间数据,其中没有丢失任何行,那么使用“嵌入”功能,这种任务变得非常简单。假设我们有一些看起来像这样的数据:

data <- data.frame(week=1:20, value=1:20+(1:20/100))

#    week value
# 1     1  1.01
# 2     2  2.02
# 3     3  3.03
# 4     4  4.04
# 5     5  5.05
# 6     6  6.06
# 7     7  7.07
# 8     8  8.08
# 9     9  9.09
# 10   10 10.10
# 11   11 11.11
# 12   12 12.12
# 13   13 13.13
# 14   14 14.14
# 15   15 15.15
# 16   16 16.16
# 17   17 17.17
# 18   18 18.18
# 19   19 19.19
# 20   20 20.20

我们可以立即创建一个滞后数据集,如下所示:

new_data <- data.frame(week=data$week[3:20], embed(data$value,3))

names(new_data)[2:4] <- c("this_week", "last_week", "2_weeks_ago")

#    week this_week last_week 2_weeks_ago
# 1     3      3.03      2.02        1.01
# 2     4      4.04      3.03        2.02
# 3     5      5.05      4.04        3.03
# 4     6      6.06      5.05        4.04
# 5     7      7.07      6.06        5.05
# 6     8      8.08      7.07        6.06
# 7     9      9.09      8.08        7.07
# 8    10     10.10      9.09        8.08
# 9    11     11.11     10.10        9.09
# 10   12     12.12     11.11       10.10
# 11   13     13.13     12.12       11.11
# 12   14     14.14     13.13       12.12
# 13   15     15.15     14.14       13.13
# 14   16     16.16     15.15       14.14
# 15   17     17.17     16.16       15.15
# 16   18     18.18     17.17       16.16
# 17   19     19.19     18.18       17.17
# 18   20     20.20     19.19       18.18
于 2013-08-14T17:22:53.660 回答