当前位置：首页 > Python > 正文

Python中class函数用法详解 - 掌握面向对象编程核心

DiaoZe
Python
2025-08-07
370

Python中class用法详解教程

Python类(Class)是什么？

在Python中，类(Class)是面向对象编程(OOP)的核心概念。类可以看作创建对象的蓝图或模板，它定义了对象的属性和方法。通过类，我们可以创建多个具有相同结构和行为的对象实例。

本教程将带你全面掌握Python中类的用法，包括：

如何定义类
创建对象实例
使用构造函数
类属性和实例属性
类方法和静态方法
继承和多态

1. 类的基本结构

Python中使用class关键字定义类，基本语法如下：

class 类名:
    """类的文档字符串"""
    
    def __init__(self, 参数1, 参数2, ...):
        """构造函数，初始化对象属性"""
        self.属性1 = 参数1
        self.属性2 = 参数2
        ...
    
    def 方法名(self, 参数...):
        """定义类的方法"""
        # 方法体

示例：定义一个简单的Person类

class Person:
    """表示一个人的类"""
    
    def __init__(self, name, age):
        """初始化人的属性"""
        self.name = name  # 实例属性
        self.age = age    # 实例属性
    
    def introduce(self):
        """自我介绍的方法"""
        print(f"大家好，我叫{self.name}，今年{self.age}岁。")

# 创建Person类的实例
person1 = Person("张三", 25)
person1.introduce()  # 输出：大家好，我叫张三，今年25岁。

2. 构造函数和self关键字

__init__方法是Python类的构造函数，在创建新对象时自动调用。

self参数代表类的当前实例，用于访问属于该类的变量和方法。

class Car:
    def __init__(self, brand, model, year):
        self.brand = brand
        self.model = model
        self.year = year
        self.mileage = 0  # 设置默认值
    
    def drive(self, distance):
        """模拟驾驶汽车，增加里程"""
        self.mileage += distance
        print(f"行驶了{distance}公里，总里程：{self.mileage}公里")
    
    def get_info(self):
        """获取汽车信息"""
        return f"{self.year}年{self.brand}{self.model}，行驶里程：{self.mileage}公里"

# 创建Car对象
my_car = Car("丰田", "凯美瑞", 2020)
print(my_car.get_info())  # 输出：2020年丰田凯美瑞，行驶里程：0公里

my_car.drive(150)  # 输出：行驶了150公里，总里程：150公里
my_car.drive(85)   # 输出：行驶了85公里，总里程：235公里

3. 类属性和实例属性

实例属性：每个对象实例特有的属性，通过self设置

类属性：所有对象实例共享的属性，在类内部但在方法外部定义

class Dog:
    # 类属性 - 所有狗共享的属性
    species = "Canis familiaris"
    
    def __init__(self, name, breed, age):
        # 实例属性 - 每只狗特有的属性
        self.name = name
        self.breed = breed
        self.age = age
    
    def bark(self):
        print(f"{self.name}说：汪汪！")
    
    def info(self):
        return f"{self.name}是一只{self.age}岁的{self.breed}，属于{self.species}"

# 创建Dog对象
dog1 = Dog("小黑", "拉布拉多", 3)
dog2 = Dog("小白", "泰迪", 2)

print(dog1.info())  # 小黑是一只3岁的拉布拉多，属于Canis familiaris
print(dog2.info())  # 小白是一只2岁的泰迪，属于Canis familiaris

# 访问类属性
print(Dog.species)  # 输出：Canis familiaris

# 修改类属性会影响所有实例
Dog.species = "Canis lupus familiaris"
print(dog1.species)  # 输出：Canis lupus familiaris

4. 类方法和静态方法

类方法：使用@classmethod装饰器，第一个参数是cls，可以访问类属性

静态方法：使用@staticmethod装饰器，与类和实例无关，类似于普通函数

class Circle:
    PI = 3.14159  # 类属性
    
    def __init__(self, radius):
        self.radius = radius
    
    # 实例方法
    def area(self):
        return Circle.PI * self.radius ** 2
    
    # 类方法
    @classmethod
    def from_diameter(cls, diameter):
        """通过直径创建圆"""
        return cls(diameter / 2)  # cls代表类本身
    
    # 静态方法
    @staticmethod
    def is_valid_radius(radius):
        """检查半径是否有效"""
        return radius > 0

# 使用构造函数创建圆
circle1 = Circle(5)
print(f"半径为5的圆面积: {circle1.area():.2f}")  # 输出：78.54

# 使用类方法创建圆
circle2 = Circle.from_diameter(10)
print(f"直径为10的圆面积: {circle2.area():.2f}")  # 输出：78.54

# 使用静态方法
print(Circle.is_valid_radius(-5))  # 输出：False
print(Circle.is_valid_radius(7))   # 输出：True

5. 继承和多态

继承是OOP的重要特性，允许我们定义一个新类来继承现有类的属性和方法。

# 基类（父类）
class Animal:
    def __init__(self, name):
        self.name = name
    
    def speak(self):
        raise NotImplementedError("子类必须实现此方法")

# 子类继承Animal
class Dog(Animal):
    def speak(self):
        return f"{self.name}说：汪汪！"

# 另一个子类
class Cat(Animal):
    def speak(self):
        return f"{self.name}说：喵喵~"

# 使用多态
def animal_sound(animal):
    print(animal.speak())

# 创建不同子类的对象
dog = Dog("旺财")
cat = Cat("咪咪")

animal_sound(dog)  # 输出：旺财说：汪汪！
animal_sound(cat)  # 输出：咪咪说：喵喵~

# 方法重写示例
class Bird(Animal):
    def __init__(self, name, can_fly=True):
        super().__init__(name)  # 调用父类的构造函数
        self.can_fly = can_fly
    
    def speak(self):
        sound = "啾啾" if self.can_fly else "咕咕"
        return f"{self.name}说：{sound}"

sparrow = Bird("小麻雀")
penguin = Bird("企鹅", can_fly=False)

print(sparrow.speak())  # 输出：小麻雀说：啾啾
print(penguin.speak())  # 输出：企鹅说：咕咕

6. 类使用的最佳实践

遵循PEP8命名规范：类名使用大驼峰式命名法（如MyClass）
使用有意义的类名和方法名
为类和方法添加文档字符串
保持类职责单一（单一职责原则）
优先使用组合而不是继承
合理使用访问控制：Python中没有真正的私有变量，但约定以单下划线_var表示"内部使用"，双下划线__var触发名称修饰

class BankAccount:
    """银行账户类"""
    
    def __init__(self, account_holder, initial_balance=0):
        self.account_holder = account_holder
        self._balance = initial_balance  # 单下划线表示受保护属性
    
    def deposit(self, amount):
        """存款"""
        if amount > 0:
            self._balance += amount
            return True
        return False
    
    def withdraw(self, amount):
        """取款"""
        if 0 < amount <= self._balance:
            self._balance -= amount
            return True
        return False
    
    def get_balance(self):
        """获取余额"""
        return self._balance

# 创建账户
account = BankAccount("张三", 1000)
account.deposit(500)
account.withdraw(200)
print(f"账户余额: {account.get_balance()}")  # 输出：1300