पंडों में डेटाफ्रेम के कॉलम-स्लाइस कैसे लें

Question

मैं CSV फ़ाइल से कुछ मशीन लर्निंग डेटा लोड करता हूं। पहले 2 कॉलम अवलोकन हैं और शेष कॉलम विशेषताएं हैं।

वर्तमान में, मैं निम्नलिखित कार्य करता हूं:

data = pandas.read_csv('mydata.csv')

जो कुछ इस तरह देता है:

data = pandas.DataFrame(np.random.rand(10,5), columns = list('abcde'))

मैं दो dataframes में इस dataframe काट करना चाहते हैं: एक स्तंभ युक्त aऔर bऔर एक कॉलम युक्त c, dऔर e।

कुछ लिखना संभव नहीं है

observations = data[:'c']
features = data['c':]

मुझे यकीन नहीं है कि सबसे अच्छा तरीका क्या है। क्या मुझे एक की आवश्यकता है pd.Panel?

वैसे, मुझे लगता है कि डेटाफ्रेम इंडेक्सिंग असंगत है: data['a']की अनुमति है, लेकिन data[0]नहीं है। दूसरी तरफ, data['a':]अनुमति नहीं है लेकिन data[0:]है। क्या इसका कोई व्यावहारिक कारण है? यह वास्तव में भ्रामक है अगर कॉलम Int द्वारा अनुक्रमित किया जाता है, जिसे दिया गया हैdata[0] != data[0:1]

Comments

DataFrame स्वाभाविक है dict जैसी वस्तु है जब आप df [...], हालांकि कुछ उपयुक्तता करते हैं, उदाहरण के लिए एक df[5:10]पंक्तियों के चयन के लिए जोड़ा गया था ( pandas.pydata.org/pandas-docs/stable/... )

— वेस मैककिनी

तो क्या यह असंगति सुविधा के पक्ष में एक डिजाइन निर्णय है? ठीक है, लेकिन यह निश्चित रूप से शुरुआती लोगों के लिए अधिक स्पष्ट होना चाहिए!

— cpa

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

— यू शेन

Answer 1

2017 उत्तर - पांडा 0.20: .ix को पदावनत किया गया है। .Loc का प्रयोग करें

डॉक्स में अपवर्तन देखें

.locदोनों पंक्तियों और स्तंभों का चयन करने के लिए लेबल आधारित अनुक्रमण का उपयोग करता है। सूचकांक या स्तंभ के मान वाले लेबल। .locअंतिम तत्व के साथ स्लाइसिंग शामिल है।

चलो मान लेते हैं कि हम निम्न कॉलम वाली DataFrame है:
foo, bar, quz, ant, cat, sat, dat।

# selects all rows and all columns beginning at 'foo' up to and including 'sat'
df.loc[:, 'foo':'sat']
# foo bar quz ant cat sat

.locएक ही स्लाइस नोटेशन को स्वीकार करता है जो पायथन सूची पंक्ति और स्तंभ दोनों के लिए करता है। स्लाइस नोटेशन किया जा रहा हैstart:stop:step

# slice from 'foo' to 'cat' by every 2nd column
df.loc[:, 'foo':'cat':2]
# foo quz cat

# slice from the beginning to 'bar'
df.loc[:, :'bar']
# foo bar

# slice from 'quz' to the end by 3
df.loc[:, 'quz'::3]
# quz sat

# attempt from 'sat' to 'bar'
df.loc[:, 'sat':'bar']
# no columns returned

# slice from 'sat' to 'bar'
df.loc[:, 'sat':'bar':-1]
sat cat ant quz bar

# slice notation is syntatic sugar for the slice function
# slice from 'quz' to the end by 2 with slice function
df.loc[:, slice('quz',None, 2)]
# quz cat dat

# select specific columns with a list
# select columns foo, bar and dat
df.loc[:, ['foo','bar','dat']]
# foo bar dat

आप पंक्तियों और स्तंभों द्वारा स्लाइस कर सकते हैं। उदाहरण के लिए, आप लेबल के साथ 5 पंक्तियाँ अगर v, w, x, y,z

# slice from 'w' to 'y' and 'foo' to 'ant' by 3
df.loc['w':'y', 'foo':'ant':3]
#    foo ant
# w
# x
# y

Comments

