类名称空间,查询顺序等/组合

主要内容:

面向对象中:

　　1.类名称空间和对象的名称空间

　　2.查询顺序

　　3.计算一个类中有多少实例化对象(含有__init__初始化方法的类)

　　4.组合

一.类名称空间和对象的名称空间

创建一个类就会创建一个类的名称空间,用来存储类中定义的所有名字,这些名字称为类的属性

而类有两种属性：静态属性和动态属性

• 静态属性就是直接在类中定义的变量
• 动态属性就是定义在类中的方法

其中类的静态属性是共享给所有对象的,而类的动态属性是绑定到所有对象的

创建一个对象/实例就会创建一个对象/实例的名称空间，存放对象/实例的名字，称为对象/实例的属性

#创建一个Person类
class Person:
    animal = '高级动物'
    soul = '有灵魂'        #类的静态变量/静态字段/静态属性
    language = '语言'

    #类的动态变量/动态属性/方法
    def __init__(self, country, name, sex, age, hight):   #初始化方法
        self.country = country
        self.name = name
        self.sex = sex
        self.age = age
        self.hight = hight

    def eat(self):
        print('%s吃饭' % self.name)

    def sleep(self):
        print('睡觉')

    def work(self):
        print('工作')

Person.__dict__['sleep'](111)   #内存地址+()也可以执行方法,相当于Person.sleep(111),,必须要加参数,否则不能打印睡觉

p1 = Person('菲律宾','alex','未知',42,175)     #实例化一个对象p1
# p1.animal = '禽兽'    #新增一个对象属性
# print(p1.animal)      #查看对象的属性值
print(Person.name)    #通过类查看类的属性

类名称空间和对象名称空间在内存的情况;

创建一个类,程序的执行情况:

 

二.查询顺序

#   对象.属性 : 先从对象空间找,如果找不到,再从类空间找,再找不到,再从父类找....
#   类名.属性 : 先从本类空间找,如果找不到,再从父类找....

同一个类中,对象与对象之间是互相独立的.

三.计算一个类中有多少实例化对象(含有__init__初始化方法的类)

1.代码

# 计算一个类 实例化多少对象.

class Count:
    count = 0
    def __init__(self):
        Count.count = self.count + 1

obj1 = Count()
obj2 = Count()

print(Count.count)  #2
count = 0

# 通过类名可以更改我的类中的静态变量值
Count.count = 6   #通过类名修改count值
print(Count.__dict__)
'''{'__module__': '__main__', 'count': 6, '__init__': <function Count.__init__ at 0x0000009D9F958A60>
 , '__dict__': <attribute '__dict__' of 'Count' objects>, '__weakref__': <attribute '__weakref__' of 'Count' objects>
 , '__doc__': None}
'''
# 但是通过对象 不能改变只能引用类中的静态变量
obj1.count = 6   #相当于在对象obj1新增属性,对类中的属性count无法修改.

2.执行过程

四.组合

组合: 给一个类的对象封装一个属性,这个属性是另一个类的对象.

# 组合: 给一个类的对象封装一个属性,这个属性是另一个类的对象.

# 版本一：添加武器：斧子，刀，枪，棍，棒...,
# 代码不合理: 人物利用武器攻击别人,你的动作发起者是人,而不是武器.
class GameRole:
    def __init__(self, name, ad, hp):
        self.name = name
        self.ad = ad
        self.hp = hp

    def attack(self,p):
        p.hp = p.hp - self.ad
        print('%s 攻击 %s,%s 掉了%s血,还剩%s血' %(self.name,p.name,p.name,self.ad,p.hp))

class Weapon:
    def __init__(self,name,ad):
        self.name = name
        self.ad = ad
    def fight(self,p1,p2):
        p2.hp = p2.hp - self.ad
        print('%s 用%s打了%s,%s 掉了%s血,还剩%s血'
              % (p1.name,self.name,p2.name,p2.name,self.ad,p2.hp))

p1 = GameRole('大阳哥',20,500)
p2 = GameRole('印度阿宁',50,200)
axe = Weapon('三板斧',60)
broadsword = Weapon('屠龙宝刀',100)
#用武器fight
axe.fight(p1,p2)   #大阳哥 用三板斧打了印度阿宁,印度阿宁 掉了60血,还剩140血
broadsword.fight(p2,p1)     #印度阿宁 用屠龙宝刀打了大阳哥,大阳哥 掉了100血,还剩400血
#不用武器attack
p1.attack(p2)    #大阳哥 攻击 印度阿宁,印度阿宁 掉了20血,还剩120血



# 版本二:
class GameRole:
    def __init__(self, name, ad, hp):
        self.name = name
        self.ad = ad
        self.hp = hp

    def attack(self,p):
        p.hp = p.hp - self.ad
        print('%s 攻击 %s,%s 掉了%s血,还剩%s血' %(self.name,p.name,p.name,self.ad,p.hp))

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


class Weapon:
    def __init__(self,name,ad):
        self.name = name
        self.ad = ad
    def fight(self,p1,p2):
        p2.hp = p2.hp - self.ad
        print('%s 用%s打了%s,%s 掉了%s血,还剩%s血'
              % (p1.name,self.name,p2.name,p2.name,self.ad,p2.hp))

p1 = GameRole('大阳哥',20,500)
p2 = GameRole('印度阿宁',50,200)
axe = Weapon('三板斧',60)
broadsword = Weapon('屠龙宝刀',100)
# print(axe)   #<__main__.Weapon object at 0x0000009E18C57C88>
p1.armament_weapon(axe)  # 给大阳哥 装备了三板斧这个对象.
# print(p1.wea)    #<__main__.Weapon object at 0x00000085E8A57C50>
# print(p1.wea.name)     #三板斧
# print(p1.wea.ad)       #60
p1.wea.fight(p1,p2)   #大阳哥 用三板斧打了印度阿宁,印度阿宁 掉了60血,还剩140血