Pemrograman Fungsional vs Pemrograman Berorientasi Objek dalam Analisis Data

Struktur yang baik adalah ciri khas dari kode yang ditulis dengan baik. Sifat struktur ini ditentukan oleh paradigma pemrograman yang digunakan. Paradigma pemrograman adalah seperangkat prinsip dan teknik yang koheren yang mendefinisikan pendekatan dalam merancang dan membuat kode program komputer.

Ada banyak paradigma pemrograman, seperti prosedural, imperatif, deklaratif, berorientasi objek, dan fungsional. Beberapa bahasa terbatas hanya pada beberapa paradigma. Misalnya, SQL adalah bahasa yang bersifat deklaratif. Namun, banyak bahasa modern, termasuk Python, mendukung beberapa paradigma pemrograman, sehingga memberikan fleksibilitas.

Latih menulis pure function dengan latihan langsung dari kursus Introduction to Programming Paradigms kami. 

Banyak programmer cenderung menggunakan paradigma pemrograman yang mereka sukai, sering kali yang pertama kali mereka pelajari. Programmer yang lebih berpengalaman memahami kelebihan dan kelemahan setiap paradigma pemrograman dan dapat memanfaatkan kekuatan masing-masing dalam berbagai skenario. Mari kita bahas dua paradigma pemrograman yang paling umum digunakan dalam ilmu data: pemrograman fungsional dan pemrograman berorientasi objek.

Apa itu Pemrograman Fungsional (FP)?

Dalam pemrograman fungsional, kode dibangun dengan mendefinisikan dan menggunakan fungsi yang menentukan bagaimana program harus berjalan. Ini adalah subtipe dari paradigma pemrograman deklaratif.

Fungsi adalah baris-baris kode yang menerima argumen dan mengembalikan keluaran. Sebuah fungsi sederhana mungkin menerima daftar angka sebagai argumen dan, misalnya, hanya mengembalikan nilai genap.

def get_even_numbers(list):
    return [num for num in list if num % 2 == 0]

Lihat kursus-kursus ini untuk mempelajari praktik terbaik menulis fungsi dalam Python dan R.

Pemrograman fungsional menonjol karena kemudahan pelacakan dan prediktabilitasnya. Ini karena fungsi yang digunakan bersifat immutable, artinya tidak dapat diubah. Fungsi didefinisikan, sering kali di bagian terpisah dari kode (atau kadang di berkas yang berbeda), lalu digunakan di seluruh kode sesuai kebutuhan. Atribut ini memudahkan untuk menentukan apa yang terjadi di suatu bagian kode, karena fungsi berperilaku sama dan dipanggil dengan cara yang sama di mana pun.

Konsep immutability juga berlaku untuk struktur data dalam pemrograman fungsional. Dalam FP, lebih disukai membuat salinan data saat mengubah keadaannya. Ini membangun jejak kertas virtual dari semua transformasi yang diterapkan pada data, meningkatkan keterlacakan dan mempermudah identifikasi masalah. Namun, penting untuk dicatat bahwa pendekatan ini sering mengakibatkan peningkatan konsumsi memori, karena setiap perubahan keadaan melibatkan penyalinan seluruh dataset.

Subkumpulan fungsi yang digunakan dalam pemrograman fungsional adalah higher-order function. Ini adalah fungsi yang menerima fungsi lain sebagai argumen atau mengembalikan fungsi sebagai hasil. Misalnya, Anda mungkin memiliki higher-order function yang menjalankan sebuah fungsi beberapa kali, seperti yang ditunjukkan di bawah ini, atau yang memilih fungsi yang tepat untuk digunakan dalam skenario tertentu.

def run_function_multiple_times(function, num_times):
	for i in range(num_times):
        function()

Kelebihan pemrograman fungsional dalam analisis data

Pemrograman fungsional memberikan struktur untuk mengurangi duplikasi dalam kode Anda. Tujuan pemrograman fungsional adalah memudahkan mengekspresikan tindakan berulang menggunakan verba tingkat tinggi.

