blocks|key|490837|text|使用hstack的一种方法是：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|490838|b+=+np.hstack((a,+np.zeros((a.shape[0],+1),+dtype=a.dtype)))|code-block|syntax|javascript|490839|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.scipy.org/doc/numpy/reference/generated/numpy.hstack.html^0|2|6|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

One way, using <a href="https://docs.scipy.org/doc/numpy/reference/generated/numpy.hstack.html" rel="noreferrer">hstack</a>, is:

<pre><code>b = np.hstack((a, np.zeros((a.shape[0], 1), dtype=a.dtype)))
</code></pre>

blocks|key|706501|text|我认为更直接的解决方案和更快的启动是执行以下操作：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|706502|import+numpy+as+np
N+=+10
a+=+np.random.rand(N,N)
b+=+np.zeros((N,N%2B1))
b[:,:-1]+=+a|code-block|syntax|javascript|706503|和计时：|706504|In+[23]:+N+=+10

In+[24]:+a+=+np.random.rand(N,N)

In+[25]:+%25timeit+b+=+np.hstack((a,np.zeros((a.shape[0],1))))
10000+loops,+best+of+3:+19.6+us+per+loop

In+[27]:+%25timeit+b+=+np.zeros((a.shape[0],a.shape[1]%2B1));+b[:,:-1]+=+a
100000+loops,+best+of+3:+5.62+us+per+loop|706505|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

I think a more straightforward solution and faster to boot is to do the following:

<pre><code>import numpy as np
N = 10
a = np.random.rand(N,N)
b = np.zeros((N,N+1))
b[:,:-1] = a
</code></pre>

And timings:

<pre><code>In [23]: N = 10

In [24]: a = np.random.rand(N,N)

In [25]: %timeit b = np.hstack((a,np.zeros((a.shape[0],1))))
10000 loops, best of 3: 19.6 us per loop

In [27]: %timeit b = np.zeros((a.shape[0],a.shape[1]+1)); b[:,:-1] = a
100000 loops, best of 3: 5.62 us per loop
</code></pre>

blocks|key|706623|text|np.r_[+...+]和np.c_[+...+]是vstack和hstack的有用替代品，它们使用方括号[]代替了round+()。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|706624|下面是几个例子：|706625|:+import+numpy+as+np
:+N+=+3
:+A+=+np.eye(N)

:+np.c_[+A,+np.ones(N)+]++++++++++++++#+add+a+column
array([[+1.,++0.,++0.,++1.],
+++++++[+0.,++1.,++0.,++1.],
+++++++[+0.,++0.,++1.,++1.]])

:+np.c_[+np.ones(N),+A,+np.ones(N)+]++#+or+two
array([[+1.,++1.,++0.,++0.,++1.],
+++++++[+1.,++0.,++1.,++0.,++1.],
+++++++[+1.,++0.,++0.,++1.,++1.]])

:+np.r_[+A,+[A[1]]+]++++++++++++++#+add+a+row
array([[+1.,++0.,++0.],
+++++++[+0.,++1.,++0.],
+++++++[+0.,++0.,++1.],
+++++++[+0.,++1.,++0.]])
:+#+not+np.r_[+A,+A[1]+]

:+np.r_[+A[0],+1,+2,+3,+A[1]+]++++#+mix+vecs+and+scalars
++array([+1.,++0.,++0.,++1.,++2.,++3.,++0.,++1.,++0.])

:+np.r_[+A[0],+[1,+2,+3],+A[1]+]++#+lists
++array([+1.,++0.,++0.,++1.,++2.,++3.,++0.,++1.,++0.])

:+np.r_[+A[0],+(1,+2,+3),+A[1]+]++#+tuples
++array([+1.,++0.,++0.,++1.,++2.,++3.,++0.,++1.,++0.])

:+np.r_[+A[0],+1:4,+A[1]+]++++++++#+same,+1:4+==+arange(1,4)+==+1,2,3
++array([+1.,++0.,++0.,++1.,++2.,++3.,++0.,++1.,++0.])|code-block|syntax|javascript|706626|(使用方括号[]而不是round+()的原因是Python扩展了，例如1:4的正方形--重载的奇迹。)|706627|entityMap^0|0|C|D|C|Q|6|X|6|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]|$9|T|A|U|B|C]|$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Z|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|10|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|11|8|@]|D|@]|E|$]]|$1|O|3|-4|5|6|7|12|8|@]|D|@]|E|$]]]|P|$]]

<code>np.r_[ ... ]</code> and <code>np.c_[ ... ]</code>
are useful alternatives to <code>vstack</code> and <code>hstack</code>,
with square brackets [] instead of round (). 
A couple of examples:

<pre><code>: import numpy as np
: N = 3
: A = np.eye(N)

: np.c_[ A, np.ones(N) ] # add a column
array([[ 1., 0., 0., 1.],
 [ 0., 1., 0., 1.],
 [ 0., 0., 1., 1.]])

: np.c_[ np.ones(N), A, np.ones(N) ] # or two
array([[ 1., 1., 0., 0., 1.],
 [ 1., 0., 1., 0., 1.],
 [ 1., 0., 0., 1., 1.]])

: np.r_[ A, [A[1]] ] # add a row
array([[ 1., 0., 0.],
 [ 0., 1., 0.],
 [ 0., 0., 1.],
 [ 0., 1., 0.]])
: # not np.r_[ A, A[1] ]

: np.r_[ A[0], 1, 2, 3, A[1] ] # mix vecs and scalars
 array([ 1., 0., 0., 1., 2., 3., 0., 1., 0.])

: np.r_[ A[0], [1, 2, 3], A[1] ] # lists
 array([ 1., 0., 0., 1., 2., 3., 0., 1., 0.])

