Python: Affectation de # valeurs dans une liste à des cases, en arrondissant

Question

Je veux une fonction qui peut prendre une série et un ensemble de cases, et arrondir à la poubelle la plus proche. Par exemple:

my_series = [ 1, 1.5, 2, 2.3, 2.6, 3] 
def my_function(my_series, bins): 
    ... 

my_function(my_series, bins=[1,2,3]) 
> [1,2,2,3,3,3] 

Cela semble être très proche de ce que Numpy's Digitize est destiné à faire, mais il produit les mauvaises valeurs (astérisques pour de mauvaises valeurs):

np.digitize(my_series, bins= [1,2,3], right=False) 
> [1, 1*, 2, 2*, 2*, 3] 

La raison pour laquelle il est faux est clairement de la documentation:

Chaque indice i revenu est tel que bacs [i-1] < = x < bacs [i] si bin s est en augmentation monotone, ou les cases [i-1]> x> = cases [i] si les cases décroissent de façon monotone. Si les valeurs dans x sont au-delà des limites des cases , 0 ou len (cases) est renvoyé comme approprié. Si le droit est vrai, alors la case de droite est fermée de telle sorte que l'index i est tel que les cases [i-1] < x < = les cases [i] ou les cases [i-1]> = x> les cases [i] `` si les casiers sont respectivement monotones ou décroissants.

Je sorte de se rapprocher de ce que je veux si je rentre dans les valeurs décroissantes et « droite » à vrai ...

np.digitize(my_series, bins= [3,2,1], right=True) 
> [3, 2, 2, 1, 1, 1] 

mais je vais devoir penser à un manière d'inverser de façon méthodique l'attribution de numéro la plus faible (1) avec l'attribution de numéro la plus élevée (3). C'est simple quand il n'y a que 3 bacs, mais ça va devenir plus poilu quand le nombre de bacs sera plus long ... il doit y avoir une façon plus élégante de faire tout ça.

Answer 1

Nous pouvons simplement utiliser np.digitize avec son right option définie comme True pour obtenir les indices, puis pour extraire les éléments correspondants bins, introduire np.take, comme si -

np.take(bins,np.digitize(a,bins,right=True)) 

Answer 2

Je crois que np.searchsorted va faire ce que vous voulez:

Trouver les indices dans un tableau trié a de telle sorte que, si les éléments v ont été insérés avant les indices correspondants, l'ordre d'un serait être conservé.

In [1]: my_series = [1, 1.5, 2, 2.3, 2.6, 3] 

In [2]: bins = [1,2,3] 

In [3]: import numpy as np 

In [4]: [bins[k] for k in np.searchsorted(bins, my_series)] 
Out[4]: [1, 2, 2, 3, 3, 3] 

(Au numpy 1.10.0, digitize est mis en œuvre en termes de searchsorted.)

Answer 3

Une autre façon serait:

In [25]: def find_nearest(array,value): 
    ...:  idx = (np.abs(array-np.ceil(value))).argmin() 
    ...:  return array[idx] 
    ...: 

In [26]: my_series = np.array([ 1, 1.5, 2, 2.3, 2.6, 3]) 

In [27]: bins = [1, 2, 3] 

In [28]: [find_nearest(bins, x) for x in my_series] 
Out[28]: [1, 2, 2, 3, 3, 3]