目錄
面向?qū)ο缶幊痰奶攸c(diǎn)：
封裝：封裝是將數(shù)據(jù)和操作（方法）封裝在一個(gè)對(duì)象中的能力
繼承：繼承是指一個(gè)類（子類）可以繼承另一個(gè)類（父類）的屬性和方法。
我們?yōu)槭裁葱枰^承呢？
父類/基類 => ATM
子類/派生類=> ChinaATM/ICBCATM
ATM系統(tǒng)父類子類講解代碼：
經(jīng)典類和新式類
經(jīng)典類 和 新式類的區(qū)別：（python2的環(huán)境中進(jìn)行）
區(qū)別一：查看數(shù)據(jù)類型之間的區(qū)別
區(qū)別二：多重繼承的查找順序不同
經(jīng)典類和新式類的繼承關(guān)系
經(jīng)典類 => 深度優(yōu)先算法?
新式類 => C3算法?
多態(tài)：多態(tài)是指同一種操作或方法可以在不同的對(duì)象上產(chǎn)生不同的行為。
多態(tài)示例：?
靜態(tài)方法和類方法：
示例代碼：實(shí)例方法、靜態(tài)方法、類方法的定義和使用
什么時(shí)候使用靜態(tài)方法呢？?
什么時(shí)候使用類方法呢？
調(diào)用靜態(tài)、類、實(shí)例方法的條件：
python中下劃線的使用：
python中的下劃線：
單下劃線開(kāi)頭的變量/函數(shù)/屬性/方法/類--》保護(hù)對(duì)象 =>? 外部還是可以用
雙下劃線開(kāi)頭的變量/函數(shù)/屬性/方法/類--》私有對(duì)象 =>? 只在自己空間中生效
示例：python中內(nèi)置特殊變量或特殊方法一般都是用雙下劃線__開(kāi)頭雙下劃線結(jié)尾的
通過(guò)代碼來(lái)實(shí)現(xiàn)單下劃線 和 雙下劃線不同的功能
實(shí)驗(yàn)：回合制攻擊游戲：
游戲介紹：
面向?qū)ο缶幊痰奶攸c(diǎn)：
封裝（Encapsulation）：封裝是將數(shù)據(jù)和操作（方法）封裝在一個(gè)對(duì)象中的能力。對(duì)象對(duì)外部提供一組公共接口（方法），通過(guò)這些接口可以訪問(wèn)和操作對(duì)象的內(nèi)部狀態(tài)，而對(duì)象的內(nèi)部實(shí)現(xiàn)細(xì)節(jié)對(duì)外部是不可見(jiàn)的。封裝提供了信息隱藏和保護(hù)數(shù)據(jù)的機(jī)制，使得對(duì)象的設(shè)計(jì)更加模塊化、安全性更高。
繼承（Inheritance）：繼承是指一個(gè)類（子類）可以繼承另一個(gè)類（父類）的屬性和方法。通過(guò)繼承，子類可以重用父類的代碼，并可以在此基礎(chǔ)上添加、修改或覆蓋父類的行為。繼承提供了代碼的重用性和層次化組織的能力，使得代碼更加可維護(hù)和可擴(kuò)展。
多態(tài)（Polymorphism）：多態(tài)是指同一種操作或方法可以在不同的對(duì)象上產(chǎn)生不同的行為。多態(tài)通過(guò)繼承和方法重寫實(shí)現(xiàn)，允許使用父類類型的變量來(lái)引用子類對(duì)象，從而在運(yùn)行時(shí)動(dòng)態(tài)地調(diào)用子類的方法。多態(tài)提供了接口的靈活性和代碼的可擴(kuò)展性，使得程序更加具有通用性和可復(fù)用性。
抽象（Abstraction）：抽象是指從具體的事物中提取出共同的特征和行為，形成抽象類或接口。抽象類定義了一組抽象方法和屬性，描述了對(duì)象的基本行為和特征，而具體的實(shí)現(xiàn)則由子類來(lái)完成。抽象類和接口提供了對(duì)問(wèn)題域的建模能力，使得程序設(shè)計(jì)更加符合現(xiàn)實(shí)世界的抽象和概念。
封裝：封裝是將數(shù)據(jù)和操作（方法）封裝在一個(gè)對(duì)象中的能力
繼承：繼承是指一個(gè)類（子類）可以繼承另一個(gè)類（父類）的屬性和方法。
# 在python2中屬于經(jīng)典類
class A:
pass
# 在python2中屬于經(jīng)典類
class B():
pass
# 在python2中屬于新式類
class C(object):
pass
# class 類名(父類列表): pass --》 我們可以繼承的多個(gè)父類
# python3 以上寫法效果一樣的。
# python3 中默認(rèn)繼承自object
我們?yōu)槭裁葱枰^承呢？
因?yàn)槔^承可以幫助我們減少重復(fù)的代碼
如下面的ATM系統(tǒng)為例（它可以使我們的擴(kuò)展性更強(qiáng)）
# ATM類 bank =>銀行
# 我們需要使用中國(guó)工商銀行的ATM機(jī)和中國(guó)銀行的ATM機(jī)
# 因此可以看到我們都需要使用ATM機(jī)的功能，只是我們需要去的銀行不同，因此我們的父類可以使用ATM ， 子類可以使用?ChinaATM/ICBCATM（中國(guó)銀行 或者 中國(guó)工商銀行）
父類/基類 => ATM
子類/派生類=> ChinaATM/ICBCATM
父類和子類的創(chuàng)建條件：
父類：所有子類都公共的功能
子類;? 如果父類的功能并不能滿足我們的需求，我們需要撰寫子類重寫該方法
? ? ? ? ? 如果父類沒(méi)有該功能，我們需要撰寫子類自己定義一個(gè)功能（也包括屬性）
? ? ? ? ? 如果__init__初始化不滿足需求，我們需要在子類中重寫一個(gè)__init__，并也可以執(zhí)行父類的__init__函數(shù)，使用super().__init__ 方法
多重繼承：一個(gè)類可以繼承多個(gè)父類
? ? ? ? ? ? ? ? ?多級(jí)別的繼承
ATM系統(tǒng)父類子類講解代碼：
其中包含了ATM(object), 子類ChinaATM(ATM)和ICBCATM(ATM)）
使用到了繼承的添加、修改 和 重寫父類的行為
ChinaATM繼承自ATM, 因此ATM中的所有東西，ChinaATM都有，并在其中添加?__init__ 初始化函數(shù)的功能，如果父類中有相同的變量，我們的ChinaATM內(nèi)可以不用再繼續(xù)定義了，我們只需要使用super().__init__(No, location, balance)去調(diào)用父類中的變量即可
重寫屬性、方法 => 父類的某些東西，不滿足需求，可以重寫
如果需要的功能，父類沒(méi)有，自己添加一個(gè)
class ATM(object):
bank = "銀行ATM"
def __init__(self, No, location, balance):
print("這是ATM的__init__")
self.No = No
self.location = location
self.balance = balance
def save_money(self, money):
self.balance += money
print(f"{self.bank}-{self.No}余額為：{self.balance}")
def get_money(self, money):
self.balance -= money
print(f"{self.bank}-{self.No}余額為：{self.balance}")
class ChinaATM(ATM):
bank = "中國(guó)銀行ATM"
# No, location, balance, test
def __init__(self, No, location, balance, test):
print("這是ChinaATM的__init__")
self.test = test
super().__init__(No, location, balance)
# ChinaATM繼承自ATM,ATM中的所有東西，ChinaATM都有
class ICBCATM(ATM):
# 重寫屬性、方法 => 父類的某些東西，不滿足需求，可以重寫
bank = "工商銀行ATM"
def save_money(self):
print("這是ICBC-ATM的save_money")
# 如果需要的功能，父類沒(méi)有，自己添加一個(gè)
def show(self):
print(self.bank, self.No)
# 創(chuàng)建一個(gè)中國(guó)銀行的ATM機(jī)
china_atm1 = ChinaATM("cn_atm_001", "長(zhǎng)沙市芙蓉區(qū)湖南農(nóng)業(yè)大學(xué)", 100, "ok")
china_atm1.get_money(10)
print(china_atm1.bank)
# icbc_atm1 = ICBCATM("icbc_atm_001", "長(zhǎng)沙市岳麓區(qū)",1000)
# icbc_atm1.save_money()
# icbc_atm1.show()經(jīng)典類和新式類
新式類：繼承與object =>?python3中默認(rèn)都是繼承于object => python3中所有的類都是新式類哦
經(jīng)典類: 沒(méi)有顯式地繼承object（就是父類沒(méi)有寫object來(lái)表示自己是父類） =>python2中
經(jīng)典類 和 新式類的區(qū)別：（python2的環(huán)境中進(jìn)行）
區(qū)別一：查看數(shù)據(jù)類型之間的區(qū)別
#定義了四個(gè)類
class A():pass 經(jīng)典類
class B: pass 經(jīng)典類
class C(object):pass 新式類
class D(object):pass 新式類
# 區(qū)別一：查看數(shù)據(jù)類型之間的區(qū)別
# 經(jīng)典類：
a = A() # type(a) => instance
b = B() # type(b) => instance
type(a) == type(b) => True # 上面的方式來(lái)判斷數(shù)據(jù)類型是不對(duì)的
a.__class__ => #這種方式才能獲取到正確的數(shù)據(jù)類型
b.__class__
# 新式類
c = C() # type(c) => <class '__main__.C'> #新式類可以直接使用type來(lái)查看數(shù)據(jù)類型
d = D()區(qū)別二：多重繼承的查找順序不同
經(jīng)典類和新式類的繼承關(guān)系
代碼展示：
class A:
pass
#def test(self):
# print("this is A")
class B(A):
pass
#def test(self):
# print("this is B")
class C(A):
pass
#def test(self):
# print("this is C")
class D(B):
pass
#def test(self):
# print("this is D")
class E(C):
pass
#def test(self):
# print("this is E")
class F(D,E):
pass
#def test(self):
# print("this is F")
f = F()
f.test()經(jīng)典類
在python2中多重繼承的查找順序：
經(jīng)典類 => 深度優(yōu)先算法?
F -> D -> B -> A -> E -> C
新式類
新式類 => C3算法?
我們可以通過(guò)?F.mro(), F.__mro__? 方法直接 查看到查找到父類的順序
F -> D -> B -> E -> C -> A -> Object
解析列表：
A => [AO] => AO
B(A) => B+[AO] => BAO
C(A) => C+[AO] =>CAO
D(B) => D+[BAO] => DBAO
E(C) => E+[CAO] => ECAO
F(D,E) => F+[DBAO]+[ECAO]
? ? ? ?=> FDBECAO
1. 將自身放到解析順序中
2. 接下來(lái)出現(xiàn)的類，如果在后面解析列表中沒(méi)有出現(xiàn)的話，直接將該類放到解析順序中
? ? 如果出現(xiàn)了，再看后面的類（再解析后面的類）
多態(tài)：多態(tài)是指同一種操作或方法可以在不同的對(duì)象上產(chǎn)生不同的行為。
其實(shí)就是一個(gè)功能，展現(xiàn)多種形態(tài)
鴨子類型：
? ? ? 一只鳥(niǎo)，游起來(lái)泳來(lái)像一只鴨子，走起路來(lái)像一只鴨子，它就是一只鴨子
? ? ? 接收一個(gè)鴨子數(shù)據(jù)（swim,walk） => 等于傳遞一個(gè)鳥(niǎo)數(shù)據(jù)(swim, walk) --》因此在使用(swim, walk)的時(shí)候呈現(xiàn)多種形態(tài)
多態(tài)示例：?
#創(chuàng)建一個(gè)功能
def MoneyPay(obj):
obj.pay()
# 可以調(diào)用多種狀態(tài)（類的方法）
class WePay():
def pay(self):
print("this is wepay!")
class AliPay():
def pay(self):
print("This is alipay")
#調(diào)用方法（一個(gè)功能，多種形態(tài)）
wepay1 = WePay()
MoneyPay(wepay1)
alipay1 = AliPay()
MoneyPay(alipay1)靜態(tài)方法和類方法：
屬性和方法的種類：
# 屬性: 類屬性和實(shí)例屬性
# 方法： 實(shí)例方法、靜態(tài)方法、類方法
示例代碼：實(shí)例方法、靜態(tài)方法、類方法的定義和使用
class Person(object):
# 類屬性
MAX = 10
# 實(shí)例方法
# 實(shí)例方法：沒(méi)有任何修飾，第一個(gè)參數(shù)self
def __init__(self, name): #self代表實(shí)例本身
self.name = name
# 靜態(tài)方法
# 靜態(tài)方法：使用@staticmethod裝飾器，沒(méi)有額外的參數(shù)
# 寫在函數(shù)/類上方用@修飾對(duì)象稱為裝飾器
# 如果定義一個(gè)類中方法的時(shí)候，沒(méi)有用到類和實(shí)例相關(guān)的數(shù)據(jù)時(shí)，可以定義成靜態(tài)方法
@staticmethod
def static_method(): #括號(hào)中什么都沒(méi)有
print("this is a static method")
def instance_method(self):
# 給實(shí)例添加了一個(gè)MAX
# self.MAX = 20
self.__class__.MAX = 20 #在實(shí)例方法中修改 類屬性 的變量，需要使用self.__class__.類屬性
print(f"this is a instance method:{self}")
# 類方法
# 當(dāng)在方法中需要類（類屬性）中數(shù)據(jù)，可以把它定義成類方法
# 類方法：使用@classmethod修飾，有一個(gè)默認(rèn)的參數(shù) cls=>表示當(dāng)前類
@classmethod
def class_method(cls): #cls表示當(dāng)前的類
# cls.MAX = 20
print(f"this is a class method：{cls}")
#實(shí)例調(diào)用方法
p1 = Person("Cici")
# 調(diào)用方法
p1.static_method() #不代表什么，直接運(yùn)行函數(shù)得到的結(jié)果
p1.class_method() #代表類
p1.instance_method() #代表實(shí)例
# 類調(diào)用方法
Person.static_method()
Person.class_method()
# 類名.實(shí)例方法（） 不可以調(diào)用 會(huì)報(bào)錯(cuò)
# Person.instance_method()
print(Person.MAX)
# 即沒(méi)有用到類數(shù)據(jù)，也沒(méi)有用到實(shí)例數(shù)據(jù)：@staticmethod
# 用到類數(shù)據(jù)，沒(méi)有用到實(shí)例數(shù)據(jù)：@classmethod
# 用到實(shí)例數(shù)據(jù)，沒(méi)有用到類數(shù)據(jù)：實(shí)例方法
# 即用到了實(shí)例數(shù)據(jù)，又用到了類數(shù)據(jù)：實(shí)例方法 self.__class__結(jié)果輸出：
this is a static method #靜態(tài)方法
this is a class method：<class '__main__.Person'> #類方法
this is a instance method:<__main__.Person object at 0x000001E5997DCF10> #實(shí)例方法什么時(shí)候使用靜態(tài)方法呢？?
如果定義一個(gè)類中方法的時(shí)候，沒(méi)有用到類和實(shí)例相關(guān)的數(shù)據(jù)時(shí)，可以定義成靜態(tài)方法。
什么時(shí)候使用類方法呢？
當(dāng)在方法中需要類（類屬性）中數(shù)據(jù)，可以把它定義成類方法
調(diào)用靜態(tài)、類、實(shí)例方法的條件：
# 即沒(méi)有用到類數(shù)據(jù)，也沒(méi)有用到實(shí)例數(shù)據(jù)：@staticmethod
# 用到類數(shù)據(jù)，沒(méi)有用到實(shí)例數(shù)據(jù)：@classmethod
# 用到實(shí)例數(shù)據(jù)，沒(méi)有用到類數(shù)據(jù)：實(shí)例方法
# 即用到了實(shí)例方法，又用到了類數(shù)據(jù)：實(shí)例方法 + self.__class__.類屬性
python中下劃線的使用：
python使用下劃線的時(shí)候：
_user_name = 0 # 單下劃線
__user_name = 0 # 雙下劃線go中使用下劃線的時(shí)候：
# file, _ = OpenFile()
# 在go中如果丟棄某個(gè)數(shù)據(jù)放到_變量中python中的下劃線：
單下劃線開(kāi)頭的變量/函數(shù)/屬性/方法/類--》保護(hù)對(duì)象 =>? 外部還是可以用
雙下劃線開(kāi)頭的變量/函數(shù)/屬性/方法/類--》私有對(duì)象 =>? 只在自己空間中生效
缺點(diǎn)：
使用通配符（*）的方式導(dǎo)入文件/模塊的時(shí)候，以單下劃線_ 和 雙下劃線__開(kāi)頭的對(duì)象是不會(huì)被導(dǎo)入進(jìn)去的
from 模塊名 import *示例：python中內(nèi)置特殊變量或特殊方法一般都是用雙下劃線__開(kāi)頭雙下劃線結(jié)尾的
# python內(nèi)置特殊變量或方法一般都是用雙下劃線開(kāi)頭雙下劃線結(jié)尾
print(__file__) # 當(dāng)前文件的絕對(duì)路徑
print(__name__) # 當(dāng)前運(yùn)行的模塊名（__main__或模塊路徑）
print(__doc__) # 當(dāng)前文件/函數(shù)/類 文檔注釋
print(a.__class__) # a是哪個(gè)類，返回當(dāng)前類
print(B.__bases__) # 查看B的父類有哪些
from requests import get
print(get.__module__) # 查看當(dāng)前模塊名
#例如：
def test():
"""
this is a test function
:return:
"""
pass
print(test.__doc__) # 當(dāng)前文件/函數(shù)/類 文檔注釋
========
#定義兩個(gè)類：
class A(object):
pass
class B(A):
pass
a = A()
b = B()
print(a.__class__) # a是哪個(gè)類，返回當(dāng)前類
print(B.__bases__) # 查看B的父類有哪些
print(dir(A))
通過(guò)print(dir(A))來(lái)查看A類可以使用哪些方法，其中就包含了很多的雙下劃線的方法通過(guò)代碼來(lái)實(shí)現(xiàn)單下劃線 和 雙下劃線不同的功能
class Parent:
tmp = 'tmp'
_min = 0 # 保護(hù)變量
__max = 10 # 私有變量，只能在當(dāng)前類的內(nèi)部使用（子類也用不了）
def __make(self): #私有方法
print("這是一個(gè)私有方法")
def _make2(self): #保護(hù)方法
print("這是一個(gè)保護(hù)方法")
def show(self):
print(f"_min:{self._min}, __max:{self.__max}")
class Child(Parent):
def show(self):
# print(f"__max:{self.__max}")
print(f"__max:{self._min}")
#定義實(shí)例
p = Parent()
c = Child()
#輸出當(dāng)前類可用的屬性和方法
print(dir(p))
print(dir(c))
print(Child.__dict__)
print(Parent.__dict__)
#調(diào)用show()方法
p.show()
# python所謂的私有，實(shí)際上也是可以訪問(wèn)到的，方法特殊一些，如下面的p._Parent__max方式訪問(wèn)
print(p._min, p._Parent__max)
#調(diào)用show()方法
c.show()
print(c._Parent__max)
p._make2() #可以訪問(wèn)包含方法
# p.__make() #但是不可以訪問(wèn)私有方法實(shí)驗(yàn)：回合制攻擊游戲：
游戲介紹：
回合制游戲：兩人進(jìn)行到一個(gè)房間，相互攻擊
創(chuàng)建Game類：游戲
????交互式菜單：
????????創(chuàng)建角色，創(chuàng)建房間，
????????添加角色到房間，
????????房間滿員自動(dòng)開(kāi)始游戲
創(chuàng)建Room類：房間
????房間名，房間編號(hào)，房間成員，房間最大人數(shù)
????加入房間：房間滿員自動(dòng)開(kāi)始游戲(player1,?player2?)
????room.add(player)
創(chuàng)建Role類：角色
????初始血量100，初始積分100，
????名字、血量、積分、當(dāng)前所在房間
????攻擊?a.attack(b)隨機(jī)掉血（10-30）
????role.join(room)文章來(lái)源：http://www.zghlxwxcb.cn/news/detail-605412.html
代碼：文章來(lái)源地址http://www.zghlxwxcb.cn/news/detail-605412.html
#回合制游戲：兩人進(jìn)入到一個(gè)房間，相互攻擊
#創(chuàng)建Game類：游戲
# 交互式菜單：創(chuàng)建角色，創(chuàng)建房間，添加角色到房間，房間滿員自動(dòng)開(kāi)始游戲
#創(chuàng)建Room類：房間
# 房間名，房間編號(hào)，房間成員，房間最大人數(shù)
# 加入房間：房間滿員自動(dòng)開(kāi)始游戲(player1,player2)
# room.add(player)
#創(chuàng)建Role類：角色
# 初始血量100、初始積分100
# 名字、血量、積分、當(dāng)前所在房間
# 攻擊 a.attack(b)隨機(jī)掉血（10-30）
# role.join(room)
class Game:
flag = 0
def __init__(self):
self.player = {}
name = input("請(qǐng)輸入要?jiǎng)?chuàng)建的角色名：")
self.player[name] = Role(name, 100, 30)
self.player[name].show()
room_name = input("請(qǐng)輸入要?jiǎng)?chuàng)建的房間名：")
room_number = int(input("請(qǐng)輸入要房間人數(shù)："))
self.room = Room(room_name, 0, room_number)
self.room.add(name)
self.room.show()
def start(self):
choice = input("1.繼續(xù)創(chuàng)建角色\n2.邀請(qǐng)角色加入房間\n請(qǐng)輸入：")
if choice == "1":
name = input("請(qǐng)輸入要?jiǎng)?chuàng)建的角色名：")
self.player[name] = Role(name, 100, 30)
self.player[name].show()
if choice == "2":
player_name = input("請(qǐng)輸入被邀請(qǐng)人名字：")
self.room.add(player_name)
def attack(self):
for i in self.player:
if not self.player[i].flag2:
print(f"{i}發(fā)動(dòng)攻擊！")
name = input("請(qǐng)輸入要攻擊玩家的名字:")
self.player[i].attack_obj(self.player[name])
self.player[name].show()
else:
print(f"游戲結(jié)束！")
self.flag = 1
for j in self.player:
self.player[j].show()
class Room:
room_member = []
flag = 0
def __init__(self, room_name, number, max_person):
self.room_name = room_name
self.number = number
self.max_person = max_person
def add(self, player):
self.room_member.append(player)
self.show()
if len(self.room_member) == self.max_person:
print("房間人數(shù)已滿，游戲開(kāi)始")
self.flag = 1
def show(self):
print(f"房間名：{self.room_name}，房間號(hào)：{self.number}，房間最大人數(shù)是：{self.max_person}")
print("房間成員有：", self.room_member)
import random
class Role:
INIT_HP = 100
score = 100
flag2 = 0
def __init__(self, name, hp = None, attack = 50):
self.name = name
if hp:
self.hp = hp
else:
#self.hp = self.INIT_HP
self.hp = self.__class__.INIT_HP
#攻擊上限
self.attack = attack
def show(self):
print(f"{self.name}當(dāng)前的血量為:{self.hp},當(dāng)前的積分為：{self.score}")
def attack_obj(self, att_obj):
if self.hp:
x = random.randint(1, self.attack)
print(f"{self.name}對(duì){att_obj.name}造成了{(lán)x}點(diǎn)傷害")
if att_obj.hp < x:
print(f"{att_obj.name}玩家死亡")
att_obj.hp = 0
att_obj.flag2 = 1
self.score += 1
else:
att_obj.hp -= x
game = Game()
while not game.room.flag:
game.start()
while not game.flag:
game.attack()import random
class Role():
blood = 100
grade = 100
defence = 0
def __init__(self,name,room):
self.name = name
self.room = room
print(f"角色{self.name}創(chuàng)建成功，當(dāng)前房間號(hào)為：{self.room}")
def attack(self,name):
if self.blood > 0:
i = random.randint(10,30)
if self.defence >= i:
self.defence -= i
else:
name.blood = name.blood - (i-self.defence)
print(f"{self.name}受到{i}點(diǎn)傷害，當(dāng)前剩余血量：{name.blood}")
if name.blood <= 0:
print(f"{self.name} died.game over!")
else:
print("玩家已陣亡，請(qǐng)重新開(kāi)始游戲")
def updefence(self):
if self.blood>0 and self.grade >= 10:
i = random.randint(10,20)
self.grade -= 10
self.defence += i
print(f"{self.name}增加防御{i}點(diǎn)，當(dāng)前防御為：{self.defence}")
elif self.grade < 10:
print("積分不足")
def bigskill(self,name):
#無(wú)視防御
if self.blood>0 and self.grade >= 40:
self.grade -= 40
i = random.randint(30,60)
name.blood -= i
print(f"{self.name}受到大招傷害{i}點(diǎn)，當(dāng)前剩余血量：{name.blood}")
if name.blood <= 0:
print(f"{self.name} died.game over!")
elif self.grade < 40:
print("積分不足，無(wú)法使用")
elif self.blood < 0:
print("玩家已陣亡，請(qǐng)重新開(kāi)始游戲")
class Room():
roommax = 2
def __init__(self,roomname,roomnum,player1,player2):
self.room_name = roomname
self.room_num = roomnum
self.player1 = player1
self.player2 = player2
print(f"當(dāng)前房間為{self.room_name}{self.room_num}")
print(f"房間成員：{self.player1},{self.player2}")
if self.player1 and self.player2:
print("游戲開(kāi)始")
self.start()
else:
print("角色數(shù)量不足，無(wú)法開(kāi)始游戲")
def start(self):
role1 = Role(self.player1, self.room_num)
role2 = Role(self.player2, self.room_num)
menu_data = """
1.攻擊
2.提高防御
3.發(fā)動(dòng)大招
"""
while True:
print(menu_data)
choice = input("輸入角色1的技能序號(hào)：")
if choice == "1":
role1.attack(role2)
if role2.blood <= 0:
break
elif choice == "2":
role1.updefence()
elif choice == "3":
role1.bigskill(role2)
if role2.blood <= 0:
break
choice = input("輸入角色2的技能序號(hào)：")
if choice == "1":
role2.attack(role1)
if role1.blood <= 0:
break
elif choice == "2":
role2.updefence()
elif choice == "3":
role2.bigskill(role1)
if role1.blood <= 0:
break
class Game():
def start(self):
menu_data = """
1.創(chuàng)建角色
2.創(chuàng)建房間
"""
while True:
print(menu_data)
choice = input("請(qǐng)輸入你的操作:")
if choice == "1":
n = 1
while n<3:
print("提示：你需要?jiǎng)?chuàng)建兩名角色才能開(kāi)始游戲！")
name = input("請(qǐng)輸入角色名稱：")
room = input("請(qǐng)輸入房間號(hào)：")
if n==1:
player1 = name
Role(player1, room)
n += 1
print(f"當(dāng)前角色數(shù)量為{n-1}")
else:
player2 = name
Role(player2, room)
n += 1
print(f"當(dāng)前角色數(shù)量為{n-1}")
elif choice == "2":
roomname = input("請(qǐng)輸入需要?jiǎng)?chuàng)建的房間名稱:")
roomnum = input("請(qǐng)輸入需要?jiǎng)?chuàng)建的房間號(hào)")
room1 = Room(roomname, roomnum, player1, player2)
else:
print("錯(cuò)誤輸入！請(qǐng)重新輸入:")
if __name__ == "__main__":
game = Game()
game.start()到了這里，關(guān)于python 面向?qū)ο缶幊痰奶攸c(diǎn) - 封裝 - 繼承(經(jīng)典類、新式類) - 多態(tài) - 靜態(tài)方法、類方法 - 下劃線的使用 - 回合制攻擊游戲?qū)嶒?yàn)的文章就介紹完了。如果您還想了解更多內(nèi)容，請(qǐng)?jiān)谟疑辖撬阉鱐OY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！
