问题描述：

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

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

那么 Pandas 中的 axis 是什么意思呢？

解决方案 1：

它指定计算平均值的轴。默认情况下为。这与明确指定时的用法axis=0一致（在中，默认情况下 axis==None，计算展平数组的平均值），其中沿行（即pandas 中的索引）和沿列。为了更加清晰，可以选择指定（而不是）或（而不是）。numpy.mean`axisnumpy.meanaxis=0axis=1axis='index'axis=0axis='columns'`axis=1

          A        B
0  0.626386  1.52325  → → axis=1 → →
          ↓        ↓
          ↓ axis=0 ↓
          ↓        ↓

解决方案 2：

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

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

• 轴 0 将作用于每个列中的所有行

• 轴 1 将作用于每行​​的所有列

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

归根结底，这与@zhangxaochen 和@Michael 所说的是相同的，但对我来说更容易内化。

解决方案 3：

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

在 Pandas 中：

1. axis=0 表示沿“索引”方向。这是按行进行的操作。

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

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

例如在桌子或地板上堆放书籍

1. axis=1 表示沿着“列”。这是按列进行的操作。

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

例如，在书架上整理书籍。

更重要的是，与矩阵相比，数组是更好的表示嵌套 n 维结构的表示方法！因此，下面的内容可以帮助您更好地直观地了解轴在推广到多维时如何发挥重要作用。此外，您实际上可以打印/编写/绘制/可视化任何 n 维数组，但在 3 维以上的纸上以矩阵表示（3 维）形式编写或可视化相同的数组是不可能的。

解决方案 4：

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

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

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

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

