pandas dataframe index-match

Frage ich mich, ob es eine effizientere Art und Weise zu tun, die eine "index & match" type-Funktion, die beliebt in excel. Zum Beispiel - zwei pandas DataFrames, aktualisieren Sie die df_1 mit Informationen, die in df_2:

import pandas as pd

df_1 = pd.DataFrame({'num_a':[1, 2, 3, 4, 5],
                     'num_b':[2, 4, 1, 2, 3]})    
df_2 = pd.DataFrame({'num':[1, 2, 3, 4, 5],
                     'name':['a', 'b', 'c', 'd', 'e']})

Arbeite ich mit Daten-sets, die ~80.000 Zeilen in beiden df_1 und df_2 und mein Ziel ist, erstellen Sie zwei neue Spalten in df_1, "name_a" und "name_b".

Unten ist die effizienteste Methode, die ich kommen konnte mit. Es hat der bessere Weg zu sein!

name_a = []
name_b = []
for i in range(len(df_1)):

    name_a.append(df_2.name.iloc[df_2[
                  df_2.num == df_1.num_a.iloc[i]].index[0]])
    name_b.append(df_2.name.iloc[df_2[
                  df_2.num == df_1.num_b.iloc[i]].index[0]])

df_1['name_a'] = name_a
df_1['name_b'] = name_b

Ergibt:

>>> df_1.head()
   num_a  num_b name_a name_b
0      1      2      a      b
1      2      4      b      d
2      3      1      c      a
3      4      2      d      b
4      5      3      e      c
InformationsquelleAutor A. Martin | 2017-06-02
  1. 5

    Hohe

    • Erstellen Sie ein Wörterbuch verwenden, in einer replace
    • replace, rename Spalten, und join
    m = dict(zip(
    df_2.num.values.tolist(),
    df_2.name.values.tolist()
))

df_1.join(
    df_1.replace(m).rename(
        columns=lambda x: x.replace('num', 'name')
    )
)

   num_a  num_b name_a name_b
0      1      2      a      b
1      2      4      b      d
2      3      1      c      a
3      4      2      d      b
4      5      3      5      c

    Aufschlüsselung

    replace mit einem Wörterbuch sollte ziemlich schnell. Es gibt paar Möglichkeiten, um ein Wörterbuch form df_2. Als eine Angelegenheit von der Tat, die wir verwendet haben konnten, eine pd.Series. Ich entschied mich für das bauen mit dict und zip weil ich finde, dass es schneller geht.

    Gebäude m

    Option 1 

    m = df_2.set_index('num').name

    Option 2 

    m = df_2.set_index('num').name.to_dict()

    Option 3 

    m = dict(zip(df_2.num, df_2.name))

    Option 4 (Meine Wahl) 

    m = dict(zip(df_2.num.values.tolist(), df_2.name.values.tolist()))

    m build-Zeiten 

    1000 loops, best of 3: 325 µs per loop
1000 loops, best of 3: 376 µs per loop
10000 loops, best of 3: 32.9 µs per loop
100000 loops, best of 3: 10.4 µs per loop

%timeit df_2.set_index('num').name
%timeit df_2.set_index('num').name.to_dict()
%timeit dict(zip(df_2.num, df_2.name))
%timeit dict(zip(df_2.num.values.tolist(), df_2.name.values.tolist()))

    Ersetzen num

    Wieder, wir haben die Wahl, hier sind ein paar, und Ihre Zeiten.

    %timeit df_1.replace(m)
%timeit df_1.applymap(lambda x: m.get(x, x))
%timeit df_1.stack().map(lambda x: m.get(x, x)).unstack()

1000 loops, best of 3: 792 µs per loop
1000 loops, best of 3: 959 µs per loop
1000 loops, best of 3: 925 µs per loop

    Ich wählen...

    df_1.replace(m)

  num_a num_b
0     a     b
1     b     d
2     c     a
3     d     b
4     5     c

    Spalten umbenennen 

    df_1.replace(m).rename(columns=lambda x: x.replace('num', 'name'))

  name_a name_b   <-- note the column name change
0      a      b
1      b      d
2      c      a
3      d      b
4      5      c

    Join 

    df_1.join(df_1.replace(m).rename(columns=lambda x: x.replace('num', 'name')))

   num_a  num_b name_a name_b
0      1      2      a      b
1      2      4      b      d
2      3      1      c      a
3      4      2      d      b
4      5      3      5      c
    InformationsquelleAutor piRSquared
  2. 2

    Ich denke, es gibt eine einfacher Lösung als diejenigen, die bereits angeboten. Da Sie erwähnten Excel ist ein einfacher SVERWEIS. Sie können dies simulieren, in pandas von mit Serie.anzeigen.

    name_map = dict(df_2.set_index('num').name)

df_1['name_a'] = df_1.num_a.map(name_map)
df_1['name_b'] = df_1.num_b.map(name_map)

df_1

   num_a  num_b name_a name_b
0      1      2      a      b
1      2      4      b      d
2      3      1      c      a
3      4      2      d      b
4      5      3      e      c

    Alles, was wir tun ist, konvertieren Sie df_2 ein dict mit 'num' als der Schlüssel. Die map-Funktion sieht Sie jeden Wert aus einem df_1 Spalte in der dict und gibt den entsprechenden Buchstaben. Keine komplizierte Indizierung erforderlich.

    InformationsquelleAutor T. Ray
  3. 0

    Nur versuchen, eine bedingte Anweisung:

    import pandas as pd
import numpy as np
df_1 = pd.DataFrame({'num_a':[1, 2, 3, 4, 5],
                     'num_b':[2, 4, 1, 2, 3]})    
df_2 = pd.DataFrame({'num':[1, 2, 3, 4, 5],
                     'name':['a', 'b', 'c', 'd', 'e']})
df_1["name_a"] = df_2["num_b"]
df_1["name_b"] = np.array(df_1["name_a"][df_1["num_b"]-1]) 
print(df_1)

   num_a  num_b name_a name_b
0      1      2      a      b
1      2      4      b      d
2      3      1      c      a
3      4      2      d      b
4      5      3      e      c
    InformationsquelleAutor David Jaimes
Schreibe einen Kommentar