0707 Python 类与对象

# 类名为大驼峰
class PeopleInfo:
    """
    定义人类
    """
    # 类中称为方法
    # 类似于函数
    def __init__(self, name, age, sex):     # 构造方法, 构造器
        pass

class PersonInfo:  # 类相当于图纸(模板)
    """
    定义人类
    """
    def run(self):
        # self跟调用方法时的对象ID一致
        print("人会跑步")

    def eat(self):  # 在类中创建的方法, 如果带self, 那么往往把它叫做实例方式
        print("人会吃饭")


one_person = PersonInfo()  # 创建对象(盖房子), 是一个实例化的过程
print(f"one_person的ID为: {id(one_person)}")
one_person.run()  # 使用 对象.方法名 来调用方法
one_person.eat()  # 对象将自身, 自动传给了self, 所以不会报错, 在类里面, self相当于one_person

# 在类的外面创建属性, ---不推荐使用
# 使用 对象.属性 = 属性值    类似于给变量赋值
one_person.name = "胡巴"
one_person.age = 25
one_person.height = 190
# 在类的外面如何调用属性
# 使用 对象.属性   类似于获取变量
print(one_person.name)
print(one_person.age)
print(one_person.height)

class PersonInfo:   # 类相当于图纸(模板)
    """
    定义人类
    """
    # 共有的特征, 那么叫做类属性
    head = 1    # 在类的外面定义的是变量, 但是在类名的下面, 定义的变量, 称为类属性, 所以对象共有的特征

    def __init__(self, name, age, height):
        """
        固定形式, 绝大多数情况下, 会使用__init__方法来创建属性，称为构造方法或者构造器, 推荐做法
        :param name:形参，由类名("雨欣") 来传参实参
        :param age:形参，由类名(16) 来传参实参
        :param height:形参，由类名(170) 来传参实参
        """
        self.fair = "假发"     # 创建属性，写死
        self.name = name      # 一般在类的里面, 会使用 self.属性 来创建属性
        self.age = age
        self.height = height
        print(f"self的ID为: {id(self)}")
        # 在类的里面使用self.属性名, 能获取属性的值
        print("姓名: {}\n年龄: {}\n身高: {}".format(self.name, self.age, self.height))

    def run(self):
        # self跟调用方法时的对象ID一致，实例方法中，使用self.属性名 来调用
        # self.face = "瓜子"      # 实例方法中创建属性--不推荐
        print("{}会跑步".format(self.name))

    def eat(self):  
        # 在类中创建的方法, 如果带self, 那么往往把它叫做实例方法
        print("{}会吃饭".format(self.name))

    def info(self):
        # 在类的里面, 可以使用类名.类属性 来获取类属性的值
        # print("姓名: {}\n年龄: {}\n身高: {}\n脑袋个数: {}".format(self.name, self.age, self.height, PersonInfo.head))
        # 在类的里面, 可以使用self.类属性 来获取类属性的值
        print("姓名: {}\n年龄: {}\n身高: {}\n脑袋个数: {}".format(self.name, self.age, self.height, self.head))

    def __str__(self):  # 魔术方法
        # 如果使用print函数打印一个对象, 那么会自动调用__str__实例方法
        # 往往__str__实例方法, 需要返回一个字符串
        return "<{}>".format(self.name)


# 可以使用类来创建多个对象
# 每个对象之间, 拥有不同的属性值
# 每个对象的实例属性是独有的
one_person = PersonInfo("雨欣", 16, 180)   # 类名() 默认会调用__init__方法，实参
two_person = PersonInfo("Sunny", 18, 185)

# one_person.run()
# two_person.run()
# two_person.eat()
print(one_person)
print(two_person)

# 在类的外面如何访问类属性?
# 1. 类名.类属性
print(PersonInfo.head)
# 2. 对象.类属性
print(one_person.head)
print(two_person.head)

# PersonInfo.info()     # 不能使用类名来调用实例方法
# PersonInfo.name       # 不能使用类名来调用实例属性
one_person.info()       # 可以使用对象名来调用实例方法

@classmethod    # （译：可拉斯.蛮色的）装饰器，类方法来处理类属性的
    def angray(cls):    # 如果不加装饰器，默认创建实例方法
        cls.head = 2
        pass

