I'm mencoba untuk mendapatkan jumlah baris dataframe df dengan Panda, dan berikut ini adalah kode saya.
total_rows = df.count
print total_rows +1
total_rows = df['First_columnn_label'].count
print total_rows +1
Kedua potongan kode yang memberi saya kesalahan ini:
TypeError: tidak didukung operan tipe(s)+: 'instancemethod' dan 'int'
Apa yang saya lakukan salah?
Anda dapat menggunakan .bentuk
atau hanya len(DataFrame.indeks)
. Namun, ada yang terkenal perbedaan kinerja ( len(DataFrame.indeks)
tercepat):
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)
EDIT: Karena @Dan Allen mencatat di komentar len(df.indeks)
dan df[0].count()
adalah tidak dapat dipertukarkan sebagai count
tidak `NaN,
Misalkan df
adalah dataframe maka:
count_row = df.shape[0] # gives number of row count
count_col = df.shape[1] # gives number of col count
Atau, lebih ringkas,
r, c = df.shape
Gunakan len(df)
. Ini bekerja seperti panda 0.11 atau mungkin bahkan lebih awal.
__len__()
saat ini (0.12) didokumentasikan dengan Mengembalikan panjang dari index
. Waktu info, set up dengan cara yang sama seperti di root's jawaban:
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
Karena salah satu fungsi tambahan yang menyebutnya sedikit lebih lambat daripada menelepon len(df.indeks)
secara langsung, tapi ini seharusnya tidak memainkan peran apa pun dalam kebanyakan kasus penggunaan.
Bagaimana cara mendapatkan jumlah baris dari panda DataFrame?
Tabel ini merangkum situasi yang berbeda di mana anda'd ingin menghitung sesuatu di sebuah DataFrame (atau Seri, untuk kelengkapan), bersama dengan metode yang direkomendasikan(s).
catatan kaki
DataFrame.hitung kembali jumlah untuk masing-masing kolom sebagai
Series` sejak non-null hitungan bervariasi dengan kolom.DataFrameGroupBy.ukuran
kembaliSeri
, karena semua kolom dalam kelompok yang sama berbagi baris yang sama-hitungan.DataFrameGroupBy.menghitung
kembaliDataFrame
, karena non-null count bisa berbeda di setiap kolom dalam kelompok yang sama. Untuk mendapatkan kelompok-bijak non-null hitung untuk kolom tertentu, menggunakandf.groupby(...)['x'].count()
mana "x" adalah kolom untuk menghitung.
Di bawah ini saya tampilkan contoh-contoh dari masing-masing metode yang dijelaskan dalam tabel di atas. Pertama, setup -
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
, len(df)
, df.bentuk[0]
, atau len(df.indeks)
len(df)
# 5
df.shape[0]
# 5
len(df.index)
# 5
Tampaknya konyol untuk membandingkan kinerja dari waktu yang konstan operasi, terutama ketika perbedaan pada tingkat "serius, don't khawatir tentang hal itu". Tapi ini tampaknya menjadi tren dengan jawaban yang lain, sehingga saya'm melakukan hal yang sama untuk kelengkapan.
3 metode di atas, len(df.indeks)
(seperti yang disebutkan dalam jawaban yang lain) adalah yang tercepat.
Catatan
- Semua metode di atas adalah konstanta waktu operasi yang sederhana atribut lookup.
df.bentuk
(mirip denganndarray.bentuk
) adalah atribut yang mengembalikan sebuah tuple dari(# Baris # Cols)
. Misalnya,df.bentuk
kembali(8, 2)
untuk contoh di sini.
df.bentuk[1]
, len(df.kolom)
df.shape[1]
# 2
len(df.columns)
# 2
Analog dengan len(df.indeks)
, len(df.kolom)
adalah lebih cepat dari dua metode (tetapi membutuhkan lebih banyak karakter untuk type).
, len(s)
, s.ukuran
, len(s.indeks)
len(s)
# 5
s.size
# 5
len(s.index)
# 5
s.size
dan len(s.indeks)
yang hampir sama dalam hal kecepatan. Tapi saya sarankan len(df)
.
Catatan
ukuran
adalah suatu atribut, dan mengembalikan jumlah elemen (=menghitung baris untuk setiap Seri). DataFrames juga menentukan ukuran atribut yang mengembalikan hasil yang sama sepertidf.bentuk[0] * df.bentuk[1]
.
DataFrame.count
]() dan [Seri.count
]()Metode yang dijelaskan di sini hanya menghitung nilai non-null (arti NaNs diabaikan).
Panggilan DataFrame.count
akan kembali non-NaN penting untuk each kolom:
df.count()
A 5
B 3
dtype: int64
Untuk Seri, gunakan Seri.count
untuk efek yang sama:
s.count()
# 3
GroupBy.ukuran
Untuk DataFrames
, menggunakan DataFrameGroupBy.size
untuk menghitung jumlah baris per kelompok.
df.groupby('A').size()
A
a 2
b 2
c 1
dtype: int64
Demikian pula, untuk Seri
, anda'll menggunakan SeriesGroupBy.size
.
s.groupby(df.A).size()
A
a 2
b 2
c 1
Name: B, dtype: int64
Dalam kedua kasus, seorang Serial
kembali. Ini masuk akal untuk DataFrames
juga karena semua kelompok berbagi baris yang sama-hitungan.
GroupBy.count
Mirip dengan di atas, tetapi menggunakan GroupBy.count
, tidak GroupBy.ukuran
. Perhatikan bahwa ukuran
selalu kembali Seri
, sementara menghitung
kembali Seri
jika disebut pada kolom tertentu, atau yang lain DataFrame
.
Berikut metode kembali hal yang sama:
df.groupby('A')['B'].size()
df.groupby('A').size()
A
a 2
b 2
c 1
Name: B, dtype: int64
Sementara itu, untuk menghitung
, kita memiliki
df.groupby('A').count()
B
A
a 2
b 1
c 0
...disebut pada seluruh GroupBy objek, v/s,
df.groupby('A')['B'].count()
A
a 2
b 1
c 0
Name: B, dtype: int64
Yang disebut pada kolom tertentu.
len()
adalah teman anda, jawaban singkat untuk jumlah baris adalah len(df)
.
Atau, anda dapat mengakses semua baris dengan df.index
dan semua kolom dengan
df.kolom
, dan anda dapat menggunakan len(anyList)
untuk mendapatkan hitungan dari daftar, maka anda dapat menggunakan
len(df.indeks)
untuk mendapatkan jumlah baris, dan len(df.kolom)
untuk kolom menghitung.
Atau, anda dapat menggunakan df.bentuk
yang mengembalikan jumlah baris dan kolom yang sama, jika anda ingin mengakses jumlah baris yang hanya menggunakan df.bentuk[0]
dan untuk jumlah kolom yang hanya menggunakan: df.bentuk[1]
.
Terlepas dari jawaban diatas menggunakan dapat menggunakan df.kapak
untuk mendapatkan tupel dengan baris dan kolom indeks dan kemudian menggunakan len()
fungsi:
total_rows=len(df.axes[0])
total_cols=len(df.axes[1])
Saya datang ke panda dari R
latar belakang, dan saya melihat bahwa panda adalah lebih rumit ketika datang untuk memilih baris atau kolom.
Aku harus bergulat dengan itu untuk sementara waktu, kemudian saya menemukan beberapa cara untuk menangani:
mendapatkan jumlah kolom:
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.
mendapatkan jumlah baris:
len(df.index) #It's similar.
...bangunan pada Jan-Philip Gehrcke's jawaban.
Alasan mengapa len(df)
atau len(df.indeks)
lebih cepat dari df.bentuk[0]
. Melihat kode. df.bentuk adalah @property
yang berjalan DataFrame metode memanggil len
dua kali.
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)
Dan di bawah kap len(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.indeks)
akan sedikit lebih cepat dari len(df)
karena memiliki kurang satu fungsi panggilan, tapi ini selalu lebih cepat dari df.bentuk[0]
Dalam kasus anda ingin mendapatkan jumlah baris di tengah-tengah dirantai operasi, anda dapat menggunakan:
df.pipe(len)
Contoh:
row_count = (
pd.DataFrame(np.random.rand(3,4))
.reset_index()
.pipe(len)
)
Hal ini dapat berguna jika anda don't ingin menempatkan sebuah pernyataan panjang di dalam len() fungsi.
Anda bisa menggunakan __len() bukan tapi \len__() terlihat sedikit aneh.