熊猫中的轴是什么意思？

Question

这是我生成数据框的代码：

import pandas as pd
import numpy as np

dff = pd.DataFrame(np.random.randn(1,2),columns=list('AB'))

然后我得到了数据框：

+------------+---------+--------+
|            |  A      |  B     |
+------------+---------+---------
|      0     | 0.626386| 1.52325|
+------------+---------+--------+

当我输入命令时：

dff.mean(axis=1)

我明白了：

0    1.074821
dtype: float64

根据pandas的参考，axis=1代表列，我希望命令的结果是

A    0.626386
B    1.523255
dtype: float64

所以这是我的问题：熊猫中的轴是什么意思？

Answer 1

它指定沿其计算均值的轴。默认axis=0。这与numpy.mean 的用法一致，当axis 被明确 指定时（在numpy.mean 中，默认情况下axis==None，它计算扁平数组的平均值），其中@ 987654326@ 沿着 rows（即 pandas 中的 index），axis=1 沿着 columns。为了更清楚起见，可以选择指定axis='index'（而不是axis=0）或axis='columns'（而不是axis=1）。

+------------+---------+--------+
|            |  A      |  B     |
+------------+---------+---------
|      0     | 0.626386| 1.52325|----axis=1----->
+------------+---------+--------+
             |         |
             | axis=0  |
             ↓         ↓

Answer 2

这些答案确实有助于解释这一点，但对于非程序员（即像我这样第一次在数据科学课程背景下学习 Python 的人）来说，它仍然不是很直观。我仍然发现对行和列使用“沿”或“每个”这样的术语会让人感到困惑。

对我来说更有意义的是这样说：

• 轴 0 将作用于每个 COLUMN 中的所有 ROWS
• 轴 1 将作用于每一行中的所有列

因此，轴 0 上的平均值将是每列中所有行的平均值，轴 1 上的平均值将是每行中所有列的平均值。

最终这与@zhangxaochen 和@Michael 说的相同，但我更容易内化。

Answer 3

让我们想象一下（你会永远记得），

在熊猫中：

1. axis=0 表示沿“索引”。这是一个逐行操作。

假设，对 dataframe1 & dataframe2 执行 concat() 操作， 我们将取出dataframe1并从dataframe1中取出第一行并放入新的DF中，然后我们从dataframe1中取出另一行放入新的DF中，我们重复此过程直到到达dataframe1的底部。然后，我们对 dataframe2 执行相同的过程。

基本上，将 dataframe2 堆叠在 dataframe1 之上，反之亦然。

例如在桌子或地板上堆一堆书

1. axis=1 表示沿“列”。这是一个按列操作。

假设，对 dataframe1 & dataframe2 执行 concat() 操作， 我们将取出dataframe1的第一个完整列（又名1st series）并放入新的DF中，然后我们取出dataframe1的第二列并保持与它相邻（横向），我们必须重复这个操作，直到所有列都完成。然后，我们在 dataframe2 上重复相同的过程。 基本上， 横向堆叠 dataframe2。

例如在书架上摆放书籍。

更重要的是，与矩阵相比，数组是表示嵌套 n 维结构的更好表示！所以下面可以帮助您更多地了解当您推广到多个维度时轴如何发挥重要作用。此外，您实际上可以打印/写入/绘制/可视化任何 n-dim 数组，但是在超过 3 维的纸上以矩阵表示（3-dim）写入或可视化相同的数组是不可能的。

Answer 4

axis指的是数组的维度，在pd.DataFrames的情况下axis=0是指向下方的维度，axis=1是指向右侧的维度。

示例：想象一个ndarray，形状为(3,5,7)。

a = np.ones((3,5,7))

a 是一个 3 维的 ndarray，即它有 3 个轴（“axes”是“axis”的复数）。 a 的配置看起来像 3 片面包，其中每片的尺寸为 5×7。 a[0,:,:] 将引用第 0 个切片，a[1,:,:] 将引用第 1 个切片等。

