python進階（4）：初識面向對象

一切皆對象！預習： #仿照正方形類寫一個圓形類 class Square: def __init__(self,length_of_side): self.length_of_side = length_of_side def square(self): '面積' return self.leng ...

一切皆對象！

預習：

#仿照正方形類寫一個圓形類
class Square:
    def __init__(self,length_of_side):
        self.length_of_side = length_of_side

    def square(self):
        '面積'
        return self.length_of_side * self.length_of_side

    def perimeter(self):
        '周長'
        return self.length_of_side * 4

正方形 = Square(2)
print(正方形.square())
print(正方形.perimeter())

預習題

一、面向過程-->面向對象

面向過程：根據業務邏輯從上到下堆疊代碼

函數式：將某功能代碼封裝到函數中，日後便無需重覆編寫，僅調用函數即可

面向對象：對函數進行分類和封裝，讓開發“更快更好更強...”

二、初始類和對象

python中一切皆為對象，類型的本質就是類，所以你已經使用了很長時間的類了

在python中，用變數表示特征，用函數表示技能，因而具有相同特征和技能的一類事物就是‘類’，對象是則是這一類事物中具體的一個。

1、類

#定義一個人類 class類關鍵字和定義函數時的def同理
class Person:   
    role = 'person'  
    #role變數 屬性—— 靜態屬性
    def walk(self):  
    #self必須寫（作用後面會介紹）方法，也叫動態屬性
        print("person is walking..."

類

屬性引用（類名.屬性）

class Person:
    role = 'person' 
    def walk(self):
        print("person is walking...")


print(Person.role)  #查看人的role屬性
print(Person.walk)  #引用人的走路方法，註意，這裡不是在調用

引用

實例化：類名加括弧就是實例化，會自動觸發__init__函數的運行，可以用它來為每個實例定製自己的特征

語法：對象名 = 類名(參數)

class Person:   #定義一個人類
    role = 'person'
    def __init__(self,name):
        self.name = name  # 每一個角色都有自己的昵稱;
 
蒼井井 = Person('蒼井井')
小澤澤 = Person('小澤澤')
#實例化的過程就是類——>對象的過程

實例化

類名()就等於在執行Person.__init__()，執行完__init__()就會返回一個對象。這個對象類似一個字典，存著屬於這個人本身的一些屬性和方法。

查看屬性&調用方法

print(蒼井井.name)     #查看對象屬性直接 對象名.屬性名

self：在實例化時自動將對象/實例本身傳給__init__的第參數，必須寫可以有別名但不建議用別名

類補充

一：我們定義的類的屬性到底存到哪裡了？有兩種方式查看
dir(類名)：查出的是一個名字列表
類名.__dict__:查出的是一個字典，key為屬性名，value為屬性值

二：特殊的類屬性
類名.__name__# 類的名字(字元串)
類名.__doc__# 類的文檔字元串
類名.__base__# 類的第一個父類(在講繼承時會講)
類名.__bases__# 類所有父類構成的元組(在講繼承時會講)
類名.__dict__# 類的字典屬性
類名.__module__# 類定義所在的模塊
類名.__class__# 實例對應的類(僅新式類中)

類屬性的補充

2、對象

我們來寫一個人狗大戰：現在我們需要對我們的類做出一點點改變。人類除了可以走路之外應該具備一些攻擊技能

class Person:  # 定義一個人類
    role = 'person'  # 人的角色屬性都是人
    def __init__(self, name, aggressivity, life_value):
        self.name = name  # 每一個角色都有自己的昵稱;
        self.aggressivity = aggressivity  # 每一個角色都有自己的攻擊力;
        self.life_value = life_value  # 每一個角色都有自己的生命值;
    def attack(self,dog):
        # 人可以攻擊狗，這裡的狗也是一個對象。
        dog.life_value -= self.aggressivity
        print("{0}打了{1}一下，{1}剩餘血量{2}".format(self.name, dog.name, dog.life_value))

人類

對象是關於類而實際存在的一個例子，即實例。對象/實例只有一種作用：屬性引用

蒼井井 = Person('蒼井井',10,1000)
print(蒼井井.name)
print(蒼井井.aggressivity)
print(蒼井井.life_value)

你也可以引用一個方法，因為方法也是一個屬性（動態屬性）。

class 類名:
    類屬性 = None
    def __init__(self,參數1,參數2):
        self.對象的屬性1 = 參數1
        self.對象的屬性2 = 參數2

    def 方法名(self):pass

    def 方法名2(self):pass

對象名 = 類名(1,2)  #對象就是實例，代表一個具體的東西
                  #類名() : 類名+括弧就是實例化一個類，相當於調用了__init__方法
                  #括弧里傳參數，參數不需要傳self，其他與init中的形參一一對應
                  #結果返回一個對象
對象名.對象的屬性1   #查看對象的屬性，直接用 對象名.屬性名 即可
對象名.方法名()     #調用類中的方法，直接用 對象名.方法名() 即可
#對象增加屬性
對象.新的屬性名 = 1000

小結

對象之間的交互

既然我們要做人狗大戰，我們已經有人了，現在我們要再創建一個狗類，狗咬人，我們給狗一個bite方法。有了狗類，我們再實例化一隻實實在在的狗出來。人和狗就可以打架了。

class Dog:  # 定義一個狗類
    role = 'dog'  # 狗的角色屬性都是狗
    def __init__(self, name, breed, aggressivity, life_value):
        self.name = name  # 每一隻狗都有自己的昵稱;
        self.breed = breed  # 每一隻狗都有自己的品種;
        self.aggressivity = aggressivity  # 每一隻狗都有自己的攻擊力;
        self.life_value = life_value  # 每一隻狗都有自己的生命值;
    def bite(self,people):
        # 狗可以咬人，這裡的狗也是一個對象。
        people.life_value -= self.aggressivity
        print("{0}咬了{1}一下，{1}剩餘血量{2}".format(self.name,people.name,people.life_value))

狗類

實例化一隻狼狗：

egon = Dog('egon','狼狗',100,20000)  #創造了一隻實實在在的狗egon

交互蒼井井打了 egon 一下/egon 咬了蒼井井一下

a = Person("蒼井井",10,1000)
b = Dog("egon","狼狗",100,20000)
a.attack(b)
b.bite(a)

交互

完整的人狗大戰代碼：

class Person:  # 定義一個人類
    role = 'person'  # 人的角色屬性都是人
    def __init__(self, name, aggressivity, life_value):
        self.name = name  # 每一個角色都有自己的昵稱;
        self.aggressivity = aggressivity  # 每一個角色都有自己的攻擊力;
        self.life_value = life_value  # 每一個角色都有自己的生命值;
    def attack(self,dog):
        # 人可以攻擊狗，這裡的狗也是一個對象。
        dog.life_value -= self.aggressivity
        print("{0}打了{1}一下，{1}剩餘血量{2}".format(self.name, dog.name, dog.life_value))

class Dog:  # 定義一個狗類
    role = 'dog'  # 狗的角色屬性都是狗
    def __init__(self, name, breed, aggressivity, life_value):
        self.name = name  # 每一隻狗都有自己的昵稱;
        self.breed = breed  # 每一隻狗都有自己的品種;
        self.aggressivity = aggressivity  # 每一隻狗都有自己的攻擊力;
        self.life_value = life_value  # 每一隻狗都有自己的生命值;
    def bite(self,people):
        # 狗可以咬人，這裡的狗也是一個對象。
        people.life_value -= self.aggressivity
        print("{0}咬了{1}一下，{1}剩餘血量{2}".format(self.name,people.name,people.life_value))

a = Person("蒼井井",10,1000)
b = Dog("egon","狼狗",200,20000)
while True :
    a.attack(b)
    b.bite(a)
    if a.life_value <= 0 :
        print(a.name+"被"+b.name+"咬死了！")
        break
    if b.life_value <= 0 :
        print(b.name + "被" + a.name + "咬死了！")
        break

egon大戰蒼井井

三、類命名空間與對象、實例的命名空間

創建一個類就會創建一個類的名稱空間，用來存儲類中定義的所有名字，這些名字稱為類的屬性

靜態屬性就是直接在類中定義的變數，動態屬性就是定義在類中的方法

其中類的數據屬性是共用給所有對象的

print(id(a.role))
print(id(Person.role))  #相同

而類的動態屬性是綁定到所有對象的

print(a.attack)
print(Person.attack)  #不同

創建一個對象/實例就會創建一個對象/實例的名稱空間，存放對象/實例的名字，稱為對象/實例的屬性，在obj.name會先從obj自己的名稱空間里找name，找不到則去類中找，類也找不到就找父類...最後都找不到就拋出異常

四、面向對象的組合用法

組合指的是，在一個類中以另外一個類的對象作為數據屬性，稱為類的組合

class Weapon:
    '''
        這是一個游戲里武器的數據類型
    '''
    def __init__(self,name, price, aggrev, life_value):
        self.name = name    #武器名稱
        self.price = price  #武器價格
        self.aggrev = aggrev    #武器傷害加成
        self.life_value = life_value    #武器血量加成

    def update(self, obj):  #obj就是要帶這個裝備的人
        obj.money -= self.price  # 用這個武器的人花錢買所以對應的錢要減少
        obj.aggressivity += self.aggrev  # 帶上這個裝備可以讓人增加攻擊
        obj.life_value += self.life_value  # 帶上這個裝備可以讓人增加生命值

    def prick(self, obj):  # 這是該裝備的主動技能，絞龍
        obj.life_value -= 3000  # 假設攻擊力是3000

武器類

組合交互人狗大戰完整代碼：

class Person:  # 定義一個人類
    '''
        這是一個游戲裡人物的數據類型
    '''
    role = 'person'  # 人的角色屬性都是人
    def __init__(self, name, aggressivity, life_value):
        self.name = name  # 每一個角色都有自己的昵稱;
        self.aggressivity = aggressivity  # 每一個角色都有自己的攻擊力;
        self.life_value = life_value  # 每一個角色都有自己的生命值;
    def attack(self,dog):
        # 人可以攻擊狗，這裡的狗也是一個對象。
        dog.life_value -= self.aggressivity
        print("{0}打了{1}一下，{1}剩餘血量{2}".format(self.name, dog.name, dog.life_value))

class Dog:  # 定義一個狗類
    '''
        這是一個游戲里狗的數據類型
    '''
    role = 'dog'  # 狗的角色屬性都是狗
    def __init__(self, name, breed, aggressivity, life_value):
        self.name = name  # 每一隻狗都有自己的昵稱;
        self.breed = breed  # 每一隻狗都有自己的品種;
        self.aggressivity = aggressivity  # 每一隻狗都有自己的攻擊力;
        self.life_value = life_value  # 每一隻狗都有自己的生命值;
    def bite(self,people):
        # 狗可以咬人，這裡的狗也是一個對象。
        people.life_value -= self.aggressivity
        print("{0}咬了{1}一下，{1}剩餘血量{2}".format(self.name,people.name,people.life_value))

class Weapon:
    '''
        這是一個游戲里武器的數據類型
    '''
    def __init__(self,name, price, aggrev, life_value):
        self.name = name    #武器名稱
        self.price = price  #武器價格
        self.aggrev = aggrev    #武器傷害加成
        self.life_value = life_value    #武器血量加成

    def update(self, obj):  #obj就是要帶這個裝備的人
        obj.money -= self.price  # 用這個武器的人花錢買所以對應的錢要減少
        obj.aggressivity += self.aggrev  # 帶上這個裝備可以讓人增加攻擊
        obj.life_value += self.life_value  # 帶上這個裝備可以讓人增加生命值

    def prick(self, obj):  # 這是該裝備的主動技能，絞龍
        obj.life_value -= 3000  # 假設攻擊力是3000
        print("{0}發動主動技：蛟龍==>{1}剩餘血量{2}".format(self.name, obj.name, obj.life_value))


a = Person("蒼井井",10,1000)
b = Dog("egon","狼狗",200,20000)
c = Weapon("蛟龍鞭",1000,40,2000)
a.money = 2000

#判斷是否買的起武器
if a.money > c.price :
    c.update(a)
    a.weapon = c

#大戰開始
while True :
    a.attack(b)
    if b.life_value <= 0 :
        print(b.name + "被" + a.name + "打死了！")
        break
    a.weapon.prick(b)
    if b.life_value <= 0 :
        print(b.name + "被" + a.name + "絞死了！")
        break
    b.bite(a)
    if a.life_value <= 0 :
        print(a.name+"被"+b.name+"咬死了！")
        break

egon大戰蒼井井升級版

思維導圖：

預習答案：

#圓形類
class Circle:
    def __init__(self,radius):
        self.radius = radius

    def area(self):
        '面積'
        return self.radius **2  * 3.14

    def perimeter(self):
        '周長'
        return self.radius * 2 *3.14

圓 = Circle(8)
print(圓.area())
print(圓.perimeter())

預習答案