මම උත්සාහ කරන්නේ පැන්ඩාස් සමඟ දත්ත රාමු df පේළි ගණන ලබා ගැනීමටයි, මෙන්න මගේ කේතය.

ක්රමය 1:

total_rows = df.count
print total_rows +1

ක්රමය 2:

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

කේත ස්නිපෙට් දෙකම මට මෙම දෝෂය ලබා දෙයි:

TypeError: + සඳහා සහය නොදක්වන ඔපෙරන්ඩ් වර්ගය (ය): 'instancemethod' සහ 'int'

මම වැරදි කරන්නේ කුමක් ද?

ඔබට .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ජනයා බැහැර NaNs,

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

භාවිතා කරන්න 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)කෙලින්ම ඇමතීමට වඩා ටිකක් මන්දගාමී වේ , නමුත් මෙය බොහෝ භාවිත අවස්ථා වලදී කිසිදු කාර්යභාරයක් ඉටු නොකළ යුතුය.

පැන්ඩාස් දත්ත රාමුවක පේළි ගණන ලබා ගන්නේ කෙසේද?

මෙම වගුව මඟින් ඔබට නිර්දේශිත ක්‍රමවේදය සමඟ දත්ත රාමුවක (හෝ ශ්‍රේණියේ, සම්පූර්ණත්වය සඳහා) යමක් ගණනය කිරීමට අවශ්‍ය විවිධ අවස්ථා සාරාංශ කරයි.

පාද සටහන්

1. DataFrame.countSeriesශුන්‍ය නොවන ගණනය තීරුව අනුව වෙනස් වන බැවින් එක් එක් තීරුව සඳහා ප්‍රතිලාභ ගණනය කිරීම්.
2. DataFrameGroupBy.sizeSeriesඑකම කණ්ඩායමේ සියලුම තීරු එකම පේළි ගණන බෙදා ගන්නා බැවින් a නැවත ලබා දෙයි .
3. DataFrameGroupBy.countDataFrameශුන්‍ය නොවන ගණනය එකම කණ්ඩායමේ තීරු හරහා වෙනස් විය හැකි බැවින් a නැවත ලබා දෙයි . නිශ්චිත තීරුවක් සඳහා කණ්ඩායම් වශයෙන් ශුන්‍ය නොවන ගණනය ලබා ගැනීම සඳහා, 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 යනු ගුණාංගයක් වන අතර, එය මූලද්‍රව්‍ය ගණන නැවත ලබා දෙයි (= ඕනෑම ශ්‍රේණියක් සඳහා පේළි ගණන). ඩේටා ෆ්‍රේම්ස් ද ප්‍රමාණයේ ලක්ෂණයක් අර්ථ දක්වයි df.shape[0] * df.shape[1].

ශුන්‍ය නොවන පේළි ගණන: DataFrame.countසහSeries.count

මෙහි විස්තර කර ඇති ක්‍රම ගණනය කරනුයේ ශුන්‍ය නොවන අගයන් පමණි (එනම් NaNs නොසලකා හරිනු ලැබේ).

ඇමතුම් DataFrame.countසඳහා-නන් නොවන චෝදනා ආපසු එක් එක් තීරුවේ:

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

අවස්ථා දෙකේදීම, a 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

නිශ්චිත තීරුවකට කැඳවනු ලැබේ.

ටීඑල්; ඩී.ආර්

භාවිත 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].

ඉහත පිළිතුරු වලට අමතරව df.axesපේළි සහ තීරු දර්ශක සමඟ ටුපල් ලබා ගැනීමට සහ පසුව len()ශ්‍රිතය භාවිතා කිරීමට භාවිතා කළ හැකිය :

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

... ජෑන්-පිලිප් ගෙර්ක්ගේ පිළිතුර මත ගොඩනැගීම.

හේතුව 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]

මම 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ඔබේ dataframe වේ. එවිට df.shapeඔබේ දත්ත රාමුවේ හැඩය ලබා දෙයි(row,col)

මේ අනුව, අවශ්‍ය දේ ලබා ගැනීම සඳහා පහත විධානය යොදන්න

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

දම්වැල් සහිත මෙහෙයුමක් මැද පේළි ගණන ලබා ගැනීමට ඔබට අවශ්‍ය නම්, ඔබට මෙය භාවිතා කළ හැකිය:

df.pipe(len)

උදාහරණයක්:

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

len()ශ්‍රිතයක් තුළ දීර් statement ප්‍රකාශයක් කිරීමට ඔබට අවශ්‍ය නැතිනම් මෙය ප්‍රයෝජනවත් වේ .

ඔබට __len__()ඒ වෙනුවට භාවිතා කළ හැකි නමුත් __len__()ටිකක් අමුතු පෙනුමක්.

දත්ත රාමු df සඳහා, දත්ත ගවේෂණය කිරීමේදී භාවිතා කරන මුද්‍රිත කොමා ආකෘතිගත පේළි ගණන:

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

උදාහරණයක්:

nrow(my_df)
12,456,789

මේ dfදෙකෙන් එකක්වත් කළ හැකිය (දත්ත රාමුවේ නම):

ක්රමය 1: lenශ්‍රිතය භාවිතා කිරීම:

len(df)දත්ත රාමුවක පේළි ගණන ලබා දෙනු ඇත df.

ක්රමය 2: countශ්‍රිතය භාවිතා කිරීම :

df[col].count()දී ඇති තීරුවක පේළි ගණන ගණනය කරනු ඇත col.

df.count() සියලු තීරු සඳහා පේළි ගණන ලබා දෙනු ඇත.

දත්ත රාමුවක පේළි ප්‍රමාණය සොයා ගැනීම සඳහා විකල්ප ක්‍රමයක් වන්නේ වඩාත්ම කියවිය හැකි ප්‍රභේදයයි pandas.Index.size.

පිළිගත් පිළිතුර පිළිබඳව මා අදහස් දැක්වූ පරිදි:

සැක සහිතය pandas.Index.sizeඇත්ත වශයෙන්ම වඩා වේගවත් වනු ඇති len(df.index)නමුත් timeitමගේ පරිගණකයේ වෙනත් ආකාරයකින් මට කියයි (ලූපයකට ~ 150 ns මන්දගාමී).

මෙය ක්‍රියාත්මක වේදැයි මට විශ්වාස නැත (දත්ත මඟ හැරිය හැක), නමුත් මෙය ක්‍රියාත්මක විය හැකිය:

*dataframe name*.tails(1)

ඉන්පසු මෙය භාවිතා කිරීමෙන් ඔබට කේත ස්නිපෙට් ධාවනය කර ඔබට ලබා දුන් පේළි අංකය බැලීමෙන් පේළි ගණන සොයාගත හැකිය.