Con trăn setter là gì?

Phương thức Getter và Setter là gì?

Các phương thức getter và setter khá phổ biến trong nhiều ngôn ngữ lập trình hướng đối tượng. Vì vậy, rất có thể bạn đã nghe về chúng rồi. Như một định nghĩa sơ bộ, bạn có thể nói rằng getters và setters là

• người bắt. Một phương thức cho phép bạn truy cập một thuộc tính trong một lớp nhất định
• người định cư. Một phương thức cho phép bạn thiết lập hoặc thay đổi giá trị của một thuộc tính trong một lớp

Trong OOP, mẫu getter và setter gợi ý rằng các thuộc tính public chỉ nên được sử dụng khi bạn chắc chắn rằng không ai cần đính kèm hành vi với chúng. Nếu một thuộc tính có khả năng thay đổi cách triển khai bên trong của nó, thì bạn nên sử dụng các phương thức getter và setter

Việc triển khai mẫu getter và setter yêu cầu

1. Làm cho các thuộc tính của bạn không công khai
2. Viết các phương thức getter và setter cho từng thuộc tính

Ví dụ: giả sử bạn cần viết một lớp

# label.py

class Label:
    def __init__(self, text, font):
        self.set_text(text)
        self.font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value.upper()  # Attached behavior

# label.py

class Label:
    def __init__(self, text, font):
        self._text = text
        self._font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value

    def get_font(self):
        return self._font

    def set_font(self, value):
        self._font = value

Trong ví dụ này, hàm tạo của

# label.py

class Label:
    def __init__(self, text, font):
        self.set_text(text)
        self.font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value.upper()  # Attached behavior

# label.py

class Label:
    def __init__(self, text, font):
        self.set_text(text)
        self.font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value.upper()  # Attached behavior

# label.py

class Label:
    def __init__(self, text, font):
        self.set_text(text)
        self.font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value.upper()  # Attached behavior

# label.py

class Label:
    def __init__(self, text, font):
        self.set_text(text)
        self.font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value.upper()  # Attached behavior

# label.py

class Label:
    def __init__(self, text, font):
        self.set_text(text)
        self.font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value.upper()  # Attached behavior

Sau đó, bạn xác định các phương thức getter và setter cho cả hai thuộc tính. Thông thường, các phương thức getter trả về giá trị của thuộc tính đích, trong khi các phương thức setter lấy một giá trị mới và gán nó cho thuộc tính bên dưới

Ghi chú. Python không có khái niệm về các công cụ sửa đổi truy cập, chẳng hạn như

# label.py

class Label:
    def __init__(self, text, font):
        self.set_text(text)
        self.font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value.upper()  # Attached behavior

# label.py

class Label:
    def __init__(self, text, font):
        self.set_text(text)
        self.font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value.upper()  # Attached behavior

# label.py

class Label:
    def __init__(self, text, font):
        self.set_text(text)
        self.font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value.upper()  # Attached behavior

