Qu'est-np.r_ faire (numpy)?

Code suivant est tiré de ici

sa = sort(a[i:i+block])
n += np.r_[sa.searchsorted(bins[:-1], 'left'),
           sa.searchsorted(bins[-1], 'right')]

Donc je sais que searchsorted trouve que la position dans le tableau sa où les éléments de bins devra être inséré dans le but de garder sa triés (left donne l'index gauche de l'endroit où nous insérer la valeur et right l'index droit).
Ce que je ne comprends pas, c'est l'ensemble de la construction autour d'elle signifie ce qui est

np.r_[array,array]

Qu'est-ce que np.r_?

Juste pour que la communauté puisse mieux se concentrer toutes les réponses, il n'y a rien dans le documentation pour np.r_ qui n'est pas clair?
Pour une raison quelconque, il n'a pas eu lieu pour moi de google pour numpy.r - stupide. Cela résout-il, merci.

OriginalL'auteur Philipp | 2015-06-02

  1. 23

    Ce qu'il fait est de la ligne sage fusion. Ce post a quelques belles exemple:

    >>>V = array([1,2,3,4,5,6 ])
>>>Y = array([7,8,9,10,11,12])
>>>np.r_[V[0:2],Y[0],V[3],Y[1:3],V[4:],Y[4:]]
array([ 1,  2,  7,  4,  8,  9,  5,  6, 11, 12])

    Lire plus à ce sujet dans le présent , et dans le la documentation de numpy.

    Pourquoi ne pas utiliser np.hstack?
    vous voudrez peut-être lire cette réponse...

    OriginalL'auteur omerbp

  2. 1
    numpy.r_[array[], array[]]

    Ce est utilisé pour concaténer n'importe quel nombre de tableau tranches le long de la ligne (premier axe). C'est un moyen simple de créer des tableaux numpy rapidement et efficacement.

    Par exemple, pour créer un tableau à partir de deux tableaux en sélectionnant les éléments de votre choix, nous allons devoir attribuer les tranches de valeurs à une nouvelle grandeur et utiliser la méthode de concaténation à se joindre à eux le long d'un axe. 

    >>> a = np.arange(9).reshape(3,3)
>>> b = np.arange(10,19).reshape(3,3)
>>> a
array([[0, 1, 2],
       [3, 4, 5],
       [6, 7, 8]])
>>> b
array([[10, 11, 12],
       [13, 14, 15],
       [16, 17, 18]])

    Je veux créer un nouveau tableau 2d, avec 2*2 éléments ([4,5,14,15]) alors, je vais le faire de suite, 

    >>> slided_a = a[1,1:3]
>>> sliced_b = b[1,1:3]
>>> new_array = np.concatenate((sliced_a, sliced_b), axis = 0)

    Que c'est clairement un moyen inefficace parce que, comme le nombre d'éléments qui doivent être inclus dans le nouveau tableau augmente, les variables temporaires qui sont affectés à stocker les tranches de valeurs augmente.

    C'est là que nous utilisons np.r_

    >>> c = np.r_[a[1,1:3],b[1,1:3]]
array([ 4,  5, 14, 15])

    De même, si nous voulons créer un nouveau tableau par l'empilement de tranches de valeurs dans le 2ème axe, nous pouvons utiliser np.c_

    >>> c = np.c_[a[1,1:3],b[1,1:3]]
array([[ 4, 14],
       [ 5, 15]])
    Vous dites que "le nombre d'éléments ...augmente, les variables temp ... augmente. C'est là que nous utilisons np.r_". Mais je ne vois pas la différence entre la ligne: np.concatenate((a[1,1:3], b[1,1:3]), axis = 0) et np.r_[a[1,1:3],b[1,1:3]]. Pourquoi à l'aide de np.r_ être plus efficace? Comme je sais l'avantage de np.r_ sur np.concatenate est que np.concatenate ne prend que des tableaux d'entrée.

    OriginalL'auteur vivek