我花了很长时间才明白，但似乎我终于明白了。
你所要做的就是沿着第二个轴相加。
让我们看看：

np.c_[np.array([1,2,3]), np.array([4,5,6])]

但是没有第二个轴。所以我们在心里加了一个。
因此两个阵列形状都变为(3,1)。
所以结果的形状是（3，1 + 1），也就是（3，2），这是结果的形状-

array([[1, 4],
       [2, 5],
       [3, 6]])

另一个例子：

np.c_[np.array([[1,2,3]]), 0, 0, np.array([[4,5,6]])]

形状：
np.array([[1,2,3]]) = 1,3
np.array([[4,5,6]]) = 1,3
所以我们可以把它想成[[0]] = 1,1
所以结果是1,3+1+1+3 = 1,8
这是结果的形状x1米10英寸1x

使用IPython的?语法获取更多信息：

In [2]: c_?
Type:       CClass
Base Class: <class 'numpy.lib.index_tricks.CClass'>
String Form:<numpy.lib.index_tricks.CClass object at 0x9a848cc>
Namespace:  Interactive
Length:     0
File:       /usr/lib/python2.7/dist-packages/numpy/lib/index_tricks.py
Docstring:
Translates slice objects to concatenation along the second axis.

This is short-hand for ``np.r_['-1,2,0', index expression]``, which is
useful because of its common occurrence. In particular, arrays will be
stacked along their last axis after being upgraded to at least 2-D with
1's post-pended to the shape (column vectors made out of 1-D arrays).

For detailed documentation, see `r_`.

Examples
--------
>>> np.c_[np.array([[1,2,3]]), 0, 0, np.array([[4,5,6]])]
array([[1, 2, 3, 0, 0, 4, 5, 6]])

我会解释如下，它将你的第一个数组连接到函数中最后一个数组的last dimension（axis）。
例如：

# both are 2 dimensional array
a = array([[1, 2, 3], [4, 5, 6]])
b = array([[7, 8, 9], [10, 11, 12]])

现在，我们来看一下np.c_[a, b]（使用方括号）：

• • 首先，让我们看看形状：**

a和b的形状都是(2, 3)，将a（2，3）压缩成b（3）的最后一个轴，而保持其他轴不变，则（1）变为

(2, 3 + 3) = (2, 6)

这是新的形状。

• • 现在，让我们看看结果：**

在b中，最后一个轴中的2项是：

1st: [7, 8, 9]
2nd: [10, 11, 12]

向其中添加表示：

1st item: [1,2,3] + [7,8,9] = [1,2,3,7,8,9]
2nd item: [4,5,6] + [10,11,12] = [4,5,6,10,11,12]

所以结果是

[
  [1,2,3,7,8,9],
  [4,5,6,10,11,12]
]

它的形状是（2，6）

使用numpy连接数组的一个简短技巧是np. c_和np. r_
np. c_[]沿第二个轴连接数组，而np. r_[]沿第一个轴连接数组
假设：

import numpy as np
a = np.array([[1,2,3],
             [11,22,33]]
             )
b = np.array([[4,5,6],
             [44,55,66]]
             )

a的形状：（2，3）即（行数，列数）也=（第一轴，第二轴）
b的形状：（2，3）即（第一轴，第二轴）
np. r_沿第一个轴连接，因此np. r_[a，b]给出：

array([[ 1,  2,  3],
       [11, 22, 33],
       [ 4,  5,  6],
       [44, 55, 66]])

即，沿着行（第一轴）串联，因此这里的行数将增加。
而np. c_[a，b]沿第二轴连接，即列如下所示：

array([[ 1,  2,  3,  4,  5,  6],
       [11, 22, 33, 44, 55, 66]])

它将多个一维数组转换为一个二维数组，并保留原始数组的一维作为二维数组的第一维，多个输入数组作为第二维。
你可以这样想：如果您将每个包含30条记录的数据系列收集到单独的1D数组中，则np.c_会像在Excel表中一样组合这些系列：在30个的单独列中并排，而不是延伸第一系列。
例如，2个起始阵列：

>>> arrayX = np.array([X1,X2...,X30])
array([X1, X2..., X30])
>>> arrayY = np.array([Y1,Y2...,Y30])
array([Y1, Y2..., Y30])

让我们看看np.c_是如何组合它们的：

>>>arrayC = np.c_(arrayX, arrayY)
array([[X1, Y1],
       [X2, Y2],
       ...
       [X30, Y30]])

看到它仍然有30条记录长吗？现在您可以使用第二维在数据系列之间导航。
documentation有些隐晦地指出："将切片对象转换为沿第二个轴的连接。"* 什么的第二个轴？* 他们的意思是结果的2D数组。如果你不知道这是np.r_的变体，那就不清楚了，np.r_沿第一个轴连接;如果你不认为一个一维数组，有另一个维度，但是语法上，它有。
查询数组的形状以说明这一点：

>>> np.shape(arrayX)
(30,)
>>> np.shape(arrayY)
(30,)
>>> np.shape(arrayC)
(30,2)

您可以看到第二维或轴是通过np.c_方法创建的，并在那里进行连接。

>>> arrayR = np.r_[array1,array2]
array([X1, X2..., X30, Y1, Y2..., Y30])
>>> np.shape(arrayR)
(60,)

np.r_方法在第一个维度内或沿第一个轴连接。

实际上它不是一个函数，它是类CClass的一个对象。

it is "not a function, so takes no parameters

以上是官方文件所说的，你可以查这个问题了解详情。
numpy.r_ is not a function. What is it?

例如：
我有两个数组的值：
第一个月
b = [y1,y2,y3]
我们想把它们合并在一起，得到这样的结果：[[x1, y1],[x2, y2],[x3, y3]].
因此我们使用numpy.c_[a, b]

import numpy

a = [1,2,3]
b = [4,5,6]  
value = numpy.c_[a,b]

print(value)
# [
#  [1, 4],
#  [2, 5],
#  [3, 6]
# ]

np.c_[[1，4，5，4，5，3]，[1，4，2，4，5，3]，[2，4，6，8，9，0]]..这将合并水平方向上的数组，也就是说按轴0合并数组。

array([[1, 1, 2],
       [4, 4, 4],
       [5, 2, 6],
       [4, 4, 8],
       [5, 5, 9],
       [3, 3, 0]])

***要确定行，***元素总数/数组总数

(i.e[{长度（[1，4，5，4，5，3]）}+{长度（[1，4，5，4，5，3]）}+{长度（[2，4，6，8，9，0]）}]//长度（[[1，4，5，4，5，3]，[1，4，2，4，5，3]，[2，4，6，8，9，0]]）
所以上面的一个给6...所以6行将在那里。

***对于列数，***Total Elements/len（数组中的任何一个数组）

例如18/晶状体（[1，4，5，4，5，3]）
所以列数是18/6，也就是3.