Nếu bạn muốn báo hiệu rằng một thuộc tính hoặc phương thức nhất định là không công khai, thì bạn nên sử dụng quy ước Python đã được thiết lập tốt về việc thêm tiền tố vào tên bằng dấu gạch dưới (

# label.py

class Label:
    def __init__(self, text, font):
        self.set_text(text)
        self.font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value.upper()  # Attached behavior

Lưu ý rằng đây chỉ là một quy ước. Nó không ngăn bạn và các lập trình viên khác truy cập các thuộc tính bằng cách sử dụng ký hiệu dấu chấm, như trong

# label.py

class Label:
    def __init__(self, text, font):
        self._text = text
        self._font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value

    def get_font(self):
        return self._font

    def set_font(self, value):
        self._font = value

Bạn có thể sử dụng lớp

# label.py

class Label:
    def __init__(self, text, font):
        self.set_text(text)
        self.font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value.upper()  # Attached behavior

>>>

# label.py

class Label:
    def __init__(self, text, font):
        self._text = text
        self._font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value

    def get_font(self):
        return self._font

    def set_font(self, value):
        self._font = value

# label.py

class Label:
    def __init__(self, text, font):
        self.set_text(text)
        self.font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value.upper()  # Attached behavior

Các phương thức Getter và Setter đến từ đâu?

Để hiểu các phương thức getter và setter đến từ đâu, hãy quay lại ví dụ

# label.py

class Label:
    def __init__(self, text, font):
        self.set_text(text)
        self.font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value.upper()  # Attached behavior

# label.py

class Label:
    def __init__(self, text, font):
        self._text = text
        self._font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value

    def get_font(self):
        return self._font

    def set_font(self, value):
        self._font = value

Vậy, bạn có thể làm gì? . Tuy nhiên, các ngôn ngữ lập trình như Java và C++ không hỗ trợ cấu trúc giống như thuộc tính hoặc thuộc tính của chúng không hoàn toàn giống thuộc tính của Python

Đó là lý do tại sao những ngôn ngữ này khuyến khích bạn không bao giờ để lộ các thuộc tính của mình như một phần của API công khai. Thay vào đó, bạn phải cung cấp các phương thức getter và setter, cung cấp một cách nhanh chóng để thay đổi cách triển khai nội bộ các thuộc tính của bạn mà không thay đổi API công khai của bạn

Đóng gói là một chủ đề cơ bản khác liên quan đến nguồn gốc của các phương thức getter và setter. Về cơ bản, nguyên tắc này đề cập đến việc kết hợp dữ liệu với các phương thức hoạt động trên dữ liệu đó. Bằng cách này, các hoạt động truy cập và đột biến sẽ được thực hiện thông qua các phương thức dành riêng

Nguyên tắc này cũng liên quan đến việc hạn chế quyền truy cập trực tiếp vào các thuộc tính của đối tượng, điều này sẽ ngăn việc tiết lộ chi tiết triển khai hoặc vi phạm tính bất biến của trạng thái

Để cung cấp cho

# label.py

class Label:
    def __init__(self, text, font):
        self.set_text(text)
        self.font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value.upper()  # Attached behavior

Xem xét phiên bản sau của

# label.py

class Label:
    def __init__(self, text, font):
        self.set_text(text)
        self.font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value.upper()  # Attached behavior

# label.py

class Label:
    def __init__(self, text, font):
        self.set_text(text)
        self.font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value.upper()  # Attached behavior

Trong phiên bản cập nhật này của

# label.py

class Label:
    def __init__(self, text, font):
        self.set_text(text)
        self.font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value.upper()  # Attached behavior

# label.py

class Label:
    def __init__(self, text, font):
        self.set_text(text)
        self.font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value.upper()  # Attached behavior

Bây giờ bạn có thể sử dụng lớp

# label.py

class Label:
    def __init__(self, text, font):
        self.set_text(text)
        self.font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value.upper()  # Attached behavior

>>>

# label.py

class Label:
    def __init__(self, text, font):
        self._text = text
        self._font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value

    def get_font(self):
        return self._font

    def set_font(self, value):
        self._font = value

Mát mẻ. Bạn đã thêm thành công hành vi bắt buộc vào thuộc tính văn bản của nhãn. Bây giờ phương thức setter của bạn có một mục tiêu thực sự thay vì chỉ gán một giá trị mới cho thuộc tính đích. Nó có mục tiêu thêm hành vi bổ sung vào thuộc tính

# label.py

class Label:
    def __init__(self, text, font):
        self.set_text(text)
        self.font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value.upper()  # Attached behavior

Mặc dù mẫu getter và setter khá phổ biến trong các ngôn ngữ lập trình khác, nhưng đó không phải là trường hợp trong Python

Việc thêm các phương thức getter và setter vào các lớp của bạn có thể làm tăng đáng kể số dòng trong mã của bạn. Getters và setters cũng tuân theo một mô hình lặp đi lặp lại và nhàm chán sẽ cần thêm thời gian để hoàn thành. Mẫu này có thể dễ bị lỗi và tẻ nhạt. Bạn cũng sẽ thấy rằng chức năng ngay lập tức thu được từ tất cả mã bổ sung này thường bằng không

Tất cả điều này nghe có vẻ giống như điều mà các nhà phát triển Python không muốn thực hiện trong mã của họ. Trong Python, có thể bạn sẽ viết lớp

# label.py

class Label:
    def __init__(self, text, font):
        self.set_text(text)
        self.font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value.upper()  # Attached behavior

>>>

# label.py

class Label:
    def __init__(self, text, font):
        self.set_text(text)
        self.font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value.upper()  # Attached behavior

Ở đây,

# label.py

class Label:
    def __init__(self, text, font):
        self.set_text(text)
        self.font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value.upper()  # Attached behavior

# label.py

class Label:
    def __init__(self, text, font):
        self.set_text(text)
        self.font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value.upper()  # Attached behavior

>>>

# label.py

class Label:
    def __init__(self, text, font):
        self.set_text(text)
        self.font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value.upper()  # Attached behavior

Việc hiển thị các thuộc tính như

# label.py

class Label:
    def __init__(self, text, font):
        self._text = text
        self._font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value

    def get_font(self):
        return self._font

    def set_font(self, value):
        self._font = value

# label.py

class Label:
    def __init__(self, text, font):
        self.set_text(text)
        self.font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value.upper()  # Attached behavior

Công khai các thuộc tính của bạn, như trong ví dụ trên, là một cách phổ biến trong Python. Trong những trường hợp này, việc chuyển sang getters và setters sẽ đưa ra những thay đổi đột phá. Vì vậy, làm thế nào để bạn đối phó với các tình huống yêu cầu thêm hành vi vào thuộc tính của bạn?

Mô tả của Python

Bộ mô tả là một tính năng Python nâng cao cho phép bạn tạo các thuộc tính với các hành vi được đính kèm trong các lớp của bạn. Để tạo bộ mô tả, bạn cần sử dụng giao thức bộ mô tả, đặc biệt là các phương thức đặc biệt

# label.py

class Label:
    def __init__(self, text, font):
        self.set_text(text)
        self.font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value.upper()  # Attached behavior

# label.py

class Label:
    def __init__(self, text, font):
        self.set_text(text)
        self.font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value.upper()  # Attached behavior

Mô tả khá giống với thuộc tính. Trên thực tế, thuộc tính là một kiểu mô tả đặc biệt. Tuy nhiên, các mô tả thông thường mạnh hơn các thuộc tính và có thể được sử dụng lại thông qua các lớp khác nhau

Để minh họa cách sử dụng bộ mô tả để tạo các thuộc tính có hành vi chức năng, hãy nói rằng bạn cần tiếp tục phát triển lớp

# label.py

class Label:
    def __init__(self, text, font):
        self.set_text(text)
        self.font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value.upper()  # Attached behavior

# label.py

class Label:
    def __init__(self, text, font):
        self._text = text
        self._font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value

    def get_font(self):
        return self._font

    def set_font(self, value):
        self._font = value

Trong bản cập nhật này, bạn đã thêm một thuộc tính khác vào

# label.py

class Label:
    def __init__(self, text, font):
        self.set_text(text)
        self.font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value.upper()  # Attached behavior

# label.py

class Label:
    def __init__(self, text, font):
        self.set_text(text)
        self.font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value.upper()  # Attached behavior

Lớp học này hoạt động như mong đợi. Tuy nhiên, nó bắt đầu lặp đi lặp lại và nhàm chán. Vì vậy, bạn quyết định cấu trúc lại lớp. Bạn nhận thấy rằng bạn đang thực hiện cùng một thao tác trong cả hai thuộc tính liên quan đến ngày tháng và bạn nghĩ đến việc sử dụng một bộ mô tả để đóng gói chức năng lặp đi lặp lại

# label.py

class Label:
    def __init__(self, text, font):
        self._text = text
        self._font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value

    def get_font(self):
        return self._font

    def set_font(self, value):
        self._font = value

Mã này sạch hơn và ít lặp lại hơn phiên bản trước. Trong bản cập nhật này, bạn tạo một bộ mô tả

# label.py

class Label:
    def __init__(self, text, font):
        self.set_text(text)
        self.font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value.upper()  # Attached behavior

# label.py

class Label:
    def __init__(self, text, font):
        self.set_text(text)
        self.font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value.upper()  # Attached behavior

# label.py

class Label:
    def __init__(self, text, font):
        self.set_text(text)
        self.font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value.upper()  # Attached behavior

# label.py

class Label:
    def __init__(self, text, font):
        self.set_text(text)
        self.font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value.upper()  # Attached behavior

Hai triển khai của

# label.py

class Label:
    def __init__(self, text, font):
        self.set_text(text)
        self.font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value.upper()  # Attached behavior

Nói chung, nếu bạn thấy mình làm lộn xộn các lớp của mình với các định nghĩa thuộc tính tương tự, thì bạn nên cân nhắc sử dụng một bộ mô tả để thay thế

Phương thức # label.py class Label: def __init__(self, text, font): self.set_text(text) self.font = font def get_text(self): return self._text def set_text(self, value): self._text = value.upper() # Attached behavior 63 và # label.py class Label: def __init__(self, text, font): self.set_text(text) self.font = font def get_text(self): return self._text def set_text(self, value): self._text = value.upper() # Attached behavior 64

Một cách khác để thay thế các phương thức getter và setter truyền thống trong Python là sử dụng các phương thức đặc biệt

# label.py

class Label:
    def __init__(self, text, font):
        self.set_text(text)
        self.font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value.upper()  # Attached behavior

# label.py

class Label:
    def __init__(self, text, font):
        self.set_text(text)
        self.font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value.upper()  # Attached behavior

# label.py

class Label:
    def __init__(self, text, font):
        self.set_text(text)
        self.font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value.upper()  # Attached behavior

# label.py

class Label:
    def __init__(self, text, font):
        self._text = text
        self._font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value

    def get_font(self):
        return self._font

    def set_font(self, value):
        self._font = value

Trình khởi tạo của

# label.py

class Label:
    def __init__(self, text, font):
        self.set_text(text)
        self.font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value.upper()  # Attached behavior

# label.py

class Label:
    def __init__(self, text, font):
        self.set_text(text)
        self.font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value.upper()  # Attached behavior

# label.py

class Label:
    def __init__(self, text, font):
        self.set_text(text)
        self.font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value.upper()  # Attached behavior

# label.py

class Label:
    def __init__(self, text, font):
        self.set_text(text)
        self.font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value.upper()  # Attached behavior

# label.py

class Label:
    def __init__(self, text, font):
        self.set_text(text)
        self.font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value.upper()  # Attached behavior

# label.py

class Label:
    def __init__(self, text, font):
        self.set_text(text)
        self.font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value.upper()  # Attached behavior

# label.py

class Label:
    def __init__(self, text, font):
        self.set_text(text)
        self.font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value.upper()  # Attached behavior

# label.py

class Label:
    def __init__(self, text, font):
        self.set_text(text)
        self.font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value.upper()  # Attached behavior

# label.py

class Label:
    def __init__(self, text, font):
        self.set_text(text)
        self.font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value.upper()  # Attached behavior

Phương thức

# label.py

class Label:
    def __init__(self, text, font):
        self.set_text(text)
        self.font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value.upper()  # Attached behavior

# label.py

class Label:
    def __init__(self, text, font):
        self.set_text(text)
        self.font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value.upper()  # Attached behavior

# label.py

class Label:
    def __init__(self, text, font):
        self.set_text(text)
        self.font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value.upper()  # Attached behavior

# label.py

class Label:
    def __init__(self, text, font):
        self.set_text(text)
        self.font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value.upper()  # Attached behavior

Đây là cách lớp này hoạt động trong thực tế

>>>

# label.py

class Label:
    def __init__(self, text, font):
        self._text = text
        self._font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value

    def get_font(self):
        return self._font

    def set_font(self, value):
        self._font = value

Lớp

# label.py

class Label:
    def __init__(self, text, font):
        self.set_text(text)
        self.font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value.upper()  # Attached behavior

# label.py

class Label:
    def __init__(self, text, font):
        self.set_text(text)
        self.font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value.upper()  # Attached behavior

# label.py

class Label:
    def __init__(self, text, font):
        self.set_text(text)
        self.font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value.upper()  # Attached behavior

# label.py

class Label:
    def __init__(self, text, font):
        self.set_text(text)
        self.font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value.upper()  # Attached behavior

# label.py

class Label:
    def __init__(self, text, font):
        self.set_text(text)
        self.font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value.upper()  # Attached behavior

Lưu ý rằng

# label.py

class Label:
    def __init__(self, text, font):
        self.set_text(text)
        self.font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value.upper()  # Attached behavior

# label.py

class Label:
    def __init__(self, text, font):
        self.set_text(text)
        self.font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value.upper()  # Attached behavior

Ví dụ trong phần này hơi kỳ lạ và có thể bạn sẽ không sử dụng thứ gì đó tương tự trong mã của mình. Tuy nhiên, các công cụ mà bạn đã sử dụng trong ví dụ này cho phép bạn thực hiện xác thực hoặc chuyển đổi khi truy cập và thay đổi thuộc tính, giống như các phương thức getter và setter thực hiện

Theo một nghĩa nào đó,

# label.py

class Label:
    def __init__(self, text, font):
        self.set_text(text)
        self.font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value.upper()  # Attached behavior

# label.py

class Label:
    def __init__(self, text, font):
        self.set_text(text)
        self.font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value.upper()  # Attached behavior

Tránh các phương thức chậm đằng sau các thuộc tính

Bạn nên tránh ẩn các hoạt động chậm đằng sau thuộc tính Python. Người dùng API của bạn sẽ mong đợi quyền truy cập và biến đổi thuộc tính hoạt động như quyền truy cập và biến đổi thông thường. Nói cách khác, người dùng sẽ mong đợi các hoạt động này diễn ra ngay lập tức và không có tác dụng phụ

Đi quá xa so với kỳ vọng đó sẽ khiến API của bạn trở nên kỳ quặc và khó sử dụng, vi phạm nguyên tắc ít bất ngờ nhất

Ngoài ra, nếu người dùng của bạn liên tục truy cập và thay đổi các thuộc tính của bạn trong một vòng lặp, thì mã của họ có thể liên quan đến quá nhiều chi phí, điều này có thể tạo ra các vấn đề lớn và không mong muốn về hiệu suất

Ngược lại, các phương thức getter và setter truyền thống làm rõ rằng việc truy cập hoặc thay đổi một thuộc tính nhất định xảy ra thông qua một lệnh gọi phương thức. Thật vậy, người dùng của bạn sẽ biết rằng việc gọi một phương thức có thể mất thời gian và hiệu suất mã của họ có thể thay đổi đáng kể vì điều đó

Việc làm rõ ràng các dữ kiện đó trong API của bạn có thể giúp giảm thiểu sự ngạc nhiên của người dùng khi họ truy cập và thay đổi các thuộc tính của bạn trong mã của họ

Nói tóm lại, nếu bạn định sử dụng thuộc tính để quản lý thuộc tính, thì hãy đảm bảo rằng các phương thức đằng sau thuộc tính đó nhanh và không gây tác dụng phụ. Ngược lại, nếu bạn đang xử lý các phương thức của bộ truy cập và bộ biến đổi chậm, thì hãy ưu tiên các phương thức getter và setters truyền thống hơn các thuộc tính

Lấy thêm đối số và cờ

Không giống như các thuộc tính Python, các phương thức getter và setter truyền thống cho phép truy cập và thay đổi thuộc tính linh hoạt hơn. Ví dụ: giả sử bạn có lớp

# label.py

class Label:
    def __init__(self, text, font):
        self._text = text
        self._font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value

    def get_font(self):
        return self._font

    def set_font(self, value):
        self._font = value

# label.py

class Label:
    def __init__(self, text, font):
        self.set_text(text)
        self.font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value.upper()  # Attached behavior

Tuy nhiên, do lỗi của con người tồn tại, bạn sẽ gặp phải trường hợp ai đó mắc lỗi khi nhập ngày sinh của một người nhất định. Bạn có thể giải quyết vấn đề này bằng cách cung cấp phương thức setter nhận cờ

# label.py

class Label:
    def __init__(self, text, font):
        self._text = text
        self._font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value

    def get_font(self):
        return self._font

    def set_font(self, value):
        self._font = value

# label.py

class Label:
    def __init__(self, text, font):
        self._text = text
        self._font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value

    def get_font(self):
        return self._font

    def set_font(self, value):
        self._font = value

Bạn cung cấp các phương thức getter và setter truyền thống cho thuộc tính

# label.py

class Label:
    def __init__(self, text, font):
        self.set_text(text)
        self.font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value.upper()  # Attached behavior

# label.py

class Label:
    def __init__(self, text, font):
        self._text = text
        self._font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value

    def get_font(self):
        return self._font

    def set_font(self, value):
        self._font = value

Ghi chú. Các phương thức setter truyền thống thường không nhận nhiều hơn một đối số. Ví dụ trên có thể trông kỳ lạ hoặc thậm chí không chính xác đối với một số nhà phát triển. Tuy nhiên, ý định của nó là giới thiệu một kỹ thuật có thể hữu ích trong một số tình huống.

Đây là cách lớp này hoạt động

>>>

# label.py

class Label:
    def __init__(self, text, font):
        self._text = text
        self._font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value

    def get_font(self):
        return self._font

    def set_font(self, value):
        self._font = value

Khi bạn cố gắng sửa đổi ngày sinh của Jane bằng cách sử dụng

# label.py

class Label:
    def __init__(self, text, font):
        self._text = text
        self._font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value

    def get_font(self):
        return self._font

    def set_font(self, value):
        self._font = value

# label.py

class Label:
    def __init__(self, text, font):
        self._text = text
        self._font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value

    def get_font(self):
        return self._font

    def set_font(self, value):
        self._font = value

# label.py

class Label:
    def __init__(self, text, font):
        self._text = text
        self._font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value

    def get_font(self):
        return self._font

    def set_font(self, value):
        self._font = value

# label.py

class Label:
    def __init__(self, text, font):
        self._text = text
        self._font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value

    def get_font(self):
        return self._font

    def set_font(self, value):
        self._font = value

# label.py

class Label:
    def __init__(self, text, font):
        self._text = text
        self._font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value

    def get_font(self):
        return self._font

    def set_font(self, value):
        self._font = value

# label.py

class Label:
    def __init__(self, text, font):
        self._text = text
        self._font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value

    def get_font(self):
        return self._font

    def set_font(self, value):
        self._font = value

Điều quan trọng cần lưu ý là các thuộc tính Python không chấp nhận các đối số bổ sung trong các phương thức setter của chúng. Họ chỉ chấp nhận giá trị được đặt hoặc cập nhật

Sử dụng thừa kế. Getter và Setters so với Thuộc tính

Một vấn đề với các thuộc tính Python là chúng không hoạt động tốt trong các tình huống kế thừa. Ví dụ: giả sử bạn cần mở rộng hoặc sửa đổi phương thức getter của thuộc tính trong lớp con. Trong thực tế, không có cách nào an toàn để làm điều này. Bạn không thể chỉ ghi đè phương thức getter và mong đợi phần còn lại của chức năng thuộc tính vẫn giữ nguyên như trong lớp cha

Sự cố này xảy ra do các phương thức getter và setter bị ẩn bên trong thuộc tính. Chúng không được kế thừa một cách độc lập mà là một tổng thể. Do đó, khi bạn ghi đè phương thức getter của một thuộc tính được kế thừa từ lớp cha, bạn sẽ ghi đè toàn bộ thuộc tính, bao gồm phương thức setter và phần còn lại của các thành phần bên trong của nó

Ví dụ, hãy xem xét hệ thống phân cấp lớp sau

# label.py

class Label:
    def __init__(self, text, font):
        self._text = text
        self._font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value

    def get_font(self):
        return self._font

    def set_font(self, value):
        self._font = value

Trong ví dụ này, bạn ghi đè phương thức getter của thuộc tính

# label.py

class Label:
    def __init__(self, text, font):
        self.set_text(text)
        self.font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value.upper()  # Attached behavior

# label.py

class Label:
    def __init__(self, text, font):
        self.set_text(text)
        self.font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value.upper()  # Attached behavior

# label.py

class Label:
    def __init__(self, text, font):
        self.set_text(text)
        self.font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value.upper()  # Attached behavior

>>>

# label.py

class Label:
    def __init__(self, text, font):
        self._text = text
        self._font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value

    def get_font(self):
        return self._font

    def set_font(self, value):
        self._font = value

Bây giờ

# label.py

class Label:
    def __init__(self, text, font):
        self.set_text(text)
        self.font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value.upper()  # Attached behavior

Nếu bạn sử dụng các phương thức getter và setter truyền thống thì sự cố sẽ không xảy ra

# label.py

class Label:
    def __init__(self, text, font):
        self._text = text
        self._font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value

    def get_font(self):
        return self._font

    def set_font(self, value):
        self._font = value

Phiên bản này của

# label.py

class Label:
    def __init__(self, text, font):
        self._text = text
        self._font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value

    def get_font(self):
        return self._font

    def set_font(self, value):
        self._font = value

# label.py

class Label:
    def __init__(self, text, font):
        self.set_text(text)
        self.font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value.upper()  # Attached behavior

# label.py

class Label:
    def __init__(self, text, font):
        self._text = text
        self._font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value

    def get_font(self):
        return self._font

    def set_font(self, value):
        self._font = value

# label.py

class Label:
    def __init__(self, text, font):
        self.set_text(text)
        self.font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value.upper()  # Attached behavior

# label.py

class Label:
    def __init__(self, text, font):
        self._text = text
        self._font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value

    def get_font(self):
        return self._font

    def set_font(self, value):
        self._font = value

Đây là cách phiên bản mới này của

# label.py

class Label:
    def __init__(self, text, font):
        self.set_text(text)
        self.font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value.upper()  # Attached behavior

>>>

# label.py

class Label:
    def __init__(self, text, font):
        self._text = text
        self._font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value

    def get_font(self):
        return self._font

    def set_font(self, value):
        self._font = value

Bây giờ

# label.py

class Label:
    def __init__(self, text, font):
        self.set_text(text)
        self.font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value.upper()  # Attached behavior

# label.py

class Label:
    def __init__(self, text, font):
        self._text = text
        self._font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value

    def get_font(self):
        return self._font

    def set_font(self, value):
        self._font = value

Tăng ngoại lệ khi truy cập thuộc tính hoặc đột biến

Hầu hết thời gian, bạn sẽ không mong đợi một câu lệnh gán như

# label.py

class Label:
    def __init__(self, text, font):
        self._text = text
        self._font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value

    def get_font(self):
        return self._font

    def set_font(self, value):
        self._font = value

Ví dụ:

# label.py

class Label:
    def __init__(self, text, font):
        self._text = text
        self._font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value

    def get_font(self):
        return self._font

    def set_font(self, value):
        self._font = value

# label.py

class Label:
    def __init__(self, text, font):
        self._text = text
        self._font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value

    def get_font(self):
        return self._font

    def set_font(self, value):
        self._font = value

# label.py

class Label:
    def __init__(self, text, font):
        self._text = text
        self._font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value

    def get_font(self):
        return self._font

    def set_font(self, value):
        self._font = value

Theo nguyên tắc thông thường, tránh đưa ra các ngoại lệ từ các thuộc tính Python của bạn trừ khi bạn đang sử dụng một thuộc tính để cung cấp các thuộc tính chỉ đọc. Nếu bạn cần đưa ra các ngoại lệ đối với quyền truy cập hoặc biến đổi thuộc tính, thì bạn nên cân nhắc sử dụng các phương thức getter và setter thay vì các thuộc tính

Trong những trường hợp này, việc sử dụng getters và setters sẽ làm giảm sự ngạc nhiên của người dùng và làm cho mã của bạn phù hợp hơn với các thông lệ và kỳ vọng chung

Tạo điều kiện tích hợp nhóm và di chuyển dự án

Cung cấp các phương thức getter và setter là thông lệ phổ biến trong nhiều ngôn ngữ lập trình được thiết lập tốt. Nếu bạn đang làm việc trên một dự án Python với một nhóm các nhà phát triển đến từ các nền tảng ngôn ngữ khác, thì rất có thể mẫu getter và setter sẽ trông quen thuộc hơn với họ so với các thuộc tính Python

Trong loại nhóm không đồng nhất này, việc sử dụng getters và setters có thể tạo điều kiện thuận lợi cho việc tích hợp các nhà phát triển mới vào nhóm

Sử dụng mẫu getter và setter cũng có thể thúc đẩy tính nhất quán của API. Nó cho phép bạn cung cấp một API dựa trên các lệnh gọi phương thức chứ không phải là một API kết hợp các lệnh gọi phương thức với truy cập và thay đổi thuộc tính trực tiếp

Thông thường, khi một dự án Python phát triển, bạn có thể cần chuyển dự án từ Python sang ngôn ngữ khác. Ngôn ngữ mới có thể không có các thuộc tính hoặc chúng có thể không hoạt động như các thuộc tính của Python. Trong những tình huống này, việc sử dụng getters và setters truyền thống ngay từ đầu sẽ giúp việc di chuyển trong tương lai bớt khó khăn hơn

Trong tất cả các tình huống trên, bạn nên cân nhắc sử dụng các phương thức getter và setter truyền thống thay vì các thuộc tính trong Python