python面向对象

课程视频链接

Python面向对象：https://b23.tv/jg6FZv

1. 基础篇教程代码

# 类是一个模板
#类属性：
# 1、整个类只有一份，所有的实例都共享这一份
# 2、可以通过类名或实例名访问类属性，访问的都是同一个
# 3、修改类属性需要通过类名，因为通过实例名会创建一个同名的实例变量
# 4、当实例属性和类属性相同时，通过实例访问，优先访问的是实例属性

# 类方法：
# 1、可以通过类名调用，也可以通过实例名调用
# 2、类方法不能访问实例变量，可以访问类变量
# 3、类方法需要加上@classmethod, 第一参数必须是class（cls）

# 静态方法：
# 1、需要加上@staticmethod
# 2、不需要传入实例或者类作为第一个参数


class Dog:
#     num_of_dogs = 0 #类属性，区分类属性和实例属性
    dogs = [] #用来保存所有狗的列表
    
    @classmethod  #类方法
    def num_of_dogs(cls): #添加类方法，@classmethod, 传参cls
        return len(cls.dogs)
    
    @classmethod
    def biggest(cls):
        max_height = -0.1
        for d in cls.dogs:
            if(d.height > max_height):
                max_height = d.height
        return max_height
    
    @staticmethod #静态方法
    def intro():
        print("Dog is human's best friend")
    
    #构造方法， 添加实例属性，做其他的初始化工作
    def __init__(self, name, height, power):#self指代一般实例，特殊
        self.name = name #属性可以由外部传入
        self.height = height
        self.blood = 10 #属性可以定成死的
        self.power = power
#         Dog.num_of_dogs += 1 #初始化个数
        Dog.dogs.append(self)
        print(f"{self.name}出生了，汪汪！")
        
        
    #创建实例方法、行为    
    def bark(self):#只有一个参数,调用的时候不用传
        #前面加f,后面可以加变量
        print(f'我是{self.name}，身高{self.height}，血量{self.blood}，攻击力{self.power}')
    
    def attack(self, dog2):#有2个参数,调用的时候传1个
        dog2.reduce_blood(self.power)
    
    def reduce_blood(self, reduce_value):
        if(reduce_value > self.blood):
            self.blood = 0
            print(f'{self.name}受到攻击，死亡')
        else:
            self.blood = self.blood - reduce_value
            print(f'{self.name}受到攻击，减少{reduce_value}点血量')
#创建2个实例
d1 = Dog('大黄', 0.7, 3) #self不用传入
d2 = Dog('二黑', 0.5, 4)

print(d1.blood)
d1.blood = 9 #修改属性
print(d1.blood)#属性不加括号
print(id(d1)) #取实例内存地址
print(id(d2))

d1.bark()#方法要加括号，属性不加括号
d2.bark()
d1.attack(d2)
d2.bark()

# Dog.num_of_dogs = 8 #修改类属性
# d1.num_of_dogs = 7 #给d1创建新的实例属性，当实例属性和类属性相同时，通过实例访问，优先访问的是实例属性
# print(Dog.num_of_dogs)#通过类名访问
# print(d1.num_of_dogs)#通过实例访问
# print(d2.num_of_dogs)#通过实例访问

print(Dog.num_of_dogs())#通过类名访问
print(d1.num_of_dogs())#通过实例访问
print(d2.biggest())#通过实例访问

Dog.intro()#通过类名访问
d1.intro()#通过实例访问

2. 类的继承

# 类的继承

# 模块类的引入
# import dog继承 as dog
# pd = dog.PetDog('小可爱',0.2,1,988)

class Dog:
    def __init__(self, name, height, power):#self指代一般实例，特殊
        self.name = name #属性可以由外部传入
        self.height = height
        self.blood = 10 #属性可以定成死的
        self.power = power
        
    def bark(self):#只有一个参数,调用的时候不用传
        #前面加f,后面可以加变量
        print(f'我是{self.name}，身高{self.height}')
        