@staticmethod   # （译：四大题刻.蛮色的 ）定义的是静态方法, 静态跟类外面定义的函数几乎没有区别, 只不过是位置不同以
def weather_forecase(motion):
    """
    播报天气
    在类的外面定义的一定是函数, 在类的里面定义的才是方法
    :return:
    """
    print("天气, 晴朗!")
    print("温度: 22°")
    print("适合出游")

class NumDeal:

    num_type = ‘数字类型‘
    num_amount1 = 11
    num_amount2 = 33

    def __init__(self, num1, num2):
        self.num1 = num1
        self.num2 = num2
        print(f‘类内部调用类方法nums_sum:{self.nums_sum()}‘)  # 类内部调用类方法,因为创建了两次实例对象,所以调用该方法时传入两个对象的实例变量值
        print(f‘类内部调用实例方法nums_add:{self.nums_add()}‘)  # 类内部调用类方法,因为创建了两次实例对象,所以调用该方法时传入两个对象的实例变量值
        print(f‘类的内部调用实例属性num1:{self.num1},num2:{self.num2}‘)  # 因为创建了两个实例化对象，所以会调用初始化函数两次，分别打印出两个对象分别传入的值
        print(f‘类的内部调用类属性num_type:{self.num_type},num_amount1:{self.num_amount1},num_amount2:{self.num_amount2}‘)

    def nums_add(self):  # 实例方法
        return self.num1 + self.num2

    @classmethod  # 定义类方法需要用装饰器@classmethod
    def nums_sum(cls):      # 类方法

        return cls.num_amount1 + cls.num_amount2


num_int = NumDeal(4, 5)
num_float = NumDeal(4.1, 5.1)
print(‘*‘*30, ‘num_int‘, ‘*‘*30)
print(f‘类外边通过类实例对象num_int调用类属性:{num_int.num_type}‘)
print(f‘类外边通过类实例对象num_int调用实例属性num1:{num_int.num1},num2:{num_int.num2}‘)
print(f‘类外边通过类实例对象num_int调用实例方法nums_add(两个int类型数字相加结果):{num_int.nums_add()}‘)
print(f‘类外边通过类实例对象num_int调用类方法nums_sum():{num_int.nums_sum()}‘)
print()
print(‘*‘*30, ‘num_float‘, ‘*‘*30)
print(f‘类外边通过类实例对象num_float调用类属性:{num_float.num_type}‘)
print(f‘类外边通过类实例对象num_float调用实例属性num1:{num_float.num1},num2:{num_float.num2}‘)
print(f‘类外边通过类实例对象num_float调用实例方法nums_add(两个float类型数字相加结果):{num_float.nums_add()}‘)
print(f‘类外边通过类实例对象num_float调用类方法nums_sum():{num_float.nums_sum()}‘)
print()
print(‘*‘*30, ‘NumDeal‘, ‘*‘*30)
print(f‘类外边通过类名NumDeal调用类属性:{NumDeal.num_type}‘)
# print(f‘类外边通过类名NumDeal调用实例属性num1:{NumDeal.num1}‘)  # 会报错,说明不能用类名调用实例属性
# print(f‘类外边通过类名NumDeal调用实例方法nums_add():{NumDeal.add()}‘)#会报错,说明不能用类名调用实例方法
# print(f‘类外边通过类名NumDeal调用实例方法nums_add(:{NumDeal.nums_add(num_int)}‘)  # 可以在调用实例方法是传入类实例对象
print(f‘类外边通过类名NumDeal调用类方法nums_sum():{NumDeal.nums_sum()}‘)

类内部调用类方法nums_sum:44
类内部调用实例方法nums_add:9
类的内部调用实例属性num1:4,num2:5
类的内部调用类属性num_type:数字类型,num_amount1:11,num_amount2:33
类内部调用类方法nums_sum:44
类内部调用实例方法nums_add:9.2
类的内部调用实例属性num1:4.1,num2:5.1
类的内部调用类属性num_type:数字类型,num_amount1:11,num_amount2:33
****************************** num_int ******************************
类外边通过类实例对象num_int调用类属性:数字类型
类外边通过类实例对象num_int调用实例属性num1:4,num2:5
类外边通过类实例对象num_int调用实例方法nums_add(两个int类型数字相加结果):9
类外边通过类实例对象num_int调用类方法nums_sum():44

****************************** num_float ******************************
类外边通过类实例对象num_float调用类属性:数字类型
类外边通过类实例对象num_float调用实例属性num1:4.1,num2:5.1
类外边通过类实例对象num_float调用实例方法nums_add(两个float类型数字相加结果):9.2
类外边通过类实例对象num_float调用类方法nums_sum():44

