1. 面向对象基础语法
1.类: 类是对一群具有相同特征或者行为的事物的一个统称，是抽象的，不能直接使用
    特征被称为属性
    行为被称为方法
类就相当于制造飞机时的图纸，是一个模板，是复制创建对象的

2.对象: 对象是由类创建出来的一个具体存在，可以直接使用
    由哪一个类创建出来的对象，就拥有在哪一个类中定义的: 属性和方法
对象就相当于用图纸制造的飞机
在程序开发中，应该先有类，再有对象

3.类和对象的关系
    类是模板，对象是根据类这个模板创建出来的，应该先有类，再有对象
    类只有一个，而对象可以有很多个
    不同的对象之间属性 可能会各不相同
    类中定义了什么属性和方法，对象中就有什么属性和方法，不可能多，也不可能少

4.类的设计
    在程序开发中，要设计一个类，通常需要满足一下三个要素：
        类名: 这类事物的名字，满足大驼峰命名法(每一个单词的首字母大写并且单词与单词之间没有下划线)
        属性: 这类事物具有什么样的特征
        方法: 这类事物具有什么样的行为
    4.1 类名的确定
        名词提炼法 分析整个业务流程，出现的名词，通常就是找到的类
    4.2 属性和方法的确定
        对对象的特征描述，通常可以定义成属性
        对象具有的行为（动词），通常可以定义成方法
        提示: 需求中没有涉及的属性或者方法在设计类时，不需要考虑
"""


# 第一个面向对象程序: 小猫爱吃鱼 小猫要喝水
# 这里的话按照需求首先是不需要定义属性的
class Cat:
    """这是一个猫类"""

    def eat(self):
        # self: 由哪一个对象调用的方法，方法内的self就是哪一个对象的引用
        # 1.在类封装的方法内部，self就表示当前调用方法的对象自己
        # 2.调用方法时，我们是不需要传递self参数的 解释器会自动帮我们传入
        # 3.在方法内部 可以通过self.访问对象的属性 也可以通过self.调用其他的对象方法
        print("%s 爱吃鱼" % self.name)

    def drink(self):
        print("小猫在喝水")


# 创建对象
tom = Cat()
# tom.eat()  # 在设置属性之前 调用方法报错
tom.drink()
# 在类的外部是可以直接通过.的方式去给对象添加属性的，但是不推荐
# 因为对象属性的封装应该封装在类的内部
tom.name = "Tom"
# print(tom.name)
tom.eat()  # tom.eat(tom)
# print(tom.__dict__)  # 可以查看对象绑定了哪些属性
# print(Cat.__dict__)  # 可以查看类绑定了哪些命名空间

lazy_cat = Cat()
lazy_cat.name = "大懒猫"
lazy_cat.eat()
# 在类的外部通过变量名.访问对象的属性和方法
# 在类的封装方法中，通过self.访问对象的属性和方法
2. 初始化方法__init__
# -*- coding: utf-8 -*-
# @Time    : 2019/12/9 14:40
# @Author  : 我就是任性-Amo
# @FileName: 2.初始化方法.py
# @Software: PyCharm

"""
初始化方法:
    1.当使用类名()创建对象时，会自动执行以下操作:
      为对象在内存中分配空间--创建对象
      为对象的属性设置初始值--初始化方法(init)
    2.__init__方法是专门用来定义一个类具有哪些属性的方法