# 牧羊犬
#类的继承，继承Dog类的一些属性
class SheepDog(Dog):  #对类的命名：驼峰命名法,各单词首字母大写
    def __init__(self, name, height, power, num_of_sheeps):
        super().__init__(name, height, power) #继承父类Dog
        self.num_of_sheeps = num_of_sheeps
    
    # 给子类添加方法
    def protect(self):  
        print('我开始保护小羊了！')
    
    # 重写父类方法
    def bark(self):
        print("我是牧羊犬，我骄傲！")
        super().bark() #继承父类Dog

# 警犬
class PoliceDog(Dog):  
    def __init__(self, name, height, power, ability):
        super().__init__(name, height, power) 
        self.ability = ability
    
# 宠物犬
class PetDog(Dog):  
    def __init__(self, name, height, power, price, house):
        super().__init__(name, height, power) 
        self.price = price
        self.house = house

class DogHouse():
    def __init__(self, no):
        self.no = no
        print(f'已创建狗窝{self.no}')

sd = SheepDog('牧羊犬1', 0.6, 4, 5) #self不用传入
print(sd.name)
print(sd.blood)
sd.bark()

house = DogHouse('9527')  #其他实例作为属性
pd = PetDog('小可爱',0.2,1,988, house) 

3. Dog版本的吃鸡游戏

片码段 dog.py

#2种狗具有不同的攻击力和防御能力。攻击强的防御弱；反之亦然；
import random
class Dog:
    dogs = [] #保存所有活着的Dog
    def __init__(self, name):
        self.name = name 
        self.blood = 100
        self.attack_power = 5
        self.defense_power = 3

    #攻击!
    def attack(self, dog2):
        print(f'{self.name}攻击{dog2.name}，攻击力:{self.attack_power}，防御力:{dog2.defense_power}')
        point = self.attack_power - dog2.defense_power
        if(dog2.blood > point):
            dog2.blood -= point
            print(f'{dog2.name}受到攻击，奋力自救，血量减少为{dog2.blood}')
        else:
            dog2.blood = 0
            print(f'{dog2.name}受到攻击，失血过多，死亡！😭😭😭😭😭😭😭😭')
            Dog.dogs.remove(dog2)   
    
    #判定狗的类型
    def dog_type(self):
        if(isinstance(self, SheepDog)):
            return '牧羊犬🐑'
        elif(isinstance(self, PoliceDog)):
            return '警犬👮'
        else:
            return '普通犬'


#牧羊犬
class SheepDog(Dog):
    def __init__(self, name):
        super().__init__(name)
        self.attack_power = random.randint(5, 10)
        self.defense_power = random.randint(3,5) 
        print('🐑牧羊犬{self.name}问世！')
        self.dogs.append(self)


#警犬
class PoliceDog(Dog):
    def __init__(self, name):
        super().__init__(name)
        self.attack_power = random.randint(8, 13)
        self.defense_power = random.randint(1,3) 
        print('👮‍♀️警犬{self.name}问世！')
        self.dogs.append(self)

主程序 game.py

#1. 首先创建100个Dog, 50个SheepDog, 50个PoliceDog
#2. 每一轮游戏，随机选出2个Dog
#3. dog1先攻击dog2，然后dog2攻击dog1
#3. 任何一方血量变为0就表明死亡！死亡的Dog退出游戏。
#4. 最后只有一个Dog了，游戏结束，胜利者可以吃鸡。
from dog import *
import random #产生随机数字
import time #时间模块

#1.创建100条狗
for i in range(100):
    if(i%2==0):
        SheepDog(i+1) #创建1个牧羊犬
    else:
        PoliceDog(i+1) #创建1个警犬

#2. 开始游戏循环
while(True):
    #判断是否只有1个Dog
    if(len(Dog.dogs) == 1):
        winner = Dog.dogs[0]
        print('🐔🐔🐔🐔🐔🐔🐔🐔')
        print('大吉大利，今晚吃鸡！')
        print(f'赢家是：{winner.dog_type()} {winner.name}')
        print('🐔🐔🐔🐔🐔🐔🐔🐔')
        break

    dog1, dog2 = random.sample(Dog.dogs, 2) # 随机选取两个
    dog1.attack(dog2)
    dog2.attack(dog1)
    time.sleep(0.02) # 休眠，产生视觉效果