另一种使用DataFrame.apply()的解决方案，当您想要联接更多列时，它的打字稍微少一点，可伸缩性更强：

cols = ['foo', 'bar', 'new']
df['combined'] = df[cols].apply(lambda row: '_'.join(row.values.astype(str)), axis=1)

您可以使用字符串连接来组合列，可以使用分隔符或不使用分隔符。您必须转换非字符串列上的类型。

In[17]: df['combined'] = df['bar'].astype(str) + '_' + df['foo'] + '_' + df['new']

In[17]:df
Out[18]: 
   bar foo     new    combined
0    1   a   apple   1_a_apple
1    2   b  banana  2_b_banana
2    3   c    pear    3_c_pear

如果要合并更多列，使用Series方法str.cat可能会很方便：

df["combined"] = df["foo"].str.cat(df[["bar", "new"]].astype(str), sep="_")

基本上，您选择第一列(如果它还不是str类型，则需要追加.astype(str))，然后再追加其他列(用可选的分隔符分隔)。

我只是想对两种解决方案(针对30K行df)进行时间比较：

In [1]: df = DataFrame({'foo':['a','b','c'], 'bar':[1, 2, 3], 'new':['apple', 'banana', 'pear']})

In [2]: big = pd.concat([df] * 10**4, ignore_index=True)

In [3]: big.shape
Out[3]: (30000, 3)

In [4]: %timeit big.apply(lambda x:'%s_%s_%s' % (x['bar'],x['foo'],x['new']),axis=1)
1 loop, best of 3: 881 ms per loop

In [5]: %timeit big['bar'].astype(str)+'_'+big['foo']+'_'+big['new']
10 loops, best of 3: 44.2 ms per loop

还有几个选项：

In [6]: %timeit big.ix[:, :-1].astype(str).add('_').sum(axis=1).str.cat(big.new)
10 loops, best of 3: 72.2 ms per loop

In [11]: %timeit big.astype(str).add('_').sum(axis=1).str[:-1]
10 loops, best of 3: 82.3 ms per loop

@allen给出的答案相当通用，但对于较大的 Dataframe 可能缺乏性能：

Reduced确实好了很多：

from functools import reduce

import pandas as pd

# make data

df = pd.DataFrame(index=range(1_000_000))
df['1'] = 'CO'
df['2'] = 'BOB'
df['3'] = '01'
df['4'] = 'BILL'

def reduce_join(df, columns):
    assert len(columns) > 1
    slist = [df[x].astype(str) for x in columns]
    return reduce(lambda x, y: x + '_' + y, slist[1:], slist[0])

def apply_join(df, columns):
    assert len(columns) > 1
    return df[columns].apply(lambda row:'_'.join(row.values.astype(str)), axis=1)

# ensure outputs are equal

df1 = reduce_join(df, list('1234'))
df2 = apply_join(df, list('1234'))
assert df1.equals(df2)

# profile

%timeit df1 = reduce_join(df, list('1234'))  # 733 ms
%timeit df2 = apply_join(df, list('1234'))   # 8.84 s

可能最快的解决方案是在纯Python中操作：

Series(
    map(
        '_'.join,
        df.values.tolist()
        # when non-string columns are present:
        # df.values.astype(str).tolist()
    ),
    index=df.index
)

与@MaxU答案的比较(使用同时包含数字列和字符串列的big数据框)：

%timeit big['bar'].astype(str) + '_' + big['foo'] + '_' + big['new']

# 29.4 ms ± 1.08 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

%timeit Series(map('_'.join, big.values.astype(str).tolist()), index=big.index)

# 27.4 ms ± 2.36 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

与@derChambers答案的比较(使用他们的df数据框，其中所有列都是字符串)：

from functools import reduce

def reduce_join(df, columns):
    slist = [df[x] for x in columns]
    return reduce(lambda x, y: x + '_' + y, slist[1:], slist[0])

def list_map(df, columns):
    return Series(
        map(
            '_'.join,
            df[columns].values.tolist()
        ),
        index=df.index
    )

%timeit df1 = reduce_join(df, list('1234'))

# 602 ms ± 39 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

%timeit df2 = list_map(df, list('1234'))

# 351 ms ± 12.1 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

我想你少了一个*%s*

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

首先将列转换为字符串。然后使用.T.agg(‘_’.Join)函数将它们连接起来。有关更多信息，请访问here

# Initialize columns

cols_concat = ['first_name', 'second_name']

# Convert them to type str

df[cols_concat] = df[cols_concat].astype('str')

# Then concatenate them as follows

df['new_col'] = df[cols_concat].T.agg('_'.join)

df = DataFrame({'foo':['a','b','c'], 'bar':[1, 2, 3], 'new':['apple', 'banana', 'pear']})

df['combined'] = df['foo'].astype(str)+'_'+df['bar'].astype(str)

如果使用字符串(‘_’)连接，请将列转换为所需的字符串，然后可以连接 Dataframe 。

df['New_column_name'] = df['Column1'].map(str) + 'X' + df['Steps']

X=x是用来分隔两个合并列的任何分隔符(例如：空格)。

如果您有一个想要连接的列的列表，并且可能想要使用分隔符，下面是您可以做的

def concat_columns(df, cols_to_concat, new_col_name, sep=" "):
    df[new_col_name] = df[cols_to_concat[0]]
    for col in cols_to_concat[1:]:
        df[new_col_name] = df[new_col_name].astype(str) + sep + df[col].astype(str)

这应该比apply更快，并且需要连接任意数量的列。

@derChambers我又找到了一个解决方案：

import pandas as pd

# make data

df = pd.DataFrame(index=range(1_000_000))
df['1'] = 'CO'
df['2'] = 'BOB'
df['3'] = '01'
df['4'] = 'BILL'

def eval_join(df, columns):

    sum_elements = [f"df['{col}']" for col in columns]
    to_eval = "+ '_' + ".join(sum_elements)

    return eval(to_eval)

# profile

%timeit df3 = eval_join(df, list('1234')) # 504 ms

您可以创建一个函数来使实现更简洁(例如。如果您在整个实施过程中多次使用此功能)：

def concat_cols(df, cols_to_concat, new_col_name, separator):  
    df[new_col_name] = ''
    for i, col in enumerate(cols_to_concat):
        df[new_col_name] += ('' if i == 0 else separator) + df[col].astype(str)
    return df

示例用法：

test = pd.DataFrame(data=[[1,2,3], [4,5,6], [7,8,9]], columns=['a', 'b', 'c'])
test = concat_cols(test, ['a', 'b', 'c'], 'concat_col', '_')

• 关注@Allen回复**

如果您需要将此类操作与其他 Dataframe 转换链接，请使用assign：

df.assign(
    combined = lambda x: x[cols].apply(
        lambda row: "_".join(row.values.astype(str)), axis=1
  )
)

考虑到要组合三列，则需要三个格式说明符'%s_%s_%s'，而不仅仅是两个'%s_%s'。以下内容将完成此工作

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

[Out]:
  foo  bar     new    combined
0   a    1   apple   a_1_apple
1   b    2  banana  b_2_banana
2   c    3    pear    c_3_pear

或者，如果想要创建一个单独的列表来存储想要组合的列，可以使用以下方法。

columns = ['foo', 'bar', 'new']

df['combined'] = df.apply(lambda x: '_'.join([str(x[i]) for i in columns]), axis=1)

[Out]:
  foo  bar     new    combined
0   a    1   apple   a_1_apple
1   b    2  banana  b_2_banana
2   c    3    pear    c_3_pear

最后一种方法更方便，因为用户只需更改或添加列表中的列名-它需要的更改较少。