Question

如果我有这样的数据集：

Object1    Object2    Outcome1  Outcome2      Total_TestsObject1 Total_TestsObject2   TotalOutcomes_Object1    TotalOutcomesObject2
  A         C            0         1                    0                 0                      0                      0
  D         A            0         1                    0                 1                      0                      0
  B         E            1         0                    0                 0                      0                      0
  F         B            0         1                    0                 1                      0                      1 
  A         B            1         0                    2                 2                      1                      2  
  A         C            0         1                    3                 1                      1                      1
  D         A            0         1                    1                 4                      0                      1
  B         E            1         0                    3                 1                      1                      0
  F         B            0         1                    1                 4                      0                      2 
  A         B            1         0                    5                 5                      3                      3

我想做的是创建两列：

Object1中的第1列跟踪项将所有以前的唯一对相加，如下所示。 TotalOutcomes_ObjectX / Total_TestsObjectX 由于对象1中的一项以前可以存在于对象2中，因此求和必须在两个对象中找到唯一的对。

我知道目前还不清楚，但仍在设法找到适当地制定它的方法。但这是一个例子。

在最后一行，我们有A＆B

A最接近事件的先前唯一对

A   D   row 7
A   c   row 6

B的先前配对最接近事件

B    F  row 9
B    E  row 8

因此，在找到这些对之后，总和如下。

Column 1(Object1):    Sum: (D_Outcomes + C_outcomes) / (D_TotalTest + C_TotalTest)
             = (1 + 1)/(1 + 1)=1


Column 2(Object2):    Sum: (F_Outcomes + E_outcomes) / (F_TotalTest + E_TotalTest)
             = (1 + 1)/(1 + 1)=1

因此，此过程遍历每一行，并找到所有先前的唯一对向后进行并求和。

我不知道该怎么用python完成。

 Input

    {
    Object1:[ A, A, B, C, A, F, B]
    Object2:[C, D, E, D, B, E, D]
    Outcome1:[1, 0, 1, 0, 0, 1, 0]
    Outcome2:[0, 1, 0, 1, 1, 0, 1]
    TotalOutcomes_Object1:[0, 0, 0, 1, 1, 0, 0]
    TotalOutcomes_Object2:[0, 0, 0, 0, 0, 1, 0]
    Total_TestsObject1:[0, 1, 0, 1, 2, 0, 2]
    Total_TestsObject2:[0, 0, 0, 1, 1, 1, 2]
    }

条件：

由于对象既可以作为对象1也可以作为对象2，所以求和必须在对象1和对象2中都找到对象的唯一外观

由于将Total_Outcomes和Total_Tests计为产生的结果并进行了测试，因此必须找到所有唯一的对象对，并返回其结果和最新的Total_Tests

Example:

Let's say A(Object1) and B(Object2) are a pair
A has previously been a pair with D, E and F
B has previously been a pair with C, D, G

Column1 then sums all of A's previous pair partners, meaning D, E, F
in the following way.

Sum: (D_Outcomes + E_outcomes + F_outcomes) / (C_TotalTest + D_TotalTest + F_outcomes)

Column2 then sums all of B's previous pair partners, meaning C,D, G
in the following way.

Sum: (C_Outcomes + D_outcomes + G_outcomes) / (C_TotalTest + D_TotalTest + G_outcomes)

The importance in this summations is that the pair partners latest stats are used, this is because both TotalOutcomes and TotalTest are counted up as they occur.

如何基于多个条件顺序评估Dataframe中的列

0 个答案: