Pandas & NumPy Academy · Pelajaran

GroupBy dengan Satu dan Pelbagai Kunci

Kumpulkan mengikut satu atau lebih lajur dengan groupby() dan gunakan agregasi jumlah, min, kiraan serta minimum/maksimum.

Pelajaran 2 daripada 413 langkah

GroupBy dengan Satu dan Pelbagai Kunci ialah pelajaran Pandas & NumPy Academy percuma di CoddyKit. Ini ialah pelajaran 2 daripada 4. Anda boleh membaca keseluruhan pelajaran di bawah secara percuma — kemudian berlatih secara praktikal dalam pelayar menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Pandas & NumPy Academy, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Pandas & NumPy Academy merangkumi sejumlah 4 pelajaran.

GroupBy dengan Satu Kunci

Panggilan GroupBy yang paling mudah menggunakan satu lajur sebagai kunci pengumpulan. Anda memanggil df.groupby('column_name') dan merangkaikan pengagregatan. Pandas mencipta satu kumpulan bagi setiap nilai unik dalam lajur tersebut dan menggunakan pengagregatan pada setiap lajur berangka, atau lajur yang dipilih. Ini ialah bentuk GroupBy yang paling biasa dalam analisis harian.

import pandas as pd

df = pd.DataFrame({
    'dept': ['Eng', 'HR', 'Eng', 'HR', 'Eng'],
    'salary': [90000, 60000, 95000, 62000, 88000],
    'years': [3, 5, 7, 2, 4]
})

print(df.groupby('dept')['salary'].mean())
# dept
# Eng    91000.0
# HR     61000.0

Memilih Lajur untuk Diagregat

Selepas memanggil groupby(), Anda boleh memilih satu lajur menggunakan tatatanda kurungan untuk mendapatkan SeriesGroupBy, atau memilih berbilang lajur menggunakan senarai untuk mendapatkan DataFrameGroupBy. Jika Anda tidak membuat sebarang pilihan, Pandas akan mengagregat semua lajur berangka, yang mudah tetapi boleh menghasilkan hasil tidak dijangka apabila terdapat lajur berangka yang tidak berkaitan.

# Single column result -> SeriesGroupBy
print(df.groupby('dept')['salary'].sum())

# Multiple columns result -> DataFrameGroupBy
print(df.groupby('dept')[['salary', 'years']].mean())
#        salary  years
# dept
# Eng   91000.0    4.667
# HR    61000.0    3.500

Semua Pengagregatan Biasa

Pandas menyokong set lengkap kaedah pengagregatan terbina dalam pada objek GroupBy: sum(), mean(), median(), min(), max(), count(), std(), var(), first() dan last(). Setiap kaedah mengembalikan satu skalar bagi setiap kumpulan, lalu menghasilkan jadual ringkasan yang kemas dan diindeks berdasarkan kunci pengumpulan.

g = df.groupby('dept')['salary']
print('sum:   ', g.sum())
print('mean:  ', g.mean())
print('min:   ', g.min())
print('max:   ', g.max())
print('count: ', g.count())
print('std:   ', g.std().round(2))

GroupBy dengan Berbilang Kunci

Hantar senarai nama lajur kepada groupby() untuk mengumpulkan data berdasarkan lebih daripada satu dimensi pada satu-satu masa. Setiap gabungan nilai unik dalam lajur tersebut menjadi kumpulannya sendiri. Hasilnya mempunyai MultiIndex dengan satu aras bagi setiap lajur pengumpulan, yang membolehkan Anda meneliti ringkasan merentas dimensi dalam satu langkah.

df2 = pd.DataFrame({
    'dept':   ['Eng', 'Eng', 'HR',  'HR',  'Eng', 'HR'],
    'level':  ['L1',  'L2',  'L1',  'L2',  'L1',  'L1'],
    'salary': [80000, 100000, 55000, 70000, 82000, 58000]
})

result = df2.groupby(['dept', 'level'])['salary'].mean()
print(result)
# dept  level
# Eng   L1       81000.0
#       L2      100000.0
# HR    L1       56500.0
#       L2       70000.0

Mengakses Hasil MultiIndex

Apabila Anda mengumpulkan data berdasarkan berbilang kunci, indeks hasilnya ialah MultiIndex. Anda boleh mengakses aras luar tertentu dengan .loc['value'] dan menelusuri aras dalam menggunakan tuple. Memanggil reset_index() meratakan MultiIndex menjadi lajur biasa, yang selalunya lebih mudah untuk operasi seterusnya atau eksport.

result = df2.groupby(['dept', 'level'])['salary'].mean()

# Access Engineering rows only
print(result.loc['Eng'])
# level
# L1     81000.0
# L2    100000.0

# Flatten to a regular DataFrame
print(result.reset_index())
#   dept level    salary
# 0  Eng    L1   81000.0
# 1  Eng    L2  100000.0

Menggunakan as_index=False

Secara lalai, lajur pengumpulan menjadi indeks hasil. Penggunaan as_index=False mengekalkannya sebagai lajur biasa, lalu menghasilkan DataFrame rata yang lebih mudah dihantar kepada operasi Pandas seterusnya atau dieksport. Ini bersamaan dengan memanggil reset_index() pada hasil tersebut.

flat = df2.groupby(['dept', 'level'], as_index=False)['salary'].mean()
print(flat)
#   dept level    salary
# 0  Eng    L1   81000.0
# 1  Eng    L2  100000.0
# 2   HR    L1   56500.0
# 3   HR    L2   70000.0