Sebagai contoh, misalkan Anda perlu memodifikasi string agar sesuai format tertentu di beberapa tempat berbeda dalam kode. Format ini mengharuskan Anda menghapus spasi, tanda baca, dan angka serta menjadikannya huruf kecil semua. Anda bisa menyalin dan menempel beberapa baris kode di berbagai bagian program sesuai kebutuhan. Namun, duplikasi ini akan membuat kode membengkak. Sebagai gantinya, Anda cukup mendefinisikan fungsi untuk memodifikasi string dan memanggil fungsi tersebut di tempat yang sesuai. Ini merampingkan kode Anda agar lebih ringkas, mudah dibaca, dan cepat diketik.

def clean_string(string):
	exclude = set(string.punctuation + string.digits + " ")
    return ''.join(ch.lower() for ch in string if ch not in exclude)
 
my_string = "Hello, World! 123"
new_string = clean_string(my_string)
print(new_string)

Menyusun fungsi untuk membangun pipeline data yang kompleks

Pemrograman fungsional berguna saat bekerja dengan dataset besar atau pipeline data karena memungkinkan kita memecah tugas pemrosesan data yang kompleks menjadi langkah-langkah yang lebih kecil dan mudah dikelola. Sering kali, setidaknya satu fungsi akan dibuat untuk setiap langkah sepanjang pipeline. Jika Anda telah menuliskan bagan alur langkah-langkah yang dibutuhkan dalam pipeline, Anda akan memiliki gambaran kasar fungsi-fungsi apa yang diperlukan. Secara umum, Anda memerlukan setidaknya satu fungsi untuk setiap langkah.

Kebanyakan bahasa juga memiliki banyak fungsi bawaan dan pustaka fungsi tambahan yang dapat diunduh. Paket purr di R adalah contoh yang bagus. Ini memudahkan untuk dengan cepat membangun pipeline sambil meminimalkan jumlah fungsi kustom yang perlu Anda buat.

Menciptakan kode yang ekspresif dan mudah dibaca dengan prinsip FP

Pemrograman fungsional bertujuan menghasilkan kode yang sangat mudah dibaca. Berikut beberapa pedoman untuk membangun kode yang ekspresif dan mudah dibaca menggunakan pemrograman fungsional:

• Jaga fungsi tetap kecil dan fokus: Setiap fungsi harus memiliki tanggung jawab yang jelas dan tunggal, sehingga lebih mudah dipahami dan dipelihara. Ini disebut pure function.
• Hindari state yang dapat berubah (mutable): Hindari mengubah keadaan data Anda untuk menghilangkan efek samping dan membuat alur data lebih dapat diprediksi. Struktur data immutable berkontribusi pada kejelasan kode dan penalaran. Alih-alih memodifikasi keadaan suatu struktur, buat struktur data baru dengan perubahan yang diinginkan.
• Manfaatkan higher-order function: Fungsi yang menerima fungsi lain sebagai argumen atau mengembalikan fungsi disebut higher-order function. Ini memungkinkan Anda menulis kode yang lebih ekspresif dan ringkas.
• Gunakan komposisi fungsi: Komposisi fungsi adalah proses menggabungkan dua atau lebih fungsi untuk menghasilkan fungsi baru. Ini memungkinkan Anda memecah masalah kompleks menjadi bagian-bagian yang lebih kecil dan mudah dikelola.

Apa itu Pemrograman Berorientasi Objek (OOP)?

Pemrograman berorientasi objek adalah paradigma yang berfokus pada objek. Objek adalah entitas mandiri yang terdiri dari data dan metode yang beroperasi pada data tersebut. Ini adalah cara menjaga data dan operasinya tetap berdekatan, berbeda dengan pemrograman fungsional, di mana keduanya sering dipisahkan. Ini dapat memudahkan untuk mengikuti apa yang terjadi pada data Anda.

