Pandas création conditionnelle d'une colonne série / trame de données

J'ai une trame de données dans le sens de ce qui suit:

    Type       Set
1    A          Z
2    B          Z           
3    B          X
4    C          Y

Je veux ajouter une autre colonne à la trame de données (ou générer une série) de la même longueur que la trame de données (= nombre égal d'enregistrements / lignes) qui définit une couleur verte si Set = 'Z' et 'rouge' si Set = sinon .

Quelle est la meilleure façon de procéder?

Si vous n'avez que deux choix:

df['color'] = np.where(df['Set']=='Z', 'green', 'red')

Par exemple,

import pandas as pd
import numpy as np

df = pd.DataFrame({'Type':list('ABBC'), 'Set':list('ZZXY')})
df['color'] = np.where(df['Set']=='Z', 'green', 'red')
print(df)

les rendements

  Set Type  color
0   Z    A  green
1   Z    B  green
2   X    B    red
3   Y    C    red

Si vous avez plus de deux conditions, utiliseznp.select . Par exemple, si vous voulez colorêtre

• yellow quand (df['Set'] == 'Z') & (df['Type'] == 'A')
• sinon bluequand(df['Set'] == 'Z') & (df['Type'] == 'B')
• sinon purplequand(df['Type'] == 'B')
• sinon black,

puis utilisez

df = pd.DataFrame({'Type':list('ABBC'), 'Set':list('ZZXY')})
conditions = [
    (df['Set'] == 'Z') & (df['Type'] == 'A'),
    (df['Set'] == 'Z') & (df['Type'] == 'B'),
    (df['Type'] == 'B')]
choices = ['yellow', 'blue', 'purple']
df['color'] = np.select(conditions, choices, default='black')
print(df)

qui donne

  Set Type   color
0   Z    A  yellow
1   Z    B    blue
2   X    B  purple
3   Y    C   black

La compréhension des listes est une autre façon de créer une autre colonne de manière conditionnelle. Si vous travaillez avec des dtypes d'objet dans des colonnes, comme dans votre exemple, les compréhensions de liste surpassent généralement la plupart des autres méthodes.

Exemple de compréhension de liste:

df['color'] = ['red' if x == 'Z' else 'green' for x in df['Set']]

% tests timeit:

import pandas as pd
import numpy as np

df = pd.DataFrame({'Type':list('ABBC'), 'Set':list('ZZXY')})
%timeit df['color'] = ['red' if x == 'Z' else 'green' for x in df['Set']]
%timeit df['color'] = np.where(df['Set']=='Z', 'green', 'red')
%timeit df['color'] = df.Set.map( lambda x: 'red' if x == 'Z' else 'green')

1000 loops, best of 3: 239 µs per loop
1000 loops, best of 3: 523 µs per loop
1000 loops, best of 3: 263 µs per loop

Un autre moyen d’y parvenir est de

df['color'] = df.Set.map( lambda x: 'red' if x == 'Z' else 'green')

Voici encore une autre façon d'habiller ce chat, en utilisant un dictionnaire pour mapper de nouvelles valeurs sur les clés de la liste:

def map_values(row, values_dict):
    return values_dict[row]

values_dict = {'A': 1, 'B': 2, 'C': 3, 'D': 4}

df = pd.DataFrame({'INDICATOR': ['A', 'B', 'C', 'D'], 'VALUE': [10, 9, 8, 7]})

df['NEW_VALUE'] = df['INDICATOR'].apply(map_values, args = (values_dict,))

À quoi ça ressemble:

df
Out[2]: 
  INDICATOR  VALUE  NEW_VALUE
0         A     10          1
1         B      9          2
2         C      8          3
3         D      7          4

Cette approche peut être très puissante lorsque vous avez de nombreuses ifelseinstructions de type à effectuer (c'est-à-dire de nombreuses valeurs uniques à remplacer).

Et bien sûr, vous pouvez toujours faire ceci:

df['NEW_VALUE'] = df['INDICATOR'].map(values_dict)

Mais cette approche est plus de trois fois plus lente que l' applyapproche d'en haut, sur ma machine.

Et vous pouvez également le faire en utilisant dict.get:

df['NEW_VALUE'] = [values_dict.get(v, None) for v in df['INDICATOR']]

Ce qui suit est plus lent que les approches chronométrées ici , mais nous pouvons calculer la colonne supplémentaire en fonction du contenu de plus d'une colonne, et plus de deux valeurs peuvent être calculées pour la colonne supplémentaire.

Exemple simple utilisant uniquement la colonne "Set":

def set_color(row):
    if row["Set"] == "Z":
        return "red"
    else:
        return "green"

df = df.assign(color=df.apply(set_color, axis=1))

print(df)

  Set Type  color
0   Z    A    red
1   Z    B    red
2   X    B  green
3   Y    C  green

Exemple avec plus de couleurs et plus de colonnes prises en compte:

def set_color(row):
    if row["Set"] == "Z":
        return "red"
    elif row["Type"] == "C":
        return "blue"
    else:
        return "green"

df = df.assign(color=df.apply(set_color, axis=1))

print(df)

  Set Type  color
0   Z    A    red
1   Z    B    red
2   X    B  green
3   Y    C   blue

Edit (21/06/2019): Utilisation de plydata

Il est également possible d'utiliser plydata pour faire ce genre de choses (cela semble encore plus lent que d'utiliser assignet apply, cependant).

from plydata import define, if_else

Simple if_else:

df = define(df, color=if_else('Set=="Z"', '"red"', '"green"'))

print(df)

  Set Type  color
0   Z    A    red
1   Z    B    red
2   X    B  green
3   Y    C  green

Imbriqué if_else:

df = define(df, color=if_else(
    'Set=="Z"',
    '"red"',
    if_else('Type=="C"', '"green"', '"blue"')))

print(df)                            

  Set Type  color
0   Z    A    red
1   Z    B    red
2   X    B   blue
3   Y    C  green

Peut-être que cela a été possible avec les nouvelles mises à jour de Pandas, mais je pense que ce qui suit est la réponse la plus courte et peut-être la meilleure pour l'instant. Vous pouvez utiliser le.loc méthode et utiliser une ou plusieurs conditions selon vos besoins.

Résumé du code:

df=pd.DataFrame(dict(Type='A B B C'.split(), Set='Z Z X Y'.split()))
df['Color'] = "red"
df.loc[(df['Set']=="Z"), 'Color'] = "green"

#practice!
df.loc[(df['Set']=="Z")&(df['Type']=="B")|(df['Type']=="C"), 'Color'] = "purple"

Explication:

df=pd.DataFrame(dict(Type='A B B C'.split(), Set='Z Z X Y'.split()))

# df so far: 
  Type Set  
0    A   Z 
1    B   Z 
2    B   X 
3    C   Y

ajouter une colonne «couleur» et définir toutes les valeurs sur «rouge»

df['Color'] = "red"

Appliquez votre seule condition:

df.loc[(df['Set']=="Z"), 'Color'] = "green"


# df: 
  Type Set  Color
0    A   Z  green
1    B   Z  green
2    B   X    red
3    C   Y    red

ou plusieurs conditions si vous le souhaitez:

df.loc[(df['Set']=="Z")&(df['Type']=="B")|(df['Type']=="C"), 'Color'] = "purple"

Vous pouvez lire sur les opérateurs logiques Pandas et la sélection conditionnelle ici: Opérateurs logiques pour l'indexation booléenne dans Pandas

Un liner avec .apply()méthode suit:

df['color'] = df['Set'].apply(lambda set_: 'green' if set_=='Z' else 'red')

Après cela, dfle bloc de données ressemble à ceci:

>>> print(df)
  Type Set  color
0    A   Z  green
1    B   Z  green
2    B   X    red
3    C   Y    red

Si vous travaillez avec des données massives, une approche mémorisée serait la meilleure:

# First create a dictionary of manually stored values
color_dict = {'Z':'red'}

# Second, build a dictionary of "other" values
color_dict_other = {x:'green' for x in df['Set'].unique() if x not in color_dict.keys()}

# Next, merge the two
color_dict.update(color_dict_other)

# Finally, map it to your column
df['color'] = df['Set'].map(color_dict)

Cette approche sera plus rapide lorsque vous avez plusieurs valeurs répétées. Ma règle générale est de mémoriser quand: data_size> 10**4& n_distinct<data_size/4

Ex Memoize dans un cas 10 000 lignes avec 2 500 ou moins de valeurs distinctes.