Python 3 学习笔记之——面向对象

1. 类的介绍

类(Class) 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例，类是对象的抽象。

方法：类中定义的函数。
类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
方法变量：定义在方法中的变量。
继承：即一个派生类（derived class）继承基类（base class）的属性和方法。
方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也成为方法的重写。

2. 类的定义

语法格式如下:

class ClassName:
    <statement-1>
    .
    .
    .
    <statement-N>

类有一个名为 _init_() 的特殊方法，也即是构造函数，该方法会在定义对象的时候自动调用，可以通过参数传递来对类的实例进行设定。
在类内部，使用 def 关键字来定义一个方法，与一般函数不同，类方法必须包含参数 self，并且作为第一个参数，self 代表类的实例，类似于 C++ 中的 this 指针。
类的私有属性 __private_attrs 以两个下划线开头，在类内部的方法中使用时用 self.__private_attrs 调用，不能在类外部访问类的私有属性。
类的私有方法 __private_method 以两个下划线开头，只能在类的内部调用，不能在类外部调用。

class person:
    
    instances = 0                # 类变量，所有类公用
    
    def __init__(self, name, age, weight):
        self.name = name         # 公有属性
        self.age = age
        self.__weight = weight   # 私有属性，在类外无法直接访问
        
        person.instances += 1;   # 通过类来访问类变量
    
    def tell_a_secret(self):     # 私有方法
        print("Tell you a secret, my weight is {} kg.".format(self.__weight))
    
    def speak(self):             # 公有方法
        print('My name is {}, I\'m {} years old.'.format(self.name, self.age))
        self.tell_a_secret()


people = person('seniusen', 21, 60)
people.speak()
print(people.instances)
print(people.instances) # 通过实例也可以访问类变量

# My name is seniusen, I'm 21 years old.
# Tell you a secret, my weight is 60 kg.
# 1
# 1

3. 类的单继承

语法格式如下:

class DerivedClassName(BaseClassName1):
    <statement-1>
    .
    .
    .
    <statement-N>

注意圆括号中基类的顺序，若是基类中有相同的方法名，而在子类使用时未指定，则 Python 从左至右进行搜索。即方法在子类中未找到时，从左到右查找基类中是否包含该方法。
基类名 BaseClassName 必须与派生类定义在一个作用域，如果基类定义在另一个模块，这时候我们还可以用一个表达式来定义派生类，class DerivedClassName(modname.BaseClassName):。

class student(person):
        
    def __init__(self, name, age, weight, major):
        
        person.__init__(self, name, age, weight) # 调用父类的构造函数，此时必须给定 self 参数
        # super(student, self).__init__(name, age, weight) 或者利用 super() 函数
        self.major = major

    # 重写父类的方法
    def speak(self): # 公有方法
        person.speak(self)
        print('My major in college is {}.'.format(self.major))

stu = student('seniusen', 21, 60, 'Automation')
stu.speak()
print(student.instances)
print(stu.instances) # 通过实例也可以访问类变量

# My name is seniusen, I'm 21 years old.
# Tell you a secret, my weight is 60 kg.
# My major in college is Automation.
# 2
# 2

3. 类的多继承

语法格式如下:

class DerivedClassName(Base1, Base2, Base3):
    <statement-1>
    .
    .
    .
    <statement-N>

class teacher:
      
    def __init__(self, title, topic):
        self.title = title 
        self.topic = topic
    
    def speak(self): # 公有方法
        print('I\'m a {} , my research topic is {}.'.format(self.title, self.topic))

# 继承自 teacher 和 student 的子类
class sample(teacher, student):
    
    def __init__(self, name, age, weight, major, title, topic):
        student.__init__(self, name, age, weight, major)
        teacher.__init__(self, title, topic)

test = sample('seniusen', 21, 60, 'Automation', 'prefessor', 'CV')
test.speak() # 没有指定方法，从左到右查找，这里调用了 teacher 类的 speak() 方法

# I'm a prefessor , my research topic is CV.

利用 super() 函数可以调用被子类重写的父类中的方法。

class Parent:           # 定义父类
    
    def myMethod(self):
        print ('Method form Parent class!')

        
class Child(Parent):    # 定义子类
    
    def myMethod(self):
        print ('Method form Child class!')

a = Child()                # 子类实例
a.myMethod()               # 子类调用重写方法
super(Child, a).myMethod() #用子类对象调用父类已被覆盖的方法

# Method form Child class!
# Method form Parent class!