Python-面向對象之封裝與多態

時間 2019-12-02

標籤 python 面向對象封裝欄目 Python 简体版

原文原文鏈接

組合

什麼是組合

組合指的是一個對象中的屬性是另外一個對象的引用linux

組合是對象與對象的關係，一種什麼有什麼的關係，一個對象擁有另外一個對象
繼承是類與類的關係，一種什麼是什麼的關係，子類與父類是從屬關係

使用組合的目的

和繼承同樣減小代碼冗餘安全

如何使用組合

上代碼app

# 組合練習

# 定義相同屬性的屬性
class People:
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex

    # 每一個對象都都選課的權利/功能，添加課程功能，添加的課程利用組合知識點，添加課程的對象，
    # 進而對 課程對象操做
    def add_course(self,course_name):
        self.course_list.append(course_name)

    # 打印當前對象中全部課程的信息
    def tell_all_course(self):

        # 拿到當前對象的課程列表，列表中存放的是一個個課程對象
        for course_obj in self.course_list:

            # 每個課程對象能夠調用它的綁定方法查看課程的信息，
            # 利用for循環遍歷 進而能夠查看全部課程
            course_obj.tell_info()


class Teacher(People):
    def __init__(self,name,age,sex):
        super().__init__(name,age,sex)
        self.course_list = []

class Student(People):
    def __init__(self,name,age,sex):
        super().__init__(name,age,sex)
        self.course_list = []

# 定義課程類
class Course:
    def __init__(self,name,period,price):
        self.name = name
        self.period = period
        self.price = price

    def tell_info(self):
        print(f"""
        課程名稱：{self.name}
        課程週期：{self.period}
        課程價錢：{self.price}
        """)

# 實例化老師和學生類
tea1 = Teacher("tank",18,"man")
stu1 = Student("qinyj",20,"man")

# 實例化課程類
python = Course("python","6個月","20K")
linux = Course("linux","6個月","15K")

# 使用組合將課程對象添加到老師屬性裏面
tea1.add_course(python)
tea1.add_course(linux)

# 對對象的屬性進行調用，循環遍歷出全部課程
tea1.tell_all_course()

封裝

什麼是封裝

封裝值得就是把一堆屬性（特徵和技能）封裝到一個對象中函數

存數據不是目的，取才是目的，建立出對象後能夠"."的方式獲取屬性code

爲何要封裝

封裝的目的是爲了方便存取，能夠經過對象「.」的方式獲取屬性對象

如何封裝

定義類：繼承

特徵：變量--》數據屬性接口

技能：函數--》方法屬性字符串

在類內部，定義一堆屬性（特徵和技能）

經過對象.屬性獲得/修改屬性值

訪問限制機制

什麼是訪問限制機制

在類內部定義，凡是以__開頭的數據屬性與方法屬性都會被python類隱藏起來，讓外部不能直接訪問這些屬性，好比：__name = "qinyj"

訪問限制機制的目的

一堆隱私屬性不能被外部輕易訪問的屬性能夠隱藏起來，不能被外部直接訪問

好處：對重要數據獲取的邏輯更加嚴謹，保證數據的安全

接口：隱私屬性能夠經過封裝一個接口，在接口內部作業務邏輯的處理，把數據返回給調用者。

注意：python中不會強制限制屬性的訪問，類內部__開頭的屬性，只是作了一種變形，若想直接訪問，調用變形後的名字便可。即：

class Foo:
    __name = "qinyj"    --》變形爲 _類名__屬性名

print(Foo._Foo__name)

如何使用訪問限制

上代碼

class Teacher:
    def __init__(self,name,age,sex):
        self.__name = name
        self.__age = age
        self.__sex = sex

    def get_info(self):
        # 驗證用戶邏輯
        user = input("請輸入用戶")
        pwd = input("請輸入密碼")
        if user == "qinyj" and pwd == "123":
            print(f"""
            姓名：{self.__name}
            年齡：{self.__age}
            性別：{self.__sex}
            """)

    def set_info(self,name,age,sex):

        # 驗證輸入邏輯
        if not isinstance(name,str):
            raise TypeError("名字必需要使用字符串")
        if not isinstance(age,int):
            raise TypeError("年齡必需要使用數字")
        if not isinstance(sex,str):
            raise TypeError("性別必需要使用字符串")

        self.__name = name
        self.__age = age
        self.__sex = sex

t = Teacher("qinyj",18,"man")
# t.get_info()

t.set_info("jack",18,"man")
t.get_info()

property

什麼是property

property是python內部的裝飾器，主要是給類內部的方法使用的。

將類內部的方法變成屬性引用

爲何要用property

在對象調用某個方法時，將類內部的方法當作一個普通的數據屬性調用

如何使用property

@property

上代碼

