類

舊式類（經典類）和新式類

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()
# 讓私有屬性可以被子類訪問