: np.r_[ A[0], (1, 2, 3), A[1] ] # tuples
 array([ 1., 0., 0., 1., 2., 3., 0., 1., 0.])

: np.r_[ A[0], 1:4, A[1] ] # same, 1:4 == arange(1,4) == 1,2,3
 array([ 1., 0., 0., 1., 2., 3., 0., 1., 0.])
</code></pre>

(The reason for square brackets [] instead of round ()
is that Python expands e.g. 1:4 in square --
the wonders of overloading.)

blocks|key|706695|text|我发现以下是最优雅的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|706696|b+=+np.insert(a,+3,+values=0,+axis=1)+#+Insert+values+before+column+3|code-block|syntax|javascript|706697|insert的一个优点是，它还允许您在数组内的其他位置插入列(或行)。此外，您还可以轻松地插入整个向量，例如复制最后一列，而不是插入单个值：|offset|length|style|CODE|706698|b+=+np.insert(a,+insert_index,+values=a[:,2],+axis=1)|706699|这会导致：|706700|array([[1,+2,+3,+3],
+++++++[2,+3,+4,+4]])|706701|在时间上，insert可能比JoshAdel的解决方案慢：|706702|In+[1]:+N+=+10

In+[2]:+a+=+np.random.rand(N,N)

In+[3]:+%25timeit+b+=+np.hstack((a,+np.zeros((a.shape[0],+1))))
100000+loops,+best+of+3:+7.5+µs+per+loop

In+[4]:+%25timeit+b+=+np.zeros((a.shape[0],+a.shape[1]%2B1));+b[:,:-1]+=+a
100000+loops,+best+of+3:+2.17+µs+per+loop

In+[5]:+%25timeit+b+=+np.insert(a,+3,+values=0,+axis=1)
100000+loops,+best+of+3:+10.2+µs+per+loop|706703|entityMap^0|0|0|0|6|0|0|0|0|5|6|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|10|8|@$I|11|J|12|K|L]]|9|@]|A|$]]|$1|M|3|N|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|14|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|15|8|@]|9|@]|A|$E|F]]|$1|S|3|T|5|6|7|16|8|@$I|17|J|18|K|L]]|9|@]|A|$]]|$1|U|3|V|5|D|7|19|8|@]|9|@]|A|$E|F]]|$1|W|3|-4|5|6|7|1A|8|@]|9|@]|A|$]]]|X|$]]

I find the following most elegant:

<pre><code>b = np.insert(a, 3, values=0, axis=1) # Insert values before column 3
</code></pre>

An advantage of <code>insert</code> is that it also allows you to insert columns (or rows) at other places inside the array. Also instead of inserting a single value you can easily insert a whole vector, for instance duplicate the last column:

<pre><code>b = np.insert(a, insert_index, values=a[:,2], axis=1)
</code></pre>

Which leads to:

<pre><code>array([[1, 2, 3, 3],
 [2, 3, 4, 4]])
</code></pre>

For the timing, <code>insert</code> might be slower than JoshAdel's solution:

<pre><code>In [1]: N = 10

In [2]: a = np.random.rand(N,N)

In [3]: %timeit b = np.hstack((a, np.zeros((a.shape[0], 1))))
100000 loops, best of 3: 7.5 µs per loop

In [4]: %timeit b = np.zeros((a.shape[0], a.shape[1]+1)); b[:,:-1] = a
100000 loops, best of 3: 2.17 µs per loop

In [5]: %timeit b = np.insert(a, 3, values=0, axis=1)
100000 loops, best of 3: 10.2 µs per loop
</code></pre>

blocks|key|706722|text|我认为：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|706723|np.column_stack((a,+zeros(shape(a)[0])))|code-block|syntax|javascript|706724|更加优雅。|706725|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

I think:

<pre><code>np.column_stack((a, zeros(shape(a)[0])))
</code></pre>

is more elegant.

blocks|key|706737|text|使用numpy.append|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|706738|>>>+a+=+np.array([[1,2,3],[2,3,4]])
>>>+a
array([[1,+2,+3],
+++++++[2,+3,+4]])

>>>+z+=+np.zeros((2,1),+dtype=int64)
>>>+z
array([[0],
+++++++[0]])

>>>+np.append(a,+z,+axis=1)
array([[1,+2,+3,+0],
+++++++[2,+3,+4,+0]])|code-block|syntax|javascript|706739|entityMap^0|2|C|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

Use <code>numpy.append</code>:

<pre><code>&gt;&gt;&gt; a = np.array([[1,2,3],[2,3,4]])
&gt;&gt;&gt; a
array([[1, 2, 3],
 [2, 3, 4]])

&gt;&gt;&gt; z = np.zeros((2,1), dtype=int64)
&gt;&gt;&gt; z
array([[0],
 [0]])

&gt;&gt;&gt; np.append(a, z, axis=1)
array([[1, 2, 3, 0],
 [2, 3, 4, 0]])
</code></pre>

blocks|key|706859|text|我喜欢JoshAdel的回答，因为它关注的是性能。一个较小的性能改进是避免使用零初始化的开销，只会被覆盖。当N很大，使用空而不是零，并且零列作为一个单独的步骤写入时，这会有一个可测量的差异：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|706860|In+[1]:+import+numpy+as+np

In+[2]:+N+=+10000

In+[3]:+a+=+np.ones((N,N))

In+[4]:+%25timeit+b+=+np.zeros((a.shape[0],a.shape[1]%2B1));+b[:,:-1]+=+a
1+loops,+best+of+3:+492+ms+per+loop

