python我想对你说_python学习第15天----名称空间、组合

1.查询顺序

1)对象.属性：先从对象空间找，如果找不到，再从类空间找；再找不到，再从父类找。。

2)类名.属性：先从本类空间找，如果找不到，再从父类找。。。

注：对象与对象之间是相互独立的

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

classCount:

count= 0 #此处的count不是全局变量，如果要在方法中调用，需要通过类名.变量名的方式调用

def __init__(self):

Count.count= Count.count + 1c1=Count()

c2=Count()

c3=Count()

c4=Count()

c5=Count()print(Count.count)

输出：5

View Code

#通过类名可以修改类中的静态变量值

classCount:

count=0def __init__(self):

Count.count= Count.count + 1c1=Count()

Count.count= 20 #通过类名修改类中的静态变量值

print(Count.count)

输出：20

View Code

#通过对象只能引用类中的静态变量值，但是不可以改变类中的静态变量值，它改变的只是类对象空间

classCount:

count=0def __init__(self):

Count.count= Count.count + 1c1=Count()

c1.count= 20 #只是给对象空间，添加了一个count

print(c1.count)print(Count.count)print(c1.__dict__)print(Count.__dict__)

输出：20

1{'count': 20}

{'__dict__': , '__doc__': None, 'count': 1, '__weakref__': , '__module__': '__main__', '__init__': }

View Code

总结：类不可能找到对象空间中的属性，但是对象可以找到类中的属性；通过对象只能查找类中的属性，但是不能更改类中的属性(因为通过【对象.变量】只是给对象添加了一个属性，而不是给类)

2.组合

本质就是给一个对象封装一个属性，但是组合封装的属性是另一个类的对象

1)引例：模拟英雄联盟写一个游戏人物的类(升级题).

要求:

①创建一个 Game_role的类.

②构造方法中给对象封装name,ad(攻击力),hp(血量).三个属性.

③创建一个attack方法,此方法是实例化两个对象,互相攻击的功能:

例: 实例化一个对象 盖伦,ad为10, hp为100

实例化另个一个对象 剑豪 ad为20, hp为80

盖伦通过attack方法攻击剑豪,此方法要完成 '谁攻击谁,谁掉了多少血,  还剩多少血'的提示功能

classGameRole:def __init__(self,name,ad,hp):

self.name=name

self.ad=ad

self.hp=hpdefattack(self,p):

p.hp= p.hp-self.ad #需要在方法中把属性改变，负责没有变化

print("%s 攻击 %s, %s 掉了 %s 的血,还剩%s的血"%(self.name,p.name,p.name,self.ad,p.hp))

p1= GameRole("德玛",20,400)

p2= GameRole("亚索",40,200)

p1.attack(p2)print(p2.hp)

输出：

德玛 攻击 亚索, 亚索 掉了20的血,还剩180的血180

View Code

2)组合定义:给一个类的对象封装一个属性，这个属性是另一个类的对象

#针对上面程序，再添加一个武器类，完成X用X武器打了X，掉了X的血，还剩X的血

classGameRole:def __init__(self,name,ad,hp):

self.name=name

self.ad=ad

self.hp=hpdefattack(self,p):

p.hp= p.hp-self.adprint("%s 攻击 %s, %s 掉了 %s 的血,还剩%s的血"%(self.name,p.name,p.name,self.ad,p.hp))classWeapon:def __init__(self,name,ad):

self.name=name

self.ad=addeffight(self,p1,p2):

p2.hp= p2.hp -self.adprint("%s 用 %s 攻击了 %s , 掉了 %s 的血，还剩 %s 的血" %(p1.name,self.name,p2.name,self.ad,p2.hp))

p1= GameRole("德玛",20,400)

p2= GameRole("亚索",40,200)

bloodDrinkingSword= Weapon("饮血剑",60)

endlessBlade= Weapon("无尽之刃",100)

bloodDrinkingSword.fight(p1,p2)

endlessBlade.fight(p2,p1)print(p1.hp,p2.hp)

输出：

