Panda sütunundaki değerleri bir dikte ile yeniden eşleme

Ben böyle bir sözlük var: di = {1: "A", 2: "B"}

Ben benzer bir veri çerçevesinin "col1" sütununa uygulamak istiyorum:

     col1   col2
0       w      a
1       1      2
2       2    NaN

almak:

     col1   col2
0       w      a
1       A      2
2       B    NaN

Bunu en iyi nasıl yapabilirim? Bazı nedenlerden dolayı, bununla ilgili googling terimleri bana yalnızca diktlerden sütunlar nasıl yapılacağına ilişkin bağlantıları gösterir:

Kullanabilirsiniz .replace. Örneğin:

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

veya doğrudan Series, yani df["col1"].replace(di, inplace=True).

map daha hızlı olabilir replace

Sözlüğünüzde birden fazla anahtar varsa, kullanmak mapçok daha hızlı olabilir replace. Sözlüğünüzün olası tüm değerleri kapsamlı bir şekilde eşleyip eşlemediğine (ve aynı zamanda eşleşmeyenlerin değerlerini korumasını veya NaN'lere dönüştürülmesini isteyip istemediğinize bağlı olarak) bu yaklaşımın iki sürümü vardır:

Kapsamlı Haritalama

Bu durumda, form çok basittir:

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

mapEn yaygın olarak bir işlevi argüman olarak alsa da, alternatif olarak bir sözlük veya seri alabilir: Pandas.series.map belgeleri

Kapsamlı Olmayan Haritalama

Kapsamlı olmayan bir eşlemeniz varsa ve eşleşmeyenler için mevcut değişkenleri korumak istiyorsanız, şunları ekleyebilirsiniz fillna:

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

@ jpp'ın cevabındaki gibi: Pandalar serisindeki değerleri sözlük aracılığıyla verimli bir şekilde değiştirin

Deneyler

Panda verileri 0.23.1 ile aşağıdaki verileri kullanma:

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

ve ile test , yaklaşık 10 kat daha hızlı %timeitgörünüyor . mapreplace

İle hızlandırmanızın mapverilerinize göre değişeceğini unutmayın. En büyük hızlanma, büyük sözlükler ve kapsamlı ikameler ile görünüyor. Daha kapsamlı karşılaştırmalar ve tartışma için @jpp yanıtına (yukarıda bağlantılı) bakın.

Sorunuzda biraz belirsizlik var. En az üç iki yorum vardır:

1. anahtarlar didizin değerlerine atıfta bulunur
2. anahtarlar değerlere diatıfta bulunurdf['col1']
3. anahtarlar didizin konumlarına atıfta bulunur (OP'nin sorusu değil, eğlenmek için atılır.)

Aşağıda her durum için bir çözüm bulunmaktadır.

Durum 1: tuşlarının didizin değerlerine başvurması gerekiyorsa, updateyöntemi kullanabilirsiniz :

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

Örneğin,

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)

verim

  col1 col2
1    w    a
2    B   30
0    A  NaN

Orijinal yayınınızdaki değerleri değiştirdim, böylece ne updateyaptığı daha net . Anahtarların didizin değerleriyle nasıl ilişkilendirildiğine dikkat edin. Dizin değerlerinin sırası - yani dizin konumları - önemli değildir.

Durum 2: Anahtarlar değerlere diatıfta bulunuyorsa df['col1'], @DanAllan ve @DSM bunun nasıl yapılacağını gösterir 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)

verim

  col1 col2
1    w    a
2    A   30
0    B  NaN

Bu durumda tuşlar nasıl Not dimaç için değiştirildi değerler içinde df['col1'].

Durum 3: Anahtarlar didizin konumlarına başvuruyorsa,

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

dan beri

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)

verim

  col1 col2
1    A    a
2   10   30
0    B  NaN

Tuşları çünkü Burada, birinci ve üçüncü sıraları, değiştirilmiş diolan 0ve 2Python'un 0 tabanlı indeksleme ile birinci ve üçüncü konumlara işaret hangi.

Bir veri veri çerçevesinde yeniden eşlenecek birden fazla sütununuz varsa bu soruya ekleme:

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

Umarım birisi için yararlı olabilir.

Şerefe

DSM'nin kabul ettiği cevap var, ancak kodlama herkes için işe yaramıyor gibi görünüyor. İşte pandaların mevcut sürümü ile çalışan bir tane (8/2018 itibariyle 0.23.4):

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

Göründüğünüz gibi olacak:

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

Pandas.DataFrame.replace için dokümanlar burada .

Veya şunu yapın 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
>>> 

Verilen map, değiştirilmekten daha hızlıdır (@ JohnE'nin çözümü), belirli değerleri eşlemek istediğiniz Ayrıntılı Olmayan eşlemelerNaN konusunda dikkatli olmanız gerekir . Bu durumda uygun yöntem maskSerileri siz yapmanızı gerektirir .fillna, aksi takdirde eşlemeyi geri alırsınız 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

Sınıf etiketlerinizin haritasını tutan güzel ve eksiksiz bir çözüm:

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

Bu şekilde, herhangi bir noktada label_dict içindeki orijinal sınıf etiketine başvurabilirsiniz.

Nico Coallier (birden çok sütuna uygula) ve U10-Forward (yöntemlerin uygulanma stilini kullanarak) tarafından önerilenlerin bir uzantısı olarak ve bunu tek katmanlı olarak özetleyeceğim:

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

.transform()Bir dizi olarak her sütun işler. Bunun aksine, .apply()DataFrame içinde toplanan sütunları geçirir.

Sonuç olarak Seri yöntemini uygulayabilirsiniz map().

Son olarak, U10 sayesinde bu davranışı keşfettim. Serinin tamamını .get () ifadesinde kullanabilirsiniz. Ben davranışını yanlış anlamadım ve dizi bitwisely yerine ardışık olarak işler sürece. Değerleri için hesaplar tarafından aksi Nan olarak düşünülebilir, harita sözlükte söz etmedi yöntemle
.get(x,x).map()

Daha doğal bir panda yaklaşımı, aşağıdaki gibi bir değiştirme işlevi uygulamaktır:

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) 

İşlevi tanımladıktan sonra, veri çerçevenize uygulayabilirsiniz.

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