팬더 / 파이썬에서 데이터 프레임에 두 개의 텍스트 열 결합

팬더를 사용하여 Python에서 20 x 4000 데이터 프레임이 있습니다. 이 열 중 두 개는 이름이 Year및 quarter입니다. periodmake Year = 2000및 quarter= q2into 라는 변수를 만들고 싶습니다 2000q2.

누구든지 그걸 도울 수 있습니까?

두 열이 모두 문자열 인 경우 직접 연결할 수 있습니다.

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)

여기서 "-"는 구분 기호입니다.

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 () 메소드에 대한 자세한 정보는 여기에서 확인할 수 있습니다.

작은 데이터 세트 (<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']

업데이트 : 타이밍 그래프 팬더 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

이 방법 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

팬더 데이터 프레임 / 시리즈에 null 값이있는 경우 NaN 값을 문자열로 바꾸려면 na_rep 매개 변수를 포함해야합니다. 그렇지 않으면 결합 된 열의 기본값은 NaN입니다.

이번에는 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

귀하의 질문에 대한 간단한 답변.

    year    quarter
0   2000    q1
1   2000    q2

> df['year_quarter'] = df['year'] + '' + df['quarter']

> print(df['year_quarter'])
  2000q1
  2000q2

@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

우리는 당신의 가정하자 dataframeIS를 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']

다음은 매우 다재다능한 구현입니다.

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

데이터가 데이터 프레임에 삽입되면이 명령으로 문제를 해결할 수 있습니다.

df['period'] = df[['Year', 'quarter']].apply(lambda x: ' '.join(x.astype(str)), axis=1)

더 효율적인

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] + \
           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)를 사용하면 결과가 단순히 concat이 아니라 정수로 변환됩니다.

여러 열로 일반화하는 이유는 무엇입니까?

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

사용하여 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()

가장 간단한 해결책 :

일반 솔루션

df['combined_col'] = df[['col1', 'col2']].astype(str).apply('-'.join, axis=1)

질문 특정 솔루션

df['quarter_year'] = df[['quarter', 'year']].astype(str).apply(''.join, axis=1)

.join 전에 따옴표 안에 선호 분리 문자를 지정하십시오.

이 솔루션은 DataFrame의 두 열을 값 목록 이 포함 된 단일 열로 압축 하는 중간 단계를 사용 합니다. 이것은 문자열뿐만 아니라 모든 종류의 열 dtype에 적용됩니다.

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

많은 사람들이 앞에서 언급했듯이 각 열을 문자열로 변환 한 다음 더하기 연산자를 사용하여 두 문자열 열을 결합해야합니다. 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)

팬더에서 열을 결합하는 가장 좋은 방법은 두 열을 정수로 변환 한 다음 str로 변환하는 것입니다.

df[['Year', 'quarter']] = df[['Year', 'quarter']].astype(int).astype(str)
df['Period']= df['Year'] + 'q' + df['quarter']

다음은 열 값 사이의 구분 기호를 사용하여 두 열을 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)

사용하십시오 .combine_first.

df['Period'] = df['Year'].combine_first(df['Quarter'])

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

DataFrame의 assign 메소드를 사용할 수 있습니다 .

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

dataframe["period"] = dataframe["Year"].astype(str).add(dataframe["quarter"])

또는 값이 [2000] [4]와 같고 [2000q4]를 만들려는 경우

dataframe["period"] = dataframe["Year"].astype(str).add('q').add(dataframe["quarter"]).astype(str)

대체 .astype(str)와 .map(str)도 작동합니다.