天天看點
傳回

Python 面向對象系列（二）01 封裝02 小明愛跑步案例03 擺放家具案例04 士兵突擊案例05 身份運算符06 私有屬性和私有方法

面向對象封裝案例練習

  • 01 封裝
  • 02 小明愛跑步案例
    • 2.1 小明愛跑步案例擴充 -- 小美也愛跑步
  • 03 擺放家具案例
    • 3.1 需求分析，被使用類的應該先開發
    • 3.2 家具類以及建立家具對象
    • 3.3 定義房子類
    • 3.4 添加家具
  • 04 士兵突擊案例
    • 4.1 開發搶類
    • 4.2 開發士兵類
  • 05 身份運算符
  • 06 私有屬性和私有方法
    • 6.1 應用場景及定義方式
    • 6.2 僞私有屬性和私有方法（科普）

01 封裝

  1. 封裝 是面向對象程式設計的一大特點
  2. 面向對象程式設計的 第一步 —— 将 屬性 和 方法 封裝 到一個抽象的 類 中
  3. 外界 使用 類 建立 對象，然後 讓對象調用方法
  4. 對象方法的細節 都被 封裝 在 類的内部
一個對象的 屬性 可以是 另外一個類建立的對象

02 小明愛跑步案例

需求

  1. 小明 體重 75.0 公斤
  2. 小明每次 跑步 會減肥0.5 公斤
  3. 小明每次 吃東西 體重增加 1 公斤
類 屬性 方法
Person

name

weight

__ init __(self,name,weight):

__ str __(self):

run(self):

eat(self):
提示：在 對象的方法内部，是可以 直接通路對象的屬性 的！

代碼實作

class Person:

    def __init__(self, name, weight):
        # self.屬性 = 形參
        self.name = name
        self.weight = weight

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

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

    def eat(self):
        print("%s 是吃貨，吃完這頓在減肥" % self.name)
        self.weight += 1


xiaoming = Person("小明", 75.0)

xiaoming.run()
xiaoming.eat()

print(xiaoming)

輸出結果

小明 愛跑步，跑步鍛煉身體

小明 是吃貨，吃完這頓在減肥

我的名字叫 小明 體重是 75.50 公斤

2.1 小明愛跑步案例擴充 – 小美也愛跑步

需求

  1. 小明 和 小美 都愛跑步
  2. 小明 體重 75.0 公斤
  3. 小美 體重 45.0 公斤
  4. 每次 跑步 會減肥0.5 公斤
  5. 每次 吃東西 體重增加 1 公斤
類 屬性 方法
Person

name

weight

__ init __(self,name,weight):

__ str __(self):

run(self):

eat(self):
提示：
  1. 在 對象的方法内部，是可以 直接通路對象的屬性 的
  2. 同一個 類 建立的 多個對象 之間，屬性 互不幹擾

代碼實作

class Person:

    def __init__(self, name, weight):
        # self.屬性 = 形參
        self.name = name
        self.weight = weight

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

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

    def eat(self):
        print("%s 是吃貨，吃完這頓在減肥" % self.name)
        self.weight += 1


xiaoming = Person("小明", 75.0)

xiaoming.run()
xiaoming.eat()

print(xiaoming)

xiaomei = Person("小美", 45.0)
xiaomei.eat()
xiaomei.run()

print(xiaomei)
print(xiaoming)

輸出結果

小明 愛跑步，跑步鍛煉身體

小明 是吃貨，吃完這頓在減肥

我的名字叫 小明 體重是 75.50 公斤

小美 是吃貨，吃完這頓在減肥

小美 愛跑步，跑步鍛煉身體

我的名字叫 小美 體重是 45.50 公斤

我的名字叫 小明 體重是 75.50 公斤

03 擺放家具案例

需求

  1. 房子(House) 有 戶型、總面積 和 家具名稱清單
    • 新房子沒有任何的家具
  2. 家具(HouseItem) 有 名字 和 占地面積，其中
    • 席夢思(bed) 占地 4 平米
    • 衣櫃(chest) 占地 2 平米
    • 餐桌(table) 占地 1.5 平米
  3. 将以上三件 家具 添加 到 房子 中
  4. 列印房子時，要求輸出：戶型、總面積、剩餘面積、家具名稱清單

3.1 需求分析，被使用類的應該先開發

類 屬性 方法
HouseItem

name

area

__ init __(self,name,area):

__ str __(self):
House

house_type

area

free_area

item_list

__ init __(self,house_type,area):