a.sum(axis=0) 将沿 a 的第 0 轴应用 sum()。您将添加所有切片并最终得到一个形状 (5,7) 的切片。

a.sum(axis=0) 等价于

b = np.zeros((5,7))
for i in range(5):
    for j in range(7):
        b[i,j] += a[:,i,j].sum()

b 和 a.sum(axis=0) 都会像这样

array([[ 3.,  3.,  3.,  3.,  3.,  3.,  3.],
       [ 3.,  3.,  3.,  3.,  3.,  3.,  3.],
       [ 3.,  3.,  3.,  3.,  3.,  3.,  3.],
       [ 3.,  3.,  3.,  3.,  3.,  3.,  3.],
       [ 3.,  3.,  3.,  3.,  3.,  3.,  3.]])

在pd.DataFrame 中，轴的工作方式与numpy.arrays 中的相同：axis=0 将为每列应用sum() 或任何其他缩减函数。

注意在@zhangxaochen 的回答中，我发现“沿行”和“沿列”这两个短语有点令人困惑。 axis=0 应指“沿每一列”，axis=1 应指“沿每一行”。

Answer 5

对我来说最容易理解的方法是谈论您是在计算每列 (axis = 0) 还是每一行 (axis = 1) 的统计数据。如果您使用axis = 0 计算统计数据，比如平均值，您将获得每列的统计数据。因此，如果每个观察值是一行并且每个变量都在一列中，那么您将获得每个变量的平均值。如果您设置axis = 1，那么您将计算每一行的统计数据。在我们的示例中，您将获得所有变量的每个观察值的平均值（也许您想要相关测量值的平均值）。

axis = 0: by column = column-wise = 沿行

axis = 1: 按行 = 按行 = 沿列

Answer 6

让我们看一下 Wiki 中的表格。这是国际货币基金组织对 2010 年至 2019 年前十名国家的 GDP 的估计。

1.轴 1 将作用于所有列上的每一行
如果您想计算十年（2010-2019 年）每个国家/地区的平均（平均）GDP，您需要这样做，df.mean(axis=1)。例如，如果要计算美国 2010 年到 2019 年的平均 GDP，df.loc['United States','2010':'2019'].mean(axis=1)

2。轴 0 将作用于所有行上的每一列
如果我想计算所有国家/地区每一年的平均（平均）GDP，您需要这样做，df.mean(axis=0)。例如，如果您想计算美国、中国、日本、德国和印度 2015 年的平均 GDP，df.loc['United States':'India','2015'].mean(axis=0)

注意：上述代码只有在使用set_index方法将“国家（或附属领土）”列设置为索引后才能工作。

Answer 7

从编程的角度来看，轴是形状元组中的位置。这是一个例子：

import numpy as np

a=np.arange(120).reshape(2,3,4,5)

a.shape
Out[3]: (2, 3, 4, 5)

np.sum(a,axis=0).shape
Out[4]: (3, 4, 5)

np.sum(a,axis=1).shape
Out[5]: (2, 4, 5)

np.sum(a,axis=2).shape
Out[6]: (2, 3, 5)

np.sum(a,axis=3).shape
Out[7]: (2, 3, 4)

轴上的平均值将导致该维度被删除。

参考原题，dff形状为(1,2)。使用 axis=1 会将形状更改为 (1,)。

Answer 8

pandas 的设计师 Wes McKinney 曾经专注于财务数据方面的工作。将列视为股票名称，将索引视为每日价格。然后，您可以猜测此财务数据的默认行为是什么（即axis=0）。 axis=1 可以简单地认为是“另一个方向”。

例如，mean()、sum()、describe()、count() 等统计函数都默认为按列，因为对每只股票执行这些函数更有意义。 sort_index(by=) 也默认为列。 fillna(method='ffill') 将沿列填充，因为它是相同的库存。 dropna() 默认为 row 因为您可能只想丢弃当天的价格，而不是丢弃该股票的所有价格。

