Łączenie łańcuchów dwóch kolumn pandy

Mam DataFrame:

from pandas import *
df = DataFrame({'foo':['a','b','c'], 'bar':[1, 2, 3]})

To wygląda tak:

    bar foo
0    1   a
1    2   b
2    3   c

Teraz chcę mieć coś takiego:

     bar
0    1 is a
1    2 is b
2    3 is c

Jak mogę to osiągnąć? Próbowałem następujących rzeczy:

df['foo'] = '%s is %s' % (df['bar'], df['foo'])

ale daje mi zły wynik:

>>>print df.ix[0]

bar                                                    a
foo    0    a
1    b
2    c
Name: bar is 0    1
1    2
2
Name: 0

Przepraszam za głupie pytanie, ale ta jedna panda: połączenie dwóch kolumn w DataFrame nie było dla mnie pomocne.

df['bar'] = df.bar.map(str) + " is " + df.foo.

Na to pytanie już udzielono odpowiedzi, ale uważam, że dobrze byłoby wrzucić kilka użytecznych metod, które nie zostały wcześniej omówione, i porównać wszystkie proponowane do tej pory metody pod względem wydajności.

Oto kilka użytecznych rozwiązań tego problemu, w kolejności rosnącej wydajności.

DataFrame.agg

To jest proste str.formatpodejście.

df['baz'] = df.agg('{0[bar]} is {0[foo]}'.format, axis=1)
df
  foo  bar     baz
0   a    1  1 is a
1   b    2  2 is b
2   c    3  3 is c

Możesz również użyć formatowania f-string tutaj:

df['baz'] = df.agg(lambda x: f"{x['bar']} is {x['foo']}", axis=1)
df
  foo  bar     baz
0   a    1  1 is a
1   b    2  2 is b
2   c    3  3 is c

char.array-based konkatenacja

Przekonwertuj kolumny, aby chararrayspołączyć je jako , a następnie dodaj je razem.

a = np.char.array(df['bar'].values)
b = np.char.array(df['foo'].values)

df['baz'] = (a + b' is ' + b).astype(str)
df
  foo  bar     baz
0   a    1  1 is a
1   b    2  2 is b
2   c    3  3 is c

Rozumienie listy zzip

Nie mogę przecenić, jak niedoceniane jest rozumienie listy u pand.

df['baz'] = [str(x) + ' is ' + y for x, y in zip(df['bar'], df['foo'])]

Alternatywnie, używając str.joindo concat (będzie też lepiej skalować):

df['baz'] = [
    ' '.join([str(x), 'is', y]) for x, y in zip(df['bar'], df['foo'])]

df
  foo  bar     baz
0   a    1  1 is a
1   b    2  2 is b
2   c    3  3 is c

Listy składane wyróżniają się w manipulacji na łańcuchach, ponieważ operacje na łańcuchach są z natury trudne do wektoryzacji, a większość funkcji „wektoryzowanych” pand jest w zasadzie zawijana wokół pętli. Obszernie pisałem na ten temat w Pętle For z pandami - kiedy powinno mnie to obchodzić? . Ogólnie rzecz biorąc, jeśli nie musisz martwić się o wyrównanie indeksów, podczas operacji na łańcuchach i wyrażeniach regularnych używaj funkcji list.

Powyższa kompozycja list domyślnie nie obsługuje nazw NaN. Jednak zawsze można napisać funkcję opakowującą try-z wyjątkiem sytuacji, gdy trzeba to obsłużyć.

def try_concat(x, y):
    try:
        return str(x) + ' is ' + y
    except (ValueError, TypeError):
        return np.nan


df['baz'] = [try_concat(x, y) for x, y in zip(df['bar'], df['foo'])]

perfplot Pomiary wydajności

Wykres wygenerowany za pomocą perfplot . Oto pełna lista kodów .

Funkcje

def brenbarn(df):
    return df.assign(baz=df.bar.map(str) + " is " + df.foo)

def danielvelkov(df):
    return df.assign(baz=df.apply(
        lambda x:'%s is %s' % (x['bar'],x['foo']),axis=1))

def chrimuelle(df):
    return df.assign(
        baz=df['bar'].astype(str).str.cat(df['foo'].values, sep=' is '))

def vladimiryashin(df):
    return df.assign(baz=df.astype(str).apply(lambda x: ' is '.join(x), axis=1))

def erickfis(df):
    return df.assign(
        baz=df.apply(lambda x: f"{x['bar']} is {x['foo']}", axis=1))

def cs1_format(df):
    return df.assign(baz=df.agg('{0[bar]} is {0[foo]}'.format, axis=1))

def cs1_fstrings(df):
    return df.assign(baz=df.agg(lambda x: f"{x['bar']} is {x['foo']}", axis=1))

def cs2(df):
    a = np.char.array(df['bar'].values)
    b = np.char.array(df['foo'].values)

    return df.assign(baz=(a + b' is ' + b).astype(str))

def cs3(df):
    return df.assign(
        baz=[str(x) + ' is ' + y for x, y in zip(df['bar'], df['foo'])])

Problem w twoim kodzie polega na tym, że chcesz zastosować operację w każdym wierszu. Sposób, w jaki to napisałeś, zajmuje całe kolumny „bar” i „foo”, konwertuje je na łańcuchy i zwraca jeden duży ciąg. Możesz to napisać tak:

df.apply(lambda x:'%s is %s' % (x['bar'],x['foo']),axis=1)

Jest dłuższa niż druga odpowiedź, ale jest bardziej ogólna (można jej używać z wartościami, które nie są ciągami znaków).

Możesz również użyć

df['bar'] = df['bar'].str.cat(df['foo'].values.astype(str), sep=' is ')

df.astype(str).apply(lambda x: ' is '.join(x), axis=1)

0    1 is a
1    2 is b
2    3 is c
dtype: object

series.str.cat to najbardziej elastyczny sposób rozwiązania tego problemu:

Dla df = pd.DataFrame({'foo':['a','b','c'], 'bar':[1, 2, 3]})

df.foo.str.cat(df.bar.astype(str), sep=' is ')

>>>  0    a is 1
     1    b is 2
     2    c is 3
     Name: foo, dtype: object

LUB

df.bar.astype(str).str.cat(df.foo, sep=' is ')

>>>  0    1 is a
     1    2 is b
     2    3 is c
     Name: bar, dtype: object

Co najważniejsze (i w przeciwieństwie .join()), pozwala to zignorować lub zastąpić Nullwartości na_repparametrem.

@DanielVelkov odpowiedź jest właściwa, ALE użycie literałów tekstowych jest szybsze:

# Daniel's
%timeit df.apply(lambda x:'%s is %s' % (x['bar'],x['foo']),axis=1)
## 963 µs ± 157 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

# String literals - python 3
%timeit df.apply(lambda x: f"{x['bar']} is {x['foo']}", axis=1)
## 849 µs ± 4.28 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)