面向对象：

• 面向过程程序设计：自上而下，不适合复杂的大型项目。
• 面向对象程序设计：一切皆对象

类最基础的作用是封装代码：class关键字，类名满足大驼峰

类的组成：属性，方法（第一个参数是self的函数）

对象通过类创建和初始化

对象的初始化：通过__init__方法初始化

对象的生命周期：

• 一个对象从创建完成后，其生命周期开始
• 在对象调用了__del__方法后，生命周期结束
• 在对象的生命周期范围内，可以调用对象的属性和方法

# 面向对象 类
class People:
    # __slot__防止用户恶意添加一些原本不存在的属性
    # __slots__ = ("name", "__age", "skill")

    def __init__(self, name, age, skill):  # __init__相当于java中的new，self相当于this
        self.name = name
        self.__age = age  # 私有属性 python中没有严格的私有属性，不过是障眼法
        self.skill = skill

    def ability(self):
        print("%s love %s" % (self.name, self.skill))

    def get_age(self):  # 通过get访问私有变量
        return self.__age

    def set_age(self, new_age):
        self.__age = new_age


def run(self):
    print("%s run" % (self.name))


maidu = People("maidu", 22, "dance")
print(maidu)  # 输出<__main__.People object at 0x0000000002864C50>
# print(maidu.age)  # 输出22
print(maidu.get_age())  # 输出22
maidu.set_age(19)
# maidu.sex = "male"
print(dir(maidu))  # 查看所有的方法和属性
print(maidu._People__age)  # 输出19
maidu.ability()  # 输出maidu love dance
maidu.run = run
maidu.run(maidu)  # 输出maidu run

封装：

• 封装是面向对象编程的一大特点
• 面向对象编程的第一步：将属性和方法的实现细节封装到一个抽象的类内部
• 外部使用类创建对象，利用对象调用方法和属性
• 私有属性和方法：属性或方法前加两个下划线

继承:

• 继承实现了代码的复用
• 继承具有传递性
• 方法的重写
• 多继承
• 新式类：object  【python3的类中默认继承自新式类，python2中需要明确指定 clas ClassName(object):pass】

案例：# 设计时钟日历类，将时钟类和日历类进行联动

# 设计时钟日历类，将时钟类和日历类进行联动


class Clock:  # 时钟类
    def __init__(self, hour, minute, second):
        self.hour = hour
        self.minute = minute
        self.second = second

    def __str__(self):
        return "%02d:%02d:%02d" % (self.hour, self.minute, self.second)

    def tick(self):  # 使秒钟+1
        self.second += 1
        if self.second == 60:
            self.second = 0
            self.minute += 1
        if self.minute == 60:
            self.minute = 0
            self.hour += 1
        if self.hour == 24:
            self.hour = 0
        return "%02d:%02d:%02d" % (self.hour, self.minute, self.second)


clock = Clock(8, 59, 59)
print(clock)  # 输出08:59:59
print(clock.tick())  # 输出09:00:00


class Calendar:  # 日历类
    def __init__(self, year, month, day):
        self.year = year
        self.month = month
        self.day = day

    def __str__(self):
        return "%04d-%02d-%02d" % (self.year, self.month, self.day)

    def next_day(self):  # 使天+1
        self.day += 1
        if self.day == 31:  # 每月暂时按30天处理
            self.day = 1
            self.month += 1
        if self.month == 13:
            self.month = 1
            self.year += 1

        return "%02d-%02d-%02d" % (self.year, self.month, self.day)


c1 = Calendar(2020, 12, 30)
print(c1)  # 输出2020-12-30
print(c1.next_day())  # 输出2021-01-01


# 时钟日期联动


class ClockCalendar(Clock, Calendar):
    def __init__(self, year, month, day, hour, minute, second):
        Clock.__init__(self, hour, minute, second)
        Calendar.__init__(self, year, month, day)

    def __str__(self):
        return Calendar.__str__(self)+" "+Clock.__str__(self)

    def tick(self):
        if self.hour == 0:
            Clock.tick(self)
        elif self.hour == 23:
            Clock.tick(self)
            if self.hour == 0:
                Calendar.next_day(self)


cc = ClockCalendar(2022, 12, 30, 0, 0, 59)
print(cc)  # 输出2022-12-30 00:00:59
cc.tick()
print(cc)  # 输出2022-12-30 00:01:00