類
舊式類(經典類)和新式類
Python中類分兩種:舊式類和新式類:
新式類都從object繼承,經典類不需要。
新式類是自動調用object類的
python3.幾版本後可以自動調用基類(object類)
類的抽象化:類定義之後不調用是沒辦法輸出的。
在Python 3.x中取消了經典類,默認都是新式類,並且不必顯式的繼承object,也就是說:
class Person(object):pass
class Person():pass
class Person:pass
三種寫法並無區別,推薦第一種
但是在Python2.x中,默認都是經典類,只有顯式繼承了object纔是新式類,即:
class Person(object):pass 新式類寫法
class Person():pass 經典類寫法
class Person:pass 經典類寫法
什麼是類?
類是一個特殊的對象
Python中一切皆對象
class AAA: 定義的類屬於類對象
obj1 = AAA:屬於實例對象
在運行程序時, 類同時會被加載到內存
類的結構
實例:
1.使用面向對象開發,第一步是設計類
2.使用類名()創建對象,創建對象的動作有兩步
1.在內存中爲對象分配空間
2.調用初始化方法init爲對象初始化
3.對象創建後,內存中就有了一個對象的實實在在的存在–實例
因此:
1.創建出來的對象叫做類的實例
2.創建對象的動作叫做實例化
3.對象的屬性鍵作實例屬性
4.對象調用的方法叫做實例方法
爲什麼類是抽象的?
抽象類提供多個派生類共享基類的公共定義,它既可以提供抽象方法,也可以提供非抽象方法。抽象類不能實例化,必須通過繼承由派生類實現其抽象方法。
抽象類既可以定義規則,還可能提供已實現的成員。
抽象類可以定義字段、屬性、包含有實現的方法。
抽象類只能作用於引用類型。
在程序執行時:
1.對象各自擁有自己的實例屬性
2.調用對象的方法,可以通過self
訪問自己的屬性
調用自己的方法
結論:
1.每一個對象都有自己獨立的內存空間,保存各自不同的屬性
2.多個對象的方法,在內存中有一份,在調用方法時,需要把對象的引用傳遞到方法內部
class Tool(object):
def __init__(self, name):
self.name = name
tool1 = Tool('耳機')
tool2 = Tool('充電線')
tool3 = Tool('手機')
class Tool(object):
# 1.使用了賦值語句定義類屬性,記錄所有工具的數量
count = 0
def __init__(self, name):
self.name = name
# 讓類屬性+1
Tool.count += 1
# 創建工具對象(對象在創建的時候,會自動調用初始化方法)
tool1 = Tool('耳機')
tool2 = Tool('充電線')
tool3 = Tool('手機')
# 輸出對象的總數
# 使用 類名.屬性名 來獲取
print Tool.count
類屬性
在python中,類是一個特殊的對象–類對象
@classmethod
除了封裝 實例(對象) 的屬性和方法外,類對象還可以有自己的方法和屬性
通過 類名.的方式可以直接訪問類的屬性或者調用類的方法
class Toy(object):
# 1.定義類屬性
count = 0
@classmethod
def show_toy_count(cls):
# cls.count:在類方法的內部,訪問當前的類屬性
print '玩具對象的數量 %d' % cls.count
def __init__(self, name):
self.name = name
Toy.count += 1
# 讓類屬性的值 +1
# 創建玩具對象
toy1 = Toy('芭比')
toy2 = Toy('丁丁車')
toy3 = Toy('大毛')
# 調用類方法
Toy.show_toy_count()
# 在方法的內部,可以直接訪問類屬性
靜態方法:
在開發時,如果需要在類中封裝一個方法,這個方法:
即不需要訪問實例屬性或者調用實例方法
也不需要訪問類屬性或調用類方法
這個時候可以把這個方法封裝成一個靜態方法
語法如下:
@staticmethod
def 靜態方法():
pass
靜態方法需要修飾器@staticmethod來標示,告訴解釋器這是一個靜態方法
通過類名,調用實例方法
class Cat(object):
@staticmethod
# 靜態方法不需要傳遞第一個參數:self
def call():
print '小貓喵喵叫'
# 通過類名,調用靜態方法
# 不需要創建對象,可以直接使用
Cat.call()
綜合應用:
1.設計一個Game類
2.屬性
設計記錄遊戲的歷史最高分
記錄當前遊戲玩家的玩家姓名
3.方法:
方法show_help顯示遊戲幫助
方法show_top_score顯示歷史最高分
方法start_game開始當前玩家的遊戲
4.主程序步驟
1.查看幫助信息
2.查看歷史最高分
3.創建遊戲對象,開始遊戲
class Tools(object):
@staticmethod
def show_help():
print 'help menu ,我可以幫到你哦'
def Pleyer_name(self):
print '當前玩家: %s' % self.name
def start_game(self):
print '歡迎來到第一關,遊戲開始,請做好準備'
class Game(Tools):
def __init__(self, name, score):
self.name = name
self.score = score
self.history = 20
def show_top_score(self):
# 1. 判斷玩家得分
if self.score <= self.history:
print '對不起,您距離最高分還差一點點'
return
else:
print ' 最高分 %s' % self.score
Player = Game('xiaoming', 60)
Tools.show_help()
Player.Pleyer_name()
Player.show_top_score()
Player.start_game()
1.設計一個Game類
2.屬性
類屬性
設計記錄遊戲的歷史最高分
實例方法
記錄當前遊戲玩家的玩家姓名
3.方法:
靜態方法
方法show_help顯示遊戲幫助
方法show_top_score顯示歷史最高分
方法start_game開始當前玩家的遊戲
4.主程序步驟
1.查看幫助信息
2.查看歷史最高分
class Game(object):
# 1.記錄歷史最高分
top_score = 0
def __init__(self, player_name):
self.player_name = player_name
@staticmethod
def show_help():
print 'Help menu'
@classmethod
def show_top_score(cls):
print '歷史記錄 %d' % cls.top_score
def start_game(self):
print '%s 開始遊戲,請做好準備' % self.player_name
player = Game('花花')
player.show_help()
player.start_game()
player.show_top_score()
案例小結
1.實例方法:方法內部需要訪問實例屬性
2.類方法:方法內部只需要訪問類屬性
3.靜態方法:方法內部不需要訪問實例屬性和類屬性
提問:如果方法內部,即需要訪問實例屬性,又需要訪問類屬性,應該使用哪種方法
應該定義實例方法
私有屬性和私有方法:
應用場景:
在實際開發中,對象的某些屬性或方法只希望在對象的內部使用,而不希望在外部被訪問到
私有屬性 就是對象 不希望公開的屬性
私有方法 就是對象 不希望公開的方法
定義方法:
在定義屬性或方法是,在屬性或方法名前增加兩個下劃線,定義的就是私有方法和屬性
父類的私有屬性和私有方法
1.字類對象不能在自己的方法內部,直接訪問父類的私有方法
2.字類對象可以通過父類惡公有方法簡介訪問到私有屬性
私有屬性,私有方法是對象的隱私,不對外公開
私有屬性,私有方法常用做一些內部的事情
class Girl():
def __init__(self,name):
self.name = name
self.__age = 3
print self.__age
def __secret(self):
print '%s的年齡是 %d' % (self.name,self.__age)
# 私有屬性,外界不允許訪問
lily = Girl('Lily')
# 私有方法,外界不允許直接訪問
lily.secret()
在繼承中,子類不能繼承父類的私有屬性/調用私有方法
class A(object):
def __init__(self):
# 初始化定義了一個共有屬性和一個私有屬性
self.num1 = 100
self.__num2 = 200
def __test(self):
print '私有方法'
print '%s %s' %(self.num1,self.__num2)
# 父類中定義了一個私有方法
class B(A):
pass
# 創建了一個字類對象
b = B()
print b
# 在繼承中,子類不能繼承父類的私有屬性/調用私有方法
# b.__num2
# b.__test
print b.__num2
父類的私有屬性和私有方法
1.子類對象不能在自己的方法內部,直接訪問父類的私有屬性和私有方法
2.子類對象可以通過父類的共有屬性間接訪問到私有屬性或私有方法
私有屬性,私有方法是對象的隱私,不對外公開,外界以及子類都不能直接訪問
私有屬性,私有方法常做一些內部的事情
class A(object):
def __init__(self):
# 初始化定義了一個共有屬性和一個私有屬性
self.num1 = 100
self.__num2 = 200
def __test(self):
print '私有方法'
print '%d %d' % (self.num1, self.__num2)
# 父類中定義了一個私有方法
class B(A):
def demo(self):
# 在子類的方法中,不能訪問父類的私有屬性
print '訪問父類的私有屬性 %d' % self.__num2
a = A()
print a
b = B()
print b
class A(object):
def __init__(self):
# 初始化定義了一個共有屬性和一個私有屬性
self.num1 = 100
self.__num2 = 200
def __test(self):
print '私有方法'
print '%d %d' % (self.num1, self.__num2)
# 父類中定義了一個私有方法
class B(A):
def demo(self):
# 在子類的方法中,不能訪問父類的私有屬性
print '訪問父類的私有屬性 %d' % self.__num2
b = B()
print b
b.demo()
如何讓私有屬性可以被子類訪問:
將其變爲公有屬性:
class A(object):
def __init__(self):
# 初始化定義了一個共有屬性和一個私有屬性
self.num1 = 100
self.__num2 = 200
def __test(self):
print '私有方法'
print '%d %d' % (self.num1, self.__num2)
# 父類中定義了一個私有方法
def test(self):
print '%d' % self.__num2
self.__test()
class B(A):
def demo(self):
# 在子類的方法中,不能訪問父類的私有屬性
print '訪問父類的私有屬性 %d' % self.__num2
b = B()
print b
b.test()
# 讓私有屬性可以被子類訪問