Python 类与对象

类与对象

Python 是一种面向对象的编程语言。

Python 中的几乎所有东西都是对象，拥有属性和方法。
类（Class）类似对象构造函数，或者是用于创建对象的“蓝图”。

在现实生活中，类是所有同种物体的统称，如：人类、鸟类等。

而对象则是一个类中的具体的一个个体，如：人类小明是人类的具体个体。

类的定义

在Python中，定义一个类的格式如下：

1
2
3
4
5
6
class ClassName:
    <statement-1>
    .
    .
    .
    <statement-N>

通常类中还包含一个初始化函数，帮助我们初始化对象的属性：

1
2
3
4
5
6
class ClassName:
    def __init__(self, ···):
     ···
    ···
    ···
    ···

让我们定义一个学生类，并实例化出一个对象：

1
2
3
4
5
6
7
class Student:
 # self 代表类的当前实例
 def __init__(self, name, age, ID):
     self.name = name
     self.age = age
     self.ID = ID
stu1 = Student('小嗷犬', 18, '666') # 实例化

这样我们就可以通过类打印出stu1的各个属性：

1
2
3
4
5
6
7
class Student:
 def __init__(self, name, age, ID):
     self.name = name
     self.age = age
     self.ID = ID
stu1 = Student('小嗷犬', 18, '666')
print(stu1.name, stu1.age, stu1.ID)

类的方法

这种打印方法也可以写在类里：

1
2
3
4
5
6
7
8
9
class Student:
    def __init__(self, name, age, ID):
        self.name = name
        self.age = age
        self.ID = ID
    def introduce(self):
        print(f'我叫{self.name}，今年{self.age}岁，学号是{self.ID}')
stu1 = Student('小嗷犬', 18, '666')
stu1.introduce()

继承

单继承

Python 支持类的继承，派生类的定义如下所示:

1
2
3
4
5
6
class DerivedClassName(BaseClassName):
    <statement-1>
    .
    .
    .
    <statement-N>

子类（派生类 DerivedClassName）会继承父类（基类 BaseClassName）的属性和方法。

下面我们用学生类来派生一个大学生类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class Student:
    def __init__(self, name, age, ID):
        self.name = name
        self.age = age
        self.ID = ID
    def introduce(self):
        print(f'我叫{self.name}，今年{self.age}岁，学号是{self.ID}')

class BigStudent(Student):
    def eat(self):
        print('我是大学生，我会吃大米饭。')

stu1 = BigStudent('小嗷犬', 18, '666')
stu1.introduce()
stu1.eat()

多继承

除此之外，Python还支持多继承，多继承的类定义形如下：

1
2
3
4
5
6
class DerivedClassName(Base1, Base2, Base3):
    <statement-1>
    .
    .
    .
    <statement-N>

需要注意圆括号中父类的顺序，若是父类中有相同的方法名，而在子类使用时未指定，Python从左至右搜索，即方法在子类中未找到时，从左到右查找父类中是否包含方法。

方法重写

在派生类继承了父类方法后，可以对原有方法进行重写：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class Student:
    def __init__(self, name, age, ID):
        self.name = name
        self.age = age
        self.ID = ID
    def introduce(self):
        print(f'我叫{self.name}，今年{self.age}岁，学号是{self.ID}')

class BigStudent(Student):
 def introduce(self):
        super().introduce()
        print('我已经是个大学生了。')

    def eat(self):
        print('我是大学生，我会吃大米饭。')

stu1 = BigStudent('小嗷犬', 18, '666')
stu1.introduce()
stu1.eat()

上例的大学生类重写了学生类的introduce函数，其中用super()来调用父类函数。

私有属性与方法

Python中可以将属性或方法设为私有，使其只能在类的内部访问，语法格式为在属性或方法名前加两个下划线：

1
2
__private_attrs # 私有属性
__private_method # 私有方法

代码实例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class Student:
    __name = None
    __age = None
    __ID = None
    
    def __init__(self, name, age, ID):
        self.__name = name
        self.__age = age
        self.__ID = ID
        
    def getName(self):
        return self.__name
    
    def getAge(self):
        return self.__age
    
    def getID(self):
        return self.__ID
stu1 = Student('小嗷犬', 18, '666')
print(stu1.getName(), stu1.getAge(), stu1.getID())

直接访问私有属性将会报错：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class Student:
    __name = None
    __age = None
    __ID = None
    
    def __init__(self, name, age, ID):
        self.__name = name
        self.__age = age
        self.__ID = ID
        
    def getName(self):
        return self.__name
    
    def getAge(self):
        return self.__age
    
    def getID(self):
        return self.__ID
stu1 = Student('小嗷犬', 18, '666')
print(stu1.__name)