मेरी राय में शीर्ष उत्तर त्रुटिपूर्ण है। उम्मीद है, कोई भी बड़े पैमाने पर अपने नाम स्थान के साथ सभी पांडा आयात नहीं कर रहा है from pandas import *। इसके अलावा, यह mapविधि उन समयों के लिए आरक्षित होनी चाहिए जब इसे एक शब्दकोश या श्रृंखला पास करते हैं। यह एक फ़ंक्शन ले सकता है लेकिन यह वह applyहै जिसका उपयोग किया जाता है।
इसलिए, यदि आप उपरोक्त दृष्टिकोण का उपयोग करना चाहते हैं, तो मैं इसे इस तरह से लिखूंगा
df["A1"], df["A2"] = zip(*df["a"].apply(calculate))
वास्तव में यहाँ ज़िप का उपयोग करने का कोई कारण नहीं है। आप बस यह कर सकते हैं:
df["A1"], df["A2"] = calculate(df['a'])
बड़े डेटाफ़्रेम पर यह दूसरी विधि भी बहुत तेज़ है
df = pd.DataFrame({'a': [1,2,3] * 100000, 'b': [2,3,4] * 100000})
DataFrame 300,000 पंक्तियों के साथ बनाया गया
%timeit df["A1"], df["A2"] = calculate(df['a'])
2.65 ms ± 92.4 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
%timeit df["A1"], df["A2"] = zip(*df["a"].apply(calculate))
159 ms ± 5.24 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
ज़िप से 60x तेज
सामान्य तौर पर, लागू होने से बचें
लागू करें आमतौर पर पायथन सूची पर पुनरावृत्ति की तुलना में बहुत तेजी से नहीं होता है। चलो ऊपर के रूप में एक ही काम करने के लिए फॉर-लूप के प्रदर्शन का परीक्षण करें
%%timeit
A1, A2 = [], []
for val in df['a']:
A1.append(val**2)
A2.append(val**3)
df['A1'] = A1
df['A2'] = A2
298 ms ± 7.14 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
तो यह दोगुना धीमा है जो एक भयानक प्रदर्शन प्रतिगमन नहीं है, लेकिन यदि हम ऊपर का पता लगाते हैं, तो हमें बेहतर प्रदर्शन मिलता है। मान लें, आप ipython का उपयोग कर रहे हैं:
%load_ext cython
%%cython
cpdef power(vals):
A1, A2 = [], []
cdef double val
for val in vals:
A1.append(val**2)
A2.append(val**3)
return A1, A2
%timeit df['A1'], df['A2'] = power(df['a'])
72.7 ms ± 2.16 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
बिना आवेदन के सीधे कार्य करना
यदि आप प्रत्यक्ष सदिश संचालन का उपयोग करते हैं तो आप और भी अधिक गति सुधार प्राप्त कर सकते हैं।
%timeit df['A1'], df['A2'] = df['a'] ** 2, df['a'] ** 3
5.13 ms ± 320 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
यह हमारे छोरों के बजाय NumPy के बेहद तेज वेक्टर किए गए कार्यों का लाभ उठाता है। अब हमारे पास मूल पर 30x स्पीडअप है।
के साथ सबसे सरल गति परीक्षण apply
उपरोक्त उदाहरण को स्पष्ट रूप से दिखाना चाहिए कि कितना धीमा applyहो सकता है, लेकिन बस इसके अतिरिक्त स्पष्ट चलो सबसे बुनियादी उदाहरण देखें। चलो लागू होते हैं और बिना लागू के 10 मिलियन संख्याओं की एक श्रृंखला को स्क्वायर करते हैं
s = pd.Series(np.random.rand(10000000))
%timeit s.apply(calc)
3.3 s ± 57.4 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
बिना आवेदन 50x तेज है
%timeit s ** 2
66 ms ± 2 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)