Reasignar valores en la columna de pandas con un dict

Tengo un diccionario que se ve así: di = {1: "A", 2: "B"}

Me gustaría aplicarlo a la columna "col1" de un marco de datos similar a:

     col1   col2
0       w      a
1       1      2
2       2    NaN

Llegar:

     col1   col2
0       w      a
1       A      2
2       B    NaN

¿Cómo puedo hacer esto mejor? Por alguna razón, los términos de Google relacionados con esto solo me muestran enlaces sobre cómo hacer columnas a partir de dictados y viceversa: - /

Puedes usar .replace. Por ejemplo:

>>> df = pd.DataFrame({'col2': {0: 'a', 1: 2, 2: np.nan}, 'col1': {0: 'w', 1: 1, 2: 2}})
>>> di = {1: "A", 2: "B"}
>>> df
  col1 col2
0    w    a
1    1    2
2    2  NaN
>>> df.replace({"col1": di})
  col1 col2
0    w    a
1    A    2
2    B  NaN

o directamente en el Series, es decir df["col1"].replace(di, inplace=True).

map puede ser mucho más rápido que replace

Si su diccionario tiene más de un par de claves, el uso mappuede ser mucho más rápido que replace. Hay dos versiones de este enfoque, dependiendo de si su diccionario mapea exhaustivamente todos los valores posibles (y también si desea que las no coincidencias conserven sus valores o se conviertan en NaN):

Mapeo exhaustivo

En este caso, el formulario es muy simple:

df['col1'].map(di)       # note: if the dictionary does not exhaustively map all
                         # entries then non-matched entries are changed to NaNs

Aunque mapmás comúnmente toma una función como argumento, también puede tomar un diccionario o una serie: Documentación para Pandas.series.map

Mapeo no exhaustivo

Si tiene un mapeo no exhaustivo y desea retener las variables existentes para no coincidencias, puede agregar fillna:

df['col1'].map(di).fillna(df['col1'])

como en la respuesta de @ jpp aquí: Reemplazar valores en una serie de pandas a través del diccionario de manera eficiente

Puntos de referencia

Usando los siguientes datos con pandas versión 0.23.1:

di = {1: "A", 2: "B", 3: "C", 4: "D", 5: "E", 6: "F", 7: "G", 8: "H" }
df = pd.DataFrame({ 'col1': np.random.choice( range(1,9), 100000 ) })

y probando con %timeit, parece que mapes aproximadamente 10 veces más rápido que replace.

Tenga en cuenta que su aceleración mapvariará con sus datos. La mayor aceleración parece ser con grandes diccionarios y reemplazos exhaustivos. Consulte la respuesta @jpp (vinculada anteriormente) para obtener puntos de referencia y debates más extensos.

Hay un poco de ambigüedad en su pregunta. Hay al menos tres interpretaciones:

1. las claves se direfieren a valores de índice
2. las claves se direfieren a df['col1']valores
3. las claves se direfieren a ubicaciones de índice (no es la pregunta del OP, pero son divertidas).

A continuación hay una solución para cada caso.

Caso 1: Si las claves de diestán destinadas a hacer referencia a valores de índice, entonces podría usar el updatemétodo:

df['col1'].update(pd.Series(di))

Por ejemplo,

import pandas as pd
import numpy as np

df = pd.DataFrame({'col1':['w', 10, 20],
                   'col2': ['a', 30, np.nan]},
                  index=[1,2,0])
#   col1 col2
# 1    w    a
# 2   10   30
# 0   20  NaN

di = {0: "A", 2: "B"}

# The value at the 0-index is mapped to 'A', the value at the 2-index is mapped to 'B'
df['col1'].update(pd.Series(di))
print(df)

rendimientos

  col1 col2
1    w    a
2    B   30
0    A  NaN

He modificado los valores de tu publicación original para que quede más claro lo que updateestá haciendo. Observe cómo las claves dise asocian con valores de índice. El orden de los valores del índice, es decir, las ubicaciones del índice , no importa.

Caso 2: Si las claves se direfieren a df['col1']valores, entonces @DanAllan y @DSM muestran cómo lograr esto con replace:

import pandas as pd
import numpy as np

df = pd.DataFrame({'col1':['w', 10, 20],
                   'col2': ['a', 30, np.nan]},
                  index=[1,2,0])
print(df)
#   col1 col2
# 1    w    a
# 2   10   30
# 0   20  NaN

di = {10: "A", 20: "B"}

# The values 10 and 20 are replaced by 'A' and 'B'
df['col1'].replace(di, inplace=True)
print(df)

rendimientos

  col1 col2
1    w    a
2    A   30
0    B  NaN

Tenga en cuenta cómo, en este caso, dise modificaron las claves para que coincidan con los valores de df['col1'].

Caso 3: si las claves se direfieren a ubicaciones de índice, entonces podría usar

