pandas
डेटा अनुक्रमण और चयन
खोज…
लेबल द्वारा कॉलम चुनें
# Create a sample DF
df = pd.DataFrame(np.random.randn(5, 3), columns=list('ABC'))
# Show DF
df
A B C
0 -0.467542 0.469146 -0.861848
1 -0.823205 -0.167087 -0.759942
2 -1.508202 1.361894 -0.166701
3 0.394143 -0.287349 -0.978102
4 -0.160431 1.054736 -0.785250
# Select column using a single label, 'A'
df['A']
0 -0.467542
1 -0.823205
2 -1.508202
3 0.394143
4 -0.160431
# Select multiple columns using an array of labels, ['A', 'C']
df[['A', 'C']]
A C
0 -0.467542 -0.861848
1 -0.823205 -0.759942
2 -1.508202 -0.166701
3 0.394143 -0.978102
4 -0.160431 -0.785250
अतिरिक्त विवरण यहां हैं: http://pandas.pydata.org/pandas-docs/version/0.18.0/indexing.html#selection-by-label
स्थिति के अनुसार चयन करें
iloc ( पूर्णांक स्थान के लिए छोटा) विधि उनकी स्थिति सूचकांक के आधार पर iloc की पंक्तियों का चयन करने की अनुमति देती है। इस तरह से कोई डेटाफ्रेम को स्लाइस कर सकता है, जैसे कि पायथन की सूची स्लाइसिंग के साथ करता है।
df = pd.DataFrame([[11, 22], [33, 44], [55, 66]], index=list("abc"))
df
# Out:
# 0 1
# a 11 22
# b 33 44
# c 55 66
df.iloc[0] # the 0th index (row)
# Out:
# 0 11
# 1 22
# Name: a, dtype: int64
df.iloc[1] # the 1st index (row)
# Out:
# 0 33
# 1 44
# Name: b, dtype: int64
df.iloc[:2] # the first 2 rows
# 0 1
# a 11 22
# b 33 44
df[::-1] # reverse order of rows
# 0 1
# c 55 66
# b 33 44
# a 11 22
पंक्ति स्थान को स्तंभ स्थान के साथ जोड़ा जा सकता है
df.iloc[:, 1] # the 1st column
# Out[15]:
# a 22
# b 44
# c 66
# Name: 1, dtype: int64
इसे भी देखें: स्थिति के अनुसार चयन
लेबल के साथ कटा हुआ
लेबल का उपयोग करते समय, परिणाम में प्रारंभ और रोक दोनों शामिल होते हैं।
import pandas as pd
import numpy as np
np.random.seed(5)
df = pd.DataFrame(np.random.randint(100, size=(5, 5)), columns = list("ABCDE"),
index = ["R" + str(i) for i in range(5)])
# Out:
# A B C D E
# R0 99 78 61 16 73
# R1 8 62 27 30 80
# R2 7 76 15 53 80
# R3 27 44 77 75 65
# R4 47 30 84 86 18
पंक्तियों R0 से R2 :
df.loc['R0':'R2']
# Out:
# A B C D E
# R0 9 41 62 1 82
# R1 16 78 5 58 0
# R2 80 4 36 51 27
सूचना कैसे loc अलग से iloc क्योंकि iloc शामिल नहीं अंत सूचकांक
df.loc['R0':'R2'] # rows labelled R0, R1, R2
# Out:
# A B C D E
# R0 9 41 62 1 82
# R1 16 78 5 58 0
# R2 80 4 36 51 27
# df.iloc[0:2] # rows indexed by 0, 1
# A B C D E
# R0 99 78 61 16 73
# R1 8 62 27 30 80
कॉलम C से E :
df.loc[:, 'C':'E']
# Out:
# C D E
# R0 62 1 82
# R1 5 58 0
# R2 36 51 27
# R3 68 38 83
# R4 7 30 62
मिश्रित स्थिति और लेबल आधारित चयन
डेटा ढांचा:
import pandas as pd
import numpy as np
np.random.seed(5)
df = pd.DataFrame(np.random.randint(100, size=(5, 5)), columns = list("ABCDE"),
index = ["R" + str(i) for i in range(5)])
df
Out[12]:
A B C D E
R0 99 78 61 16 73
R1 8 62 27 30 80
R2 7 76 15 53 80
R3 27 44 77 75 65
R4 47 30 84 86 18
स्थिति और पंक्तियों को लेबल द्वारा पंक्तियों का चयन करें:
df.ix[1:3, 'C':'E']
Out[19]:
C D E
R1 5 58 0
R2 36 51 27
यदि सूचकांक पूर्णांक है, तो .ix पदों के बजाय लेबल का उपयोग करेगा:
df.index = np.arange(5, 10)
df
Out[22]:
A B C D E
5 9 41 62 1 82
6 16 78 5 58 0
7 80 4 36 51 27
8 31 2 68 38 83
9 19 18 7 30 62
#same call returns an empty DataFrame because now the index is integer
df.ix[1:3, 'C':'E']
Out[24]:
Empty DataFrame
Columns: [C, D, E]
Index: []
बूलियन अनुक्रमण
बूलियन सरणियों का उपयोग करके कोई डेटाफ़्रेम की पंक्तियों और स्तंभों का चयन कर सकता है।
import pandas as pd
import numpy as np
np.random.seed(5)
df = pd.DataFrame(np.random.randint(100, size=(5, 5)), columns = list("ABCDE"),
index = ["R" + str(i) for i in range(5)])
print (df)
# A B C D E
# R0 99 78 61 16 73
# R1 8 62 27 30 80
# R2 7 76 15 53 80
# R3 27 44 77 75 65
# R4 47 30 84 86 18
mask = df['A'] > 10
print (mask)
# R0 True
# R1 False
# R2 False
# R3 True
# R4 True
# Name: A, dtype: bool
print (df[mask])
# A B C D E
# R0 99 78 61 16 73
# R3 27 44 77 75 65
# R4 47 30 84 86 18
print (df.ix[mask, 'C'])
# R0 61
# R3 77
# R4 84
# Name: C, dtype: int32
print(df.ix[mask, ['C', 'D']])
# C D
# R0 61 16
# R3 77 75
# R4 84 86
पांडा प्रलेखन में अधिक।
फ़िल्टरिंग कॉलम ("दिलचस्प" का चयन करना, अनावश्यक रूप से छोड़ना, RegEx का उपयोग करना, आदि)
नमूना DF
In [39]: df = pd.DataFrame(np.random.randint(0, 10, size=(5, 6)), columns=['a10','a20','a25','b','c','d'])
In [40]: df
Out[40]:
a10 a20 a25 b c d
0 2 3 7 5 4 7
1 3 1 5 7 2 6
2 7 4 9 0 8 7
3 5 8 8 9 6 8
4 8 1 0 4 4 9
'a' अक्षर वाले कॉलम दिखाएं
In [41]: df.filter(like='a')
Out[41]:
a10 a20 a25
0 2 3 7
1 3 1 5
2 7 4 9
3 5 8 8
4 8 1 0
RegEx फ़िल्टर (b|c|d) - b या c या d का उपयोग करके कॉलम दिखाएं:
In [42]: df.filter(regex='(b|c|d)')
Out[42]:
b c d
0 5 4 7
1 7 2 6
2 0 8 7
3 9 6 8
4 4 4 9
उन सभी कॉलमों को छोड़ें जिनकी शुरुआत a साथ हो (दूसरे शब्द में दिए गए सभी कॉलम हटा दें / छोड़ दें।
In [43]: df.ix[:, ~df.columns.str.contains('^a')]
Out[43]:
b c d
0 5 4 7
1 7 2 6
2 0 8 7
3 9 6 8
4 4 4 9
`.Query ()` विधि का उपयोग करके पंक्तियों को फ़िल्टर / चयन करना
import pandas as pd
यादृच्छिक डीएफ उत्पन्न
df = pd.DataFrame(np.random.randint(0,10,size=(10, 3)), columns=list('ABC'))
In [16]: print(df)
A B C
0 4 1 4
1 0 2 0
2 7 8 8
3 2 1 9
4 7 3 8
5 4 0 7
6 1 5 5
7 6 7 8
8 6 7 3
9 6 4 5
उन पंक्तियों का चयन करें जहाँ कॉलम A > 2 मान और कॉलम B < 5 में मान हैं
In [18]: df.query('A > 2 and B < 5')
Out[18]:
A B C
0 4 1 4
4 7 3 8
5 4 0 7
9 6 4 5
.query() फ़िल्टरिंग के लिए चर के साथ .query() विधि का उपयोग करना
In [23]: B_filter = [1,7]
In [24]: df.query('B == @B_filter')
Out[24]:
A B C
0 4 1 4
3 2 1 9
7 6 7 8
8 6 7 3
In [25]: df.query('@B_filter in B')
Out[25]:
A B C
0 4 1 4
पथ निर्भर डिप्लिंगिंग
किसी श्रृंखला या डेटाफ़्रेम की पंक्तियों को इस तरह से पार करना आवश्यक हो सकता है कि अगली तत्व या अगली पंक्ति पहले से चयनित तत्व या पंक्ति पर निर्भर हो। इसे पथ निर्भरता कहा जाता है।
पर विचार करें निम्नलिखित समय श्रृंखला s अनियमित आवृत्ति के साथ।
#starting python community conventions
import numpy as np
import pandas as pd
# n is number of observations
n = 5000
day = pd.to_datetime(['2013-02-06'])
# irregular seconds spanning 28800 seconds (8 hours)
seconds = np.random.rand(n) * 28800 * pd.Timedelta(1, 's')
# start at 8 am
start = pd.offsets.Hour(8)
# irregular timeseries
tidx = day + start + seconds
tidx = tidx.sort_values()
s = pd.Series(np.random.randn(n), tidx, name='A').cumsum()
s.plot();
चलो एक पथ निर्भर स्थिति मान। श्रृंखला के पहले सदस्य के साथ शुरू करते हुए, मैं प्रत्येक बाद के तत्व को हथियाना चाहता हूं ताकि उस तत्व और वर्तमान तत्व के बीच का पूर्ण अंतर x बराबर या उससे अधिक हो।
हम अजगर जनरेटर का उपयोग करके इस समस्या को हल करेंगे।
जनरेटर समारोह
def mover(s, move_size=10):
"""Given a reference, find next value with
an absolute difference >= move_size"""
ref = None
for i, v in s.iteritems():
if ref is None or (abs(ref - v) >= move_size):
yield i, v
ref = v
तब हम एक नई श्रृंखला moves को परिभाषित कर सकते हैं
moves = pd.Series({i:v for i, v in mover(s, move_size=10)},
name='_{}_'.format(s.name))
उन दोनों को प्लॉट करना
moves.plot(legend=True)
s.plot(legend=True)
डेटाफ्रेम के लिए एनालॉग होगा:
def mover_df(df, col, move_size=2):
ref = None
for i, row in df.iterrows():
if ref is None or (abs(ref - row.loc[col]) >= move_size):
yield row
ref = row.loc[col]
df = s.to_frame()
moves_df = pd.concat(mover_df(df, 'A', 10), axis=1).T
moves_df.A.plot(label='_A_', legend=True)
df.A.plot(legend=True)
डेटाफ़्रेम की पहली / अंतिम n पंक्तियाँ प्राप्त करें
किसी डेटाफ़्रेम के पहले या अंतिम कुछ रिकॉर्ड देखने के लिए, आप विधियों का उपयोग कर सकते हैं head और tail
पहली n पंक्तियों को वापस करने के लिए DataFrame.head([n])
df.head(n)
अंतिम n पंक्तियों को वापस करने के लिए DataFrame.tail([n])
df.tail(n)
तर्क n के बिना, ये फ़ंक्शन 5 पंक्तियों को वापस करते हैं।
ध्यान दें कि head / tail लिए स्लाइस अंकन होगा:
df[:10] # same as df.head(10)
df[-10:] # same as df.tail(10)
डेटाफ़्रेम में अलग-अलग पंक्तियों का चयन करें
चलो
df = pd.DataFrame({'col_1':['A','B','A','B','C'], 'col_2':[3,4,3,5,6]})
df
# Output:
# col_1 col_2
# 0 A 3
# 1 B 4
# 2 A 3
# 3 B 5
# 4 C 6
col_1 में अलग-अलग मान प्राप्त करने के लिए आप Series.unique() उपयोग कर सकते हैं
df['col_1'].unique()
# Output:
# array(['A', 'B', 'C'], dtype=object)
लेकिन Series.unique () केवल एक कॉलम के लिए काम करता है।
अनोखे col_1 का अनुकरण करने के लिए , SQL का DataFrame.drop_duplicates() आप DataFrame.drop_duplicates() उपयोग कर सकते हैं:
df.drop_duplicates()
# col_1 col_2
# 0 A 3
# 1 B 4
# 3 B 5
# 4 C 6
यह आपको डेटाफ़्रेम में सभी अद्वितीय पंक्तियाँ प्राप्त होगी। तो अगर
df = pd.DataFrame({'col_1':['A','B','A','B','C'], 'col_2':[3,4,3,5,6], 'col_3':[0,0.1,0.2,0.3,0.4]})
df
# Output:
# col_1 col_2 col_3
# 0 A 3 0.0
# 1 B 4 0.1
# 2 A 3 0.2
# 3 B 5 0.3
# 4 C 6 0.4
df.drop_duplicates()
# col_1 col_2 col_3
# 0 A 3 0.0
# 1 B 4 0.1
# 2 A 3 0.2
# 3 B 5 0.3
# 4 C 6 0.4
अद्वितीय रिकॉर्ड का चयन करते समय कॉलम को निर्दिष्ट करने के लिए, उन्हें तर्क के रूप में पास करें
df = pd.DataFrame({'col_1':['A','B','A','B','C'], 'col_2':[3,4,3,5,6], 'col_3':[0,0.1,0.2,0.3,0.4]})
df.drop_duplicates(['col_1','col_2'])
# Output:
# col_1 col_2 col_3
# 0 A 3 0.0
# 1 B 4 0.1
# 3 B 5 0.3
# 4 C 6 0.4
# skip last column
# df.drop_duplicates(['col_1','col_2'])[['col_1','col_2']]
# col_1 col_2
# 0 A 3
# 1 B 4
# 3 B 5
# 4 C 6
स्रोत: पंडों में कई डेटा फ्रेम कॉलम में "अलग-अलग" कैसे चुनें? ।
लापता डेटा (NaN, कोई नहीं, NaT) के साथ पंक्तियों को फ़िल्टर करें
यदि आपके पास लापता डेटा ( NaN , pd.NaT , None ) के साथ एक pd.NaT तो आप अधूरी पंक्तियों को फ़िल्टर कर सकते हैं
df = pd.DataFrame([[0,1,2,3],
[None,5,None,pd.NaT],
[8,None,10,None],
[11,12,13,pd.NaT]],columns=list('ABCD'))
df
# Output:
# A B C D
# 0 0 1 2 3
# 1 NaN 5 NaN NaT
# 2 8 NaN 10 None
# 3 11 12 13 NaT
DataFrame.dropna सभी पंक्तियों को गायब डेटा के साथ कम से कम एक फ़ील्ड से युक्त करता है
df.dropna()
# Output:
# A B C D
# 0 0 1 2 3
उन पंक्तियों को छोड़ने के लिए जो निर्दिष्ट कॉलम में डेटा गायब हैं, subset उपयोग करें
df.dropna(subset=['C'])
# Output:
# A B C D
# 0 0 1 2 3
# 2 8 NaN 10 None
# 3 11 12 13 NaT
फ़िल्टर किए गए फ़्रेम के साथ इन-प्लेस प्रतिस्थापन के लिए विकल्प inplace = True उपयोग करें।