德玛 用 饮血剑 攻击了 亚索 , 掉了60 的血，还剩 140的血

亚索 用 无尽之刃 攻击了 德玛 , 掉了100 的血，还剩 300的血300 140

View Code

对于上面程序，虽然完成了功能，但是在代码的规范上是不合理的，容易让人看不明白，因为是人物利用武器攻击别人，动作的发起者是人，而不应该是武器

#版本二(利用组合)

classGameRole:def __init__(self,name,ad,hp):

self.name=name

self.ad=ad

self.hp=hpdefattack(self,p):

p.hp= p.hp-self.adprint("%s 攻击 %s, %s 掉了 %s 的血,还剩%s的血"%(self.name,p.name,p.name,self.ad,p.hp))defEquipped_with_weapon(self,wea):

self.wea=weaclassWeapon:def __init__(self,name,ad):

self.name=name

self.ad=addeffight(self,p1,p2):

p2.hp= p2.hp -self.adprint("%s 用 %s 攻击了 %s , 掉了 %s 的血，还剩 %s 的血" %(p1.name,self.name,p2.name,self.ad,p2.hp))

p1= GameRole("德玛",20,400)

p2= GameRole("亚索",40,200)

bloodDrinkingSword= Weapon("饮血剑",60)

endlessBlade= Weapon("无尽之刃",100)

p1.Equipped_with_weapon(bloodDrinkingSword)#给德玛装备了饮血剑这个对象;即把bloodDrinkingSword的对象空间传给了形参wea,即又给对象p1新增加了一个属性wea,wea的值为bloodDrinkingSword的对象空间，即最终给p1添加了饮血剑这个属性(添加的属性就是另一个类的对象)#通过如上语句后，实际上bloodDrinkingSword就是p1.wea，即给对象的一个属性，封装了另一个对象的属性

print(bloodDrinkingSword) #输出地址值<__main__.weapon object at>

print(p1.wea) #输出地址值<__main__.weapon object at>

print(p1.wea.name,p1.wea.ad) #输出饮血剑 60

p1.wea.fight(p1,p2)

输出：<__main__.weapon object at>

<__main__.weapon object at>饮血剑60德玛 用 饮血剑 攻击了 亚索 , 掉了60 的血，还剩 140 的血

View Code

3.练习

1.完成暴力摩托程序(完成下列需求)

1)创建三个游戏人物，分别

①阿狸，女，18，攻击力ad为20，血量200

②男刀，男，20，攻击力ad为30，血量150

③剑姬，女，19，攻击力ad为50，血量80

2)创建三个游戏武器，分别是：

①无尽之刃，ad为65

②饮血剑，ad为50

③饮魔刀，ad为20

3)创建三个游戏摩托车，分别是：

①小踏板，速度60迈

②雅马哈，速度80迈

③宝马，速度120迈

classGameRole:def __init__(self,name,sex, age,ad,hp):

self.name=name

self.sex=sex

self.age=age

self.ad=ad

self.hp=hpclassWeapon:def __init__(self,name,ad):

self.name=name

self.ad=adclassMotorcycle:def __init__(self,name,speed):

self.name=name

self.speed=speed

p1= GameRole("阿狸","女",18,20,300)

p2= GameRole("男刀","男",20,25,250)

p3= GameRole("剑姬","女",19,50,200)

w1= Weapon("无尽之刃",65)

w2= Weapon("饮血剑",50)

w3= Weapon("饮魔刀",20)

m1= Motorcycle("小踏板",60)

m2= Motorcycle("雅马哈",80)

m3= Motorcycle("宝马",120)

View Code

4)完成下列需求(利用武器打人掉的血量为武器的ad + 人的ad)

①阿狸骑着小踏板开着60迈的车行驶在赛道上。

②男刀骑着宝马开着120迈的车行驶在赛道上。

③剑姬骑着雅马哈开着80迈的车行驶在赛道上。

classGameRole:def __init__(self,name,sex, age,ad,hp):

self.name=name

self.sex=sex

self.age=age

self.ad=ad