In+[5]:+%25timeit+b+=+np.empty((a.shape[0],a.shape[1]%2B1));+b[:,:-1]+=+a;+b[:,-1]+=+np.zeros((a.shape[0],))
1+loops,+best+of+3:+407+ms+per+loop|code-block|syntax|javascript|706861|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I like JoshAdel's answer because of the focus on performance. A minor performance improvement is to avoid the overhead of initializing with zeros, only to be overwritten. This has a measurable difference when N is large, empty is used instead of zeros, and the column of zeros is written as a separate step:

<pre><code>In [1]: import numpy as np

In [2]: N = 10000

In [3]: a = np.ones((N,N))

In [4]: %timeit b = np.zeros((a.shape[0],a.shape[1]+1)); b[:,:-1] = a
1 loops, best of 3: 492 ms per loop

In [5]: %timeit b = np.empty((a.shape[0],a.shape[1]+1)); b[:,:-1] = a; b[:,-1] = np.zeros((a.shape[0],))
1 loops, best of 3: 407 ms per loop
</code></pre>

blocks|key|706909|text|参加聚会有点晚了，但是还没有人发布这个答案，所以为了完整起见:你可以在一个普通的Python数组上用列表理解来做这件事：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|706910|source+=+a.tolist()
result+=+[row+%2B+[0]+for+row+in+source]
b+=+np.array(result)|code-block|syntax|javascript|706911|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

A bit late to the party, but nobody posted this answer yet, so for the sake of completeness: you can do this with list comprehensions, on a plain Python array:

<pre><code>source = a.tolist()
result = [row + [0] for row in source]
b = np.array(result)
</code></pre>

blocks|key|491300|text|np.concatenate也可以工作|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|491301|>>>+a+=+np.array([[1,2,3],[2,3,4]])
>>>+a
array([[1,+2,+3],
+++++++[2,+3,+4]])
>>>+z+=+np.zeros((2,1))
>>>+z
array([[+0.],
+++++++[+0.]])
>>>+np.concatenate((a,+z),+axis=1)
array([[+1.,++2.,++3.,++0.],
+++++++[+2.,++3.,++4.,++0.]])|code-block|syntax|javascript|491302|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.scipy.org/doc/numpy-1.10.0/reference/generated/numpy.concatenate.html^0|0|E|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

<a href="http://docs.scipy.org/doc/numpy-1.10.0/reference/generated/numpy.concatenate.html">np.concatenate</a> also works

<pre><code>&gt;&gt;&gt; a = np.array([[1,2,3],[2,3,4]])
&gt;&gt;&gt; a
array([[1, 2, 3],
 [2, 3, 4]])
&gt;&gt;&gt; z = np.zeros((2,1))
&gt;&gt;&gt; z
array([[ 0.],
 [ 0.]])
&gt;&gt;&gt; np.concatenate((a, z), axis=1)
array([[ 1., 2., 3., 0.],
 [ 2., 3., 4., 0.]])
</code></pre>

blocks|key|491409|text|我对这个问题也很感兴趣，并比较了|type|unstyled|depth|inlineStyleRanges|entityRanges|data|491410|numpy.c_[a,+a]
numpy.stack([a,+a]).T
numpy.vstack([a,+a]).T
numpy.ascontiguousarray(numpy.stack([a,+a]).T)+++++++++++++++
numpy.ascontiguousarray(numpy.vstack([a,+a]).T)
numpy.column_stack([a,+a])
numpy.concatenate([a[:,None],+a[:,None]],+axis=1)
numpy.concatenate([a[None],+a[None]],+axis=0).T|code-block|syntax|javascript|491411|它们对任何输入向量a都做同样的事情。a增长的时间安排|offset|length|style|CODE|491412|​|491413|📷|atomic|491414|491415|请注意，所有非连续变体(特别是stack/vstack)最终都比所有连续变体更快。如果您需要邻接性，column_stack+(因为它的清晰度和速度)似乎是一个很好的选择。|491416|491417|重现该图的代码：|491418|import+numpy+as+np
import+perfplot

b+=+perfplot.bench(
++++setup=np.random.rand,
++++kernels=[
++++++++lambda+a:+np.c_[a,+a],
++++++++lambda+a:+np.ascontiguousarray(np.stack([a,+a]).T),
++++++++lambda+a:+np.ascontiguousarray(np.vstack([a,+a]).T),
++++++++lambda+a:+np.column_stack([a,+a]),
++++++++lambda+a:+np.concatenate([a[:,+None],+a[:,+None]],+axis=1),
++++++++lambda+a:+np.ascontiguousarray(np.concatenate([a[None],+a[None]],+axis=0).T),
++++++++lambda+a:+np.stack([a,+a]).T,
++++++++lambda+a:+np.vstack([a,+a]).T,
++++++++lambda+a:+np.concatenate([a[None],+a[None]],+axis=0).T,
++++],
++++labels=[
++++++++"c_",
++++++++"ascont(stack)",
++++++++"ascont(vstack)",
++++++++"column_stack",
++++++++"concat",
++++++++"ascont(concat)",
++++++++"stack+(non-cont)",
++++++++"vstack+(non-cont)",
++++++++"concat+(non-cont)",
++++],
++++n_range=[2+**+k+for+k+in+range(23)],
++++xlabel="len(a)",
)
b.save("out.png")|491419|entityMap|0|IMAGE|mutability|IMMUTABLE|imageUrl|https://ask.qcloudimg.com/http-save/yehe-900000/531b6b288f8b7e1671cfa672da872667.png|imageAlt^0|0|0|9|1|I|1|0|0|0|1|0|0|0|F|5|L|6|1E|C|0|0|0|0^^$0|@$1|2|3|4|5|6|7|18|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|19|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|1A|8|@$I|1B|J|1C|K|L]|$I|1D|J|1E|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|1F|8|@]|9|@]|A|$]]|$1|O|3|P|5|Q|7|1G|8|@]|9|@$I|1H|J|1I|1|1J]]|A|$]]|$1|R|3|N|5|6|7|1K|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|1L|8|@$I|1M|J|1N|K|L]|$I|1O|J|1P|K|L]|$I|1Q|J|1R|K|L]]|9|@]|A|$]]|$1|U|3|-4|5|6|7|1S|8|@]|9|@]|A|$]]|$1|V|3|W|5|6|7|1T|8|@]|9|@]|A|$]]|$1|X|3|Y|5|D|7|1U|8|@]|9|@]|A|$E|F]]|$1|Z|3|-4|5|6|7|1V|8|@]|9|@]|A|$]]]|10|$11|$5|12|13|14|A|$15|16|17|-4]]]]

