Python 使用pandas计算数据帧中选定数据的平均值的循环

我有一个3行96列的数据帧。我试图计算索引下每12个数据点的两行（行1:96）的平均值。这是我的数据框：

 Run 1       Run 2      Run 3       Run 4       Run 5       Run 6  \
0  1461274.92  1458079.44  1456807.1  1459216.08  1458643.24  1457145.19   
1   478167.44   479528.72  480316.08   475569.52   472989.01   476054.89   
2      ------      ------     ------      ------      ------      ------   

    Run 7       Run 8       Run 9      Run 10     ...          Run 87  \
0  1458117.08  1455184.82  1455768.69  1454738.07     ...      1441822.45   
1   473630.89   476282.93   475530.87   474200.22     ...        468525.2   
2      ------      ------      ------      ------     ...          ------   

   Run 88      Run 89      Run 90      Run 91      Run 92      Run 93  \
0  1445339.53  1461050.97  1446849.43  1438870.43  1431275.76  1430781.28   
1    460076.8   473263.06   455885.07   475245.64   483875.35   487065.25   
2      ------      ------      ------      ------      ------      ------   

   Run 94      Run 95      Run 96  
0  1436007.32  1435238.23  1444300.51  
1   474328.87   475789.12   458681.11  
2      ------      ------      ------  

[3 rows x 96 columns]

目前我正在尝试使用df.irow（0）来选择行索引0中的所有数据

大致如下：

selection = np.arange(0,13)

for i in selection:
    new_df = pd.DataFrame()
    data = df.irow(0)

    ........

然后我就迷路了

我只是不知道如何将这个范围与数据帧联系起来，以便计算每列中每12个数据点的平均值

总而言之，我想要每列中每12次的平均值。因此，我应该得到一个单独的数据帧，平均值为2*8（96/12）。 有什么想法吗

---

谢谢

如果可以，最好尝试使用

pandas

方法，而不是迭代行。数据帧的

iloc

方法可用于提取任意数量的行

下面的示例演示如何在两列数据帧中执行所需操作。相同的技术将独立于列数工作：

In [14]: df = pd.DataFrame({"x": [1, 2, "-"], "y": [3, 4, "-"]})

In [15]: df
Out[15]:
   x  y
0  1  3
1  2  4
2  -  -

In [16]: df.iloc[2] = df.iloc[0:2].sum()

In [17]: df
Out[17]:
   x  y
0  1  3
1  2  4
2  3  7

但是，在您的例子中，您希望对df.iloc[2]``中的每组八个单元格求和，因此最好是将求和表达式的结果与语句一起使用

ds = df.iloc[0:2].sum()

其中包含您的数据的表格

col1    0
col2    1
col3    2
col4    3
   ...
col93  92
col94  93
col95  94
col96  95

（这些数字是有代表性的，您显然会看到您的列总和）。然后，您可以使用

ds.values.reshape(12, 8)

谁的价值是

array([[ 0,  1,  2,  3,  4,  5,  6,  7],
   [ 8,  9, 10, 11, 12, 13, 14, 15],
   [16, 17, 18, 19, 20, 21, 22, 23],
   [24, 25, 26, 27, 28, 29, 30, 31],
   [32, 33, 34, 35, 36, 37, 38, 39],
   [40, 41, 42, 43, 44, 45, 46, 47],
   [48, 49, 50, 51, 52, 53, 54, 55],
   [56, 57, 58, 59, 60, 61, 62, 63],
   [64, 65, 66, 67, 68, 69, 70, 71],
   [72, 73, 74, 75, 76, 77, 78, 79],
   [80, 81, 82, 83, 84, 85, 86, 87],
   [88, 89, 90, 91, 92, 93, 94, 95]])

但是，对这个数组求和将得到所有元素的和，因此使用

rs = pd.DataFrame(ds.values.reshape(12, 8))

然后求和：

rs.sum()

给予

0    528
1    540
2    552
3    564
4    576
5    588
6    600
7    612
dtype: int64

---

