这是我生成数据框的代码：
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
根据熊猫的参考，axis = 1代表列，我希望命令的结果是
A 0.626386
B 1.523255
dtype: float64
所以这是我的问题：熊猫中的轴是什么意思？
它指定沿其计算均值的轴。默认情况下 axis=0。这与 明确 指定 axis 时的 numpy.mean 用法一致（在 numpy.mean 中，默认情况下，axis==None，它计算扁平数组上的平均值），其中 { 1} 沿着 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 |
↓ ↓
这些答案确实有助于解释这一点，但对于非程序员（即像我这样第一次在数据科学课程背景下学习 Python 的人）来说，它仍然不是很直观。我仍然发现对行和列使用术语“沿”或“每个”会令人困惑。
对我来说更有意义的是这样说：
轴 0 将作用于每列中的所有行
轴 1 将作用于每一行中的所有列
因此，轴 0 上的平均值将是每列中所有行的平均值，轴 1 上的平均值将是每行中所有列的平均值。
归根结底，这与@zhangxaochen 和@Michael 的说法相同，但以一种更容易让我内化的方式。
https://i.stack.imgur.com/FzimB.png
在熊猫中：
axis=0 表示沿“索引”。这是一个逐行操作。
假设要对dataframe1和dataframe2执行concat()操作，我们将从dataframe1中取出第一行并放入新的DF中，然后从dataframe1中取出另一行放入新的DF中，重复此过程直到我们到达dataframe1的底部。然后，我们对 dataframe2 执行相同的过程。
基本上，将 dataframe2 堆叠在 dataframe1 之上，反之亦然。
例如在桌子或地板上制作一堆书
axis=1 表示沿“列”。这是一个按列操作。
假设要对dataframe1和dataframe2执行concat()操作，我们将取出dataframe1的第一个完整列（又名第1系列）并放入新的DF中，然后我们取出dataframe1的第二列并保持相邻（横向)，我们必须重复这个操作，直到所有列都完成。然后，我们在 dataframe2 上重复相同的过程。基本上，横向堆叠dataframe2。
例如在书架上排列书籍。
更重要的是，与矩阵相比，数组是表示嵌套 n 维结构的更好表示！所以下面可以帮助您更多地了解当您推广到多个维度时轴如何发挥重要作用。此外，您实际上可以打印/写入/绘制/可视化任何 n-dim 数组，但是在超过 3 维的纸上以矩阵表示（3-dim）写入或可视化相同的数组是不可能的。
https://i.stack.imgur.com/waS00.jpg
axis='index'/'columns' 而不是 axis=0/1 可能更有意义。 axis='index' 表示您正在沿索引垂直向下移动。 axis='columns' 表示您正在沿列水平向右移动。透视你的书架可视化是违反直觉的。
axis 是指数组的维度，在 pd.DataFrame 的情况下，axis=0 是指向下方的维度，axis=1 是指向右侧的维度。
示例：想象一个形状为 (3,5,7) 的 ndarray。
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() 或任何其他缩减函数。
NB 在@zhangxaochen 的回答中，我发现“沿行”和“沿列”这两个短语有点令人困惑。 axis=0 应指“沿每一列”，axis=1 应指“沿每一行”。
对我来说最容易理解的方法是谈论您是在计算每列 (axis = 0) 还是每一行 (axis = 1) 的统计数据。如果您计算一个统计数据，比如说一个平均值，使用 axis = 0 您将获得每列的统计数据。因此，如果每个观察值是一行并且每个变量都在一列中，那么您将获得每个变量的平均值。如果您设置 axis = 1，那么您将计算每一行的统计数据。在我们的示例中，您将获得所有变量的每个观察值的平均值（也许您想要相关测量值的平均值）。
axis = 0：按列 = 按列 = 沿行
axis = 1：按行 = 按行 = 沿列
axis=0 我们不会停留在说行上，例如，计算平均值；而是我们遍历列中的所有行。
https://i.stack.imgur.com/BoPJR.png
<强> 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 方法将“国家（或附属领土）”列设置为索引后。
从编程的角度来看，轴是形状元组中的位置。这是一个例子：
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,)。
pandas 的设计者 Wes McKinney 曾经专注于金融数据。将列视为股票名称，将索引视为每日价格。然后，您可以猜测该财务数据的默认行为（即axis=0）是什么。 axis=1 可以简单地认为是“另一个方向”。
例如，统计函数，如 mean()、sum()、describe()、count() 都默认为按列，因为对每只股票执行这些函数更有意义。 sort_index(by=) 也默认为列。 fillna(method='ffill') 将沿列填充，因为它是相同的股票。 dropna() 默认为 row，因为您可能只想丢弃当天的价格，而不是丢弃该股票的所有价格。
同样，方括号索引指的是列，因为选择股票而不是选择一天更为常见。
正确使用 axis= 的问题在于它用于两种主要的不同情况：
用于计算累积值或重新排列（例如排序）数据。用于操作（“玩”）实体（例如数据框）。
这个答案背后的主要思想是，为了避免混淆，我们选择一个数字或一个名称来指定特定的轴，以更清晰、直观和描述性为准。
Pandas 基于 NumPy，它基于数学，特别是基于 n 维矩阵。这是 3 维空间中数学中常用轴名称的图像：
https://i.stack.imgur.com/TtPst.png
0 表示 x 轴，
1 表示 y 轴，并且
为 z 轴。
z 轴 仅适用于面板；对于 dataframes，我们将把兴趣限制在具有 x 轴（0，垂直）的绿色 2 维基本平面 , 和 y 轴（1，水平）。
https://i.stack.imgur.com/9TOQv.png
轴的名称是 'index'（您可以使用别名 'rows'）和 'columns'，对于这个解释这些名称和序数之间的关系并不重要< /em>（轴），因为每个人都知道 “rows” 和 “columns” 这两个词是什么意思（以及每个人 here - 我想— 知道 pandas 中的单词 "index" 是什么意思）。
现在，我的建议：
如果要计算累积值，可以从位于轴 0（或沿轴 1）的值计算它——使用轴 = 0（或轴 = 1）。同样，如果您想重新排列值，请使用轴的轴号，沿着该轴号定位数据进行重新排列（例如，用于排序）。如果您想操作（例如连接）实体（例如数据框）——使用axis='index'（同义词：axis='rows'）或axis='columns'来指定产生的变化——分别是索引（行）或列. （对于连接，您将分别获得更长的索引（= 更多行）或更多列。）
记住轴 1（列）和轴 0（行）的简单方法之一是您期望的输出。
如果您希望使用axis ='columns'的每一行都有输出，
另一方面，如果您想要为每一列使用axis ='rows'的输出。
pd.concat 或 df.dropna() 之类的方法，它们在更多的识别能力中使用了 kewarg 轴。
我曾经也对此感到困惑，但这就是我记得的方式。
它指定将更改或将在其上执行操作的数据框的维度。
让我们通过一个例子来理解这一点。我们有一个数据框 df，它的形状为 (5, 10)，这意味着它有 5 行和 10 列。
现在，当我们执行 df.mean(axis=1) 时，这意味着维度 1 将被更改，这意味着它将具有相同的行数但不同的列数。因此，将得到的结果将是形状 (5, 1)。
类似地，如果我们执行 df.mean(axis=0)，则表示维度 0 会发生变化，即行数会发生变化，但列数会保持不变，因此结果的形状为 (1, 10)。
尝试将此与问题中提供的示例联系起来。
这是基于@Safak 的回答。理解 pandas/numpy 中轴的最佳方法是创建一个 3d 数组并检查 sum 函数沿 3 个不同轴的结果。
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.]])
我相信，正确的答案应该是“它很复杂”
[1] 术语“轴”本身在不同的人中会让人联想到不同的心理形象
让我们说 y 轴，它应该会让人联想到垂直事物的形象。但是，现在考虑一条垂直线 x=0。它是平行于 y 轴的垂直线，但它由 x 轴上的值 0（定位器）寻址。
类似地，当我们说 axis='index' (意思是axis=0），我们是说索引所在的“垂直”方向吗？还是由索引值处理的一系列数据？熊猫往往意味着第一个含义，垂直方向。
[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')
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'
# [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] drop duplicate
df.drop_duplicates(subset=['mycolumn0', 'mycolumn1']...)
# thank God we don't need to deal with the "axis" bs in this
https://i.stack.imgur.com/Sutro.png
https://i.stack.imgur.com/YZwVI.png
axis=1 ，它将给出总和行，keepdims=True 将保持二维维度。希望它可以帮助你。
df.apply(np.sum, axis=1) 将具有与 numpy 操作相同的效果。 “逐行”求和，但我们使用 axis=1 或等效的 axis="columns"。即，axis=1 kwarg 表示“跨列”，并不表示“沿列”。
在 Pandas 上，axis 有两种最常见的用法：
用作索引，例如 df.iloc[0, 1] 用作函数内部的参数，例如 df.mean(axis=1)
在用作索引时，我们可以理解为axis=0代表行，axis=1代表列，即df.iloc[rows, columns]。因此，df.iloc[0, 1] 表示从第 0 行和第 1 列中选择数据，在这种情况下，它返回 1.52325。
用作参数时，axis=0 表示垂直跨行选择对象，axis=1 表示水平跨列选择对象。
https://i.stack.imgur.com/4pFuZ.png
因此，df.mean(axis=1) 代表水平计算列的平均值，它返回：
0 1.074821
dtype: float64
轴的通用用途用于选择要操作的特定数据。而理解轴的关键，是将“选择”和“操作”的过程分开。
让我们用 1 个额外的案例来解释它：df.drop('A', axis=1)
该操作是 df.drop()，它需要预期列的名称，在本例中为“A”。它与对数据内容进行操作的 df.mean() 不同。选择的是列的名称，而不是列的数据内容。由于所有列名都是横向跨列排列的，所以我们使用axis=1来选择名称对象。
总之，我们最好将“选择”和“操作”分开，以便清楚地了解：
选择什么对象 它是如何排列的
实际上，我们不需要很难记住 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 中指定的 dims 替换为 :。
axis = 0 表示从上到下 axis = 1 表示从左到右
sums[key] = lang_sets[key].iloc[:,1:].sum(axis=0)
给定的示例是对列 == 键中的所有数据求和。
我的想法：Axis = n，其中 n = 0、1 等表示矩阵沿该轴折叠（折叠）。因此，在 2D 矩阵中，当您沿 0（行）折叠时，您实际上是一次操作一列。对于高阶矩阵也是如此。
这与对矩阵中维度的正常引用不同，其中 0 -> 行和 1 -> 列。对于 N 维数组中的其他维度也是如此。
我是熊猫的新手。但这就是我对熊猫轴的理解：
轴恒定变化方向
列向下行 |
1 行列向右 -->
因此，要计算一列的平均值，该特定列应该是恒定的，但其下的行可以改变（变化），因此它是轴 = 0。
类似地，要计算一行的平均值，该特定行是恒定的，但它可以遍历不同的列（变化），axis = 1。
我这样理解：
假设您的操作需要在数据框中从左到右/从右到左遍历，那么您显然是在合并列，即。您正在对各个列进行操作。这是轴=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
这里要注意的是我们在列上操作
同样，如果您的操作需要在数据框中从上到下/从下到上遍历，则您正在合并行。这是轴= 0。
我将明确避免使用“按行”或“沿列”，因为人们可能会以完全错误的方式解释它们。
先类比。直观地说，您会期望 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 只是“行”和“列”的别名。这是矩阵索引的约定。
pd.concat 时，它并不完全奏效。你能解释一下 2 轴的 concat 行为吗？谢谢。
例如，如果您使用 df.shape ，那么您将获得一个包含数据框中行数和列数的元组作为输出。
In [10]: movies_df.shape
Out[10]: (1000, 11)
在上面的示例中，电影数据帧中有 1000 行和 11 列，其中在索引 0 位置中提到了“行”，在元组的索引 1 位置中提到了“列”。因此，“axis=1”表示列，“axis=0”表示行。
学分：Github
我认为还有另一种理解方式。
对于 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 的定义
在过去的一个小时里，我也一直在试图弄清楚轴。上述所有答案中的语言以及文档都没有帮助。
按照我现在的理解来回答这个问题，在 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 时，您修复行标题并更改数据，这些数据将来自不同的列。
这里的许多答案对我帮助很大！
如果您对 Python 中的 axis 和 R 中的 MARGIN（如 apply 函数）的不同行为感到困惑，您可能会发现我写的一篇感兴趣的博文：https://accio.github.io/programming/2020/05/19/numpy-pandas-axis.html。
在本质上：
有趣的是，使用 3 维数组比使用二维数组更容易理解它们的行为。
在 Python 包 numpy 和 pandas 中，sum 中的轴参数实际上指定 numpy 以数组 [0, 0, ..., i, ..., 0] 的形式计算所有可取值的平均值，其中 i遍历所有可能的值。在 i 的位置固定的情况下重复该过程，并且其他维度的索引一个接一个地变化（从最右边的元素开始）。结果是一个 n-1 维数组。
在 R 中，MARGINS 参数让 apply 函数计算可以以 array[, ... , i, ... ,] 形式获取的所有值的平均值，其中 i 迭代所有可能的值。当所有 i 值都已迭代时，该过程不会重复。因此，结果是一个简单的向量。
重要的是要记住，当您使用平均值、中位数等函数时，您基本上是在进行 numpy 聚合。将聚合视为获得最终的单个输出，它可以是按列、按行或整个数据集的单个数字。
所以当我们说数组中的聚合时，比如 numpy.sum(data, axis = 0)，我们真正的意思是我们想要删除那个特定的轴（这里是 0 轴）。
https://i.stack.imgur.com/Piqwc.png
示例：对于这个特定的数据集，如果我们按轴 = 0 计算总和，我们实际上对移除（聚合）零轴感兴趣。一旦我们移除零轴，沿零轴聚合将导致[1,4,3]等于8，[2,3,6]等于11，[5,7,9]等于21。类似的逻辑可以扩展到axis = 1。
在 drop、concat 和其他一些函数的情况下，我们实际上并没有汇总结果。
我用于直觉的心智模型：
假设当轴 = 0 时，我们在第一列的每个单元格中放置了一个袋鼠/青蛙，如果轴 = 1，则沿着第一行放置一个袋鼠/青蛙。
案例：当axis = 0时
https://i.stack.imgur.com/gCQEF.png
把加绿色的形状想象成一只青蛙。
零轴意味着沿行移动
总和：假设我们正在计算总和，那么首先他们将计算其位置的总和 (r1c1, r2c1, r3c1) [1,4,3] = [8]。然后他们的下一步行动也将沿着轴 = 0 的行。他们的新位置在下一张图片中（下图）。
Drop：如果在行中遇到 (r1c1, r2c1, r3c1) 中的任何 NaN，他们将删除对应的行，因为 axis = 0
https://i.stack.imgur.com/yIPGc.png
总和：现在，他们将再次计算其位置的总和 (r1c2, r2c2, r3c2) [2,3,6] = [11]，类似地，他们将沿行向前移动一步并计算第三列的总和[21]。
Drop：如果在行中遇到 (r1c2, r2c2, r3c2) 中的任何 NaN，他们将删除相应的行，因为轴 = 0。类似的逻辑可以扩展到不同的轴和其他行/列。
https://i.stack.imgur.com/N48EV.png
https://i.stack.imgur.com/YiAo9.png
axis=0 表示将每一行作为一个整体，我们只能操作 DataFrame 行间而不是内行。 axis=1 表示将每一列作为一个块，我们只能操作 DataFrame 列间而不是内列。
axis=0表示沿行聚合而axis=1表示沿列聚合的原因是因为您对数据帧的索引方式。在df.iloc[row, column]中，row位于索引位置 0，而column位于索引位置 1。Numpy 将其推广到 N 维，这是考虑聚合折叠的轴开始更有意义的地方比“逐行”或“逐列”。df.drop("A", axis = 1)，则 A column 将被删除。它不是“沿行”也不是“逐行”，而是删除 A 列。axis=0表示每一行都是一个整体，我们只能操作 DataFrame 行间而不是行内。axis=1表示将每一列作为一个块，我们只能操作 DataFrame 列间而不是内列。因此，如果您使用df.drop("A", axis = 1)，它将删除一整列。