Python教程6

　　1.面向物件

# -*-coding:utf-8-*-
""""
面向物件：相比較函式，面向物件是更大的封裝，根據職責在一個物件中封裝多個方法
1.在完成某一個需求前，首先確定不過職責---要做的事情（方法）
2.根據職責確定不同的物件，在物件內部封裝不同的方法
特點：
注重物件和職責，不同的物件承擔不同的職責
更加適合對複雜的需求變化，是專門對應復炸專案的開發，提供固定的套路
需要在面向物件的基礎上，再學習一些面向物件的語法
兩個核心概念：
類：是對一群具有相同特徵或者行為的事務一個統稱，是抽象的，不能直接使用（類包括屬性和方法）
物件：是類建立的一個具體的存在
類是模板，物件根據模板創建出來的
類只有一個，而物件可以用很多個，不同的物件之間屬性可能會各不相同
類中定義的屬性和方法，物件中就有什麼屬性和方法，不能多，野不能少

再開發程式中，設計類需要滿足三個要素：
類名，屬性，方法
 
"""

""""
dir 內建函式（知道）
在python中物件是無所不在的，變數，資料，函式都是物件
驗證方法：
1.在識別符號/資料 後面輸入一個.，然後按TAB鍵會顯示物件能呼叫的方法列表
2.使用內建函式dir傳入識別符號/資料 ，可以檢視物件內所有的屬性和方法的一個列表
"""


def demo():
    """"這是個測試函式"""
    print("hello python")


demo()
print(dir(demo))  # dir()內建函式的使用
print(demo.__doc__)  # 內建函式__doc__的使用

# 定義簡單的類（只包含方法）,建立物件
 

"""
class 類名：
    def 方法1（self,引數列表）
        pass
    def 方法2（self,引數列表）
        pass
建立物件：
物件變數 = 類名（）
"""


# 第一個面向物件的程式：小貓愛吃魚，小貓要喝水
class Cat:
    def eat(self):  # 哪一個物件呼叫的方法，self就是哪一個物件的引用
        print("%s貓愛吃魚" % self.name)

    def drink(self):
        print("小貓要喝水")


# 建立貓物件
tom = Cat()
tom.name 
 
= "Tom"  #如果這行增加的屬性在貓的方法tom.eat()和tom.drink（）後，則會報錯
tom.eat()
tom.drink()
# 物件同樣使用引用
print(tom)
addr = id(tom)
print("%d" % addr)  # %d 十進位制列印輸出
print("%x" % addr)  # %x 十六進位制列印輸出

# 再建立一個貓物件
lazy_cat = Cat()
lazy_cat.name = "大懶貓"
lazy_cat.eat()
lazy_cat.drink()
print(lazy_cat)  # 兩隻貓tom和lazy_cat的記憶體地址不一樣，
lazy_cat2 = lazy_cat  # 這兩隻貓記憶體一樣

# 給某個物件增加屬性，不推薦使用

　　2.初始化方法

# -*-coding:utf-8-*-
""""
初始化方法：
當使用類名（）建立物件時，會執行以下操作：
1.為物件在記憶體中分配空間--建立物件
2.為物件的屬性設定初始值--初始化方法（__init__）
"""


class Cat:
    def __init__(self):
        print("這是初始化方法")


tom = Cat()  # 使用類名（）建立物件時，會自動呼叫初始化方法
"""__init__(self)方法時專門用來定義一個類具有那些屬性方法！"""


# 在初始方法內部定義屬性
class Cat1:
    def __init__(self):
        print("這是Cat1類初始化方法")
        self.name = "Tom"


tom = Cat1()
print(tom.name)


# 使用引數設定屬性的初始值
class Cat2():
    def __init__(self, new_name):
        self.name = new_name

    def eat(self):
        print("%s 愛吃魚" % self.name)


ton = Cat2("黃小魚")
print(ton.name)
ton.eat()

# __del__方法，如果希望物件在被銷燬前，在做些事情
print("__del__物件銷燬方法")


class Cat3():
    def __init__(self, new_name):
        self.name = new_name
        print("這是初始化方法，%s 我來了" % self.name)

    def __del__(self):
        print("這是物件銷燬方法，%s 我去了" % self.name)


ton1 = Cat3("TON")
print("-" * 50)  # 注意銷燬方法，是在程式結束時，即此行後列印。
del ton1  # del ton1可以提前銷燬物件
print("*" * 50)

# __str__方法，使用print輸出物件變數，預設情況下，會輸出這個變數的引用物件，
# 是由哪一個類建立的物件，以及在記憶體中的地址（十六進位制表示），__str__這個內建的方
# 法可以自定義內容，注意：__str__這個方法必須返回一個字串
print("__str__方法")  # 常用來列印變數


class Cat4():
    def __init__(self, new_name):
        self.name = new_name
        print("這是初始化方法，%s 我來了" % self.name)

    def __del__(self):
        print("這是物件銷燬方法，%s 我去了" % self.name)

    def __str__(self):
        print("這是__str__方法")
        return "我是小貓%s" % self.name


tomm = Cat4("tomm")
print(tomm)

　　3.封裝

# -*-coding:utf-8-*-
""""
封裝：
1.封裝是面向物件的一個特點
2.面向物件的第一步，將屬性和方法封裝到一個抽象的類中
3.外界使用類建立物件，然後讓物件呼叫方法
4.物件方法的細節都被封裝在類的內部
"""
"""封裝例項，小明愛跑步，需求：小明體重75.0公斤，每次跑步減肥0.5公斤，每次吃東西體重增加1公斤"""