Dalam pemrograman berorientasi objek, data dan metode diorganisasi ke dalam objek yang didefinisikan oleh kelasnya. Kelas dirancang untuk menentukan bagaimana setiap objek harus berperilaku, kemudian objek dibuat di dalam kelas tersebut. Lihat tutorial DataCamp untuk detail lebih lanjut tentang cara kerja kelas di Python.

Contoh OOP

Sebagai contoh, Anda mungkin memiliki kelas bernama BankAccount yang menjelaskan bagaimana setiap akun harus berperilaku. Kelas ini dapat memiliki atribut seperti saldo, nomor ID, dan nama nasabah. Kelas ini juga dapat memiliki metode yang menggambarkan bagaimana informasi di dalam kelas tersebut dapat dipengaruhi, seperti penarikan, penyetoran, dan cek saldo.

Setelah kelas ini didefinisikan, Anda dapat membuat objek, dalam hal ini, sebuah akun untuk seseorang. Setelah objek dibuat, Anda dapat mengisinya dengan data untuk setiap properti dan menggunakan metode untuk memodifikasi akun. Lihat contoh di bawah ini.

# Define a class representing a bank account
class BankAccount:
    def __init__(self, account_id, customer_name, initial_balance=0.0):
        # Initialize account properties
        self.account_id = account_id
        self.customer_name = customer_name
        self.balance = initial_balance

    # Method to deposit money into the account
    def deposit(self, amount):
        """Deposit money into the account."""
        if amount > 0:
            # Update balance and print deposit information
            self.balance += amount
            print(f"Deposited ${amount}. New balance: ${self.balance}")
        else:
            # Print message for invalid deposit amount
            print("Invalid deposit amount. Please deposit a positive amount.")

    # Method to withdraw money from the account
    def withdraw(self, amount):
        """Withdraw money from the account."""
        if 0 < amount <= self.balance:
            # Update balance and print withdrawal information
            self.balance -= amount
            print(f"Withdrew ${amount}. New balance: ${self.balance}")
        elif amount > self.balance:
            # Print message for insufficient funds
            print("Insufficient funds. Withdrawal canceled.")
        else:
            # Print message for invalid withdrawal amount
            print("Invalid withdrawal amount. Please withdraw a positive amount.")

    # Method to check the current balance of the account
    def check_balance(self):
        """Check the current balance of the account."""
        print(f"Current balance for {self.customer_name}'s account (ID: {self.account_id}): ${self.balance}")

Enkapsulasi

Proses menggabungkan data dan perilaku Anda ke dalam objek yang didefinisikan oleh sebuah kelas disebut enkapsulasi. Ini memungkinkan Anda membuat struktur yang terdefinisi dengan baik agar bagian kode lainnya dapat dengan mudah berinteraksi dengan objek. Variabel yang disimpan di dalam objek disebut atribut, dan fungsi yang menentukan perilaku objek disebut metode.

Pewarisan

Salah satu cara untuk mengurangi duplikasi kode adalah menggunakan pewarisan saat membuat kelas baru. Ini adalah cara membuat kelas baru yang mempertahankan fungsionalitas dari kelas induk. Dalam contoh rekening bank kita, Anda dapat memiliki kelas induk yang digeneralisasi untuk semua akun dan kelas turunan dengan spesifik untuk rekening tabungan dan rekening giro.

Polimorfisme

Polimorfisme adalah konsep yang memungkinkan Anda menggunakan nama yang sama untuk metode berbeda yang memiliki perilaku berbeda tergantung pada inputnya. Ini umum digunakan bersama pewarisan.

Sebagai contoh, misalkan kita memiliki kelas induk bernama Shape yang memiliki metode untuk menghitung luas bangun. Anda mungkin memiliki dua kelas turunan, Circle dan Square. Meskipun masing-masing akan memiliki metode bernama Area, definisi metode tersebut akan berbeda untuk setiap bangun. Bandingkan metode untuk luas pada bangun yang berbeda dalam blok kode di bawah ini.