I was also interested in this question and compared the speed of
<pre class="lang-py prettyprint-override"><code>numpy.c_[a, a]
numpy.stack([a, a]).T
numpy.vstack([a, a]).T
numpy.ascontiguousarray(numpy.stack([a, a]).T) 
numpy.ascontiguousarray(numpy.vstack([a, a]).T)
numpy.column_stack([a, a])
numpy.concatenate([a[:,None], a[:,None]], axis=1)
numpy.concatenate([a[None], a[None]], axis=0).T
</code></pre>
which all do the same thing for any input vector <code>a</code>. Timings for growing <code>a</code>:
<a href="https://i.stack.imgur.com/Dht56.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/Dht56.png" alt="enter image description here" /></a>
Note that all non-contiguous variants (in particular <code>stack</code>/<code>vstack</code>) are eventually faster than all contiguous variants. <code>column_stack</code> (for its clarity and speed) appears to be a good option if you require contiguity.
<hr />
Code to reproduce the plot:
<pre class="lang-py prettyprint-override"><code>import numpy as np
import perfplot

b = perfplot.bench(
 setup=np.random.rand,
 kernels=[
 lambda a: np.c_[a, a],
 lambda a: np.ascontiguousarray(np.stack([a, a]).T),
 lambda a: np.ascontiguousarray(np.vstack([a, a]).T),
 lambda a: np.column_stack([a, a]),
 lambda a: np.concatenate([a[:, None], a[:, None]], axis=1),
 lambda a: np.ascontiguousarray(np.concatenate([a[None], a[None]], axis=0).T),
 lambda a: np.stack([a, a]).T,
 lambda a: np.vstack([a, a]).T,
 lambda a: np.concatenate([a[None], a[None]], axis=0).T,
 ],
 labels=[
 &quot;c_&quot;,
 &quot;ascont(stack)&quot;,
 &quot;ascont(vstack)&quot;,
 &quot;column_stack&quot;,
 &quot;concat&quot;,
 &quot;ascont(concat)&quot;,
 &quot;stack (non-cont)&quot;,
 &quot;vstack (non-cont)&quot;,
 &quot;concat (non-cont)&quot;,
 ],
 n_range=[2 ** k for k in range(23)],
 xlabel=&quot;len(a)&quot;,
)
b.save(&quot;out.png&quot;)
</code></pre>

blocks|key|491457|text|假设M是(100,3)+ndarray，y是(100)+ndarray，则可以按如下方式使用append：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|491458|M=numpy.append(M,y[:,None],1)|code-block|syntax|javascript|491459|诀窍是使用|491460|y[:,+None]|491461|这会将y转换为(100，1)+2D数组。|491462|M.shape|491463|现在给出|491464|(100,+4)|491465|entityMap^0|2|1|K|1|1A|6|0|0|0|0|3|1|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@$9|Z|A|10|B|C]|$9|11|A|12|B|C]|$9|13|A|14|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|15|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|16|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|17|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|18|8|@$9|19|A|1A|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|H|7|1B|8|@]|D|@]|E|$I|J]]|$1|S|3|T|5|6|7|1C|8|@]|D|@]|E|$]]|$1|U|3|V|5|H|7|1D|8|@]|D|@]|E|$I|J]]|$1|W|3|-4|5|6|7|1E|8|@]|D|@]|E|$]]]|X|$]]

Assuming <code>M</code> is a (100,3) ndarray and <code>y</code> is a (100,) ndarray <code>append</code> can be used as follows:

<pre><code>M=numpy.append(M,y[:,None],1)
</code></pre>

The trick is to use 

<pre><code>y[:, None]
</code></pre>

This converts <code>y</code> to a (100, 1) 2D array.

<pre><code>M.shape
</code></pre>

now gives

<pre><code>(100, 4)
</code></pre>

blocks|key|707167|text|在我的例子中，我必须向NumPy数组中添加一列1|type|unstyled|depth|inlineStyleRanges|entityRanges|data|707168|X+=+array([+6.1101,+5.5277,+...+])
X.shape+=>+(97,)
X+=+np.concatenate((np.ones((m,1),+dtype=np.int),+X.reshape(m,1)),+axis=1)|code-block|syntax|javascript|707169|在X.shape+=>之后(97，2)|707170|array([[+1.+,+6.1101],
+++++++[+1.+,+5.5277],
...|707171|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

In my case, I had to add a column of ones to a NumPy array

<pre><code>X = array([ 6.1101, 5.5277, ... ])
X.shape =&gt; (97,)
X = np.concatenate((np.ones((m,1), dtype=np.int), X.reshape(m,1)), axis=1)
</code></pre>

After
 X.shape => (97, 2)

<pre><code>array([[ 1. , 6.1101],
 [ 1. , 5.5277],
...
</code></pre>

blocks|key|707253|text|np.insert也服务于此目的。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|707254|matA+=+np.array([[1,2,3],+
+++++++++++++++++[2,3,4]])
idx+=+3
new_col+=+np.array([0,+0])
np.insert(matA,+idx,+new_col,+axis=1)

array([[1,+2,+3,+0],
+++++++[2,+3,+4,+0]])|code-block|syntax|javascript|707255|它沿着一个轴在给定索引之前插入值，在这里是new_col，在这里是idx。换句话说，新插入的值将占据idx列，并将idx时和之后的值向后移动。|707256|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.scipy.org/doc/numpy-1.13.0/reference/generated/numpy.insert.html^0|0|9|0|9|0|0|0|L|7|X|3|1E|3|1L|3|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@$9|X|A|Y|1|Z]]|E|$]]|$1|F|3|G|5|H|7|10|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|11|8|@$9|12|A|13|B|C]|$9|14|A|15|B|C]|$9|16|A|17|B|C]|$9|18|A|19|B|C]]|D|@]|E|$]]|$1|M|3|-4|5|6|7|1A|8|@]|D|@]|E|$]]]|N|$O|$5|P|Q|R|E|$S|T]]]]

