Remap nilai dalam kolom panda dengan dict

Saya memiliki kamus yang terlihat seperti ini: di = {1: "A", 2: "B"}

Saya ingin menerapkannya pada kolom "col1" dari dataframe yang mirip dengan:

     col1   col2
0       w      a
1       1      2
2       2    NaN

mendapatkan:

     col1   col2
0       w      a
1       A      2
2       B    NaN

Bagaimana saya bisa melakukan ini? Untuk beberapa alasan, istilah googling yang berkaitan dengan ini hanya menunjukkan kepada saya tautan tentang cara membuat kolom dari dicts dan sebaliknya: - /

Anda bisa menggunakannya .replace. Sebagai contoh:

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

atau langsung pada Series, yaitu df["col1"].replace(di, inplace=True).

map bisa jauh lebih cepat daripada replace

Jika kamus Anda memiliki lebih dari beberapa kunci, menggunakan mapbisa jauh lebih cepat daripada replace. Ada dua versi dari pendekatan ini, tergantung pada apakah kamus Anda secara mendalam memetakan semua nilai yang mungkin (dan juga apakah Anda ingin yang tidak cocok mempertahankan nilainya atau dikonversi ke NaNs):

Pemetaan Lengkap

Dalam hal ini, formulirnya sangat sederhana:

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

Meskipun mappaling umum mengambil fungsi sebagai argumennya, ia dapat juga mengambil kamus atau seri: Documentation for Pandas.series.map

Pemetaan Tidak Lengkap

Jika Anda memiliki pemetaan yang tidak lengkap dan ingin mempertahankan variabel yang ada untuk yang tidak cocok, Anda dapat menambahkan fillna:

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

seperti pada jawaban @ jpp di sini: Ganti nilai dalam seri panda melalui kamus secara efisien

Tolak ukur

Menggunakan data berikut dengan panda versi 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 ) })

dan pengujian dengan %timeit, tampaknya mapsekitar 10x lebih cepat daripada replace.

Perhatikan bahwa speedup Anda mapakan berbeda dengan data Anda. Speedup terbesar tampaknya dengan kamus besar dan penggantian lengkap. Lihat jawaban @jpp (ditautkan di atas) untuk tolok ukur dan diskusi yang lebih luas.

Ada sedikit ambiguitas dalam pertanyaan Anda. Setidaknya ada tiga dua interpretasi:

1. kunci dalam dimerujuk pada nilai indeks
2. kunci dimengacu pada df['col1']nilai
3. kunci dalam dimerujuk ke lokasi indeks (bukan pertanyaan OP, tetapi dilemparkan untuk bersenang-senang.)

Di bawah ini adalah solusi untuk setiap kasus.

Kasus 1: Jika kunci didimaksudkan untuk merujuk ke nilai indeks, maka Anda dapat menggunakan updatemetode ini:

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

Sebagai contoh,

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)

hasil panen

  col1 col2
1    w    a
2    B   30
0    A  NaN

Saya telah memodifikasi nilai dari pos asli Anda sehingga lebih jelas apa updateyang dilakukan. Perhatikan bagaimana kunci diterkait dengan nilai indeks. Urutan nilai indeks - yaitu, lokasi indeks - tidak masalah.

Kasus 2: Jika kunci dimengacu pada df['col1']nilai, maka @DanAllan dan @DSM menunjukkan cara mencapai ini dengan 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)

hasil panen

  col1 col2
1    w    a
2    A   30
0    B  NaN

Perhatikan bagaimana dalam hal ini kunci didiubah untuk mencocokkan nilai dalam df['col1'].

Kasus 3: Jika kunci dimengacu pada lokasi indeks, maka Anda dapat menggunakannya

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

sejak

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)

hasil panen

  col1 col2
1    A    a
2   10   30
0    B  NaN

Di sini, baris pertama dan ketiga yang diubah, karena kunci dalam diadalah 0dan 2, yang dengan pengindeksan 0 berbasis Python mengacu pada lokasi pertama dan ketiga.

Menambahkan ke pertanyaan ini jika Anda memiliki lebih dari satu kolom untuk dipetakan kembali dalam kerangka data data:

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

Semoga bermanfaat bagi seseorang.

Bersulang

DSM memiliki jawaban yang diterima, tetapi pengkodean tampaknya tidak berfungsi untuk semua orang. Berikut ini adalah yang berfungsi dengan versi panda saat ini (0.23.4 pada 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())

Anda akan melihatnya seperti:

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

Dokumen untuk panda . DataFrame.replace ada di sini .

Atau lakukan apply:

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

Demo:

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

Diberikan maplebih cepat daripada mengganti (solusi @ JohnE) Anda harus berhati -NaN hati dengan pemetaan Non-Lengkap di mana Anda ingin memetakan nilai tertentu . Metode yang tepat dalam hal ini mengharuskan Anda maskmenjadi Seri saat Anda .fillna, jika tidak Anda membatalkan pemetaan 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

Solusi lengkap yang bagus yang menyimpan peta label kelas Anda:

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

Dengan cara ini, Anda dapat merujuk label kelas asli dari label_dict kapan saja.

Sebagai perpanjangan dari apa yang telah diusulkan oleh Nico Coallier (berlaku untuk beberapa kolom) dan U10-Forward (menggunakan gaya metode terapkan), dan meringkasnya menjadi satu-baris yang saya usulkan:

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

The .transform()memproses setiap kolom sebagai seri. Bertentangan dengan .apply()yang melewati kolom yang dikumpulkan dalam DataFrame.

Akibatnya, Anda dapat menerapkan metode Seri map().

Akhirnya, dan saya menemukan perilaku ini berkat U10, Anda dapat menggunakan seluruh Seri dalam ekspresi .get (). Kecuali jika saya salah memahami perilakunya dan memproses seri secara berurutan alih-alih dengan sedikit.
The .get(x,x)account untuk nilai-nilai Anda tidak menyebutkan dalam kamus pemetaan Anda yang akan dianggap sebagai Nan lain oleh .map()metode

Pendekatan panda yang lebih asli adalah menerapkan fungsi ganti seperti di bawah ini:

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) 

Setelah Anda mendefinisikan fungsi, Anda bisa menerapkannya ke bingkai data Anda.

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