類命名空間
在一個類中它的函數(方法)屬于動態屬性,直接定義的變量屬于靜態屬性
首先先定義一個類,并在這個類里面加入靜態變量、屬性等然后將一個對象實例化
class
Fighter:
#
定義一個戰機的類
price = 5000
#
靜態變量
def
__init__
(self,name,speed,atk,hp):
self.name
=
name
self.speed
=
speed
self.atk
=
atk
self.hp
=
hp
def
Attack(self):
print
(
'
本次攻擊造成了%s的傷害
'
%
(self.atk))
f1
= Fighter(
'
J-20
'
,1000,400,5000
)
print
(f1.
__dict__
)
#
{'name': 'J-20', 'speed': 1000, 'atk': 400, 'hp': 5000}
那如何修改一個靜態屬性,我們可以用類名.靜態變量名等于我們想要賦值的內容就可以修改
Fighter.price = 4500
print
(Fighter.
__dict__
)
#
{'__module__': '__main__', 'price': 4500,
'__init__':
,
'Attack':
,
'__dict__':
,
'__weakref__':
, '__doc__': None}
如果我們用__dict__方法去修改結果是不行的
Fighter.
__dict__
[
'
price
'
] = 2500
print
(Fighter.
__dict__
)
#
TypeError: 'mappingproxy' object does not support item assignment
關系圖:
當我們使用f1.price的時候,f1會先在自己的命名空間去找,它會發現自己的內存空間里沒有這個price,然后在通過類對象指針找到Fighter的命名空間,取得price這個變量
而Fighter.price是直接從自己的命名空間中取得,找到就返回
注意:只有實例化出來的對象才能找到類,而類并不能找到每一個對象
?
如果我們想用實例化出來的一個對象去修改類里面的靜態變量,該怎么做？
可以看出在這里直接修改這個靜態變量我們并沒有修改成功,而是在我們的這個self;'字典'里新增了一個price屬性
f1.price = 4500
print
(f1.
__dict__
)
#
{'name': 'J-20', 'speed': 1000, 'atk': 400, 'hp': 5000, 'price': 4500}
print
(Fighter.
__dict__
)
#
{'__module__': '__main__', 'price': 5000,
'__init__':
,
'
Attack
'
:
,
'
__dict__
'
:
'
__dict__
'
of
'
Fighter
'
objects>
,
'
__weakref__
'
:
'
__weakref__
'
of
'
Fighter
'
objects>,
'
__doc__
'
: None}
那么再想用回類里面的靜態變量的話只能刪除price
del
f1.price
print
(f1.price)
#
5000
print
(f1.
__dict__
)
#
{'name': 'J-20', 'speed': 1000, 'atk': 400, 'hp': 5000}
對于像上面這種不可變數據類型而言,類變量最好用類操作
現在我們把這個靜態變量改成列表的類型, 可以看到我們運用修改索引值的方式成功修改了原來的列表的元素
class
Fighter:
#
定義一個戰機的類
price = [5000]
#
靜態變量
def
__init__
(self,name,speed,atk,hp):
self.name
=
name
self.speed
=
speed
self.atk
=
atk
self.hp
=
hp
def
Attack(self):
print
(
'
本次攻擊造成了%s的傷害
'
%
(self.atk))
f1
= Fighter(
'
J-20
'
,1000,400,5000
)
f1.price[0]
= 6000
print
(f1.
__dict__
)
#
{'name': 'J-20', 'speed': 1000, 'atk': 400, 'hp': 5000}
print
(Fighter.
__dict__
)
#
{'__module__': '__main__', 'price': [6000], '__init__':
,
'
Attack
'
:
,
'
__dict__
'
:
'
__dict__
'
of
'
Fighter
'
objects>
,
'
__weakref__
'
:
'
__weakref__
'
of
'
Fighter
'
objects>,
'
__doc__
'
: None}
這是因為像這種可變數據類型(列表),它所改變的值不影響它本身的內存地址,像price它所指向的還是列表這個內存地址,所以改變了它的內部的值不會有太大的影響
但是如果我們這樣寫的話就相當于開辟了一個新的內存空間存放新的列表了
f1.price = [6000
]
print
(f1.
__dict__
)
#
{'name': 'J-20', 'speed': 1000, 'atk': 400, 'hp': 5000, 'price': [6000]}
print
(Fighter.
__dict__
)
#
{'__module__': '__main__', 'price': [5000], '__init__':
,
'Attack':
,
'__dict__':
,
'__weakref__':
, '__doc__': None}
最后靜態變量和函數名不要相同
一個例子: 創建一個類,每實例化一個對象就計數,最終所有的對象都共享這個數據
class
Counter():
count
=
0
def
__init__
(self):
Counter.count
+= 1
print
(Counter.count)
#
0
c1 =
Counter()
print
(Counter.count)
#
1
c2 =
Counter()
print
(Counter.count)
#
2
綁定方法:
一個類沒有__init__也可以實例化,self仍能把自己傳給f1
class
Person:
def
fuc(self):
print
(
'
Walking...
'
)
f1
=
Person()
print
(f1.
__dict__
)
#
{}
f1.fuc()
#
Walking...
現在再定義一個函數
def
func():
print
(
'
Testing...
'
)
class
Person:
def
fuc(self):
print
(
'
Walking...
'
)
f1
=
Person()
print
(func)
#
<__main__.Person object at 0x0000000002737A58>>
print
(f1)
#
<__main__.Person object at 0x0000000002737A58>
當對象去調用方法的時候就是把里面的值傳給這個方法那么他們之間就發生了一種綁定關系
import
當我們引入一個包的時候就相當于實例化了一個對象
?
組合
表示在一個類中以另外一個類的對象作為數據屬性,稱為類的組合
我們先聲明三個類玩家的戰機類、敵機的類和武器的類:
class
Fighter:
#
定義一個玩家戰機的類
def
__init__
(self,name,atk,hp,speed,money):
self.name
=
name
self.atk
=
atk
self.hp
=
hp
self.speed
=
speed
self.money
=
0
def
playerAttack(self,enemyfighter):
enemyfighter.hp
-=
self.atk
class
EnemyFighter:
#
定義個敵機的類
def
__init__
(self,name,atk,hp,speed,kind):
self.name
=
name
self.atk
=
atk
self.hp
=
hp
self.speed
=
speed
self.kind
=
kind
def
enemyFighterAttack(self,fighter):
fighter.hp
-=
self.atk
class
Weapon:
#
定義一個武器的類
def
__init__
(self,name,atk,durability,price):
self.name
=
name
self.atk
=
atk
self.durability
=
durability
self.price
=
price
playerFighter1
= Fighter(
'
Player1
'
,200,1500,300
,0)
Boss1
= EnemyFighter(
'
lazerBoss
'
,1000,7000,50,
'
Boss
'
)
w1
= Weapon(
'
AMR-123
'
,1000,10,300
)
print
(w1.
__dict__
)
#
{'name': 'AMR-123', 'atk': 1000, 'durability': 10, 'price': 300}
print
(Boss1.
__dict__
)
#
{'name': 'lazerBoss', 'atk': 1000, 'hp': 7000, 'speed': 50, 'kind': 'Boss'}
print
(playerFighter1.
__dict__
)
#
{'name': 'Player1', 'atk': 200, 'hp': 1500, 'speed': 300, 'money': 0}
如何將我們的裝備裝備到我們玩家的戰機上?在玩家的身上寫一個get_weapon函數讓一個武器的對象作為參數傳給這個函數,再讓玩家或得到武器的這些屬性
class
Fighter:
#
定義一個玩家戰機的類
def
__init__
(self,name,atk,hp,speed,money =
0):
self.name
=
name
self.atk
=
atk
self.hp
=
hp
self.speed
=
speed
self.money
=
money
def
playerAttack(self,enemyfighter):
enemyfighter.hp
-=
self.atk
def
get_weapon(self,weapon):
#
玩家獲得武器屬性的函數
if
self.money >= weapon.price:
#
如果玩家的金錢大于武器的價格
self.money -=
weapon.price
self.weapon
= weapon
#
給玩家添加武器的屬性
self.hp +=
weapon.maxHp
self.atk
+=
weapon.atk
else
:
print
(
'
余額不足請先充值!
'
)
class
EnemyFighter:
#
定義個敵機的類
def
__init__
(self,name,atk,hp,speed,kind):
self.name
=
name
self.atk
=
atk
self.hp
=
hp
self.speed
=
speed
self.kind
=
kind
def
enemyFighterAttack(self,fighter):
fighter.hp
-=
self.atk
class
Weapon:
#
定義一個武器的類
def
__init__
(self,name,atk,maxHp,durability,price):
self.name
=
name
self.atk
=
atk
self.maxHp
=
maxHp
self.durability
=
durability
self.price
=
price
playerFighter1
= Fighter(
'
Player1
'
,200,1500,300,500
)
Boss1
= EnemyFighter(
'
lazerBoss
'
,1000,7000,50,
'
Boss
'
)
w1
= Weapon(
'
AMR-123
'
,1000,1000,10,300
)
print
(playerFighter1.
__dict__
)
#
{'name': 'Player1', 'atk': 200, 'hp': 1500, 'speed': 300, 'money': 500}
playerFighter1.get_weapon(w1)
print
(playerFighter1.
__dict__
)
#
{'name': 'Player1', 'atk': 1200, 'hp': 2500, 'speed': 300, 'money': 200,
'weapon':<__main__.Weapon object at 0x000000000280D518>}
現在我們給武器設計一個招數,給怪物一個致命一擊
class
Fighter:
#
定義一個玩家戰機的類
def
__init__
(self,name,atk,hp,speed,money =
0):
self.name
=
name
self.atk
=
atk
self.hp
=
hp
self.speed
=
speed
self.money
=
money
def
playerAttack(self,enemyfighter):
enemyfighter.hp
-=
self.atk
def
get_weapon(self,weapon):
#
玩家獲得武器屬性的函數
if
self.money >= weapon.price:
#
如果玩家的金錢大于武器的價格
self.money -=
weapon.price
self.weapon
= weapon
#
給玩家添加武器的屬性
self.hp +=
weapon.maxHp
self.atk
+=
weapon.atk
else
:
print
(
'
余額不足請先充值!
'
)
class
EnemyFighter:
#
定義個敵機的類
def
__init__
(self,name,atk,hp,speed,kind):
self.name
=
name
self.atk
=
atk
self.hp
=
hp
self.speed
=
speed
self.kind
=
kind
def
enemyFighterAttack(self,fighter):
fighter.hp
-=
self.atk
class
Weapon:
#
定義一個武器的類
def
__init__
(self,name,atk,maxHp,durability,price):
self.name
=
name
self.atk
=
atk
self.maxHp
=
maxHp
self.durability
=
durability
self.price
=
price
def
lazerBullet(self,enemyFighter,fighter):
if
self.durability >
0:
enemyFighter.hp
-= self.atk*2 +
fighter.atk
self.durability
-= 5
else
:
print
(
'
您的武器耐久度為0,不可再使用!請重新充值!
'
)
playerFighter1
= Fighter(
'
Player1
'
,200,1500,300,500
)
Boss1
= EnemyFighter(
'
lazerBoss
'
,1000,7000,50,
'
Boss
'
)
w1
= Weapon(
'
AMR-123
'
,1000,1000,10,300
)
#
初始的怪物和玩家屬性
print
(Boss1.
__dict__
)
#
{'name': '
lazerBoss
', 'atk': 1000, 'hp':
7000
, 'speed': 50, 'kind': 'Boss'}
print
(playerFighter1.
__dict__
)
#
{'name': '
Player1
', 'atk':
200
, 'hp':
1500
, 'speed': 300, 'money':
500
}
#
玩家裝備上武器后屬性
playerFighter1.get_weapon(w1)
print
(playerFighter1.
__dict__
)
#
{'name': '
Player1
', 'atk':
1200
, 'hp':
2500
, 'speed': 300, 'money':
200
,
'weapon': <__main__.Weapon object at 0x000000000280D518>}
#
第一回合玩家用武器大招攻擊
playerFighter1.weapon.lazerBullet(Boss1,playerFighter1)
print
(Boss1.
__dict__
)
#
{'name': '
lazerBoss
', 'atk': 1000, 'hp':
3800
, 'speed': 50, 'kind': 'Boss'}
#
第二回合Boss攻擊玩家
Boss1.enemyFighterAttack(playerFighter1)
print
(playerFighter1.
__dict__
)
#
{'name': '
Player1
', 'atk':
1200
, 'hp':
1500
, 'speed': 300, 'money': 200,
'weapon': <__main__.Weapon object at 0x000000000279D4A8>}
#
第三回合玩家用武器大招攻擊
playerFighter1.weapon.lazerBullet(Boss1,playerFighter1)
print
(Boss1.
__dict__
)
#
{'name': '
lazerBoss
', 'atk': 1000, 'hp':
600
, 'speed': 50, 'kind': 'Boss'}
playerFighter1.weapon.lazerBullet(Boss1,playerFighter1)
#
您的武器耐久度為0,不可再使用!請重新充值!
print
(Boss1.
__dict__
)
#
{'name': 'lazerBoss', 'atk': 1000, 'hp': 600, 'speed': 50, 'kind': 'Boss'}
?
組合練習
1.用組合的方法求這個圖形的面積,假設這里大圓半徑為10,小圓半徑為
from
math
import
pi as P
class
Cicle:
def
__init__
(self,r):
self.r
=
r
def
S(self):
return
P*self.r**2
def
L(self):
return
2*P*
self.r
class
Ring:
def
__init__
(self,outside_r,inside_r):
self.outside_c
=
Cicle(outside_r)
self.inside_c
=
Cicle(inside_r)
def
ret_S(self):
return
self.outside_c.S() -
self.inside_c.S()
def
ret_L(self):
return
self.outside_c.L() +
self.inside_c.L()
ring
= Ring(10,5
)
print
(ring.ret_S())
#
235.61944901923448
print
(ring.ret_L())
#
94.24777960769379
2.創建一個老師類,老師有生日、課程,生日和課程可以是一個類,用組合的方式表示
class
Teacher:
def
__init__
(self,name,age,gender,course,birthday):
self.name
=
name
self.age
=
age
self.gender
=
gender
self.course
=
course
self.birthday
=
birthday
class
Course:
def
__init__
(self,name,price,period):
self.name
=
name
self.price
=
price
self.period
=
period
class
Birthday:
def
__init__
(self,year,month,day):
self.year
=
year
self.month
=
month
self.day
=
day
p1
= Teacher(
'
Jackson
'
,25,
'
male
'
,Course(
'
python
'
,15000,
'
7 months
'
),Birthday(1994,6,12
))
print
(p1.
__dict__
)
#
{'name': 'Jackson', 'age': 25, 'gender': 'male',
'course': <__main__.Course object at 0x00000000024AD390>,
'birthday': <__main__.Birthday object at 0x00000000024AD400>}
print
(p1.course.name,p1.course.price,p1.course.period)
#
python 15000 7 months
print
(p1.birthday.year,p1.birthday.month,p1.birthday.day)
#
1994 6 12
更多文章、技術交流、商務合作、聯系博主
微信掃碼或搜索：z360901061
微信掃一掃加我為好友
QQ號聯系： 360901061
您的支持是博主寫作最大的動力，如果您喜歡我的文章，感覺我的文章對您有幫助，請用微信掃描下面二維碼支持博主2元、5元、10元、20元等您想捐的金額吧，狠狠點擊下面給點支持吧，站長非常感激您！手機微信長按不能支付解決辦法：請將微信支付二維碼保存到相冊，切換到微信，然后點擊微信右上角掃一掃功能，選擇支付二維碼完成支付。
【本文對您有幫助就好】元
