• 当前位置：首页
  • IT科技
  • 在熊猫数据框中合并两列文本

在熊猫数据框中合并两列文本

2024-11-29 08:42:00
admin
原创
115
摘要：问题描述：我有一个看起来像的数据框Year quarter 2000 q2 2001 q3 如何通过组合这些列来添加新列以获取以下数据框？Year quarter period 2000 q2 2000q2 2001 q3 2001q3 解决方案 1：...

问题描述：

我有一个看起来像的数据框

Year  quarter
2000       q2
2001       q3

如何通过组合这些列来添加新列以获取以下数据框？

Year  quarter  period
2000       q2  2000q2
2001       q3  2001q3

解决方案 1：

如果两列都是字符串，则可以直接将它们连接起来：

df["period"] = df["Year"] + df["quarter"]

如果其中一个（或两个）列不是字符串类型，则应先转换它（它们），

df["period"] = df["Year"].astype(str) + df["quarter"]

执行此操作时要小心 NaN！

如果需要连接多个字符串列，可以使用agg：

df['period'] = df[['Year', 'quarter', ...]].agg('-'.join, axis=1)

其中“-”是分隔符。

解决方案 2：

小型数据集（<150 行）

[''.join(i) for i in zip(df["Year"].map(str),df["quarter"])]

或者稍微慢一点但更紧凑：

df.Year.str.cat(df.quarter)

更大的数据集（> 150 行）

df['Year'].astype(str) + df['quarter']

更新：时间图 Pandas 0.23.4

在此处输入图片描述

让我们在 200K 行 DF 上进行测试：

In [250]: df
Out[250]:
   Year quarter
0  2014      q1
1  2015      q2

In [251]: df = pd.concat([df] * 10**5)

In [252]: df.shape
Out[252]: (200000, 2)

更新：使用 Pandas 0.19.0 的新计时

未进行 CPU/GPU 优化的时间（从最快到最慢排序）：

In [107]: %timeit df['Year'].astype(str) + df['quarter']
10 loops, best of 3: 131 ms per loop

In [106]: %timeit df['Year'].map(str) + df['quarter']
10 loops, best of 3: 161 ms per loop

In [108]: %timeit df.Year.str.cat(df.quarter)
10 loops, best of 3: 189 ms per loop

In [109]: %timeit df.loc[:, ['Year','quarter']].astype(str).sum(axis=1)
1 loop, best of 3: 567 ms per loop

In [110]: %timeit df[['Year','quarter']].astype(str).sum(axis=1)
1 loop, best of 3: 584 ms per loop

In [111]: %timeit df[['Year','quarter']].apply(lambda x : '{}{}'.format(x[0],x[1]), axis=1)
1 loop, best of 3: 24.7 s per loop

使用 CPU/GPU 优化的时间：

In [113]: %timeit df['Year'].astype(str) + df['quarter']
10 loops, best of 3: 53.3 ms per loop

In [114]: %timeit df['Year'].map(str) + df['quarter']
10 loops, best of 3: 65.5 ms per loop

In [115]: %timeit df.Year.str.cat(df.quarter)
10 loops, best of 3: 79.9 ms per loop

In [116]: %timeit df.loc[:, ['Year','quarter']].astype(str).sum(axis=1)
1 loop, best of 3: 230 ms per loop

In [117]: %timeit df[['Year','quarter']].astype(str).sum(axis=1)
1 loop, best of 3: 230 ms per loop

In [118]: %timeit df[['Year','quarter']].apply(lambda x : '{}{}'.format(x[0],x[1]), axis=1)
1 loop, best of 3: 9.38 s per loop

@anton-vbr贡献的答案

解决方案 3：

df = pd.DataFrame({'Year': ['2014', '2015'], 'quarter': ['q1', 'q2']})
df['period'] = df[['Year', 'quarter']].apply(lambda x: ''.join(x), axis=1)

产生此数据框

   Year quarter  period
0  2014      q1  2014q1
1  2015      q2  2015q2

