मुझे पंडों की पंक्ति संख्या कैसे मिलती है DataFrame?


929

मैं पंडों के साथ डेटाफ्रेम डीएफ की पंक्तियों की संख्या प्राप्त करने की कोशिश कर रहा हूं, और यहां मेरा कोड है।

विधि 1:

total_rows = df.count
print total_rows +1

विधि 2:

total_rows = df['First_columnn_label'].count
print total_rows +1

दोनों कोड स्निपेट मुझे यह त्रुटि देते हैं:

TypeError: असमर्थित ऑपरेंड प्रकार (ओं) के लिए +: 'Instmethod' और 'int'

मैं क्या गलत कर रहा हूं?


12
ठीक है मुझे पता चला, मुझे विधि को संपत्ति की जांच नहीं करने के लिए कहा जाना चाहिए, इसलिए यह df.count होना चाहिए () नहीं df.count
yemu

56
^ खतरनाक! खबरदार कि df.count()प्रत्येक कॉलम के लिए केवल गैर-NA / NaN पंक्तियों की गिनती वापस करेंगे। आपको df.shape[0]इसके बजाय उपयोग करना चाहिए , जो हमेशा सही ढंग से आपको पंक्तियों की संख्या बताएगा।
12

3
ध्यान दें कि डेटाफ्रेम खाली होने पर df.count एक int नहीं लौटेगा (जैसे, pd.DataFrame (कॉलम = ["ब्लू", "रेड")। काउंट 0 नहीं है)
Marcelo Bielsa

जवाबों:


1247

आप .shapeसंपत्ति का उपयोग कर सकते हैं या बस len(DataFrame.index)। हालांकि, उल्लेखनीय प्रदर्शन अंतर हैं ( len(DataFrame.index)सबसे तेज़ है):

In [1]: import numpy as np

In [2]: import pandas as pd

In [3]: df = pd.DataFrame(np.arange(12).reshape(4,3))

In [4]: df
Out[4]: 
   0  1  2
0  0  1  2
1  3  4  5
2  6  7  8
3  9  10 11

In [5]: df.shape
Out[5]: (4, 3)

In [6]: timeit df.shape
2.77 µs ± 644 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

In [7]: timeit df[0].count()
348 µs ± 1.31 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

In [8]: len(df.index)
Out[8]: 4

In [9]: timeit len(df.index)
990 ns ± 4.97 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

यहां छवि विवरण दर्ज करें

संपादित करें: जैसा कि @Dan एलन टिप्पणी में उल्लेख किया len(df.index)और df[0].count()के रूप में परस्पर विनिमय नहीं कर रहे हैं countशामिल नहीं NaNहै,


13
shapeलेन-देन (df) के बजाय इंटरैक्टिव काम में उपयोग करने का एक अच्छा कारण है : अलग-अलग फ़िल्टरिंग की कोशिश करना, मुझे अक्सर यह जानना होगा कि कितने आइटम रहते हैं। आकार के साथ, मैं देख सकता हूँ कि मेरे छानने के बाद .shape जोड़कर। लेन () के साथ कमांड-लाइन का संपादन बहुत अधिक बोझिल हो जाता है, आगे-पीछे हो रहा है।
के-माइकल ऐ

9
ओपी के लिए काम नहीं करेगा, लेकिन अगर आपको सिर्फ यह जानना है कि क्या डेटाफ्रेम खाली है, df.emptyतो सबसे अच्छा विकल्प है।
jtschoonhoven

19
मुझे पता है कि यह एक समय हो गया है, लेकिन लेन नहीं है (df.index) 381 नैनोसेकंड लेता है, या 0.381 माइक्रोसेकंड, df.shape 3 गुना धीमी है, 1.17 microseconds ले रहा है। क्या मैं कुछ भुल गया? @ बरोट
टीजी

11
(3,3) मैट्रिक्स खराब उदाहरण है क्योंकि यह आकार के क्रम को प्रदर्शित नहीं करता है
xaedes

4
कैसे df.shape[0]तेजी से len(df)या है len(df.columns)? चूँकि 1 ns (नैनोसेकंड) = 1000 mics (माइक्रोसेकंड), इसलिए 1.17µs = 1170ns, जिसका अर्थ है कि यह लगभग 381ns की तुलना में 3 गुना धीमा है
itsjef

303

मान लीजिए dfकि आपका डेटाफ्रेम तब है:

count_row = df.shape[0]  # gives number of row count
count_col = df.shape[1]  # gives number of col count

या, अधिक संक्षेप में,

r, c = df.shape

4
यदि डेटा सेट बड़ा है, तो len (df.index) df.shape की तुलना में काफी तेज है [0] यदि आपको केवल पंक्ति गणना की आवश्यकता है। मैंने इसका परीक्षण किया।
सुमित पोखरेल

145

का उपयोग करें len(df)। यह पांडा के रूप में काम करता है 0.11 या शायद पहले भी।

__len__()वर्तमान में (0.12) के साथ प्रलेखित है Returns length of index। समय की जानकारी, जड़ के उत्तर में उसी तरह सेट करें:

In [7]: timeit len(df.index)
1000000 loops, best of 3: 248 ns per loop

In [8]: timeit len(df)
1000000 loops, best of 3: 573 ns per loop

एक अतिरिक्त फ़ंक्शन कॉल के कारण यह len(df.index)सीधे कॉल करने की तुलना में थोड़ा धीमा है , लेकिन यह अधिकांश उपयोग के मामलों में कोई भूमिका नहीं निभानी चाहिए।


81

मुझे पंडों की पंक्ति संख्या कैसे मिलती है DataFrame?

यह तालिका उन विभिन्न स्थितियों को संक्षेप में बताती है जिनमें आप डेटाफ्रेम (या पूर्णता के लिए श्रृंखला), अनुशंसित विधि (ओं) के साथ कुछ गिनना चाहते हैं।

यहां छवि विवरण दर्ज करें

फुटनोट

  1. DataFrame.countप्रत्येक कॉलम के लिए रिटर्न मायने रखता है Seriesक्योंकि गैर-शून्य गणना कॉलम से भिन्न होती है।
  2. DataFrameGroupBy.sizeरिटर्न Series, एक ही समूह में सभी कॉलम एक ही पंक्ति-गिनती साझा करते हैं।
  3. DataFrameGroupBy.countDataFrameगैर-शून्य गणना के बाद से एक ही समूह में कॉलम भर में भिन्न हो सकता है। किसी विशिष्ट कॉलम के लिए समूह-वार गैर-शून्य गणना प्राप्त करने के लिए, df.groupby(...)['x'].count()जहां "x" गणना करने के लिए कॉलम है, का उपयोग करें ।

न्यूनतम कोड उदाहरण

नीचे, मैं ऊपर दी गई तालिका में वर्णित प्रत्येक विधियों के उदाहरण दिखाता हूं। सबसे पहले, सेटअप -

df = pd.DataFrame({
    'A': list('aabbc'), 'B': ['x', 'x', np.nan, 'x', np.nan]})
s = df['B'].copy()

df

   A    B
0  a    x
1  a    x
2  b  NaN
3  b    x
4  c  NaN

s

0      x
1      x
2    NaN
3      x
4    NaN
Name: B, dtype: object

एक DataFrame की पंक्ति गणना: len(df), df.shape[0], याlen(df.index)

len(df)
# 5

df.shape[0]
# 5

len(df.index)
# 5

यह निरंतर समय के संचालन के प्रदर्शन की तुलना करने के लिए मूर्खतापूर्ण लगता है, खासकर जब अंतर "गंभीरता से, इसके बारे में चिंता न करें" के स्तर पर है। लेकिन यह अन्य उत्तरों के साथ एक प्रवृत्ति प्रतीत होती है, इसलिए मैं पूर्णता के लिए भी ऐसा ही कर रहा हूं।

उपरोक्त 3 विधियों में से, len(df.index)(जैसा कि अन्य उत्तरों में उल्लेख किया गया है) सबसे तेज़ है।

ध्यान दें

  • उपरोक्त सभी विधियां निरंतर समय संचालन हैं क्योंकि वे सरल विशेषता लुकअप हैं।
  • df.shape(इसी तरह ndarray.shape) एक विशेषता है जो एक टपल देता है (# Rows, # Cols)। उदाहरण के लिए, उदाहरण के लिए यहां df.shapeलौटता (8, 2)है।

स्तंभ एक DataFrame की गणना: df.shape[1],len(df.columns)

df.shape[1]
# 2

len(df.columns)
# 2

के अनुरूप len(df.index), len(df.columns)दो विधियों का तेज है (लेकिन टाइप करने के लिए अधिक वर्ण लेता है)।

पंक्ति एक श्रृंखला की गणना: len(s), s.size,len(s.index)

len(s)
# 5

s.size
# 5

len(s.index)
# 5

s.sizeऔर len(s.index)गति के संदर्भ में समान हैं। लेकिन मैं सलाह देता हूं len(df)

नोट
size एक विशेषता है, और यह तत्वों की संख्या (किसी भी श्रृंखला के लिए पंक्तियों की गिनती) को लौटाता है। DataFrames भी एक आकार विशेषता को परिभाषित करता है जो उसी के समान परिणाम देता है df.shape[0] * df.shape[1]

गैर-नल पंक्ति गणना: DataFrame.countऔरSeries.count

यहां बताए गए तरीके केवल गैर-शून्य मानों की गणना करते हैं (जिसका अर्थ है NaNs की अनदेखी)।

कॉलिंग प्रत्येक कॉलम के DataFrame.countलिए गैर-NaN काउंट लौटाएगी :

df.count()

A    5
B    3
dtype: int64

श्रृंखला के लिए, Series.countसमान प्रभाव का उपयोग करें:

s.count()
# 3

समूहवार पंक्ति गणना: GroupBy.size

के लिए DataFrames, DataFrameGroupBy.sizeप्रति समूह पंक्तियों की संख्या गिनने के लिए उपयोग करें।

df.groupby('A').size()

A
a    2
b    2
c    1
dtype: int64

इसी तरह, Seriesआप उपयोग करेंगे SeriesGroupBy.size

s.groupby(df.A).size()

A
a    2
b    2
c    1
Name: B, dtype: int64

दोनों मामलों में, एक Seriesवापस कर दिया जाता है। यह तब तक के लिए समझ में आता है DataFramesजब से सभी समूह एक ही पंक्ति-गणना साझा करते हैं।

समूह-वार गैर-नल पंक्ति गणना: GroupBy.count

उपरोक्त के समान, लेकिन उपयोग करें GroupBy.count, नहीं GroupBy.size। ध्यान दें कि sizeहमेशा एक रिटर्न देता है Series, जबकि countरिटर्न Seriesअगर एक विशिष्ट कॉलम पर कहा जाता है, या फिर ए DataFrame

निम्नलिखित तरीके एक ही चीज़ लौटाते हैं:

df.groupby('A')['B'].size()
df.groupby('A').size()

A
a    2
b    2
c    1
Name: B, dtype: int64

इस बीच, के लिए count, हमारे पास है

df.groupby('A').count()

   B
A   
a  2
b  1
c  0

... पूरे GroupBy ऑब्जेक्ट, v / s पर कॉल किया गया,

df.groupby('A')['B'].count()

A
a    2
b    1
c    0
Name: B, dtype: int64

एक विशिष्ट कॉलम पर कॉल किया गया।


35

टी एल; डॉ

उपयोग len(df)


len()आपका मित्र है, इसका उपयोग पंक्ति गणनाओं के लिए किया जा सकता है len(df)

वैकल्पिक रूप से, आप सभी पंक्तियों तक df.indexऔर सभी स्तंभों तक पहुंच सकते हैं df.columns, और जैसा कि आप len(anyList)सूची की गिनती प्राप्त करने के लिए उपयोग कर सकते हैं , len(df.index)पंक्तियों की संख्या प्राप्त करने के लिए उपयोग कर सकते हैं , और len(df.columns)स्तंभ गणना के लिए।

या, आप उपयोग कर सकते हैं df.shapeजो पंक्तियों और स्तंभों की संख्या को एक साथ लौटाता है, यदि आप केवल उपयोग की जाने वाली पंक्तियों की संख्या तक पहुँचना चाहते हैं df.shape[0]और केवल स्तंभों की संख्या का उपयोग करते हैं df.shape[1]:।


19

उपरोक्त उत्तरों के अलावा, df.axesपंक्ति और स्तंभ अनुक्रमित के साथ टपल प्राप्त करने के लिए उपयोग कर सकते हैं और फिर len()फ़ंक्शन का उपयोग कर सकते हैं:

total_rows=len(df.axes[0])
total_cols=len(df.axes[1])

2
यह इंडेक्स ऑब्जेक्ट्स को लौटाता है, जो मूल की प्रतियां नहीं हो सकता है या हो सकता है, जो बेकार है अगर आप लंबाई की जांच करने के बाद उन्हें छोड़ रहे हैं। जब तक आप इंडेक्स के साथ कुछ और करने का इरादा नहीं रखते हैं, तब तक उपयोग न करें
cs95

9

... जन-फिलिप गेर्के के उत्तर पर निर्माण।

कारण len(df)या इससे len(df.index)तेज क्यों है df.shape[0]। कोड को देखो। df.shape एक @propertyऐसा डेटा है जो डेटाफ़्रेम विधि को lenदो बार कॉल करता है ।

df.shape??
Type:        property
String form: <property object at 0x1127b33c0>
Source:     
# df.shape.fget
@property
def shape(self):
    """
    Return a tuple representing the dimensionality of the DataFrame.
    """
    return len(self.index), len(self.columns)

और लेन के नीचे (df)

df.__len__??
Signature: df.__len__()
Source:   
    def __len__(self):
        """Returns length of info axis, but here we use the index """
        return len(self.index)
File:      ~/miniconda2/lib/python2.7/site-packages/pandas/core/frame.py
Type:      instancemethod

len(df.index)की तुलना len(df)में यह एक कम फ़ंक्शन कॉल की तुलना में थोड़ा तेज़ होगा , लेकिन यह हमेशा की तुलना में तेज़ हैdf.shape[0]


7

मैं Rपृष्ठभूमि से पांडा के लिए आता हूं , और मैं देखता हूं कि जब पंक्ति या स्तंभ का चयन होता है तो पांडा अधिक जटिल होता है। मुझे इसके साथ थोड़ी देर के लिए कुश्ती करनी पड़ी, तब मुझे इससे निपटने के कुछ तरीके मिले:

कॉलम की संख्या प्राप्त करना:

len(df.columns)  
## Here:
#df is your data.frame
#df.columns return a string, it contains column's titles of the df. 
#Then, "len()" gets the length of it.

पंक्तियों की संख्या प्राप्त करना:

len(df.index) #It's similar.

थोड़ी देर के लिए पंडों का उपयोग करने के बाद , मुझे लगता है कि हमें साथ जाना चाहिए df.shape। यह क्रमशः पंक्तियों और स्तंभों की संख्या लौटाता है।
१०

4

यदि आप पंक्तिबद्ध ऑपरेशन के बीच में पंक्ति की गिनती प्राप्त करना चाहते हैं, तो आप इसका उपयोग कर सकते हैं:

df.pipe(len)

उदाहरण:

row_count = (
      pd.DataFrame(np.random.rand(3,4))
      .reset_index()
      .pipe(len)
)

यह उपयोगी हो सकता है यदि आप किसी len()फ़ंक्शन के अंदर एक लंबा स्टेटमेंट नहीं डालना चाहते हैं ।

आप __len__()इसके बजाय उपयोग कर सकते हैं लेकिन __len__()थोड़ा अजीब लग रहा है।


ऐसा लगता है कि इस ऑपरेशन को "पाइप" करना चाहते हैं, क्योंकि इसमें कुछ और नहीं है जो आप इसे पाइप कर सकते हैं (यह एक पूर्णांक देता है)। मैं बहुत बल्कि होगा count = len(df.reset_index())की तुलना में count = df.reset_index().pipe(len)। फ़ंक्शन फ़ंक्शन के बिना पूर्व केवल एक विशेषता लुकअप है।
CS95

1

अरे आप यह भी उपयोग कर सकते हैं:

मान लीजिए कि dfआपका डेटाफ्रेम है। फिर df.shapeआपको अपने डेटाफ्रेम का आकार देता है(row,col)

इस प्रकार, आवश्यक प्राप्त करने के लिए कमांड के नीचे असाइन करें

 row = df.shape[0], col = df.shape[1]

0

डेटाफ्रेम डीएफ के लिए, डेटा की खोज करते समय एक मुद्रित अल्पविराम स्वरूपित पंक्ति गणना का उपयोग किया जाता है:

def nrow(df):
    print("{:,}".format(df.shape[0]))

उदाहरण:

nrow(my_df)
12,456,789

0

एक डेटाफ़्रेम में पंक्तियों की मात्रा का पता लगाने का एक वैकल्पिक तरीका जो मुझे लगता है कि सबसे पठनीय संस्करण है pandas.Index.size

ध्यान दें कि जैसा कि मैंने स्वीकृत उत्तर पर टिप्पणी की है:

संदिग्ध pandas.Index.sizeवास्तव में तेजी से होगा, len(df.index)लेकिन timeitमेरे कंप्यूटर पर मुझे अन्यथा (~ 150 एनएस धीमी प्रति लूप) बताता है।


0

मुझे यकीन नहीं है कि यह काम करेगा (डेटा COULD छोड़ा जा सकता है), लेकिन यह काम कर सकता है:

*dataframe name*.tails(1)

और फिर इसका उपयोग करके, आप कोड स्निपेट चलाकर और उस पंक्ति संख्या को देख सकते हैं जो आपको दी गई थी।


-2

या तो यह कर सकता है ( dfडेटाफ्रैम का नाम है):

विधि 1: lenफ़ंक्शन का उपयोग करना:

len(df)डेटाफ्रेम नाम की पंक्तियों की संख्या देगा df

विधि 2: countफ़ंक्शन का उपयोग कर:

df[col].count()किसी दिए गए कॉलम में पंक्तियों की संख्या गिनेंगे col

df.count() सभी स्तंभों के लिए पंक्तियों की संख्या देगा।


3
यह एक अच्छा जवाब है, लेकिन इस सवाल के पहले से ही पर्याप्त जवाब हैं, इसलिए यह वास्तव में कुछ भी नहीं जोड़ता है।
जॉन
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.