python - 面向对象基础（类，对象，查询顺序，组合）

class Person:  # 通过class创建一个类，类名首字母大写

class Person:  # 创建一个类，类名首字母大写
    mind = ‘思想‘  # 定义一个变量，静态变量，静态字段
    faith = ‘信仰‘
    def __init__(self):
        print(‘今天又是充满元气的一天‘)

    def work(self):  # 方法，函数，动态变量
        print(‘新的一天‘)

# 类名.__dict__ 查询类中所有内容。（不能进行增删改操作）
print(Person.__dict__) 
# 类名.__dict__[‘静态变量‘] 查询静态变量的内容。（不推荐）
print(Person.__dict__[‘mind‘])

# 万能的 . 对类中的单个变量进行增删改查操作
Person.money = ‘600‘    # 增
del Person.faith        # 删
Person.mind = ‘思维‘    # 改
print(Person.mind)      # 查
print(Person.__dict__)

Person.work(‘传一个参数‘) # 调用方法 （不推荐）

Person()    # 类名+（）实例化的过程，创建一个对象的过程（也叫对象空间）
　　　　　　　 # 只要 类名+（），就会自动执行类中的__init__方法

    def __init__(self,name,age,hobby):
        self.name = name
        self.age = age
        self.hobby = hobby  # 给对象空间封装属性

p1 = Person(‘alex‘,‘26‘,‘篮球‘)   
p1.sex = ‘女‘    # 增
del p1.hobby    # 删
p1.age = 18     # 改
print(p1.name)  # 查
print(p1.__dict__)  # 查对象空间中所有内容
# 输出结果{‘name‘: ‘alex‘, ‘age‘: 18, ‘sex‘: ‘女‘}
#1. 类名+（）产生一个实例（对象，对象空间）
#2. 自动执行__init__方法，将对像空间传给参数self
#3. 给对象封装对应的属性

p1.work()

# 组合：给一个类的对象封装一个属性，这个属性又是另一个类的对象
class GameRole:

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

    def attack(self, role):
        role.ph = role.ph - self.ad
        print(‘%s 攻击了 %s,打了%s血，还剩%s血‘ % (self.name, role.name, self.ad, role2.ph))

    def Weapon_attributes(self,wea):
        self.wea = wea

class Weapon:
    def __init__(self, name, ad):
        self.name = name
        self.ad = ad

    def fight(self, role1, role2):
        role2.ph = role2.ph - self.ad

        print(‘%s 拿 %s 攻击了 %s,打了%s血，还剩%s血‘ % (role1.name, self.name, role2.name, self.ad, role2.ph))
        if role2.ph == 0:
            print(‘%s死掉了‘ % role2.name)

role1 = GameRole(‘阿狸‘, 60, 500)
role2 = GameRole(‘卡特琳娜‘, 80, 700)
axe = Weapon(‘开天斧‘,500)
broadsword = Weapon(‘青龙偃月刀‘,300)
axe.fight(role2,role1)
role1.Weapon_attributes(broadsword)
print(role1.__dict__)
role1.wea.fight(role1,role2)
role1.wea.fight(role1,role2)