Les Pandas conditionnelle création d'une série/dataframe colonne

J'ai un dataframe le long des lignes de:

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

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

Quelle est la meilleure façon de le faire?

InformationsquelleAutor user7289 | 2013-11-11

591

Si vous n'avez que deux choix pour sélectionner à partir de:
```
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)
```
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, alors, utiliser np.sélectionnez. Par exemple, si vous voulez color être
- yellow quand (df['Set'] == 'Z') & (df['Type'] == 'A')
- sinon blue quand (df['Set'] == 'Z') & (df['Type'] == 'B')
- sinon purple quand (df['Type'] == 'B')
- sinon black,
ensuite utiliser
```
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
```
- ne fonctionne pas si j'ai posé deux conditions à l'intérieur de la clause where avec et
- Utilisation & au lieu de and. Voir stackoverflow.com/q/13589390/190597
- df['couleur'] = list(np.où(df['Jeu']=='Z', 'green', 'red')) va supprimer les pandas avertissement: Une valeur est d'essayer d'être mis sur une copie d'une tranche à partir d'un DataFrame. Essayez d'utiliser .loc[row_indexer,col_indexer] = valeur à la place
- "vert" et "rouge" peut être remplacée par la colonne de l'arithmétique. par exemple, df['foo'] = np.where(df['Set']=='Z', df['Set'], df['Type'].shift(1))
- n'np.où créer une nouvelle colonne? J'ai utilisé ce code et lorsque je fais un df.couleur.la tête() j'obtiens: 'numpy.ndarray' objet n'a pas d'attribut "tête"
- Avez-vous utiliser l'assignation df.color = np.where(...) pour créer une nouvelle colonne? Si vous n'avez, aucune nouvelle colonne a été créé. Au lieu de cela, df obtient un attribut nommé color qui est attribué à un tableau NumPy. En revanche, df['color'] = np.where(...) créer un nouveau DataFrame de la colonne. Puis df.color serait le retour de la Série df['color']. Cette asymétrie dans le comportement de df['color'] vs df.color est (je crois) une raison de ne jamais utiliser la syntaxe à point pour accéder à des colonnes. L'enregistrement d'un clavier n'est pas la peine de cette confusion mentale.
- Mais de toute façon, vous avez raison: np.where retourne toujours un tableau NumPy. Lorsque vous affectez des valeurs d'un DataFrame colonne à l'aide de df['color'] = ..., et, plus tard, le récupérer à l'aide de df['color'] que vous obtenez en retour une Série à la place.
- <rant>L'autre raison, je trouve la syntaxe à point désagréable est que vous ne pouvez pas accéder à des colonnes nommées last ou mean (pour n'en nommer que quelques-uns) le même que foo parce que last et mean sont des noms de méthode. df.last à juste titre renvoie à la méthode. Donc, si vous utilisez la syntaxe à point, vous devez avoir une mémoire parfaite hors tension tous les DataFrame noms d'attribut, sinon vous allez être constamment l'écriture du code bogué, pouvant écraser les méthodes avec les valeurs de la colonne....</rant> 🙂
- C'est une excellente solution. Je me demande cependant, est-il aussi un "pur" pandas solution plutôt que d'une solution qui mêle numpy et les pandas? Serait-ce l'utilisation df.Set.map(lambda x: ...) comme proposé dans la réponse par @cheekybastard ci-dessous?
- Les Pandas est construit sur le haut de NumPy, alors df['Set'].map(lambda x: ...) est "pure Pandas" je ne vois pas vraiment l'attraction en remplacement de np.where avec une fonction lambda. (Sous le capot, map a appeler le lambda fonction dans une boucle. Plusieurs appels à une fonction lambda ont tendance à être plus lent que 1 appel à np.where.) Pour moi, la partie vraiment intéressante de cheekbastard réponse est un pure Python compréhension de liste beats np.where pour une large gamme d'entrées.
- Est np.d'où aussi bien pour les situations où je veux vérifier si la valeur CONTIENT une chaîne de caractères, mais n'en a pas besoin pour le match (ce qui est le cas de l'OP de l'exemple)? Ou dois-je utiliser autre chose?
- Pour vérifier si une Pandas Série contient une chaîne de caractères, utilisez Series.str.contains.
- Belle réponse. Côté question -- PyCharm avertit à propos de "type Attendu 'Union[int, float, complexe, Aucun]' ai 'str' au lieu de" quand j'utilise np.select(conditions, choices, default="foo"). Pourquoi est-PyCharm avertissement si str est valide np.ScalarType?
- PyCharm essaie de deviner ce type de np.select sera de retour, mais fait une erreur dans ce cas. Je n'utilise pas PyCharm donc je ne peux pas tester, mais vous voudrez peut-être regarder ici pour des moyens pour supprimer cette alerte.
- J'ai essayer avec les conditions étant de savoir si une certaine valeur dans une ligne d'une colonne se retrouve également dans une certaine liste: conditions = [(mydata['column'] in someList), (mydata['column'] in someOtherList)] Cependant, alors j'obtiens l'erreur suivante: The truth value of a Series is ambiguous. Use a.empty, a.bool(), a.item(), a.any() or a.all(). Pourquoi ma solution ne fonctionne pas pour moi?
- Le langage Python cahier des charges demande que le in opérateur renvoie une seule valeur True/False. Je suppose que vous voulez (mydata['column'] in someList) pour retourner un tableau ressemblant à de Vraies/Fausses valeurs, une valeur booléenne pour chaque valeur de mydata['column']. Pour cela, utilisez le Series.isin méthode: conditions = [(mydata['column'].isin(someList)), (mydata['column'].isin(someOtherList))]
- Pour en savoir plus sur pourquoi les opérations qui essayez de mapper une Série entière à une seule valeur booléenne élever ValueError: The truth value of an array is ambiguous voir ce post.
- C'est une honte je ne peux pas upvote ce à plusieurs reprises. Un upvote ne semble pas suffisant.
- Tiens juste à ajouter le cas extrême: Si vous avez tellement de conditions que le codage avec np.sélectionnez() est intraitable, vous pouvez créer un fichier csv avec les colonnes: CONDITION_A, CONDITION_B,..., CONDITION_Z, CHOIX. Puis lecture de ce tableau comme un dataframe et merge sur la droite de votre original dataframe.
InformationsquelleAutor unutbu
100

