Numpy “où” avec plusieurs conditions

J'essaie d'ajouter une nouvelle colonne "energy_class" à un dataframe "df_energy", qui contient la chaîne de caractères "haut" si le "consumption_energy" valeur > 400, "moyen" si le "consumption_energy" la valeur est comprise entre 200 et 400, et le "bas" si le "consumption_energy" la valeur est de moins de 200.
J'essaie d'utiliser np.d'où numpy, mais je vois que numpy.where(condition[, x, y]) traiter seulement deux condition de ne pas 3 comme dans mon cas.

Une idée pour m'aider s'il vous plaît?

Je vous remercie à l'avance

OriginalL'auteur Poisson | 2016-08-23

  1. 20

    Vous pouvez utiliser un ternaire:

    np.where(consumption_energy > 400, 'high', 
         (np.where(consumption_energy < 200, 'low', 'medium')))

    OriginalL'auteur Alexander

  2. 12

    Je voudrais utiliser le cut() méthode ici, ce qui va générer très efficace et d'économie de mémoire category dtype:

    In [124]: df
Out[124]:
   consumption_energy
0                 459
1                 416
2                 186
3                 250
4                 411
5                 210
6                 343
7                 328
8                 208
9                 223

In [125]: pd.cut(df.consumption_energy, [0, 200, 400, np.inf], labels=['low','medium','high'])
Out[125]:
0      high
1      high
2       low
3    medium
4      high
5    medium
6    medium
7    medium
8    medium
9    medium
Name: consumption_energy, dtype: category
Categories (3, object): [low < medium < high]
    Hey max, dans cette méthode est de 200 inclus dans la moyenne ou faible?
    il devrait tomber sous “moyenne de la catégorie “ parce que tous les bords droit d'intervalles sont inclus par défaut
    Merci mon homme, désolé pour les commentaires sur un ancien fil!
    en fait, je me trompe - il devrait tomber sous le “bas” de la catégorie que c'est un bord droit du premier intervalle

    OriginalL'auteur MaxU

  3. 10

    Essayez ceci:
    En utilisant le programme d'installation à partir de @Maxu

    col         = 'consumption_energy'
conditions  = [ df2[col] >= 400, (df2[col] < 400) & (df2[col]> 200), df2[col] <= 200 ]
choices     = [ "high", 'medium', 'low' ]

df2["energy_class"] = np.select(conditions, choices, default=np.nan)


  consumption_energy energy_class
0                 459         high
1                 416         high
2                 186          low
3                 250       medium
4                 411         high
5                 210       medium
6                 343       medium
7                 328       medium
8                 208       medium
9                 223       medium
    C'est fantastique. Comme une note, cela fonctionne comme la plupart des if / elif / else fonctions que si le premier et la seconde conditions sont remplies, la première s'applique et non à la seconde. Merci @Merlin

    OriginalL'auteur Merlin

  4. 7

    J'aime pour avoir un code propre. C'est pourquoi je préfère np.vectorize pour de telles tâches.

    def conditions(x):
    if x > 400:
        return "High"
    elif x > 200:
        return "Medium"
    else:
        return "Low"

func = np.vectorize(conditions)
energy_class = func(df_energy["consumption_energy"])

    Puis il suffit d'ajouter un tableau numpy comme une colonne dans votre dataframe à l'aide de:

    df_energy["energy_class"] = energy_class

    L'avantage de cette approche est que si vous souhaitez ajouter plus compliqué contraintes à une colonne, il peut être fait facilement.
    Espérons que cela aide.

    OriginalL'auteur

  5. 0

    Je seconde à l'aide de np.vectoriser. Il est beaucoup plus rapide que les np.où et aussi plus propre code sage. Vous pouvez certainement dire que la vitesse avec de grands ensembles de données. Vous pouvez utiliser un dictionnaire format pour votre conditionnelles ainsi que la sortie de ces conditions. 

    # Vectorizing with numpy 
row_dic = {'Condition1':'high',
          'Condition2':'medium',
          'Condition3':'low',
          'Condition4':'lowest'}

def Conditions(dfSeries_element,dictionary):
    '''
    dfSeries_element is an element from df_series 
    dictionary: is the dictionary of your conditions with their outcome
    '''
    if dfSeries_element in dictionary.keys():
        return dictionary[dfSeries]

def VectorizeConditions():
    func = np.vectorize(Conditions)
    result_vector = func(df['Series'],row_dic)
    df['new_Series'] = result_vector

    # running the below function will apply multi conditional formatting to your df
VectorizeConditions()

    OriginalL'auteur wpmoradi