# Define the parent class Shape
class Shape:
	# Initialize the attributes for the shape
	def __init__(self, name):
    	    self.name = name
	
	# Define a generic method for calculating the area
	def area(self):
    	    print(f"The area of {self.name} is unknown.")
 
# Define the child class Circle that inherits from Shape
class Circle(Shape):
	# Initialize the attributes for the circle
	def __init__(self, name, radius):
    	# Call the parent class constructor
    	    super().__init__(name)
    	    self.radius = radius
	
	# Override the area method for the circle
	def area(self):
    	# Use the formula pi * r^2
    	    area = 3.14 * self.radius ** 2
    	    print(f"The area of {self.name} is {area}.")
 
# Define the child class Square that inherits from Shape
class Square(Shape):
	# Initialize the attributes for the square
	def __init__(self, name, side):
    	# Call the parent class constructor
    	    super().__init__(name)
    	    self.side = side
	
	# Override the area method for the square
	def area(self):
    	# Use the formula s^2
    	    area = self.side ** 2
    	    print(f"The area of {self.name} is {area}.")

Ada beberapa sumber untuk mempelajari cara menggunakan pemrograman berorientasi objek, termasuk kursus OOP di Python dari DataCamp, kursus OOP di R, dan tutorial OOP di Python.

Kelebihan Pemrograman Berorientasi Objek dalam analisis data

Pemrograman Berorientasi Objek dapat menawarkan beberapa kelebihan untuk analisis data:

• Enkapsulasi data: Enkapsulasi membantu menyembunyikan detail internal algoritma dan struktur analisis data, hanya mengekspos antarmuka yang diperlukan. Ini mendorong pemisahan komponen yang bersih dan meningkatkan kemampuan pemeliharaan kode.
• Guna ulang kode: Pemrograman berorientasi objek mendorong pembuatan kelas generik yang dapat diwarisi oleh kelas lain, menghindari duplikasi kode dan mengurangi upaya pemeliharaan. Ini dapat meningkatkan produktivitas dan efisiensi analisis data.
• Manfaat desain: Pemodelan masalah dunia nyata menggunakan kelas dan objek yang merepresentasikan data dan perilaku meningkatkan keterbacaan, kejelasan, dan modularitas analisis data.

OOP vs. FP: Memilih Paradigma yang Tepat

Ada banyak faktor yang perlu dipertimbangkan saat memilih menggunakan OOP atau FP untuk proyek data Anda. Beberapa tim data mungkin sangat menyukai satu paradigma dibandingkan yang lain, dalam hal ini, menyelaraskan paradigma Anda dengan tim adalah pilihan yang tepat. Dalam kasus lain, sifat data atau aplikasi Anda dapat mempengaruhi pilihan ke salah satu arah.

Kapan memanfaatkan OOP untuk tugas data

Pemrograman berorientasi objek sangat baik untuk aplikasi yang perlu memodelkan entitas. Contoh yang bagus termasuk merancang sistem untuk mengelola perpustakaan atau membuat sistem untuk memberi skor setiap perusahaan dalam portofolio investasi. Proses membuat objek yang teren kapsulasi memudahkan pelacakan entitas ini. OOP juga lebih disukai saat Anda memiliki memori terbatas, karena FP cenderung membutuhkan lebih banyak memori daripada OOP.

Kapan memanfaatkan FP untuk tugas data

Pemrograman fungsional unggul dalam tugas analisis data yang memerlukan pemrosesan paralel. Fokus pada immutability dan menghindari efek samping memudahkan paralelisasi operasi pada dataset. Fungsi dapat diterapkan secara bersamaan pada bagian-bagian berbeda dari data tanpa saling mengganggu.

Fokus FP pada immutability juga menjadikannya ideal untuk pipeline transformasi data. Fungsi dapat dikomposisikan untuk membuat rangkaian transformasi tanpa memutasi state, menghasilkan kode yang lebih mudah dibaca dan dipelihara.