df[['Year', 'quarter']]此方法通过替换数据框的任意列切片，可推广到任意数量的字符串列，例如df.iloc[:,0:2].apply(lambda x: ''.join(x), axis=1)。

您可以在此处查看有关 apply() 方法的更多信息

解决方案 4：

访问器cat()的.str方法对于此非常有效：

>>> import pandas as pd
>>> df = pd.DataFrame([["2014", "q1"], 
...                    ["2015", "q3"]],
...                   columns=('Year', 'Quarter'))
>>> print(df)
   Year Quarter
0  2014      q1
1  2015      q3
>>> df['Period'] = df.Year.str.cat(df.Quarter)
>>> print(df)
   Year Quarter  Period
0  2014      q1  2014q1
1  2015      q3  2015q3

cat()甚至允许您添加分隔符，例如，假设您只有年份和时期的整数，您可以这样做：

>>> import pandas as pd
>>> df = pd.DataFrame([[2014, 1],
...                    [2015, 3]],
...                   columns=('Year', 'Quarter'))
>>> print(df)
   Year Quarter
0  2014       1
1  2015       3
>>> df['Period'] = df.Year.astype(str).str.cat(df.Quarter.astype(str), sep='q')
>>> print(df)
   Year Quarter  Period
0  2014       1  2014q1
1  2015       3  2015q3

连接多列只需将一系列列表或包含除第一列之外的所有列的数据框作为参数str.cat()传递到第一列（系列）上进行调用：

>>> df = pd.DataFrame(
...     [['USA', 'Nevada', 'Las Vegas'],
...      ['Brazil', 'Pernambuco', 'Recife']],
...     columns=['Country', 'State', 'City'],
... )
>>> df['AllTogether'] = df['Country'].str.cat(df[['State', 'City']], sep=' - ')
>>> print(df)
  Country       State       City                   AllTogether
0     USA      Nevada  Las Vegas      USA - Nevada - Las Vegas
1  Brazil  Pernambuco     Recife  Brazil - Pernambuco - Recife

请注意，如果您的 pandas 数据框/系列具有空值，则需要包含参数 na_rep 以用字符串替换 NaN 值，否则组合列将默认为 NaN。

解决方案 5：

这次使用带有 string.format() 的 lamba 函数。

import pandas as pd
df = pd.DataFrame({'Year': ['2014', '2015'], 'Quarter': ['q1', 'q2']})
print df
df['YearQuarter'] = df[['Year','Quarter']].apply(lambda x : '{}{}'.format(x[0],x[1]), axis=1)
print df

  Quarter  Year
0      q1  2014
1      q2  2015
  Quarter  Year YearQuarter
0      q1  2014      2014q1
1      q2  2015      2015q2

这使您可以根据需要处理非字符串并重新格式化值。

import pandas as pd
df = pd.DataFrame({'Year': ['2014', '2015'], 'Quarter': [1, 2]})
print df.dtypes
print df

df['YearQuarter'] = df[['Year','Quarter']].apply(lambda x : '{}q{}'.format(x[0],x[1]), axis=1)
print df

Quarter     int64
Year       object
dtype: object
   Quarter  Year
0        1  2014
1        2  2015
   Quarter  Year YearQuarter
0        1  2014      2014q1
1        2  2015      2015q2

解决方案 6：

概括到多列，为什么不呢：

columns = ['whatever', 'columns', 'you', 'choose']
df['period'] = df[columns].astype(str).sum(axis=1)

解决方案 7：

您可以使用 lambda：

combine_lambda = lambda x: '{}{}'.format(x.Year, x.quarter)

然后使用它来创建新列：

df['period'] = df.apply(combine_lambda, axis = 1)

解决方案 8：

假设您的 dataframe有df列Year和Quarter。

import pandas as pd
df = pd.DataFrame({'Quarter':'q1 q2 q3 q4'.split(), 'Year':'2000'})

假设我们想查看数据框；