****************************** NumDeal ******************************
类外边通过类名NumDeal调用类属性:数字类型
类外边通过类名NumDeal调用类方法nums_sum():44

def info(self):     # 定义与父类同样的方法
    # super()能够调用父类的方法, 是Python3中的方法
    # super().info()    # 调用父类的方法
    print("工作: {}".format(self.job))    # 在本子类中添加新的内容
    # 即继承了父类中的方法，也添加了新的内容

class Cat:
    """
    create a cat class
    """
    def __init__(self, name, color, age):
        """
        构造方法
        :param name: 姓名
        :param color: 颜色
        :param age: 年龄
        """
        self.name = name
        self.color = color
        self.age = age
        self.status = [] # 状态

    def eat(self):
        print("{}正在吃东西...".format(self.name))
        self.status.append("舔嘴巴")

    def drink(self):
        print("{}正在喝饮料...".format(self.name))
        self.status.append("喵喵喵...")


tom = Cat("Tom", "灰色", 1)
print("名字：{}\n颜色：{}\n年龄：{}".format(tom.name, tom.color, tom.age))
tom.eat()
tom.drink()
print("{}很享受的样子，{}、{}".format(tom.name, *tom.status))

@classmethod 
def 类方法名(cls): 
    pass

@staticmethod 
def 静态方法名(参数): 
    pass

class Restaurant:

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

    def description(self, status):
        if status == ‘OPEN‘:
            print(‘{}饭店营业正常营业‘.format(self.name))
            for item in self.args:
                print(‘美食种类有:{}‘.format(item))
        elif status == ‘CLOSED‘:
            print(‘{}饭店暂停营业，欢迎下次光临!‘.format(self.name))


if __name__ == ‘__main__‘:
    a = Restaurant(‘金手勺‘, ‘米饭‘, ‘馒头‘, ‘大饼‘)
    a.description(‘OPEN‘)
    a.description(‘CLOSED‘)

class Restaurant:
    """
    创建一个餐馆类
    """
    def __init__(self, restaurant_name, cooking_type):
        self.restaurant_name, self.cooking_type = restaurant_name, cooking_type

    def describe_restaurant(self):
        print("*" * 46)
        print("{:^40s}\n".format(self.restaurant_name))
        for key, item in enumerate(self.cooking_type, start=1):
            print("\t{}.{}".format(key, item))
        print("\t请点餐，祝您用餐愉快！")
        print("*" * 46)

    def open_restaurant(self):
        print("{}，正在营业...".format(self.restaurant_name))


cooking_types = ["北京烤鸭", "四川麻婆豆腐", "西湖醋鱼", "飞龙汤", "无为熏鸭", "东坡肉", "腊味合蒸", "辣子鸡", "东安子鸡", "清 蒸武昌鱼"]
famous_restaurant = Restaurant("可优吃不腻餐馆", cooking_types)
famous_restaurant.describe_restaurant()
famous_restaurant.open_restaurant()

class MathOperation:
    """
    数学运算类
    """
    def __init__(self, one_num, two_num):
        self.first_num, self.second_num = one_num, two_num

    def add(self):
        return self.first_num + self.second_num

    def minus(self):
        return self.first_num - self.second_num

    def multiply(self):
        return self.first_num * self.second_num

    def divide(self):
        try:
            return round(self.first_num / self.second_num, 2)   # 相乘之后四舍五入
        except ZeroDivisionError:
            # print("出现除0错误！")
            return "∞"


if __name__ == ‘__main__‘:
    # one_number = 10
    # two_number = 0
    # math_operate = MathOperation(one_number, two_number)
    # print("{} + {} = {}".format(one_number, two_number, math_operate.add()))
    # print("{} - {} = {}".format(one_number, two_number, math_operate.minus()))
    # print("{} * {} = {}".format(one_number, two_number, math_operate.multiply()))
    # print("{} / {} = {}".format(one_number, two_number, math_operate.divide()))

    nums = (10, 0)      # 传入两个参数
    math_operate1 = MathOperation(*nums)    # *号代表解包：10和0
    print("{} + {} = {}".format(*nums, math_operate1.add()))
    print("{} - {} = {}".format(*nums, math_operate1.minus()))
    print("{} * {} = {}".format(*nums, math_operate1.multiply()))
    print("{} / {} = {}".format(*nums, math_operate1.divide()))