यदि आपका प्रयोग लैम्ब्डा पंक्ति के साथ लागू होता है, जैसे कि: df['newcol'] = df.apply(lambda row: myfunc(row), axis=1) तो आप myfunc(row){... का उपयोग कर सकते हैं row['foo':'ant']। उदाहरण के लिए ( इस StackOverflow जवाब के अनुसार ), myfuncआप के अंदर का मूल्यांकन कर सकते हैं अगर इनमें से कोई भी गैर-संख्यात्मक है:row['foo':'ant'].apply(lambda x: isinstance(x, str)).any()

— 23

.ilocके बजाय अब उपयोग किया जाना चाहिए .loc। इसे ठीक करें, और मैं इसे बढ़ा दूंगा।

— craned

@ क्रोधित - यह सही नहीं है। पंडों के प्रलेखन से: .loc मुख्य रूप से लेबल आधारित है, लेकिन इसका उपयोग बूलियन सरणी के साथ भी किया जा सकता है। .loc आइटम नहीं मिलने पर KeyError को बढ़ाएगा। इसी तरह का एक बयान दिया गया है। इसके बारे में .ococ विशेष रूप से सूचकांक आधारित स्लाइसिंग को संदर्भित करता है। इस उदाहरण में दूसरे शब्दों में, उन्होंने लेबल आधारित अनुक्रमण का उपयोग किया और। सही विकल्प (मूल रूप से एकमात्र विकल्प) है। यदि आप उदाहरण के लिए स्थिति -10 5:10 तक स्लाइस करना चाहते हैं, तो .iloc का उपयोग करें

— user2103050

Answer 2

नोट: .ix पंडों v0.20 के बाद से पदावनत कर दिया गया है। आपको इसके बजाय .locया .iloc, उपयुक्त के रूप में उपयोग करना चाहिए ।

DataFrame.ix इंडेक्स वह है जो आप एक्सेस करना चाहते हैं। यह थोड़ा भ्रमित करने वाला है (मैं मानता हूं कि पंडों का अनुक्रमण कई बार खराब होता है!), लेकिन निम्नलिखित आपको लगता है:

>>> df = DataFrame(np.random.rand(4,5), columns = list('abcde'))
>>> df.ix[:,'b':]
      b         c         d         e
0  0.418762  0.042369  0.869203  0.972314
1  0.991058  0.510228  0.594784  0.534366
2  0.407472  0.259811  0.396664  0.894202
3  0.726168  0.139531  0.324932  0.906575

जहाँ .ix [पंक्ति टुकड़ा, स्तंभ टुकड़ा] की व्याख्या की जा रही है। यहाँ पर पंडों को अनुक्रमित करने के बारे में अधिक जानकारी: http://pandas.pydata.org/pandas-docs/stable/indexing.html#indexing-advanced

Comments

पंडों में सावधान रहने वाले दोनों अंत बिंदु शामिल हैं, अर्थात>>>data.ix[:, 'a':'c'] a b c 0 0.859192 0.881433 0.843624 1 0.744979 0.427986 0.177159

— टिड्डी

कई कॉलम कैब को इस तरह से पास किया जाना चाहिएdf.ix[:,[0,3,4]]

— user602599

@ कर्मेल: ऊपर के आउटपुट में कॉपी / पेस्ट की त्रुटि दिखती है। शायद तुम्हारा मतलब df.ix[:,'b':'e']?

— चैमग जूल

इसके locबजाय इसका उपयोग करना बेहतर है ix: stackoverflow.com/a/31593712/4323

— जॉन ज़्विनक

इस तरह के पुराने उत्तरों को हटाने की आवश्यकता है। .ix को पदावनत किया जाता है और इसका उपयोग कभी नहीं किया जाना चाहिए।

— टेड पेट्रोउ

Answer 3

एक उदाहरण के रूप में समुद्री पैकेज से टाइटैनिक डेटासेट का उपयोग करने देता है

# Load dataset (pip install seaborn)
>> import seaborn.apionly as sns
>> titanic = sns.load_dataset('titanic')

कॉलम नामों का उपयोग करना

>> titanic.loc[:,['sex','age','fare']]

कॉलम सूचकांकों का उपयोग करना

>> titanic.iloc[:,[2,3,6]]

ix का उपयोग करना (पंडों की तुलना में पुराना <.20 संस्करण)

>> titanic.ix[:,[‘sex’,’age’,’fare’]]

या

>> titanic.ix[:,[2,3,6]]

रेनडेक्स विधि का उपयोग करना

>> titanic.reindex(columns=['sex','age','fare'])

Comments

पांडा 0.20 में: .ixपदावनत किया गया है।

— शिह झांग

Passing list-likes to .loc or [] with any missing label will raise KeyError in the future, you can use .reindex() as an alternative.df.loc[:, some_list_of_columns]

— पदावनति

Answer 4

इसके अलावा, एक DataFrame दिया

डेटा

अपने उदाहरण के रूप में, यदि आप कॉलम a और d केवल (ei the 1st और 4th column) निकालना चाहते हैं, तो पंडों के डेटाफ्रेम से iloc mothod वह है जिसकी आपको आवश्यकता है और जिसका उपयोग बहुत प्रभावी ढंग से किया जा सकता है। आपको केवल उन स्तंभों का सूचकांक जानना होगा, जिन्हें आप निकालना चाहते हैं। उदाहरण के लिए:

>>> data.iloc[:,[0,3]]

तुम्हे दूंगा

          a         d
0  0.883283  0.100975
1  0.614313  0.221731
2  0.438963  0.224361
3  0.466078  0.703347
4  0.955285  0.114033
5  0.268443  0.416996
6  0.613241  0.327548
7  0.370784  0.359159
8  0.692708  0.659410
9  0.806624  0.875476

Answer 5

आप DataFrameकिसी सूची में प्रत्येक कॉलम के नाम का उल्लेख करके कॉलम के साथ स्लाइस कर सकते हैं , जैसे:

data = pandas.DataFrame(np.random.rand(10,5), columns = list('abcde'))
data_ab = data[list('ab')]
data_cde = data[list('cde')]

Comments

इसलिए यदि मुझे कॉलम 'बी' से शुरू होने वाले सभी डेटा चाहिए, तो मुझे data.columns में 'b' का इंडेक्स ढूंढना होगा और डेटा [data.columns [1:]] करना होगा? यह काम करने के लिए विहित तरीका है?

— cpa

आपका मतलब है कि आप आगे से 'b' से सभी कॉलम चुनना चाहते हैं?

— ब्रेंडन वुड

हां, या दी गई सीमा में सभी कॉलम का चयन करें।

— cpa

मैं खुद को पंडों के लिए बहुत नया हूँ, इसलिए मैं ऐसा नहीं बोल सकता जिसे विहित माना जाए। मैं इसे वैसे ही करूंगा जैसे आपने कहा था, लेकिन get_locफ़ंक्शन का उपयोग data.columnsकॉलम 'बी' या जो भी हो, के सूचकांक को निर्धारित करने के लिए करें।

— ब्रेंडन वुड

Answer 6

और अगर आप यहां दो श्रेणियों के स्तंभों को खिसकाने और उन्हें एक साथ मिलाने (मेरी तरह) की तलाश में आए थे, तो आप कुछ ऐसा कर सकते हैं

op = df[list(df.columns[0:899]) + list(df.columns[3593:])]
print op

यह पहले 900 कॉलम और (सभी) कॉलम> 3593 के साथ एक नया डेटाफ्रेम बनाएगा (यह मानते हुए कि आपके डेटा सेट में कुछ 4000 कॉलम हैं)।

Comments

महान, किसी ने यह कोशिश की है ... मैं सोच रहा था, यह 0: 899 जो पहले 900 कॉलम प्राप्त करता है .. उन्होंने ऐसा क्यों किया? यह पायथन की तरह महसूस नहीं करता है। अजगर में श्रेणियों का उपयोग करते समय यह हमेशा 'जब तक' नहीं 'तक' और शामिल होता है '

— zwep

Answer 7

यहां बताया गया है कि आप कैसे चयनात्मक स्तंभ स्लाइसिंग करने के लिए विभिन्न तरीकों का उपयोग कर सकते हैं, जिसमें चयनात्मक लेबल आधारित, सूचकांक आधारित और चयनात्मक श्रेणी आधारित स्तंभ स्लाइसिंग शामिल हैं।

In [37]: import pandas as pd    
In [38]: import numpy as np
In [43]: df = pd.DataFrame(np.random.rand(4,7), columns = list('abcdefg'))

In [44]: df
Out[44]: 
          a         b         c         d         e         f         g
0  0.409038  0.745497  0.890767  0.945890  0.014655  0.458070  0.786633
1  0.570642  0.181552  0.794599  0.036340  0.907011  0.655237  0.735268
2  0.568440  0.501638  0.186635  0.441445  0.703312  0.187447  0.604305
3  0.679125  0.642817  0.697628  0.391686  0.698381  0.936899  0.101806

In [45]: df.loc[:, ["a", "b", "c"]] ## label based selective column slicing 
Out[45]: 
          a         b         c
0  0.409038  0.745497  0.890767
1  0.570642  0.181552  0.794599
2  0.568440  0.501638  0.186635
3  0.679125  0.642817  0.697628

In [46]: df.loc[:, "a":"c"] ## label based column ranges slicing 
Out[46]: 
          a         b         c
0  0.409038  0.745497  0.890767
1  0.570642  0.181552  0.794599
2  0.568440  0.501638  0.186635
3  0.679125  0.642817  0.697628

In [47]: df.iloc[:, 0:3] ## index based column ranges slicing 
Out[47]: 
          a         b         c
0  0.409038  0.745497  0.890767
1  0.570642  0.181552  0.794599
2  0.568440  0.501638  0.186635
3  0.679125  0.642817  0.697628

### with 2 different column ranges, index based slicing: 
In [49]: df[df.columns[0:1].tolist() + df.columns[1:3].tolist()]
Out[49]: 
          a         b         c
0  0.409038  0.745497  0.890767
1  0.570642  0.181552  0.794599
2  0.568440  0.501638  0.186635
3  0.679125  0.642817  0.697628

Comments

कृपया उत्तर के रूप में केवल डंपिंग कोड से बचने की कोशिश करें और यह समझाने की कोशिश करें कि यह क्या और क्यों करता है। आपका कोड उन लोगों के लिए स्पष्ट नहीं हो सकता है जिनके पास प्रासंगिक कोडिंग अनुभव नहीं है। स्पष्टीकरण, संदर्भ

— एस ओ ओन

Answer 8

इसके समकक्ष

 >>> print(df2.loc[140:160,['Relevance','Title']])
 >>> print(df2.ix[140:160,[3,7]])

Answer 9

यदि डेटा फ़्रेम ऐसा दिखता है:

group         name      count
fruit         apple     90
fruit         banana    150
fruit         orange    130
vegetable     broccoli  80
vegetable     kale      70
vegetable     lettuce   125

और OUTPUT की तरह हो सकता है

   group    name  count
0  fruit   apple     90
1  fruit  banana    150
2  fruit  orange    130

यदि आप तार्किक ऑपरेटर np.logical_not का उपयोग करते हैं

df[np.logical_not(df['group'] == 'vegetable')]

के बारे में अधिक

https://docs.scipy.org/doc/numpy-1.13.0/reference/routines.logic.html

अन्य तार्किक ऑपरेटरों

1. तार्किक_और (एक्स 1, एक्स 2, / [, आउट, जहां, ...) एक्स 1 और एक्स 2 तत्व-वार के सत्य मूल्य की गणना करें।

2. तार्किक_ओर (एक्स 1, एक्स 2, / [, आउट, जहां, कास्टिंग, ...) एक्स 1 या एक्स 2 तत्व-वार के सत्य मूल्य की गणना करें।

3. तार्किक_नोट (एक्स, / [, आउट, जहां, कास्टिंग, ...)) एक्स-वार के अनुरूप नहीं के सत्य मूल्य की गणना करें।
4. तार्किक_xor (X1, x2, / [, out, where, ..]) X1-XOR x2, तत्व-वार के सत्य मान की गणना करें।

Answer 10

अपने डेटाफ़्रेम से स्तंभों का एक सबसेट प्राप्त करने का दूसरा तरीका, यह मानते हुए कि आप सभी पंक्तियों को चाहते हैं, ऐसा करना होगा:
data[['a','b']]और data[['c','d','e']]
यदि आप संख्यात्मक स्तंभ अनुक्रमणिकाओं का उपयोग करना चाहते हैं:
data[data.columns[:2]]औरdata[data.columns[2:]]