df
>>>  Quarter    Year
   0    q1      2000
   1    q2      2000
   2    q3      2000
   3    q4      2000

最后，将Year和连接起来，Quarter如下所示。

df['Period'] = df['Year'] + ' ' + df['Quarter']

您现在可以print df 看到生成的数据框。

df
>>>  Quarter    Year    Period
    0   q1      2000    2000 q1
    1   q2      2000    2000 q2
    2   q3      2000    2000 q3
    3   q4      2000    2000 q4

如果您不想要年份和季度之间的空格，只需将其删除即可；

df['Period'] = df['Year'] + df['Quarter']

解决方案 9：

虽然@silvado 的答案很好，但如果你改变df.map(str)它df.astype(str)会更快：

import pandas as pd
df = pd.DataFrame({'Year': ['2014', '2015'], 'quarter': ['q1', 'q2']})

In [131]: %timeit df["Year"].map(str)
10000 loops, best of 3: 132 us per loop

In [132]: %timeit df["Year"].astype(str)
10000 loops, best of 3: 82.2 us per loop

解决方案 10：

以下是我发现的一个非常通用的实现：

In [1]: import pandas as pd 

In [2]: df = pd.DataFrame([[0, 'the', 'quick', 'brown'],
   ...:                    [1, 'fox', 'jumps', 'over'], 
   ...:                    [2, 'the', 'lazy', 'dog']],
   ...:                   columns=['c0', 'c1', 'c2', 'c3'])

In [3]: def str_join(df, sep, *cols):
   ...:     from functools import reduce
   ...:     return reduce(lambda x, y: x.astype(str).str.cat(y.astype(str), sep=sep), 
   ...:                   [df[col] for col in cols])
   ...: 

In [4]: df['cat'] = str_join(df, '-', 'c0', 'c1', 'c2', 'c3')

In [5]: df
Out[5]: 
   c0   c1     c2     c3                cat
0   0  the  quick  brown  0-the-quick-brown
1   1  fox  jumps   over   1-fox-jumps-over
2   2  the   lazy    dog     2-the-lazy-dog

解决方案 11：

更有效的是

def concat_df_str1(df):
    """ run time: 1.3416s """
    return pd.Series([''.join(row.astype(str)) for row in df.values], index=df.index)

以下是时间测试：

import numpy as np
import pandas as pd

from time import time


def concat_df_str1(df):
    """ run time: 1.3416s """
    return pd.Series([''.join(row.astype(str)) for row in df.values], index=df.index)


def concat_df_str2(df):
    """ run time: 5.2758s """
    return df.astype(str).sum(axis=1)


def concat_df_str3(df):
    """ run time: 5.0076s """
    df = df.astype(str)
    return df[0] + df[1] + df[2] + df[3] + df[4] + \n           df[5] + df[6] + df[7] + df[8] + df[9]


def concat_df_str4(df):
    """ run time: 7.8624s """
    return df.astype(str).apply(lambda x: ''.join(x), axis=1)


def main():
    df = pd.DataFrame(np.zeros(1000000).reshape(100000, 10))
    df = df.astype(int)

    time1 = time()
    df_en = concat_df_str4(df)
    print('run time: %.4fs' % (time() - time1))
    print(df_en.head(10))


if __name__ == '__main__':
    main()

最后，当sum使用（concat_df_str2）时，结果不是简单的连接，而是转换为整数。

解决方案 12：

使用zip可能会更快：

df["period"] = [''.join(i) for i in zip(df["Year"].map(str),df["quarter"])]

图形：

在此处输入图片描述

import pandas as pd
import numpy as np
import timeit
import matplotlib.pyplot as plt
from collections import defaultdict

df = pd.DataFrame({'Year': ['2014', '2015'], 'quarter': ['q1', 'q2']})