在实践中，您可能会发现，首先简单地创建两个12x8矩阵更容易，您可以在创建数据帧之前将它们相加，然后再对其求和。这在很大程度上取决于您读取数据的方式。

在可能的情况下，最好尝试使用

pandas

方法，而不是遍历行。数据帧的

iloc

方法可用于提取任意数量的行

下面的示例演示如何在两列数据帧中执行所需操作。相同的技术将独立于列数工作：

In [14]: df = pd.DataFrame({"x": [1, 2, "-"], "y": [3, 4, "-"]})

In [15]: df
Out[15]:
   x  y
0  1  3
1  2  4
2  -  -

In [16]: df.iloc[2] = df.iloc[0:2].sum()

In [17]: df
Out[17]:
   x  y
0  1  3
1  2  4
2  3  7

但是，在您的例子中，您希望对df.iloc[2]``中的每组八个单元格求和，因此最好是将求和表达式的结果与语句一起使用

ds = df.iloc[0:2].sum()

其中包含您的数据的表格

col1    0
col2    1
col3    2
col4    3
   ...
col93  92
col94  93
col95  94
col96  95

（这些数字是有代表性的，您显然会看到您的列总和）。然后，您可以使用

ds.values.reshape(12, 8)

谁的价值是

array([[ 0,  1,  2,  3,  4,  5,  6,  7],
   [ 8,  9, 10, 11, 12, 13, 14, 15],
   [16, 17, 18, 19, 20, 21, 22, 23],
   [24, 25, 26, 27, 28, 29, 30, 31],
   [32, 33, 34, 35, 36, 37, 38, 39],
   [40, 41, 42, 43, 44, 45, 46, 47],
   [48, 49, 50, 51, 52, 53, 54, 55],
   [56, 57, 58, 59, 60, 61, 62, 63],
   [64, 65, 66, 67, 68, 69, 70, 71],
   [72, 73, 74, 75, 76, 77, 78, 79],
   [80, 81, 82, 83, 84, 85, 86, 87],
   [88, 89, 90, 91, 92, 93, 94, 95]])

但是，对这个数组求和将得到所有元素的和，因此使用

rs = pd.DataFrame(ds.values.reshape(12, 8))

然后求和：

rs.sum()

给予

0    528
1    540
2    552
3    564
4    576
5    588
6    600
7    612
dtype: int64

---

在实践中，您可能会发现，首先简单地创建两个12x8矩阵更容易，您可以在创建数据帧之前将它们相加，然后再对其求和。这在很大程度上取决于您读取数据的方式。

在可能的情况下，最好尝试使用

pandas

方法，而不是遍历行。数据帧的

iloc

方法可用于提取任意数量的行

下面的示例演示如何在两列数据帧中执行所需操作。相同的技术将独立于列数工作：

In [14]: df = pd.DataFrame({"x": [1, 2, "-"], "y": [3, 4, "-"]})

In [15]: df
Out[15]:
   x  y
0  1  3
1  2  4
2  -  -

In [16]: df.iloc[2] = df.iloc[0:2].sum()

In [17]: df
Out[17]:
   x  y
0  1  3
1  2  4
2  3  7

但是，在您的例子中，您希望对df.iloc[2]``中的每组八个单元格求和，因此最好是将求和表达式的结果与语句一起使用

ds = df.iloc[0:2].sum()

其中包含您的数据的表格

col1    0
col2    1
col3    2
col4    3
   ...
col93  92
col94  93
col95  94
col96  95

（这些数字是有代表性的，您显然会看到您的列总和）。然后，您可以使用

ds.values.reshape(12, 8)

谁的价值是

