Python类定义有哪些作用

Python中的类定义是面向对象编程的基础，它具有以下作用：

一、封装与抽象

1. 封装

封装是指将数据和行为封装在一起形成一个独立的实体，通过类来实现。类将数据和函数绑定在一起，隐藏了实现细节，只暴露给外部的接口，提供了更高层次的抽象，使得使用者可以更加方便、安全地调用。

例如，我们可以定义一个名为Student的类，类中封装了学生的属性（如姓名、年龄）和方法（如学习、休息），外部只需要调用类的接口即可。

class Student:
    def __init__(self, name, age):
        self.name = name
        self.age = age
        
    def study(self):
        print(self.name, '正在学习')
        
    def rest(self):
        print(self.name, '正在休息')

s = Student('小明', 18)
s.study()
s.rest()

2. 抽象

抽象是指从具体事物中提取共同的、本质性的特征，忽略其非本质的属性和行为，形成一个抽象的概念，通过类的继承来实现。抽象类是不能实例化的，它只能用作其他类的基类。

例如，我们可以定义一个名为Animal的抽象类，其中定义了一个抽象方法speak()，子类需要继承Animal并实现speak()方法。这样一来，我们可以通过抽象类来定义一些通用的特性和行为，不同的子类可以有不同的实现。

from abc import ABC, abstractmethod

class Animal(ABC):
    @abstractmethod
    def speak(self):
        pass

class Cat(Animal):
    def speak(self):
        print('喵喵喵')

class Dog(Animal):
    def speak(self):
        print('汪汪汪')

a = Cat()
a.speak()

b = Dog()
b.speak()

二、继承与多态

1. 继承

继承是指通过一个已有的类创建新的类，新的类拥有已有类的属性和方法，并可以扩展和修改。继承分为单继承和多继承，通过继承可以实现代码的复用和层次化的设计，减少重复代码的编写。

例如，我们可以定义一个名为Person的基类，其中包含姓名和年龄两个属性，然后通过继承Person类来创建不同的子类，如Student和Teacher类，它们共享了Person类的属性，同时又可以添加自己特有的属性和方法。

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
        
    def show_info(self):
        print('姓名:', self.name)
        print('年龄:', self.age)

class Student(Person):
    def __init__(self, name, age, school):
        super().__init__(name, age)
        self.school = school
        
    def show_info(self):
        super().show_info()
        print('学校:', self.school)

class Teacher(Person):
    def __init__(self, name, age, subject):
        super().__init__(name, age)
        self.subject = subject
        
    def show_info(self):
        super().show_info()
        print('科目:', self.subject)

s = Student('小明', 18, '高中')
s.show_info()

t = Teacher('张老师', 30, '数学')
t.show_info()

2. 多态

多态是指同一种操作可以作用于不同的对象上，并且可以根据对象的类型选择不同的实现方式。通过多态，我们可以分离抽象和具体的实现，提高了代码的扩展性和灵活性。

例如，在上面的例子中，Student和Teacher类都重写了父类Person的show_info()方法，当我们调用show_info()方法时，根据不同对象的类型（Student或Teacher），会调用相应的实现方式，实现了同一种操作的不同实现。

def show_info(obj):
    obj.show_info()

p = Person('小明', 18)
show_info(p)

s = Student('小红', 17, '高中')
show_info(s)

t = Teacher('张老师', 30, '数学')
show_info(t)

三、封装数据与行为的安全性和灵活性

1. 数据封装的安全性

类的定义可以将数据封装在类中，通过访问控制权限（公有、私有、受保护等）来限制对数据的直接访问，提高了数据的安全性。

例如，我们可以将类的属性定义为私有属性（在属性前加上双下划线），然后通过公有的getter和setter方法来访问和修改属性。这样一来，外部无法直接访问私有属性，必须通过类的接口来进行操作。

class Person:
    def __init__(self, name, age):
        self.__name = name
        self.__age = age
        
    def get_name(self):
        return self.__name
    
    def set_name(self, name):
        self.__name = name
        
    def get_age(self):
        return self.__age
    
    def set_age(self, age):
        if age < 0:
            print('年龄不能为负数')
        else:
            self.__age = age
            
p = Person('小明', 18)
print(p.get_name())
p.set_age(-5)
print(p.get_age())

2. 数据与行为的灵活性

类的定义中既包含数据，也包含了对数据的操作行为，它们紧密地绑定在一起，提供了一种灵活的方式来组织和管理代码。

例如，我们可以为类定义一些特殊方法（如__str__、__len__等），使得类的对象可以像内置类型一样进行常用操作（如打印、长度计算等），方便了代码的编写和使用。

class Rectangle:
    def __init__(self, width, height):
        self.width = width
        self.height = height
        
    def __str__(self):
        return f'Rectangle(width={self.width}, height={self.height})'
        
    def __len__(self):
        return self.width * self.height

r = Rectangle(3, 4)
print(r)
print(len(r))

总结：

Python类定义具有封装与抽象、继承与多态、封装数据与行为的安全性和灵活性等作用。通过封装和抽象，可以将数据和函数封装在一起，提供简洁的接口和高层次的抽象，方便使用和理解代码。通过继承和多态，可以实现代码的复用和层次化设计，提高代码的灵活性和扩展性。通过封装数据和行为的安全性和灵活性，可以保护数据的安全性并提供灵活的操作方式。