class Tool:
    """
    定义工具类
    """

    def __init__(self, name, desc, price):
        """ 构造方法
        :param name: 工具名称
        :param desc: 工具描述
        :param price: 工具价格
        :return: 无
        """
        self.name, self.desc, self.price = name, desc, price

    def describe_tool(self):
        """
        获取工具描述信息
        :return: """
        print("\n{:*^100}".format("开始描述"))
        print(f"名称：{self.name}\n功能：{self.desc}\n价格： {self.price}")
        print("{:*^100}\n".format("结束描述"))

    def __str__(self):
        return "<{}>".format(self.name)


class ToolPackage:
    """
    定义工具箱类
    """
    tools_count = 0

    def __init__(self, name):
        self.name = name
        self.all_tools = []  # 存放工具的列表

    def add(self, one_tool):
        """
        添加工具到工具箱中
        :param one_tool: Tool工具对象
        :return: """
        if isinstance(one_tool, Tool):
            self.all_tools.append(one_tool)
            self.modify_tool_count()
            print("成功添加【{}】到【{}】中！".format(one_tool.name, self.name))
        else:
            print("{}不是工具对象，无法添加！".format(one_tool))

    def has_tool(self, one_tool):
        """
        判断工具是否在工具箱中
        :param one_tool: Tool工具对象或者工具名
        :return: True or False
        """
        if isinstance(one_tool, Tool):  # 如果one_tool是工具对象
            return one_tool in self.all_tools  # 判断是否在工具箱中
        elif isinstance(one_tool, str):  # 如果是工具名，字符串
            for tool_obj in self.all_tools:
                if one_tool == tool_obj.name:
                    return True
        return False

    def remove(self, one_tool):
        """
        删除工具
        :param one_tool: Tool工具对象或者工具名称
        :return:
        """
        if self.has_tool(one_tool):  # 如果要删除的工具存在
            if isinstance(one_tool, Tool):  # 如果one_tool为Tool工具对象
                self.all_tools.remove(one_tool)
            else:  # 为工具名称字符串
                for index, item in enumerate(self.all_tools):
                    if one_tool == item.name:  # 当前遍历的工具名为 one_tool
                        self.all_tools.pop(index)
                        break  # 删除之后，退出循环
        else:
            print("工具不存在，无法删除！")

    def search(self, one_tool):
        """
        根据工具对象或者工具名称查找工具
        :param one_tool: Tool工具对象或者工具名称
        :return:
        """
        if self.has_tool(one_tool):
            if isinstance(one_tool, Tool):  # 如果one_tool为Tool工具对象
                one_tool.describe_tool()
            else:  # 为工具名称字符串
                for index, item in enumerate(self.all_tools):
                    if one_tool == item.name:  # 当前遍历的工具名为 one_tool
                        self.all_tools[index].describe_tool()
                        break  # 找到工具之后，退出循环
        else:
            print("工具不存在！")

    @classmethod
    def modify_tool_count(cls):
        """
        类方法，每调用一次工具总数加一
        :return:
        """
        cls.tools_count += 1

    @classmethod
    def get_tool_count(cls):
        """
        类方法，获取工具箱中，工具总数
        :return:
        """
        return cls.tools_count


hammer = Tool("锤子", "由金属或木头等材料做成的头和与之垂直的柄构成的敲击工 具。", 25.2)
screwdriver = Tool("螺丝刀", "是一种用来拧转螺丝以使其就位的工具，通常有一个薄 楔形头，可插入螺丝钉头的槽缝或凹口内。", 5)
saw = Tool("锯子", "用来把木料或者其他需要加工的物品锯断或锯割开的工具。", 12)
electric_drill = Tool("电钻", "利用电做动力的钻孔机具。", 278)

family_tool_package = ToolPackage("家用工具箱")
# 将工具添加到工具箱中
family_tool_package.add(hammer)
family_tool_package.add(screwdriver)
# 删除一个不存在的工具
family_tool_package.remove(saw)
# 按照工具的名字来删除一个工具
family_tool_package.remove("锤子")
# 再次添加工具
family_tool_package.add(electric_drill)
# 查询工具
family_tool_package.search(saw)  # 查询不存在的工具
family_tool_package.search(screwdriver)  # 查询已存在的工具
family_tool_package.search("电钻")  # 通过工具名来查询工具
# 获取工具总数
print("{}中现在有【{}】件工具。".format(family_tool_package.name, family_tool_package.get_tool_count()))