<a href="https://docs.scipy.org/doc/numpy-1.13.0/reference/generated/numpy.insert.html" rel="noreferrer"><code>np.insert</code></a> also serves the purpose. 

<pre><code>matA = np.array([[1,2,3], 
 [2,3,4]])
idx = 3
new_col = np.array([0, 0])
np.insert(matA, idx, new_col, axis=1)

array([[1, 2, 3, 0],
 [2, 3, 4, 0]])
</code></pre>

It inserts values, here <code>new_col</code>, before a given index, here <code>idx</code> along one axis. In other words, the newly inserted values will occupy the <code>idx</code> column and move what were originally there at and after <code>idx</code> backward.

blocks|key|707305|text|有一个专门针对这一点的函数。它被称为numpy.pad|type|unstyled|depth|inlineStyleRanges|entityRanges|data|707306|a+=+np.array([[1,2,3],+[2,3,4]])
b+=+np.pad(a,+((0,+0),+(0,+1)),+mode='constant',+constant_values=0)
print+b
>>>+array([[1,+2,+3,+0],
+++++++++++[2,+3,+4,+0]])|code-block|syntax|javascript|707307|这是它在文档字符串中的内容：|707308|Pads+an+array.

Parameters
----------
array+:+array_like+of+rank+N
++++Input+array
pad_width+:+{sequence,+array_like,+int}
++++Number+of+values+padded+to+the+edges+of+each+axis.
++++((before_1,+after_1),+...+(before_N,+after_N))+unique+pad+widths
++++for+each+axis.
++++((before,+after),)+yields+same+before+and+after+pad+for+each+axis.
++++(pad,)+or+int+is+a+shortcut+for+before+=+after+=+pad+width+for+all
++++axes.
mode+:+str+or+function
++++One+of+the+following+string+values+or+a+user+supplied+function.

++++'constant'
++++++++Pads+with+a+constant+value.
++++'edge'
++++++++Pads+with+the+edge+values+of+array.
++++'linear_ramp'
++++++++Pads+with+the+linear+ramp+between+end_value+and+the
++++++++array+edge+value.
++++'maximum'
++++++++Pads+with+the+maximum+value+of+all+or+part+of+the
++++++++vector+along+each+axis.
++++'mean'
++++++++Pads+with+the+mean+value+of+all+or+part+of+the
++++++++vector+along+each+axis.
++++'median'
++++++++Pads+with+the+median+value+of+all+or+part+of+the
++++++++vector+along+each+axis.
++++'minimum'
++++++++Pads+with+the+minimum+value+of+all+or+part+of+the
++++++++vector+along+each+axis.
++++'reflect'
++++++++Pads+with+the+reflection+of+the+vector+mirrored+on
++++++++the+first+and+last+values+of+the+vector+along+each
++++++++axis.
++++'symmetric'
++++++++Pads+with+the+reflection+of+the+vector+mirrored
++++++++along+the+edge+of+the+array.
++++'wrap'
++++++++Pads+with+the+wrap+of+the+vector+along+the+axis.
++++++++The+first+values+are+used+to+pad+the+end+and+the
++++++++end+values+are+used+to+pad+the+beginning.
++++<function>
++++++++Padding+function,+see+Notes.
stat_length+:+sequence+or+int,+optional
++++Used+in+'maximum',+'mean',+'median',+and+'minimum'.++Number+of
++++values+at+edge+of+each+axis+used+to+calculate+the+statistic+value.

++++((before_1,+after_1),+...+(before_N,+after_N))+unique+statistic
++++lengths+for+each+axis.

++++((before,+after),)+yields+same+before+and+after+statistic+lengths
++++for+each+axis.

++++(stat_length,)+or+int+is+a+shortcut+for+before+=+after+=+statistic
++++length+for+all+axes.

++++Default+is+``None``,+to+use+the+entire+axis.
constant_values+:+sequence+or+int,+optional
++++Used+in+'constant'.++The+values+to+set+the+padded+values+for+each
++++axis.

++++((before_1,+after_1),+...+(before_N,+after_N))+unique+pad+constants
++++for+each+axis.

++++((before,+after),)+yields+same+before+and+after+constants+for+each
++++axis.

++++(constant,)+or+int+is+a+shortcut+for+before+=+after+=+constant+for
++++all+axes.

++++Default+is+0.
end_values+:+sequence+or+int,+optional
++++Used+in+'linear_ramp'.++The+values+used+for+the+ending+value+of+the
++++linear_ramp+and+that+will+form+the+edge+of+the+padded+array.

++++((before_1,+after_1),+...+(before_N,+after_N))+unique+end+values
++++for+each+axis.

++++((before,+after),)+yields+same+before+and+after+end+values+for+each
++++axis.

