Hướng dẫn入门 Python Generics

Xin chào bạn, tương lai của người thạo Python! Hôm nay, chúng ta sẽ bắt đầu một hành trình thú vị vào thế giới Python Generics. Đừng lo lắng nếu bạn mới bắt đầu học lập trình - tôi sẽ là người hướng dẫn thân thiện của bạn, giải thích mọi thứ từng bước. Nào, hãy lấy một ly đồ uống yêu thích của bạn, và cùng tôi nhảy vào!

Python - Generics

什么是 Generics?

Trước khi chúng ta bắt đầu lập trình, hãy hiểu Generics là gì. Hãy tưởng tượng bạn có một hộp ma thuật có thể chứa bất kỳ loại vật phẩm nào - đồ chơi, sách, hoặc thậm chí là bánh quy. Đó chính là điều mà Generics làm trong lập trình. Chúng cho phép chúng ta viết mã linh hoạt có thể làm việc với nhiều loại dữ liệu khác nhau.

Định nghĩa một hàm Generics

Hãy bắt đầu bằng cách tạo một hàm Generics. Trong Python, chúng ta sử dụng TypeVar từ module typing để định nghĩa các loại Generics.

from typing import TypeVar

T = TypeVar('T')

def print_item(item: T) -> None:
print(f"Vật phẩm là: {item}")

Trong ví dụ này, T là loại Generics của chúng ta. Hàm print_item bây giờ có thể chấp nhận bất kỳ loại dữ liệu nào. Hãy phân tích nó:

Chúng ta import TypeVar từ module typing.
Chúng ta tạo một biến loại T.
Hàm của chúng ta print_item nhận một đối số item có loại T.
Hàm đơn giản chỉ in ra vật phẩm.

Gọi hàm Generics với các loại dữ liệu khác nhau

Bây giờ, hãy xem hàm Generics của chúng ta trong hành động!

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

Kết quả đầu ra:

Vật phẩm là: 42
Vật phẩm là: Hello, Generics!
Vật phẩm là: [1, 2, 3]

Như bạn có thể thấy, hàm của chúng ta hoạt động với các loại dữ liệu khác nhau - số nguyên, chuỗi và thậm chí là danh sách. Nó giống như có một cây kéo đa năng trong bộ công cụ mã của bạn!

Định nghĩa một lớp Generics

Bây giờ, sau khi chúng ta đã thành thạo hàm Generics, hãy nâng cấp và tạo một lớp Generics. Hãy tưởng tượng chúng ta đang xây dựng một hệ thống lưu trữ đơn giản có thể chứa bất kỳ loại vật phẩm nào.

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

Hãy phân tích hộp ma thuật này:

Chúng ta định nghĩa lớp Box là Generic[T].
Phương thức __init__ nhận một item có loại T.
get_item trả về vật phẩm lưu trữ.
set_item cho phép chúng ta thay đổi vật phẩm.

Bây giờ, hãy sử dụng hộp của chúng ta:

# Một hộp chứa số nguyên
int_box = Box(42)
print(int_box.get_item())  # Kết quả: 42

# Một hộp chứa chuỗi
str_box = Box("Hello, Generic Class!")
print(str_box.get_item())  # Kết quả: Hello, Generic Class!

# Thay đổi vật phẩm trong hộp
int_box.set_item(100)
print(int_box.get_item())  # Kết quả: 100

Thật tuyệt vời phải không? Chúng ta có thể tạo các hộp để lưu trữ các loại vật phẩm khác nhau, và Python đảm bảo tính an toàn của loại cho chúng ta.

Sức mạnh của Generics

Generics có thể trông có vẻ trừu tượng ban đầu, nhưng chúng rất mạnh mẽ. Chúng cho phép chúng ta viết mã linh hoạt và an toàn về loại. Hãy tưởng tượng bạn đang xây dựng một ứng dụng lớn - generics có thể giúp bạn tạo ra các thành phần có thể tái sử dụng cho nhiều loại dữ liệu khác nhau, giúp bạn tiết kiệm thời gian và giảm thiểu lỗi.

Dưới đây là một ví dụ phức tạp hơn để minh họa sức mạnh này:

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("Storage is empty")

# Sử dụng lớp Storage Generics của chúng ta
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())  # Kết quả: [1, 2, 3]
print(str_storage.get_last_item())  # Kết quả: Cherry

Trong ví dụ này, chúng ta đã tạo một lớp Storage Generics có thể chứa danh sách các loại. Chúng ta sau đó tạo các kho lưu trữ riêng cho số nguyên và chuỗi, minh họa sự linh hoạt của lớp Generics của chúng ta.

Kết luận

Chúc mừng! Bạn đã刚刚迈出了进入 Python Generics 的第一步。我们已经覆盖了泛型函数、泛型类，甚至构建了一个灵活的存储系统。请记住，像任何强大的工具一样，泛型需要练习才能掌握。如果一开始没有立即掌握，请不要气馁 - 继续尝试，你很快就会在代码中看到泛型的魔力。

在我们结束之前，这里是一个我们学到的关键方法的总结表：

Phương thức	Mô tả
`TypeVar('T')`	Tạo một biến loại cho sử dụng Generics
`Generic[T]`	Định nghĩa một lớp Generics
`__init__(self, item: T)`	Khởi tạo một lớp Generics với một vật phẩm loại T
`get_item(self) -> T`	Trả về một vật phẩm loại T
`set_item(self, new_item: T) -> None`	Đặt một vật phẩm mới loại T
`add_item(self, item: T) -> None`	Thêm một vật phẩm loại T vào một bộ sưu tập
`get_items(self) -> List[T]`	Trả về một danh sách các vật phẩm loại T
`get_last_item(self) -> T`	Trả về vật phẩm cuối cùng loại T trong một bộ sưu tập

Tiếp tục mã hóa, tiếp tục học hỏi, và nhớ - với Generics, sức mạnh Python của bạn là vô tận! Chúc may mắn, các pháp sư Python tương lai!

Credits: Image by storyset