20210121 直播课 python脚本编写

class  类名

多个类属性

多个类方法

类的命名：驼峰，首字母大写

变量，方法的命名：小写

"""
class 类名：
类名的命名规则：驼峰命名法：首字母大写
定义变量首字母不用大写
    多个类属性
    多个类方法:类中的函数
"""
class House:
    #静态属性 ->类变量，在类之中，方法之外定义
    door = "red"
    floor = "white"
    #动态方法
    def sleep(self):
        print("在房子里可以睡觉")
        #普通变量，可以定义在方法之中 ->类之中，方法之中，并且前面没有self开头
        bad  = "ximengxi"
    def cook(self):
        print("在房子里可以做饭吃")
if __name__ == '__main__':
    #实例化->变量 = 类（）
    north_house = House()
    china_house = House()
    #通过实例对象，去调用类的静态属性
    #print(north_house.door)
    #通过类也是可以调用属性的
    #print(House.door)
    #通过类可以修改属性，
    #House.door = "YEWLLO"
    #通过实例修改属性，只能修改本实例
    north_house.door = "green"
    print(north_house.door)
    print(china_house.door)
    print(House.door)

 普通变量

class House:
    #静态属性 ->类变量，在类之中，方法之外定义
    door = "red"
    floor = "white"
    #动态方法
    def sleep(self):
        # 普通变量，可以定义在方法之中 ->类之中，方法之中，并且前面没有self开头
        bed = "ximengxi"
        print(f"在房子里可以躺着{bed}上睡觉")   
    def cook(self):
        print("在房子里可以做饭吃")
if __name__ == '__main__':
    #实例化->变量 = 类（）
    north_house = House()
    china_house = House()
    north_house.sleep()

 构造函数（方法）： 在类实例化的时候，直接自动执行

class House:
    #静态属性 ->类变量，在类之中，方法之外定义
    door = "red"
    floor = "white"
    #构造方法,在类实例化的时候自动执行
    #构造方法和动态方法的区别：构造方法在类实例化的时候自动被调用，动态方法需要手动调用
    def __init__(self):
        #加上self.就变成了实例变量
        print(self.door)
        #定义实例变量->类之中，方法之内,必须以self.变量名的方式定义
        #实例变量的作用域：整个类中的所有方法(如果想扩大变量作用域，就可以写成实例变量）
        #实例变量也不一定非要在构造方法里面，其他地方也行的，只要是self.+变量名就可以了
        self.kitchen = "cook"
        print(self.kitchen)
    #动态方法
    def sleep(self):
        # 普通变量，可以定义在方法之中 ->类之中，方法之中，并且前面没有self开头
        bed = "ximengxi"
        print(f"在房子里可以躺着{bed}上睡觉")
    def cook(self):
        print("在房子里可以做饭吃")
if __name__ == '__main__':
    #实例化->变量 = 类（）
    north_house = House()
    #只要实例化了，就会调用构造方法
    china_house = House()

 self

class House:
    #静态属性 ->类变量，在类之中，方法之外定义
    door = "red"
    floor = "white"
    #构造方法,在类实例化的时候自动执行
    #构造方法和动态方法的区别：构造方法在类实例化的时候自动被调用，动态方法需要手动调用
    def __init__(self):
        self.kitchen = "cook"
        print(self.kitchen)
    #动态方法
    def sleep(self):
        # 普通变量，可以定义在方法之中 ->类之中，方法之中，并且前面没有self开头
        bed = "ximengxi"
        pool = "wulawula"
        print(f"在房子里可以躺着{bed}上睡觉")
        print(f"在房子里可以躺着{pool}上睡觉")
    def cook(self):
        print("在房子里可以做饭吃")
if __name__ == '__main__':
    #实例化->变量 = 类（）
    north_house = House()
    #只要实例化了，就会调用构造方法
    china_house = House()
    north_house.sleep()

 回合类游戏

class Games:
    def __init__(self):
        #初始化属性
        self.my_hp = 1000
        self.my_power = 200
        self.enemy_hp = 1000
        self.enemy_power = 199

    def fight(self):
        while True:
            self.my_hp -=self.enemy_power
            self.enemy_hp -= self.my_power
            print(f"我的血量{self.my_hp} VS 对手的血量{self.enemy_hp}")
            if self.my_hp <= 0:
                print("我输了")
                break
            elif self.enemy_hp <= 0:
                print("我赢了")
                break

if __name__ == '__main__':
    game =Games()
    game.fight()

 重写

Game_oop.py

class Games:
    def __init__(self):
        #初始化属性
        self.my_hp = 1000
        self.my_power = 200
        self.enemy_hp = 1000
        self.enemy_power = 199

    def fight(self):
        while True:
            self.my_hp -=self.enemy_power
            self.enemy_hp -= self.my_power
            print(f"我的血量{self.my_hp} VS 对手的血量{self.enemy_hp}")
            if self.my_hp <= 0:
                print("我输了")
                break
            elif self.enemy_hp <= 0:
                print("我赢了")
                break

if __name__ == '__main__':
    game =Games()
    game.fight()

houyi.py

from Game_oop import Games


class Houyi(Games):
    def __init__(self):
        self.defense = 100
        #继承父类的构造方法
        super().__init__()

    def fight(self):
        while True:
            self.my_hp = self.my_hp -  self.enemy_power + self.defense
            self.enemy_hp -= self.my_power
            print(f"我的血量{self.my_hp} VS 对手的血量{self.enemy_hp}")
            if self.my_hp <= 0:
                print("我输了")
                break
            elif self.enemy_hp <= 0:
                print("我赢了")
                break
if __name__ == '__main__':
    houyi = Houyi()
    #子类对象可以直接调用父类的属性和方法
    houyi.fight()

 私有方法和私有属性

class Games:
    def __init__(self, my_hp, enemy_hp):
        # 初始化属性
        self.my_hp = my_hp
        self.my_power = 200
        self.enemy_hp = enemy_hp
        self.enemy_power = 199
        #定义私有属性
        self.__secret = "secret"


    def fight(self):
        while True:
            self.my_hp -= self.enemy_power
            self.enemy_hp -= self.my_power
            print(f"我的血量{self.my_hp} VS 对手的血量{self.enemy_hp}")
            if self.my_hp <= 0:
                print("我输了")
                break
            elif self.enemy_hp <= 0:
                print("我赢了")
                break
    #定义休息方法
    def rest(self,time_num):
        self.__private_mathod()
        print(f"太累了，休息{time_num} 分钟")
        print(self.__secret)

     #定义私有方法
    def __private_mathod(self):
        print(self.__secret)
        print("这是一个私有方法")



if __name__ == '__main__':
    game = Games(1000, 1100)
    game.fight()
    game.rest(3)
    #私有变量不能通过对象去直接调用
    #私有方法也不能通过对象去直接调用

类的继承

 装饰器