"""


# 在Cat中增加__init__方法，验证该方法在创建对象时会被调用
class Cat:
    """这是一个猫类"""

    # def __init__(self):
    #     print("这是一个初始化方法")
    #     # 定义用Cat类创建的猫对象都有一个name的属性
    #     self.name = "Tom"

    # 在开发中，如果希望在创建对象的同时，就设置对象的属性，可以对_init__方法进行改造
    # 把希望设置的属性值，定义成__init__方法的参数，在方法内部使用
    # self.属性 = 形参 接收外部传递的参数
    # 在创建对象时，使用类名(属性1, 属性2...)

    def __init__(self, name):
        self.name = name

    def eat(self):
        print("%s 爱吃鱼" % self.name)

    # 如果在开发中，希望使用print输出对象变量时，能够打印自定义的内容，就可以利用__str__这个内置方法了
    def __str__(self):
        return "我是小猫: %s" % self.name

    # def __del__(self):
    # __del__:如果希望在对象被销毁前，再做一些事情，可以考虑此方法
    def __del__(self):
        print("准备删除~~~")


tom = Cat("Tom")  # 创建对象时 会自动调用初始化__init__方法
tom.eat()
lazy_cat = Cat("大懒猫")
lazy_cat.eat()
# 在Python中，使用print输出对象变量，默认情况下，会输出这个变量引用的对象是由哪一个类创建的对象，
# 以及在内存中的地址（十六进制表示）
print(tom)  # <__main__.Cat object at 0x103959bd0>

del lazy_cat
print("-" * 50)
3. 属性查找与绑定方法
# -*- coding: utf-8 -*-
# @Time    : 2019/12/9 15:00
# @Author  : 我就是任性-Amo
# @FileName: 3.属性查找与绑定方法.py
# @Software: PyCharm
# @Blog    ：https://blog.csdn.net/xw1680


# 属性查找与绑定方法

class Person:
    """这是一个猫类"""

    # nationality = "中国"

    # def __init__(self, name, age, address, nationality):
    #     self.name = name
    #     self.age = age
    #     self.address = address
    #     self.nationality = nationality 给对象绑定国籍属性
    def __init__(self, name, age, address):
        self.name = name
        self.age = age
        self.address = address

    def eat(self):
        print(f"{self.name}正在吃饭~~~")


# 1.分别创建amo对象和paul对象
# amo = Person("amo", 18, "重庆市沙坪坝区", "美国")
# paul = Person("paul", 22, "重庆市沙坪坝区", "中国")
# 属性: 首先会从对象本身先去查找，如果对象本身没有绑定该属性，则会从类中去找
# print(id(amo.nationality))  # 4406863312
# print(id(paul.nationality))  # 4406863504

amo = Person("amo", 18, "重庆市沙坪坝区")
paul = Person("paul", 22, "重庆市沙坪坝区")
# 如果对象身上没有绑定该属性 则去在类中查找 类属性是被所有对象共用的 所以返回的地址值是一致的.
# print(id(amo.nationality))  # 4461503952
# print(id(paul.nationality))  # 4461503952
# 如果在类中查找该属性 还是没有 程序就会报错
# print(id(paul.nationality))  # AttributeError: 'Person' object has no attribute 'nationality'


# 函数属性:是绑定给对象使用的，绑定到不同的对象是不同的绑定方法，对象调用绑定方法时，会把对象本身作为一个参数进行传入，传给self
print(amo.eat)  # <bound method Person.eat of <__main__.Person object at 0x10e9c7350>>
print(paul.eat)  # <bound method Person.eat of <__main__.Person object at 0x10e9c73d0>>
# 可以看到 两个的绑定方法的内存地址值是不一致的

print(Person.__dict__)
print(id(Person.eat(amo)))  # 4393136216
print(id(Person.eat(paul)))  # 4393136216
4. 案例
4.1 跑步案例
# -*- coding: utf-8 -*-
# @Time    : 2019/12/10 16:28
# @Author  : 我就是任性-Amo
# @FileName: 4.练习1.py
# @Software: PyCharm

# 封装是面向对象编程的一大特点
# 面向对象编程的第一步:将属性和方法封装到一个抽象的类中
# 外界使用类创建对象，然后让对象调用方法
# 对象方法的细节都被封装在类的内部

"""
需求:amo和jerry都爱跑步
amo体重75.0公斤
jerry体重45.0 公斤
每次跑步都会减少0.5公斤
每次吃东西都会增加1公斤
"""


class Person:
    def __init__(self, name, weight):
        self.name = name
        self.weight = weight

    def run(self):
        self.weight -= 0.5
        print("%s 爱锻炼，跑步锻炼身体" % self.name)

    def eat(self):
        self.weight += 1
        # 注意: 在对象的方法内部，是可以直接访问对象的属性的
        print("%s 是吃货，吃完这顿在减肥" % self.name)

    def __str__(self):
        return "我的名字是%s,体重%.2f公斤" % (self.name, self.weight)


amo = Person("amo", 75.0)
amo.run()
amo.eat()
amo.eat()
print(amo)
print("-" * 50)
jerry = Person("jerry", 45.0)  # 同一个类创建的多个对象之间，属性互不干扰
function(){ //外汇返佣 http://www.kaifx.cn/
jerry.run()
jerry.eat()
jerry.eat()
print(jerry)
4.2 家具案例
# -*- coding: utf-8 -*-
# @Time    : 2019/12/20 09:26
# @Author  : 我就是任性-Amo
# @FileName: 5.家具案例.py
# @Software: PyCharm
# @Blog    ：https://blog.csdn.net/xw1680

"""
需求:
    1.房子(House)有户型、总面积和家具名称列表
        新房子没有任何的家具
    2.家具(HouseItem)有名字和占地面积，其中
        席梦思(bed)占地4平米
        衣柜(chest)占地2平米
        餐桌(table)占地1.5平米
    3.将以上三件家具添加到房子中
    4.打印房子时，要求输出:户型、总面积、剩余面积、家具名称列表