++++(constant,)+or+int+is+a+shortcut+for+before+=+after+=+end+value+for
++++all+axes.

++++Default+is+0.
reflect_type+:+{'even',+'odd'},+optional
++++Used+in+'reflect',+and+'symmetric'.++The+'even'+style+is+the
++++default+with+an+unaltered+reflection+around+the+edge+value.++For
++++the+'odd'+style,+the+extented+part+of+the+array+is+created+by
++++subtracting+the+reflected+values+from+two+times+the+edge+value.

Returns
-------
pad+:+ndarray
++++Padded+array+of+rank+equal+to+`array`+with+shape+increased
++++according+to+`pad_width`.

Notes
-----
..+versionadded::+1.7.0

For+an+array+with+rank+greater+than+1,+some+of+the+padding+of+later
axes+is+calculated+from+padding+of+previous+axes.++This+is+easiest+to
think+about+with+a+rank+2+array+where+the+corners+of+the+padded+array
are+calculated+by+using+padded+values+from+the+first+axis.

The+padding+function,+if+used,+should+return+a+rank+1+array+equal+in
length+to+the+vector+argument+with+padded+values+replaced.+It+has+the
following+signature::

++++padding_func(vector,+iaxis_pad_width,+iaxis,+kwargs)

where

++++vector+:+ndarray
++++++++A+rank+1+array+already+padded+with+zeros.++Padded+values+are
++++++++vector[:pad_tuple[0]]+and+vector[-pad_tuple[1]:].
++++iaxis_pad_width+:+tuple
++++++++A+2-tuple+of+ints,+iaxis_pad_width[0]+represents+the+number+of
++++++++values+padded+at+the+beginning+of+vector+where
++++++++iaxis_pad_width[1]+represents+the+number+of+values+padded+at
++++++++the+end+of+vector.
++++iaxis+:+int
++++++++The+axis+currently+being+calculated.
++++kwargs+:+dict
++++++++Any+keyword+arguments+the+function+requires.

Examples
--------
>>>+a+=+[1,+2,+3,+4,+5]
>>>+np.pad(a,+(2,3),+'constant',+constant_values=(4,+6))
array([4,+4,+1,+2,+3,+4,+5,+6,+6,+6])

>>>+np.pad(a,+(2,+3),+'edge')
array([1,+1,+1,+2,+3,+4,+5,+5,+5,+5])

>>>+np.pad(a,+(2,+3),+'linear_ramp',+end_values=(5,+-4))
array([+5,++3,++1,++2,++3,++4,++5,++2,+-1,+-4])

>>>+np.pad(a,+(2,),+'maximum')
array([5,+5,+1,+2,+3,+4,+5,+5,+5])

>>>+np.pad(a,+(2,),+'mean')
array([3,+3,+1,+2,+3,+4,+5,+3,+3])

>>>+np.pad(a,+(2,),+'median')
array([3,+3,+1,+2,+3,+4,+5,+3,+3])

>>>+a+=+[[1,+2],+[3,+4]]
>>>+np.pad(a,+((3,+2),+(2,+3)),+'minimum')
array([[1,+1,+1,+2,+1,+1,+1],
+++++++[1,+1,+1,+2,+1,+1,+1],
+++++++[1,+1,+1,+2,+1,+1,+1],
+++++++[1,+1,+1,+2,+1,+1,+1],
+++++++[3,+3,+3,+4,+3,+3,+3],
+++++++[1,+1,+1,+2,+1,+1,+1],
+++++++[1,+1,+1,+2,+1,+1,+1]])

>>>+a+=+[1,+2,+3,+4,+5]
>>>+np.pad(a,+(2,+3),+'reflect')
array([3,+2,+1,+2,+3,+4,+5,+4,+3,+2])

>>>+np.pad(a,+(2,+3),+'reflect',+reflect_type='odd')
array([-1,++0,++1,++2,++3,++4,++5,++6,++7,++8])

>>>+np.pad(a,+(2,+3),+'symmetric')
array([2,+1,+1,+2,+3,+4,+5,+5,+4,+3])

>>>+np.pad(a,+(2,+3),+'symmetric',+reflect_type='odd')
array([0,+1,+1,+2,+3,+4,+5,+5,+6,+7])

>>>+np.pad(a,+(2,+3),+'wrap')
array([4,+5,+1,+2,+3,+4,+5,+1,+2,+3])

>>>+def+pad_with(vector,+pad_width,+iaxis,+kwargs):
...+++++pad_value+=+kwargs.get('padder',+10)
...+++++vector[:pad_width[0]]+=+pad_value
...+++++vector[-pad_width[1]:]+=+pad_value
...+++++return+vector
>>>+a+=+np.arange(6)
>>>+a+=+a.reshape((2,+3))
>>>+np.pad(a,+2,+pad_with)
array([[10,+10,+10,+10,+10,+10,+10],
+++++++[10,+10,+10,+10,+10,+10,+10],
+++++++[10,+10,++0,++1,++2,+10,+10],
+++++++[10,+10,++3,++4,++5,+10,+10],
+++++++[10,+10,+10,+10,+10,+10,+10],
+++++++[10,+10,+10,+10,+10,+10,+10]])
>>>+np.pad(a,+2,+pad_with,+padder=100)
array([[100,+100,+100,+100,+100,+100,+100],
+++++++[100,+100,+100,+100,+100,+100,+100],
+++++++[100,+100,+++0,+++1,+++2,+100,+100],
+++++++[100,+100,+++3,+++4,+++5,+100,+100],
+++++++[100,+100,+100,+100,+100,+100,+100],
+++++++[100,+100,+100,+100,+100,+100,+100]])|707309|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

There is a function specifically for this. It is called numpy.pad

