Remap giá trị trong cột gấu trúc với một dict

Tôi có một từ điển giống như thế này: di = {1: "A", 2: "B"}

Tôi muốn áp dụng nó cho cột "col1" của khung dữ liệu tương tự như:

     col1   col2
0       w      a
1       1      2
2       2    NaN

để có được:

     col1   col2
0       w      a
1       A      2
2       B    NaN

Làm thế nào tốt nhất tôi có thể làm điều này? Vì một số lý do, các thuật ngữ liên quan đến điều này chỉ cho tôi thấy các liên kết về cách tạo các cột từ dicts và ngược lại: - /

Bạn có thể sử dụng .replace. Ví dụ:

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

hoặc trực tiếp trên Series, tức là df["col1"].replace(di, inplace=True).

map có thể nhanh hơn nhiều replace

Nếu từ điển của bạn có nhiều hơn một vài khóa, việc sử dụng mapcó thể nhanh hơn nhiều replace. Có hai phiên bản của phương pháp này, tùy thuộc vào việc từ điển của bạn có ánh xạ toàn bộ tất cả các giá trị có thể hay không (và cả việc bạn muốn các kết quả không khớp để giữ các giá trị của chúng hay được chuyển đổi thành NaN):

Bản đồ toàn diện

Trong trường hợp này, hình thức rất đơn giản:

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

Mặc dù maphầu hết thường lấy một hàm làm đối số của nó, nhưng nó có thể lấy từ điển hoặc sê-ri : Tài liệu cho Pandas.series.map

Bản đồ không toàn diện

Nếu bạn có một ánh xạ không đầy đủ và muốn giữ lại các biến hiện có cho các kết quả không khớp, bạn có thể thêm fillna:

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

như trong câu trả lời của @ jpp tại đây: Thay thế các giá trị trong chuỗi gấu trúc thông qua từ điển một cách hiệu quả

Điểm chuẩn

Sử dụng dữ liệu sau với gấu trúc phiên bả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 ) })

và thử nghiệm với %timeit, nó dường như mapnhanh hơn khoảng 10 lần replace.

Lưu ý rằng việc tăng tốc của bạn mapsẽ thay đổi theo dữ liệu của bạn. Việc tăng tốc lớn nhất dường như là với các từ điển lớn và thay thế toàn diện. Xem câu trả lời @jpp (được liên kết ở trên) để biết thêm điểm chuẩn và thảo luận.

Có một chút mơ hồ trong câu hỏi của bạn. Có ít nhất ba hai cách hiểu:

1. các khóa trong ditham chiếu đến các giá trị chỉ mục
2. các khóa trong ditham chiếu đến df['col1']các giá trị
3. các khóa trong ditham chiếu đến các vị trí chỉ mục (không phải câu hỏi của OP, nhưng được ném vào cho vui.)

Dưới đây là một giải pháp cho từng trường hợp.

Trường hợp 1: Nếu các khóa dicó nghĩa là tham chiếu đến các giá trị chỉ mục, thì bạn có thể sử dụng updatephương thức:

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

Ví dụ,

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)

sản lượng

  col1 col2
1    w    a
2    B   30
0    A  NaN

Tôi đã sửa đổi các giá trị từ bài viết gốc của bạn để rõ ràng hơn những gì updateđang làm. Lưu ý cách các khóa trong diđược liên kết với các giá trị chỉ mục. Thứ tự của các giá trị chỉ mục - nghĩa là các vị trí chỉ mục - không quan trọng.

Trường hợp 2: Nếu các khóa trong ditham chiếu đến df['col1']các giá trị, thì @DanAllan và @DSM chỉ ra cách đạt được điều này với 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)

sản lượng

  col1 col2
1    w    a
2    A   30
0    B  NaN

Lưu ý làm thế nào trong trường hợp này, các khóa trong diđã được thay đổi để khớp với các giá trị trong df['col1'].

Trường hợp 3: Nếu các khóa trong ditham chiếu đến các vị trí chỉ mục, thì bạn có thể sử dụng

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

từ

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)

sản lượng

  col1 col2
1    A    a
2   10   30
0    B  NaN

Ở đây, các hàng đầu tiên và thứ ba được thay đổi, bởi vì các phím trong dilà 0và 2, trong đó có chỉ mục 0 dựa trên Python tham khảo các địa điểm đầu tiên và thứ ba.

Thêm vào câu hỏi này nếu bạn có nhiều hơn một cột để ánh xạ lại trong khung dữ liệu dữ liệu:

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

Hy vọng nó có thể hữu ích cho ai đó.

Chúc mừng

DSM có câu trả lời được chấp nhận, nhưng mã hóa dường như không hoạt động với tất cả mọi người. Dưới đây là một phiên bản hoạt động với phiên bản gấu trúc hiện tại (0.23.4 tính đến 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())

Bạn sẽ thấy nó trông giống như:

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

Các tài liệu cho pandas.DataFrame.replace đang ở đây .

Hoặc làm apply:

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

Bản giới thiệu:

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

Đưa ra maplà nhanh hơn thay thế (giải pháp của @ JohnE), bạn cần cẩn thận với ánh xạ không cạn kiệt nơi bạn định ánh xạ các giá trị cụ thể tớiNaN . Phương thức thích hợp trong trường hợp này yêu cầu bạn maskSê-ri khi bạn .fillna, nếu không, bạn hoàn tác ánh xạ tới 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

Một giải pháp hoàn chỉnh tốt đẹp giữ bản đồ nhãn lớp của bạn:

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

Bằng cách này, bất cứ lúc nào bạn cũng có thể tham khảo nhãn lớp gốc từ nhãn_dict.

Là một phần mở rộng cho những gì đã được đề xuất bởi Nico Coallier (áp dụng cho nhiều cột) và U10-Forward (sử dụng kiểu phương thức áp dụng) và tóm tắt nó thành một lớp lót mà tôi đề xuất:

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

Các .transform()quy trình mỗi cột như một chuỗi. Trái ngược với việc .apply()vượt qua các cột được tổng hợp trong DataFrame.

Do đó, bạn có thể áp dụng phương pháp Sê-ri map().

Cuối cùng, và tôi đã phát hiện ra hành vi này nhờ vào U10, bạn có thể sử dụng toàn bộ Sê-ri trong biểu thức .get (). Trừ khi tôi đã hiểu sai hành vi của nó và nó xử lý tuần tự chuỗi thay vì bitw chính xác.
Các .get(x,x)tài khoản cho các giá trị bạn đã không đề cập trong từ điển bản đồ của bạn đó sẽ được coi là Nan khác bởi các .map()phương pháp

Một cách tiếp cận gấu trúc bản địa hơn là áp dụng chức năng thay thế như dưới đây:

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) 

Khi bạn đã xác định hàm, bạn có thể áp dụng nó cho khung dữ liệu của mình.

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