'''
計算人體的bim值
bim值 = 體重 / （身高 * 身高）
'''
class People:
    def __init__(self,name,weight,height):
        self.name = name
        self.weight = weight
        self.height = height

    @property       
    def bim(self):
        return self.weight / (self.height * self.height)

    # 瞭解
    @property
    def get_name(self):
        return self.name

    @get_name.setter
    def set_name(self,value):
        self.name = value

    @get_name.deleter
    def del_name(self):
        del self.name

p = People("qinyj",120,1.72)
print(p.bim)        # bim方法不用加括號 自動觸發執行bim方法

print(p.get_name)
p.set_name = "jack" # 自動觸發set_name方法
print(p.get_name)
del p.del_name      # 自動觸發del_name方法
print(p.get_name)

多態與多態性

什麼是多態

多態指的是同一種事物的多種形態

多態的目的

多態也稱之爲多態性，在程序中繼承就是多態的表現形式
父類：定義一套統一的標準
子類：遵循父類統一的標準

多態的最終目的：爲了讓多種不一樣類型的對象，在使用相同功能狀況下，調用同一名字的方法名，統一子類編寫的規範，爲了讓使用者更方便調用相同功能的方法

如何實現多態性

繼承父類
繼承抽象類
鴨子類型

注意，在python中不會強制要求子類必須遵循父類的一套標準，因此出現了抽象類

上代碼

# 多態性騷操做
class Cat:
    def talk(self):
        print("say miao")

# 定義一個普通函數，將對象放入函數參數調用類內部的方法
def func(animal):
    animal.talk()

cat1 = Cat()    # 實例化出一隻貓的對象
func(cat1)


# 多態：同一種事物的多種形態
# 多態性：一種調用方式，不一樣的執行結果

抽象類

什麼是抽象類

即abc模塊（abcstract_class）

使用抽象類的目的

強制子類必須遵循父類的一套標準

如何使用

import abc

上代碼

import abc

class Animal(metaclass=abc.ABCMeta):

    # 使用此裝飾器就意味着統一了方法，子類若繼承此類，方法名必須遵循此類的規範定義
    # 同時不能少方法
    # 能夠派生出本身的屬性和方法
    # 使用的時候在此類()內添加 metaclass=abc.ABCMeta
    # 想讓什麼方法遵循就在什麼方法上加 @abc.abstractmethod
    @abc.abstractmethod
    def eat(self):
        pass

    @abc.abstractmethod
    def drink(self):
        pass


class Pig(Animal):

    def eat(self):
        print("豬在吃飯")

    def drink(self):
        print("豬在喝水")

    def run(self):
        print("豬在跑步")

p = Pig()

鴨子類型

什麼是鴨子類型

在不知道當前對象時何物的時候，可是你長得像鴨子，那麼你就是鴨子類型

在python中，不推薦使用抽象類強制限制子類的定義，可是推薦類都遵循燕子類型

使用繼承：耦合性過高，程序可擴展性差

鴨子類型：耦合性低，程序可擴展性高

即不使用繼承，又按照某一種規範編寫程序

小結

1.組合:
        - 什麼是組合
                組合指的是一個對象中的屬性,是另外一個對象.
        - 爲何要使用組合
            組合目的和繼承同樣, 爲了減小代碼冗餘.
2.封裝:
        - 什麼是封裝?
                封裝指的是把一堆屬性(特徵與技能)封裝到一個對象中.
                存數據的目的是爲了取, 對象能夠"."的方式獲取屬性.
                
        - 爲何要封裝?
        封裝的目的爲了方便存取,能夠經過對象.屬性的方式獲取屬性.

3.訪問限制機制:
    - 什麼是訪問限制機制?
         在類內部定義, 凡是以__開頭的數據屬性與方法屬性,都會被python內部隱藏起來,讓外部不能"直接"訪問類內部的__開頭的屬性.

    - 訪問限制機制的目的?
        一堆隱私的屬性與不能被外部輕易訪問的屬性, 能夠隱藏起來,不被外部直接調用.   
   
4.property:
    - 什麼是property
        python內置的裝飾器, 主要是給類內部的方法使用.

    - 爲何要用property
        在對象調用某個方法時,將對象.方法()變成對象.方法(看起來想一個普通的數據屬性)
        obj.bmi() == obj.bmi

    - 如何使用property
        @property
        def 類內部的方法(self):

5.多態:
    - 什麼是多態?
        多態指的是同一種事物的多種形態.

    - 多態的目的:
        多態的目的是爲了, 讓多種不一樣類型的對象, 在使用相同功能的狀況下,調用同一個名字的方法名.
        父類: 定義一套統一的標準.
        子類: 遵循父類統一的標準.
        
    - 如何實現:
        - 繼承父類
        - 繼承抽象類
        - 鴨子類型

6.抽象類的目的:
        強制子類必須遵循父類的一套標準.

7.鴨子類型:
    - 什麼是鴨子類型?
        在不知道當前對象是何物的狀況下,可是你長得像鴨子,那麼你就是鴨子類型.
    - 繼承:
        耦合性過高,程序的可擴展性差

    - 鴨子類型:
        耦合度低,程序的可擴展性強