"""


# 分析: 要去添加家具 首先肯定要有一个家具类 被使用的类 通常应该先被开发
class HouseItem:
    def __init__(self, name, area):
        self.name = name  # 家具名称
        self.area = area  # 占地面积

    def __str__(self):
        return "[%s] 占地面积 %.2f" % (self.name, self.area)


bed = HouseItem("bed", 4)  # 席梦思
chest = HouseItem("chest", 2)  # 衣柜
table = HouseItem("table", 1.5)  # 餐桌
print(bed)
print(chest)
print(table)


class House:

    def __init__(self, apartment, area):
        self.apartment = apartment  # 户型
        self.total_area = area  # 总面积
        self.free_area = area  # 剩余面积开始的时候和总面积是一样的
        self.furniture_list = []  # 家具名称列表 默认是没有放置任何家具的

    def add_item(self, furniture):
        """添加家具"""
        print(f"添加:{furniture.name}")
        # 判断家具的面积是否超过剩余面积，如果超过，提示不能添加这件家具
        if furniture.area > self.free_area:
            print("房间剩余面积不够，不能添置这件家具...")
            return
        self.furniture_list.append(furniture.name)  # 将家具名称追加到家具名称列表中
        self.free_area -= furniture.area  # 用房子的剩余面积-家具面积

    def __str__(self):
        return f"房子户型为:{self.apartment},总面积为:{self.total_area}," \
               f"剩余面积为{self.free_area},家具列表为:{self.furniture_list}"


if __name__ == "__main__":
    my_house1 = House("两室一厅", 60)
    my_house1.add_item(bed)
    my_house1.add_item(chest)
    my_house1.add_item(table)
    print(my_house1)

    my_house2 = House("一室一厅", 10)
    my_house2.add_item(bed)
    my_house2.add_item(chest)
    my_house2.add_item(table)
    my_house2.add_item(bed)
    print(my_house2)
6. 私有属性
# -*- coding: utf-8 -*-
# @Time    : 2019/12/20 10:08
# @Author  : 我就是任性-Amo
# @FileName: 6.私有属性.py
# @Software: PyCharm
# @Blog    ：https://blog.csdn.net/xw1680

"""
应用场景:
  在实际开发中，对象的某些属性或方法可能只希望在对象的内部被使用，而不希望在外部被访问到
  私有属性就是对象不希望公开的属性
  私有方法就是对象不希望公开的方法
