numpy.r_

numpy.r_ = <numpy.lib.index_tricks.CClass object>

Объект r_ преобразует срез в строку, а последовательности соединяет вдоль первой оси.

Так же как и c_ объект r_ является очень простым и в тоже время очень мощьным инструментом для создания и объединения массивов.

Смотрите так же:
c_, s_, concatenate, vstack, hstack


Примеры

Указанные массивы будут соединены вдоль первой оси:

>>> import numpy as np
>>> 
>>> np.r_[[1, 2, 3], [3, 2, 1]]
array([1, 2, 3, 3, 2, 1])

Скаляр вернет одномерный массив:

>>> np.r_[5]
array([5])

Последовательность скаляров будет объединена в одномерный массив:

>>> np.r_[5, 5, 5, 5]
array([5, 5, 5, 5], dtype=int32)

Последовательность массивов и скаляров так же будет объединена в одномерный массив:

>>> np.r_[5, [0, 0], 5, 5, [0, 0], 5]
array([5, 0, 0, 5, 5, 0, 0, 5])

Индексное выражение вернет одномерный массив:

>>> #  от 1 до 10:
... np.r_[1:10]
array([1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> 
>>> #  от 1 до 20 с шагом 2:
... np.r_[1:20:2]
array([ 1,  3,  5,  7,  9, 11, 13, 15, 17, 19])

Если в качестве шага в индексном выражении указать целую мнимую часть комплексного числа, например: 0:1:6j, то оно будет интерпретировано как последовательность 6 равноотстоящих точек в интервале [0:1]. Такое поведение очень похоже, на функцию linspace():

>>> np.r_[0:1:6j]
array([0. , 0.2, 0.4, 0.6, 0.8, 1. ])
>>> 
>>> x = np.r_[-np.pi : np.pi : 300j]
>>> x
array([-3.14159265, -3.12057866, -3.09956466, ...,  3.09956466,
        3.12057866,  3.14159265])

Массивы, срезы и скаляры могут быть указаны вместе:

>>> a = np.array([1, 2])
>>> 
>>> y = np.r_[9, a, 1:3, 1:4:2, 0:1:3j, [-1]*2]
>>> 
>>> print(np.array2string(y, separator = ', ', threshold = 100))
[ 9. ,  1. ,  2. ,  1. ,  2. ,  1. ,  3. ,  0. ,  0.5,  1. , -1. , -1. ]

Заметьте, что тип данных результирующего массива приводится к наиболее общему типу его элементов.

Двумерные и многомерные массивы соединяются вдоль первой оси:

>>> a = np.ones((4, 4))
>>> b = np.zeros((2, 3))
>>> 
>>> a = np.zeros((2, 3))
>>> b = np.ones((2, 3))
>>> 
>>> a
array([[0., 0., 0.],
       [0., 0., 0.]])
>>> b
array([[1., 1., 1.],
       [1., 1., 1.]])
>>> 
>>> k = np.r_[a, b]
>>> k
array([[0., 0., 0.],
       [0., 0., 0.],
       [1., 1., 1.],
       [1., 1., 1.]])
>>> 
>>> a.shape, b.shape, k.shape
((2, 3), (2, 3), (4, 3))
>>> 
>>> 
>>> c = np.ones((2, 3, 1))
>>> c
array([[[1.],
        [1.],
        [1.]],

       [[1.],
        [1.],
        [1.]]])
>>> 
>>> d = np.zeros((2, 3, 1))
>>> d
array([[[0.],
        [0.],
        [0.]],

       [[0.],
        [0.],
        [0.]]])
>>> 
>>> m = np.r_[c, d]
>>> m
array([[[1.],
        [1.],
        [1.]],

       [[1.],
        [1.],
        [1.]],

       [[0.],
        [0.],
        [0.]],

       [[0.],
        [0.],
        [0.]]])
>>> 
>>> c.shape, d.shape, m.shape
((2, 3, 1), (2, 3, 1), (4, 3, 1))

Однако, ось вдоль которой происходит соединение массивов можно изменить, указав новую в виде числа в строке. Но следует помнить, что исходные массивы сами ддолжны обладать необходимым количеством измерений, наприме, одномерные массивы можно соединить только вдоль первой (нулевой) оси:

>>> a = np.r_[1:4]
>>> b = np.r_[4:7]
>>> 
>>> np.r_['0', a, b]
array([1, 2, 3, 4, 5, 6])
>>> 
>>> np.r_['1', a, b]    #  приведет к ошибке
>>> 
>>> 
>>> a = np.zeros((2, 3))
>>> b = np.ones((2, 3))
>>> 
>>> np.r_['0', a, b]
array([[0., 0., 0.],
       [0., 0., 0.],
       [1., 1., 1.],
       [1., 1., 1.]])
>>> 
>>> np.r_['1', a, b]
array([[0., 0., 0., 1., 1., 1.],
       [0., 0., 0., 1., 1., 1.]])
>>> 
>>> np.r_['2', a, b]    #  так же приведет к ошибке

Тем не менее, мы можем привести указанные массивы к необходимому количеству измерений с помощью второго целого числа в строке, при этом объединение будет так же происходить вдоль оси указанной в первом числе:

>>> a
array([1, 2, 3])
>>> b
array([4, 5, 6])
>>> 
>>> np.r_['0, 2', a, b]
array([[1, 2, 3],
       [4, 5, 6]])
>>> 
>>> np.r_['1, 2', a, b]
array([[1, 2, 3, 4, 5, 6]])
>>> 
>>> 
>>> np.r_['0, 3', a, b]
array([[[1, 2, 3]],

       [[4, 5, 6]]])
>>> 
>>> np.r_['1, 3', a, b]
array([[[1, 2, 3],
        [4, 5, 6]]])
>>> 
>>> np.r_['2, 3', a, b]
array([[[1, 2, 3, 4, 5, 6]]])

Но и даже на этом трюки не заканчиваются. Если второе число указывает к какой размерности должны быть приведены массивы, то с помощью третьего числа мы можем указать в какое место формы должны быть помещены новые оси (их длина всегда будет равна 1). Рассмотрим на примере одного массива. По умолчанию, если третье число не указано, то новая ось размещается вначале формы:

>>> a = np.array([1, 2, 3])
>>> a.shape
(3,)
>>> 
>>> np.r_['0, 2', a]
array([[1, 2, 3]])
>>> np.r_['0, 2', a].shape
(1, 3)
>>> 
>>> np.r_['0, 2', a], np.r_['0, 2', a].shape
(array([[1, 2, 3]]), (1, 3))
>>> 
>>> np.r_['0, 2, -1', a], np.r_['0, 2, -1', a].shape
(array([[1, 2, 3]]), (1, 3))
>>> 
>>> np.r_['0, 2, 0', a], np.r_['0, 2, 0', a].shape
(array([[1],
       [2],
       [3]]), (3, 1))
>>> 
>>> np.r_['0, 2, 1', a], np.r_['0, 2, 1', a].shape
(array([[1, 2, 3]]), (1, 3))

Использование третьего числа, может изменить результат соединения массивов:

>>> a = [1, 2, 3]
>>> b = [4, 5, 6]
>>> 
>>> np.r_['0, 2', a, b]
array([[1, 2, 3],
       [4, 5, 6]])
>>> 
>>> np.r_['0, 2, 1', a, b]
array([[1, 2, 3],
       [4, 5, 6]])
>>> 
>>> np.r_['0, 2, 0', a, b]
array([[1],
       [2],
       [3],
       [4],
       [5],
       [6]])

Данная строковая дериктива может находиться только в начале и в единственном числе.

Еще одна строковая директива r или c приводит к созданию матриц:

>>> np.r_['r', a, b]    #  соединять как строки
matrix([[1, 2, 3, 4, 5, 6]])
>>> 
>>> np.r_['c', a, b]    #  соединять как столбцы
matrix([[1],
        [2],
        [3],
        [4],
        [5],
        [6]])

Но это действует только для одномерных массивов, двумерные будут стыкованы только по первой оси:

>>> a = np.zeros((2, 3))
>>> b = np.ones((2, 3))
>>> 
>>> a
array([[0., 0., 0.],
       [0., 0., 0.]])
>>> 
>>> b
array([[1., 1., 1.],
       [1., 1., 1.]])
>>> 
>>> np.r_['r', a, b]
matrix([[0., 0., 0.],
        [0., 0., 0.],
        [1., 1., 1.],
        [1., 1., 1.]])
>>> 
>>> np.r_['c', a, b]
matrix([[0., 0., 0.],
        [0., 0., 0.],
        [1., 1., 1.],
        [1., 1., 1.]])