Hướng dẫn python create file descriptor - python tạo bộ mô tả tệp
Raymond Hettinger Show
Mô tả cho phép các đối tượng tùy chỉnh Tra cứu, lưu trữ và xóa thuộc tính. let objects customize attribute lookup, storage, and deletion. Hướng dẫn này có bốn phần chính:
Lót¶Trong phần mồi này, chúng tôi bắt đầu với ví dụ cơ bản nhất có thể và sau đó chúng tôi sẽ thêm các khả năng mới từng. Ví dụ đơn giản: một mô tả trả về một hằng sốLớp import logging logging.basicConfig(level=logging.INFO) class LoggedAgeAccess: def __get__(self, obj, objtype=None): value = obj._age logging.info('Accessing %r giving %r', 'age', value) return value def __set__(self, obj, value): logging.info('Updating %r to %r', 'age', value) obj._age = value class Person: age = LoggedAgeAccess() # Descriptor instance def __init__(self, name, age): self.name = name # Regular instance attribute self.age = age # Calls __set__() def birthday(self): self.age += 1 # Calls both __get__() and __set__()9 là một bộ mô tả có phương thức >>> mary = Person('Mary M', 30) # The initial age update is logged INFO:root:Updating 'age' to 30 >>> dave = Person('David D', 40) INFO:root:Updating 'age' to 40 >>> vars(mary) # The actual data is in a private attribute {'name': 'Mary M', '_age': 30} >>> vars(dave) {'name': 'David D', '_age': 40} >>> mary.age # Access the data and log the lookup INFO:root:Accessing 'age' giving 30 30 >>> mary.birthday() # Updates are logged as well INFO:root:Accessing 'age' giving 30 INFO:root:Updating 'age' to 31 >>> dave.name # Regular attribute lookup isn't logged 'David D' >>> dave.age # Only the managed attribute is logged INFO:root:Accessing 'age' giving 40 400 luôn trả về hằng số >>> mary = Person('Mary M', 30) # The initial age update is logged INFO:root:Updating 'age' to 30 >>> dave = Person('David D', 40) INFO:root:Updating 'age' to 40 >>> vars(mary) # The actual data is in a private attribute {'name': 'Mary M', '_age': 30} >>> vars(dave) {'name': 'David D', '_age': 40} >>> mary.age # Access the data and log the lookup INFO:root:Accessing 'age' giving 30 30 >>> mary.birthday() # Updates are logged as well INFO:root:Accessing 'age' giving 30 INFO:root:Updating 'age' to 31 >>> dave.name # Regular attribute lookup isn't logged 'David D' >>> dave.age # Only the managed attribute is logged INFO:root:Accessing 'age' giving 40 401: class Ten: def __get__(self, obj, objtype=None): return 10 Để sử dụng bộ mô tả, nó phải được lưu trữ dưới dạng biến lớp trong một lớp khác: class A: x = 5 # Regular class attribute y = Ten() # Descriptor instance Một phiên tương tác cho thấy sự khác biệt giữa tra cứu thuộc tính thông thường và tra cứu mô tả: >>> a = A() # Make an instance of class A >>> a.x # Normal attribute lookup 5 >>> a.y # Descriptor lookup 10 Trong Tra cứu thuộc tính >>> mary = Person('Mary M', 30) # The initial age update is logged INFO:root:Updating 'age' to 30 >>> dave = Person('David D', 40) INFO:root:Updating 'age' to 40 >>> vars(mary) # The actual data is in a private attribute {'name': 'Mary M', '_age': 30} >>> vars(dave) {'name': 'David D', '_age': 40} >>> mary.age # Access the data and log the lookup INFO:root:Accessing 'age' giving 30 30 >>> mary.birthday() # Updates are logged as well INFO:root:Accessing 'age' giving 30 INFO:root:Updating 'age' to 31 >>> dave.name # Regular attribute lookup isn't logged 'David D' >>> dave.age # Only the managed attribute is logged INFO:root:Accessing 'age' giving 40 402, toán tử DOT tìm thấy >>> mary = Person('Mary M', 30) # The initial age update is logged INFO:root:Updating 'age' to 30 >>> dave = Person('David D', 40) INFO:root:Updating 'age' to 40 >>> vars(mary) # The actual data is in a private attribute {'name': 'Mary M', '_age': 30} >>> vars(dave) {'name': 'David D', '_age': 40} >>> mary.age # Access the data and log the lookup INFO:root:Accessing 'age' giving 30 30 >>> mary.birthday() # Updates are logged as well INFO:root:Accessing 'age' giving 30 INFO:root:Updating 'age' to 31 >>> dave.name # Regular attribute lookup isn't logged 'David D' >>> dave.age # Only the managed attribute is logged INFO:root:Accessing 'age' giving 40 403 trong từ điển lớp. Trong tra cứu >>> mary = Person('Mary M', 30) # The initial age update is logged INFO:root:Updating 'age' to 30 >>> dave = Person('David D', 40) INFO:root:Updating 'age' to 40 >>> vars(mary) # The actual data is in a private attribute {'name': 'Mary M', '_age': 30} >>> vars(dave) {'name': 'David D', '_age': 40} >>> mary.age # Access the data and log the lookup INFO:root:Accessing 'age' giving 30 30 >>> mary.birthday() # Updates are logged as well INFO:root:Accessing 'age' giving 30 INFO:root:Updating 'age' to 31 >>> dave.name # Regular attribute lookup isn't logged 'David D' >>> dave.age # Only the managed attribute is logged INFO:root:Accessing 'age' giving 40 404, toán tử DOT tìm thấy một thể hiện mô tả, được nhận ra bằng phương pháp >>> mary = Person('Mary M', 30) # The initial age update is logged INFO:root:Updating 'age' to 30 >>> dave = Person('David D', 40) INFO:root:Updating 'age' to 40 >>> vars(mary) # The actual data is in a private attribute {'name': 'Mary M', '_age': 30} >>> vars(dave) {'name': 'David D', '_age': 40} >>> mary.age # Access the data and log the lookup INFO:root:Accessing 'age' giving 30 30 >>> mary.birthday() # Updates are logged as well INFO:root:Accessing 'age' giving 30 INFO:root:Updating 'age' to 31 >>> dave.name # Regular attribute lookup isn't logged 'David D' >>> dave.age # Only the managed attribute is logged INFO:root:Accessing 'age' giving 40 405 của nó. Gọi phương thức đó trả về >>> mary = Person('Mary M', 30) # The initial age update is logged INFO:root:Updating 'age' to 30 >>> dave = Person('David D', 40) INFO:root:Updating 'age' to 40 >>> vars(mary) # The actual data is in a private attribute {'name': 'Mary M', '_age': 30} >>> vars(dave) {'name': 'David D', '_age': 40} >>> mary.age # Access the data and log the lookup INFO:root:Accessing 'age' giving 30 30 >>> mary.birthday() # Updates are logged as well INFO:root:Accessing 'age' giving 30 INFO:root:Updating 'age' to 31 >>> dave.name # Regular attribute lookup isn't logged 'David D' >>> dave.age # Only the managed attribute is logged INFO:root:Accessing 'age' giving 40 401. Lưu ý rằng giá trị >>> mary = Person('Mary M', 30) # The initial age update is logged INFO:root:Updating 'age' to 30 >>> dave = Person('David D', 40) INFO:root:Updating 'age' to 40 >>> vars(mary) # The actual data is in a private attribute {'name': 'Mary M', '_age': 30} >>> vars(dave) {'name': 'David D', '_age': 40} >>> mary.age # Access the data and log the lookup INFO:root:Accessing 'age' giving 30 30 >>> mary.birthday() # Updates are logged as well INFO:root:Accessing 'age' giving 30 INFO:root:Updating 'age' to 31 >>> dave.name # Regular attribute lookup isn't logged 'David D' >>> dave.age # Only the managed attribute is logged INFO:root:Accessing 'age' giving 40 401 không được lưu trữ trong từ điển lớp hoặc từ điển thể hiện. Thay vào đó, giá trị >>> mary = Person('Mary M', 30) # The initial age update is logged INFO:root:Updating 'age' to 30 >>> dave = Person('David D', 40) INFO:root:Updating 'age' to 40 >>> vars(mary) # The actual data is in a private attribute {'name': 'Mary M', '_age': 30} >>> vars(dave) {'name': 'David D', '_age': 40} >>> mary.age # Access the data and log the lookup INFO:root:Accessing 'age' giving 30 30 >>> mary.birthday() # Updates are logged as well INFO:root:Accessing 'age' giving 30 INFO:root:Updating 'age' to 31 >>> dave.name # Regular attribute lookup isn't logged 'David D' >>> dave.age # Only the managed attribute is logged INFO:root:Accessing 'age' giving 40 401 được tính theo yêu cầu. Ví dụ này cho thấy cách thức hoạt động của một mô tả đơn giản, nhưng nó rất hữu ích. Để truy xuất các hằng số, tra cứu thuộc tính bình thường sẽ tốt hơn. Trong phần tiếp theo, chúng tôi sẽ tạo ra một cái gì đó hữu ích hơn, một tra cứu năng động. Tra cứu độngCác mô tả thú vị thường chạy tính toán thay vì trả về hằng số: import os class DirectorySize: def __get__(self, obj, objtype=None): return len(os.listdir(obj.dirname)) class Directory: size = DirectorySize() # Descriptor instance def __init__(self, dirname): self.dirname = dirname # Regular instance attribute Một phiên tương tác cho thấy rằng tra cứu là động - nó tính toán các câu trả lời được cập nhật khác nhau mỗi lần: >>> s = Directory('songs') >>> g = Directory('games') >>> s.size # The songs directory has twenty files 20 >>> g.size # The games directory has three files 3 >>> os.remove('games/chess') # Delete a game >>> g.size # File count is automatically updated 2 Bên cạnh việc hiển thị cách các mô tả có thể chạy tính toán, ví dụ này cũng cho thấy mục đích của các tham số thành >>> mary = Person('Mary M', 30) # The initial age update is logged INFO:root:Updating 'age' to 30 >>> dave = Person('David D', 40) INFO:root:Updating 'age' to 40 >>> vars(mary) # The actual data is in a private attribute {'name': 'Mary M', '_age': 30} >>> vars(dave) {'name': 'David D', '_age': 40} >>> mary.age # Access the data and log the lookup INFO:root:Accessing 'age' giving 30 30 >>> mary.birthday() # Updates are logged as well INFO:root:Accessing 'age' giving 30 INFO:root:Updating 'age' to 31 >>> dave.name # Regular attribute lookup isn't logged 'David D' >>> dave.age # Only the managed attribute is logged INFO:root:Accessing 'age' giving 40 400. Tham số tự là kích thước, một thể hiện của thư mục. Tham số OBJ là G hoặc S, một ví dụ của thư mục. Đó là tham số OBJ cho phép phương thức >>> mary = Person('Mary M', 30) # The initial age update is logged INFO:root:Updating 'age' to 30 >>> dave = Person('David D', 40) INFO:root:Updating 'age' to 40 >>> vars(mary) # The actual data is in a private attribute {'name': 'Mary M', '_age': 30} >>> vars(dave) {'name': 'David D', '_age': 40} >>> mary.age # Access the data and log the lookup INFO:root:Accessing 'age' giving 30 30 >>> mary.birthday() # Updates are logged as well INFO:root:Accessing 'age' giving 30 INFO:root:Updating 'age' to 31 >>> dave.name # Regular attribute lookup isn't logged 'David D' >>> dave.age # Only the managed attribute is logged INFO:root:Accessing 'age' giving 40 400 tìm hiểu thư mục đích. Tham số objtype là thư mục lớp. Thuộc tính được quản lýMột cách sử dụng phổ biến cho các mô tả là quản lý quyền truy cập vào dữ liệu thể hiện. Bộ mô tả được gán cho một thuộc tính công khai trong từ điển lớp trong khi dữ liệu thực tế được lưu trữ dưới dạng thuộc tính riêng tư trong từ điển thể hiện. Các phương thức mô tả >>> mary = Person('Mary M', 30) # The initial age update is logged INFO:root:Updating 'age' to 30 >>> dave = Person('David D', 40) INFO:root:Updating 'age' to 40 >>> vars(mary) # The actual data is in a private attribute {'name': 'Mary M', '_age': 30} >>> vars(dave) {'name': 'David D', '_age': 40} >>> mary.age # Access the data and log the lookup INFO:root:Accessing 'age' giving 30 30 >>> mary.birthday() # Updates are logged as well INFO:root:Accessing 'age' giving 30 INFO:root:Updating 'age' to 31 >>> dave.name # Regular attribute lookup isn't logged 'David D' >>> dave.age # Only the managed attribute is logged INFO:root:Accessing 'age' giving 40 400 và import logging logging.basicConfig(level=logging.INFO) class LoggedAccess: def __set_name__(self, owner, name): self.public_name = name self.private_name = '_' + name def __get__(self, obj, objtype=None): value = getattr(obj, self.private_name) logging.info('Accessing %r giving %r', self.public_name, value) return value def __set__(self, obj, value): logging.info('Updating %r to %r', self.public_name, value) setattr(obj, self.private_name, value) class Person: name = LoggedAccess() # First descriptor instance age = LoggedAccess() # Second descriptor instance def __init__(self, name, age): self.name = name # Calls the first descriptor self.age = age # Calls the second descriptor def birthday(self): self.age += 12 được kích hoạt khi thuộc tính công khai được truy cập. Trong ví dụ sau, tuổi là thuộc tính công khai và _age là thuộc tính riêng tư. Khi thuộc tính công khai được truy cập, mô tả ghi lại tra cứu hoặc cập nhật: import logging logging.basicConfig(level=logging.INFO) class LoggedAgeAccess: def __get__(self, obj, objtype=None): value = obj._age logging.info('Accessing %r giving %r', 'age', value) return value def __set__(self, obj, value): logging.info('Updating %r to %r', 'age', value) obj._age = value class Person: age = LoggedAgeAccess() # Descriptor instance def __init__(self, name, age): self.name = name # Regular instance attribute self.age = age # Calls __set__() def birthday(self): self.age += 1 # Calls both __get__() and __set__() Một phiên tương tác cho thấy rằng tất cả các quyền truy cập vào tuổi thuộc tính được quản lý được ghi lại, nhưng tên thuộc tính thông thường không được ghi lại: >>> mary = Person('Mary M', 30) # The initial age update is logged INFO:root:Updating 'age' to 30 >>> dave = Person('David D', 40) INFO:root:Updating 'age' to 40 >>> vars(mary) # The actual data is in a private attribute {'name': 'Mary M', '_age': 30} >>> vars(dave) {'name': 'David D', '_age': 40} >>> mary.age # Access the data and log the lookup INFO:root:Accessing 'age' giving 30 30 >>> mary.birthday() # Updates are logged as well INFO:root:Accessing 'age' giving 30 INFO:root:Updating 'age' to 31 >>> dave.name # Regular attribute lookup isn't logged 'David D' >>> dave.age # Only the managed attribute is logged INFO:root:Accessing 'age' giving 40 40 Một vấn đề lớn với ví dụ này là tên riêng _age được làm cứng trong lớp LogGedageAccess. Điều đó có nghĩa là mỗi trường hợp chỉ có thể có một thuộc tính đã ghi và tên của nó là không thể thay đổi. Trong ví dụ tiếp theo, chúng tôi sẽ khắc phục vấn đề đó. Tên tùy chỉnhKhi một lớp sử dụng các mô tả, nó có thể thông báo cho từng mô tả về tên biến được sử dụng. Trong ví dụ này, lớp import logging logging.basicConfig(level=logging.INFO) class LoggedAccess: def __set_name__(self, owner, name): self.public_name = name self.private_name = '_' + name def __get__(self, obj, objtype=None): value = getattr(obj, self.private_name) logging.info('Accessing %r giving %r', self.public_name, value) return value def __set__(self, obj, value): logging.info('Updating %r to %r', self.public_name, value) setattr(obj, self.private_name, value) class Person: name = LoggedAccess() # First descriptor instance age = LoggedAccess() # Second descriptor instance def __init__(self, name, age): self.name = name # Calls the first descriptor self.age = age # Calls the second descriptor def birthday(self): self.age += 13 có hai trường hợp mô tả, tên và tuổi. Khi lớp import logging logging.basicConfig(level=logging.INFO) class LoggedAccess: def __set_name__(self, owner, name): self.public_name = name self.private_name = '_' + name def __get__(self, obj, objtype=None): value = getattr(obj, self.private_name) logging.info('Accessing %r giving %r', self.public_name, value) return value def __set__(self, obj, value): logging.info('Updating %r to %r', self.public_name, value) setattr(obj, self.private_name, value) class Person: name = LoggedAccess() # First descriptor instance age = LoggedAccess() # Second descriptor instance def __init__(self, name, age): self.name = name # Calls the first descriptor self.age = age # Calls the second descriptor def birthday(self): self.age += 13 được xác định, nó sẽ gọi lại cho import logging logging.basicConfig(level=logging.INFO) class LoggedAccess: def __set_name__(self, owner, name): self.public_name = name self.private_name = '_' + name def __get__(self, obj, objtype=None): value = getattr(obj, self.private_name) logging.info('Accessing %r giving %r', self.public_name, value) return value def __set__(self, obj, value): logging.info('Updating %r to %r', self.public_name, value) setattr(obj, self.private_name, value) class Person: name = LoggedAccess() # First descriptor instance age = LoggedAccess() # Second descriptor instance def __init__(self, name, age): self.name = name # Calls the first descriptor self.age = age # Calls the second descriptor def birthday(self): self.age += 15 trong LoggedAccess để có thể ghi lại tên trường, cung cấp cho mỗi mô tả của riêng mình_name và private_name: import logging logging.basicConfig(level=logging.INFO) class LoggedAccess: def __set_name__(self, owner, name): self.public_name = name self.private_name = '_' + name def __get__(self, obj, objtype=None): value = getattr(obj, self.private_name) logging.info('Accessing %r giving %r', self.public_name, value) return value def __set__(self, obj, value): logging.info('Updating %r to %r', self.public_name, value) setattr(obj, self.private_name, value) class Person: name = LoggedAccess() # First descriptor instance age = LoggedAccess() # Second descriptor instance def __init__(self, name, age): self.name = name # Calls the first descriptor self.age = age # Calls the second descriptor def birthday(self): self.age += 1 Một phiên tương tác cho thấy lớp import logging logging.basicConfig(level=logging.INFO) class LoggedAccess: def __set_name__(self, owner, name): self.public_name = name self.private_name = '_' + name def __get__(self, obj, objtype=None): value = getattr(obj, self.private_name) logging.info('Accessing %r giving %r', self.public_name, value) return value def __set__(self, obj, value): logging.info('Updating %r to %r', self.public_name, value) setattr(obj, self.private_name, value) class Person: name = LoggedAccess() # First descriptor instance age = LoggedAccess() # Second descriptor instance def __init__(self, name, age): self.name = name # Calls the first descriptor self.age = age # Calls the second descriptor def birthday(self): self.age += 13 đã gọi import logging logging.basicConfig(level=logging.INFO) class LoggedAccess: def __set_name__(self, owner, name): self.public_name = name self.private_name = '_' + name def __get__(self, obj, objtype=None): value = getattr(obj, self.private_name) logging.info('Accessing %r giving %r', self.public_name, value) return value def __set__(self, obj, value): logging.info('Updating %r to %r', self.public_name, value) setattr(obj, self.private_name, value) class Person: name = LoggedAccess() # First descriptor instance age = LoggedAccess() # Second descriptor instance def __init__(self, name, age): self.name = name # Calls the first descriptor self.age = age # Calls the second descriptor def birthday(self): self.age += 15 để các tên trường sẽ được ghi lại. Ở đây chúng tôi gọi import logging logging.basicConfig(level=logging.INFO) class LoggedAccess: def __set_name__(self, owner, name): self.public_name = name self.private_name = '_' + name def __get__(self, obj, objtype=None): value = getattr(obj, self.private_name) logging.info('Accessing %r giving %r', self.public_name, value) return value def __set__(self, obj, value): logging.info('Updating %r to %r', self.public_name, value) setattr(obj, self.private_name, value) class Person: name = LoggedAccess() # First descriptor instance age = LoggedAccess() # Second descriptor instance def __init__(self, name, age): self.name = name # Calls the first descriptor self.age = age # Calls the second descriptor def birthday(self): self.age += 18 để tra cứu bộ mô tả mà không kích hoạt nó: >>> vars(vars(Person)['name']) {'public_name': 'name', 'private_name': '_name'} >>> vars(vars(Person)['age']) {'public_name': 'age', 'private_name': '_age'} Lớp mới hiện ghi nhật ký truy cập vào cả tên và tuổi: >>> pete = Person('Peter P', 10) INFO:root:Updating 'name' to 'Peter P' INFO:root:Updating 'age' to 10 >>> kate = Person('Catherine C', 20) INFO:root:Updating 'name' to 'Catherine C' INFO:root:Updating 'age' to 20 Các trường hợp hai người chỉ chứa tên riêng tư: class A: x = 5 # Regular class attribute y = Ten() # Descriptor instance0 Bớt tư tưởng¶Một mô tả là những gì chúng ta gọi là bất kỳ đối tượng nào xác định >>> mary = Person('Mary M', 30) # The initial age update is logged INFO:root:Updating 'age' to 30 >>> dave = Person('David D', 40) INFO:root:Updating 'age' to 40 >>> vars(mary) # The actual data is in a private attribute {'name': 'Mary M', '_age': 30} >>> vars(dave) {'name': 'David D', '_age': 40} >>> mary.age # Access the data and log the lookup INFO:root:Accessing 'age' giving 30 30 >>> mary.birthday() # Updates are logged as well INFO:root:Accessing 'age' giving 30 INFO:root:Updating 'age' to 31 >>> dave.name # Regular attribute lookup isn't logged 'David D' >>> dave.age # Only the managed attribute is logged INFO:root:Accessing 'age' giving 40 400, import logging logging.basicConfig(level=logging.INFO) class LoggedAccess: def __set_name__(self, owner, name): self.public_name = name self.private_name = '_' + name def __get__(self, obj, objtype=None): value = getattr(obj, self.private_name) logging.info('Accessing %r giving %r', self.public_name, value) return value def __set__(self, obj, value): logging.info('Updating %r to %r', self.public_name, value) setattr(obj, self.private_name, value) class Person: name = LoggedAccess() # First descriptor instance age = LoggedAccess() # Second descriptor instance def __init__(self, name, age): self.name = name # Calls the first descriptor self.age = age # Calls the second descriptor def birthday(self): self.age += 12 hoặc >>> vars(vars(Person)['name']) {'public_name': 'name', 'private_name': '_name'} >>> vars(vars(Person)['age']) {'public_name': 'age', 'private_name': '_age'}1.descriptor is what we call any object that defines >>> mary = Person('Mary M', 30) # The initial age update is logged INFO:root:Updating 'age' to 30 >>> dave = Person('David D', 40) INFO:root:Updating 'age' to 40 >>> vars(mary) # The actual data is in a private attribute {'name': 'Mary M', '_age': 30} >>> vars(dave) {'name': 'David D', '_age': 40} >>> mary.age # Access the data and log the lookup INFO:root:Accessing 'age' giving 30 30 >>> mary.birthday() # Updates are logged as well INFO:root:Accessing 'age' giving 30 INFO:root:Updating 'age' to 31 >>> dave.name # Regular attribute lookup isn't logged 'David D' >>> dave.age # Only the managed attribute is logged INFO:root:Accessing 'age' giving 40 400, import logging logging.basicConfig(level=logging.INFO) class LoggedAccess: def __set_name__(self, owner, name): self.public_name = name self.private_name = '_' + name def __get__(self, obj, objtype=None): value = getattr(obj, self.private_name) logging.info('Accessing %r giving %r', self.public_name, value) return value def __set__(self, obj, value): logging.info('Updating %r to %r', self.public_name, value) setattr(obj, self.private_name, value) class Person: name = LoggedAccess() # First descriptor instance age = LoggedAccess() # Second descriptor instance def __init__(self, name, age): self.name = name # Calls the first descriptor self.age = age # Calls the second descriptor def birthday(self): self.age += 12, or >>> vars(vars(Person)['name']) {'public_name': 'name', 'private_name': '_name'} >>> vars(vars(Person)['age']) {'public_name': 'age', 'private_name': '_age'}1. Tùy chọn, mô tả có thể có phương thức import logging logging.basicConfig(level=logging.INFO) class LoggedAccess: def __set_name__(self, owner, name): self.public_name = name self.private_name = '_' + name def __get__(self, obj, objtype=None): value = getattr(obj, self.private_name) logging.info('Accessing %r giving %r', self.public_name, value) return value def __set__(self, obj, value): logging.info('Updating %r to %r', self.public_name, value) setattr(obj, self.private_name, value) class Person: name = LoggedAccess() # First descriptor instance age = LoggedAccess() # Second descriptor instance def __init__(self, name, age): self.name = name # Calls the first descriptor self.age = age # Calls the second descriptor def birthday(self): self.age += 15. Điều này chỉ được sử dụng trong trường hợp một mô tả cần biết lớp nơi nó được tạo hoặc tên của biến lớp mà nó được gán cho. (Phương pháp này, nếu có, được gọi ngay cả khi lớp không phải là mô tả.) Mô tả được gọi bởi toán tử DOT trong quá trình tra cứu thuộc tính. Nếu một mô tả được truy cập gián tiếp với >>> vars(vars(Person)['name']) {'public_name': 'name', 'private_name': '_name'} >>> vars(vars(Person)['age']) {'public_name': 'age', 'private_name': '_age'}3, phiên bản mô tả được trả về mà không cần gọi nó. Mô tả chỉ hoạt động khi được sử dụng làm biến lớp. Khi đặt trong các trường hợp, chúng không có tác dụng. Động lực chính cho các mô tả là cung cấp một móc cho phép các đối tượng được lưu trữ trong các biến lớp để kiểm soát những gì xảy ra trong quá trình tra cứu thuộc tính. Theo truyền thống, lớp gọi kiểm soát những gì xảy ra trong quá trình tra cứu. Các mô tả đảo ngược mối quan hệ đó và cho phép dữ liệu được tra cứu có tiếng nói trong vấn đề này. Mô tả được sử dụng trong suốt ngôn ngữ. Đó là cách các chức năng biến thành các phương thức bị ràng buộc. Các công cụ phổ biến như import logging logging.basicConfig(level=logging.INFO) class LoggedAgeAccess: def __get__(self, obj, objtype=None): value = obj._age logging.info('Accessing %r giving %r', 'age', value) return value def __set__(self, obj, value): logging.info('Updating %r to %r', 'age', value) obj._age = value class Person: age = LoggedAgeAccess() # Descriptor instance def __init__(self, name, age): self.name = name # Regular instance attribute self.age = age # Calls __set__() def birthday(self): self.age += 1 # Calls both __get__() and __set__()6, import logging logging.basicConfig(level=logging.INFO) class LoggedAgeAccess: def __get__(self, obj, objtype=None): value = obj._age logging.info('Accessing %r giving %r', 'age', value) return value def __set__(self, obj, value): logging.info('Updating %r to %r', 'age', value) obj._age = value class Person: age = LoggedAgeAccess() # Descriptor instance def __init__(self, name, age): self.name = name # Regular instance attribute self.age = age # Calls __set__() def birthday(self): self.age += 1 # Calls both __get__() and __set__()7, import logging logging.basicConfig(level=logging.INFO) class LoggedAgeAccess: def __get__(self, obj, objtype=None): value = obj._age logging.info('Accessing %r giving %r', 'age', value) return value def __set__(self, obj, value): logging.info('Updating %r to %r', 'age', value) obj._age = value class Person: age = LoggedAgeAccess() # Descriptor instance def __init__(self, name, age): self.name = name # Regular instance attribute self.age = age # Calls __set__() def birthday(self): self.age += 1 # Calls both __get__() and __set__()8 và >>> vars(vars(Person)['name']) {'public_name': 'name', 'private_name': '_name'} >>> vars(vars(Person)['age']) {'public_name': 'age', 'private_name': '_age'}7 đều được triển khai dưới dạng mô tả. Hoàn thành ví dụ thực tếTrong ví dụ này, chúng tôi tạo ra một công cụ thực tế và mạnh mẽ để định vị rất khó để tìm các lỗi tham nhũng dữ liệu. Lớp xác thựcTrình xác nhận là một mô tả cho quyền truy cập thuộc tính được quản lý. Trước khi lưu trữ bất kỳ dữ liệu nào, nó xác minh rằng giá trị mới đáp ứng các hạn chế loại và phạm vi khác nhau. Nếu những hạn chế đó được đáp ứng, nó sẽ đặt ra một ngoại lệ để ngăn chặn sự tham nhũng dữ liệu tại nguồn của nó. Lớp >>> vars(vars(Person)['name']) {'public_name': 'name', 'private_name': '_name'} >>> vars(vars(Person)['age']) {'public_name': 'age', 'private_name': '_age'}8 này vừa là một lớp cơ sở trừu tượng vừa là bộ mô tả thuộc tính được quản lý:abstract base class and a managed attribute descriptor: class A: x = 5 # Regular class attribute y = Ten() # Descriptor instance1 Người xác nhận tùy chỉnh cần được kế thừa từ >>> vars(vars(Person)['name']) {'public_name': 'name', 'private_name': '_name'} >>> vars(vars(Person)['age']) {'public_name': 'age', 'private_name': '_age'}8 và phải cung cấp phương pháp >>> pete = Person('Peter P', 10) INFO:root:Updating 'name' to 'Peter P' INFO:root:Updating 'age' to 10 >>> kate = Person('Catherine C', 20) INFO:root:Updating 'name' to 'Catherine C' INFO:root:Updating 'age' to 200 để kiểm tra các hạn chế khác nhau khi cần thiết. Người xác nhận tùy chỉnh OrDưới đây là ba tiện ích xác nhận dữ liệu thực tế:
class A: x = 5 # Regular class attribute y = Ten() # Descriptor instance2 Ứng dụng thực tếỞ đây, cách thức sử dụng trình xác thực dữ liệu trong một lớp thực: class A: x = 5 # Regular class attribute y = Ten() # Descriptor instance3 Các mô tả ngăn chặn các trường hợp không hợp lệ được tạo: class A: x = 5 # Regular class attribute y = Ten() # Descriptor instance4 Hướng dẫn kỹ thuậtNhững gì sau đây là một hướng dẫn kỹ thuật hơn cho các cơ chế và chi tiết về cách các mô tả hoạt động. Trừu tượng¶Xác định các mô tả, tóm tắt giao thức và cho thấy cách các mô tả được gọi. Cung cấp một ví dụ cho thấy cách ánh xạ quan hệ đối tượng hoạt động. Tìm hiểu về các mô tả không chỉ cung cấp quyền truy cập vào bộ công cụ lớn hơn, nó tạo ra sự hiểu biết sâu sắc hơn về cách thức hoạt động của Python. Định nghĩa và giới thiệuNói chung, một mô tả là một giá trị thuộc tính có một trong các phương thức trong giao thức mô tả. Những phương pháp đó là >>> mary = Person('Mary M', 30) # The initial age update is logged INFO:root:Updating 'age' to 30 >>> dave = Person('David D', 40) INFO:root:Updating 'age' to 40 >>> vars(mary) # The actual data is in a private attribute {'name': 'Mary M', '_age': 30} >>> vars(dave) {'name': 'David D', '_age': 40} >>> mary.age # Access the data and log the lookup INFO:root:Accessing 'age' giving 30 30 >>> mary.birthday() # Updates are logged as well INFO:root:Accessing 'age' giving 30 INFO:root:Updating 'age' to 31 >>> dave.name # Regular attribute lookup isn't logged 'David D' >>> dave.age # Only the managed attribute is logged INFO:root:Accessing 'age' giving 40 400, import logging logging.basicConfig(level=logging.INFO) class LoggedAccess: def __set_name__(self, owner, name): self.public_name = name self.private_name = '_' + name def __get__(self, obj, objtype=None): value = getattr(obj, self.private_name) logging.info('Accessing %r giving %r', self.public_name, value) return value def __set__(self, obj, value): logging.info('Updating %r to %r', self.public_name, value) setattr(obj, self.private_name, value) class Person: name = LoggedAccess() # First descriptor instance age = LoggedAccess() # Second descriptor instance def __init__(self, name, age): self.name = name # Calls the first descriptor self.age = age # Calls the second descriptor def birthday(self): self.age += 12 và >>> vars(vars(Person)['name']) {'public_name': 'name', 'private_name': '_name'} >>> vars(vars(Person)['age']) {'public_name': 'age', 'private_name': '_age'}1. Nếu bất kỳ phương pháp nào được xác định cho một thuộc tính, nó được cho là một mô tả.descriptor. Hành vi mặc định cho quyền truy cập thuộc tính là để có được, đặt hoặc xóa thuộc tính khỏi từ điển đối tượng. Chẳng hạn, >>> mary = Person('Mary M', 30) # The initial age update is logged INFO:root:Updating 'age' to 30 >>> dave = Person('David D', 40) INFO:root:Updating 'age' to 40 >>> vars(mary) # The actual data is in a private attribute {'name': 'Mary M', '_age': 30} >>> vars(dave) {'name': 'David D', '_age': 40} >>> mary.age # Access the data and log the lookup INFO:root:Accessing 'age' giving 30 30 >>> mary.birthday() # Updates are logged as well INFO:root:Accessing 'age' giving 30 INFO:root:Updating 'age' to 31 >>> dave.name # Regular attribute lookup isn't logged 'David D' >>> dave.age # Only the managed attribute is logged INFO:root:Accessing 'age' giving 40 402 có chuỗi tra cứu bắt đầu bằng class A: x = 5 # Regular class attribute y = Ten() # Descriptor instance01, sau đó class A: x = 5 # Regular class attribute y = Ten() # Descriptor instance02 và tiếp tục thông qua thứ tự độ phân giải phương pháp của class A: x = 5 # Regular class attribute y = Ten() # Descriptor instance03. Nếu giá trị tra cứu là một đối tượng xác định một trong các phương thức mô tả, thì Python có thể ghi đè hành vi mặc định và gọi phương thức mô tả thay thế. Trường hợp điều này xảy ra trong chuỗi ưu tiên phụ thuộc vào phương thức mô tả nào được xác định. Mô tả là một giao thức mục đích mạnh mẽ, mạnh mẽ. Chúng là cơ chế đằng sau các thuộc tính, phương pháp, phương pháp tĩnh, phương pháp lớp và class A: x = 5 # Regular class attribute y = Ten() # Descriptor instance04. Chúng được sử dụng trong suốt Python. Các mô tả đơn giản hóa mã C cơ bản và cung cấp một bộ công cụ mới linh hoạt cho các chương trình Python hàng ngày. Giao thức mô tảclass A: x = 5 # Regular class attribute y = Ten() # Descriptor instance05 class A: x = 5 # Regular class attribute y = Ten() # Descriptor instance06 class A: x = 5 # Regular class attribute y = Ten() # Descriptor instance07 Đó là tất cả để có nó. Xác định bất kỳ phương thức nào trong số này và một đối tượng được coi là một mô tả và có thể ghi đè hành vi mặc định khi được tra cứu như một thuộc tính. Nếu một đối tượng xác định import logging logging.basicConfig(level=logging.INFO) class LoggedAccess: def __set_name__(self, owner, name): self.public_name = name self.private_name = '_' + name def __get__(self, obj, objtype=None): value = getattr(obj, self.private_name) logging.info('Accessing %r giving %r', self.public_name, value) return value def __set__(self, obj, value): logging.info('Updating %r to %r', self.public_name, value) setattr(obj, self.private_name, value) class Person: name = LoggedAccess() # First descriptor instance age = LoggedAccess() # Second descriptor instance def __init__(self, name, age): self.name = name # Calls the first descriptor self.age = age # Calls the second descriptor def birthday(self): self.age += 12 hoặc >>> vars(vars(Person)['name']) {'public_name': 'name', 'private_name': '_name'} >>> vars(vars(Person)['age']) {'public_name': 'age', 'private_name': '_age'}1, thì nó được coi là mô tả dữ liệu. Các mô tả chỉ xác định >>> mary = Person('Mary M', 30) # The initial age update is logged INFO:root:Updating 'age' to 30 >>> dave = Person('David D', 40) INFO:root:Updating 'age' to 40 >>> vars(mary) # The actual data is in a private attribute {'name': 'Mary M', '_age': 30} >>> vars(dave) {'name': 'David D', '_age': 40} >>> mary.age # Access the data and log the lookup INFO:root:Accessing 'age' giving 30 30 >>> mary.birthday() # Updates are logged as well INFO:root:Accessing 'age' giving 30 INFO:root:Updating 'age' to 31 >>> dave.name # Regular attribute lookup isn't logged 'David D' >>> dave.age # Only the managed attribute is logged INFO:root:Accessing 'age' giving 40 400 được gọi là mô tả không dữ liệu (chúng thường được sử dụng cho các phương pháp nhưng có thể sử dụng khác). Các mô tả dữ liệu và không dữ liệu khác nhau về cách tính toán được tính toán liên quan đến các mục trong từ điển phiên bản. Nếu một từ điển phiên bản có một mục có cùng tên với bộ mô tả dữ liệu, bộ mô tả dữ liệu sẽ được ưu tiên. Nếu một từ điển phiên bản có một mục có cùng tên với bộ mô tả không phải là dữ liệu, thì mục từ điển sẽ được ưu tiên. Để thực hiện mô tả dữ liệu chỉ đọc, hãy xác định cả >>> mary = Person('Mary M', 30) # The initial age update is logged INFO:root:Updating 'age' to 30 >>> dave = Person('David D', 40) INFO:root:Updating 'age' to 40 >>> vars(mary) # The actual data is in a private attribute {'name': 'Mary M', '_age': 30} >>> vars(dave) {'name': 'David D', '_age': 40} >>> mary.age # Access the data and log the lookup INFO:root:Accessing 'age' giving 30 30 >>> mary.birthday() # Updates are logged as well INFO:root:Accessing 'age' giving 30 INFO:root:Updating 'age' to 31 >>> dave.name # Regular attribute lookup isn't logged 'David D' >>> dave.age # Only the managed attribute is logged INFO:root:Accessing 'age' giving 40 400 và import logging logging.basicConfig(level=logging.INFO) class LoggedAccess: def __set_name__(self, owner, name): self.public_name = name self.private_name = '_' + name def __get__(self, obj, objtype=None): value = getattr(obj, self.private_name) logging.info('Accessing %r giving %r', self.public_name, value) return value def __set__(self, obj, value): logging.info('Updating %r to %r', self.public_name, value) setattr(obj, self.private_name, value) class Person: name = LoggedAccess() # First descriptor instance age = LoggedAccess() # Second descriptor instance def __init__(self, name, age): self.name = name # Calls the first descriptor self.age = age # Calls the second descriptor def birthday(self): self.age += 12 với import logging logging.basicConfig(level=logging.INFO) class LoggedAccess: def __set_name__(self, owner, name): self.public_name = name self.private_name = '_' + name def __get__(self, obj, objtype=None): value = getattr(obj, self.private_name) logging.info('Accessing %r giving %r', self.public_name, value) return value def __set__(self, obj, value): logging.info('Updating %r to %r', self.public_name, value) setattr(obj, self.private_name, value) class Person: name = LoggedAccess() # First descriptor instance age = LoggedAccess() # Second descriptor instance def __init__(self, name, age): self.name = name # Calls the first descriptor self.age = age # Calls the second descriptor def birthday(self): self.age += 12 tăng class A: x = 5 # Regular class attribute y = Ten() # Descriptor instance14 khi được gọi. Xác định phương pháp import logging logging.basicConfig(level=logging.INFO) class LoggedAccess: def __set_name__(self, owner, name): self.public_name = name self.private_name = '_' + name def __get__(self, obj, objtype=None): value = getattr(obj, self.private_name) logging.info('Accessing %r giving %r', self.public_name, value) return value def __set__(self, obj, value): logging.info('Updating %r to %r', self.public_name, value) setattr(obj, self.private_name, value) class Person: name = LoggedAccess() # First descriptor instance age = LoggedAccess() # Second descriptor instance def __init__(self, name, age): self.name = name # Calls the first descriptor self.age = age # Calls the second descriptor def birthday(self): self.age += 12 với một trình giữ chỗ tăng ngoại lệ là đủ để biến nó thành một mô tả dữ liệu. Tổng quan về lời mời mô tảMột mô tả có thể được gọi trực tiếp với class A: x = 5 # Regular class attribute y = Ten() # Descriptor instance16 hoặc class A: x = 5 # Regular class attribute y = Ten() # Descriptor instance17. Nhưng thông thường hơn cho một mô tả được gọi tự động từ quyền truy cập thuộc tính. Biểu thức class A: x = 5 # Regular class attribute y = Ten() # Descriptor instance18 tìm kiếm thuộc tính class A: x = 5 # Regular class attribute y = Ten() # Descriptor instance19 trong chuỗi không gian tên cho class A: x = 5 # Regular class attribute y = Ten() # Descriptor instance20. Nếu tìm kiếm tìm thấy một mô tả bên ngoài trường hợp class A: x = 5 # Regular class attribute y = Ten() # Descriptor instance21, phương thức >>> mary = Person('Mary M', 30) # The initial age update is logged INFO:root:Updating 'age' to 30 >>> dave = Person('David D', 40) INFO:root:Updating 'age' to 40 >>> vars(mary) # The actual data is in a private attribute {'name': 'Mary M', '_age': 30} >>> vars(dave) {'name': 'David D', '_age': 40} >>> mary.age # Access the data and log the lookup INFO:root:Accessing 'age' giving 30 30 >>> mary.birthday() # Updates are logged as well INFO:root:Accessing 'age' giving 30 INFO:root:Updating 'age' to 31 >>> dave.name # Regular attribute lookup isn't logged 'David D' >>> dave.age # Only the managed attribute is logged INFO:root:Accessing 'age' giving 40 400 của nó được gọi theo các quy tắc ưu tiên được liệt kê dưới đây. Các chi tiết về việc gọi phụ thuộc vào việc class A: x = 5 # Regular class attribute y = Ten() # Descriptor instance20 có phải là đối tượng, lớp hoặc thể hiện của Super. Bắt đầu từ một trường hợpTra cứu phiên bản quét thông qua một chuỗi các không gian tên mang lại cho các mô tả dữ liệu ưu tiên cao nhất, theo sau là các biến thể hiện, sau đó là các mô tả không gây dữ liệu, sau đó là các biến lớp và cuối cùng là class A: x = 5 # Regular class attribute y = Ten() # Descriptor instance24 nếu nó được cung cấp. Nếu một mô tả được tìm thấy cho >>> mary = Person('Mary M', 30) # The initial age update is logged INFO:root:Updating 'age' to 30 >>> dave = Person('David D', 40) INFO:root:Updating 'age' to 40 >>> vars(mary) # The actual data is in a private attribute {'name': 'Mary M', '_age': 30} >>> vars(dave) {'name': 'David D', '_age': 40} >>> mary.age # Access the data and log the lookup INFO:root:Accessing 'age' giving 30 30 >>> mary.birthday() # Updates are logged as well INFO:root:Accessing 'age' giving 30 INFO:root:Updating 'age' to 31 >>> dave.name # Regular attribute lookup isn't logged 'David D' >>> dave.age # Only the managed attribute is logged INFO:root:Accessing 'age' giving 40 402, thì nó được gọi bằng: class A: x = 5 # Regular class attribute y = Ten() # Descriptor instance26. Logic cho một tra cứu chấm là trong class A: x = 5 # Regular class attribute y = Ten() # Descriptor instance27. Đây là một python thuần túy tương đương: class A: x = 5 # Regular class attribute y = Ten() # Descriptor instance5 Lưu ý, không có móc class A: x = 5 # Regular class attribute y = Ten() # Descriptor instance24 trong mã class A: x = 5 # Regular class attribute y = Ten() # Descriptor instance29. Đó là lý do tại sao gọi class A: x = 5 # Regular class attribute y = Ten() # Descriptor instance29 trực tiếp hoặc với class A: x = 5 # Regular class attribute y = Ten() # Descriptor instance31 sẽ bỏ qua hoàn toàn class A: x = 5 # Regular class attribute y = Ten() # Descriptor instance24. Thay vào đó, chính toán tử DOT và hàm class A: x = 5 # Regular class attribute y = Ten() # Descriptor instance33 chịu trách nhiệm gọi class A: x = 5 # Regular class attribute y = Ten() # Descriptor instance24 bất cứ khi nào class A: x = 5 # Regular class attribute y = Ten() # Descriptor instance29 tăng class A: x = 5 # Regular class attribute y = Ten() # Descriptor instance14. Logic của họ được gói gọn trong hàm trợ giúp: class A: x = 5 # Regular class attribute y = Ten() # Descriptor instance6 Bắt đầu từ một lớp họcLogic cho một tra cứu chấm, chẳng hạn như class A: x = 5 # Regular class attribute y = Ten() # Descriptor instance37 là trong class A: x = 5 # Regular class attribute y = Ten() # Descriptor instance38. Các bước tương tự như các bước cho class A: x = 5 # Regular class attribute y = Ten() # Descriptor instance27 nhưng Tra cứu từ điển thể hiện được thay thế bằng tìm kiếm thông qua thứ tự phân giải phương thức lớp.method resolution order. Nếu một mô tả được tìm thấy, nó được gọi bằng class A: x = 5 # Regular class attribute y = Ten() # Descriptor instance40. Việc triển khai C đầy đủ có thể được tìm thấy trong class A: x = 5 # Regular class attribute y = Ten() # Descriptor instance41 và class A: x = 5 # Regular class attribute y = Ten() # Descriptor instance42 trong các đối tượng/typeObject.C. Bắt đầu từ Super¶Logic cho tra cứu chấm siêu tốc có trong phương thức class A: x = 5 # Regular class attribute y = Ten() # Descriptor instance29 cho đối tượng được trả về bởi class A: x = 5 # Regular class attribute y = Ten() # Descriptor instance04. Tra cứu chấm chấm, chẳng hạn như class A: x = 5 # Regular class attribute y = Ten() # Descriptor instance45 tìm kiếm class A: x = 5 # Regular class attribute y = Ten() # Descriptor instance46 cho lớp cơ sở class A: x = 5 # Regular class attribute y = Ten() # Descriptor instance47 ngay sau class A: x = 5 # Regular class attribute y = Ten() # Descriptor instance48 và sau đó trả về class A: x = 5 # Regular class attribute y = Ten() # Descriptor instance49. Nếu không phải là một mô tả, class A: x = 5 # Regular class attribute y = Ten() # Descriptor instance50 được trả về không thay đổi. Việc triển khai C đầy đủ có thể được tìm thấy trong class A: x = 5 # Regular class attribute y = Ten() # Descriptor instance51 trong các đối tượng/typeObject.c. Một tương đương Python thuần túy có thể được tìm thấy trong hướng dẫn của Guido. Tóm tắt Logic Lệnh gọiCơ chế cho các mô tả được nhúng trong các phương pháp class A: x = 5 # Regular class attribute y = Ten() # Descriptor instance29 cho class A: x = 5 # Regular class attribute y = Ten() # Descriptor instance53, class A: x = 5 # Regular class attribute y = Ten() # Descriptor instance54 và class A: x = 5 # Regular class attribute y = Ten() # Descriptor instance04. Những điểm quan trọng cần nhớ là:
Thông báo tên tự độngĐôi khi, một mô tả là mong muốn để biết tên biến lớp mà nó được gán cho. Khi một lớp mới được tạo ra, Metaclass class A: x = 5 # Regular class attribute y = Ten() # Descriptor instance54 sẽ quét từ điển của lớp mới. Nếu bất kỳ mục nào là mô tả và nếu chúng xác định import logging logging.basicConfig(level=logging.INFO) class LoggedAccess: def __set_name__(self, owner, name): self.public_name = name self.private_name = '_' + name def __get__(self, obj, objtype=None): value = getattr(obj, self.private_name) logging.info('Accessing %r giving %r', self.public_name, value) return value def __set__(self, obj, value): logging.info('Updating %r to %r', self.public_name, value) setattr(obj, self.private_name, value) class Person: name = LoggedAccess() # First descriptor instance age = LoggedAccess() # Second descriptor instance def __init__(self, name, age): self.name = name # Calls the first descriptor self.age = age # Calls the second descriptor def birthday(self): self.age += 15, phương thức đó được gọi với hai đối số. Chủ sở hữu là lớp nơi sử dụng mô tả và tên là biến lớp mà bộ mô tả được gán cho. Các chi tiết triển khai nằm trong class A: x = 5 # Regular class attribute y = Ten() # Descriptor instance67 và class A: x = 5 # Regular class attribute y = Ten() # Descriptor instance68 trong các đối tượng/typeObject.C. Vì logic cập nhật là trong class A: x = 5 # Regular class attribute y = Ten() # Descriptor instance69, các thông báo chỉ diễn ra tại thời điểm tạo lớp. Nếu các mô tả được thêm vào lớp sau đó, import logging logging.basicConfig(level=logging.INFO) class LoggedAccess: def __set_name__(self, owner, name): self.public_name = name self.private_name = '_' + name def __get__(self, obj, objtype=None): value = getattr(obj, self.private_name) logging.info('Accessing %r giving %r', self.public_name, value) return value def __set__(self, obj, value): logging.info('Updating %r to %r', self.public_name, value) setattr(obj, self.private_name, value) class Person: name = LoggedAccess() # First descriptor instance age = LoggedAccess() # Second descriptor instance def __init__(self, name, age): self.name = name # Calls the first descriptor self.age = age # Calls the second descriptor def birthday(self): self.age += 15 sẽ cần được gọi bằng tay. Ví dụ OrmMã sau đây là một bộ xương đơn giản hóa cho thấy cách mô tả dữ liệu có thể được sử dụng để thực hiện ánh xạ quan hệ đối tượng. Ý tưởng thiết yếu là dữ liệu được lưu trữ trong cơ sở dữ liệu bên ngoài. Các phiên bản Python chỉ giữ các khóa cho các bảng cơ sở dữ liệu. Người mô tả chăm sóc các bộ tra cứu hoặc cập nhật: class A: x = 5 # Regular class attribute y = Ten() # Descriptor instance7 Chúng ta có thể sử dụng lớp class A: x = 5 # Regular class attribute y = Ten() # Descriptor instance71 để xác định các mô hình mô tả lược đồ cho mỗi bảng trong cơ sở dữ liệu: class A: x = 5 # Regular class attribute y = Ten() # Descriptor instance8 Để sử dụng các mô hình, trước tiên hãy kết nối với cơ sở dữ liệu: class A: x = 5 # Regular class attribute y = Ten() # Descriptor instance9 Một phiên tương tác cho thấy cách lấy dữ liệu từ cơ sở dữ liệu và cách cập nhật nó: >>> a = A() # Make an instance of class A >>> a.x # Normal attribute lookup 5 >>> a.y # Descriptor lookup 100 Tương đương Python thuần túyGiao thức mô tả rất đơn giản và cung cấp các khả năng thú vị. Một số trường hợp sử dụng là phổ biến đến mức chúng đã được đóng gói sẵn thành các công cụ tích hợp. Các thuộc tính, phương thức ràng buộc, phương thức tĩnh, phương thức lớp và __Slots__ đều dựa trên giao thức mô tả. Đặc tính¶Gọi import logging logging.basicConfig(level=logging.INFO) class LoggedAgeAccess: def __get__(self, obj, objtype=None): value = obj._age logging.info('Accessing %r giving %r', 'age', value) return value def __set__(self, obj, value): logging.info('Updating %r to %r', 'age', value) obj._age = value class Person: age = LoggedAgeAccess() # Descriptor instance def __init__(self, name, age): self.name = name # Regular instance attribute self.age = age # Calls __set__() def birthday(self): self.age += 1 # Calls both __get__() and __set__()8 là một cách ngắn gọn để xây dựng bộ mô tả dữ liệu kích hoạt lệnh gọi hàm khi truy cập vào một thuộc tính. Chữ ký của nó là: >>> a = A() # Make an instance of class A >>> a.x # Normal attribute lookup 5 >>> a.y # Descriptor lookup 101 Tài liệu cho thấy một cách sử dụng điển hình để xác định thuộc tính được quản lý class A: x = 5 # Regular class attribute y = Ten() # Descriptor instance19: >>> a = A() # Make an instance of class A >>> a.x # Normal attribute lookup 5 >>> a.y # Descriptor lookup 102 Để xem cách import logging logging.basicConfig(level=logging.INFO) class LoggedAgeAccess: def __get__(self, obj, objtype=None): value = obj._age logging.info('Accessing %r giving %r', 'age', value) return value def __set__(self, obj, value): logging.info('Updating %r to %r', 'age', value) obj._age = value class Person: age = LoggedAgeAccess() # Descriptor instance def __init__(self, name, age): self.name = name # Regular instance attribute self.age = age # Calls __set__() def birthday(self): self.age += 1 # Calls both __get__() and __set__()8 được thực hiện theo giao thức mô tả, đây là một tương đương Python thuần túy: tương đương: >>> a = A() # Make an instance of class A >>> a.x # Normal attribute lookup 5 >>> a.y # Descriptor lookup 103 import logging logging.basicConfig(level=logging.INFO) class LoggedAgeAccess: def __get__(self, obj, objtype=None): value = obj._age logging.info('Accessing %r giving %r', 'age', value) return value def __set__(self, obj, value): logging.info('Updating %r to %r', 'age', value) obj._age = value class Person: age = LoggedAgeAccess() # Descriptor instance def __init__(self, name, age): self.name = name # Regular instance attribute self.age = age # Calls __set__() def birthday(self): self.age += 1 # Calls both __get__() and __set__()8 Buildin giúp bất cứ khi nào giao diện người dùng đã cấp quyền truy cập thuộc tính và sau đó các thay đổi tiếp theo yêu cầu sự can thiệp của phương thức. Chẳng hạn, một lớp bảng tính có thể cấp quyền truy cập vào giá trị ô thông qua class A: x = 5 # Regular class attribute y = Ten() # Descriptor instance76. Những cải tiến tiếp theo cho chương trình yêu cầu tế bào phải được tính toán lại trên mọi truy cập; Tuy nhiên, lập trình viên không muốn ảnh hưởng trực tiếp đến mã khách hàng hiện tại truy cập thuộc tính. Giải pháp là kết thúc quyền truy cập vào thuộc tính giá trị trong bộ mô tả dữ liệu thuộc tính: >>> a = A() # Make an instance of class A >>> a.x # Normal attribute lookup 5 >>> a.y # Descriptor lookup 104 Tương đương import logging logging.basicConfig(level=logging.INFO) class LoggedAgeAccess: def __get__(self, obj, objtype=None): value = obj._age logging.info('Accessing %r giving %r', 'age', value) return value def __set__(self, obj, value): logging.info('Updating %r to %r', 'age', value) obj._age = value class Person: age = LoggedAgeAccess() # Descriptor instance def __init__(self, name, age): self.name = name # Regular instance attribute self.age = age # Calls __set__() def birthday(self): self.age += 1 # Calls both __get__() and __set__()8 hoặc tương đương class A: x = 5 # Regular class attribute y = Ten() # Descriptor instance78 của chúng tôi sẽ hoạt động trong ví dụ này. Chức năng và Phương phápCác tính năng định hướng đối tượng Python sườn được xây dựng trên một môi trường dựa trên chức năng. Sử dụng các mô tả không dữ liệu, cả hai được hợp nhất liền mạch. Các chức năng được lưu trữ trong từ điển lớp được chuyển thành các phương thức khi được gọi. Các phương thức chỉ khác với các chức năng thông thường ở chỗ đối tượng được chuẩn bị cho các đối số khác. Theo quy ước, trường hợp được gọi là bản thân nhưng có thể được gọi là tên này hoặc bất kỳ tên biến nào khác. Các phương thức có thể được tạo thủ công với class A: x = 5 # Regular class attribute y = Ten() # Descriptor instance79 tương đương với: >>> a = A() # Make an instance of class A >>> a.x # Normal attribute lookup 5 >>> a.y # Descriptor lookup 105 Để hỗ trợ tạo tự động các phương thức, các chức năng bao gồm phương thức >>> mary = Person('Mary M', 30) # The initial age update is logged INFO:root:Updating 'age' to 30 >>> dave = Person('David D', 40) INFO:root:Updating 'age' to 40 >>> vars(mary) # The actual data is in a private attribute {'name': 'Mary M', '_age': 30} >>> vars(dave) {'name': 'David D', '_age': 40} >>> mary.age # Access the data and log the lookup INFO:root:Accessing 'age' giving 30 30 >>> mary.birthday() # Updates are logged as well INFO:root:Accessing 'age' giving 30 INFO:root:Updating 'age' to 31 >>> dave.name # Regular attribute lookup isn't logged 'David D' >>> dave.age # Only the managed attribute is logged INFO:root:Accessing 'age' giving 40 400 cho các phương thức liên kết trong quá trình truy cập thuộc tính. Điều này có nghĩa là các chức năng là các mô tả không phải là dữ liệu trả về các phương thức bị ràng buộc trong quá trình tra cứu chấm từ một trường hợp. Ở đây, cách thức hoạt động của nó: >>> a = A() # Make an instance of class A >>> a.x # Normal attribute lookup 5 >>> a.y # Descriptor lookup 106 Chạy lớp sau trong trình thông dịch cho thấy cách thức mô tả chức năng hoạt động trong thực tế: >>> a = A() # Make an instance of class A >>> a.x # Normal attribute lookup 5 >>> a.y # Descriptor lookup 107 Hàm có thuộc tính tên đủ điều kiện để hỗ trợ hướng nội:qualified name attribute to support introspection: >>> a = A() # Make an instance of class A >>> a.x # Normal attribute lookup 5 >>> a.y # Descriptor lookup 108 Truy cập chức năng thông qua từ điển lớp không gọi >>> mary = Person('Mary M', 30) # The initial age update is logged INFO:root:Updating 'age' to 30 >>> dave = Person('David D', 40) INFO:root:Updating 'age' to 40 >>> vars(mary) # The actual data is in a private attribute {'name': 'Mary M', '_age': 30} >>> vars(dave) {'name': 'David D', '_age': 40} >>> mary.age # Access the data and log the lookup INFO:root:Accessing 'age' giving 30 30 >>> mary.birthday() # Updates are logged as well INFO:root:Accessing 'age' giving 30 INFO:root:Updating 'age' to 31 >>> dave.name # Regular attribute lookup isn't logged 'David D' >>> dave.age # Only the managed attribute is logged INFO:root:Accessing 'age' giving 40 400. Thay vào đó, nó chỉ trả về đối tượng chức năng cơ bản: >>> a = A() # Make an instance of class A >>> a.x # Normal attribute lookup 5 >>> a.y # Descriptor lookup 109 Truy cập chấm từ một lớp gọi >>> mary = Person('Mary M', 30) # The initial age update is logged INFO:root:Updating 'age' to 30 >>> dave = Person('David D', 40) INFO:root:Updating 'age' to 40 >>> vars(mary) # The actual data is in a private attribute {'name': 'Mary M', '_age': 30} >>> vars(dave) {'name': 'David D', '_age': 40} >>> mary.age # Access the data and log the lookup INFO:root:Accessing 'age' giving 30 30 >>> mary.birthday() # Updates are logged as well INFO:root:Accessing 'age' giving 30 INFO:root:Updating 'age' to 31 >>> dave.name # Regular attribute lookup isn't logged 'David D' >>> dave.age # Only the managed attribute is logged INFO:root:Accessing 'age' giving 40 400 chỉ trả về chức năng cơ bản không thay đổi: import os class DirectorySize: def __get__(self, obj, objtype=None): return len(os.listdir(obj.dirname)) class Directory: size = DirectorySize() # Descriptor instance def __init__(self, dirname): self.dirname = dirname # Regular instance attribute0 Các hành vi thú vị xảy ra trong quá trình truy cập chấm từ một trường hợp. Tra cứu chấm chấm các cuộc gọi >>> mary = Person('Mary M', 30) # The initial age update is logged INFO:root:Updating 'age' to 30 >>> dave = Person('David D', 40) INFO:root:Updating 'age' to 40 >>> vars(mary) # The actual data is in a private attribute {'name': 'Mary M', '_age': 30} >>> vars(dave) {'name': 'David D', '_age': 40} >>> mary.age # Access the data and log the lookup INFO:root:Accessing 'age' giving 30 30 >>> mary.birthday() # Updates are logged as well INFO:root:Accessing 'age' giving 30 INFO:root:Updating 'age' to 31 >>> dave.name # Regular attribute lookup isn't logged 'David D' >>> dave.age # Only the managed attribute is logged INFO:root:Accessing 'age' giving 40 400 trả về một đối tượng phương thức ràng buộc: import os class DirectorySize: def __get__(self, obj, objtype=None): return len(os.listdir(obj.dirname)) class Directory: size = DirectorySize() # Descriptor instance def __init__(self, dirname): self.dirname = dirname # Regular instance attribute1 Trong nội bộ, phương thức ràng buộc lưu trữ chức năng cơ bản và thể hiện ràng buộc: import os class DirectorySize: def __get__(self, obj, objtype=None): return len(os.listdir(obj.dirname)) class Directory: size = DirectorySize() # Descriptor instance def __init__(self, dirname): self.dirname = dirname # Regular instance attribute2 Nếu bạn đã từng tự hỏi bản thân đến từ đâu trong các phương pháp thông thường hoặc CLS đến từ các phương pháp trong lớp, thì đây là nó! Các loại phương phápCác mô tả phi dữ liệu cung cấp một cơ chế đơn giản cho các biến thể trên các mẫu chức năng liên kết thông thường thành các phương thức. Để tóm tắt lại, các hàm có phương thức >>> mary = Person('Mary M', 30) # The initial age update is logged INFO:root:Updating 'age' to 30 >>> dave = Person('David D', 40) INFO:root:Updating 'age' to 40 >>> vars(mary) # The actual data is in a private attribute {'name': 'Mary M', '_age': 30} >>> vars(dave) {'name': 'David D', '_age': 40} >>> mary.age # Access the data and log the lookup INFO:root:Accessing 'age' giving 30 30 >>> mary.birthday() # Updates are logged as well INFO:root:Accessing 'age' giving 30 INFO:root:Updating 'age' to 31 >>> dave.name # Regular attribute lookup isn't logged 'David D' >>> dave.age # Only the managed attribute is logged INFO:root:Accessing 'age' giving 40 400 để chúng có thể được chuyển đổi thành phương thức khi được truy cập dưới dạng thuộc tính. Bộ mô tả không dữ liệu biến đổi cuộc gọi class A: x = 5 # Regular class attribute y = Ten() # Descriptor instance85 thành class A: x = 5 # Regular class attribute y = Ten() # Descriptor instance86. Gọi class A: x = 5 # Regular class attribute y = Ten() # Descriptor instance87 trở thành class A: x = 5 # Regular class attribute y = Ten() # Descriptor instance88. Biểu đồ này tóm tắt ràng buộc và hai biến thể hữu ích nhất của nó:
Phương pháp tĩnhCác phương thức tĩnh trả về chức năng cơ bản mà không thay đổi. Gọi class A: x = 5 # Regular class attribute y = Ten() # Descriptor instance89 hoặc class A: x = 5 # Regular class attribute y = Ten() # Descriptor instance90 tương đương với việc tra cứu trực tiếp vào class A: x = 5 # Regular class attribute y = Ten() # Descriptor instance91 hoặc class A: x = 5 # Regular class attribute y = Ten() # Descriptor instance92. Kết quả là, hàm trở nên có thể truy cập giống hệt nhau từ một đối tượng hoặc một lớp. Các ứng cử viên tốt cho các phương pháp tĩnh là các phương pháp không tham chiếu biến class A: x = 5 # Regular class attribute y = Ten() # Descriptor instance93. Chẳng hạn, gói thống kê có thể bao gồm một lớp container cho dữ liệu thử nghiệm. Lớp cung cấp các phương pháp bình thường để tính toán trung bình, trung bình, trung bình và các số liệu thống kê mô tả khác phụ thuộc vào dữ liệu. Tuy nhiên, có thể có các chức năng hữu ích có liên quan về mặt khái niệm nhưng không phụ thuộc vào dữ liệu. Ví dụ, class A: x = 5 # Regular class attribute y = Ten() # Descriptor instance94 là thói quen chuyển đổi tiện dụng xuất hiện trong công việc thống kê nhưng không phụ thuộc trực tiếp vào một bộ dữ liệu cụ thể. Nó có thể được gọi từ một đối tượng hoặc lớp: class A: x = 5 # Regular class attribute y = Ten() # Descriptor instance95 hoặc class A: x = 5 # Regular class attribute y = Ten() # Descriptor instance96. Vì các phương thức tĩnh trả về chức năng cơ bản mà không có thay đổi, các cuộc gọi ví dụ không thể chịu đựng được: import os class DirectorySize: def __get__(self, obj, objtype=None): return len(os.listdir(obj.dirname)) class Directory: size = DirectorySize() # Descriptor instance def __init__(self, dirname): self.dirname = dirname # Regular instance attribute3 import os class DirectorySize: def __get__(self, obj, objtype=None): return len(os.listdir(obj.dirname)) class Directory: size = DirectorySize() # Descriptor instance def __init__(self, dirname): self.dirname = dirname # Regular instance attribute4 Sử dụng giao thức mô tả không dữ liệu, phiên bản Python thuần túy của import logging logging.basicConfig(level=logging.INFO) class LoggedAgeAccess: def __get__(self, obj, objtype=None): value = obj._age logging.info('Accessing %r giving %r', 'age', value) return value def __set__(self, obj, value): logging.info('Updating %r to %r', 'age', value) obj._age = value class Person: age = LoggedAgeAccess() # Descriptor instance def __init__(self, name, age): self.name = name # Regular instance attribute self.age = age # Calls __set__() def birthday(self): self.age += 1 # Calls both __get__() and __set__()7 sẽ trông như thế này: import os class DirectorySize: def __get__(self, obj, objtype=None): return len(os.listdir(obj.dirname)) class Directory: size = DirectorySize() # Descriptor instance def __init__(self, dirname): self.dirname = dirname # Regular instance attribute5 Phương pháp lớpKhông giống như các phương thức tĩnh, các phương thức lớp dành cho tham chiếu lớp vào danh sách đối số trước khi gọi hàm. Định dạng này giống nhau cho dù người gọi là đối tượng hay một lớp: import os class DirectorySize: def __get__(self, obj, objtype=None): return len(os.listdir(obj.dirname)) class Directory: size = DirectorySize() # Descriptor instance def __init__(self, dirname): self.dirname = dirname # Regular instance attribute6 import os class DirectorySize: def __get__(self, obj, objtype=None): return len(os.listdir(obj.dirname)) class Directory: size = DirectorySize() # Descriptor instance def __init__(self, dirname): self.dirname = dirname # Regular instance attribute7 Hành vi này rất hữu ích bất cứ khi nào phương thức chỉ cần có tham chiếu lớp và không dựa vào dữ liệu được lưu trữ trong một trường hợp cụ thể. Một cách sử dụng cho các phương thức lớp là tạo các hàm tạo lớp thay thế. Ví dụ: ClassMethod class A: x = 5 # Regular class attribute y = Ten() # Descriptor instance98 tạo ra một từ điển mới từ danh sách các khóa. Tương đương Python thuần túy là: import os class DirectorySize: def __get__(self, obj, objtype=None): return len(os.listdir(obj.dirname)) class Directory: size = DirectorySize() # Descriptor instance def __init__(self, dirname): self.dirname = dirname # Regular instance attribute8 Bây giờ, một từ điển mới của các khóa độc đáo có thể được xây dựng như thế này: import os class DirectorySize: def __get__(self, obj, objtype=None): return len(os.listdir(obj.dirname)) class Directory: size = DirectorySize() # Descriptor instance def __init__(self, dirname): self.dirname = dirname # Regular instance attribute9 Sử dụng giao thức mô tả không dữ liệu, phiên bản Python thuần túy của import logging logging.basicConfig(level=logging.INFO) class LoggedAgeAccess: def __get__(self, obj, objtype=None): value = obj._age logging.info('Accessing %r giving %r', 'age', value) return value def __set__(self, obj, value): logging.info('Updating %r to %r', 'age', value) obj._age = value class Person: age = LoggedAgeAccess() # Descriptor instance def __init__(self, name, age): self.name = name # Regular instance attribute self.age = age # Calls __set__() def birthday(self): self.age += 1 # Calls both __get__() and __set__()6 sẽ trông như thế này: >>> s = Directory('songs') >>> g = Directory('games') >>> s.size # The songs directory has twenty files 20 >>> g.size # The games directory has three files 3 >>> os.remove('games/chess') # Delete a game >>> g.size # File count is automatically updated 20 Đường dẫn mã cho >>> a = A() # Make an instance of class A >>> a.x # Normal attribute lookup 5 >>> a.y # Descriptor lookup 1000 đã được thêm vào Python 3.9 và giúp import logging logging.basicConfig(level=logging.INFO) class LoggedAgeAccess: def __get__(self, obj, objtype=None): value = obj._age logging.info('Accessing %r giving %r', 'age', value) return value def __set__(self, obj, value): logging.info('Updating %r to %r', 'age', value) obj._age = value class Person: age = LoggedAgeAccess() # Descriptor instance def __init__(self, name, age): self.name = name # Regular instance attribute self.age = age # Calls __set__() def birthday(self): self.age += 1 # Calls both __get__() and __set__()6 có thể hỗ trợ các nhà trang trí xích. Ví dụ, một lớp học và thuộc tính có thể được xích lại với nhau: >>> s = Directory('songs') >>> g = Directory('games') >>> s.size # The songs directory has twenty files 20 >>> g.size # The games directory has three files 3 >>> os.remove('games/chess') # Delete a game >>> g.size # File count is automatically updated 21 >>> s = Directory('songs') >>> g = Directory('games') >>> s.size # The songs directory has twenty files 20 >>> g.size # The games directory has three files 3 >>> os.remove('games/chess') # Delete a game >>> g.size # File count is automatically updated 22 Đối tượng thành viên và __Slots__¶Khi một lớp xác định >>> a = A() # Make an instance of class A >>> a.x # Normal attribute lookup 5 >>> a.y # Descriptor lookup 1002, nó thay thế từ điển thể hiện bằng một mảng giá trị khe có độ dài cố định. Từ quan điểm của người dùng có một số hiệu ứng: 1. Cung cấp phát hiện ngay các lỗi do các bài tập thuộc tính sai chính tả. Chỉ cho phép các tên thuộc tính được chỉ định trong >>> a = A() # Make an instance of class A >>> a.x # Normal attribute lookup 5 >>> a.y # Descriptor lookup 1002: >>> s = Directory('songs') >>> g = Directory('games') >>> s.size # The songs directory has twenty files 20 >>> g.size # The games directory has three files 3 >>> os.remove('games/chess') # Delete a game >>> g.size # File count is automatically updated 23 >>> s = Directory('songs') >>> g = Directory('games') >>> s.size # The songs directory has twenty files 20 >>> g.size # The games directory has three files 3 >>> os.remove('games/chess') # Delete a game >>> g.size # File count is automatically updated 24 2. Giúp tạo các đối tượng bất biến trong đó các mô tả quản lý quyền truy cập vào các thuộc tính riêng được lưu trữ trong >>> a = A() # Make an instance of class A >>> a.x # Normal attribute lookup 5 >>> a.y # Descriptor lookup 1002: >>> s = Directory('songs') >>> g = Directory('games') >>> s.size # The songs directory has twenty files 20 >>> g.size # The games directory has three files 3 >>> os.remove('games/chess') # Delete a game >>> g.size # File count is automatically updated 25 >>> s = Directory('songs') >>> g = Directory('games') >>> s.size # The songs directory has twenty files 20 >>> g.size # The games directory has three files 3 >>> os.remove('games/chess') # Delete a game >>> g.size # File count is automatically updated 26 3. Lưu bộ nhớ. Trên bản dựng Linux 64 bit, một thể hiện với hai thuộc tính mất 48 byte với >>> a = A() # Make an instance of class A >>> a.x # Normal attribute lookup 5 >>> a.y # Descriptor lookup 1002 và 152 byte mà không có. Mô hình thiết kế hạng nặng này có thể chỉ quan trọng khi một số lượng lớn các trường hợp sẽ được tạo ra. 4. Cải thiện tốc độ. Đọc các biến thể hiện nhanh hơn 35% với >>> a = A() # Make an instance of class A >>> a.x # Normal attribute lookup 5 >>> a.y # Descriptor lookup 1002 (được đo bằng Python 3.10 trên bộ xử lý Apple M1). 5. Khối các công cụ như >>> vars(vars(Person)['name']) {'public_name': 'name', 'private_name': '_name'} >>> vars(vars(Person)['age']) {'public_name': 'age', 'private_name': '_age'}7 yêu cầu từ điển thể hiện để hoạt động chính xác: >>> s = Directory('songs') >>> g = Directory('games') >>> s.size # The songs directory has twenty files 20 >>> g.size # The games directory has three files 3 >>> os.remove('games/chess') # Delete a game >>> g.size # File count is automatically updated 27 >>> s = Directory('songs') >>> g = Directory('games') >>> s.size # The songs directory has twenty files 20 >>> g.size # The games directory has three files 3 >>> os.remove('games/chess') # Delete a game >>> g.size # File count is automatically updated 28 Không thể tạo phiên bản Python thuần túy chính xác của >>> a = A() # Make an instance of class A >>> a.x # Normal attribute lookup 5 >>> a.y # Descriptor lookup 1002 vì nó yêu cầu truy cập trực tiếp vào các cấu trúc C và kiểm soát phân bổ bộ nhớ đối tượng. Tuy nhiên, chúng ta có thể xây dựng một mô phỏng chủ yếu là trung thành trong đó cấu trúc C thực tế cho các vị trí được mô phỏng bởi một danh sách >>> a = A() # Make an instance of class A >>> a.x # Normal attribute lookup 5 >>> a.y # Descriptor lookup 1009 riêng tư. Đọc và ghi vào cấu trúc riêng được quản lý bởi các mô tả thành viên: >>> s = Directory('songs') >>> g = Directory('games') >>> s.size # The songs directory has twenty files 20 >>> g.size # The games directory has three files 3 >>> os.remove('games/chess') # Delete a game >>> g.size # File count is automatically updated 29 Phương thức class A: x = 5 # Regular class attribute y = Ten() # Descriptor instance69 chăm sóc việc thêm các đối tượng thành viên vào các biến lớp: import logging logging.basicConfig(level=logging.INFO) class LoggedAgeAccess: def __get__(self, obj, objtype=None): value = obj._age logging.info('Accessing %r giving %r', 'age', value) return value def __set__(self, obj, value): logging.info('Updating %r to %r', 'age', value) obj._age = value class Person: age = LoggedAgeAccess() # Descriptor instance def __init__(self, name, age): self.name = name # Regular instance attribute self.age = age # Calls __set__() def birthday(self): self.age += 1 # Calls both __get__() and __set__()0 Phương pháp >>> a = A() # Make an instance of class A >>> a.x # Normal attribute lookup 5 >>> a.y # Descriptor lookup 1011 chăm sóc việc tạo các trường hợp có vị trí thay vì từ điển thể hiện. Dưới đây là một mô phỏng thô trong Python thuần túy: import logging logging.basicConfig(level=logging.INFO) class LoggedAgeAccess: def __get__(self, obj, objtype=None): value = obj._age logging.info('Accessing %r giving %r', 'age', value) return value def __set__(self, obj, value): logging.info('Updating %r to %r', 'age', value) obj._age = value class Person: age = LoggedAgeAccess() # Descriptor instance def __init__(self, name, age): self.name = name # Regular instance attribute self.age = age # Calls __set__() def birthday(self): self.age += 1 # Calls both __get__() and __set__()1 Để sử dụng mô phỏng trong một lớp thực, chỉ cần kế thừa từ >>> a = A() # Make an instance of class A >>> a.x # Normal attribute lookup 5 >>> a.y # Descriptor lookup 1012 và đặt metaclass thành >>> a = A() # Make an instance of class A >>> a.x # Normal attribute lookup 5 >>> a.y # Descriptor lookup 1013:metaclass to >>> a = A() # Make an instance of class A >>> a.x # Normal attribute lookup 5 >>> a.y # Descriptor lookup 1013: import logging logging.basicConfig(level=logging.INFO) class LoggedAgeAccess: def __get__(self, obj, objtype=None): value = obj._age logging.info('Accessing %r giving %r', 'age', value) return value def __set__(self, obj, value): logging.info('Updating %r to %r', 'age', value) obj._age = value class Person: age = LoggedAgeAccess() # Descriptor instance def __init__(self, name, age): self.name = name # Regular instance attribute self.age = age # Calls __set__() def birthday(self): self.age += 1 # Calls both __get__() and __set__()2 Tại thời điểm này, Metaclass đã tải các đối tượng thành viên cho X và Y: import logging logging.basicConfig(level=logging.INFO) class LoggedAgeAccess: def __get__(self, obj, objtype=None): value = obj._age logging.info('Accessing %r giving %r', 'age', value) return value def __set__(self, obj, value): logging.info('Updating %r to %r', 'age', value) obj._age = value class Person: age = LoggedAgeAccess() # Descriptor instance def __init__(self, name, age): self.name = name # Regular instance attribute self.age = age # Calls __set__() def birthday(self): self.age += 1 # Calls both __get__() and __set__()3 Khi các phiên bản được tạo, chúng có danh sách >>> a = A() # Make an instance of class A >>> a.x # Normal attribute lookup 5 >>> a.y # Descriptor lookup 1014 trong đó các thuộc tính được lưu trữ: import logging logging.basicConfig(level=logging.INFO) class LoggedAgeAccess: def __get__(self, obj, objtype=None): value = obj._age logging.info('Accessing %r giving %r', 'age', value) return value def __set__(self, obj, value): logging.info('Updating %r to %r', 'age', value) obj._age = value class Person: age = LoggedAgeAccess() # Descriptor instance def __init__(self, name, age): self.name = name # Regular instance attribute self.age = age # Calls __set__() def birthday(self): self.age += 1 # Calls both __get__() and __set__()4 Các thuộc tính sai chính tả hoặc không được chỉ định sẽ tăng một ngoại lệ: import logging logging.basicConfig(level=logging.INFO) class LoggedAgeAccess: def __get__(self, obj, objtype=None): value = obj._age logging.info('Accessing %r giving %r', 'age', value) return value def __set__(self, obj, value): logging.info('Updating %r to %r', 'age', value) obj._age = value class Person: age = LoggedAgeAccess() # Descriptor instance def __init__(self, name, age): self.name = name # Regular instance attribute self.age = age # Calls __set__() def birthday(self): self.age += 1 # Calls both __get__() and __set__()5 |