<pre><code>a = np.array([[1,2,3], [2,3,4]])
b = np.pad(a, ((0, 0), (0, 1)), mode='constant', constant_values=0)
print b
&gt;&gt;&gt; array([[1, 2, 3, 0],
 [2, 3, 4, 0]])
</code></pre>

Here is what it says in the docstring:

<pre><code>Pads an array.

Parameters
----------
array : array_like of rank N
 Input array
pad_width : {sequence, array_like, int}
 Number of values padded to the edges of each axis.
 ((before_1, after_1), ... (before_N, after_N)) unique pad widths
 for each axis.
 ((before, after),) yields same before and after pad for each axis.
 (pad,) or int is a shortcut for before = after = pad width for all
 axes.
mode : str or function
 One of the following string values or a user supplied function.

 'constant'
 Pads with a constant value.
 'edge'
 Pads with the edge values of array.
 'linear_ramp'
 Pads with the linear ramp between end_value and the
 array edge value.
 'maximum'
 Pads with the maximum value of all or part of the
 vector along each axis.
 'mean'
 Pads with the mean value of all or part of the
 vector along each axis.
 'median'
 Pads with the median value of all or part of the
 vector along each axis.
 'minimum'
 Pads with the minimum value of all or part of the
 vector along each axis.
 'reflect'
 Pads with the reflection of the vector mirrored on
 the first and last values of the vector along each
 axis.
 'symmetric'
 Pads with the reflection of the vector mirrored
 along the edge of the array.
 'wrap'
 Pads with the wrap of the vector along the axis.
 The first values are used to pad the end and the
 end values are used to pad the beginning.
 &lt;function&gt;
 Padding function, see Notes.
stat_length : sequence or int, optional
 Used in 'maximum', 'mean', 'median', and 'minimum'. Number of
 values at edge of each axis used to calculate the statistic value.

 ((before_1, after_1), ... (before_N, after_N)) unique statistic
 lengths for each axis.

 ((before, after),) yields same before and after statistic lengths
 for each axis.

 (stat_length,) or int is a shortcut for before = after = statistic
 length for all axes.

 Default is ``None``, to use the entire axis.
constant_values : sequence or int, optional
 Used in 'constant'. The values to set the padded values for each
 axis.

 ((before_1, after_1), ... (before_N, after_N)) unique pad constants
 for each axis.

 ((before, after),) yields same before and after constants for each
 axis.

 (constant,) or int is a shortcut for before = after = constant for
 all axes.

 Default is 0.
end_values : sequence or int, optional
 Used in 'linear_ramp'. The values used for the ending value of the
 linear_ramp and that will form the edge of the padded array.

 ((before_1, after_1), ... (before_N, after_N)) unique end values
 for each axis.

 ((before, after),) yields same before and after end values for each
 axis.

 (constant,) or int is a shortcut for before = after = end value for
 all axes.

 Default is 0.
reflect_type : {'even', 'odd'}, optional
 Used in 'reflect', and 'symmetric'. The 'even' style is the
 default with an unaltered reflection around the edge value. For
 the 'odd' style, the extented part of the array is created by
 subtracting the reflected values from two times the edge value.

Returns
-------
pad : ndarray
 Padded array of rank equal to `array` with shape increased
 according to `pad_width`.

Notes
-----
.. versionadded:: 1.7.0

For an array with rank greater than 1, some of the padding of later
axes is calculated from padding of previous axes. This is easiest to
think about with a rank 2 array where the corners of the padded array
are calculated by using padded values from the first axis.

The padding function, if used, should return a rank 1 array equal in
length to the vector argument with padded values replaced. It has the
following signature::

 padding_func(vector, iaxis_pad_width, iaxis, kwargs)

where

 vector : ndarray
 A rank 1 array already padded with zeros. Padded values are
 vector[:pad_tuple[0]] and vector[-pad_tuple[1]:].
 iaxis_pad_width : tuple
 A 2-tuple of ints, iaxis_pad_width[0] represents the number of
 values padded at the beginning of vector where
 iaxis_pad_width[1] represents the number of values padded at
 the end of vector.
 iaxis : int
 The axis currently being calculated.
 kwargs : dict
 Any keyword arguments the function requires.

Examples
--------
&gt;&gt;&gt; a = [1, 2, 3, 4, 5]
&gt;&gt;&gt; np.pad(a, (2,3), 'constant', constant_values=(4, 6))
array([4, 4, 1, 2, 3, 4, 5, 6, 6, 6])

&gt;&gt;&gt; np.pad(a, (2, 3), 'edge')
array([1, 1, 1, 2, 3, 4, 5, 5, 5, 5])

&gt;&gt;&gt; np.pad(a, (2, 3), 'linear_ramp', end_values=(5, -4))
array([ 5, 3, 1, 2, 3, 4, 5, 2, -1, -4])

&gt;&gt;&gt; np.pad(a, (2,), 'maximum')
array([5, 5, 1, 2, 3, 4, 5, 5, 5])

&gt;&gt;&gt; np.pad(a, (2,), 'mean')
array([3, 3, 1, 2, 3, 4, 5, 3, 3])

&gt;&gt;&gt; np.pad(a, (2,), 'median')
array([3, 3, 1, 2, 3, 4, 5, 3, 3])

&gt;&gt;&gt; a = [[1, 2], [3, 4]]
&gt;&gt;&gt; np.pad(a, ((3, 2), (2, 3)), 'minimum')
array([[1, 1, 1, 2, 1, 1, 1],
 [1, 1, 1, 2, 1, 1, 1],
 [1, 1, 1, 2, 1, 1, 1],
 [1, 1, 1, 2, 1, 1, 1],
 [3, 3, 3, 4, 3, 3, 3],
 [1, 1, 1, 2, 1, 1, 1],
 [1, 1, 1, 2, 1, 1, 1]])

