day2_python面向对象基础知识

@类与对象

# 类名 大驼峰命名法 (所有单词的首字母都大写)
# object类 为基类 写不写都默认继承 基类
class Person(object):
    def __init__(self, name, age, height):
        self.name = name
        self.age = age
        self.height = height

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

    def eat(self):
        print("%s is eating" % self.name)


# 对象 xiaoming
xiaoming = Person("xiaoming", 18, 1.75)
xiaoming.run()
xiaoming.eat()

@私有属性与私有方法

# 在 属性名或者方法名前 增加 两个下划线，定义的就是私有属性或私有方法
class Person:
    def __init__(self, name):
        self.name = name
        # 私有属性
        self.__age = 18

    # 私有方法
    def __getage(self):
        print("%s is %d" % (self.name, self.__age))

    # 公有方法
    def age(self):
        self.__getage()


xiaohong=Person("小红")
print(xiaohong.name)

# 对象. 访问不到私有属性和私有方法
# 只有通过公有的方法才能调用自己的私有属性和私有方法
xiaohong.age()

@类属性和类方法

class Tool:
    # 类属性 count  相当于类内的 全局变量
    count = 0

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

        # 类名.类属性
        Tool.count += 1

    # 类方法，必须加 @classmethod
    # 类方法中用 cls 相当于类名，修改类名后也会跟着变
    @classmethod
    def show_tool_count(cls):
        print("类属性count有 %d 个工具" % cls.count)


ft = Tool("斧头")
cz = Tool("锤子")

print(ft.name)
print(cz.name)

print("现在创建了 %d 个工具" % Tool.count)
print("现在创建了 %d 个工具" % ft.count)  # 一般不用 对象.类属性的方法

# if对 对象.类属性 进行赋值，对象.类属性 会变，but 类名.类属性 不会变
ft.count = 99
print("对象.类属性 %d 个工具" % ft.count)
print("类名.类属性 %d 个工具" % Tool.count)

# 类方法  类名.方法
Tool.show_tool_count()

@静态方法

class Dog(object):
    # 静态方法，用@staticmethod修饰器 修饰
    @staticmethod
    def help():  # 静态方法 括号里不用写参数
        print("我是帮助菜单...")

# 类名.静态方法
Dog.help()

@str和del

class Cat:
    def __init__(self, name):
        self.name = name
        print("I'm %s" % self.name)

    def __str__(self):
        # 必须接返回值，且返回值必须为字符串
        # 打印对象时调用
        return "我是小老鼠%s" % self.name

    def __del__(self):
        # 删除一个对象时用 del对象名 的方法
        # 对象销毁时调用
        print("%s 走了" % self.name)


tom = Cat("tom")
# del 可以删除一个类的某个 对象
del tom

jierui = Cat("jierui")
# if 不在类里面定义str，则会打印对象的的引用地址 <__main__.Cat object at 0x0000023066369FD0>
# if 在类里面定义了str，则会打印return的内容 我是小老鼠jierui
print(jierui)

@封装

# 不依赖别人的 类 先设计
# 家具的名字和占地大小 不依赖于 家，所以先设计家具类

class HouseItem:
    def __init__(self, name, area):
        self.name = name
        self.area = area

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


class House:
    def __init__(self, house_type, area):
        self.house_type = house_type
        self.area = area

        # 剩余空闲面积
        self.free_area = area

        # 家具列表
        self.item_list = []

    def __str__(self):
        # Python 能够自动的将一对括号内部的代码连接在一起
        return ("户型：%s\n 总面积：%.2f[剩余：%.2f]\n 家具：%s"
                % (self.house_type, self.area,
                   self.free_area, self.item_list))

    # :HouseItem 为注解  目的是告诉集成开发环境 变量的类型
    def add_item(self, item: HouseItem):
        print("要添加的家具为：%s" % item)
        # 判断房子的剩余面积够放家具
        if house.free_area >= item.area:
            self.item_list.append(item)
            self.free_area -= item.area
        else:
            print("no area")


# 房子
house = House("四合院", 108)

# 要添加的家具
bed = HouseItem("bed", 20)
books_hoot = HouseItem("books_shoot", 40)
print(bed)
print(books_hoot)

# 执行添加命令
house.add_item(bed)
house.add_item(books_hoot)
print(house)

@继承

# 子类继承自父类，可以直接享受父类中已经封装好的 方法
# 子类 中应该根据职责，封装 子类特有的属性和方法
# 子类 拥有 父类 以及 父类的父类 中封装的所有 属性 和 方法
# 子类 不能访问父类的 私有属性 和 私有方法

# 专业术语
# • Dog 类是 Animal 类的 子类，Animal 类是 Dog 类的 父类，Dog 类从 Animal 类 继承
# • Dog 类是 Animal 类的 派生类，Animal类是 Dog 类的 基类，Dog 类从 Animal 类 派生


class Animal:
    def eat(self):
        print("eat")

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

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


# class 类名(父类,父类,...)
class Dog(Animal):
    def bark(self):
        print("狗咬人")


# 重写父类中的方法
class XiaoTian(Dog):
    def bark(self):
        # 虽然重写父类的方法，但是还是要调用父类的方法，用super().方法
        super().bark()
        print("像神一样")


dog = Dog()
# 子类继承自父类，可以直接享受父类中已经封装好的 方法
dog.sleep()
dog.run()
dog.eat()
print('*' * 50)

# 子类 拥有 父类 以及 父类的父类 中封装的所有 属性 和 方法
xtq = XiaoTian()
xtq.eat()
xtq.sleep()
xtq.run()
xtq.bark()

@多重继承

# MRO 是 method resolution order，主要用于 在多继承时判断 方法、属性 的调用 路径

class A:
    def demo(self):
        print("A demo")


class B:
    def demo(self):
        print("B demo")


# 多重继承，按继承顺序依次扫描方法和属性
class C(A, B):
    # def demo(self):
    #     print("C demo")
    pass


print(C.mro())  # 列表 [<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>]
print(C.__mro__) # 元组 (<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>)

c = C()
c.demo() # A demo

@多态

# 多态 不同的 子类对象 调用相同的 父类方法，产生不同的执行结果

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

    def game(self):
        print("%s 简单的玩耍" % self.name)


class XiaoTian(Dog):
    # def __init__(self, name):
    #     self.name = name

    def game(self):
        print("%s 在天上玩耍" % self.name)


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

    def play(self, dog):
        print("%s 正在和 %s 一起玩耍" % (self.name, dog.name))
        # 让狗玩耍
        dog.game()


dog = Dog("小黄")
xt = XiaoTian("哮天犬")
xiaoming = Person("小明")

dog.game()
xt.game()
xiaoming.play(xt)

@is 与 == 的区别

# is用于判断 两个变量 引用 对象 是否为同一个
# ==用于判断 引用变量的 值 是否相等

a = [1, 2]
b = [1, 2]
print(a is b)  # False
print(a == b)  # True
# id()可以查看是否引用的同一对象
print(id(a))   # 2083985472576
print(id(b))   # 2083995278080

@方法综合案例

class Game:
    # 类属性
    top_score = 0

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

    # 静态方法
    @staticmethod
    def show_help():
        print("我是帮助菜单")

    # 类方法
    @classmethod
    def show_top_score(cls):
        print("历史最高分为 %d" % cls.top_score)

    # 实例方法
    def start_game(self):
        print("当前玩家 %s 开始游戏" % self.player_name)


if __name__ == '__main__':
    Game.show_help()
    Game.show_top_score()
    game = Game("旭哥")
    game.start_game()