__ str __(self):

add_item(self,item):

剩餘面積

  1. 在建立房子對象時，定義一個 剩餘面積的屬性、初始值和總面積相等

  2. 當調用 add_item 方法，向房間 添加家具 時，讓 剩餘面積 -= 家具面積

    思考：應該先開發哪一個類？

    答案 —— 家具類

  3. 家具簡單
  4. 房子要使用到家具，被使用的類，通常應該先開發

3.2 家具類以及建立家具對象

代碼實作

class HouseItem:

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

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


# 1、建立家具
bed = HouseItem("席夢思", 4)
chest = HouseItem("衣櫃", 2)
table = HouseItem("餐桌", 1.5)

print(bed)
print(chest)
print(table)

輸出結果

[席夢思] 占地 4.00

[衣櫃] 占地 2.00

[餐桌] 占地 1.50

小結

  1. 建立了一個 家具類，使用到 __ init __ 和 __ str __ 兩個内置方法
  2. 使用 家具類 建立了三個家具對象

3.3 定義房子類

代碼實作

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):
        # Python 能夠自動的将一對括号内部的代碼連接配接在一起
        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、建立家具
bed = HouseItem("席夢思", 4)
chest = HouseItem("衣櫃", 2)
table = HouseItem("餐桌", 1.5)

print(bed)
print(chest)
print(table)

# 2.建立房子對象
my_home = House("兩室一廳", 80)

my_home.add_item(bed)
my_home.add_item(chest)
my_home.add_item(table)

print(my_home)

輸出結果

[席夢思] 占地 4.00

[衣櫃] 占地 2.00

[餐桌] 占地 1.50

要添加 [席夢思] 占地 4.00

要添加 [衣櫃] 占地 2.00

要添加 [餐桌] 占地 1.50

戶型：兩室一廳

總面積：80.00[剩餘面積：80.00]

家具：[]

小結

  1. 建立了一個 房子類，使用到 __ init __ 和 __ str __ 兩個内置方法
  2. 準備了一個 add_item 方法 準備添加家具
  3. 使用 房子類 建立了一個房子對象
  4. 讓 房子對象 調用了三次 add_item 方法 方法，将 三件家具 以實參傳遞到 add_item 方法 内部

3.4 添加家具

需求

  1. 判斷 家具面積 是否 超過剩餘面積，如果超過，則提示不能添加這件家具
  2. 将 家具名稱 追加到 家具名稱清單 中
  3. 用 房子的剩餘面積 - 家具面積

代碼實作

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):
        # Python 能夠自動的将一對括号内部的代碼連接配接在一起
        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


# 1、建立家具
bed = HouseItem("席夢思", 40)
chest = HouseItem("衣櫃", 2)
table = HouseItem("餐桌", 1.5)

print(bed)
print(chest)
print(table)

# 2.建立房子對象
my_home = House("兩室一廳", 80)

my_home.add_item(bed)
my_home.add_item(chest)
my_home.add_item(table)

print(my_home)

輸出結果

[席夢思] 占地 40.00

[衣櫃] 占地 2.00

[餐桌] 占地 1.50

要添加 [席夢思] 占地 40.00

要添加 [衣櫃] 占地 2.00

要添加 [餐桌] 占地 1.50

戶型：兩室一廳

總面積：80.00[剩餘面積：36.50]

家具：[‘席夢思’, ‘衣櫃’, ‘餐桌’]

小結

  1. 主程式隻負責建立 房子 對象 和 家具 對象
  2. 讓 房子 對象調用 add_item 方法 方法 将家具添加到房子中
  3. 面積計算、剩餘面積、家具清單 等處理都被 封裝 到 房子類的内部

04 士兵突擊案例

需求

  1. 士兵 許三多 有一把 AK47
  2. 士兵 可以 開火
  3. 搶 能夠 發射 子彈
  4. 搶 能夠 填裝子彈 —— 增加子彈數量
類 屬性 方法
Soldier

name

gun

__ init __(self,name,area):

fire(self):
Gun

model

bullet_count

__ init __(self,house_type,area):

add_bullet(self,count):

shoot(self):

4.1 開發搶類

代碼實作

class Gun:

    def __init__(self, model):

        # 1. 搶的型号
        self.model = model

        # 2. 子彈數量
        self.bullet_count = 0

    def add_bullet(self, count):

        self.bullet_count += count

    def shoot(self):

        # 1. 判斷子彈數量
        if self.bullet_count <= 0:
            print("[%s]沒有子彈了" % self.model)
            return

        # 2. 發射子彈，-1
        self.bullet_count -= 1

        # 3. 提示發射資訊
        print("[%s]突突突...[%d]" % (self.model, self.bullet_count))


