Python类方法和属性的混淆解析：十个示例

原创红太狼 2025-03-05 03:03 7阅读 0赞

在Python编程中，类方法（Class Method）和属性（Attribute）是两种不同的概念。以下是这两种情况的十个示例，帮助你理解它们的区别：

1. **普通方法**：
```python
class MyClass:
    def my_method(self, arg):
        return self, arg

obj = MyClass()
result = obj.my_method('test')
print(result)  # Output: (<__main__.MyClass object at 0x7f9234568d>, 'test')
```
2. **类方法**：
```python
class MyClass:
    @classmethod
    def class_method(cls, arg):
        return cls, arg

# 使用类方法
result = MyClass.class_method('test')
print(result)  # Output: (<__main__.MyClass object at 0x7f9234568d>, 'test')
```
3. **实例属性**：
```python
class MyClass:
    def __init__(self, value):
        self.value = value

obj = MyClass('default value')
print(obj.value)  # Output: default value
```
4. **类属性（静态变量）**：
```python
class MyClass:
    _static_value = 'shared'

@classmethod
    def get_static_value(cls):
        return cls._static_value

obj1 = MyClass()
obj2 = MyClass()

print(obj1.get_static_value())  # Output: shared
print(obj2.get_static_value())  # Output: shared
```
5. **继承属性和方法**：
```python
class Parent:
    def parent_method(self, arg):
        return f"Parent: {arg}"

class Child(Parent):
    def child_method(self, arg):
        return f"Child: {arg}"

# 继承并调用父类方法
parent_obj = Parent()
child_obj = Child()

print(parent_obj.parent_method('arg for parent')))  # Output: Parent: arg for parent
print(child_obj.parent_method('arg for child through parent'))))  # Output: Parent: arg for child through parent
```
6. **实例属性和类方法的区别**：
```python
class MyClass:
    def class_method(self, arg):
        return f"Class Method: {arg}"

obj = MyClass()
print(obj.class_method('arg for class method'))))  # Output: Class Method: arg for class method

# 通过对象调用类方法
custom_result = obj.class_method('arg through instance')
print(custom_result))  # Output: Class Method: arg through instance
```
7. **属性和私有方法的区别**：
```python
class MyClass:
    def __init__(self, value):
        self.value = value

@property
    def public_attribute(self):
        return f"Public Attribute: {self.value}"

# 私有方法，外部无法直接访问
    def private_method(self, arg):
        return f"Private Method: {arg}"

obj = MyClass('default value')
print(obj.public_attribute))  # Output: Public Attribute: default value

# 通过对象调用私有方法
custom_private_result = obj.private_method('arg for private method')
print(custom_private_result))  # Output: Private Method: arg for private method
```
8. **继承属性和自定义属性的区别**：
```python
class Parent:
    attr1 = 'Parent Attribute 1'

class Child(Parent):
    # 自定义属性
    custom_attr2 = 'Child Custom Attribute 2'

# 继承属性
child_obj = Child()
print(child_obj.attr1))  # Output: Parent Attribute 1

# 自定义属性
print(child_obj.custom_attr2))  # Output: Child Custom Attribute 2
```
9. **类方法与静态方法的区别**：
```python
class MyClass:
    @classmethod
    def class_method(cls, arg):
        return f"Class Method: {arg}"

@staticmethod
    def static_method(arg):
        return f"Static Method: {arg}"

# 调用类方法
result_class_method = MyClass.class_method('arg for class method')
print(result_class_method))  # Output: Class Method: arg for class method

# 调用静态方法
result_static_method = MyClass.static_method('arg for static method'))
print(result_static_method))  # Output: Static Method: arg for static method
```
10. **属性和变量的区别**：
```python
class MyClass:
    def __init__(self, value):
        self.value = value

# 属性，可以通过对象访问
obj = MyClass('default value')
print(obj.value)  # Output: default value

# 变量，Python中的变量名是区分大小写的
my_value = 'modified value'
print(my_value)  # Output: modified value

# 注意，属性和变量在概念上是有区别的：
# - 属性是对象的一部分，通常通过点（.）操作符访问。
# - 变量则是存储值的容器，可以在程序中多次赋值。

```