基于类与对象的语法结构，把代表数据的变量和操作数据的函数进行封装成一个类或对象，通过类与对象语法对外公开少部分的数据操作

实现对类或对象的成员保护与访问机制（避免外界随意修改删除破坏类的内部数据的合理性）

访问权限：

Python对成员的保护等级只有两个：私有的（private）（——属性/方法）和公有的（public）

class Person(object):
    def __init__(self, name, money, age, password, num):
        self.name = name   # 公有属性
        self.__num = num
        self.__money = money # 私有属性
        self.__password = password # 私有属性

    def __test1(self):#私有方法
        return 123

    def get_money(self, password):
        if self.__check_password(password):
            # 通过在return在类的内部提供操作数据的接口方法给外界去获取、修改数据
            return self.__money  
        else:
            raise Exception("密码不正确！没钱！")

    def save_money(self, money, password):
        """存钱或者取钱"""
        if not self.__check_password(password):
            return "密码不正确！无法操作！"

        if money > 0:
            # 存钱
            self.__money += money
            return

        # 取钱
        if abs(money) > self.__money:
            return "余额不足！"

        self.__money += money

    def __check_password(self, password):
        """检测密码，私有方法"""
        return password == self.__password

xiaoming = Person("小明", 1000, 17, "123456", 1)
# 类的外界，可以访问公有属性，无法访问私有属性
print(xiaoming.name) #小明
"""封装其实就是为了让一些属性和方法，不能被外界直接修改和调用而已"""
# print(xiaoming.__test1) # 报错！无法访问私有方法
# print(xiaoming.__num) # 报错! 无法访问私有属性 'Person' object has no attribute '__num'
"""对数据的修改，可以通过提供公有方法的方式给外界操作，那么外界操作时，我们就可以设置一些判断"""
print(xiaoming.get_money("123456")) #1000
xiaoming.save_money(-150, "123456")
print(xiaoming.get_money("123456")) #850

import hashlib
class Person(object):
    def __init__(self, name, money, password):
        self.name = name
        self.__money = money
        self.__password = self.__pwd(password)

    @property #装饰器装饰接口
    def money(self):  # money方法因为上面加了@perperty，所以变成了只读属性方法，实际使用时，直接当成属性来进行赋值操作即可
        return self.__money

    @money.setter #装饰器的调用
    def money(self, money):
        if money < 0:
            print("无法修改！")
            return
        self.__money = money

    # 对象属性的存取器，@property 只读器，  @属性名.setter 只写器
    @property
    def password(self):
        return self.__password

    @password.setter
    def password(self, new_password):
        self.__password = self.__pwd(new_password)

    def __pwd(self, raw_password):
        hash = hashlib.sha256()
        hash.update(raw_password.encode())
        return hash.hexdigest()

xiaoming = Person("小明", 1010, "123456")
print(xiaoming.money) #1010
print(xiaoming.password) #8d969eef6ecad3c2..
xiaoming.password = "123123123"
print(xiaoming.password) #932f3c1b56257c..
xiaoming.money = 100
print(xiaoming.money) #100

xiaohong = Person("小红", 2000, "123456")
print(xiaohong.money) #2000

xiaohong.money = -1000 #无法修改！
print(xiaohong.money)  #2000 得到的结果还是原来的

1、子类只能继承父类的公有属性和方法，无法继承父类的私有属性和私有方法。

2、子类可以拥有父类所没有的属性和方法，即子类可以对父类进行扩展。

3、子类可以用自己的方式重写父类的方法。

基本使用：（单继承）

class Person(object):
    """人类"""
    def __init__(self, name, age):
        self.name=name
        self.age=age

    def eat(self):
        print("eating...")
    def sleep(self):
        print("sleep...")

class Student(Person):
    """学生类"""
    def __init__(self, name, age, achievement):
        #super就是一个内置函数，用于调用父类的属性或方法,一般写法：super(子类名, self).方法(参数列表)
        super().__init__(name, age)
        self.achievement = achievement

    """继承不仅可以复用父类的方法，也可以复用父类的属性，甚至增加属于自己的属性。"""
    def do_homework(self):
        print("do_homework.....")
    def do_read(self):
        print("reading........")

    '''继承过程中，子类不仅可以复用父类的方法，还可以重写父类的方法。'''
    def sleep(self, where):
        if where != "课堂":
            super().sleep()
        else:
            print("不能睡觉！")

class Teacher(Person):
    """老师类"""
    def __init__(self, name, age, salary):
        super().__init__(name, age)
        self.salary = salary

    def teaching(self):
        print("teaching.....")
s = Student("小明", 17, 100)
s.sleep("课堂")

多继承：

"""多继承，就是一个类同时继承多个父类的特性"""
class Animal(object):
    def eat(self):
        print("eating...")

    def sleep(self):
        print("sleep...")

class Fly(object):
    def fly(self):
        print("fly...")

class Eagle(Animal, Fly):
    def hunt(self):
        print("hunt....")

class Plane(Fly):
    def payload(self):
        print("运输....")
菱形继承：

class Human(object):
    id = 1
    def eat(self):
        print("1-饿了去打猎")
        print(self.id)
        print("2-抓到猎物，直接生吃！")

class Man(Human):
    id = 2
    def eat(self):
        print("3-饿了去买酒卖肉")
        print(super().id)
        print("4-一边喝酒，一边吃肉！")

class Woman(Human):
    id = 3
    def eat(self):
        print("5-饿了去煮饭买菜")
        print(super().id)
        print("6-动作优雅，小口尝试！")

class Children(Man, Woman):
    id = 4
    def eat(self):
        print("7-饿了就哭.")
        print(super().id) #2
        print("8-吃了接着哭。")

xm = Children()
xm.eat()
print(Children.__mro__)
#(<class '__main__.Children'>, <class '__main__.Man'>, <class '__main__.Woman'>, <class '__main__.Human'>, <class 'object'>)

   弱类型语言：

一个变量被定义类型，该变量可以根据环境变化自动进行转换，不需要经过显性强制转换。

1 继承以后子类重写父类方法，不同的子类对于父类的同一个方法可以有不同的实现方式。龙生九子，子子不同。
2 支持鸭子类型（DuckType）

class Payment(object):
    def __init__(self, name, money):
        self.money = money
        self.name = name

    def pay(self, *args, **kwargs):
        pass

class AliPay(Payment):
    def pay(self):
        # 支付宝支付渠道
        print('%s通过支付宝消费了%s元' % (self.name, self.money))

class WeChatPay(Payment):
    def pay(self):
        # 微信支付渠道
        print('%s通过微信消费了%s元' % (self.name, self.money))

class Order(object):
    def account(self, pay_obj: Payment):
        print(isinstance(pay_obj, Payment))
        pay_obj.pay()

class Test(object):
    def pay(self):
        print("测试功能")

'''继承以后子类重写父类方法'''
pay1 = WeChatPay("小红", 100)
pay2 = AliPay("小明", 200)
#class必须实例化后才能使用
order = Order()
order.account(pay1)  # True 小红通过微信消费了100元
order.account(pay2)  # True 小明通过支付宝消费了200元
'''支持鸭子类型'''
t = Test()  #有pay函数
order.account(t) #False 测试功能
# 在所有的编程语言中，只要是弱类型的面向对象编程语言，多态都是不明显的，而是大多都支持鸭子类型。