現在有個需求，需要製作一個人狗大戰遊戲
角色
人
    基礎屬性
        name
        sex
        hp
        mp
        ad
狗
    基礎屬性
        name
        kind
        hp
        ad
生成這些角色的屬性需要字典
bob = {'name':'bob','sex':'man','hp':10,'mp':10,'ad':1}
dog = {'name':'新新','kind':'金毛','hp':99999,'ad':99999}
如果是多人多狗遊戲，我們需要給每個人都建立字典，太麻煩而且字典的key無法固定

所以我們製造一個模子，刻畫一個人應該有的屬性，固定屬性和key值
def Person(name,sex,hp,mp,ad):
    info_dic = {'name':name,'sex':sex,'hp':hp,'mp':mp,'ad':ad}
    return info_dic

def attack(person,dog):
    print('%s攻擊了%s'%(person['name'],dog['name']))
    dog['hp'] -= person['ad']

def Dog(name,kind,hp,ad):
    info_dic = {'name':name,'kind':kind,'hp':hp,'ad':ad}
    return info_dic

def bite(dog,person):
    print('%s咬了%s'%(dog['name'],person['name']))
    person['hp'] -= dog['ad']

alex = Person('alex','man',10,10,0.1)
print(alex)
yuan = Person('yuan','male',100,100,1)
print(yuan)
jin = Dog('新新','金毛',9999,9999)
print(jin)
attack(alex,jin)
print(jin['hp'])
bite(jin,alex)
bite(alex,jin)

上邊的例子可以改寫成
def Person(name,sex,hp,mp,ad):
    person = {'name':name,'sex':sex,'hp':hp,'mp':mp,'ad':ad}
    def attack(dog):
        print('%s攻擊了%s'%(person['name'],dog['name']))
        dog['hp'] -= person['ad']
    person['attack'] = attack
    return person
def Dog(name,kind,hp,ad):
    dog = {'name':name,'kind':kind,'hp':hp,'ad':ad}
    def bite(person):
        print('%s咬了%s'%(dog['name'],person['name']))
        person['hp'] -= dog['ad']
    dog['bite'] = bite
    return dog
alex = Person('alex','man',10,10,0.1)
jin = Dog('新新','金毛',9999,9999)
print(alex)
alex['attack'](jin)
print(jin)
jin['bite'](alex)

通過上邊的事例可以發現
面向物件程式設計
    人狗大戰
    角色分開：人-狗
    人的基礎屬性給人：人模子
    狗的基礎屬性給狗：狗模子

模子：類(抽象的)
框架，不是具體的擁有某些屬性值的物體
而是規範一類物體有哪些共同的屬性和方法

呼叫模子得到的結果：物件(具體的值)
根據模子的規範，填上具體的值就是一個物件
python中一切皆物件

