एक नया पांडा कॉलम बनाने के लिए कई तर्कों के साथ फ़ंक्शन लागू करना

Question

मैं pandasदो मौजूदा स्तंभों के लिए एक फ़ंक्शन लागू करके डेटा फ़्रेम में एक नया कॉलम बनाना चाहता हूं । इस उत्तर के बाद मैं एक नया कॉलम बना पा रहा हूं जब मुझे एक तर्क के रूप में केवल एक कॉलम की जरूरत है:

import pandas as pd
df = pd.DataFrame({"A": [10,20,30], "B": [20, 30, 10]})

def fx(x):
    return x * x

print(df)
df['newcolumn'] = df.A.apply(fx)
print(df)

हालाँकि, मुझे यह पता नहीं चल सकता है कि जब फ़ंक्शन को कई तर्कों की आवश्यकता होती है, तो वही काम कैसे करें। उदाहरण के लिए, मैं नीचे दिए गए फ़ंक्शन में कॉलम A और कॉलम B पास करके एक नया कॉलम कैसे बनाऊं?

def fxy(x, y):
    return x * y

Answer 1

वैकल्पिक रूप से, आप numpy अंतर्निहित फ़ंक्शन का उपयोग कर सकते हैं:

>>> import numpy as np
>>> df = pd.DataFrame({"A": [10,20,30], "B": [20, 30, 10]})
>>> df['new_column'] = np.multiply(df['A'], df['B'])
>>> df
    A   B  new_column
0  10  20         200
1  20  30         600
2  30  10         300

या सामान्य मामले में मनमाने ढंग से कार्य करना:

>>> def fx(x, y):
...     return x*y
...
>>> df['new_column'] = np.vectorize(fx)(df['A'], df['B'])
>>> df
    A   B  new_column
0  10  20         200
1  20  30         600
2  30  10         300

Comments

जवाब के लिए धन्यवाद! मैं उत्सुक हूं, क्या यह सबसे तेज समाधान है?

— एमवी

उपयोग किए गए वेक्टर संस्करण np.vectorize()आश्चर्यजनक रूप से तेज़ हैं। धन्यवाद।

— stackoverflowuser2010

यह एक उपयोगी उपाय है। यदि फ़ंक्शन x और y के इनपुट तर्कों का आकार बराबर नहीं है, तो आपको एक त्रुटि मिलती है। उस स्थिति में, @RomanPekar समाधान बिना किसी समस्या के काम करता है। मैंने प्रदर्शन की तुलना नहीं की।

— एहसान सदर

मुझे पता है कि यह एक पुराना उत्तर है, लेकिन: मेरे पास एक किनारे का मामला है, जिसमें np.vectorizeकाम नहीं करता है। इसका कारण यह है कि, स्तंभों में से एक प्रकार का है pandas._libs.tslibs.timestamps.Timestamp, जो numpy.datetime64वैश्वीकरण द्वारा प्रकार में बदल जाता है । दो प्रकार विनिमेय नहीं हैं, जिससे फ़ंक्शन बुरी तरह से व्यवहार करता है। इस पर कोई सुझाव? ( .applyइस के अलावा अन्य स्पष्ट रूप से बचा जा सकता है)

— एलरुडी

महान समाधान! यदि कोई सोच रहा है कि वेक्टर तुलनात्मक कार्यों के साथ-साथ स्ट्रिंग तुलनात्मक कार्यों के लिए सुपर फास्ट काम करता है।

— infiniteloop

Answer 2

आप @greenAfrican उदाहरण के साथ जा सकते हैं, यदि आपके लिए अपने फ़ंक्शन को फिर से लिखना संभव है। लेकिन अगर आप अपने कार्य को फिर से लिखना नहीं चाहते हैं, तो आप इसे इस तरह लागू करने के लिए अनाम फ़ंक्शन में लपेट सकते हैं:

>>> def fxy(x, y):
...     return x * y

>>> df['newcolumn'] = df.apply(lambda x: fxy(x['A'], x['B']), axis=1)
>>> df
    A   B  newcolumn
0  10  20        200
1  20  30        600
2  30  10        300

Comments

यह एक महान टिप है, और यह लागू कॉल के पास कॉलम संदर्भ छोड़ता है (वास्तव में इसमें)। मैंने इस टिप का उपयोग किया और मल्टी-कॉलम आउटपुट टिप @toto_tico ने एक 3 कॉलम इन, ४ कॉलम आउट फ़ंक्शन उत्पन्न करने के लिए आपूर्ति की! बहुत अच्छा काम करता है!

— RufusVS

वाह, ऐसा लगता है कि आप केवल ओपी के नंगे न्यूनतम उदाहरण पर ध्यान केंद्रित नहीं कर रहे हैं, लेकिन पूरी समस्या को संबोधित करते हैं, धन्यवाद, वास्तव में आपको क्या चाहिए! :)

— मैट

Answer 3

इससे समस्या हल होती है:

df['newcolumn'] = df.A * df.B

आप भी कर सकते हैं:

def fab(row):
  return row['A'] * row['B']

df['newcolumn'] = df.apply(fab, axis=1)

Comments

यह उत्तर इस खिलौने के उदाहरण को हल करता है और मेरे लिए अपने वास्तविक कार्य को फिर से लिखने के लिए पर्याप्त होगा, लेकिन यह संबोधित नहीं करता है कि संदर्भ स्तंभों को फिर से लिखने के बिना पहले से परिभाषित फ़ंक्शन को कैसे लागू किया जाए।

— माइकल

Answer 4

यदि आपको एक साथ कई कॉलम बनाने की आवश्यकता है :

1. डेटाफ़्रेम बनाएँ:

   import pandas as pd
   df = pd.DataFrame({"A": [10,20,30], "B": [20, 30, 10]})

2. फ़ंक्शन बनाएं:

   def fab(row):                                                  
       return row['A'] * row['B'], row['A'] + row['B']

3. नए कॉलम असाइन करें:

   df['newcolumn'], df['newcolumn2'] = zip(*df.apply(fab, axis=1))

Comments

मैं सोच रहा था कि एक आवेदन के साथ मैं कई कॉलम कैसे तैयार कर सकता हूं! मैंने इसका उपयोग @ रोमन पाकर के जवाब के साथ 3 कॉलम इन, 4 कॉलम आउट फंक्शन उत्पन्न करने के लिए किया है! बहुत अच्छा काम करता है!

— रुफुसवीस

Answer 5

एक और अधिक स्पष्ट शैली साफ वाक्यविन्यास:

df["new_column"] = df.apply(lambda x: x["A"] * x["B"], axis = 1)

या,

df["new_column"] = df["A"] * df["B"]