定义的方式: 在定义属性或方法时，在属性名或者方法名前增加两个下划线，定义的就是私有属性或方法
在java中的话是使用private关键字
"""


class Women:
    def __init__(self, name):
        self.name = name
        self.__age = 18

    def __secret(self):
        print("我的年龄是 %d" % self.__age)


xiao_fang = Women("小芳")
# 私有属性外界不能直接访问
# print(xiao_fang.__age) 报错:AttributeError: 'Women' object has no attribute '__age'
# 私有方法，外部不嫩直接调用
# xiao_fang.__secret()

# 在日常开发中，不要使用这种方式，访问对象的私有属性或私有方法
# 在Python中，并没有真正意义的私有
# 在给属性、方法 命名时，实际是对名称做了一些特殊处理，使得外界无法访问到
# 处理方式:在名称前面加上 _类名 => _类名__名称


print(xiao_fang.__dict__)  # 查看名称空间
print(xiao_fang._Women__age)
# print(Women.__dict__)
xiao_fang._Women__secret()
程序运行结果如下：
7. 继承
7.1 面向对象的三大特性
封装: 根据职责将属性和方法封装到一个抽象的类中
继承: 实现代码的重用，相同的代码不需要重复的编写
多态: 不同的对象调用相同的方法，产生不同的执行结果，增加代码的灵活度
7.2 单继承
7.2.1 继承的概念
继承的概念: 子类拥有父类的所有方法和属性
# ---------不使用继承开发动物和狗---------------
class Animal:

    def eat(self):
        print("吃")

    def drink(self):
        print("喝")

    def run(self):
        print("跑")

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


class Dog:

    def eat(self):  # 不使用继承重复书写的代码太多
        print("吃")

    def drink(self):
        print("喝")

    def run(self):
        print("跑")

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

    def bark(self):
        print("汪汪叫")


# 创建一个狗对象
wang_cai = Dog()

wang_cai.eat()
wang_cai.drink()
wang_cai.run()
wang_cai.sleep()
wang_cai.bark()
# # ---------使用继承开发动物和狗---------------
class Animal:
    def eat(self):
        print("吃---")

    def drink(self):
        print("喝---")

    def run(self):
        print("跑---")

    def sleep(self):
        print("睡---")


class Dog(Animal):
    def bark(self):
        print("汪汪叫---")


# 创建一个狗对象
wang_cai = Dog()
wang_cai.eat()
wang_cai.drink()
wang_cai.run()
wang_cai.sleep()
wang_cai.bark()  # 直接享受父类中已经封装好的方法 不需要再次开发
7.2.2 继承的语法
class 类名(父类名):
        pass
类继承自父类，可以直接享受父类中已经封装好的方法，不需要再次开发
子类中应该根据职责，封装子类特有的属性和方法
专业术语
Dog类是Animal类的子类，Animal类是Dog类的父类，Dog类从Animal类继承
Dog类是Animal类的派生类，Animal类是Dog类的基类，Dog类从Animal类派生
继承的传递性
C类从B类继承，B类又从A类继承，那么C类就具有B类和A类的所有属性和方法
# -*- coding: utf-8 -*-
# @Time    : 2019/12/21 10:52
# @Author  : 我就是任性-Amo
# @FileName: 9.继承的传递性.py
# @Software: PyCharm
# @Blog    ：https://blog.csdn.net/xw1680


class Animal:

    def eat(self):
        print("吃---")

    def drink(self):
        print("喝---")

    def run(self):
        print("跑---")

    def sleep(self):
        print("睡---")


class Dog(Animal):

    def bark(self):
        print("汪汪叫")


class XiaoTianQuan(Dog):

    def fly(self):
        print("我会飞")


# 创建一个哮天犬的对象
xtq = XiaoTianQuan()

xtq.fly()
xtq.bark()
xtq.eat()
原文链接：https://blog.csdn.net/xw1680/article/details/103641726

1. 面向对象基础语法
1.类: 类是对一群具有相同特征或者行为的事物的一个统称，是抽象的，不能直接使用
    特征被称为属性
    行为被称为方法
类就相当于制造飞机时的图纸，是一个模板，是复制创建对象的

2.对象: 对象是由类创建出来的一个具体存在，可以直接使用
    由哪一个类创建出来的对象，就拥有在哪一个类中定义的: 属性和方法
对象就相当于用图纸制造的飞机
在程序开发中，应该先有类，再有对象

3.类和对象的关系
    类是模板，对象是根据类这个模板创建出来的，应该先有类，再有对象
    类只有一个，而对象可以有很多个
    不同的对象之间属性 可能会各不相同
    类中定义了什么属性和方法，对象中就有什么属性和方法，不可能多，也不可能少

4.类的设计
    在程序开发中，要设计一个类，通常需要满足一下三个要素：
        类名: 这类事物的名字，满足大驼峰命名法(每一个单词的首字母大写并且单词与单词之间没有下划线)
        属性: 这类事物具有什么样的特征
        方法: 这类事物具有什么样的行为
    4.1 类名的确定
        名词提炼法 分析整个业务流程，出现的名词，通常就是找到的类
    4.2 属性和方法的确定
        对对象的特征描述，通常可以定义成属性
        对象具有的行为（动词），通常可以定义成方法
        提示: 需求中没有涉及的属性或者方法在设计类时，不需要考虑
"""