class Person:
    def __init__(self, name, weight):
        self.name = name
        self.weight = weight

    def __str__(self):
        return "我的名字是 %s,我的體重是%.2f 公斤" % (self.name, self.weight)
        pass

    def run(self):
        print("%s 愛跑步，鍛鍊身體" % self.name)
        self.weight -= 0.5

    def eat(self):
        print("%s 愛吃東西，是個美食家" % self.name)
        self.weight += 1.0


xm = Person("小明", 75.0)
xm.run()
xm.eat()
print(xm)
""""在物件方法內部，是可以直接訪問物件的屬性的，同一個類中，多個物件之間屬性不干擾"""
# 小美物件
xiaomei = Person("小美", 45)
xiaomei.eat()
xiaomei.run()
print(xiaomei)
print(xm)  # 小明的體重不會增加

　　4.擺放傢俱例項

#-*-coding:utf-8-*-
# 案列2，擺放傢俱
""""
1.房子有戶型，總面積和傢俱名稱列表
新房子沒有任何傢俱
2.傢俱有名字和佔地面加，其中：
席夢思佔地4平米
衣櫃佔地2平米
餐桌佔地1.5平米
3.將以上三件餐具新增到房子中
4.列印房子時，需要輸出：戶型，總面積，剩餘面積，傢俱名稱列表
"""


class HouseItem:
    def __init__(self, name, area):
        self.name = name
        self.area = area

    def __str__(self):
        return "[%s] 佔地%.2f " % (self.name, self.area)


class House:
    def __init__(self, house_type, area):
        self.house_type = house_type
        self.area = area
        # 剩餘面積
        self.free_area = area
        # 傢俱列表
        self.item_list = []

    def __str__(self):
        return ("【戶型】: %s \n【總面積】：%.2f[剩餘面積:%.2f] \n【傢俱】：" \
                "%s" % (self.house_type, self.area, self.free_area,
                        self.item_list))

    def add_item(self, item):
        print("要新增%s" % item)
        #1.判斷傢俱的面積
        if item.area > self.free_area:
            print("！！！%s 面積太大，無法新增！！！" % item.name)
            return
        #2.將傢俱的名稱新增到列表
        self.item_list.append(item.name)
        #3.計數剩餘面積
        self.free_area -= item.area

# 建立傢俱
bed = HouseItem("席夢思", 40)
chest = HouseItem("衣櫃", 2)
table = HouseItem("餐桌", 20)
print(bed)
print(chest)
print(table)
# 建立房子物件
my_home = House("兩室一廳", 60)
my_home.add_item(bed)
my_home.add_item(chest)
my_home.add_item(table)
print(my_home)

　　5.士兵突擊例項

# -*-coding:utf-8-*-
""""
一個物件的屬性可以時另外一個類建立的物件
例項，士兵突擊：
1.士兵許三多有一把AK47
2.士兵可以開火
3.槍能發射子彈
4.搶能裝填子彈--增加子彈的數量
"""
print("！！！！士兵突擊開始！！！！")


class Gun:
    def __init__(self, model):
        self.model = model
        # 搶子彈初始值為0
        self.bullet_count = 0

    def add_bullet(self, count):
        self.bullet_count += count
        print("增加子彈數[%d]" % count)

    def shoot(self):
        # 判斷子彈數量
        if self.bullet_count <= 0:
            print("！！！沒有子彈，趕緊補充")
            return
        # 發射子彈
        self.bullet_count -= 3
        # 提示發射資訊
        print("[%s] 突 突 突 . . .！剩餘子彈[%d]" % (self.model, self.bullet_count))


# 士兵類
class Soldier:
    def __init__(self, name):
        self.name = name
        # 不知道初始值可以設定為None
        self.gun = None

    def fire(self):
        # 判斷是否有槍
        """身份運算子，比較兩個物件記憶體地址是否一致。==是變數值比較
        is /is not: x is y或者x is not y
        if self.gun is None:(建議使用)
        """
        if self.gun == None:
            print("[%s]還沒有槍！" % self.name)
            return
        # 高喊口號
        print("衝啊。。。。。[%s]" % self.name)
        # 裝填子彈
        self.gun.add_bullet(50)
        # 發射子彈
        self.gun.shoot()


ak47 = Gun("AK47")
xsd = Soldier("許三多")  # 定義許三多物件
xsd.gun = ak47
xsd.fire()
print(xsd.gun)

　　6.私有屬性和私有方法

# -*-coding:utf-8-*-
"""
在實際開發中，物件的某些屬性或方法，可能只希望在物件的內部使用，而不
希望在外部被訪問到：
1.私有屬性就是物件不希望公開的屬性
2.私有方法就是物件不希望公開的方法
3.在定義私有屬性或方法時，在屬性名或者方法名前，增加兩個下劃線，定義的就是
  私有屬性或者私有方法
"""


class Women:
    def __init__(self, name):
        self.name = name
        self.__age = 18

    def secret(self):
        print("%s的年齡時 %d" % (self.name, self.__age))


xiaofang = Women("小芳")
#  print(xiaofang.__age)  # 報錯，私有屬性在外界不能訪問
print(xiaofang._Women__age)  # 科普，python中沒有完全的私有的屬性，用這種方式同樣可以訪問
xiaofang.secret()  # 同樣，私有方法類似