self.hp=hpdef add_moto(self,mo): #给角色装备车辆

self.mo =moclassWeapon:def __init__(self,name,ad):

self.name=name

self.ad=adclassMotorcycle:def __init__(self,name,speed):

self.name=name

self.speed=speeddefdriver(self,p):print("%s骑着%s开着%s迈的车行驶在赛道上"%(p.name,self.name,self.speed))

p1= GameRole("阿狸","女",18,20,300)

p2= GameRole("男刀","男",20,25,250)

p3= GameRole("剑姬","女",19,50,200)

w1= Weapon("无尽之刃",65)

w2= Weapon("饮血剑",50)

w3= Weapon("饮魔刀",20)

m1= Motorcycle("小踏板",60)

m2= Motorcycle("雅马哈",80)

m3= Motorcycle("宝马",120)

p1.add_moto(m1)#给对象p1装配武器m1

p1.mo.driver(p1)

p2.add_moto(m3)#给对象p2装配武器m3

p2.mo.driver(p2)

p3.add_moto(m2)#给对象p3装配武器m3

p3.mo.driver(m2)

输出：

阿狸骑着小踏板开着60迈的车行驶在赛道上

男刀骑着宝马开着120迈的车行驶在赛道上

雅马哈骑着雅马哈开着80迈的车行驶在赛道上

View Code

④阿狸赤手空拳打了男刀20滴血，男刀还剩xx血。

⑤男刀赤手空拳打了剑姬30滴血，剑姬还剩xx血。

classGameRole:def __init__(self,name,sex, age,ad,hp):

self.name=name

self.sex=sex

self.age=age

self.ad=ad

self.hp=hpdeffinght_of_fist(self,p2):

p2_hp= p2.hp -self.adprint("%s赤手空拳打了%s%s滴血，%s还剩%s血。" %(self.name,p2.name,self.ad,p2.name,p2_hp))classWeapon:def __init__(self,name,ad):

self.name=name

self.ad=adclassMotorcycle:def __init__(self,name,speed):

self.name=name

self.speed=speed

p1= GameRole("阿狸","女",18,20,300)

p2= GameRole("男刀","男",20,25,250)

p3= GameRole("剑姬","女",19,50,200)

w1= Weapon("无尽之刃",65)

w2= Weapon("饮血剑",50)

w3= Weapon("饮魔刀",20)

m1= Motorcycle("小踏板",60)

m2= Motorcycle("雅马哈",80)

m3= Motorcycle("宝马",120)

p1.finght_of_fist(p2)

p2.finght_of_fist(p3)

输出：

阿狸赤手空拳打了男刀20滴血，男刀还剩230血。

男刀赤手空拳打了剑姬25滴血，剑姬还剩175血。

View Code

⑥剑姬利用饮血剑刺了男刀一饮血剑，男刀还剩xx血。

⑦阿狸利用无尽之刃打了剑姬一无尽之刃，剑姬还剩xx血。

classGameRole:def __init__(self,name,sex, age,ad,hp):

self.name=name

self.sex=sex

self.age=age

self.ad=ad

self.hp=hpdefadd_weapon(self,wea):

self.wea=weaclassWeapon:def __init__(self,name,ad):

self.name=name

self.ad=addeffight_of_weapon(self,p1,p2):

p2_hp= p2.hp-p1.ad-self.adprint("%s利用%s打了%s一%s，%s还剩%s血" %(p1.name,self.name,p3.name,self.name,p2.name,p2_hp))classMotorcycle:def __init__(self,name,speed):

self.name=name

self.speed=speed

p1= GameRole("阿狸","女",18,20,300)

p2= GameRole("男刀","男",20,25,250)

p3= GameRole("剑姬","女",19,50,200)

w1= Weapon("无尽之刃",65)

w2= Weapon("饮血剑",50)

w3= Weapon("饮魔刀",20)

m1= Motorcycle("小踏板",60)

m2= Motorcycle("雅马哈",80)

m3= Motorcycle("宝马",120)

p3.add_weapon(w2)#给p3对象装备武器