同样，方括号索引指的是列，因为选择股票而不是选择一天更为常见。

Answer 9

正确使用axis= 的问题在于它用于两种主要的不同情况：

1. 用于计算累加值，或重新排列（例如排序）数据。
2. 用于操纵（“玩”）实体（例如数据帧）。

这个答案背后的主要思想是，为了避免混淆，我们选择一个数字或一个名称来指定特定的轴，无论是更清晰、直观和描述性。

Pandas 基于 NumPy，它基于数学，特别是基于 n 维矩阵。这是 3 维空间中数学中常用轴名称的图像：

此图仅用于记忆轴序数：

• 0 x 轴，
• 1 用于 y 轴，并且
• 2 用于 z 轴。

z 轴 仅适用于面板；对于 dataframes，我们会将我们的兴趣限制在具有 x 轴（0，垂直）的绿色 2 维基本平面 , 和 y 轴（1，水平）。

这一切都是为了数字作为axis=参数的潜在值。

轴的名称是'index'（您可以使用别名'rows'）和'columns'，对于这个解释这些名称和它们之间的关系并不重要序数（轴），因为每个人都知道“rows”和“columns”这两个词是什么意思（以及每个人这里 — 我想 — 知道 pandas 中的 "index" 这个词是什么意思）。

现在，我的建议是：

1. 如果你想计算一个累加值，你可以从沿轴 0（或沿轴 1）的值计算它——使用axis=0（或axis=1）。

   同样，如果您想重新排列值，请使用轴的轴编号，沿轴编号是用于重新排列的数据（例如用于排序）。

2. 如果你想操作（例如连接）实体（例如数据框）——使用axis='index' （同义词：axis='rows'）或axis='columns' 指定产生的变化——索引（行）或列，分别。
   （对于连接，您将分别获得更长的索引（= 更多行）或更多列。）

Answer 10

记住轴 1（列）和轴 0（行）的简单方法之一是您期望的输出。

• 如果您希望使用axis='columns'的每一行都有输出，
• 另一方面，如果您希望使用axis='rows' 为每一列提供输出。

Answer 11

我曾经也对此感到困惑，但这就是我记得的方式。

它指定将要更改或将在其上执行操作的数据框的维度。

让我们通过一个例子来理解这一点。 我们有一个数据框df，它的形状为 (5, 10)，这意味着它有 5 行和 10 列。

现在当我们执行df.mean(axis=1) 时，这意味着维度 1 将被更改，这意味着它将具有相同的行数但不同的列数。因此，将得到的结果将是形状 (5, 1)。

类似地，如果我们这样做df.mean(axis=0)，则意味着维度 0 会发生变化，这意味着行数会发生变化，但列数会保持不变，因此结果将是 (1, 10) .

尝试将此与问题中提供的示例联系起来。

Answer 12

这是基于@Safak 的回答。 了解 pandas/numpy 中轴的最佳方法是创建一个 3d 数组并检查 sum 函数沿 3 个不同轴的结果。

 a = np.ones((3,5,7))

a 将是：

    array([[[1., 1., 1., 1., 1., 1., 1.],
    [1., 1., 1., 1., 1., 1., 1.],
    [1., 1., 1., 1., 1., 1., 1.],
    [1., 1., 1., 1., 1., 1., 1.],
    [1., 1., 1., 1., 1., 1., 1.]],

   [[1., 1., 1., 1., 1., 1., 1.],
    [1., 1., 1., 1., 1., 1., 1.],
    [1., 1., 1., 1., 1., 1., 1.],
    [1., 1., 1., 1., 1., 1., 1.],
    [1., 1., 1., 1., 1., 1., 1.]],

   [[1., 1., 1., 1., 1., 1., 1.],
    [1., 1., 1., 1., 1., 1., 1.],
    [1., 1., 1., 1., 1., 1., 1.],
    [1., 1., 1., 1., 1., 1., 1.],
    [1., 1., 1., 1., 1., 1., 1.]]])