Mengira Baris bagi Setiap Kumpulan

count() mengembalikan bilangan nilai bukan nol dalam setiap kumpulan. Jika Anda mahu jumlah keseluruhan baris bagi setiap kumpulan tanpa mengira nilai nol, gunakan size(). Perbezaan ini penting apabila data Anda mempunyai nilai yang hilang, kerana count() akan mengira kurang bagi kumpulan yang mempunyai entri NaN.

import numpy as np

df3 = pd.DataFrame({
    'dept': ['Eng', 'Eng', 'HR', 'HR'],
    'bonus': [5000, np.nan, 3000, 4000]
})

print(df3.groupby('dept')['bonus'].count())  # ignores NaN
# dept
# Eng    1
# HR     2

print(df3.groupby('dept')['bonus'].size())   # includes NaN rows
# dept
# Eng    2
# HR     2

Mengisih Hasil GroupBy

Secara lalai, GroupBy mengisih hasil berdasarkan kunci kumpulan. Anda boleh melumpuhkan pengisihan dengan sort=False untuk mengekalkan susunan asal kemunculan pertama, yang sedikit lebih pantas pada set data besar. Setelah hasil diperoleh sebagai DataFrame, Anda boleh mengisihnya lagi menggunakan sort_values() pada mana-mana lajur.

result = (df.groupby('dept', sort=False)['salary']
            .mean()
            .reset_index()
            .sort_values('salary', ascending=False))
print(result)
#   dept    salary
# 0  Eng   91000.0
# 1   HR   61000.0

Merangkaikan GroupBy dengan Kaedah Lain

Hasil GroupBy ialah Series atau DataFrame biasa, jadi Anda boleh terus merangkaikan kaedah Pandas seterusnya padanya. Corak yang biasa digunakan ialah mengagregat, kemudian reset_index(), kemudian menamakan semula lajur, kemudian sort_values() — semuanya dalam satu rangkaian kaedah yang mudah dibaca tanpa menyimpan pemboleh ubah perantaraan.

summary = (
    df
    .groupby('dept')['salary']
    .agg(['mean', 'count'])
    .rename(columns={'mean': 'avg_salary', 'count': 'headcount'})
    .reset_index()
    .sort_values('avg_salary', ascending=False)
)
print(summary)

Menggunakan sum, mean dan count Bersama

Anda sering memerlukan lebih daripada satu statistik bagi setiap kumpulan. Hantar senarai nama fungsi kepada .agg() untuk mengira beberapa statistik serentak. Hasilnya ialah DataFrame dengan satu lajur bagi setiap fungsi. Ini lebih cekap berbanding memanggil setiap pengagregatan secara berasingan kerana Pandas memproses kesemuanya dalam satu laluan melalui data.

result = df.groupby('dept')['salary'].agg(['sum', 'mean', 'count', 'max'])
print(result)
#           sum      mean  count    max
# dept
# Eng    273000   91000.0      3  95000
# HR     122000   61000.0      2  62000

Mengumpulkan Berdasarkan Lajur Kategori

Apabila lajur pengumpulan mempunyai jenis data Categorical, Pandas menyertakan semua kategori dalam hasil secara lalai, termasuk kategori yang tiada baris. Ini berguna untuk memastikan jadual ringkasan sentiasa memaparkan setiap kategori, tetapi menghasilkan baris dengan NaN atau 0 bagi kumpulan kosong. Kawal tingkah laku ini menggunakan parameter observed (tetapkan kepada True untuk melangkau kategori kosong).

df['dept'] = df['dept'].astype('category')
# With observed=True, only groups that appear in data are included
print(df.groupby('dept', observed=True)['salary'].mean())
# dept
# Eng    91000.0
# HR     61000.0

Semakan Pantas

Uji pemahaman Anda tentang GroupBy dengan satu dan berbilang kunci daripada pelajaran ini.

Jawab dalam pelajaran interaktif

Ringkasan Pelajaran

Dalam pelajaran ini, Anda mempelajari: cara mengumpulkan data berdasarkan satu lajur dan menggunakan pengagregatan biasa, cara mengumpulkan data berdasarkan berbilang lajur untuk menghasilkan ringkasan merentas dimensi, serta perbezaan antara count() dan size() apabila terdapat nilai nol. Seterusnya, kita akan meneroka kaedah agg() yang berkuasa untuk mengira beberapa statistik berbeza dalam satu panggilan.

Percuma untuk bermula

Pelajari Python dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 30
Pelajaran: 120

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “GroupBy dengan Satu dan Pelbagai Kunci” percuma?

Ya — teks penuh “GroupBy dengan Satu dan Pelbagai Kunci” boleh dibaca secara percuma di web ini. Untuk berlatih secara interaktif menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7, serta membuka kunci baki kursus Pandas & NumPy Academy, tingkat taraf kepada CoddyKit PRO. Kursus Pandas & NumPy Academy merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “GroupBy dengan Satu dan Pelbagai Kunci”?

Kumpulkan mengikut satu atau lebih lajur dengan groupby() dan gunakan agregasi jumlah, min, kiraan serta minimum/maksimum. Anda berlatih Pandas & NumPy Academy menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Pandas & NumPy Academy?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Pandas & NumPy Academy di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 2 daripada 4.

Berapa lamakah pelajaran “GroupBy dengan Satu dan Pelbagai Kunci” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Pandas & NumPy Academy ini?

Ya. Setiap pelajaran Pandas & NumPy Academy menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

← Kembali ke Pandas & NumPy Academy