Python 中的类class实例详解
更新时间:2026年05月29日 09:44:31 作者:梦想不只是梦与想
这段文章详细介绍了Python面向对象编程的核心概念,文章还强调了类的命名规范、实例方法与属性的区别、私有属性的定义及使用@property简化数据类定义的重要性,感兴趣的朋友跟随小编一起看看吧
类是 Python 面向对象编程的核心,用于定义对象的蓝图。类封装了数据(属性)和行为(方法),支持继承、多态等特性。
一、类的定义与实例化
1. 基本定义
class Person:
"""定义一个人类"""
# 类属性(所有实例共享)
species = "human"
# 构造方法(初始化实例)
def __init__(self, name, age):
# 实例属性(每个实例独立)
self.name = name
self.age = age
# 实例方法
def greet(self):
return f"Hello, I'm {self.name}"
def have_birthday(self):
self.age += 1
return f"Now I'm {self.age}"
# 创建实例
person1 = Person("Alice", 25)
person2 = Person("Bob", 30)
print(person1.name) # Alice
print(person1.greet()) # Hello, I'm Alice
print(person1.species) # human二、类的组成
1. 构造方法__init__
class Student:
def __init__(self, name, age, grade="大一"):
self.name = name # 公有属性
self._age = age # 受保护属性(约定)
self.__grade = grade # 私有属性(名称修饰)
self.scores = [] # 可变属性
def get_grade(self):
return self.__grade
s = Student("Alice", 20)
print(s.name) # Alice
print(s._age) # 20(可以访问,但不建议)
# print(s.__grade) # AttributeError(名称修饰)
print(s.get_grade()) # 大一2. 实例方法、类方法、静态方法
class Calculator:
# 类属性
version = "1.0"
def __init__(self, brand):
self.brand = brand
# 实例方法(需要实例调用,可以访问实例属性)
def add(self, a, b):
return a + b
# 类方法(使用 @classmethod,可以访问类属性)
@classmethod
def get_version(cls):
return cls.version
# 静态方法(使用 @staticmethod,独立于类和实例)
@staticmethod
def multiply(a, b):
return a * b
calc = Calculator("Casio")
print(calc.add(3, 5)) # 8(实例方法)
print(Calculator.get_version()) # 1.0(类方法)
print(Calculator.multiply(3, 5))# 15(静态方法)3. 属性装饰器(@property)
class Circle:
def __init__(self, radius):
self._radius = radius
# getter
@property
def radius(self):
return self._radius
# setter
@radius.setter
def radius(self, value):
if value <= 0:
raise ValueError("半径必须大于0")
self._radius = value
@property
def area(self):
"""只读属性,没有 setter"""
return 3.14159 * self._radius ** 2
c = Circle(5)
print(c.radius) # 5
c.radius = 10 # 使用 setter
# c.area = 100 # AttributeError: can't set attribute
print(c.area) # 314.159三、继承
1. 单继承
# 父类(基类)
class Animal:
def __init__(self, name):
self.name = name
def speak(self):
return "一些声音"
def move(self):
return f"{self.name} 在移动"
# 子类(派生类)
class Dog(Animal):
def speak(self):
return "汪汪"
def wag_tail(self):
return "摇尾巴"
class Cat(Animal):
def speak(self):
return "喵喵"
def climb(self):
return "爬树"
dog = Dog("旺财")
cat = Cat("咪咪")
print(dog.speak()) # 汪汪(重写了父类方法)
print(dog.move()) # 旺财 在移动(继承父类方法)
print(dog.wag_tail()) # 摇尾巴(子类特有)
print(cat.speak()) # 喵喵
print(cat.climb()) # 爬树2. 多重继承
class Flyer:
def fly(self):
return "飞行中"
def move(self):
return "飞飞飞"
class Swimmer:
def swim(self):
return "游泳中"
def move(self):
return "游游游"
# 多重继承(按 MRO 顺序查找方法)
class Duck(Flyer, Swimmer):
def move(self):
# 调用指定父类的方法
return f"{Flyer.move(self)} 并且 {Swimmer.move(self)}"
duck = Duck()
print(duck.fly()) # 飞行中
print(duck.swim()) # 游泳中
print(duck.move()) # 飞飞飞 并且 游游游
print(Duck.__mro__) # 查看方法解析顺序3. 使用super()
class Parent:
def __init__(self, name):
self.name = name
print(f"Parent init: {name}")
def greet(self):
return f"Parent: {self.name}"
class Child(Parent):
def __init__(self, name, age):
super().__init__(name) # 调用父类构造方法
self.age = age
print(f"Child init: {age}")
def greet(self):
# 调用父类方法并扩展
parent_greet = super().greet()
return f"{parent_greet}, age {self.age}"
c = Child("Alice", 25)
print(c.greet()) # Parent: Alice, age 25四、多态
class Shape:
def area(self):
pass
class Rectangle(Shape):
def __init__(self, width, height):
self.width = width
self.height = height
def area(self):
return self.width * self.height
class Circle(Shape):
def __init__(self, radius):
self.radius = radius
def area(self):
return 3.14159 * self.radius ** 2
# 多态:同一接口,不同实现
def print_area(shape):
print(f"面积: {shape.area()}")
shapes = [Rectangle(3, 4), Circle(5)]
for shape in shapes:
print_area(shape)
# 面积: 12
# 面积: 78.53975五、特殊方法(魔术方法)
class Point:
def __init__(self, x, y):
self.x = x
self.y = y
# 字符串表示(供开发者)
def __repr__(self):
return f"Point({self.x}, {self.y})"
# 字符串表示(供用户)
def __str__(self):
return f"({self.x}, {self.y})"
# 加法
def __add__(self, other):
return Point(self.x + other.x, self.y + other.y)
# 相等比较
def __eq__(self, other):
return self.x == other.x and self.y == other.y
# 长度(len())
def __len__(self):
return int((self.x ** 2 + self.y ** 2) ** 0.5)
# 可迭代
def __iter__(self):
yield self.x
yield self.y
p1 = Point(3, 4)
p2 = Point(1, 2)
print(str(p1)) # (3, 4)
print(repr(p1)) # Point(3, 4)
print(p1 + p2) # (4, 6)
print(p1 == Point(3, 4)) # True
print(len(p1)) # 5
for coord in p1:
print(coord) # 3, 4六、常用魔术方法
| 魔术方法 | 触发时机 | 用途 |
|---|---|---|
__init__(self, ...) | 创建实例时 | 初始化属性 |
__str__(self) | print(obj)、str(obj) | 用户友好的字符串 |
__repr__(self) | repr(obj)、调试 | 开发者友好的字符串 |
__len__(self) | len(obj) | 返回长度 |
__getitem__(self, key) | obj[key] | 索引访问 |
__setitem__(self, key, value) | obj[key] = value | 索引赋值 |
__iter__(self) | for x in obj | 迭代器 |
__add__(self, other) | obj + other | 加法 |
__eq__(self, other) | obj == other | 相等比较 |
__lt__(self, other) | obj < other | 小于比较 |
__call__(self, ...) | obj() | 对象作为函数调用 |
七、数据类(dataclass)
from dataclasses import dataclass, field
@dataclass
class Person:
name: str
age: int = 0 # 默认值
tags: list = field(default_factory=list) # 可变类型需要 default_factory
# 自动生成 __init__、__repr__、__eq__ 等
def greet(self):
return f"Hello, I'm {self.name}"
p1 = Person("Alice", 25)
p2 = Person("Alice", 25)
p3 = Person("Bob", 30)
print(p1) # Person(name='Alice', age=25)
print(p1 == p2) # True(自动比较属性)
print(p1 == p3) # False
print(p1.greet()) # Hello, I'm Alice八、抽象类(ABC)
from abc import ABC, abstractmethod
class Vehicle(ABC):
def __init__(self, brand):
self.brand = brand
@abstractmethod
def start(self):
"""抽象方法,子类必须实现"""
pass
@abstractmethod
def stop(self):
pass
def honk(self):
"""普通方法,子类可以直接继承"""
return "滴滴"
class Car(Vehicle):
def start(self):
return f"{self.brand} 汽车启动"
def stop(self):
return f"{self.brand} 汽车停止"
# vehicle = Vehicle() # TypeError: 不能实例化抽象类
car = Car("Tesla")
print(car.start()) # Tesla 汽车启动
print(car.honk()) # 滴滴九、属性访问控制
class User:
def __init__(self, name):
self._name = name # 受保护(约定)
self.__password = "123" # 私有(名称修饰)
@property
def name(self):
return self._name
@name.setter
def name(self, value):
if not value:
raise ValueError("名字不能为空")
self._name = value
@property
def password(self):
return "***" # 只读属性,不返回真实密码
u = User("Alice")
print(u.name) # Alice
u.name = "Bob"
# u.name = "" # ValueError
print(u._name) # Bob(可以访问,但遵守约定不直接访问)
print(u.password) # ***
# print(u.__password) # AttributeError(名称修饰)来一个总结把
| 概念 | 说明 |
|---|---|
| 类 | 对象的蓝图 |
| 实例 | 根据类创建的具体对象 |
| 实例属性 | 每个实例独有的属性(self.attr) |
| 类属性 | 所有实例共享的属性(直接在类中定义) |
| 实例方法 | 第一个参数是 self,操作实例属性 |
| 类方法 | 使用 @classmethod,第一个参数是 cls |
| 静态方法 | 使用 @staticmethod,无特殊参数 |
| 继承 | 子类继承父类的属性和方法 |
| 多态 | 同一方法名在不同类中有不同实现 |
| 属性装饰器 | @property、@setter、@deleter |
| 魔术方法 | 以双下划线开头和结尾的特殊方法 |
要点:
- 类命名用驼峰命名法(如
MyClass) - 实例方法第一个参数必须是
self - 使用
__init__初始化实例属性 - 私有属性用双下划线开头(
__name) - 使用
@property实现 getter/setter dataclass简化数据类定义
到此这篇关于Python 中的类class实例详解的文章就介绍到这了,更多相关Python类class内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家!
相关文章
从入门到进阶讲解Python自动化Playwright实战指南
Playwright是针对 Python 语言的纯自动化工具,它可以通过单个API自动执行 Chromium,Firefox 和 WebKit 浏览器,下面小编就来简单介绍一下它的具体使用吧2025-07-07


最新评论