array([[ 0,  1,  2,  3,  4,  5,  6,  7],
   [ 8,  9, 10, 11, 12, 13, 14, 15],
   [16, 17, 18, 19, 20, 21, 22, 23],
   [24, 25, 26, 27, 28, 29, 30, 31],
   [32, 33, 34, 35, 36, 37, 38, 39],
   [40, 41, 42, 43, 44, 45, 46, 47],
   [48, 49, 50, 51, 52, 53, 54, 55],
   [56, 57, 58, 59, 60, 61, 62, 63],
   [64, 65, 66, 67, 68, 69, 70, 71],
   [72, 73, 74, 75, 76, 77, 78, 79],
   [80, 81, 82, 83, 84, 85, 86, 87],
   [88, 89, 90, 91, 92, 93, 94, 95]])

但是，对这个数组求和将得到所有元素的和，因此使用

rs = pd.DataFrame(ds.values.reshape(12, 8))

然后求和：

rs.sum()

给予

0    528
1    540
2    552
3    564
4    576
5    588
6    600
7    612
dtype: int64

---

在实践中，您可能会发现，首先简单地创建两个12x8矩阵更容易，您可以在创建数据帧之前将它们相加，然后再对其求和。这在很大程度上取决于您读取数据的方式。

在可能的情况下，最好尝试使用

pandas

方法，而不是遍历行。数据帧的

iloc

方法可用于提取任意数量的行

下面的示例演示如何在两列数据帧中执行所需操作。相同的技术将独立于列数工作：

In [14]: df = pd.DataFrame({"x": [1, 2, "-"], "y": [3, 4, "-"]})

In [15]: df
Out[15]:
   x  y
0  1  3
1  2  4
2  -  -

In [16]: df.iloc[2] = df.iloc[0:2].sum()

In [17]: df
Out[17]:
   x  y
0  1  3
1  2  4
2  3  7

但是，在您的例子中，您希望对df.iloc[2]``中的每组八个单元格求和，因此最好是将求和表达式的结果与语句一起使用

ds = df.iloc[0:2].sum()

其中包含您的数据的表格

col1    0
col2    1
col3    2
col4    3
   ...
col93  92
col94  93
col95  94
col96  95

（这些数字是有代表性的，您显然会看到您的列总和）。然后，您可以使用

ds.values.reshape(12, 8)

谁的价值是

array([[ 0,  1,  2,  3,  4,  5,  6,  7],
   [ 8,  9, 10, 11, 12, 13, 14, 15],
   [16, 17, 18, 19, 20, 21, 22, 23],
   [24, 25, 26, 27, 28, 29, 30, 31],
   [32, 33, 34, 35, 36, 37, 38, 39],
   [40, 41, 42, 43, 44, 45, 46, 47],
   [48, 49, 50, 51, 52, 53, 54, 55],
   [56, 57, 58, 59, 60, 61, 62, 63],
   [64, 65, 66, 67, 68, 69, 70, 71],
   [72, 73, 74, 75, 76, 77, 78, 79],
   [80, 81, 82, 83, 84, 85, 86, 87],
   [88, 89, 90, 91, 92, 93, 94, 95]])

但是，对这个数组求和将得到所有元素的和，因此使用

rs = pd.DataFrame(ds.values.reshape(12, 8))

然后求和：

rs.sum()

给予

0    528
1    540
2    552
3    564
4    576
5    588
6    600
7    612
dtype: int64

---

在实践中，您可能会发现，首先简单地创建两个12x8矩阵更容易，您可以在创建数据帧之前将它们相加，然后再对其求和。这在很大程度上取决于您读取数据的方式。

您可以在axis=1上执行groupby（使用我制作的一些虚拟数据）：

---

首先，我们提取数据并强制识别浮点（存在

----

行意味着您可能有一个

对象

数据类型，这将使

均值

不满意。）

然后我们制作一个数组，说明我们要将不同列放入哪些组：

>>> np.arange(len(df.columns))//12
array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
       1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
       3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5,
       5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7,
       7, 7, 7, 7], dtype=int32)

---

我们将其作为参数馈送给

groupby

.mean（）

处理其余部分。

您可以在轴=1上执行groupby（使用我编的一些虚拟数据）：

---

首先，我们提取数据并强制识别浮点（存在

----

行意味着您可能有一个

对象

数据类型，这将使

均值

不满意。）

然后我们做一个数组