p3.wea.fight_of_weapon(p3,p2)

p1.add_weapon(w1)#给p3对象装备武器

p1.wea.fight_of_weapon(p1,p3)

输出：

剑姬利用饮血剑打了剑姬一饮血剑，男刀还剩150血

阿狸利用无尽之刃打了剑姬一无尽之刃，剑姬还剩115血

View Code

⑧男刀骑着宝马打了骑着小踏板的剑姬一无尽之刃，剑姬哭了，还剩xx血。

⑨剑姬骑着小踏板打了骑着雅马哈的阿狸一饮血剑，阿狸哭了，还剩xx血。

classGameRole:def __init__(self,name,sex, age,ad,hp):

self.name=name

self.sex=sex

self.age=age

self.ad=ad

self.hp=hpdefadd_moto(self,mo):

self.mo=modefadd_weapon(self,wea):

self.wea=weadeffight_combination(self,p):

p_hp= p.hp - self.ad -self.wea.adprint("%s骑着%s打了骑着%s的%s一%s，%s哭了，还剩%s血。" %(self.name,self.mo.name,p.mo.name,p.name,self.wea.name,p.name,p_hp))classWeapon:def __init__(self,name,ad):

self.name=name

self.ad=addeffight_of_weapon(self,p1,p2):

p2_hp= p2.hp-p1.ad-self.adprint("%s利用%s打了%s一%s，%s还剩%s血" %(p1.name,self.name,p3.name,self.name,p2.name,p2_hp))classMotorcycle:def __init__(self,name,speed):

self.name=name

self.speed=speed

p1= GameRole("阿狸","女",18,20,300)

p2= GameRole("男刀","男",20,25,250)

p3= GameRole("剑姬","女",19,50,200)

w1= Weapon("无尽之刃",65)

w2= Weapon("饮血剑",50)

w3= Weapon("饮魔刀",20)

m1= Motorcycle("小踏板",60)

m2= Motorcycle("雅马哈",80)

m3= Motorcycle("宝马",120)#男刀骑着宝马打了骑着小踏板的剑姬一无尽之刃，剑姬哭了，还剩xx血。

p2.add_moto(m3)

p3.add_moto(m1)

p2.add_weapon(w1)

p2.fight_combination(p3)#剑姬骑着小踏板打了骑着雅马哈的阿狸一饮血剑，阿狸哭了，还剩xx血。

p1.add_moto(m2)

p3.add_weapon(w2)

p3.fight_combination(p1)

输出:

男刀骑着宝马打了骑着小踏板的剑姬一无尽之刃，剑姬哭了，还剩110血。

剑姬骑着小踏板打了骑着雅马哈的阿狸一饮血剑，阿狸哭了，还剩200血。

View Code

2.定义一个类，计算圆的周长和面积。

from math importpiclassCircle:def __init__(self,r):

self.r=rdefperimiter(self):return self.r*2*pidefarea(self):return self.r**2*pi

c1= Circle(5)print(c1.perimiter())print(c1.area())

输出：31.41592653589793

78.53981633974483

View Code

3. 定义一个圆环类，计算圆环的周长和面积(升级题)

from math importpiclassRing:def __init__(self,r1,r2):

self.r1=r1

self.r2=r2defperimiter(self):return self.r1*2*pi + self.r2*2*pidefarea(self):return self.r1**2*pi - self.r2**2*pi

c1= Ring(10,5)print(c1.perimiter())print(c1.area())

输出：94.24777960769379

235.61944901923448

View Code

4.以组合的方式，计算圆环的面积

from math importpiclassCircle:def __init__(self,r):

self.r=rdefperimiter(self):return self.r*2*pidefarea(self):return self.r**2*piclassRing:def __init__(self,r1,r2):

self.r1=Circle(r1)

self.r2=Circle(r2)defperimiter(self):return self.r1.perimiter() +self.r2.perimiter()defarea(self):return self.r1.area() -self.r2.area()

c1= Ring(10,5)print(c1.perimiter())print(c1.area())

输出：94.24777960769379

235.61944901923448

View Code