Переопределить значения в столбце панд с помощью dict

У меня есть словарь, который выглядит так: di = {1: "A", 2: "B"}

Я хотел бы применить его к столбцу "col1" в кадре данных, похожем на:

     col1   col2
0       w      a
1       1      2
2       2    NaN

получить:

     col1   col2
0       w      a
1       A      2
2       B    NaN

Как я могу лучше всего это сделать? По некоторым причинам термины поиска в Google, относящиеся к этому, показывают только ссылки о том, как сделать столбцы из разногласий и наоборот: - /

Вы можете использовать .replace. Например:

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

или непосредственно на Series, то есть df["col1"].replace(di, inplace=True).

map может быть намного быстрее, чем replace

Если ваш словарь содержит более пары ключей, использование mapможет быть намного быстрее, чем replace. Существует две версии этого подхода, в зависимости от того, исчерпывающе ли сопоставляет ваш словарь все возможные значения (а также от того, хотите ли вы, чтобы несоответствия сохранили свои значения или были преобразованы в NaN):

Исчерпывающее картографирование

В этом случае форма очень проста:

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

Хотя mapчаще всего в качестве аргумента используется функция, в качестве альтернативы можно использовать словарь или серию: Документация для Pandas.series.map

Неисчерпывающее картографирование

Если у вас есть неполное сопоставление и вы хотите сохранить существующие переменные для несоответствий, вы можете добавить fillna:

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

как в ответе @ jpp здесь: Замените значения в ряду панд через словарь эффективно

Ориентиры

Используя следующие данные с версией панды 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 ) })

и тестирование %timeit, кажется, mapпримерно в 10 раз быстрее, чем replace.

Обратите внимание, что ваше ускорение mapзависит от ваших данных. Наибольшее ускорение, по-видимому, связано с большими словарями и исчерпывающими заменами. Посмотрите ответ @jpp (ссылка выше) для более подробных тестов и обсуждения.

В вашем вопросе есть немного неясности. Существует как минимум три две интерпретации:

1. ключи diотносятся к значениям индекса
2. ключи diотносятся к df['col1']значениям
3. ключи diотносятся к указателям (не вопрос ОП, но добавлены для забавы).

Ниже приведено решение для каждого случая.

Случай 1: если ключи diпредназначены для ссылки на значения индекса, то вы можете использовать updateметод:

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

Например,

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)

доходность

  col1 col2
1    w    a
2    B   30
0    A  NaN

Я изменил значения из вашего исходного поста, чтобы было понятнее, что updateпроисходит. Обратите внимание, как ключи diсвязаны со значениями индекса. Порядок значений индекса, то есть местоположения индекса, не имеет значения.

Случай 2: если ключи diотносятся к df['col1']значениям, то @DanAllan и @DSM показывают, как этого добиться с помощью 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)

доходность

  col1 col2
1    w    a
2    A   30
0    B  NaN

Обратите внимание, как в этом случае ключи diбыли изменены, чтобы соответствовать значениям в df['col1'].

Случай 3: если ключи diотносятся к указателям, то вы можете использовать

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

поскольку

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)

доходность

  col1 col2
1    A    a
2   10   30
0    B  NaN

Здесь первые и третьи ряды были изменены, потому что ключи в diэто 0и 2, которые при индексации на основе 0 Пайтона относятся к первым и третьим местам.

Добавим к этому вопросу, если у вас когда-либо будет более одного столбца для переназначения в кадре данных:

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

Надеюсь, что это может быть полезно для кого-то.

ура

У DSM есть принятый ответ, но кодирование, кажется, не работает для всех. Вот тот, который работает с текущей версией панд (0.23.4 от 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())

Вы увидите, что это выглядит так:

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

Документы для панд. DataFrame.replace здесь .

Или сделать apply:

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

Демо-версия:

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

Учитывая, что mapэто быстрее, чем заменить (решение @ JohnE), вы должны быть осторожны с неисчерпывающими отображениями, в которые вы намереваетесь отобразить конкретные значенияNaN . Правильный метод в этом случае требует, чтобы вы maskиспользовали Серию, когда вы .fillna, иначе вы отмените сопоставление 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

Хорошее законченное решение, которое хранит карту меток ваших классов:

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

Таким образом, вы можете в любой момент обратиться к исходной метке класса из label_dict.

В качестве дополнения к тому, что было предложено Nico Coallier (применимо к нескольким столбцам) и U10-Forward (с использованием методов применения стиля), и обобщив его в виде однострочника, я предлагаю:

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

.transform()Обрабатывает каждый столбец в виде ряда. В отличие от .apply()чего передаются столбцы, агрегированные в DataFrame.

Следовательно, вы можете применить метод серии map().

Наконец, и я обнаружил это поведение благодаря U10, вы можете использовать всю серию в выражении .get (). Если только я неправильно понял его поведение и он последовательно обрабатывает серию, а не поразрядно.
На .get(x,x)счетах для значений, не говоря уже в словаре отображения , которое будет рассматриваться как Nan иного .map()методом

Более родной подход панд заключается в применении функции замены, как показано ниже:

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) 

После того как вы определили функцию, вы можете применить ее к вашему фрейму данных.

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