a.sum(axis=0)`sum()将沿 的第 0 轴应用a。您将添加所有切片，最终得到一个形状为 的切片(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.]])

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

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

解决方案 5：

我们来看看维基百科上的表格，这是 IMF 对 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。

解决方案 6：

对我来说，最简单的理解方式是讨论您是否在为每列（axis = 0）或每行（axis = 1）计算统计数据。如果您计算统计数据，比如平均值，axis = 0您将获得每列的统计数据。因此，如果每个观察值是一行，每个变量都在一列中，那么您将获得每个变量的平均值。如果您设置，axis = 1那么您将计算每行的统计数据。在我们的示例中，您将获得所有变量的每个观察值的平均值（也许您想要相关度量的平均值）。

axis = 0：按列 = 按照列方向 = 沿着行

axis = 1：按行 = 按行排列 = 沿列排列

解决方案 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,)。

解决方案 8：

pandas 的设计者 Wes McKinney 曾经深入研究过金融数据。将列视为股票名称，将指数视为每日价格。然后，您可以猜测axis=0针对这些金融数据的默认行为是什么（即）。axis=1可以简单地认为是“另一个方向”。

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

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

解决方案 9：

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

1. 用于计算累积值，或重新排列（例如排序）数据。

2. 用于操纵（“玩”）实体（例如数据框）。

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

Pandas 基于 NumPy，而 NumPy 又基于数学，特别是 n 维矩阵。下面是三维空间中数学中轴名称的常见用法图：

此图仅用于记忆轴的序数：

• 0对于 x 轴，

• 1对于 y 轴，以及

• 2对于 z 轴。

z 轴仅适用于面板；对于数据框，我们将兴趣限制在具有x 轴（，垂直）和y 轴（ ，水平）的绿色二维基本平面。01

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

轴的名称是（您可以使用别名）和，并且对于这个解释，这些名称和序数（轴）之间的关系并不重要，因为每个人都知道“行”和“列”这两个词的意思（并且这里的每个人 - 我想 - 都知道熊猫中“索引”这个词的意思）。'index'`'rows'`'columns'

现在，我的建议是：

1. 如果您想要计算累积值，您可以根据位于轴 0（或轴 1 ）上的值来计算——使用axis=0(或axis=1)。

类似地，如果要重新排列值，请使用数据所在的轴的轴号进行重新排列（例如，排序）。

1. 如果您想要操作（例如连接）实体（例如数据框） — 使用axis='index'（同义词axis='rows'：）或axis='columns'指定结果更改—分别使用索引（行）或列。

（对于连接，您将分别获得更长的索引（=更多行）或更多的列。）

解决方案 10：

我以前也对此感到困惑，但我记得是这样。

它指定将要改变的数据框的维度或将要执行操作的数据框的维度。

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

现在，当我们df.mean(axis=1)这样做时，意味着维度 1 会发生变化，这意味着它将具有相同数量的行，但列数不同。因此，得到的结果将是形状 (5, 1)。

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

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

解决方案 11：

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

• 如果您希望每行都有一个输出，则使用 axis='columns'，

• 另一方面，如果您想要每列的输出，则可以使用 axis='rows'。

解决方案 12：

要记住的重要一点是，当您使用诸如平均值、中位数等函数时，您基本上是在进行numpy 聚合。将聚合视为获取最终的单一输出，可以是列、行或整个数据集的单个数字。

因此，当我们说数组中的聚合时，numpy.sum(data, axis = 0)我们真正的意思是我们想要删除那个特定的轴（这里是 0 轴）。

示例：对于此特定数据集，如果我们按轴 = 0 计算总和，我们实际上想要删除（聚合）零轴。一旦我们删除零轴，沿零轴的聚合将导致 [1,4,3] 等于 8，[2,3,6] 等于 11，[5,7,9] 等于 21。类似的逻辑可以扩展到轴 = 1。

对于 drop、concat 和其他一些函数，我们实际上并没有聚合结果。

我用来直觉的心理模型：

想象一下，当轴 = 0 时，我们在第一列的每个单元格中放置了一只袋鼠/青蛙；如果轴 = 1 时，则在第一行的每个单元格中放置了一只袋鼠/青蛙。

情况：当轴 = 零时

将绿色形状想象成一只青蛙。

轴零表示沿行移动

总和：假设我们正在计算总和，那么首先他们将计算其位置的总和 (r1c1, r2c1, r3c1) [1,4,3] = [8]。然后他们的下一步移动也将沿着行移动，因为轴 = 0。他们的新位置在下一张图片中（下图）。

删除：如果在行中遇到 (r1c1, r2c1, r3c1) 中的任何 NaN，则它们将删除相应的行，因为轴 = 0

总和：现在，它们将再次计算其位置 (r1c2, r2c2, r3c2) 的总和 [2,3,6] = [11]，同样，它们将沿着行向前移动一步并计算第三列的总和 [21]。

删除：如果在行中它们遇到（r1c2、r2c2、r3c2）中的任何 NaN，它们将删除相应的行，因为轴 = 0。类似的逻辑可以扩展到不同的轴和额外的行/列。

解决方案 13：

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

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

将是：

    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.]])

解决方案 14：

我认为，正确答案应该是“这很复杂”

[1] “轴”一词本身在不同人心中会形成不同的形象，

比如 y 轴，它应该让人联想到垂直的东西。但是，现在想想一条垂直线x=0。它也是垂直线，但它是由x 轴上的值表示的。0

类似地，当我们说axis='index'（意思是）时，我们是在说索引所在的“垂直”方向吗？还是说索引值所指向axis=0的一系列数据？Panda 倾向于指第一个意思，即垂直方向。

[2] Pandas 本身也并非 100% 一致，观察以下案例，它们几乎具有相同的共同主题：

# [1] piling dfs
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'

# [2] for every column in df: operate on it
df.apply(foo, axis='index')     # apply func foo to one column at a time
df.mean('A', axis='index')      # apply "mean()" to one column at a time
a_boolean_df.all(axis='index')  # check if each column contains only bool "True"
    # 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'

# [3] delete a column or row of data
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'

# [4] when you iterate thru a df naturally, what would show up first? a row or a column?
for x in df:
    # x == a column's name

# [5] drop duplicate
df.drop_duplicates(subset=['mycolumn0', 'mycolumn1']...)
    # thank God we don't need to deal with the "axis" bs in this

解决方案 15：

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。

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

因此，df.mean(axis=1)代表计算水平列的平均值，并返回：

0    1.074821
dtype: float64

轴的一般用途是用来选取特定的数据进行运算。而理解轴的关键，在于把“选取”与“运算”的过程分开。

我们用另外1个案例来解释一下：df.drop('A', axis=1)

1. 该操作是，它需要目标列的名称，在本例中为“A”。它与
   对数据内容的操作df.drop()不同。df.mean()

2. 选取的是列名，而不是列的数据内容。由于所有列名都是水平排列在列上的，所以我们用axis=1选取名称对象的方式。

总之，我们最好把“选择”和“操作”分开，这样才能清楚地了解：

1. 选择什么对象

2. 如何安排

解决方案 16：

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

据我所知，回答这个问题的方法是，在 Pandas 中，axis = 1 或 0 表示在应用函数时要保持哪些轴标题不变。

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

扩展你的例子：

+------------+---------+--------+
|            |  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 时，您可以修复行标题并更改来自不同列的数据。

解决方案 17：

axis=1，它将按行给出总和，keepdims=True 将保持 2D 维度。希望这对您有所帮助。

解决方案 18：

其实我们不需要费力去记住axis=0, axis=1代表什么，

因为有时候 axis 可以是一个元组：例如axis=(0,1)我们该如何理解这种多重 dim axis？

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

假设我们有一个一维数组：
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[:,:])

规则很简单，在计算时替换axisas中指定的 dims。:

解决方案 19：

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

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

给出的例子是取列 == key 中所有数据的总和。

解决方案 20：

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

这与矩阵中维度的正常引用不同，矩阵中 0 -> 行，1 -> 列。N 维数组中的其他维度也类似。

解决方案 21：

我是 Pandas 的新手。但我对 Pandas 中的 axis 的理解如下：

轴 恒定 变化 方向

0 列 行 向下 |

1 行 列向右 -->

因此，要计算某一列的平均值，该特定列应该是恒定的，但其下的行可以改变（变化），因此轴 = 0。

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

解决方案 22：

我的理解是这样的：

假设您的操作需要在数据框中从左到右/从右到左遍历，那么您显然是在合并列，即您正在对各个列进行操作。这是axis =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。

解决方案 23：

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

首先进行类比。直观地讲，你会期望pandas.DataFrame.drop(axis='column')从 N 列中删除一列并返回 (N - 1) 列。因此，你现在无需关注行（并从你的英语词典中删除单词“row”）。反之亦然，drop(axis='row')对行进行操作。

以同样的方式，sum(axis='column')对多列进行操作并返回 1 列。类似地，sum(axis='row')结果为 1 行。这与其最简单的定义形式一致，即将数字列表缩减为单个数字。

通常，使用axis=column，您可以查看列、处理列并获取列。忘记行。

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

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

解决方案 24：

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

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

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

来源：Github

解决方案 25：

现有的很多答案都使用了令人困惑的图形，或者对“为什么”的问题进行了过深的探讨。我希望提供一个更简单的答案。

总结

我认为，pandas 用户最好始终参考文档，了解每个方法的轴值有何作用。我们可以理解参数值的含义（即axis=0或axis=1），但最终轴的实现方式可能并不直观。

理解框架

直接上下文是 pandas。那么 pandas 对其 axis 参数有何说明？它是关于利用某种类型的标签的方法。在 pandas 中，有索引和列标签。

以下“轴{}对应{}标签。”

axis=0→索引标签

axis=1→列标签

注意：这就是为什么，例如，一个pd.Series对象没有可用的选项axis=1（它是唯一的“列”）。换句话说，一个pd.Series对象只有索引标签。

举pandas.DataFrame.mean个例子：

axis{index (0), columns (1)}
Axis for the function to be applied on. For Series this parameter is unused and defaults to 0.

For DataFrames, specifying axis=None will apply the aggregation across both axes.

聚合方法与非聚合方法

聚合方法pd.DataFrame.mean和非聚合方法使用相同的axis值映射，但结果可能会引起用户的困惑。

示例

例子pd.DataFrame

df = pd.DataFrame({
    'A': [1, 2, 3, 4],
    'B': [None, 5, 6, 7],
    'C': [8, 9, 10, None],
    'D': [12, 13, None, 15]
})

Original DataFrame:
   A    B     C     D
0  1  NaN   8.0  12.0
1  2  5.0   9.0  13.0
2  3  6.0  10.0   NaN
3  4  7.0   NaN  15.0

聚合：pd.DataFrame.any

axis=0→ 索引标签 → 生成一个 pd.Series，其中索引标签现在是列标签，其对应值是其对应的行是否包含 NaN 值。

axis=1→ 列标签 → 生成一个 pd.Series，其中索引标签保留，但其对应值是其对应的列标签是否包含 NaN 值。

df.isna().any(axis=0):
A     True
B     True
C     True
D     True
dtype: bool

df.isna().any(axis=1):
0     True
1    False
2     True
3     True
dtype: bool

非聚合：pd.DataFrame.dropna

axis=0→ 索引标签 → 如果任何对应的列标签包含 NaN 值，则按索引标签删除

axis=1→ 列标签 → 如果任何对应的索引标签包含 NaN 值，则按列标签删除

pd.DataFrame.dropna(axis=0):
   A    B    C     D
1  2  5.0  9.0  13.0

pd.DataFrame.dropna(axis=1):
   A
0  1
1  2
2  3
3  4

参考

• pd.DataFrame.mean

• pd.DataFrame.dropna

• pd.DataFrame.any

解决方案 26：

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

对于 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中查看定义

解决方案 27：

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

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

实质上：

• 有趣的是，使用三维数组比使用二维数组更容易理解它们的行为。

• 在 Python 包numpy和pandas中，sum 中的 axis 参数实际上指定 numpy 计算可以以 array[0, 0, ..., i, ..., 0] 形式获取的所有值的平均值，其中 i 遍历所有可能的值。该过程重复进行，i 的位置固定，其他维度的索引依次变化（从最右边的元素开始）。结果是一个 n-1 维数组。

• 在 R 中，MARGINS 参数让apply函数计算可以以数组 [, ... , i, ... ,] 的形式获取的所有值的平均值，其中 i 迭代所有可能的值。迭代完所有 i 值后，不再重复该过程。因此，结果是一个简单的向量。

解决方案 28：

以@jerry_sjtu 为例：

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

Pandas 文档可能解决了下面一半的问题（它对每列的行进行平均值计算）：

axis{0 or ‘index’, 1 or ‘columns’}, default 0
    Axis along which the function is applied:
        0 or ‘index’: apply function to each column.
        1 or ‘columns’: apply function to each row.

dff.mean(axis='index')将给出预期的答案（它沿行计算平均值- 只有一行，因此平均值与行值相同）。值得注意的是，Pandas 还给出了列标签，从而减少了歧义：

A    0.626386
B    1.523255
dtype: float64

然而，dff.mean(axis='column')将给出（它正在沿列计算平均值- 有两列，因此计算平均值：0.62.. + 1.75..=/2 => 1.07..）。值得注意的是，Pandas 还给出了索引标签，即 "0"，减少了歧义：

0    1.074821
dtype: float64

要点：也许使用英语，即 axis='column', 'column' 而不是 '1' 会使其不那么令人困惑 - 并将其表述为 ...值沿着 <指定标签，例如列>！其他是参考手册页。可以通过检查结果中是否有列或索引名称来验证操作。

https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.apply.html

解决方案 29：

即使读了大家在这里的精彩意见，我仍然感到困惑。然后我意识到，许多接受 axis 关键字的不同 pandas 函数都会导致两种类型的返回输出之一 - 1D 系列或 2D 数据框。然后我想出了自己的两步查看方法（如下）。

1. Pandas 函数的组名称

A 组 pandas 函数：
A 组（返回 1D 系列的函数）。表示对折叠数据执行函数。此组的图例（下图）是根据要执行函数的方向箭头选择的。

mathematical operations: .sum(), .mean(), .min(), etc.
.apply()
.any()

B 组 pandas 函数：
B 组（返回 2D 数据帧的函数）。指示在哪个索引上执行函数。此组的图例（下图）是根据“轴标签”选择的，即要执行函数的索引标签。

.dropna()
.drop()
.concat()
.rename_axis()
.set_axis()
.reindex()

1. 行轴和列轴的图例：

如何使用：示例 1：目标：在数据框内按特定方向求和。对于此示例：向上/向下：

从上面的列表中获取 .sum() 函数所在的组号（组 A）。组 A 函数沿轴方向箭头运行。因此，请参阅带有向上/向下方向箭头的图例并使用相应的轴号：df.sum(axis=0)

示例 #2：目标：删除数据框中含有 NaN 的行：

从上面的列表中获取 .dropna() 函数所在的组号（组 B）。组 B 函数对轴标签进行操作。因此，请参阅轴标签 = 行的图例，并使用相应的轴号：df.dropna(axis=0)

注意到其中一个示例是按列工作而另一个是按行工作，但它们都使用相同的轴号吗？如果根据函数类型的输出类型对其进行分类，您将开始看到轴要么采用“遍历”方法，要么采用索引方法工作 - 这种区别似乎是本主题混淆的根源。