Python3面向对象编程实例

/*认真研究完这个实例，理解python面向对象编程的方法*/
class Person:
    """人员信息"""
    # 姓名(共有属性)
    name = ''
    # 年龄(共有属性)
    age = 0

    #定义构造函数
    def __init__(self, name='', age=0):
        self.name = name
        self.age = age

    # 重载专有方法: __str__
    def __str__(self):
        return "这里重载了 __str__ 专有方法, " + str({'name': self.name, 'age': self.age})

    def set_age(self, age):
        self.age = age


class Account:
    """账户信息"""
    # 账户余额(私有属性)
    __balance = 0
    # 所有账户总额
    __total_balance = 0

    # 获取账户余额
    # self 必须是方法的第一个参数
    def balance(self):
        return self.__balance

    '''一共有三种方式定义类的方法
    第一种：不加修饰，绑定的是当前的实例
    增加账户余额'''
    def balance_add(self, cost):
        # self 访问的是本实例
        self.__balance += cost
        # self.__class__ 可以访问类
        self.__class__.__total_balance += cost

    '''
    第二种：用@classmethod来修饰，绑定的是类
    类方法(用@classmethod标识，第一个参数为 cls)
    '''
    @classmethod
    def total_balance(cls):
        return cls.__total_balance

    '''
    第二种：用@staticmethod修饰，不绑定
    静态方法(用 @staticmethod 标识，不需要类参数或实例参数)
    '''
    @staticmethod
    def exchange(a, b):
        return b, a


class Teacher(Person, Account):
    """教师"""
    # 班级名称，受保护的属性
    _class_name = ''

    def __init__(self, name):
        # 第一种重载父类__init__()构造方法
        # super(子类，self).__init__(参数1，参数2，....)
        super(Teacher, self).__init__(name)

    @classmethod
    def set_class_name(cls,class_name):
        cls._class_name = class_name

    def get_info(self):
        # 以字典的形式返回个人信息
        return {
            'name': self.name,  # 此处访问的是父类Person的属性值
            'age': self.age,
            'class_name': self._class_name,
            'balance': self.balance(),  # 此处调用的是子类重载过的方法
        }

    # 方法重载
    def balance(self):
        # Account.__balance 为私有属性，子类无法访问，所以父类提供方法进行访问
        return Account.balance(self) * 1.1


class Student(Person, Account):
    """学生"""
    _teacher_name = ''

    def __init__(self, name, age=18):
        # 第二种重载父类__init__()构造方法
        # 父类名称.__init__(self,参数1，参数2，...)
        Person.__init__(self, name, age)

    @classmethod
    def set_teacher_name(cls,teacher_name):
        cls._teacher_name = teacher_name

    def get_info(self):
        # 以字典的形式返回个人信息
        return {
            'name': self.name,  # 此处访问的是父类Person的属性值
            'age': self.age,
            'teacher_name': self._teacher_name,
            'balance': self.balance(),
        }

# 教师 John
john = Teacher('John')
john.set_class_name('CS2018')
john.balance_add(20)
john.set_age(36)  # 子类的实例可以直接调用父类的方法
print("John's info:", john.get_info())

# 学生 Mary
mary = Student('Mary', 18)
mary.balance_add(18)
mary.set_teacher_name('john')
print("Mary's info:", mary.get_info())

# 学生 Fake
fake = Student('Fake')
fake.balance_add(30)
print("Fake's info", fake.get_info())

# 三种不同的方式调用静态方法
print("john.exchange('a', 'b'):", john.exchange('a', 'b'))
print('Teacher.exchange(1, 2)', Teacher.exchange(1, 2))
print('Account.exchange(10, 20):', Account.exchange(10, 20))

# 类方法、类属性
print('Account.total_balance():', Account.total_balance())
print('Teacher.total_balance():', Teacher.total_balance())
print('Student.total_balance():', Student.total_balance())

# 重载专有方法
print(john)
print(mary)
print(fake)

输出：

John's info: {'name': 'John', 'age': 36, 'balance': 22.0, 'class_name': 'CS2018'}
Mary's info: {'teacher_name': 'john', 'name': 'Mary', 'age': 18, 'balance': 18}
Fake's info {'teacher_name': 'john', 'name': 'Fake', 'age': 18, 'balance': 30}
john.exchange('a', 'b'): ('b', 'a')
Teacher.exchange(1, 2) (2, 1)
Account.exchange(10, 20): (20, 10)
Account.total_balance(): 0
Teacher.total_balance(): 20
Student.total_balance(): 48
这里重载了 __str__ 专有方法, {'name': 'John', 'age': 36}
这里重载了 __str__ 专有方法, {'name': 'Mary', 'age': 18}
这里重载了 __str__ 专有方法, {'name': 'Fake', 'age': 18}