पांडा का उपयोग करते हुए दो कॉलम की तुलना करें

Question 1

इसे शुरुआती बिंदु के रूप में उपयोग करना:

a = [['10', '1.2', '4.2'], ['15', '70', '0.03'], ['8', '5', '0']]
df = pd.DataFrame(a, columns=['one', 'two', 'three'])

Out[8]: 
  one  two three
0   10  1.2   4.2
1   15  70   0.03
2    8   5     0

मैं ifपंडों के भीतर एक बयान की तरह कुछ का उपयोग करना चाहता हूं ।

if df['one'] >= df['two'] and df['one'] <= df['three']:
    df['que'] = df['one']

मूल रूप से, ifकथन के माध्यम से प्रत्येक पंक्ति की जांच करें , नया कॉलम बनाएं।

डॉक्स का उपयोग करने के लिए कहते हैं, .allलेकिन कोई उदाहरण नहीं है ...

Question 2

आप np.where का उपयोग कर सकते हैं । तो condएक बूलियन सरणी है, और Aऔर Bसरणियों, तो कर रहे हैं

C = np.where(cond, A, B)

सी को परिभाषित करता है Aकि condयह कहां तक सही है और Bकहां condगलत है।

import numpy as np
import pandas as pd

a = [['10', '1.2', '4.2'], ['15', '70', '0.03'], ['8', '5', '0']]
df = pd.DataFrame(a, columns=['one', 'two', 'three'])

df['que'] = np.where((df['one'] >= df['two']) & (df['one'] <= df['three'])
                     , df['one'], np.nan)

पैदावार

  one  two three  que
0  10  1.2   4.2   10
1  15   70  0.03  NaN
2   8    5     0  NaN

यदि आपके पास एक से अधिक स्थितियां हैं, तो आप इसके बजाय np.select का उपयोग कर सकते हैं । उदाहरण के लिए, यदि आप df['que']समान df['two']होने की इच्छा रखते हैं df['one'] < df['two'], तो

conditions = [
    (df['one'] >= df['two']) & (df['one'] <= df['three']), 
    df['one'] < df['two']]

choices = [df['one'], df['two']]

df['que'] = np.select(conditions, choices, default=np.nan)

पैदावार

  one  two three  que
0  10  1.2   4.2   10
1  15   70  0.03   70
2   8    5     0  NaN

अगर हम यह मान सकते हैं कि df['one'] >= df['two']कब df['one'] < df['two']गलत है, तो शर्तों और विकल्पों को सरल बनाया जा सकता है

conditions = [
    df['one'] < df['two'],
    df['one'] <= df['three']]

choices = [df['two'], df['one']]

(इस धारणा अगर सच नहीं हो सकता df['one']या df['two']Nans होते हैं।)

ध्यान दें कि

a = [['10', '1.2', '4.2'], ['15', '70', '0.03'], ['8', '5', '0']]
df = pd.DataFrame(a, columns=['one', 'two', 'three'])

स्ट्रिंग मानों के साथ एक DataFrame परिभाषित करता है। चूंकि वे संख्यात्मक दिखते हैं, इसलिए आप उन स्ट्रिंग्स को फ़्लोट में परिवर्तित करना बेहतर हो सकते हैं:

df2 = df.astype(float)

यह परिणाम बदलता है, हालांकि, चूंकि तार चरित्र-दर-वर्ण की तुलना करते हैं, जबकि फ्लोट की तुलना संख्यात्मक रूप से की जाती है।

In [61]: '10' <= '4.2'
Out[61]: True

In [62]: 10 <= 4.2
Out[62]: False

Question 3

आप .equalsकॉलम या संपूर्ण डेटाफ़्रेम के लिए उपयोग कर सकते हैं ।

df['col1'].equals(df['col2'])

यदि वे बराबर हैं, कि बयान वापस आ जाएगी Trueऔर को, False।

Question 4

आप आवेदन () का उपयोग कर सकते हैं और ऐसा कुछ कर सकते हैं

df['que'] = df.apply(lambda x : x['one'] if x['one'] >= x['two'] and x['one'] <= x['three'] else "", axis=1)

या यदि आप लैम्बडा का उपयोग नहीं करना पसंद करते हैं

def que(x):
    if x['one'] >= x['two'] and x['one'] <= x['three']:
        return x['one']
    return ''
df['que'] = df.apply(que, axis=1)

Question 5

स्तंभ को अनुक्रमित करने के लिए एक बूलियन श्रृंखला का उपयोग करने का एक तरीका है df['one']। यह आपको एक नया कॉलम देता है, जहां Trueप्रविष्टियों का मूल्य उसी पंक्ति के समान होता है जैसे df['one']और Falseमान होते हैंNaN ।

बूलियन श्रृंखला सिर्फ आपके ifबयान द्वारा दी गई है (हालांकि इसके &बजाय इसका उपयोग करना आवश्यक है and):

>>> df['que'] = df['one'][(df['one'] >= df['two']) & (df['one'] <= df['three'])]
>>> df
    one two three   que
0   10  1.2 4.2      10
1   15  70  0.03    NaN
2   8   5   0       NaN

यदि आप चाहते हैं कि NaNमानों को अन्य मानों द्वारा प्रतिस्थापित किया जाए, तो आप fillnaनए कॉलम पर विधि का उपयोग कर सकते हैं que। मैंने 0यहां खाली स्ट्रिंग के बजाय उपयोग किया है:

>>> df['que'] = df['que'].fillna(0)
>>> df
    one two three   que
0   10  1.2   4.2    10
1   15   70  0.03     0
2    8    5     0     0

Question 6

कोष्ठकों में प्रत्येक व्यक्तिगत स्थिति को लपेटें, और फिर &शर्तों को संयोजित करने के लिए ऑपरेटर का उपयोग करें :

df.loc[(df['one'] >= df['two']) & (df['one'] <= df['three']), 'que'] = df['one']

आप ~मैच का उल्टा करने के लिए ("नहीं" ऑपरेटर) का उपयोग करके गैर-मिलान वाली पंक्तियों को भर सकते हैं :

df.loc[~ ((df['one'] >= df['two']) & (df['one'] <= df['three'])), 'que'] = ''

आपको उपयोग करने की बजाय &और करने की आवश्यकता ~है andऔर notक्योंकि &और ~ऑपरेटर तत्व-दर-तत्व काम करते हैं।

अंतिम परिणाम:

df
Out[8]: 
  one  two three que
0  10  1.2   4.2  10
1  15   70  0.03    
2   8    5     0

Question 7

का प्रयोग करें np.selectयदि आप कई की स्थिति एक अलग कॉलम में dataframe और उत्पादन एक विशिष्ट विकल्प से जांच की जानी है

conditions=[(condition1),(condition2)]
choices=["choice1","chocie2"]

df["new column"]=np.select=(condtion,choice,default=)

नोट: कोई भी स्थिति और विकल्पों में से कोई भी मेल नहीं खाना चाहिए, यदि आपके पास एक ही विकल्प है, तो दो अलग-अलग स्थितियों में पाठ को दोहराएं

Question 8

मुझे लगता है कि ओपी के अंतर्ज्ञान के सबसे करीब अगर कोई कथन है तो इनलाइन:

df['que'] = (df['one'] if ((df['one'] >= df['two']) and (df['one'] <= df['three']))