पंडों के साथ अधिकतम दो या दो से अधिक कॉलम खोजें

Question 1

मैं कॉलम के साथ एक dataframe है A, B। मुझे Cहर रिकॉर्ड / पंक्ति के लिए एक कॉलम बनाने की जरूरत है :

C = max(A, B)।

मै यह कैसे कर सकता हूँ?

Question 2

आप इस तरह अधिकतम प्राप्त कर सकते हैं:

>>> import pandas as pd
>>> df = pd.DataFrame({"A": [1,2,3], "B": [-2, 8, 1]})
>>> df
   A  B
0  1 -2
1  2  8
2  3  1
>>> df[["A", "B"]]
   A  B
0  1 -2
1  2  8
2  3  1
>>> df[["A", "B"]].max(axis=1)
0    1
1    8
2    3

इसलिए:

>>> df["C"] = df[["A", "B"]].max(axis=1)
>>> df
   A  B  C
0  1 -2  1
1  2  8  8
2  3  1  3

यदि आप जानते हैं कि "ए" और "बी" एकमात्र स्तंभ हैं, तो आप भी दूर हो सकते हैं

>>> df["C"] = df.max(axis=1)

और आप भी इस्तेमाल कर सकते हैं .apply(max, axis=1), मुझे लगता है।

Question 3

@ डीएसएम का जवाब लगभग किसी भी सामान्य परिदृश्य में पूरी तरह से ठीक है। लेकिन अगर आप प्रोग्रामर का प्रकार हैं जो सतह के स्तर से थोड़ा गहरा जाना चाहते हैं, तो आपको यह जानने में दिलचस्पी हो सकती है कि सीधे के बजाय अंतर्निहित .to_numpy()(या .values<0.24) सरणी पर संख्यात्मक कार्यों को कॉल करने के लिए यह थोड़ा तेज़ है DataFrame / Series ऑब्जेक्ट पर परिभाषित कॉलिंग (साइटोनाइज्ड) फ़ंक्शन।

उदाहरण के लिए, आप ndarray.max()पहली धुरी के साथ उपयोग कर सकते हैं ।

# Data borrowed from @DSM's post.
df = pd.DataFrame({"A": [1,2,3], "B": [-2, 8, 1]})
df
   A  B
0  1 -2
1  2  8
2  3  1

df['C'] = df[['A', 'B']].values.max(1)
# Or, assuming "A" and "B" are the only columns, 
# df['C'] = df.values.max(1) 
df

   A  B  C
0  1 -2  1
1  2  8  8
2  3  1  3

यदि आपका डेटा है NaN, तो आपको आवश्यकता होगी numpy.nanmax:

df['C'] = np.nanmax(df.values, axis=1)
df

   A  B  C
0  1 -2  1
1  2  8  8
2  3  1  3

आप भी इस्तेमाल कर सकते हैं numpy.maximum.reduce। numpy.maximumएक ufunc (यूनिवर्सल फंक्शन) है , और हर ufunc में एक हैreduce :

df['C'] = np.maximum.reduce(df['A', 'B']].values, axis=1)
# df['C'] = np.maximum.reduce(df[['A', 'B']], axis=1)
# df['C'] = np.maximum.reduce(df, axis=1)
df

   A  B  C
0  1 -2  1
1  2  8  8
2  3  1  3

np.maximum.reduceऔर np.maxकम या ज्यादा (सामान्य आकार के DataFrames के लिए) के समान प्रतीत होता है - और इससे भी तेज एक शेड होता है DataFrame.max। मुझे लगता है कि यह अंतर लगभग स्थिर रहता है, और यह आंतरिक ओवरहेड (अनुक्रमण संरेखण, NaNs, आदि से निपटने) के कारण है।

परफ्लोट का उपयोग करके ग्राफ उत्पन्न किया गया था । संदर्भ के लिए बेंचमार्किंग कोड:

import pandas as pd
import perfplot

np.random.seed(0)
df_ = pd.DataFrame(np.random.randn(5, 1000))

perfplot.show(
    setup=lambda n: pd.concat([df_] * n, ignore_index=True),
    kernels=[
        lambda df: df.assign(new=df.max(axis=1)),
        lambda df: df.assign(new=df.values.max(1)),
        lambda df: df.assign(new=np.nanmax(df.values, axis=1)),
        lambda df: df.assign(new=np.maximum.reduce(df.values, axis=1)),
    ],
    labels=['df.max', 'np.max', 'np.maximum.reduce', 'np.nanmax'],
    n_range=[2**k for k in range(0, 15)],
    xlabel='N (* len(df))',
    logx=True,
    logy=True)