现在检查沿每个轴的数组元素的总和：

 x0 = np.sum(a,axis=0)
 x1 = np.sum(a,axis=1)
 x2 = np.sum(a,axis=2)

会给你以下结果：

   x0 :
   array([[3., 3., 3., 3., 3., 3., 3.],
        [3., 3., 3., 3., 3., 3., 3.],
        [3., 3., 3., 3., 3., 3., 3.],
        [3., 3., 3., 3., 3., 3., 3.],
        [3., 3., 3., 3., 3., 3., 3.]])

   x1 : 
   array([[5., 5., 5., 5., 5., 5., 5.],
   [5., 5., 5., 5., 5., 5., 5.],
   [5., 5., 5., 5., 5., 5., 5.]])

  x2 :
   array([[7., 7., 7., 7., 7.],
        [7., 7., 7., 7., 7.],
        [7., 7., 7., 7., 7.]])

Answer 13

我是这样理解的：

假设您的操作需要在数据框中从 从左到右/从右到左 遍历，那么您显然是在合并列，即。您正在对各个列进行操作。 这是轴 =1

示例

df = pd.DataFrame(np.arange(12).reshape(3,4),columns=['A', 'B', 'C', 'D'])
print(df)
   A  B   C   D
0  0  1   2   3
1  4  5   6   7
2  8  9  10  11 

df.mean(axis=1)

0    1.5
1    5.5
2    9.5
dtype: float64

df.drop(['A','B'],axis=1,inplace=True)

    C   D
0   2   3
1   6   7
2  10  11

这里要注意的是我们是在列上操作

同样，如果您的操作需要在数据框中从从上到下/从下到上遍历，则您正在合并行。这是 axis=0。

Answer 14

在 Pandas 上有两种最常见的轴用法：

1. 用作索引，如df.iloc[0, 1]
2. 用作函数内部的参数，如df.mean(axis=1)

使用 as 索引时，我们可以理解为 axis=0 代表行，axis=1 代表列，即df.iloc[rows, columns]。所以，df.iloc[0, 1] 表示从第 0 行和第 1 列中选择数据，在这种情况下，它返回 1.52325。

使用 as 参数时，axis=0 表示垂直跨行选择对象，axis=1 表示水平跨列选择对象。

所以，df.mean(axis=1) 代表水平计算列的平均值，它返回：

0    1.074821
dtype: float64

axis 的通用用途是选择特定的数据进行操作。而理解轴的关键，是将“选择”和“操作”的过程分开。

让我们用1个额外的案例来解释它：df.drop('A', axis=1)

1. 操作是df.drop()，它需要预期的名称 列，在这种情况下为“A”。和df.mean()不一样 对数据内容进行操作。
2. 选择的是列的名称，而不是列的数据内容。由于所有列名都是横向跨列排列的，所以我们使用axis=1来选择名称对象。

简而言之，我们最好将“选择”和“操作”分开，以便清楚地了解：

1. 要选择什么对象
2. 怎么安排的

Answer 15

其实我们不需要硬记axis=0, axis=1代表什么。
有时，轴可以是一个元组：例如axis=(0,1)我们如何理解这样的多个暗轴？

我发现如果我们了解 python slice [:] 的工作原理，会更容易。

假设我们有一个一维数组： a = [ 0, 1, 0 ]

a[:] # select all the elements in array a

假设我们有一个二维数组：

M = [[0, 0, 1],
     [1, 0, 0],
     [0, 2, 1],
     [2, 0, 2],
     [3, 1, 0]]
M[1,:] # M[0]=1, M[1]=* --> [1, 0, 0]
M[:,2] # M[0]=*, M[1]=2 --> [1, 0, 1, 2, 0]
M[:,:] # M[0]=*, M[1]=* --> all the elements in M are selected