df['col1'].put(di.keys(), di.values())

ya que

df = pd.DataFrame({'col1':['w', 10, 20],
                   'col2': ['a', 30, np.nan]},
                  index=[1,2,0])
di = {0: "A", 2: "B"}

# The values at the 0 and 2 index locations are replaced by 'A' and 'B'
df['col1'].put(di.keys(), di.values())
print(df)

rendimientos

  col1 col2
1    A    a
2   10   30
0    B  NaN

Aquí, la primera y la tercera fila fueron alteradas, porque las claves en dison 0y 2, que con la indexación basada en 0 de Python se refieren a las ubicaciones primera y tercera.

Agregando a esta pregunta si alguna vez tiene más de una columna para reasignar en un marco de datos:

def remap(data,dict_labels):
    """
    This function take in a dictionnary of labels : dict_labels 
    and replace the values (previously labelencode) into the string.

    ex: dict_labels = {{'col1':{1:'A',2:'B'}}

    """
    for field,values in dict_labels.items():
        print("I am remapping %s"%field)
        data.replace({field:values},inplace=True)
    print("DONE")

    return data

Espero que pueda ser útil para alguien.

Salud

DSM tiene la respuesta aceptada, pero la codificación no parece funcionar para todos. Aquí hay uno que funciona con la versión actual de pandas (0.23.4 a partir de 8/2018):

import pandas as pd

df = pd.DataFrame({'col1': [1, 2, 2, 3, 1],
            'col2': ['negative', 'positive', 'neutral', 'neutral', 'positive']})

conversion_dict = {'negative': -1, 'neutral': 0, 'positive': 1}
df['converted_column'] = df['col2'].replace(conversion_dict)

print(df.head())

Verás que se ve así:

   col1      col2  converted_column
0     1  negative                -1
1     2  positive                 1
2     2   neutral                 0
3     3   neutral                 0
4     1  positive                 1

Los documentos para pandas.DataFrame.replace están aquí .

O hacer apply:

df['col1'].apply(lambda x: {1: "A", 2: "B"}.get(x,x))

Manifestación:

>>> df['col1']=df['col1'].apply(lambda x: {1: "A", 2: "B"}.get(x,x))
>>> df
  col1 col2
0    w    a
1    1    2
2    2  NaN
>>> 

Dado que mapes más rápido que reemplazar (solución de @ JohnE), debe tener cuidado con las asignaciones no exhaustivas en las que pretende asignar valores específicosNaN . El método adecuado en este caso requiere que usted sea maskla Serie cuando usted .fillna, de lo contrario, deshaga la asignación NaN.

import pandas as pd
import numpy as np

d = {'m': 'Male', 'f': 'Female', 'missing': np.NaN}
df = pd.DataFrame({'gender': ['m', 'f', 'missing', 'Male', 'U']})

keep_nan = [k for k,v in d.items() if pd.isnull(v)]
s = df['gender']

df['mapped'] = s.map(d).fillna(s.mask(s.isin(keep_nan)))

    gender  mapped
0        m    Male
1        f  Female
2  missing     NaN
3     Male    Male
4        U       U

Una buena solución completa que mantiene un mapa de las etiquetas de su clase:

labels = features['col1'].unique()
labels_dict = dict(zip(labels, range(len(labels))))
features = features.replace({"col1": labels_dict})

De esta manera, puede referirse en cualquier momento a la etiqueta de clase original de labels_dict.

Como una extensión de lo que ha propuesto Nico Coallier (se aplica a varias columnas) y U10-Forward (utilizando el estilo de aplicación de métodos), y resumiendo en una línea, propongo:

df.loc[:,['col1','col2']].transform(lambda x: x.map(lambda x: {1: "A", 2: "B"}.get(x,x))

El .transform()procesa cada columna como una serie. Al contrario de lo .apply()que pasa las columnas agregadas en un DataFrame.

En consecuencia, puede aplicar el método de la serie map().

Finalmente, y descubrí este comportamiento gracias a U10, puedes usar toda la serie en la expresión .get (). A menos que haya malinterpretado su comportamiento y procese secuencialmente la serie en lugar de ser torpe.
Las .get(x,x)cuentas de los valores que no mencionó en su diccionario de mapeo que de otra manera se considerarían como Nan por el .map()método

Un enfoque de pandas más nativo es aplicar una función de reemplazo como se muestra a continuación:

def multiple_replace(dict, text):
  # Create a regular expression  from the dictionary keys
  regex = re.compile("(%s)" % "|".join(map(re.escape, dict.keys())))

  # For each match, look-up corresponding value in dictionary
  return regex.sub(lambda mo: dict[mo.string[mo.start():mo.end()]], text) 

Una vez que haya definido la función, puede aplicarla a su marco de datos.

di = {1: "A", 2: "B"}
df['col1'] = df.apply(lambda row: multiple_replace(di, row['col1']), axis=1)