Python类的定义和使用

一、Python类的基本概念

Python中的类是一种自定义数据类型，允许我们定义自己的数据结构，包括数据属性（成员变量）和方法（成员函数），并支持面向对象编程中的封装、继承和多态等特性。类是一种模板，可以通过实例化获得对象，每个对象具有相同的属性和方法，但这些属性可能具有不同的值。

Python中使用class来定义类，一般的语法格式为：

class 类名[(父类名)]:
    def __init__(self[, 参数1, 参数2... ]):
        self.成员变量1 = 初始值1
        self.成员变量2 = 初始值2
        ...
    def 成员方法1(self[, 参数1, 参数2... ]):
        方法体1
    def 成员方法2(self[, 参数1, 参数2... ]):
        方法体2
    ...

其中，__init__(self[, 参数1, 参数2… ])是类的构造函数（或初始化函数），用于定义对象的属性；成员方法是类的函数，用于实现对象的行为。self代表对象本身，相当于C++中的this指针。

二、Python类的继承和多态

Python支持继承，一个类可以从另一个类中继承属性和方法，被继承的类称为父类或基类，继承它的类称为子类或派生类。子类可以重写父类的方法，实现多态，调用同一个方法时可以根据对象类型的不同产生不同的行为。Python中支持多重继承，一个类可以同时继承多个父类。

可以使用super()函数来调用父类的方法，格式为super(子类名, self).父类方法名(参数列表)。

例如，定义一个Animal类，具有基本的属性和方法，然后定义Dog类和Cat类继承自Animal类，并实现自己的特殊方法。代码如下：

class Animal:
    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex

    def run(self):
        print("I'm running!")

class Dog(Animal):
    def __init__(self, name, age, sex, breed):
        super(Dog, self).__init__(name, age, sex)
        self.breed = breed

    def bark(self):
        print("I'm a dog, I'm barking!")

class Cat(Animal):
    def __init__(self, name, age, sex, coat):
        super(Cat, self).__init__(name, age, sex)
        self.coat = coat

    def mew(self):
        print("I'm a cat, I'm mewing!")

dog = Dog("Tom", 3, "male", "Golden Retriever")
cat = Cat("Lucy", 2, "female", "Siamese")
print(dog.name, dog.age, dog.sex, dog.breed)
dog.bark()
print(cat.name, cat.age, cat.sex, cat.coat)
cat.mew()

输出结果为：

Tom 3 male Golden Retriever
I'm a dog, I'm barking!
Lucy 2 female Siamese
I'm a cat, I'm mewing!

三、Python类的封装和访问控制

Python中可以使用属性访问和方法调用来访问对象的属性和方法，但是属性和方法默认都是公有的，可以被类的外部访问和修改。为了实现封装，Python提供了一些访问控制的方法。具体地，属性和方法可以分为公有、私有和受保护三种类型，用下划线进行命名约定，规则如下：

• 以单下划线开头（如_name）的属性和方法表示保护，只能在类和子类中访问，不建议在类外部使用。
• 以双下划线开头（如__name）的属性和方法表示私有，只能在类中访问，无法在外部访问。可以通过使用_get_name()和_set_name()方法来实现私有属性的读写操作。
• 以双下划线开头和结尾（如__init__()）的方法表示特殊方法，如构造函数和析构函数。

例如，假设我们要定义一个人类，具有年龄属性和show_age()方法，其中年龄属性可以通过setter和getter方法进行读写。代码如下：

class Person:
    def __init__(self, name, age):
        self._name = name
        self.__age = age

    def show_age(self):
        print("My age is", self.__age)

    def get_age(self):
        return self.__age

    def set_age(self, age):
        if age  200:
            print("Invalid age!")
        else:
            self.__age = age

person = Person("John", 30)
person.show_age()
person.set_age(40)
person.show_age()
print(person.get_age())
person.__age = 50 # 私有属性无法直接访问
person.show_age()

输出结果为：

My age is 30
My age is 40
40
My age is 40

四、Python类的静态方法和类方法

Python中的方法支持普通方法、静态方法和类方法三种类型。静态方法和类方法是面向对象编程中常用的语法结构，可以无需创建对象即可使用，提高了代码的复用性和可维护性。

静态方法使用@staticmethod装饰器进行声明，没有cls和self参数，可以被类和对象直接调用，通常用于对传入的数据进行处理或转换。

类方法使用@classmethod装饰器进行声明，第一个参数必须是cls，表示类本身，也可以被类和对象调用，通常用于对类属性进行操作。

例如，假设我们要定义一个数学类，具有计算圆周率pi和求绝对值abs的静态方法和求阶乘factorial的类方法。代码如下：

class Math:
    PI = 3.14159

    @staticmethod
    def abs(x):
        return x if x > 0 else -x

    @staticmethod
    def pi():
        return Math.PI

    @classmethod
    def factorial(cls, n):
        if n > 1:
            return n * cls.factorial(n - 1)
        else:
            return 1

print(Math.abs(-1))
print(Math.pi())
print(Math.factorial(5))

输出结果为：

1
3.14159
120

五、Python类的特殊方法

Python中的类还可以通过特殊方法来实现一些有意义的操作，如__str__()方法用于返回对象的字符串表示形式，__eq__()方法用于比较两个对象是否相等等。

例如，假设我们要定义一个向量类，具有加法、减法和乘法等运算，以及向量的长度、正方向和字符串表示等特殊方法。代码如下：

class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __add__(self, other):
        return Vector(self.x + other.x, self.y + other.y)

    def __sub__(self, other):
        return Vector(self.x - other.x, self.y - other.y)

    def __mul__(self, other):
        return self.x * other.x + self.y * other.y

    def __len__(self):
        return round((self.x ** 2 + self.y ** 2) ** 0.5, 2)

    def __str__(self):
        return "({}, {})".format(self.x, self.y)

    def __eq__(self, other):
        return self.x == other.x and self.y == other.y

v1 = Vector(2, 3)
v2 = Vector(3, 4)
print(v1 + v2)
print(v1 - v2)
print(v1 * v2)
print(len(v1))
print(str(v1))
print(v1 == v2)

输出结果为：

(5, 7)
(-1, -1)
18
3.61
(2, 3)
False