FP juga umumnya lebih disukai oleh ilmuwan dan akademisi karena mempertahankan fokus yang lebih pada matematika murni.

Menggabungkan teknik OOP dan FP

Dalam beberapa aplikasi praktis, OOP dan FP dapat digabungkan dalam satu program. Ini memungkinkan pengembang memanfaatkan kekuatan masing-masing paradigma. Enkapsulasi pada OOP dan ekspresivitas pada FP dapat sama-sama dimanfaatkan untuk membangun pipeline pembelajaran mesin atau aplikasi web.

Namun, menggabungkan paradigma seperti ini dapat menimbulkan tantangan dan harus dilakukan dengan hati-hati. Kode yang melompat di antara beberapa paradigma bisa lebih sulit dipahami. Menjaga integrasi komponen yang mulus juga bisa menjadi tantangan.

Pertimbangkan contoh di bawah ini. Kode Python ini menggabungkan OOP dan FP untuk melakukan operasi matematika pada daftar angka. Kelas MathOperation bertindak seperti kontainer untuk operasi matematika tertentu yang dibuat menggunakan FP. Fungsi filter_odd_numbers dan square_operation membantu menyaring bilangan ganjil dan menghitung kuadrat suatu angka. Dengan menggunakan komponen ini bersama-sama, kode secara efisien menyaring bilangan ganjil dari daftar yang diberikan lalu menguadratkan nilainya, menunjukkan bagaimana OOP dan FP dapat bekerja sama untuk menyederhanakan dan menata tugas analisis data.

# Object-Oriented Programming (OOP) - Class Definition
class MathOperation:
	def __init__(self, operation):
    	    self.operation = operation
 
	def apply_operation(self, number):
    	    return self.operation(number)
 
# Functional Programming (FP) - Higher-Order Functions
def filter_odd_numbers(numbers):
    return list(filter(lambda x: x % 2 != 0, numbers))
 
def square_operation(number):
    return number ** 2
 
def process_numbers(numbers, operation_function):
    return list(map(operation_function, numbers))
 
# Example Usage:
# Define an OOP class representing a mathematical operation (square in this case)
square_operation_instance = MathOperation(square_operation)
 
# Sample list of numbers
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
 
# Use FP to filter odd numbers
odd_numbers = filter_odd_numbers(numbers)
 
# Use OOP to apply the square operation to odd numbers
result = process_numbers(odd_numbers, square_operation_instance.apply_operation)
 
# Display the result
print(result)

Untuk contoh lain penggunaan OOP dan FP secara bersamaan, lihat repositori GitHub ini.

Kesimpulan

Tidak ada jawaban pasti tentang paradigma pemrograman mana yang terbaik, karena bergantung pada konteks, tujuan, bahasa, dan preferensi programmer. Namun, ada beberapa panduan umum yang dapat Anda ikuti untuk menentukan paradigma mana yang paling cocok untuk situasi Anda.

Gunakan OOP saat Anda perlu memodelkan sistem kompleks dengan banyak entitas dan interaksi, serta ketika Anda perlu mengen kapsulasi data dan perilaku ke dalam komponen yang dapat digunakan kembali. Gunakan FP saat Anda perlu melakukan perhitungan murni dengan masukan dan keluaran sederhana, serta ketika Anda perlu menghindari efek samping atau perubahan state. Gunakan pendekatan campuran saat Anda perlu memanfaatkan kekuatan kedua paradigma, serta ketika Anda perlu menyesuaikan diri dengan fitur dan keterbatasan bahasa.

Programmer terbaik tidak terbatas pada satu paradigma saja; mereka dapat berpindah antarparadigma sesuai kebutuhan untuk mencapai tujuan mereka. Jelajahi berbagai paradigma secara mendalam melalui kursus Introduction to Programming Paradigms. Cobalah mengerjakan sebuah proyek data dan gunakan OOP serta FP untuk menyelesaikannya. Melatih setiap paradigma akan memberi Anda intuisi yang baik tentang mana yang paling cocok untuk proyek Anda.