self 是什么函数是对动作的抽象,类是对数据和行为的封装。当你需要"把相关的数据和操作这些数据的函数绑在一起"时,就需要类。
// ES6 class
class User {
constructor(name, email) {
this.name = name;
this.email = email;
}
greet() {
return `Hello, I'm ${this.name}`;
}
}
const alice = new User('Alice', 'alice@example.com');
console.log(alice.greet());
class User:
def __init__(self, name, email):
self.name = name
self.email = email
def greet(self):
return f"Hello, I'm {self.name}"
alice = User('Alice', 'alice@example.com')
print(alice.greet())
class Dog:
# 类变量(所有实例共享)
species = 'Canis lupus familiaris'
# 初始化方法(构造函数)
def __init__(self, name, age):
# 实例变量(每个实例独有)
self.name = name
self.age = age
# 实例方法
def bark(self):
return f"{self.name}: Woof!"
# 魔术方法:打印时显示
def __str__(self):
return f"{self.name} ({self.age}岁)"
# 创建实例
my_dog = Dog('旺财', 3)
print(my_dog.bark()) # 旺财: Woof!
print(my_dog) # 旺财 (3岁)
print(my_dog.species) # Canis lupus familiaris
self 是 Python 的惯例,代表实例本身。调用 my_dog.bark() 时,Python 自动翻译成 Dog.bark(my_dog)。
class Dog {
constructor(name) {
this.name = name; // this = 实例
}
bark() {
return `${this.name}: Woof!`;
}
}
const dog = new Dog('旺财');
dog.bark(); // this 自动绑定
class Dog:
def __init__(self, name):
self.name = name # self = 实例
def bark(self):
return f"{self.name}: Woof!"
dog = Dog('旺财')
dog.bark() # 自动翻译成 Dog.bark(dog)
self,JS 的 this 是隐式的。这是 Python 和 JS 类的最大区别。
| 类变量 | 实例变量 | |
|---|---|---|
| 定义位置 | 类内部,方法外部 | __init__ 里 |
| 共享性 | 所有实例共享 | 每个实例独有 |
| 修改影响 | 影响所有实例 | 只影响当前实例 |
| 例子 | species | name, age |
class Dog:
species = 'Canis lupus familiaris' # 类变量
dog1 = Dog('旺财', 3)
dog2 = Dog('来福', 5)
print(dog1.species) # Canis lupus familiaris
print(dog2.species) # Canis lupus familiaris
# 修改类变量
Dog.species = 'Dog'
print(dog1.species) # Dog
print(dog2.species) # Dog
# 父类
class Animal:
def __init__(self, name):
self.name = name
def speak(self):
raise NotImplementedError("子类必须实现这个方法")
# 子类
class Dog(Animal):
def speak(self):
return f"{self.name}: Woof!"
class Cat(Animal):
def speak(self):
return f"{self.name}: Meow!"
dog = Dog('旺财')
cat = Cat('咪咪')
print(dog.speak()) # 旺财: Woof!
print(cat.speak()) # 咪咪: Meow!
class Animal:
def __init__(self, name, species):
self.name = name
self.species = species
def info(self):
return f"{self.name} ({self.species})"
class Dog(Animal):
def __init__(self, name, breed):
# 调用父类构造函数
super().__init__(name, species='Dog')
self.breed = breed # 子类自己的属性
def info(self):
# 调用父类方法
base_info = super().info()
return f"{base_info}, 品种: {self.breed}"
dog = Dog('旺财', '金毛')
print(dog.info()) # 旺财 (Dog), 品种: 金毛
Python 支持多重继承,但要小心方法解析顺序(MRO)。
class A:
def hello(self):
print('A')
class B(A):
def hello(self):
print('B')
super().hello()
class C(A):
def hello(self):
print('C')
super().hello()
class D(B, C):
def hello(self):
print('D')
super().hello()
d = D()
d.hello()
# 输出:
# D
# B
# C
# A
# 查看 MRO
print(D.__mro__)
# (<class 'D'>, <class 'B'>, <class 'C'>, <class 'A'>, <class 'object'>)
魔术方法是以双下划线开头和结尾的特殊方法,让你的类支持 Python 的内置操作。
| 魔术方法 | 触发时机 | 例子 |
|---|---|---|
__init__ | 创建实例时 | MyClass() |
__str__ | print() 时 | print(obj) |
__repr__ | 交互式输出时 | >>> obj |
__len__ | len() 时 | len(obj) |
__getitem__ | 索引访问时 | obj[0] |
__call__ | 实例当函数调用时 | obj() |
__add__ | + 运算时 | obj1 + obj2 |
class Vector:
def __init__(self, x, y):
self.x = x
self.y = y
def __str__(self):
return f"Vector({self.x}, {self.y})"
def __add__(self, other):
return Vector(self.x + other.x, self.y + other.y)
def __len__(self):
# 返回向量长度
return int((self.x**2 + self.y**2)**0.5)
def __getitem__(self, index):
if index == 0:
return self.x
elif index == 1:
return self.y
raise IndexError("向量只有两个维度")
v1 = Vector(3, 4)
v2 = Vector(1, 2)
print(v1) # Vector(3, 4)
print(v1 + v2) # Vector(4, 6)
print(len(v1)) # 5
print(v1[0]) # 3
print(v1[1]) # 4
@property 让方法像属性一样访问,常用于计算属性和校验。
class Circle:
def __init__(self, radius):
self._radius = radius # 约定:下划线表示私有
@property
def radius(self):
return self._radius
@radius.setter
def radius(self, value):
if value < 0:
raise ValueError("半径不能为负数")
self._radius = value
@property
def area(self):
return 3.14159 * self._radius ** 2
c = Circle(5)
print(c.radius) # 5(像属性一样访问)
print(c.area) # 78.53975(计算属性)
c.radius = 10 # 触发 setter
print(c.area) # 314.159
c.radius = -1 # 抛出 ValueError
抽象基类定义接口,子类必须实现特定方法。
from abc import ABC, abstractmethod
class Shape(ABC):
@abstractmethod
def area(self):
pass
@abstractmethod
def perimeter(self):
pass
class Rectangle(Shape):
def __init__(self, width, height):
self.width = width
self.height = height
def area(self):
return self.width * self.height
def perimeter(self):
return 2 * (self.width + self.height)
# Shape 不能实例化
# Shape() # TypeError
# 子类必须实现所有抽象方法
class Circle(Shape):
def area(self):
return 3.14 * self.radius ** 2
# 忘记实现 perimeter()
# Circle() # TypeError: Can't instantiate abstract class
class User:
# 类变量
user_count = 0
def __init__(self, name):
self.name = name
User.user_count += 1
# 实例方法:第一个参数是 self
def greet(self):
return f"Hi, I'm {self.name}"
# 类方法:第一个参数是 cls
@classmethod
def from_string(cls, user_str):
name = user_str.split(',')[0]
return cls(name)
# 静态方法:没有强制的第一个参数
@staticmethod
def is_valid_name(name):
return len(name) > 0
# 使用
u1 = User('Alice')
u2 = User.from_string('Bob, bob@example.com')
print(u1.greet()) # Hi, I'm Alice
print(u2.name) # Bob
print(User.user_count) # 2
print(User.is_valid_name('')) # False
写一个 Book 类,有 title、author、pages 属性,能显示信息。
class Book:
def __init__(self, title, author, pages):
self.title = title
self.author = author
self.pages = pages
def __str__(self):
return f"《{self.title}》- {self.author} ({self.pages}页)"
def __len__(self):
return self.pages
book = Book('Python编程', 'Guido', 500)
print(book) # 《Python编程》- Guido (500页)
print(len(book)) # 500
写一个 Student 类继承 Person,加 grade 属性。
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
def introduce(self):
return f"我叫 {self.name},今年 {self.age} 岁"
class Student(Person):
def __init__(self, name, age, grade):
super().__init__(name, age)
self.grade = grade
def introduce(self):
base = super().introduce()
return f"{base},读 {self.grade} 年级"
stu = Student('小明', 12, 6)
print(stu.introduce()) # 我叫 小明,今年 12 岁,读 6 年级
实现一个栈(Stack),支持 push、pop、peek。
class Stack:
def __init__(self):
self.items = []
def push(self, item):
self.items.append(item)
def pop(self):
if not self.items:
raise IndexError("栈为空")
return self.items.pop()
def peek(self):
if not self.items:
raise IndexError("栈为空")
return self.items[-1]
def __len__(self):
return len(self.items)
def __str__(self):
return f"Stack({self.items})"
s = Stack()
s.push(1)
s.push(2)
s.push(3)
print(s) # Stack([1, 2, 3])
print(s.peek()) # 3
print(s.pop()) # 3
print(len(s)) # 2
实现一个 Counter 类,每次调用实例就加 1。
class Counter:
def __init__(self):
self.count = 0
def __call__(self):
self.count += 1
return self.count
def __str__(self):
return f"Counter: {self.count}"
c = Counter()
print(c()) # 1
print(c()) # 2
print(c()) # 3
print(c) # Counter: 3
self 是什么super() 调用父类方法__init__、__str__、__len__ 的作用@classmethod 和 @staticmethod+、len()、索引访问的类