所以当计算时：

np.sum(M, axis=0) # [sum(M[:,0]), sum(M[:,1]), sum(M[:,2])]
np.sum(M, axis=1) # [sum(M[0,:]), sum(M[1,:]), sum(M[2,:]), sum(M[3,:]), sum(M[4,:])]
np.sum(M, axis=-1) # -1 means last dim, it's the same with np.sum(M, axis=1)
np.sum(M, axis=(0,1)) # sum(M[:,:])

规则很简单，计算时将axis中指定的dim替换为:。

Answer 16

我相信，正确的答案应该是“很复杂”

[1] “轴”这个词本身在不同的人身上会产生不同的心理形象
假设 y 轴，它应该会让人联想到垂直方向的图像。但是，现在想想垂直线x=0。它是平行于 y 轴的垂直线，但它由 x 轴上的一个值（定位器）寻址。
同样，当我们说axis='index'（意思是axis=0）时，我们说的是索引所在的“垂直”方向吗？还是由索引值处理的一系列数据？熊猫往往意味着第一个意思，垂直方向。

[2] Pandas 本身也不是 100% 一致的，观察以下情况，它们几乎有相同的共同主题：

pd.concat([df0, df1], axis='index') 
    # adding dfs on top of each other vertically like pilling up a column, 
    # but, we will use the word 'index'

df.apply(foo, axis='index')
df.mean('A', axis='index')
a_boolean_df.all(axis='index')
    # apply an operation to a vertical slice of data, ie. a column, 
    # then apply the same operation to the next column on the right 
    # then to the right again... until the last column
    # but, we will use the word 'index'

df.drop(axis='index', ...)
df.dropna(axis='index', ...)
    # this time, we are droping an index/row, a horizontal slice of data.
    # so OBVIOUSLY we will use the word 'index'

df.drop_duplicates(subset=...)
    # thank God we don't need to deal with the "axis" bs in this

Answer 17

axis = 0 表示从上到下 axis = 1 表示从左到右

sums[key] = lang_sets[key].iloc[:,1:].sum(axis=0)

给出的例子是对列 == 键中的所有数据求和。

Answer 18

我的想法：Axis = n，其中 n = 0、1 等表示矩阵沿该轴折叠（折叠）。因此，在二维矩阵中，当您沿 0（行）折叠时，您实际上是一次操作一列。对于高阶矩阵也是如此。

这与对矩阵中维度的正常引用不同，其中 0 -> 行和 1 -> 列。对于 N 维数组中的其他维度也是如此。

Answer 19

我将明确避免使用“按行”或“沿列”，因为人们可能会以完全错误的方式解释它们。

先类比。直观地说，您会期望 pandas.DataFrame.drop(axis='column') 从 N 列中删除一列并为您提供 (N - 1) 列。因此，您现在可以不关注行（并从您的英语词典中删除单词“行”。）反之亦然，drop(axis='row') 适用于行。

以同样的方式，sum(axis='column') 适用于多列并为您提供 1 列。同样，sum(axis='row') 产生 1 行。这与其最简单的定义形式一致，将数字列表减少为单个数字。

一般来说，使用axis=column，您可以查看列、处理列并获取列。忘记行。

使用axis=row，改变视角并处理行。

0 和 1 只是“行”和“列”的别名。这是矩阵索引的约定。

Answer 20

axis=1 ，它将给出总和行，keepdims=True 将保持二维维度。 希望对你有帮助。

Answer 21

例如，如果您使用 df.shape，那么您将获得一个元组，其中包含数据框中的行数和列数作为输出。

In [10]: movies_df.shape
Out[10]: (1000, 11)

在上面的示例中，电影数据帧中有 1000 行和 11 列，其中在索引 0 位置中提到了“行”，在元组的索引 1 位置中提到了“列”。因此，'axis=1' 表示列，'axis=0' 表示行。

致谢：Github

Answer 22

