Panduan untuk Pemula: Generik di Python

Hai teman-teman,大师Python masa depan! Hari ini, kita akan memulai perjalanan menarik ke dunia Generik Python. Jangan khawatir jika Anda baru belajar pemrograman – saya akan menjadi panduan ramah Anda, menjelaskan segala sesuatunya secara langkah demi langkah. Jadi, ambil secangkir minuman kesukaan Anda, dan mari kita masuk ke dalam!

Apa Itu Generik?

Sebelum kita mulai mengoding, mari kita pahami apa itu generik. Bayangkan Anda memiliki kotak ajaib yang dapat menampung jenis item apa saja – mainan, buku, atau bahkan kue. Itu sebenarnya apa yang dilakukan generik dalam pemrograman. 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. Di 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"Itemnya adalah: {item}")

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

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 hanya mencetak item.

Menjalankan Fungsi Generik dengan Jenis Data yang Berbeda

Sekarang, mari kita lihat fungsi generik kita dalam aksi!

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

Output:

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

Seperti yang Anda lihat, fungsi kita bekerja dengan jenis data yang berbeda – bilangan bulat, string, dan bahkan daftar. Itu seperti memiliki pisau Swiss dalam kotak perangkat Anda!

Mendefinisikan Kelas Generik

Sekarang kita telah menguasai fungsi generik, mari kita tingkatkan dan buat kelas generik. Bayangkan kita sedang membuat 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 mengganti item.

Sekarang, mari kita gunakan kotak kita:

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

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

# Mengganti item di 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.

Kuasa Generik

Generik 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 – generik dapat membantu Anda membuat komponen yang dapat digunakan kembali dan bekerja dengan jenis data yang berbeda, menyaving 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 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 Generik Python. Kita telah menutupi fungsi generik, kelas generik, dan bahkan membuat sistem penyimpanan fleksibel. Ingat, seperti semua alat kuat, generik memerlukan latihan untuk dikuasai. Jangan frustasi jika itu belum beresonasi segera – terus mencoba dan Anda akan segera melihat keajaiban generik di kode Anda sendiri.

Sebagai penutup, ini adalah tabel yang menggabungkan metode kunci yang kita pelajari:

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 di koleksi

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

Credits: Image by storyset