Panduan Awal Mengenai Generik Python

Hai sana, master Python masa depan! Hari ini, kita akan memulai perjalanan menarik ke dunia Python Generics. Jangan khawatir jika Anda baru belajar programming - saya akan menjadi panduan ramah Anda, menjelaskan segala sesuatu secara langkah demi langkah. Jadi, ambil secangkir minuman kesukaan Anda, dan mari kita masuk ke dalamnya!

Apa Itu Generics?

Sebelum kita mulai mengoding, mari kita pahami apa itu generics. Bayangkan Anda punya kotak ajaib yang dapat menampung jenis item apa saja - mainan, buku, atau bahkan kue. Itu sebenarnya apa yang generics lakukan dalam programming. Mereka memungkinkan kita menulis kode yang fleksibel dan dapat bekerja dengan jenis data yang berbeda.

Mendefinisikan Fungsi Generik

Mari kita mulai dengan membuat fungsi generik. Dalam Python, kita menggunakan TypeVar dari modul typing untuk mendefinisikan jenis generik.

from typing import TypeVar

T = TypeVar('T')

def print_item(item: T) -> None:
print(f"Item adalah: {item}")

Dalam contoh ini, T adalah jenis generik kita. Fungsi print_item sekarang dapat menerima jenis data apa saja. Mari kitauraikan:

1. Kita mengimpor TypeVar dari modul typing.
2. Kita membuat variabel jenis T.
3. Fungsi kita print_item menerima argumen item jenis T.
4. Fungsi tersebut hanya mencetak item.

Memanggil Fungsi Generik dengan Jenis Data Berbeda

Sekarang, mari kita lihat fungsi generik kita dalam aksi!

print_item(42)
print_item("Hello, Generics!")
print_item([1, 2, 3])

Output:

Item adalah: 42
Item adalah: Hello, Generics!
Item adalah: [1, 2, 3]

Seperti yang Anda lihat, fungsi kita bekerja dengan jenis data yang berbeda - bilangan bulat, string, bahkan daftar. Itu seperti memiliki pisau瑞士军刀 dalam kotak kode Anda!

Mendefinisikan Kelas Generik

Sekarang kita telah menguasai fungsi generik, mari kita tingkatkan dan buat kelas generik. Bayangkan kita sedang membangun sistem penyimpanan sederhana yang dapat menampung jenis item apa saja.

from typing import Generic, TypeVar

T = TypeVar('T')

class Box(Generic[T]):
def __init__(self, item: T):
self.item = item

def get_item(self) -> T:
return self.item

def set_item(self, new_item: T) -> None:
self.item = new_item

Mari kitauraikan kotak ajaib ini:

1. Kita mendefinisikan kelas Box sebagai Generic[T].
2. Metode __init__ menerima item jenis T.
3. get_item mengembalikan item yang disimpan.
4. set_item memungkinkan kita mengubah item.

Sekarang, mari kita gunakan kotak kita:

# Kotak bilangan bulat
int_box = Box(42)
print(int_box.get_item())  # Output: 42

# Kotak string
str_box = Box("Hello, Generic Class!")
print(str_box.get_item())  # Output: Hello, Generic Class!

# Mengubah item dalam kotak
int_box.set_item(100)
print(int_box.get_item())  # Output: 100

Apakah itu menarik? Kita dapat membuat kotak untuk menyimpan jenis item yang berbeda, dan Python memastikan keamanan jenis untuk kita.

Kekuatan Generics

Generics mungkin terlihat sedikit abstrak pada awalnya, tetapi mereka sangat kuat. Mereka memungkinkan kita menulis kode yang fleksibel dan keamanan jenis. Bayangkan Anda sedang membangun aplikasi besar - generics dapat membantu Anda membuat komponen yang dapat digunakan kembali dan bekerja dengan jenis data yang berbeda, menyimpan waktu dan mengurangi kesalahan.

Ini adalah contoh yang lebih kompleks untuk mengilustrasikan kekuatan ini:

from typing import Generic, TypeVar, List

T = TypeVar('T')

class Storage(Generic[T]):
def __init__(self):
self.items: List[T] = []

def add_item(self, item: T) -> None:
self.items.append(item)

def get_items(self) -> List[T]:
return self.items

def get_last_item(self) -> T:
if self.items:
return self.items[-1]
raise IndexError("Penyimpanan kosong")

# Menggunakan kelas generik Storage kita
int_storage = Storage[int]()
int_storage.add_item(1)
int_storage.add_item(2)
int_storage.add_item(3)

str_storage = Storage[str]()
str_storage.add_item("Apple")
str_storage.add_item("Banana")
str_storage.add_item("Cherry")

print(int_storage.get_items())  # Output: [1, 2, 3]
print(str_storage.get_last_item())  # Output: Cherry

Dalam contoh ini, kita telah membuat kelas generik Storage yang dapat menampung daftar jenis apa saja. Kita kemudian membuat penyimpanan terpisah untuk bilangan bulat dan string, menunjukkan fleksibilitas kelas generik kita.

Kesimpulan

Selamat! Anda telah mengambil langkah pertama ke dunia Python Generics. Kita telah melihat fungsi generik, kelas generik, dan bahkan membuat sistem penyimpanan fleksibel. Ingat, seperti segala jenis alat kuat, generics memerlukan latihan untuk dikuasai. Jangan frustasi jika itu belum beresonasi segera - terus mencoba dan Anda akan segera melihat keajaiban generics dalam kode Anda sendiri.

Sementara itu, ini adalah tabel yang menggabungkan metode utama yang kita belajar:

Metode	Deskripsi
TypeVar('T')	Membuat variabel jenis untuk penggunaan generik
Generic[T]	Mendefinisikan kelas generik
__init__(self, item: T)	Menginisialisasi kelas generik dengan item jenis T
get_item(self) -> T	Mengembalikan item jenis T
set_item(self, new_item: T) -> None	Mengatur item baru jenis T
add_item(self, item: T) -> None	Menambahkan item jenis T ke koleksi
get_items(self) -> List[T]	Mengembalikan daftar item jenis T
get_last_item(self) -> T	Mengembalikan item terakhir jenis T dalam koleksi

Terus mengoding, terus belajar, dan ingat - dengan generics, kekuatan Python Anda tak terbatas! Selamat coding, para ahli Python masa depan!

Credits: Image by storyset