我是熊猫的新手。但这就是我对熊猫轴的理解：

---

轴 恒定 可变 方向

---

0 列向下行 |

---

1 行列向右-->

---

所以要计算一列的平均值，该特定列应该是constant，但其下的行可以改变(variing)，因此它是axis=0。

类似地，要计算一行的平均值，该特定行是常量，但它可以遍历不同的列（可变），axis=1。

Answer 23

我认为还有另一种理解方式。

对于 np.array，如果我们想消除列，我们使用 axis = 1;如果我们想消除行，我们使用axis = 0。

np.mean(np.array(np.ones(shape=(3,5,10))),axis = 0).shape # (5,10)
np.mean(np.array(np.ones(shape=(3,5,10))),axis = 1).shape # (3,10)
np.mean(np.array(np.ones(shape=(3,5,10))),axis = (0,1)).shape # (10,)

对于 pandas 对象，axis = 0 代表按行操作，axis = 1 代表按列操作。这与numpy的定义不同，我们可以查看numpy.doc和pandas.doc的定义

Answer 24

在过去的一个小时里，我也一直在尝试找出轴。以上所有答案中的语言以及文档都没有帮助。

按照我现在的理解来回答这个问题，在 Pandas 中，axis = 1 或 0 表示在应用函数时您希望保持哪个 axis headers 不变。

注意：当我说标题时，我指的是索引名称

扩展你的例子：

+------------+---------+--------+
|            |  A      |  B     |
+------------+---------+---------
|      X     | 0.626386| 1.52325|
+------------+---------+--------+
|      Y     | 0.626386| 1.52325|
+------------+---------+--------+

对于 axis=1=columns ：我们保持列标题不变，并通过更改数据应用均值函数。 为了演示，我们保持列标题不变：

+------------+---------+--------+
|            |  A      |  B     |

现在我们填充一组 A 和 B 值，然后找到平均值

|            | 0.626386| 1.52325|  

然后我们填充下一组 A 和 B 值并找到平均值

|            | 0.626386| 1.52325|

同样，对于axis=rows，我们保持行标题不变，并不断更改数据： 为了演示，首先修复行标题：

+------------+
|      X     |
+------------+
|      Y     |
+------------+

现在填充第一组 X 和 Y 值，然后找到平均值

+------------+---------+
|      X     | 0.626386
+------------+---------+
|      Y     | 0.626386
+------------+---------+

然后填充下一组 X 和 Y 值，然后找到平均值：

+------------+---------+
|      X     | 1.52325 |
+------------+---------+
|      Y     | 1.52325 |
+------------+---------+

总之，

当 axis=columns 时，您固定列标题并更改数据，这些数据将来自不同的行。

当axis=rows 时，您固定行标题并更改数据，这些数据将来自不同的列。

Answer 25

这里的许多答案对我帮助很大！

如果您对 Python 中的 axis 和 R 中的 MARGIN 的不同行为感到困惑（例如在 apply 函数中），您可能会发现我写的一篇博文：https://accio.github.io/programming/2020/05/19/numpy-pandas-axis.html。

本质上：

• 有趣的是，使用 3 维数组比使用二维数组更容易理解它们的行为。
• 在 Python 包numpy 和pandas 中，sum 中的axis 参数实际上指定numpy 以数组[0, 0, ..., i, . .., 0] 其中 i 遍历所有可能的值。在 i 的位置固定的情况下重复该过程，并且其他维度的索引一个接一个地变化（从最右边的元素开始）。结果是一个 n-1 维数组。
• 在 R 中，MARGINS 参数让 apply 函数计算可以以 array[, ... , i, ... ,] 形式获取的所有值的平均值，其中 i 迭代所有可能的值.当所有 i 值都已迭代时，该过程不会重复。因此，结果是一个简单的向量。

Answer 26

数组被设计成所谓的轴=0，行垂直放置，轴=1，列水平放置。轴是指数组的维度。