Конкатенация двух колонн панд

У меня есть следующий DataFrame:

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

Он выглядит следующим образом:

    bar foo
0    1   a
1    2   b
2    3   c

Теперь я хочу иметь что-то вроде:

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

Как я могу это достичь? Я попробовал следующее:

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

но это дает мне неправильный результат:

>>>print df.ix[0]

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

Извините за немой вопрос, но этот pandas: объединить два столбца в DataFrame не помог мне.

Ответ 1

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

Ответ 2

Проблема в вашем коде заключается в том, что вы хотите применить операцию для каждой строки. То, как вы его написали, принимает все столбцы "bar" и "foo", преобразует их в строки и возвращает одну большую строку. Вы можете написать это как:

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

Это больше, чем другой ответ, но более общий (может использоваться со значениями, которые не являются строками).

Ответ 3

На этот вопрос уже дан ответ, но я считаю, что было бы неплохо добавить некоторые полезные методы, которые ранее не обсуждались, и сравнить все методы, предложенные до сих пор, с точки зрения производительности.

Вот несколько полезных решений этой проблемы, в порядке возрастания производительности.

`DataFrame.agg`

Это простой str.format -based подход.

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

Вы также можете использовать форматирование f-строки здесь:

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 Конкатенация

Преобразуйте столбцы, чтобы chararrays как chararrays, а затем сложите их вместе.

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

Понимание списка с помощью `zip`

Я не могу преувеличить, насколько недооценены понимания списков в пандах.

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

Также можно использовать str.join для str.join (также будет лучше масштабироваться):

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

Постижения списков превосходны в манипулировании строками, потому что строковые операции по своей природе трудно векторизовать, и большинство "векторизованных" функций панд в основном являются обертками вокруг циклов. Я много писал на эту тему в " Для петель с пандами". Когда мне это нужно? , В общем, если вам не нужно беспокоиться о выравнивании индекса, используйте понимание списка при работе со строками и операциями регулярных выражений.

Приведенный выше список по умолчанию не обрабатывает NaN. Тем не менее, вы всегда можете написать функцию, заключающую в себе попытку, за исключением случаев, когда вам нужно ее обработать.

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` производительности `perfplot`

График создан с использованием перфплота. Здесь полный список кодов.

функции

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'])])

Ответ 4

Вы также можете использовать

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

Ответ 5

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

Ответ 6

Ответ @DanielVelkov правильный, НО использование строковых литералов происходит быстрее:

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

Ответ 7

Вы также можете использовать str.join с новым pd.Series:

>>> pd.Series(df.astype(str).values.tolist()).str.join(' is ')
0    1 is a
1    2 is b
2    3 is c
dtype: object
>>>