पंडों का उपयोग करते हुए मेरे पास पायथन में 20 x 4000 डेटाफ्रेम है। इनमें से दो स्तंभों के नाम Yearऔर हैं quarter। मैं एक वैरिएबल बनाना चाहूंगा जिसे कहा जाता periodहै Year = 2000और बनाता quarter= q2है2000q2 ।
किसी को भी उस के साथ मदद कर सकते हैं?
जवाबों:
यदि दोनों स्तंभ तार हैं, तो आप उन्हें सीधे रूप से परिवर्तित कर सकते हैं:
df["period"] = df["Year"] + df["quarter"]यदि स्तंभों में से कोई एक (या दोनों) स्ट्रिंग टाइप नहीं किया गया है, तो आपको इसे (उन्हें) पहले बदलना चाहिए,
df["period"] = df["Year"].astype(str) + df["quarter"]यदि आपको कई स्ट्रिंग कॉलम में शामिल होने की आवश्यकता है, तो आप उपयोग कर सकते हैं agg:
df['period'] = df[['Year', 'quarter', ...]].agg('-'.join, axis=1)जहां "-" विभाजक है।
sum।
dataframe["period"] = dataframe["Year"].map(str) + dataframe["quarter"].map(str)मैप करेंगे तो बस सभी प्रविष्टियों में स्ट्रिंग रूपांतरण लागू होगा ।
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) ।
आप यहां आवेदन () पद्धति के बारे में अधिक जानकारी देख सकते हैं
lambda x: ''.join(x)बस ''.join, नहीं?
lambda x: ''.join(x)निर्माण का लंबोदर हिस्सा कुछ भी नहीं करता है; यह lambda x: sum(x)सिर्फ के बजाय उपयोग करने जैसा है sum।
''.join, अर्थात df['period'] = df[['Year', 'quarter']].apply(''.join, axis=1):।
joinकेवल strएक पुनरावृत्त में उदाहरण लेता है । mapउन सभी में परिवर्तित करने के लिए a का उपयोग करें strऔर फिर उपयोग करें join।
[''.join(i) for i in zip(df["Year"].map(str),df["quarter"])]या थोड़ा धीमा लेकिन अधिक कॉम्पैक्ट:
df.Year.str.cat(df.quarter)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)अपडेट करें: पंडों 0.19.0 का उपयोग कर नए समय
सीपीयू / जीपीयू अनुकूलन के बिना समय (सबसे तेज से सबसे धीमी गति से हल):
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 loopCPU / 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 द्वारा उत्तर योगदान
df.T.apply(lambda x: x.str.cat(sep=''))
विधि 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 2015q3cat() यहां तक कि आपको एक विभाजक जोड़ने की अनुमति देता है, उदाहरण के लिए, मान लें कि आपके पास केवल वर्ष और अवधि के लिए पूर्णांक हैं, तो आप यह कर सकते हैं:
>>> 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ध्यान दें कि यदि आपके पांडा डेटाफ़्रेम / श्रृंखला में शून्य मान हैं, तो आपको NaN मानों को स्ट्रिंग के साथ बदलने के लिए पैरामीटर na_rep को शामिल करना होगा, अन्यथा संयुक्त स्तंभ NaN को डिफ़ॉल्ट कर देगा।
lambdaया map; यह भी सिर्फ सबसे साफ पढ़ता है।
str.cat()। मैं उत्तर में संशोधन करूँगा
sepकीवर्ड की आपूर्ति करना था ? पांडा में 0.23.4। धन्यवाद!
sepयदि आप concatenated स्ट्रिंग के भागों को अलग करने का इरादा पैरामीटर केवल आवश्यक है। यदि आपको कोई त्रुटि मिलती है, तो कृपया हमें अपना असफल उदाहरण दिखाएं।
इस समय string.format () के साथ एक लांबा फ़ंक्शन का उपयोग।
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
2000q2Yearएक स्ट्रिंग नहीं है
df['Year'].astype(str) + '' + df['quarter'].astype(str)
हालांकि @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हमें अपने लगता है चलो 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']df['Period'] = df['Year'].map(str) + df['Quarter'].map(str)
TypeError: Series cannot perform the operation +जब मैं या तो चलाने df2['filename'] = df2['job_number'] + '.' + df2['task_number']या df2['filename'] = df2['job_number'].map(str) + '.' + df2['task_number'].map(str)।
df2['filename'] = df2['job_number'].astype(str) + '.' + df2['task_number'].astype(str)काम किया।
dataframeमेरे द्वारा बनाए गए उदाहरण को देखते हैं, तो आप देखेंगे कि सभी कॉलम stringएस हैं।
यहाँ एक कार्यान्वयन है जो मुझे बहुत बहुमुखी लगता है:
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) का उपयोग किया जाता है, तो परिणाम केवल समतल नहीं होता है, यह पूर्णांक तक पहुंच जाएगा।
df.values[:, 0:3]या df.values[:, [0,2]]।
कई कॉलमों के लिए सामान्यीकरण, क्यों नहीं:
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)पहले उद्धरण के अंदर पसंदीदा परिसीमा निर्दिष्ट करें
यह समाधान एक मध्यवर्ती चरण का उपयोग करता है जो डेटाफ़्रेम के दो स्तंभों को एक एकल कॉलम को संपीड़ित करता है जिसमें मानों की सूची होती है। यह न केवल तार के लिए बल्कि सभी प्रकार के कॉलम-डीटीपी के लिए काम करता है
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)df2['filename'] = df2['job_number'].values.astype(str) + '.' + df2['task_number'].values.astype(str)-> आउटपुट : TypeError: ufunc 'add' did not contain a loop with signature matching types dtype('<U21') dtype('<U21') dtype('<U21')। दोनों job_number और task_number ints हैं।
df['Year'].values.astype(str) + df.quarter
मुझे लगता है कि पंडों में स्तंभों को संयोजित करने का सबसे अच्छा तरीका दोनों स्तंभों को पूर्णांक और फिर str में परिवर्तित करना है।
df[['Year', 'quarter']] = df[['Year', 'quarter']].astype(int).astype(str)
df['Period']= df['Year'] + 'q' + df['quarter']यहाँ कॉलमों के मूल्यों के बीच विभाजक का उपयोग करते हुए, एक नए कॉलम में इंट और स्ट्रेट वैल्यू के साथ दो कॉलम को जोड़ने / संयोजित करने के लिए उपरोक्त समाधानों का मेरा सारांश है। इस उद्देश्य के लिए तीन समाधान काम करते हैं।
# 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']).combine_firstया तो मूल्य 'Year'में संग्रहीत किया जा रहा है 'Period', या, अगर यह अशक्त है, से मूल्य होगा 'Quarter'। यह दो तारों को समतल नहीं करेगा और उन्हें अंदर संग्रहीत करेगा 'Period'।
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 2000q4dataframe["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)भी।
add(dataframe.iloc[:, 0:10])उदाहरण के लिए कहते हैं ?