配列の連結
NumPy の配列を連結（結合）する関数の一覧です。
numpy.concatenate()
numpy.concatenate()を使うと、複数の配列を 連結 できます。
numpy.concatenate((a1, a2, ...), axis=0, out=None)
a1, a2, a3, ... には配列を渡します。
2 次元以上の配列を渡す場合は axis を指定できます (デフォルトは axis=0)。
# NUMPY_CONCATENATE
# In[1]
import numpy as np
a1 = np.array([[1, 2, 3],
[4, 5, 6]])
a2 = np.array([[7, 8, 9]])
a3 = np.array([[1, 1],
[2, 2]])
# 2次元配列同士を縦軸方向に連結
x = np.concatenate((a1, a2))
# 2次元配列同士を横軸方向に連結
y = np.concatenate((a1, a3), axis=1)
print("配列x\n{}\n\n".format(x))
print("配列y\n{}".format(y))
# 配列x
# [[1 2 3]
# [4 5 6]
# [7 8 9]]
# 配列y
# [[1 2 3 1 1]
# [4 5 6 2 2]]numpy.vstack()
numpy.vstack() は、受け取った配列を縦積みします。引数には配列のシーケンス（リストやタプル）を渡します。この関数は numpy.concatenate() で axis=0 を渡した場合と同じ機能をもちます。
# NUMPY_VSTACK
# In[1]
import numpy as np
a1 = np.array([[1, 1, 1]])
a2 = np.array([[2, 2, 2]])
# 1次元配列同士を縦軸(axis=0)方向に連結
x = np.vstack((a1, a2))
print(x)
# [[1 1 1]
# [2 2 2]]numpy.hstack()
numpy.hstack()は、受け取った配列を横軸(axis=1)方向に連結します。引数には配列のシーケンス（リストやタプル）を渡します。この関数は numpy.concatenate() で axis=1 を渡したときと同じ機能をもちます。
# NUMPY_HSTACK
# In[1]
import numpy as np
a1 = np.array([[1, 1]])
a2 = np.array([[2, 2]])
# 1次元配列同士を横軸(axis=1)方向に連結
x = np.hstack((a1, a2))
print(x)
# [[1 1 2 2]]numpy.dstack()
numpy.dstack() は受け取った配列 a1, a2, ... を深さ方向に連結します。
numpy.dstack((a1, a2, ...))
深さ方向 (公式ドキュメントでは "depth") というと何だか曖昧な表現ですが、要するに axis=2 に沿って連結するという意味です。例として、2 次元配列を numpy.dstack() で結合してみます。
# NUMPY_DSTACK
# In[1]
import numpy as np
# 全ての要素が0の3×3配列
a = np.zeros((3, 3))
# 全ての要素が1の3×3配列
b = np.ones((3, 3))
# aとbを深さ(axis=2)方向に連結
stack_ab = np.dstack((a, b))
print(stack_ab)
'''
[[[0. 1.]
[0. 1.]
[0. 1.]]
[[0. 1.]
[0. 1.]
[0. 1.]]
[[0. 1.]
[0. 1.]
[0. 1.]]]
''' 上の例では同じ形状の 2 次元配列を下の図のように「重ね合わせて」います。
このように重ね合わせた配列の形状は 3 次元となるので、戻り値は 3 次元配列です。実行結果を見ても、3 次元配列を頭の中でイメージし難いのですが、shape 属性で形状を確かめてみましょう。
# In[2]
print(stack_ab.shape)
# (3, 3, 2)3×3 の配列が 2 つ重なっていることがわかります。引数に 1 次元配列を渡すこともできます。試してみましょう。
# In[3]
c = [0, 0, 0]
d = [1, 1, 1]
e = [2, 2, 2]
# a,b,cを奥行き方向に連結
stack_cde = np.dstack((c, d, e))
print(stack_cde)
# [[[0 1 2]
# [0 1 2]
# [0 1 2]]]渡した配列の形状が 1 次元であっても、下図のように縦でも横でもなく、深さ方向に重ねているので、戻り値はやはり 3 次元配列となっています。
numpy.dstack() に渡す配列 a1, a2, ... は、それぞれ縦横 (axis=0, axis=1) のサイズが揃っていなければなりませんが、深さ方向 (axis=2) のサイズに関しては制限がありません。たとえば、In[1] で作成した配列 stack_ab に 2 次元配列 a をさらに重ねて、深さ 3 の 3 次元配列を生成することもできます。
# In[4]
# stack_abとaを深さ方向に連結
stack_aba = np.dstack((stack_ab, a))
print(stack_aba)
'''
[[[0. 1. 0.]
[0. 1. 0.]
[0. 1. 0.]]
[[0. 1. 0.]
[0. 1. 0.]
[0. 1. 0.]]
[[0. 1. 0.]
[0. 1. 0.]
[0. 1. 0.]]]
'''
配列の分割
NumPy の配列を分割する関数の一覧です。
numpy.split()
numpy.split() は受け取った配列を 均等分割 します。
numpy.split(array, indices_or_sections, axis=0)
array には配列オブジェクトを渡します。第 2 引数に整数 N を渡すと、指定した axis (デフォルトは 0) に沿って配列を N 等分します。
# NUMPY_SPLIT
# In[1]
import numpy as np
# 9個の要素をもつ1次元配列を定義
x = np.ones(9, dtype = "int32")
# xを3つの配列に分割
y1, y2, y3 = np.split(x, 3)
print(y1, y2, y3)
# [1 1 1] [1 1 1] [1 1 1]第 2 引数に分割点インデックスのリストを渡すこともできます。
# In[2]
# x = [1 2 3 4 5 6 7 8 9]
x = np.arange(1, 10)
# xをインデックス3,5の位置で分割
y1, y2, y3 = np.split(x, [3, 5])
print(y1, y2, y3)
# [1 2 3] [4 5] [6 7 8 9]numpy.array_split()
numpy.array_split() は受け取った配列を分割します。
numpy.array_split(array, indices_or_sections, axis=0)
array には配列オブジェクトを渡します。第 2 引数に整数 N を渡すと、指定した axis (デフォルトは 0) に沿って配列を N 等分します。
numpy.split(x, N) は配列 x が N で割り切れないとエラーを返しますが、numpy.array_split(x, N) は、x が N で割り切れないときには、余りの要素数を先頭の配列から順に割り振ります。たとえば、11 個の要素で構成される配列を 3 分割する場合、4 個、4 個、3 個の要素数をもつ配列に分割します。
# NUMPY_ARRAY_SPLIT
# In[1]
import numpy as np
# x = [0 1 2 3 4 5 6 7 8 9 10]
x = np.arange(11)
# 配列xを3等分
y = np.array_split(x, 3)
print(y)
# [array([0, 1, 2, 3]), array([4, 5, 6, 7]), array([ 8, 9, 10])]第 2 引数に分割点インデックスのリストを渡すこともできます。
その場合は numpy.split() と同じはたらきをします。
numpy.vsplit()
numpy.vsplit() は配列を縦軸方向に分割します。
# NUMPY_VSPLIT
# In[1]
import numpy as np
# 乱数を固定
np.random.seed(0)
# 1～9の乱数を要素にもつ4×3配列
x = np.random.randint(1, 10, (4, 3))
print("配列x\n{}\n".format(x))
# 縦軸に沿って配列を2分割
y1, y2 = np.vsplit(x, 2)
print("配列y1\n{}\n".format(y1))
print("配列y2\n{}".format(y2))
'''
配列x
[[6 1 4]
[4 8 4]
[6 3 5]
[8 7 9]
配列y1
[[6 1 4]
[4 8 4]]
配列y2
[[6 3 5]
[8 7 9]]
'''numpy.hsplit()
numpy.hsplit() は配列を横軸方向に分割します。
# NUMPY_HSPLIT
# In[1]
import numpy as np
# 2×2の2次元配列
x = np.array([[1, 2],
[3, 4]])
# xを2個の配列に水平分割
y1, y2 = np.hsplit(x, 2)
print(y1, "\n")
print(y2)
# [[1]
# [3]]
# [[2]
# [4]numpy.dsplit()
numpy.dsplit() は受け取った配列を深さ(axis=2)方向に分割します。
numpy.dsplit(ary, indices_or_sections)
第 2 引数に整数 k を渡すと、配列を深さ方向に k 等分します (割り切れなければエラーとなります)。準備として、まずは 2 次元配列を numpy.dstack() で 3 つ重ねてみます。
# NUMPY_DSPLIT
# In[1]
import numpy as np
a = np.zeros((3, 3))
b = np.ones((3, 3))
c = np.full((3, 3), 2)
# 配列a,b,cを深さ方向に連結
stack_abc = np.dstack((a, b, c))
print(stack_abc)今度は逆に numpy.dsplit() を使って、stack_abc を深さ方向に 3 等分してみます。
# In[2]
# stack_abcを深さ方向に3等分
d, e, f = np.dsplit(stack_abc, 3)変数 d に格納された配列を確認してみます。
# In[3]
print("配列d：\n{}\n".format(d))
print("配列dの形状：\n{}".format(d.shape))
'''
配列d：
[[[0.]
[0.]
[0.]]
[[0.]
[0.]
[0.]]
[[0.]
[0.]
[0.]]]
配列dの形状：
(3, 3, 1)
'''numpy.dsplit() によって、3×3×1 の 3 次元配列にスライスされていることがわかります (配列 e, f についても確認してみてください)。重ね合わせる前の配列 a より次元が 1 つ増えていますが、numpy.dsplit() の戻り値は必ず 3 次元配列となります。
第 2 引数には配列を切り分ける位置をシーケンスで指定することもできます。stack_abc を 2 つ重ねて深さ 6 の 3 次元配列を作ってみます。
# In[4]
# stack_abcを2つ重ねる
stack_abcabc = np.dstack((stack_abc, stack_abc))
print(stack_abcabc)
'''
[[[0. 1. 2. 0. 1. 2.]
[0. 1. 2. 0. 1. 2.]
[0. 1. 2. 0. 1. 2.]]
[[0. 1. 2. 0. 1. 2.]
[0. 1. 2. 0. 1. 2.]
[0. 1. 2. 0. 1. 2.]]
[[0. 1. 2. 0. 1. 2.]
[0. 1. 2. 0. 1. 2.]
[0. 1. 2. 0. 1. 2.]]]
'''深さ方向に [1, 3] の位置で切り分けてみます (インデクス 0 と 1 の間、および 3 と 4 の間に切れ目を入れるイメージです)。
# In[5]
# stack_abcabcを深さの方向にインデクス1,3の位置でスライス
g, h, i = np.dsplit(stack_abcabc, [1, 3])配列 g の形状を確かめてみます。
# In[6]
print("配列g：\n{}\n".format(g))
print("配列gの形状：\n{}".format(g.shape))
'''
配列g：
[[[0.]
[0.]
[0.]]
[[0.]
[0.]
[0.]]
[[0.]
[0.]
[0.]]]
配列gの形状：
(3, 3, 1)
'''g は深さ 1 の 3 次元配列ですね。同様に h についても調べてみましょう。
# In[7]
print("配列h：\n{}\n".format(h))
print("配列hの形状：\n{}".format(h.shape))
'''
配列h：
[[[1. 2.]
[1. 2.]
[1. 2.]]
[[1. 2.]
[1. 2.]
[1. 2.]]
[[1. 2.]
[1. 2.]
[1. 2.]]]
配列hの形状：
(3, 3, 2)
'''h は深さ方向にインデクス 0 と 3 の間にある配列なので厚みは 2 となっています。