# 第一个面向对象程序: 小猫爱吃鱼 小猫要喝水
# 这里的话按照需求首先是不需要定义属性的
class Cat:
    """这是一个猫类"""

    def eat(self):
        # self: 由哪一个对象调用的方法，方法内的self就是哪一个对象的引用
        # 1.在类封装的方法内部，self就表示当前调用方法的对象自己
        # 2.调用方法时，我们是不需要传递self参数的 解释器会自动帮我们传入
        # 3.在方法内部 可以通过self.访问对象的属性 也可以通过self.调用其他的对象方法
        print("%s 爱吃鱼" % self.name)

    def drink(self):
        print("小猫在喝水")


# 创建对象
tom = Cat()
# tom.eat()  # 在设置属性之前 调用方法报错
tom.drink()
# 在类的外部是可以直接通过.的方式去给对象添加属性的，但是不推荐
# 因为对象属性的封装应该封装在类的内部
tom.name = "Tom"
# print(tom.name)
tom.eat()  # tom.eat(tom)
# print(tom.__dict__)  # 可以查看对象绑定了哪些属性
# print(Cat.__dict__)  # 可以查看类绑定了哪些命名空间

lazy_cat = Cat()
lazy_cat.name = "大懒猫"
lazy_cat.eat()
# 在类的外部通过变量名.访问对象的属性和方法
# 在类的封装方法中，通过self.访问对象的属性和方法
2. 初始化方法__init__
# -*- coding: utf-8 -*-
# @Time    : 2019/12/9 14:40
# @Author  : 我就是任性-Amo
# @FileName: 2.初始化方法.py
# @Software: PyCharm

"""
初始化方法:
    1.当使用类名()创建对象时，会自动执行以下操作:
      为对象在内存中分配空间--创建对象
      为对象的属性设置初始值--初始化方法(init)
    2.__init__方法是专门用来定义一个类具有哪些属性的方法
"""


# 在Cat中增加__init__方法，验证该方法在创建对象时会被调用
class Cat:
    """这是一个猫类"""

    # def __init__(self):
    #     print("这是一个初始化方法")
    #     # 定义用Cat类创建的猫对象都有一个name的属性
    #     self.name = "Tom"

    # 在开发中，如果希望在创建对象的同时，就设置对象的属性，可以对_init__方法进行改造
    # 把希望设置的属性值，定义成__init__方法的参数，在方法内部使用
    # self.属性 = 形参 接收外部传递的参数
    # 在创建对象时，使用类名(属性1, 属性2...)

    def __init__(self, name):
        self.name = name

    def eat(self):
        print("%s 爱吃鱼" % self.name)

    # 如果在开发中，希望使用print输出对象变量时，能够打印自定义的内容，就可以利用__str__这个内置方法了
    def __str__(self):
        return "我是小猫: %s" % self.name

    # def __del__(self):
    # __del__:如果希望在对象被销毁前，再做一些事情，可以考虑此方法
    def __del__(self):
        print("准备删除~~~")


