Khi tập lệnh phát triển, cuối cùng bạn sẽ chuyển cùng một nhóm biến giữa các hàm và thật khó để biết dữ liệu nào thuộc về logic nào. Các lớp và đối tượng Python giải quyết vấn đề này bằng cách gộp dữ liệu và hành vi vào một đơn vị.

Trong hướng dẫn này, chúng ta xây dựng một tài khoản ngân hàng nhỏ từng bước một và chỉ thêm từng ý tưởng OOP khi nó giải quyết được một vấn đề. Chúng tôi đã chạy mọi ví dụ trên Python 3.13 và kết quả hiển thị là từ lần chạy đó. Nếu bạn mới làm quen với ngôn ngữ này, trước tiên hãy đọc Hướng dẫn Python dành cho người mới bắt đầu của chúng tôi.

Lớp và đối tượng là gì?

class mô tả một thứ là gì và nó có thể làm gì. Một đối tượng, còn được gọi là một phiên bản, là một đối tượng cụ thể được tạo từ mô tả đó. “Tài khoản” là một lớp, trong khi tài khoản của Asha và tài khoản của Ben là hai đối tượng.

Bạn đã và đang sử dụng các đồ vật. Trong Python, chuỗi, danh sách và thậm chí cả hàm đều là đối tượng, đó là lý do tại sao bạn có thể viết "hello".upper().

Lớp học đầu tiên của bạn

class Account:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self.balance = balance

    def deposit(self, amount):
        if amount <= 0:
            raise ValueError("amount must be positive")
        self.balance += amount
        return self.balance

a = Account("Asha", 100)
b = Account("Ben")

a.deposit(50)
print(a.balance, b.balance)

# 150 0

__init__ tự động chạy bất cứ khi nào bạn tạo một đối tượng và nó đặt trạng thái bắt đầu. Việc gửi vào a không chạm vào b, vì mỗi đối tượng đều có dữ liệu riêng. Lưu ý rằng phương pháp này cũng bảo vệ số dư khỏi giá trị xấu. Hướng dẫn của chúng tôi về Xử lý ngoại lệ Python giải thích raise chi tiết hơn.

Bản thân là gì?

self chỉ đơn giản là đối tượng mà một phương thức đang hoạt động. Khi bạn viết a.deposit(50), Python gọi Account.deposit(a, 50) một cách hiệu quả, chuyển đối tượng vào làm đối số đầu tiên. Đó là cách định nghĩa một phương thức có thể phục vụ mọi đối tượng.

Tên self là một quy ước mạnh mẽ hơn là một từ khóa, nhưng hãy luôn sử dụng nó. Việc quên nó trong định nghĩa phương thức là lỗi phổ biến nhất dành cho người mới bắt đầu và nó tạo ra một thông báo khó hiểu về số lượng đối số.

Thuộc tính lớp so với thuộc tính thể hiện

Một thuộc tính được đặt trực tiếp trong nội dung lớp được chia sẻ bởi tất cả các đối tượng. Một tập hợp trên self chỉ thuộc về đối tượng đó. Ví dụ này cho thấy cách tra cứu hoạt động:

class Account:
    interest_rate = 0.04    # class attribute

    def __init__(self, owner, balance=0):
        self.owner = owner  # instance attribute
        self.balance = balance

a = Account("Asha", 100)
b = Account("Ben")
print(a.interest_rate, b.interest_rate)   # 0.04 0.04

Account.interest_rate = 0.05
print(a.interest_rate, b.interest_rate)   # 0.05 0.05

a.interest_rate = 0.09
print(a.interest_rate, b.interest_rate, Account.interest_rate)
# 0.09 0.05 0.05

Dòng cuối cùng đó làm mọi người ngạc nhiên. Việc chỉ định thông qua a không thay đổi giá trị được chia sẻ. Nó tạo ra một thuộc tính thể hiện mới trên a để ẩn lớp một. Python nhìn vào đối tượng trước, sau đó là lớp.

Các phương pháp đặc biệt (dunder)

Các phương thức có dấu gạch dưới kép cho phép đối tượng của bạn hoạt động với các tính năng tích hợp sẵn của Python. Không có chúng, việc in tài khoản sẽ hiển thị một địa chỉ bộ nhớ vô dụng. Việc thêm hai sẽ cho nó một dạng có thể đọc được:

    def __str__(self):
        return f"{self.owner}: {self.balance}"

    def __repr__(self):
        return f"Account({self.owner!r}, {self.balance})"

print(a)        # Asha: 150
print([a, b])   # [Account('Asha', 150), Account('Ben', 0)]

Kế thừa

Tính kế thừa cho phép một lớp mới sử dụng lại lớp hiện có và chỉ thay đổi những gì khác biệt. Ở đây, Savings là Account có cài đặt bổ sung:

class Savings(Account):
    def __init__(self, owner, balance=0, limit=3):
        super().__init__(owner, balance)
        self.limit = limit

    def __str__(self):
        return f"{super().__str__()} (savings)"

s = Savings("Chitra", 500)
s.deposit(100)
print(s, isinstance(s, Account), s.limit)

# Chitra: 600 (savings) True 3