myfuncs = {
"df['Year'].astype(str) + df['quarter']":
    lambda: df['Year'].astype(str) + df['quarter'],
"df['Year'].map(str) + df['quarter']":
    lambda: df['Year'].map(str) + df['quarter'],
"df.Year.str.cat(df.quarter)":
    lambda: df.Year.str.cat(df.quarter),
"df.loc[:, ['Year','quarter']].astype(str).sum(axis=1)":
    lambda: df.loc[:, ['Year','quarter']].astype(str).sum(axis=1),
"df[['Year','quarter']].astype(str).sum(axis=1)":
    lambda: df[['Year','quarter']].astype(str).sum(axis=1),
    "df[['Year','quarter']].apply(lambda x : '{}{}'.format(x[0],x[1]), axis=1)":
    lambda: df[['Year','quarter']].apply(lambda x : '{}{}'.format(x[0],x[1]), axis=1),
    "[''.join(i) for i in zip(dataframe['Year'].map(str),dataframe['quarter'])]":
    lambda: [''.join(i) for i in zip(df["Year"].map(str),df["quarter"])]
}

d = defaultdict(dict)
step = 10
cont = True
while cont:
    lendf = len(df); print(lendf)
    for k,v in myfuncs.items():
        iters = 1
        t = 0
        while t < 0.2:
            ts = timeit.repeat(v, number=iters, repeat=3)
            t = min(ts)
            iters *= 10
        d[k][lendf] = t/iters
        if t > 2: cont = False
    df = pd.concat([df]*step)

pd.DataFrame(d).plot().legend(loc='upper center', bbox_to_anchor=(0.5, -0.15))
plt.yscale('log'); plt.xscale('log'); plt.ylabel('seconds'); plt.xlabel('df rows')
plt.show()

解决方案 13：

此解决方案使用中间步骤将 DataFrame 的两列压缩为包含值列表的单个列。这不仅适用于字符串，还适用于所有类型的列类型

import pandas as pd
df = pd.DataFrame({'Year': ['2014', '2015'], 'quarter': ['q1', 'q2']})
df['list']=df[['Year','quarter']].values.tolist()
df['period']=df['list'].apply(''.join)
print(df)

结果：

   Year quarter        list  period
0  2014      q1  [2014, q1]  2014q1
1  2015      q2  [2015, q2]  2015q2

解决方案 14：

以下是我对上述解决方案的总结，将两个具有 int 和 str 值的列连接/组合成一个新列，并在列值之间使用分隔符。有三种解决方案可用于此目的。

# be cautious about the separator, some symbols may cause "SyntaxError: EOL while scanning string literal".
# e.g. ";;" as separator would raise the SyntaxError

separator = "&&" 

# pd.Series.str.cat() method does not work to concatenate / combine two columns with int value and str value. This would raise "AttributeError: Can only use .cat accessor with a 'category' dtype"

df["period"] = df["Year"].map(str) + separator + df["quarter"]
df["period"] = df[['Year','quarter']].apply(lambda x : '{} && {}'.format(x[0],x[1]), axis=1)
df["period"] = df.apply(lambda x: f'{x["Year"]} && {x["quarter"]}', axis=1)

解决方案 15：

我的看法....

listofcols = ['col1','col2','col3']
df['combined_cols'] = ''

for column in listofcols:
    df['combined_cols'] = df['combined_cols'] + ' ' + df[column]