tom = Cat("Tom")  # 创建对象时 会自动调用初始化__init__方法
tom.eat()
lazy_cat = Cat("大懒猫")
lazy_cat.eat()
# 在Python中，使用print输出对象变量，默认情况下，会输出这个变量引用的对象是由哪一个类创建的对象，
# 以及在内存中的地址（十六进制表示）
print(tom)  # <__main__.Cat object at 0x103959bd0>

del lazy_cat
print("-" * 50)
3. 属性查找与绑定方法
# -*- coding: utf-8 -*-
# @Time    : 2019/12/9 15:00
# @Author  : 我就是任性-Amo
# @FileName: 3.属性查找与绑定方法.py
# @Software: PyCharm
# @Blog    ：https://blog.csdn.net/xw1680


# 属性查找与绑定方法

class Person:
    """这是一个猫类"""

    # nationality = "中国"

    # def __init__(self, name, age, address, nationality):
    #     self.name = name
    #     self.age = age
    #     self.address = address
    #     self.nationality = nationality 给对象绑定国籍属性
    def __init__(self, name, age, address):
        self.name = name
        self.age = age
        self.address = address

    def eat(self):
        print(f"{self.name}正在吃饭~~~")


# 1.分别创建amo对象和paul对象
# amo = Person("amo", 18, "重庆市沙坪坝区", "美国")
# paul = Person("paul", 22, "重庆市沙坪坝区", "中国")
# 属性: 首先会从对象本身先去查找，如果对象本身没有绑定该属性，则会从类中去找
# print(id(amo.nationality))  # 4406863312
# print(id(paul.nationality))  # 4406863504

amo = Person("amo", 18, "重庆市沙坪坝区")
paul = Person("paul", 22, "重庆市沙坪坝区")
# 如果对象身上没有绑定该属性 则去在类中查找 类属性是被所有对象共用的 所以返回的地址值是一致的.
# print(id(amo.nationality))  # 4461503952
# print(id(paul.nationality))  # 4461503952
# 如果在类中查找该属性 还是没有 程序就会报错
# print(id(paul.nationality))  # AttributeError: 'Person' object has no attribute 'nationality'


# 函数属性:是绑定给对象使用的，绑定到不同的对象是不同的绑定方法，对象调用绑定方法时，会把对象本身作为一个参数进行传入，传给self
print(amo.eat)  # <bound method Person.eat of <__main__.Person object at 0x10e9c7350>>
print(paul.eat)  # <bound method Person.eat of <__main__.Person object at 0x10e9c73d0>>
# 可以看到 两个的绑定方法的内存地址值是不一致的

print(Person.__dict__)
print(id(Person.eat(amo)))  # 4393136216
print(id(Person.eat(paul)))  # 4393136216
4. 案例
4.1 跑步案例
# -*- coding: utf-8 -*-
# @Time    : 2019/12/10 16:28
# @Author  : 我就是任性-Amo
# @FileName: 4.练习1.py
# @Software: PyCharm

# 封装是面向对象编程的一大特点
# 面向对象编程的第一步:将属性和方法封装到一个抽象的类中
# 外界使用类创建对象，然后让对象调用方法
# 对象方法的细节都被封装在类的内部

"""
需求:amo和jerry都爱跑步
amo体重75.0公斤
jerry体重45.0 公斤
每次跑步都会减少0.5公斤
每次吃东西都会增加1公斤
"""