類的定義方法：(類只做兩件事,例項化物件(物件=類名()),檢視類中的屬性(類名.(靜態/類)屬性名())
class 類名(首字母大寫):
    類體
物件名 = 類名(例項化過程的值)
例子
    class Person:
        pass
    print(Person)
結果
    <class '__main__.Person'>

object 物件=類名

例子：
    class Person:
        pass
    a = Person()
    print(a)
結果
    <__main__.Person object at 0x00000164423AEA90>

class Person:
    def __init__(self,name,sex,hp,mp,ad):
    #本身就存在的內建方法
    #self是一塊記憶體空間
        print(name,sex,hp,mp,ad)
bob = Person('bob','man',10,10,0.1)
類名()相當於執行類中的__init__方法

但self與bob有什麼關係呢?
    class Person:
        AAA = 'Linux'   #靜態屬性/類屬性(屬於類的,所有屬於這個類的物件都共這個共同的屬性)
        def __init__(self,name,sex,hp,mp,ad):
            self.name = name    #屬性，屬性物件的值(物件屬性)
            self.sex = sex
            self.hp = hp
            self.mp = mp
            self.ad = ad
    bob(物件) = Person('bob','man',10,10,0.1) #例項化
    yuan = Person('yuan','male',100,100,2)
    print('bob--->',bob)
    # 類 -->例項化-->物件(例項)
    print(bob.name)
    print(bob.sex)
    print(bob.hp)
    print(bob.mp)
    print(bob.ad)
    print('bob,yuan',bob,yuan)
    print(Person.AAA,bob.AAA)
結果
    bob---> <__main__.Person object at 0x000001D9A3824780>
    bob
    man
    10
    10
    0.1
    bob,yuan <__main__.Person object at 0x000001D9A3824780> <__main__.Person object at 0x000001D9A38247F0>
    Linux Linux

呼叫
    class Person:
        def __init__(self,name,sex,hp,mp,ad):
            self.name = name
            self.sex = sex
            self.hp = hp
            self.mp = mp
            self.ad = ad
        def attack(self):   #動態屬性,一個函式在類當中定義函式就是方法,方法自帶self引數
            print('%s發起了攻擊'%self.name)
    bob = Person('bob','man',10,10,0.1)
    bob.attack()    #Person.attack(bob)
結果
    bob發起了攻擊


物件能夠完成的事情
    操作物件的屬性
    呼叫物件的方法
類:具有相同屬性和方法的一類事務(框架 模子)
物件
    物件是類中一個具體的例子(擁有具體的屬性值和具體的方法)
    物件就是類的例項化,類的例項
例項：例項完全和物件是一樣的
例項化：是由類建立物件的過程
類名能做什麼?
    例項化
    呼叫類中的靜態屬性
例項化的過程: 物件名 = 類名(引數)
    1.建立一個屬於物件的空間
    2.將這個空間的地址和引數傳遞給__init__方法
    3.執行init方法
    4.將物件的空間返回給物件名
靜態屬性: 所有的這個類的物件都共有的屬性\
物件能做什麼?
    呼叫物件的屬性
    呼叫類中的方法(動態屬性)
物件的屬性: 儲存在例項化之後建立的空間中的所有變數都是物件的屬性
            每一次例項化產生的空間都是獨立的,每一個物件都有自己的屬性值
動態屬性: 定義在類中的函式,自帶一個self,就是呼叫這個方法的物件本身

物件的屬性操作
class Person:
    def __init__(self,name,sex,hp,mp,ad):
        self.name = name
        self.sex = sex
        self.hp = hp
        self.mp = mp
        self.ad = ad
    def attack(self):
        print('%s發起了攻擊'%self.name)

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

bob = Person('bob',None,10,10,0.1)
jin = Dog('新新','金毛',9999,9999)

print(bob.__dict__)
bob.__dict__['name'] = 'jrey'
print(bob.name)
結果
{'name': 'bob', 'sex': None, 'hp': 10, 'mp': 10, 'ad': 0.1}
jrey

查
print(bob.hp)
改
bob.hp = 99
print(bob.hp)
增
bob.level = 1
print(bob.level)
刪
del bob.level
# print(bob.level)

兩個類的物件之間的互動
# 人打狗,狗掉血  attack
# 狗咬人,人掉血  bite
    class Person:    # 類
        def __init__(self,name,sex,hp,mp,ad):
            self.name = name
            self.sex = sex
            self.hp = hp
            self.mp = mp
            self.ad = ad
        def attack(self,dog):
            print('%s攻擊了%s'%(self.name,dog.name))
            dog.hp -= self.ad
    class Dog:
         def __init__(self,name,kind,hp,ad):
             self.name = name
             self.kind = kind
             self.hp = hp
             self.ad = ad
         def bite(self,person):
             print('%s咬人%s'%(self.name,person.name))
             person.hp -= self.ad
             if person.hp <= 0 :
                 print('%s死了'%person.name)
                 person.hp = 0
    #例項化一些物件
    bob = Person('bob',None,10,10,0.1)
    haha = Dog('新新','金毛',9999,998)
    print(haha.hp)
    bob.attack(haha)   # Person.attack(bob,haha)
    print(haha.hp)
    print(bob.hp)
    haha.bite(bob)
    print(bob.hp)
結果
    9999
    bob攻擊了新新
    9998.9
    10
    新新咬人bob
    bob死了
    0