python 面向对象初识 2类名称空间,对象名称空间 ,组合

重要:对象:

1 在内存中创造了一个空间,空间在创立之初有一个指向

2在自动执行__init__(self),并且将对象利用指向传给self

3 在__init__方法中,给对象空间封装一些属性,然后在将完善好的空间,返回给类名(),这个对象.

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

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

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

其中类的数据属性是共享给所有对象的

而类的动态属性是绑定到所有对象的

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

在obj.name会先从obj自己的名称空间里找name，找不到则去类中找，类也找不到就找父类...最后都找不到就抛出异常

来实在的吧

job1 = 'teacher'
# class A:
#     home = '老男孩教育'
#     name = '武大'
#     def __init__(self, name, age):
#         self.name = name
#         self.age = age
#     def job(self):
#         print('我在开车.....')

　查询顺序
# 对象的查询顺序:先从对象空间去找,对象的空间没有此变量或者方法,通过对象中的类对象指针去类中寻找　

类的查询顺序: 直接从类本身找.

对象的问题
# 无论创建多少对象,都是开辟独立的空间,各个对象之间不能互相查找,干扰.

obj1 = A('oldboy',1000)
# obj2 = A('alex',10000)

# import girldriver
# girldriver.func()

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

# class A:
#     home = '老男孩教育'
#     name = '武大'
#     count = 0
#     def __init__(self, name, age):
#         A.count = A.count + 1
#         self.name = name
#         self.age = age
#     def job(self):
#         print('我在开车.....')
#
# obj1 = A('alex1',1000)
# obj2 = A('alex2',1000)
# obj3 = A('alex3',1000)
# obj4 = A('alex4',1000)
# print(A.count)

　　　组合:

组合用一个class调用另一个class,使用的是变量赋值的方法 class1的对象 ---self.需要调用的属性(注意在此之前属性已被class1的对象打包)---------class2的属性--------对象或者属性的调用.

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

class Game_role:
    def __init__(self, name, ad, hp):
        self.name = name
        self.ad = ad
        self.hp = hp
    def attack(self,obj1):
        obj1.hp = obj1.hp - self.ad
        print('%s攻击%s,%s掉了%s血,还剩%s血'%(self.name,obj1.name,obj1.name,self.ad,obj1.hp))
    def package_weapon(self,wea):
        self.weapon = wea

class Sword:
    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血' %(p1.name,self.name,p2.name,p2.name,p2.hp))

 aduan = Game_role('啊段', 10, 100)
# ts = Game_role('泰森', 120, 300)
# Slaughter_knife = Sword('杀猪刀',200)
# 这么写不好,动作的发起人是人而不是刀本身
# Slaughter_knife.fight(aduan,ts)
# 下面是符合逻辑的
# aduan.package_weapon(Slaughter_knife)  # 给aduan 这个对象封装了一个weapon属性这个属性值为Slaughter_knife
# aduan.weapon.fight(aduan,ts)
# ts.attack(aduan)
# print(aduan.weapon)
# print(aduan.weapon.name)
# aduan.weapon.fight(aduan,ts)

　　这里的a = 10 ,b = 20 c因为是函数中暂存的空间,所以不存在

class A:
    a = 1
    b = 2

    def __init__(self):
        c = 5

    def func(self):
        pass


a1 = A()
A.a = 10
A.b = 20
print(a1.a, a1.b, a1.c)