# 1. 建立搶對象
ak47 = Gun("AK-47")

ak47.add_bullet(100)
ak47.shoot()

輸出結果

[AK-47]突突突…[99]

4.2 開發士兵類

假設：每一個新兵 都 沒有搶

定義沒有初始值的屬性

在定義屬性時，如果 不知道設定什麼初始值，可是設定為 None

  • None 關鍵字 表示 什麼都沒有
  • 表示一個 空對象，沒有屬性和方法，是一個特殊的常量
  • 可以将None指派給任何一個變量

fire方法需求

  1. 判斷是否有搶，沒有搶沒法沖鋒
  2. 喊一聲口号
  3. 裝填子彈
  4. 射擊

代碼實作

class Gun:

    def __init__(self, model):

        # 1. 槍的型号
        self.model = model

        # 2. 子彈數量
        self.bullet_count = 0

    def add_bullet(self, count):

        self.bullet_count += count

    def shoot(self):

        # 1. 判斷子彈數量
        if self.bullet_count <= 0:
            print("[%s]沒有子彈了" % self.model)
            return

        # 2. 發射子彈，-1
        self.bullet_count -= 1

        # 3. 提示發射資訊
        print("[%s]突突突...[%d]" % (self.model, self.bullet_count))


class Soldier:

    def __init__(self, name):

        # 1.姓名
        self.name = name
        # 1.槍-新兵沒有搶
        self.gun = None

    def fire(self):

        # 1.判斷士兵是否有搶
        if self.gun is None:
            print("[%s] 還沒有搶..." % self.name)

            return

        # 2.高喊口号
        print("沖啊...[%s]" % self.name)

        # 3.讓搶裝填子彈
        self.gun.add_bullet(50)

        # 4.讓搶發射子彈
        self.gun.shoot()


# 1. 建立槍對象
ak47 = Gun("AK-47")

# 2. 建立許三多
xusanduo = Soldier("許三多")

xusanduo.gun = ak47
xusanduo.fire()

print(xusanduo.gun)

輸出結果

沖啊…[許三多]

[AK-47]突突突…[49]

<main.Gun object at 0x0000022DD8586A60>

05 身份運算符

身份運算符用于 比較 兩個對象的 記憶體位址 是否一緻 – 是否是對同一個對象的引用

在Python中針對None 比較時，建議使用is判斷

運算符 描述 執行個體
is is是判斷兩個辨別符是不是引用同一個對象 x is y,類似 id(x)==id(y)
is not is not是判斷兩個辨別符是不是引用不同對象 x is not y,類似 id(x)!=id(y)

is 與 == 差別：

is 用于判斷 兩個變量 引用對象是否為同一個

== 用于判斷 引用變量的值 是否相等

a = [1, 2, 3]

b = [1, 2, 3]

b is a

Flase

b == a

True

06 私有屬性和私有方法

6.1 應用場景及定義方式

應用場景

  • 在實際開發中，對象 的 某個屬性或方法 可能隻希望 在對象的内部被使用，而 不希望在外部被通路到
  • 私有屬性 就是 對象 不希望公開的 屬性

  • 私有方法 就是 對象 不希望公開的 方法

    定義方式

  • 在 定義屬性或方法時，在 屬性名或者方法名 前 增加 兩個下劃線，定義的就是 私有 屬性和方法
Women
name   __ age
__ init __ (self,name) :    __secret(self): 
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)
# 私有方法，同樣不允許在外界直接被通路
# xiaofang.__secret()

6.2 僞私有屬性和私有方法（科普）

提示：在日常開發中，不要使用這種方式，通路對象的 私有屬性 或 私有方法

Python中，并沒有真正意義的私有

  • 在給 屬性、方法命名時，實際是對 名稱 做了一些特殊處理，是的外界無法通路到
  • 處理方式：在名稱前面加上 _類名 => _類名_名稱 
# 私有屬性，在外界不能直接被通路
print(xiaofang._Women__age)
# 私有方法，同樣不允許在外界直接被通路
xiaofang._Women__secret()
Python 類 面向對象程式設計 封裝
上一篇: 簡單插入排序（Insertion Sort）——插入類排序法（Java實作）
下一篇: Python3面向對象概念

繼續閱讀