Python类属性点表示法：__init__同名参数作属性为何不报错？

Great question—this is such a common "wait, why doesn't this break?" moment when learning Python classes, so let's unpack it clearly.

The core reason: Python's namespace system #

The short answer is that Python keeps variables in separate "containers" called namespaces, so the parameter and the instance attribute never actually collide. Here's the breakdown:

• The name parameter (or whatever you call it) lives in the local namespace of the __init__ function. It's a temporary variable only accessible while that function runs.
• self.name refers to an instance attribute, which lives in the unique namespace of the specific Cat object being created (stored in the object's __dict__ by default).

These are two completely separate entities. Assigning self.name = name is just copying the value from the temporary parameter into the instance's permanent attribute storage—no conflict, no error.

To see this in action, try running this quick test:

class Cat:
    def __init__(self, name):
        # Print local variables (includes the 'name' parameter)
        print("Local namespace:", locals())
        self.name = name
        # Print the instance's stored attributes
        print("Instance namespace:", self.__dict__)

my_cat = Cat("Whiskers")

You'll get output like this, showing the two separate storage areas:

Local namespace: {'self': <main.Cat object at 0x102345678>, 'name': 'Whiskers'}
Instance namespace: {'name': 'Whiskers'}

Why the "same name" convention is industry standard #

You noted this is the common practice, and it's popular for good reasons:

• Clarity: Anyone reading the code immediately knows the name parameter maps directly to the name attribute of the Cat instance. No mental work needed to remember "oh, cat_name becomes self.name".
• Brevity: It avoids unnecessary verbose names like input_name or cat_name while keeping the code readable and direct.

Comparing the three common Cat class styles #

Since you mentioned three different definitions, let's break down the pros and cons of the most common variations:

1. Standard same-name approach (the industry default):

   class Cat:
       def __init__(self, name):
           self.name = name
   

   Pros: Clean, explicit, and universally understood by Python developers. No confusion once you grasp namespaces.

2. Different parameter name:

   class Cat:
       def __init__(self, cat_name):
           self.name = cat_name
   

   Pros: Might feel safer if you're still learning namespaces. Cons: Adds unnecessary cognitive load—readers have to connect cat_name to self.name instead of seeing a direct match.

3. Underscore-prefixed attribute (for encapsulation):

   class Cat:
       def __init__(self, name):
           self._name = name
   

   Pros: Signals that _name is an internal attribute (not meant to be modified directly by external code). Cons: Still uses the same parameter name, but the attribute has a prefix—this is about encapsulation, not avoiding name conflicts.

A quick note on "shadowing" #

Could this ever cause an issue? The only time you might run into unexpected behavior is if you modify the local parameter before assigning it to the instance attribute, like this:

class Cat:
    def __init__(self, name):
        name = "Fluffy"  # This changes the local parameter, not the instance attribute
        self.name = name  # Now self.name will be "Fluffy", not the original input

But this isn't a conflict—it's just a choice you're making as a developer. Python doesn't block this, but it's something to be aware of.

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