'''

解决方案 16：

当使用加法运算符将列与字符串连接起来时，+如果有NaN，则整个输出将是，NaN因此使用fillna()

df["join"] = "some" + df["col"].fillna(df["val_if_nan"])

解决方案 17：

正如许多人之前提到的，您必须将每列转换为字符串，然后使用加号运算符将两个字符串列合并。使用 NumPy 可以获得很大的性能提升。

%timeit df['Year'].values.astype(str) + df.quarter
71.1 ms ± 3.76 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

%timeit df['Year'].astype(str) + df['quarter']
565 ms ± 22.3 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

解决方案 18：

可以使用DataFrame的assign方法：

df= (pd.DataFrame({'Year': ['2014', '2015'], 'quarter': ['q1', 'q2']}).
  assign(period=lambda x: x.Year+x.quarter ))

解决方案 19：

与@geher 答案类似，但可以使用任何您喜欢的分隔符：

SEP = " "
INPUT_COLUMNS_WITH_SEP = ",sep,".join(INPUT_COLUMNS).split(",")

df.assign(sep=SEP)[INPUT_COLUMNS_WITH_SEP].sum(axis=1)

解决方案 20：

数据框.eval()

对于一些简洁的代码，我们可以使用.eval()。我们可以使用运算符水平连接两个（或更多）字符串 dtype 列，+如下所示。

df = pd.DataFrame({'A': ['x', 'y', 'z'], 'B': ['1', '2', '3']}, dtype='string')
df['C'] = df.eval("A + B")

您甚至可以在评估表达式中包含新的列分配（这也提供了就地执行此操作的可能性）。

df = df.eval('C = A + B')
df.eval('C = A + B', inplace=True)

eval不允许使用类似简洁的方式添加分隔符；但是，我们可以在数值表达式中调用str.cat()（具有kwarg）。sep=

df = df.eval("D = A.str.cat([B, C], '_')")

产生以下输出（其中列、A和B水平C连接）：

结果

何时使用矢量化连接与显式循环

本页给出了主要的字符串连接方法：

  • 矢量化+：df['A'] + df['B']

  • 循环中的字符串格式化（注意：将列转换为列表可以使循环更快）：

[f"{x}{y}" for x,y in zip(df['A'].tolist(), df['B'].tolist())])]

  • 矢量化str.cat()：df['A'].str.cat(df['B'])

如下图所示，+如果要连接的字符串很短（如 OP 中所示），则矢量化连接（通过 ）是最快的。但是，如果字符串很长（例如，每个单元格包含一条推文或一本书的摘录），则显式 Python 循环（在列表推导中使用 f 字符串）是最快的。

性能图

重现上图的代码：

import matplotlib.pyplot as plt
import pandas as pd
import perfplot

fig, axs = plt.subplots(1, 2, figsize=(15,5))
for ax, s, title in zip(axs, ('a'*1000, 'a'), ("long", "short")):
    plt.sca(ax)
    perfplot.plot(
        kernels=[lambda df: df.assign(C=df['A'] + '_' + df['B']),
                 lambda df: df.assign(C=df['A'].str.cat(df['B'], '_')),
                 lambda df: df.assign(C=[f"{x}_{y}" for x,y in zip(df['A'].tolist(), df['B'].tolist())])],
        n_range=[2**k for k in range(18)],
        setup=lambda n: pd.DataFrame({'A': [s]*n, 'B': [s]*n}),
        labels=["df['A'] + df['B']", "str.cat", "list comp"],
        xlabel="DataFrame length",
        title=f"When the strings are {title}", 
        equality_check=pd.DataFrame.equals)
fig.tight_layout()
fig.savefig("string_concat_perf.png")

解决方案 21：

def madd(x):
    """Performs element-wise string concatenation with multiple input arrays.

    Args:
        x: iterable of np.array.

    Returns: np.array.
    """
    for i, arr in enumerate(x):
        if type(arr.item(0)) is not str:
            x[i] = x[i].astype(str)
    return reduce(np.core.defchararray.add, x)

例如：

data = list(zip([2000]*4, ['q1', 'q2', 'q3', 'q4']))
df = pd.DataFrame(data=data, columns=['Year', 'quarter'])
df['period'] = madd([df[col].values for col in ['Year', 'quarter']])

df

    Year    quarter period
0   2000    q1  2000q1
1   2000    q2  2000q2
2   2000    q3  2000q3
3   2000    q4  2000q4

解决方案 22：

使用.combine_first。

df['Period'] = df['Year'].combine_first(df['Quarter'])
相关推荐
置顶 2024年20款好用的项目管理软件推荐，项目管理提效的20个工具和技巧
2024年20款好用的项目管理软件推荐，项目管理提效的20个工具和技巧
  为什么项目管理通常仍然耗时且低效？您是否还在反复更新电子表格、淹没在便利贴中并参加每周更新会议？这确实是耗费时间和精力。借助软件工具的帮助，您可以一目了然地全面了解您的项目。如今，国内外有足够多优秀的项目管理软件可以帮助您掌控每个项目。什么是项目管理软件？项目管理软件是广泛行业用于项目规划、资源分配和调度的软件。它使项...
项目管理软件   1043  
IPD流程全称及其在敏捷开发中的融合应用
IPD流程全称及其在敏捷开发中的融合应用
  IPD（Integrated Product Development，集成产品开发）是一种系统化的产品开发方法论，旨在通过跨职能团队的协作，优化产品开发的效率和质量。IPD流程强调从市场需求出发，通过并行工程、跨部门协作和阶段性评审，确保产品从概念到上市的每个环节都高效且可控。随着敏捷开发方法的普及，越来越多的企业开始...
华为IPD流程   41  
IPD流程与敏捷开发的结合应用指南
IPD流程与敏捷开发的结合应用指南
  随着企业产品开发复杂度的提升以及市场需求的快速变化，传统的产品开发模式逐渐显现出局限性。集成产品开发（IPD）流程与敏捷开发（Agile Development）作为两种主流的开发方法论，分别从系统化管理和快速响应需求的角度为企业提供了解决方案。然而，单独使用其中一种方法往往无法完全满足企业在效率、质量和创新上的多重需...
华为IPD流程   35  
华为IPD流程如何实现技术与市场双驱动
华为IPD流程如何实现技术与市场双驱动
  华为IPD（Integrated Product Development，集成产品开发）流程是华为公司成功的关键因素之一。它不仅帮助华为在技术上实现了快速创新，还通过市场导向确保了产品的商业成功。IPD流程通过整合技术与市场双驱动，实现了从需求定义到产品交付的全生命周期管理。这种模式不仅提高了产品的开发效率，还降低了市...
IPD流程中PDCP是什么意思   32  
如何在研发IPD流程中优化资源分配的7个技巧
如何在研发IPD流程中优化资源分配的7个技巧
  在研发领域，集成产品开发（IPD）流程已经成为企业提升创新效率和市场竞争力的重要手段。然而，资源分配的不合理往往是制约IPD流程效率的关键因素之一。无论是人力资源、财务资源还是技术资源，如何高效分配直接关系到项目的成功与否。优化资源分配不仅能够缩短产品开发周期，还能降低研发成本，提升产品的市场竞争力。因此，掌握资源分配...
IPD流程中CDCP   34  
热门文章
2024年项目管理软件排行榜
2024年20款好用的项目管理软件推荐，项目管理提效的20个工具和技巧
img020
使用 Python 'Requests' 模块的代理
img044
10个项目管理常见问题解答：包括难点和解决方法
项目管理软件
项目延期的原因有哪些？如何有效预防和管理？
项目管理软件
项目管理指南：制定项目实施计划的6大步骤有哪些？
项目里程碑计划模板
项目里程碑计划模板怎么写?设定项目里程碑的5个方法
好用的项目管理软件有哪些
2024年开源项目管理软件有哪些？推荐5款好用的项目管理工具
项目管理软件有哪些？
热门标签
更多>
IPD流程 项目管理 IT项目管理 敏捷开发 项目管理软件 Scrum 敏捷项目管理 IPD流程管理 项目风险管理 项目管理工具 项目经理 极限编程  产品管理  项目经理职责 项目路线图 项目进度管理 测试管理工具 项目预算管理 PMP认证 瀑布式管理 项目范围管理 IT科技 项目管理平台 工程项目管理 项目资源管理 pmp证书考试
云禅道AD
禅道项目管理软件

云端的项目管理软件

尊享禅道项目软件收费版功能

无需维护，随时随地协同办公

内置subversion和git源码管理

每天备份，随时转为私有部署

免费试用