类名称空间对象名称空间,组合

 

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)
obj1 = A('oldboy',1000)
obj1 = A('oldboy',1000)
obj1 = A('oldboy',1000)
print(obj1.name)
print(obj1.job)
print(obj1.home)

类的查询顺序: 直接从类本身找.(不能去对象里找)
print(A.name)

对象的问题:
无论创建多少对象,都是开辟独立的空间,各个对象之间不能互相查找,干扰.
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 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)
面试题:

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)    #10,20,报错
# print(A.a,A.b,A.c)

 

组合:

描述一个圆形
属性 半径
方法  计算周长 ，计算面积
周长—— 3.14*2*r
面积——3.14*2*r**2
函数版：
def perimeter(r):  #计算周长
    return  3.14*2*r
def area(r): #计算面积
    return 3.14*2*r**2
面向对象版：
class Circle:
    def __init__(self,r):
        self.r = r
    def perimeter(self): #计算周长
        return 3.14*2*self.r
    def area(self):    #计算面积
        return 3.14*self.r**2
c1 = Circle(1)
c1 = Circle(2)
c1 = Circle(3)
print(c1.area())
print(c1.perimeter())

静态属性和对象属性的区别是什么？
如果所有的对象的某一个值都是相同的，就用静态属性
如果每一个对象的某一个值都不相同，就用对象属性。

人狗大战2：
（添加了装备）
class Person:
    def __init__(self,name,sex,hp,ad):
        self.name = name
        self.sex = sex
        self.hp = hp
        self.ad = ad
        self.money = 0
    def attack(self,dog):
        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):
        person.hp -= self.ad
# 装备
# 花钱 -> 装备 -> 攻击力上升
# 价格
# # 加一些生命值、为任务添加攻击力
# # 秘技
class Weapon:
    def __init__(self,name,price,ad=0,hp=0):
        self.name = name
        self.price = price
        self.ad = ad
        self.hp = hp
        self.ad_total = self.ad    # 人和武器的攻击力的总和
    def kill(self,dog):
        dog.hp -= self.ad_total

alex = Person('alex',None,50,1)
taibai = Dog('哮天犬','teddy',200,30)
alex.attack(taibai)
print(taibai.hp)
板儿砖 = Weapon('打狗砖',998,190)
print(板儿砖.__dict__)
alex.weapon = 板儿砖
alex.weapon.kill(taibai)   # ---> 组合
print(taibai.hp)
（装备充值）
class Person:
    def __init__(self,name,sex,hp,ad):
        self.name = name
        self.sex = sex
        self.hp = hp
        self.ad = ad
        self.money = 0
    def attack(self,dog):
        dog.hp -= self.ad

    def recharge(self,money):
        self.money += money

    def buy_weapon(self,wp):   # self ->alex  wp -> 板儿砖
        if self.money >= wp.price:
            self.money -= wp.price
            self.weap = wp
            # self.ad += wp.ad
            self.weap.ad_total += self.ad
            print('武器装备成功，当前余额%s'%self.money)
        else:
            print('余额不足，请充值再来')

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):
        person.hp -= self.ad

class Weapon:
    def __init__(self,name,price,ad=0,hp=0):
        self.name = name
        self.price = price
        self.ad = ad
        self.hp = hp
        self.ad_total = self.ad    # 人和武器的攻击力的总和
    def kill(self,dog):
        dog.hp -= self.ad_total

alex = Person('alex',None,50,1)
taibai = Dog('哮天犬','teddy',200,30)
板儿砖 = Weapon('打狗砖',998,190)
alex.buy_weapon(板儿砖)
alex.recharge(1000)
alex.buy_weapon(板儿砖)
alex.weap.kill(taibai)
print(taibai.hp)

组合：两个类的事儿
关系:一个类有另一个类  比如  人有武器
一个类的对象作为另一个类对象的属性
武器类的对象作为人类对象的一个属性
课程类的对象作为学生对象的一个属性
圆形类的对象作为圆环对象的一个属性

学生类和课程类组合：
学生类 课程类 —— 学生和课程组合在一起
    学生类 ： 学生姓名 性别 年龄 手机号 课程
    课程类 ： 名称 周期 价格

class Student:
    def __init__(self,name,sex,age,number,course):
        self.name = name
        self.sex = sex
        self.age = age
        self.number = number
        self.course = course

class Course:
    def __init__(self,name,period,price):
        self.name = name
        self.period = period
        self.price = price

python = Course('python','6 months',20000)
python.period = '5 months'
xiaoming = Student('小明','male',18,1234567891,python)
xiaoming2 = Student('小明2','male',18,1234567891,python)
xiaoming3 = Student('小明3','male',18,1234567891,python)
print(xiaoming.course.name)
print(xiaoming2.course.period)
print(xiaoming3.course.period)
print(xiaoming.course.period)
print(xiaoming.course.__dict__)

圆形类和圆环类组合：
圆形类 圆环类 —— 圆环和圆形组合在一起

from math import pi
class Circle:
    def __init__(self,r):
        self.r = r
    def perimeter(self): #计算周长
        return pi*2*self.r
    def area(self):  # 计算面积
        return pi*self.r**2

class Ring:
    def __init__(self,out_r,in_r):
        self.out_circle = Circle(out_r)
        self.in_circle = Circle(in_r)
    def peri(self):
        return self.out_circle.perimeter() + self.in_circle.perimeter()
    def are(self):
        return self.out_circle.area() - self.in_circle.area()

r = Ring(10,5)
print(r.peri())
print(r.are())