询问__list__属性及类实例直接获取内部列表的实现方法

Hey there! Let's break down your two questions with clear, practical answers:

Question 1: What's the lowdown on __list__ in Python? #

First, a quick clarification: Python doesn't have a built-in special attribute or method called __list__ — it’s likely you mixed it up with other list-related functionality. Here’s what you need to know:

• If you want a custom object to be convertible to a list using list(), you’ll need to implement either the __iter__() method (returns an iterator) or __getitem__() (supports subscript access) — there’s no __list__ method for this purpose.
• For Python’s built-in list class, these are key special methods/attributes you’ll use regularly:
  • __len__(): Returns the list length (used when you call len(my_list))
  • __getitem__(index): Fetches the element at a given index (triggers when you do my_list[index])
  • __setitem__(index, value): Updates an element at a given index (runs for my_list[index] = value)
  • __iter__(): Returns an iterator for the list (enables for loop traversal)
  • __contains__(item): Checks if an item exists in the list (used for item in my_list)

Question 2: Access a class's internal list directly from an instance (no method calls needed) #

There are a few straightforward ways to make this work, depending on whether you want to protect the internal list from external changes:

Option 1: Public instance attribute (simplest approach)

If you don’t mind external code modifying the original list, just assign it directly as a public attribute in the class constructor:

class Successors:  # Note: Python convention uses PascalCase for class names
    def __init__(self):
        self.successors = [1, 2, 3, 4]

# Usage example
neighbour = Successors()
print(neighbour.successors)  # Output: [1, 2, 3, 4]

Option 2: Use a property to return a copy (protect the original list)

To prevent external code from altering the internal list, use a property decorator to return a copy of the list instead of the original:

class Successors:
    def __init__(self):
        self._successors = [1, 2, 3, 4]  # Leading underscore signals "private" by convention

    @property
    def successors(self):
        return self._successors.copy()  # Return a copy so external changes don't affect the original

# Usage example
neighbour = Successors()
print(neighbour.successors)  # Output: [1, 2, 3, 4]
neighbour.successors.append(5)
print(neighbour.successors)  # Still outputs [1, 2, 3, 4] — original list is untouched

Option 3: Dynamic attribute handling with __getattr__

If you want to handle attribute access dynamically (e.g., for multiple fallback attributes), use __getattr__ — this method runs when an attribute isn’t found directly on the instance:

class Successors:
    def __init__(self):
        self._successors = [1, 2, 3, 4]

    def __getattr__(self, name):
        if name == 'successors':
            return self._successors
        raise AttributeError(f"'Successors' object has no attribute '{name}'")

# Usage example
neighbour = Successors()
print(neighbour.successors)  # Output: [1, 2, 3, 4]

Bonus: Make the instance iterable (loop like a list)

If you also want to iterate over the instance directly (instead of accessing the list), implement the __iter__ method:

class Successors:
    def __init__(self):
        self._successors = [1, 2, 3, 4]

    def __iter__(self):
        return iter(self._successors)

# Usage example
neighbour = Successors()
for num in neighbour:
    print(num)  # Prints 1, 2, 3, 4 in order
print(list(neighbour))  # Output: [1, 2, 3, 4]

内容的提问来源于stack exchange，提问作者Bartholomas