什么是“轴”属性的熊猫数据帧的含义是什么？

Question

以下面的例子：

>>> df1 = pd.DataFrame({"x":[1, 2, 3, 4, 5], 
                        "y":[3, 4, 5, 6, 7]}, 
                      index=['a', 'b', 'c', 'd', 'e'])

>>> df2 = pd.DataFrame({"y":[1, 3, 5, 7, 9], 
                        "z":[9, 8, 7, 6, 5]}, 
                      index=['b', 'c', 'd', 'e', 'f'])

>>> pd.concat([df1, df2], join='inner')

输出是：

   y
a  3
b  4
c  5
d  6
e  7
b  1
c  3
d  5
e  7
f  9

由于qazxsw POI是列，我认为qazxsw POI仅考虑在两个dataframes发现列。但acutal输出认为，在两个dataframes发现行。

什么是axis=0参数的确切含义是什么？

Answer 1

如果有人需要的视觉描述，这里是图像：

concat()

Answer 2

数据：

axis

水平级联（轴= 1），使用在这两种发现的DF指引元件（由索引用于接合对齐）：

垂直级联（默认值：轴= 0），使用在这两种发现的DF列：

In [55]: df1
Out[55]:
   x  y
a  1  3
b  2  4
c  3  5
d  4  6
e  5  7

In [56]: df2
Out[56]:
   y  z
b  1  9
c  3  8
d  5  7
e  7  6
f  9  5

如果你不使用

In [57]: pd.concat([df1, df2], join='inner', axis=1)
Out[57]:
   x  y  y  z
b  2  4  1  9
c  3  5  3  8
d  4  6  5  7
e  5  7  7  6

join方法 - 你将不得不这样说：

In [58]: pd.concat([df1, df2], join='inner')
Out[58]:
   y
a  3
b  4
c  5
d  6
e  7
b  1
c  3
d  5
e  7
f  9

Answer 3

这是我的绝招与轴：刚才添加的操作在你的心中，使其音质清晰：

• 轴线0 =行
• 轴1 =列

如果“总和”通过轴= 0，则表示求和的所有行，并输出将是一个单一的行具有相同的列数。如果“总和”通过轴= 1，则正在总结所有列，并且输出将与相同数量的行的单个列。

Answer 4

解释轴= 0至算法应用于沿着每列，或以行标签（索引）..的更详细架构inner。

如果您应用的一般解释你的情况，这里的算法是

In [62]: pd.concat([df1, df2])
Out[62]:
     x  y    z
a  1.0  3  NaN
b  2.0  4  NaN
c  3.0  5  NaN
d  4.0  6  NaN
e  5.0  7  NaN
b  NaN  1  9.0
c  NaN  3  8.0
d  NaN  5  7.0
e  NaN  7  6.0
f  NaN  9  5.0

In [63]: pd.concat([df1, df2], axis=1)
Out[63]:
     x    y    y    z
a  1.0  3.0  NaN  NaN
b  2.0  4.0  1.0  9.0
c  3.0  5.0  3.0  8.0
d  4.0  6.0  5.0  7.0
e  5.0  7.0  7.0  6.0
f  NaN  NaN  9.0  5.0

。因此，对于轴= 0，则表示：

对于每一列，把所有的行向下（在所有dataframes为here），和做与他们联系时，他们在共同的（因为你选择concat）。

因此，意思是采取concat所有列和Concat的下来，这将堆叠行，每块一个又一个的行。然而，这里join=inner不存在无处不在，所以它不保存最终的结果。这同样适用于x。对于x结果保持为z在所有dataframes。这是你的结果。

Answer 5

首先，OP误解的行和列在他/她的数据帧。

但实际产量认为，在两个dataframes发现行。（唯一的共同行元素“Y”）

OP以为标签y是一行。然而，y是列名。

y

这是很容易被误导，因为在字典中，它看起来像y和

df1 = pd.DataFrame(
         {"x":[1, 2, 3, 4, 5],  # <-- looks like row x but actually col x
          "y":[3, 4, 5, 6, 7]}, # <-- looks like row y but actually col y
          index=['a', 'b', 'c', 'd', 'e'])
print(df1)

            \col   x    y
 index or row\
          a       1     3   |   a
          b       2     4   v   x
          c       3     5   r   i
          d       4     6   o   s
          e       5     7   w   0

               -> column
                 a x i s 1

是两行。

如果您从列表的列表产生y，它应该是更直观：

x

因此，回到该问题，df1是用于连接一个速记（装置一起在这种方式

df1 = pd.DataFrame([[1,3], 
                    [2,4],
                    [3,5],
                    [4,6],
                    [5,7]],
                    index=['a', 'b', 'c', 'd', 'e'], columns=["x", "y"])

一系列或链节）执行concat沿着轴线0的手段沿轴线0连接两个对象。

[source]

所以......觉得你现在的感觉。怎么样在大熊猫concat功能？什么

   1
   1   <-- series 1
   1
^  ^  ^
|  |  |               1
c  a  a               1
o  l  x               1
n  o  i   gives you   2
c  n  s               2
a  g  0               2
t  |  |
|  V  V
v 
   2
   2   <--- series 2
   2

手段？

假设数据看起来像

sum

也许......沿着轴线0总结，你可能会猜测。是！！

sum(axis=0)

什么

   1 2
   1 2
   1 2

？假设你有数据

^  ^  ^
|  |  |               
s  a  a               
u  l  x                
m  o  i   gives you two values 3 6 !
|  n  s               
v  g  0               
   |  |
   V  V

而你只希望保留

dropna

上的文档，它说与上省略给定轴标签返回对象，其中交替的任何或所有数据的丢失

如果你把

   1  2  NaN
  NaN 3   5
   2  4   6

或

2
3
4

？想想看，并尝试一下与

dropna(axis=0)

提示：沿想想这个字。