Great question—this is a super common gotcha when trying to replace built-in types in Python! Let’s break down why your current approach isn’t working, then fix it for both lists and dictionaries.

Why [] Isn’t Using Your CustomList #

When you do list = CustomList, you’re only replacing the list name in your current namespace. The square bracket [] literal syntax doesn’t look up the global list variable at all—it’s hardwired into the Python interpreter to call the original built-in list constructor directly. That’s exactly why isinstance([], list) returns False: [] is still spawning a native list, while list() uses your custom subclass.

Fixing List Literals ([]) #

To make [] create instances of your CustomList, you need to replace the actual built-in list type in Python’s builtins module. Here’s how to do it safely (well, as safely as modifying built-ins gets):

import builtins

class CustomList(list):
    # Add your custom functionality here—e.g., override methods
    def append(self, item):
        print(f"Adding {item} to the list!")
        super().append(item)

# Replace the built-in list with our CustomList
builtins.list = CustomList

Now test it out:

# Both creation methods now use CustomList
print(isinstance(list(), CustomList))  # True
print(isinstance([1, 2, 3], CustomList))  # True
print(isinstance([], list))  # True (since `list` now points to CustomList)

# Custom method works for both
my_list = []
my_list.append("test")  # Prints "Adding test to the list!"

Monkey-Patching Dict Literals ({}) #

The exact same logic applies to dictionaries. If you want {} to create instances of a custom dict subclass, replace the built-in dict in builtins:

import builtins

class CustomDict(dict):
    # Example custom behavior: case-insensitive key lookup
    def __getitem__(self, key):
        if isinstance(key, str):
            key = key.lower()
        return super().__getitem__(key)

builtins.dict = CustomDict

Test this:

my_dict = {"Name": "Alice"}
print(isinstance(my_dict, CustomDict))  # True
print(my_dict["name"])  # Outputs "Alice" (thanks to case-insensitive lookup)

Important Things to Keep in Mind #

Modifying built-in types is powerful but comes with risks—here’s what to watch out for:

• Global side effects: Every piece of code running in the same interpreter session (including third-party libraries) will use your custom types. If a library relies on the original behavior of list or dict, this could break things unexpectedly.
• Inherited methods: Methods that return new lists/dicts (like list.copy(), dict.fromkeys(), or even list + list) will still return instances of the original built-in type unless you override them. For example:

  lst = [1, 2, 3]
  copied = lst.copy()
  print(isinstance(copied, CustomList))  # False by default
  

  Fix this by overriding those methods in your subclass:

  class CustomList(list):
      def copy(self):
          return CustomList(self)
      def __add__(self, other):
          return CustomList(super().__add__(other))
  

• Environment limitations: In some restricted environments (like frozen executables or certain Python implementations), modifying builtins might not be allowed or could cause crashes.

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