Belajar PySpark - sort dan orderBy pada DataFrame

belajar-pyspark-sort-dan-orderby

Salah satu aktivitas yang banyak dilakukan dalam pengolahan dan analisis data adalah pengurutan atau sorting.

Dalam pyspark DataFrame, pengurutan data dilakukan dengan menggunakan fungsi pyspark.sql.DataFrame.sort() atau pyspark.sql.DataFrame.orderBy().

Selain menggunakan fungsi tersebut, kita juga dapat menggunakan fungsi spark.sql() dan SQL statement, dengan perintah ORDER BY.

Dalam seri belajar pySpark ini kita akan mempelajari mengenai bagaimana melakukan pengurutan data pada DataFrame.

Sebelumnya, pastikan package pyspark sudah terinstall. Jika belum, kita bisa menggunakan perintah pip install pyspark untuk melakukan instalasi.

Selanjutnya kita import package yang akan kita gunakan, serta kita inisialisasi spark session

from pyspark.sql import SparkSession
import pyspark.sql.functions as F

spark = SparkSession.builder.appName("Belajar PySpark - Sorting DataFrame").getOrCreate()

 

Selanjutnya kita persiapkan DataFrame yang akan kita olah

data = [['Agus','Fisika',1,130,100],['Windy','Fisika',3,200,150],
        ['Budi','Biologi',1,200,150],['Dina','Fisika',3,150,200],
        ['Bayu','Fisika',1,150,200],['Dedi','Biologi',3,50,150]]

kolom = ["nama","jurusan","semester","nilai1","nilai2"]
df = spark.createDataFrame(data,kolom)
df.show()

 

Mengurutkan DataFrame dengan fungsi sort dan orderBy

Fungsi sort menerima argumen berupa string nama kolom dan/atau kolom DataFrame. Mengurutkan DataFrame dengan satu kolom, dapat dilakukan dengan menggunakan parameter berupa string

df.sort("jurusan").show()

 

atau parameter berupa kolom, dengan menggunakan fungsi pyspark.sql.functions.col()

df.sort(F.col("jurusan")).show()

 

atau parameter berupa kolom, dengan memanggil kolom dari DataFrame bersangkutan

df.sort(df.jurusan).show()

 

Ketiganya akan memberikan output yang sama :

+-----+-------+--------+------+------+
| nama|jurusan|semester|nilai1|nilai2|
+-----+-------+--------+------+------+
| Budi|Biologi|       1|   200|   150|
| Dedi|Biologi|       3|    50|   150|
| Agus| Fisika|       1|   130|   100|
| Dina| Fisika|       3|   150|   200|
|Windy| Fisika|       3|   200|   150|
| Bayu| Fisika|       1|   150|   200|
+-----+-------+--------+------+------+

 

Kita dapat juga menggunakan fungsi orderBy dengan cara pemanggilan yang sama. Fungsi orderBy ini sebenarnya merupakan nama lain atau alias dari fungsi sort, sehingga signature-nya (parameter dan return value-nya) persis sama dengan fungsi sort.

df.orderBy("jurusan").show()
df.orderBy(F.col("jurusan")).show()
df.orderBy(df.jurusan).show()
+-----+-------+--------+------+------+
| nama|jurusan|semester|nilai1|nilai2|
+-----+-------+--------+------+------+
| Budi|Biologi|       1|   200|   150|
| Dedi|Biologi|       3|    50|   150|
| Agus| Fisika|       1|   130|   100|
| Dina| Fisika|       3|   150|   200|
|Windy| Fisika|       3|   200|   150|
| Bayu| Fisika|       1|   150|   200|
+-----+-------+--------+------+------+

Catatan : Semua pilihan dan cara pemanggilan yang dapat dilakukan dengan fungsi sort seperti dijelaskan pada bagian selanjutnya, dapat juga digunakan dengan fungsi groupBy.

 

Mengurutkan DataFrame berdasar lebih dari 1 kolom

Untuk melakukan sorting berdasar beberapa kolom, kita kirimkan string nama-nama kolom tersebut sebagai parameter seperti berikut ini:

df.sort("semester", "jurusan").show()
+-----+-------+--------+------+------+
| nama|jurusan|semester|nilai1|nilai2|
+-----+-------+--------+------+------+
| Budi|Biologi|       1|   200|   150|
| Bayu| Fisika|       1|   150|   200|
| Agus| Fisika|       1|   130|   100|
| Dedi|Biologi|       3|    50|   150|
|Windy| Fisika|       3|   200|   150|
| Dina| Fisika|       3|   150|   200|
+-----+-------+--------+------+------+


Atau dapat juga kita gunakan format kolom seperti di bawah ini :

