基於python中的類屬性類結構及私有屬性私有方法

類

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

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