super() gọi phiên bản gốc nên logic thiết lập không bị lặp lại. deposit vẫn được kế thừa và __str__ được ghi đè để thêm nhãn. Chỉ sử dụng tính kế thừa cho mối quan hệ “là” thực sự. Nếu một lớp chỉ cần một thứ gì đó, chẳng hạn như một chiếc ô tô cần động cơ, hãy cung cấp cho nó đối tượng đó làm thuộc tính. Điều này được gọi là sự kết hợp và nó thường linh hoạt hơn các chuỗi kế thừa sâu.

Đa hình

Tính đa hình có nghĩa là các đối tượng khác nhau có thể đáp ứng cùng một lệnh gọi phương thức theo cách riêng của chúng. Mã gọi không cần biết chính xác loại:

class Square:
    def __init__(self, side):
        self.side = side
    def area(self):
        return self.side ** 2

class Circle:
    def __init__(self, radius):
        self.radius = radius
    def area(self):
        return round(3.14159 * self.radius ** 2, 2)

for shape in [Square(3), Circle(2)]:
    print(type(shape).__name__, shape.area())

# Square 9
# Circle 12.57

Hai lớp này thậm chí không có chung cha mẹ. Python chỉ quan tâm đến việc đối tượng có một phương thức area, một cách tiếp cận được gọi là gõ vịt. Việc thêm Triangle sau sẽ không cần thay đổi vòng lặp.

Đóng gói và thuộc tính

Python không có thuộc tính thực sự riêng tư và thay vào đó nó dựa vào các quy ước. Một dấu gạch dưới duy nhất, như trong_price, nói với các nhà phát triển khác “đây là nội bộ, vui lòng không chạm vào”. Để kiểm tra các giá trị khi chúng được đặt, hãy sử dụngtài sản, trông giống như một thuộc tính đơn giản từ bên ngoài:

class Product:
    def __init__(self, price):
        self.price = price

    @property
    def price(self):
        return self._price

    @price.setter
    def price(self, value):
        if value < 0:
            raise ValueError("price cannot be negative")
        self._price = value

p = Product(100)
p.price = 150
print(p.price)      # 150
p.price = -5        # ValueError: price cannot be negative

Điều này có nghĩa là bạn có thể bắt đầu với một thuộc tính đơn giản và thêm xác thực sau mà không cần thay đổi bất kỳ mã nào sử dụng lớp đó. Vì vậy, đừng viết các phương thức get_price() và set_price() theo thói quen, như bạn có thể làm trong Java. Cú pháp @ ở đây là một trình trang trí, được chúng tôi giải thích trong Các trình trang trí Python được giải thích.

Phương thức lớp và phương thức tĩnh

class Temperature:
    def __init__(self, celsius):
        self.celsius = celsius

    @classmethod
    def from_fahrenheit(cls, f):
        return cls(round((f - 32) * 5 / 9, 1))

    @staticmethod
    def is_freezing(celsius):
        return celsius <= 0

Temperature.from_fahrenheit(212).celsius   # 100.0
Temperature.is_freezing(-3)                # True

Lớp dữ liệu

Khi một lớp chủ yếu chứa dữ liệu, việc viết __init__, __repr__ và __eq__ bằng tay rất tẻ nhạt. @dataclass tạo chúng từ các chú thích kiểu:

from dataclasses import dataclass, field

@dataclass
class Item:
    name: str
    price: int
    tags: list = field(default_factory=list)

print(Item("Pen", 10))
print(Item("Pen", 10) == Item("Pen", 10))

# Item(name='Pen', price=10, tags=[])
# True

Những lỗi thường gặp

Sử dụng thuộc tính lớp có thể thay đổi

Đây là một lỗi cổ điển. Danh sách được xác định trên lớp, vì vậy tất cả các xe đều chia sẻ nó:

class Cart:
    items = []            # shared by every cart!

    def add(self, item):
        self.items.append(item)

c1, c2 = Cart(), Cart()
c1.add("pen")
print(c2.items)

# ['pen']

Tạo nó trong __init__ với self.items = [], để mọi đối tượng đều có danh sách riêng.

Các lỗi phổ biến khác

• Quên self. Viết self.balance, không phải balance, bên trong các phương thức.
• Quên super().__init__(). Sau đó, đứa trẻ sẽ bỏ lỡ các thuộc tính do cha mẹ thiết lập.
• Xây dựng các lớp học lớn. Một lớp làm được mọi thứ rất khó để kiểm tra. Hãy chia nó ra theo trách nhiệm.
• Kế thừa sâu sắc. Hai cấp độ thường nhiều và bố cục thường rõ ràng hơn.
• Không viết bài kiểm tra. Các lớp có quy tắc rất dễ kiểm tra, như hướng dẫn pytest của chúng tôi hiển thị bằng cách sử dụng một chiếc xe đẩy nhỏ.

Lời kết

Python hướng đối tượng tập trung vào việc nhóm dữ liệu với hành vi bảo vệ dữ liệu đó. Bắt đầu với __init__, các phương thức và __str__, sau đó thêm tính kế thừa và thuộc tính khi bạn gặp vấn đề mà chúng giải quyết được. Bước tiếp theo, hãy lấy một tập lệnh chuyển một số biến giống nhau ở mọi nơi và biến chúng thành một lớp nhỏ.

Câu hỏi thường gặp

Tiếp tục học hỏi