df.sort(df.semester, df.jurusan).show()


Bahkan, meskipun mungkin kurang lazim, kita bisa menggunakan campuran keduanya (string dan kolom) :

df.sort(df.semester, "jurusan").show()

 

Fungsi sort juga dapat menerima parameter berupa list, untuk mengurutkan berdasar beberapa kolom :

df.sort(["semester", "jurusan"]).show()

Mengurutkan DataFrame secara ascending dan descending

 

Secara default, fungsi sort akan mengembalikan hasil yang terurut secara naik (ascending). Untuk menentukan hasil sorting secara eksplisit, kita dapat menggunakan beberapa cara :

  • Menggunakan parameter ascending, atau asc dengan nilai boolean :True jika ascending, False jika descending.
  • Menggunakan parameter ascending, atau asc dengan nilai berupa list of boolean. Jumlah elemen list harus sama dengan jumlah kolom yang jadikan parameter sorting.
  • Menggunakan fungsi pyspark.sql.functions.asc untuk ascending dan pyspark.sql.functions.desc untuk descending
  •  Menggunakan fungsi pyspark.sql.Column.asc untuk ascending dan pyspark.sql.Column.desc untuk descending

 

Menggunakan parameter ascending dengan value boolean

Jika jumlah kolom yang dijadikan parameter sorting lebih dari 1, maka parameter ascending/descending akan diterapkan sama untuk semuanya semuanya. Contoh di bawah ini akan mengurutkan kolom semester dan jurusan secara descending.

df.sort(["semester", "jurusan"], ascending=False).show()
+-----+-------+--------+------+------+
| nama|jurusan|semester|nilai1|nilai2|
+-----+-------+--------+------+------+
|Windy| Fisika|       3|   200|   150|
| Dina| Fisika|       3|   150|   200|
| Dedi|Biologi|       3|    50|   150|
| Agus| Fisika|       1|   130|   100|
| Bayu| Fisika|       1|   150|   200|
| Budi|Biologi|       1|   200|   150|
+-----+-------+--------+------+------+

 

Menggunakan parameter ascending dengan value list of boolean

Untuk menggunakan list sebagai parameter ascending, jumlah elemen list harus sama dengan jumlah kolom yang jadikan parameter sorting. Masing-masing value akan diterapkan sesuai urutannya.

Misalnya pada contoh di bawah ini mengurutkan kolom semester secara ascending dan kolom jurusan secara descending.

df.sort("semester", "jurusan", ascending=[True, False]).show()
+-----+-------+--------+------+------+
| nama|jurusan|semester|nilai1|nilai2|
+-----+-------+--------+------+------+
| Bayu| Fisika|       1|   150|   200|
| Agus| Fisika|       1|   130|   100|
| Budi|Biologi|       1|   200|   150|
| Dina| Fisika|       3|   150|   200|
|Windy| Fisika|       3|   200|   150|
| Dedi|Biologi|       3|    50|   150|
+-----+-------+--------+------+------+

 

Menggunakan fungsi asc dan desc

Selain menggunakan parameter, kita juga dapat menggunakan fungsi asc dan desc. Pyspark mengimplementasikan fungsi-fungsi ini di 2 tempat, yaitu pyspark.sql.functions dan pyspark.sql.Column.

Untuk menggunakan fungsi asc dan desc di pyspark.sql.functions, parameter kolom dapat berupa string maupun kolom dataframe. Seperti contoh berikut ini

df.sort(F.asc("semester"), F.desc("jurusan")).show()
+-----+-------+--------+------+------+
| nama|jurusan|semester|nilai1|nilai2|
+-----+-------+--------+------+------+
| Bayu| Fisika|       1|   150|   200|
| Agus| Fisika|       1|   130|   100|
| Budi|Biologi|       1|   200|   150|
| Dina| Fisika|       3|   150|   200|
|Windy| Fisika|       3|   200|   150|
| Dedi|Biologi|       3|    50|   150|
+-----+-------+--------+------+------+

 

Sedangkan untuk menggunakan pyspark.sql.Column.asc dan pyspark.sql.Column.desc tentunya parameter harus berupa kolom dataframe.

df.sort(F.col("semester").asc(), F.col("jurusan").desc()).show()
+-----+-------+--------+------+------+
| nama|jurusan|semester|nilai1|nilai2|
+-----+-------+--------+------+------+
| Bayu| Fisika|       1|   150|   200|
| Agus| Fisika|       1|   130|   100|
| Budi|Biologi|       1|   200|   150|
| Dina| Fisika|       3|   150|   200|
|Windy| Fisika|       3|   200|   150|
| Dedi|Biologi|       3|    50|   150|
+-----+-------+--------+------+------+

 

