两个熊猫列的字符串串联

小开

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

小开

代码中的问题在于您希望在每一行上应用该操作。你写它的方式虽然需要整个‘ bar’和‘ foo’列，将它们转换成字符串，然后返回一个大字符串。你可以这样写:

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

它比另一个答案要长，但是更通用(可以与不是字符串的值一起使用)。

小开

你也可以用

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

小开

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

小开

这个问题已经得到了回答，但是我认为最好是抛出一些之前没有讨论过的有用方法，然后比较迄今为止提出的所有方法的性能。

以下是一些有用的解决方案，按照性能的增加顺序排列。

`DataFrame.agg`

这是一种简单的基于 str.format的方法。

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` 的连接

将这些列转换为连接为 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

返回文章页面列表内涵

我无法夸大大熊猫对列表的理解力被低估的程度。

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

或者，使用 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

列表理解在字符串操作方面表现出色，因为字符串运算本身就很难向量化，而且大多数“向量化”的函数基本上都是循环的包装器。我在与熊猫循环-什么时候我应该关心？中已经写了大量关于这个主题的文章。一般来说，如果你不用担心索引对齐的问题，在处理字符串和正则表达式操作时使用列表内涵。

默认情况下，上面的列表组合不处理 NaNs。但是，您总是可以编写一个包装 try 的函数-除非您需要处理它。

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`性能测量

使用完美情节生成的图。

职能

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

小开

series.str.cat是解决这个问题最灵活的方法:

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

或者

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

与 .join()(用于连接包含在单个系列中的列表)不同，此方法用于将2个系列连接在一起。它还允许您根据需要忽略或替换 NaN值。

小开

我遇到了一个具体的情况，从我的方面与10 ^ 11行在我的数据框架，在这种情况下，没有一个建议的解决方案是适当的。我已经使用了类别，在所有惟一字符串的数量不太大的情况下，这应该都能很好地工作。这在使用 XxY 及其因子的 R 软件中很容易做到，但是在 python 中我找不到任何其他方法来做到这一点(我对 python 是新手)。如果有人知道在哪里实施这一点，我会很高兴知道。

def Create_Interaction_var(df,Varnames):
'''
:df data frame
:list of 2 column names, say "X" and "Y".
The two columns should be strings or categories
convert strings columns to categories
Add a column with the "interaction of X and Y" : X x Y, with name
"Interaction-X_Y"
'''
df.loc[:, Varnames[0]] = df.loc[:, Varnames[0]].astype("category")
df.loc[:, Varnames[1]] = df.loc[:, Varnames[1]].astype("category")
CatVar = "Interaction-" + "-".join(Varnames)
Var0Levels = pd.DataFrame(enumerate(df.loc[:,Varnames[0]].cat.categories)).rename(columns={0 : "code0",1 : "name0"})
Var1Levels = pd.DataFrame(enumerate(df.loc[:,Varnames[1]].cat.categories)).rename(columns={0 : "code1",1 : "name1"})
NbLevels=len(Var0Levels)


names = pd.DataFrame(list(itertools.product(dict(enumerate(df.loc[:,Varnames[0]].cat.categories)),
dict(enumerate(df.loc[:,Varnames[1]].cat.categories)))),
columns=['code0', 'code1']).merge(Var0Levels,on="code0").merge(Var1Levels,on="code1")
names=names.assign(Interaction=[str(x) + '_' + y for x, y in zip(names["name0"], names["name1"])])
names["code01"]=names["code0"] + NbLevels*names["code1"]
df.loc[:,CatVar]=df.loc[:,Varnames[0]].cat.codes+NbLevels*df.loc[:,Varnames[1]].cat.codes
df.loc[:, CatVar]=  df[[CatVar]].replace(names.set_index("code01")[["Interaction"]].to_dict()['Interaction'])[CatVar]
df.loc[:, CatVar] = df.loc[:, CatVar].astype("category")
return df

小开

我认为，对于任意数量的列，最简洁的解决方案是这个答案的一个简短版本:

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

你可以用 df.agg()再去掉两个字符，但是速度要慢一些:

df.astype(str).agg(' is '.join, axis=1)

小开

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


x['bar'] = x.bar.astype("str") + " " + "is" + " " + x.foo
x.drop(['foo'], axis=1)

小开

已经过去10年了，没有人提出最简单和直观的方法，比这10年中提出的所有例子快50% 。

df.bar.astype(str) + ' is ' + df.foo

两个熊猫列的字符串串联

DataFrame.agg

基于 char.array 的连接

返回文章页面列表内涵

perfplot性能测量

`DataFrame.agg`

基于 `char.array` 的连接

`perfplot`性能测量