Pandas bedingte Erstellung einer Serien- / Datenrahmenspalte

Ich habe einen Datenrahmen in der folgenden Richtung:

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

Ich möchte dem Datenrahmen eine weitere Spalte mit der gleichen Länge wie der Datenrahmen (= gleiche Anzahl von Datensätzen / Zeilen) hinzufügen (oder eine Reihe generieren), die eine Farbe grün setzt, wenn Set = 'Z' und 'rot', wenn Set = andernfalls .

Was ist der beste Weg, dies zu tun?

Wenn Sie nur zwei Möglichkeiten zur Auswahl haben:

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

Zum Beispiel,

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)

ergibt

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

Wenn Sie mehr als zwei Bedingungen haben, verwenden Sie np.select . Zum Beispiel, wenn Sie wollen , colorsein

• yellow wann (df['Set'] == 'Z') & (df['Type'] == 'A')
• Andernfalls blue wenn(df['Set'] == 'Z') & (df['Type'] == 'B')
• Andernfalls purple wenn(df['Type'] == 'B')
• Andernfalls black ,

dann benutze

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)

was ergibt

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

Das Listenverständnis ist eine weitere Möglichkeit, eine weitere Spalte bedingt zu erstellen. Wenn Sie wie in Ihrem Beispiel mit Objekt-dtypes in Spalten arbeiten, übertreffen Listenverständnisse normalerweise die meisten anderen Methoden.

Beispiel Listenverständnis:

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

% timeit Tests:

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

Ein anderer Weg, wie dies erreicht werden könnte, ist

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

Hier ist noch eine andere Möglichkeit, diese Katze zu häuten, indem Sie mithilfe eines Wörterbuchs neue Werte auf die Schlüssel in der Liste abbilden:

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,))

Wie sieht es aus:

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

Dieser Ansatz kann sehr leistungsfähig sein, wenn Sie viele haben ifelse Anweisungen vom Typ geben müssen (dh viele eindeutige Werte, die ersetzt werden müssen).

Und das können Sie natürlich immer tun:

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

Dieser Ansatz ist jedoch mehr als dreimal so langsam wie der apply auf meinem Computer Ansatz von oben.

Und Sie können dies auch tun, indem Sie dict.get:

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

Das Folgende ist langsamer als die hier zeitgesteuerten Ansätze , aber wir können die zusätzliche Spalte basierend auf dem Inhalt von mehr als einer Spalte berechnen, und es können mehr als zwei Werte für die zusätzliche Spalte berechnet werden.

Einfaches Beispiel mit nur der Spalte "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

Beispiel mit mehr Farben und mehr Spalten berücksichtigt:

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

Bearbeiten (21/06/2019): Verwenden von Plydata

Es ist auch möglich, Plydata zu verwenden, um diese Art von Dingen auszuführen (dies scheint jedoch noch langsamer zu sein als die Verwendung von assignund apply).

from plydata import define, if_else

Einfach 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

Verschachtelt 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

Vielleicht war dies mit neueren Updates von Pandas möglich, aber ich denke, das Folgende ist die kürzeste und vielleicht beste Antwort auf die Frage, die es bisher gab. Du kannst den ... benutzen.loc Methode verwenden und je nach Bedarf eine oder mehrere Bedingungen verwenden.

Code-Zusammenfassung:

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"

Erläuterung:

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

Fügen Sie eine 'Farb'-Spalte hinzu und setzen Sie alle Werte auf "rot".

df['Color'] = "red"

Wenden Sie Ihre einzige Bedingung an:

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

oder mehrere Bedingungen, wenn Sie möchten:

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

Sie können die logischen Operatoren und die bedingte Auswahl von Pandas hier nachlesen: Logische Operatoren für die boolesche Indizierung in Pandas

Ein Liner mit .apply()Methode ist wie folgt:

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

Danach dfsieht der Datenrahmen folgendermaßen aus:

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

Wenn Sie mit massiven Daten arbeiten, ist ein gespeicherter Ansatz am besten:

# 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)

Dieser Ansatz ist am schnellsten, wenn Sie viele wiederholte Werte haben. Meine allgemeine Faustregel lautet, sich zu merken, wann: data_size> 10**4& n_distinct<data_size/4

Ex Merken Sie sich in einem Fall 10.000 Zeilen mit 2.500 oder weniger unterschiedlichen Werten.