Menangani null value dalam sorting

Ada beberapa pilihan ketika untuk menangani nilai null dalam sorting. Selain fungsi asc dan desc, pyspark juga menyediakan beberapa pilihan fungsi sorting terkait null, yaitu :

  • asc_nulls_first: mengurutkan secara naik/ascending, NULL didahulukan dari non-null
  • asc_nulls_last: mengurutkan secara ascending, non-null didahulukan dari NULL
  • desc_nulls_first: mengurutkan secara menurun/descending, NULL didahulukan dari non-null
  • desc_nulls_last: mengurutkan secara descending, non-null didahulukan dari NULL.
df2.sort(F.desc_nulls_first("jurusan")).show()
+-----+-------+--------+------+------+
| nama|jurusan|semester|nilai1|nilai2|
+-----+-------+--------+------+------+
| Budi|   NULL|       1|   200|   150|
| Agus| Fisika|       1|   130|   100|
|Windy|Biologi|       3|   200|   150|
+-----+-------+--------+------+------+

df2.sort(F.desc_nulls_last("jurusan")).show()
+-----+-------+--------+------+------+
| nama|jurusan|semester|nilai1|nilai2|
+-----+-------+--------+------+------+
| Agus| Fisika|       1|   130|   100|
|Windy|Biologi|       3|   200|   150|
| Budi|   NULL|       1|   200|   150|
+-----+-------+--------+------+------+

 

Mengurutkan DataFrame dengan hasil penjumlahan kolom

Adakalanya kita perlu mengurutkan data dengan hasil perhitungan beberapa kolom, misalnya hasil penjumlahan, perkalian, dll.

Misalnya untuk mengurutkan data berdasar jumlah dari kolom nilai1 dan nilai2, kita dapat melakukannya seperti berikut ini

df.sort(F.col("nilai1") + F.col("nilai2")).show()
+-----+-------+--------+------+------+
| nama|jurusan|semester|nilai1|nilai2|
+-----+-------+--------+------+------+
| Dedi|Biologi|       3|    50|   150|
| Agus| Fisika|       1|   130|   100|
| Dina| Fisika|       3|   150|   200|
|Windy| Fisika|       3|   200|   150|
| Bayu| Fisika|       1|   150|   200|
| Budi|Biologi|       1|   200|   150|
+-----+-------+--------+------+------+

 

Untuk mengurutkan secara menurun, kita dapat menggunakan parameter ascending=False, maupun fungsi desc seperti berikut ini

df.sort((F.col("nilai1") + F.col("nilai2")).desc()).show()
+-----+-------+--------+------+------+
| nama|jurusan|semester|nilai1|nilai2|
+-----+-------+--------+------+------+
| Dina| Fisika|       3|   150|   200|
|Windy| Fisika|       3|   200|   150|
| Bayu| Fisika|       1|   150|   200|
| Budi|Biologi|       1|   200|   150|
| Agus| Fisika|       1|   130|   100|
| Dedi|Biologi|       3|    50|   150|
+-----+-------+--------+------+------+

 

Mengurutkan DataFrame dengan SQL statement

Selain menggunakan fungsi-fungsi dataframe seperti contoh-contoh di atas, kita juga dapat menggunakan SQL statement.

Untuk menggunakan SQL statement, langkah pertama adalah membuat temporary view/table dari dataframe yang akan kita query, dengan perintah createOrReplaceTemporaryView. Dalam contoh berikut ini kita akan buat temporary table bernama “mahasiswa” dari dataframe kita.

df.createOrReplaceTempView("mahasiswa")

 

Selanjutnya untuk mengeksekusi SQL statement, kita gunakan fungsi pyspark.sql() yang mengembalikan dataframe.

spark.sql("SELECT * FROM mahasiswa ORDER BY semester desc, jurusan desc").show()
+-----+-------+--------+------+------+
| nama|jurusan|semester|nilai1|nilai2|
+-----+-------+--------+------+------+
|Windy| Fisika|       3|   200|   150|
| Dina| Fisika|       3|   150|   200|
| Dedi|Biologi|       3|    50|   150|
| Agus| Fisika|       1|   130|   100|
| Bayu| Fisika|       1|   150|   200|
| Budi|Biologi|       1|   200|   150|
+-----+-------+--------+------+------+

 

Wrapping Up

Ada banyak cara untuk melakukan sorting dataframe. Demikian juga, ada banyak cara untuk memanggil fungsi sort maupun orderBy. Pilihlah cara yang paling sesuai dengan kebutuhan pengolahan data yang dilakukan.

Notebook untuk tutorial ini dapat diakses di sini


Simak juga artikel-artikel sebelumnya :