&gt;&gt;&gt; a = [1, 2, 3, 4, 5]
&gt;&gt;&gt; np.pad(a, (2, 3), 'reflect')
array([3, 2, 1, 2, 3, 4, 5, 4, 3, 2])

&gt;&gt;&gt; np.pad(a, (2, 3), 'reflect', reflect_type='odd')
array([-1, 0, 1, 2, 3, 4, 5, 6, 7, 8])

&gt;&gt;&gt; np.pad(a, (2, 3), 'symmetric')
array([2, 1, 1, 2, 3, 4, 5, 5, 4, 3])

&gt;&gt;&gt; np.pad(a, (2, 3), 'symmetric', reflect_type='odd')
array([0, 1, 1, 2, 3, 4, 5, 5, 6, 7])

&gt;&gt;&gt; np.pad(a, (2, 3), 'wrap')
array([4, 5, 1, 2, 3, 4, 5, 1, 2, 3])

&gt;&gt;&gt; def pad_with(vector, pad_width, iaxis, kwargs):
... pad_value = kwargs.get('padder', 10)
... vector[:pad_width[0]] = pad_value
... vector[-pad_width[1]:] = pad_value
... return vector
&gt;&gt;&gt; a = np.arange(6)
&gt;&gt;&gt; a = a.reshape((2, 3))
&gt;&gt;&gt; np.pad(a, 2, pad_with)
array([[10, 10, 10, 10, 10, 10, 10],
 [10, 10, 10, 10, 10, 10, 10],
 [10, 10, 0, 1, 2, 10, 10],
 [10, 10, 3, 4, 5, 10, 10],
 [10, 10, 10, 10, 10, 10, 10],
 [10, 10, 10, 10, 10, 10, 10]])
&gt;&gt;&gt; np.pad(a, 2, pad_with, padder=100)
array([[100, 100, 100, 100, 100, 100, 100],
 [100, 100, 100, 100, 100, 100, 100],
 [100, 100, 0, 1, 2, 100, 100],
 [100, 100, 3, 4, 5, 100, 100],
 [100, 100, 100, 100, 100, 100, 100],
 [100, 100, 100, 100, 100, 100, 100]])
</code></pre>

blocks|key|707341|text|对我来说，下一种方法看起来非常直观和简单。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|707342|zeros+=+np.zeros((2,1))+#2+is+a+number+of+rows+in+your+array.+++
b+=+np.hstack((a,+zeros))|code-block|syntax|javascript|707343|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

For me, the next way looks pretty intuitive and simple.

<pre><code>zeros = np.zeros((2,1)) #2 is a number of rows in your array. 
b = np.hstack((a, zeros))
</code></pre>

blocks|key|707382|text|向numpy数组中添加额外的列：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|707383|numpy的np.append方法有三个参数，前两个是二维numpy数组，第三个是轴参数，指示沿哪个轴追加：|offset|length|style|CODE|707384|import+numpy+as+np++
x+=+np.array([[1,2,3],+[4,5,6]])+
print("Original+x:")+
print(x)+

y+=+np.array([[1],+[1]])+
print("Original+y:")+
print(y)+

print("x+appended+to+y+on+axis+of+1:")+
print(np.append(x,+y,+axis=1))+|code-block|syntax|javascript|707385|打印：|707386|Original+x:
[[1+2+3]
+[4+5+6]]
Original+y:
[[1]
+[1]]
y+appended+to+x+on+axis+of+1:
[[1+2+3+1]
+[4+5+6+1]]|707387|entityMap^0|0|6|9|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@$D|U|E|V|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|W|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|P|5|J|7|Y|8|@]|9|@]|A|$K|L]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

<h2>Add an extra column to a numpy array:</h2>
Numpy's <code>np.append</code> method takes three parameters, the first two are 2D numpy arrays and the 3rd is an axis parameter instructing along which axis to append:
<pre><code>import numpy as np 
x = np.array([[1,2,3], [4,5,6]]) 
print(&quot;Original x:&quot;) 
print(x) 

y = np.array([[1], [1]]) 
print(&quot;Original y:&quot;) 
print(y) 

print(&quot;x appended to y on axis of 1:&quot;) 
print(np.append(x, y, axis=1)) 
</code></pre>
Prints:
<pre><code>Original x:
[[1 2 3]
 [4 5 6]]
Original y:
[[1]
 [1]]
y appended to x on axis of 1:
[[1 2 3 1]
 [4 5 6 1]]
</code></pre>

blocks|key|707422|text|我喜欢这样：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|707423|new_column+=+np.zeros((len(a),+1))
b+=+np.block([a,+new_column])|code-block|syntax|javascript|707424|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I liked this:
<pre><code>new_column = np.zeros((len(a), 1))
b = np.block([a, new_column])
</code></pre>

Let’s say I have a NumPy array, <code>a</code>:



<pre><code>a = np.array([
 [1, 2, 3],
 [2, 3, 4]
 ])
</code></pre>

And I would like to add a column of zeros to get an array, <code>b</code>:



<pre><code>b = np.array([
 [1, 2, 3, 0],
 [2, 3, 4, 0]
 ])
</code></pre>

How can I do this easily in NumPy?

How to add an extra column to a NumPy array

Python

假设我有一个NumPy数组，aa = np.array([    [1, 2, 3],    [2, 3, 4]    ])我想添加一列零来得到一个数组，bb = np.array([    [1, 2, 3, 0],    [2, 3, 4, 0]    ])如何在NumPy中轻松做到这一点？

问如何向NumPy数组添加额外的列
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何向NumPy数组添加额外的列EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何向NumPy数组添加额外的列
EN