class Person:
    def __init__(self, name, weight):
        self.name = name
        self.weight = weight

    def run(self):
        self.weight -= 0.5
        print("%s 爱锻炼，跑步锻炼身体" % self.name)

    def eat(self):
        self.weight += 1
        # 注意: 在对象的方法内部，是可以直接访问对象的属性的
        print("%s 是吃货，吃完这顿在减肥" % self.name)

    def __str__(self):
        return "我的名字是%s,体重%.2f公斤" % (self.name, self.weight)


amo = Person("amo", 75.0)
amo.run()
amo.eat()
amo.eat()
print(amo)
print("-" * 50)
jerry = Person("jerry", 45.0)  # 同一个类创建的多个对象之间，属性互不干扰
function(){ //外汇返佣 http://www.kaifx.cn/
jerry.run()
jerry.eat()
jerry.eat()
print(jerry)
4.2 家具案例
# -*- coding: utf-8 -*-
# @Time    : 2019/12/20 09:26
# @Author  : 我就是任性-Amo
# @FileName: 5.家具案例.py
# @Software: PyCharm
# @Blog    ：https://blog.csdn.net/xw1680

"""
需求:
    1.房子(House)有户型、总面积和家具名称列表
        新房子没有任何的家具
    2.家具(HouseItem)有名字和占地面积，其中
        席梦思(bed)占地4平米
        衣柜(chest)占地2平米
        餐桌(table)占地1.5平米
    3.将以上三件家具添加到房子中
    4.打印房子时，要求输出:户型、总面积、剩余面积、家具名称列表
"""


# 分析: 要去添加家具 首先肯定要有一个家具类 被使用的类 通常应该先被开发
class HouseItem:
    def __init__(self, name, area):
        self.name = name  # 家具名称
        self.area = area  # 占地面积

    def __str__(self):
        return "[%s] 占地面积 %.2f" % (self.name, self.area)


bed = HouseItem("bed", 4)  # 席梦思
chest = HouseItem("chest", 2)  # 衣柜
table = HouseItem("table", 1.5)  # 餐桌
print(bed)
print(chest)
print(table)


class House:

    def __init__(self, apartment, area):
        self.apartment = apartment  # 户型
        self.total_area = area  # 总面积
        self.free_area = area  # 剩余面积开始的时候和总面积是一样的
        self.furniture_list = []  # 家具名称列表 默认是没有放置任何家具的

    def add_item(self, furniture):
        """添加家具"""
        print(f"添加:{furniture.name}")
        # 判断家具的面积是否超过剩余面积，如果超过，提示不能添加这件家具
        if furniture.area > self.free_area:
            print("房间剩余面积不够，不能添置这件家具...")
            return
        self.furniture_list.append(furniture.name)  # 将家具名称追加到家具名称列表中
        self.free_area -= furniture.area  # 用房子的剩余面积-家具面积

    def __str__(self):
        return f"房子户型为:{self.apartment},总面积为:{self.total_area}," \
               f"剩余面积为{self.free_area},家具列表为:{self.furniture_list}"


if __name__ == "__main__":
    my_house1 = House("两室一厅", 60)
    my_house1.add_item(bed)
    my_house1.add_item(chest)
    my_house1.add_item(table)
    print(my_house1)

    my_house2 = House("一室一厅", 10)
    my_house2.add_item(bed)
    my_house2.add_item(chest)
    my_house2.add_item(table)
    my_house2.add_item(bed)
    print(my_house2)
6. 私有属性
# -*- coding: utf-8 -*-
# @Time    : 2019/12/20 10:08
# @Author  : 我就是任性-Amo
# @FileName: 6.私有属性.py
# @Software: PyCharm
# @Blog    ：https://blog.csdn.net/xw1680

"""
应用场景:
  在实际开发中，对象的某些属性或方法可能只希望在对象的内部被使用，而不希望在外部被访问到
  私有属性就是对象不希望公开的属性
  私有方法就是对象不希望公开的方法
定义的方式: 在定义属性或方法时，在属性名或者方法名前增加两个下划线，定义的就是私有属性或方法
在java中的话是使用private关键字
"""


class Women:
    def __init__(self, name):
        self.name = name
        self.__age = 18

    def __secret(self):
        print("我的年龄是 %d" % self.__age)


xiao_fang = Women("小芳")
# 私有属性外界不能直接访问
# print(xiao_fang.__age) 报错:AttributeError: 'Women' object has no attribute '__age'
# 私有方法，外部不嫩直接调用
# xiao_fang.__secret()

# 在日常开发中，不要使用这种方式，访问对象的私有属性或私有方法
# 在Python中，并没有真正意义的私有
# 在给属性、方法 命名时，实际是对名称做了一些特殊处理，使得外界无法访问到
# 处理方式:在名称前面加上 _类名 => _类名__名称


print(xiao_fang.__dict__)  # 查看名称空间
print(xiao_fang._Women__age)
# print(Women.__dict__)
xiao_fang._Women__secret()
程序运行结果如下：
7. 继承
7.1 面向对象的三大特性
封装: 根据职责将属性和方法封装到一个抽象的类中
继承: 实现代码的重用，相同的代码不需要重复的编写
多态: 不同的对象调用相同的方法，产生不同的执行结果，增加代码的灵活度
7.2 单继承
7.2.1 继承的概念
继承的概念: 子类拥有父类的所有方法和属性
# ---------不使用继承开发动物和狗---------------
class Animal:

    def eat(self):
        print("吃")

    def drink(self):
        print("喝")

    def run(self):
        print("跑")

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


class Dog:

    def eat(self):  # 不使用继承重复书写的代码太多
        print("吃")

    def drink(self):
        print("喝")

    def run(self):
        print("跑")

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

    def bark(self):
        print("汪汪叫")


# 创建一个狗对象
wang_cai = Dog()

wang_cai.eat()
wang_cai.drink()
wang_cai.run()
wang_cai.sleep()
wang_cai.bark()
# # ---------使用继承开发动物和狗---------------
class Animal:
    def eat(self):
        print("吃---")

    def drink(self):
        print("喝---")

    def run(self):
        print("跑---")

    def sleep(self):
        print("睡---")


class Dog(Animal):
    def bark(self):
        print("汪汪叫---")


# 创建一个狗对象
wang_cai = Dog()
wang_cai.eat()
wang_cai.drink()
wang_cai.run()
wang_cai.sleep()
wang_cai.bark()  # 直接享受父类中已经封装好的方法 不需要再次开发
7.2.2 继承的语法
class 类名(父类名):
        pass
类继承自父类，可以直接享受父类中已经封装好的方法，不需要再次开发
子类中应该根据职责，封装子类特有的属性和方法
专业术语
Dog类是Animal类的子类，Animal类是Dog类的父类，Dog类从Animal类继承
Dog类是Animal类的派生类，Animal类是Dog类的基类，Dog类从Animal类派生
继承的传递性
C类从B类继承，B类又从A类继承，那么C类就具有B类和A类的所有属性和方法
# -*- coding: utf-8 -*-
# @Time    : 2019/12/21 10:52
# @Author  : 我就是任性-Amo
# @FileName: 9.继承的传递性.py
# @Software: PyCharm
# @Blog    ：https://blog.csdn.net/xw1680


class Animal:

    def eat(self):
        print("吃---")

    def drink(self):
        print("喝---")

    def run(self):
        print("跑---")

    def sleep(self):
        print("睡---")


class Dog(Animal):

    def bark(self):
        print("汪汪叫")


class XiaoTianQuan(Dog):

    def fly(self):
        print("我会飞")


# 创建一个哮天犬的对象
xtq = XiaoTianQuan()

xtq.fly()
xtq.bark()
xtq.eat()
原文链接：https://blog.csdn.net/xw1680/article/details/103641726