Compréhension de liste est une autre façon de créer une autre colonne conditionnelle. Si vous travaillez avec un objet dtypes dans les colonnes, comme dans votre exemple, les interprétations de la liste typiquement surpasser la plupart des autres méthodes.

Exemple de liste de la compréhension: l'
```
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
```
- Notez que, avec beaucoup plus dataframes (pensez pd.DataFrame({'Type':list('ABBC')*100000, 'Set':list('ZZXY')*100000})-taille), numpy.where dépasse map, mais la compréhension de liste est roi (environ 50% plus rapide que numpy.where).
- La liste de compréhension de la méthode utilisée si l'état de besoin d'informations à partir de plusieurs colonnes? Je suis à la recherche de quelque chose comme cela (ce qui ne fonctionne pas): df['color'] = ['red' if (x['Set'] == 'Z') & (x['Type'] == 'B') else 'green' for x in df]
- Ajouter iterrows pour le dataframe, alors vous pouvez accéder à plusieurs colonnes par ligne: ["rouge" if (ligne['Jeu'] == 'Z') & (row['Type'] == 'B') else 'vert' pour l'indice, ligne en dans le df.iterrows()]
- Note cette belle solution ne fonctionnera pas si vous avez besoin de prendre des valeurs de remplacement d'une autre série dans le bloc de données, tels que df['color_type'] = np.where(df['Set']=='Z', 'green', df['Type'])
InformationsquelleAutor cheekybastard

Voici encore une autre façon de la peau, ce chat, à l'aide d'un dictionnaire à la carte, de nouvelles valeurs sur les touches dans 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 il 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 puissant lorsque vous avez de nombreux ifelse-type de déclarations à faire (c'est à dire de nombreuses valeurs uniques à remplacer).

Et bien sûr, vous pourriez faire ceci:

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

Mais cette approche est plus de trois fois plus lent que le apply approche à partir de ci-dessus, sur ma machine.

Et vous pourriez aussi le faire, à l'aide de dict.get:

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

J'aime cette réponse, car elle montre comment effectuer plusieurs remplacements de valeurs

InformationsquelleAutor blacksite

16

Une autre façon dont cela pourrait être réalisé est
```
df['color'] = df.Set.map( lambda x: 'red' if x == 'Z' else 'green')
```
InformationsquelleAutor acharuva

La suite est plus lent que les approches chronométré ici, mais nous pouvons calculer la colonne supplémentaire basé sur le contenu de plus d'une colonne, et plus de deux valeurs peuvent être calculées pour la colonne supplémentaire.

Exemple Simple en utilisant simplement le "Set" de la colonne:

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 pris 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

Modifier (21/06/2019): à l'Aide de plydata

Il est également possible d'utiliser plydata pour faire ce genre de choses (ce qui semble encore plus lent que d'utiliser assign et apply, tout de même).

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ée 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

InformationsquelleAutor bli

6

Peut-être que cela a été possible avec les nouvelles mises à jour de Panda, mais je pense que ce qui suit est le plus court et peut-être la meilleure réponse pour la question, jusqu'à présent. Vous pouvez utiliser une condition ou plusieurs en fonction de votre besoin.
```
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"
print(df)

# result: 
  Type Set  Color
0    A   Z  green
1    B   Z  green
2    B   X    red
3    C   Y    red
```
- Le meilleur jusqu'à présent. Vous pourriez probablement ajouter pour plus de conditions qui seraient le code df.loc[(df['Set']=="Z") & (df['Type']=="A"), 'Color'] = "green"
- Ce doit être la accepté de répondre. En fait idiomatiques et extensible.
InformationsquelleAutor HKRC

Un liner avec .apply() méthode est la suivante:

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

Après, df 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

InformationsquelleAutor Jaroslav Bezděk

Vous devez vous connecter pour publier un commentaire.