大話Python類語義

類
　　物以類聚，人以羣分，就是相同特徵的人和事物會自動彙集在一塊兒，核心驅動點就是具備相同特徵或相相似的特徵，咱們把具備相同特徵或類似特徵的事物放在一塊兒，被稱爲分類，把分類依據的特徵稱爲類屬性

　　計算機中分類的思想叫作面向對象，Python中把數據抽象成對象，經過對象或對象間的關係來描敘數據。

　　咱們把一些類似事物的共同特徵經過一個方式描敘出來，也就是說，你是按什麼標準對事物進行分類，類似點是什麼，計算機把對類似事物的特徵數據進行描敘稱爲類定義

計算機中類的三大特徵
　　1. 封裝 對數據的可見性進行約束，分爲公有public、私有private、非公有， 公有數據能夠直接經過屬性訪問語法 obj.attr 直接訪問，可是私有、非公有則經過方法進行訪問，訪問行爲其實就是SQL中的增刪改查，查稱爲讀，增刪改稱爲寫，在Python中類的數據稱爲數據屬性，類中定義的函數稱爲方法，方法是關聯對象的函數

class Person:
    """數據封裝實現"""
    def __init__(self, name, age, sex):
        """名字是公開的， 性別是非公有， 年齡是私有"""
        # 如今給實例插入數據
        # 公有數據
        self.name = name
        # 非公有使用一個下劃線
        self._sex = sex
        # 私有變量使用兩個下劃線
        self.__age = age

    def get_name(self):
        """經過方法讀取名稱"""
        return self.name

    def set_age(self, value):
        """對年齡進行修改"""
        self.__age == value

    def get_age(self):
        """經過方法獲取私有屬性年齡"""
        return self.__age


if __name__ == '__main__':
    # 類的實例話相似函數調用，也可使用關鍵字參數和位置參數
    p = Person("北門吹雪", 20, "male")
    # 經過 obj.name 屬性訪問語言訪問實例的屬性，這個飯方法只能訪問公有屬性
    print(p.name)

    # 經過方法修改年齡
    p.set_age(22)
    # 經過方法訪問私有屬性
    print(p.get_age())
    pass

　　2. 繼承 須要理清幾個概念，父類、子類、基類、派生類，父類就是基類，子類就是派生類。繼承是創建在類的基礎上，子類徹底繼承父類的全部屬性以及控制屬性訪問的方法。繼承要理清差別共相同點，對依據對事物進行分類的特徵要很是肯定才能寫計算機中的類，否則不是分類，分類的前提是公共特徵，繼承的前提是共性與差別，若是不理解共同特徵你就沒法分類，你不理解同一類的共性與差別你沒法寫出繼承，繼承強調的是公共特徵，包括屬性和方法

class Human(object):
    """定義人類， 每一個人類都有名字和國家， 都會說話"""
    def __init__(self, name, country):
        self.name = name
        self.country = country

    def say(self, language):
        """交流說話"""
        print(f"{self.name} 能說 {language}")


class Chinese(Human):
    """定義一箇中國人，繼承人類

     Human被稱爲這個類的基類或這個類的父類，Chinese被成爲Human的派生類"""

    def __init__(self, name, country, skin):
        """中國人和外國人最大的不一樣是膚色"""
        # 調用父類的構造函數
        super(Chinese, self).__init__(name, country)
        self.skin = skin


if __name__ == '__main__':
    c = Chinese("北門吹雪", 20, "yellow")
    print(c.skin)
    c.say("中文")
    pass

　　　3. 多態 同一個行爲具備不一樣表現形式或形態的能力，計算機中最接近多態的是接口interface，接口定義相同行爲，而後咱們對接口行爲的分類，就產生所謂的抽象基類，經過繼承機制，而後子類重寫方法從而實現多態，說白了就是同一個方法中有不一樣的實現，再說漏骨一點就是函數的名稱相同，函數的形參相同，函數的返回值相同，可是函數體內的語句邏輯不同，這個函數體不一樣被稱爲多態。多態是創建在繼承的基礎上而後對方法進行重寫，其實能重寫(又稱爲重載)的只有函數體，多態強調的是方法

class HumanInterface(object):
    """定義一我的類的抽象接口，用於實現多態, 多態強調的是方法

    定義了兩個接口，一個是吃 一個是說
    """
    def say(self, language):
        """說"""
        pass

    def eat(self, what):
        """吃"""
        pass


class Chinese(HumanInterface):
    """定義一箇中國人，繼承人類"""

    def __init__(self, name, country):
        """中國人和外國人最大的不一樣是膚色"""
        # 調用父類的構造函數
        self.name = name
        self.country = country

    def eat(self, what):
        """重載或重寫 父類中的方法，實現多態"""
        print(f"{self.name} 正在吃{what}ing")
        pass

    def say(self, language):
        print(f"{self.name} 能說 {language}")
        pass


class American(HumanInterface):
    """美國人"""
    def __init__(self, name, country):
        """中國人和外國人最大的不一樣是膚色"""
        # 調用父類的構造函數
        self.name = name
        self.country = country

    def eat(self, what):
        """重載或重寫 父類中的方法，實現多態"""
        print(f"{self.name}吃{what}再跳舞")
        pass

    def say(self, language):
        print(f"{self.name} 不只能說 {language}， 還會其餘國家語言")
        pass

if __name__ == '__main__':
    c = Chinese("北門吹雪", "中國")
    a = American("alex", "美國")
    c.eat("大米")
    a.eat("漢堡包")

    c.say("中文")
    a.say("英語")
    # 你會發現他們方法名相同，可是輸出不一樣，也就是形態不一樣

Python中類定義
類定義

class Name:
    pass

　　# 定義是可執行的語句，在被import語句導入或以main文件執行時，定義就會被執行
　　# 類定義的執行，首先會在當前做用域引入一個用於存儲類中屬性的命名空間。而後把這個類命名空間封裝成對象返回，並把這個類對象綁定到class關鍵字指定的名稱，這個名稱又被綁定到class關鍵子所在的命名空間
　　# Name -> 類對象 > 類命名空間
　　# 其實類定義中包含的通常是函數定義，函數定義的第一個參數其實時實例自己，經過實例自己就能夠訪問實例中的數據屬性和方法

類對象
　　# 支持兩種操做：屬性引用 和 實例化
　　# 屬性引用使用Python標準屬性引用語法 obj.name
　　# 實例化: 類的實例化，相似於函數調用，把括號裏的參數傳遞給類的__init__方法，經過__init__方法爲類的新實例初始化特定的屬性，這個init方法又被稱爲工廠函數， 其餘語言中的類經過new關鍵字建立。Python中經過函數調用傳參的形式實現類的實例化

class Person(object):
    """人類"""
    # 能說話
    can_say = True
    # 能吃
    can_eat = True
    # 能睡覺
    can_sleep = True

    def __init__(self, name, age, country):
        self.name = name
        self.__age = age
        self.country = country

    def show_country(self):
        """顯示國籍"""
        print(f"{self.name}的國籍是: {self.country}")


if __name__ == '__main__':
    # 屬性引用
    print(Person.can_eat)
    print(Person.can_sleep)
    print(Person.can_sleep)

    # 實例化
    c = Person("北門吹雪", 20, "中國")

實例對象
　　# 支持惟一的操做就是屬性引用， 其實和普通的變量引用同樣，只是多個歸屬前綴而已，經過方法對實例裏的變量進行修改，實際上在函數封裝過程的基礎上再把數據和函數綁定起來

class Person(object):
    """人類"""
    # 能說話
    can_say = True
    # 能吃
    can_eat = True
    # 能睡覺
    can_sleep = True

    def __init__(self, name, age, country):
        self.name = name
        self.__age = age
        self.country = country

    def show_country(self):
        """顯示國籍"""
        print(f"{self.name}的國籍是: {self.country}")

    def set_age(self, value):
        """修改年齡"""
        self.__age = value

    def get_age(self):
        """獲取年齡"""
        return self.__age


if __name__ == '__main__':
    # 實例化
    user = Person("北門吹雪", 20, "中國")
    # 屬性引用
    user_age = user.get_age()
    print(user_age)

    # 設置年齡
    user.set_age(22)
    print(user.get_age())

方法對象
　　# 方法是從屬某個對象的函數，類中的函數定義了類的實例所擁有的方法，也就是說對象的類型決定了對象支持的操做
　　# 方法對比函數，函數定義在模塊或函數中，方法定義在類定義中，方法的第一個參數固定時實例對象

類和實例變量
　　# 實例變量是每一個實例的惟一數據，而類變量是該類的全部實例共享的屬性和方法
　　# 相同屬性名稱出如今類和實例中，首先被找到的時實例屬性

class Person(object):
    """人類"""
    # 該類被實例化多少次
    object_count = 0

    # 默認全球通用語言是英語
    language = "En"

    def __init__(self, name, age, country, language):
        self.name = name
        self.__age = age
        self.country = country
        self.language = language

    def show_country(self):
        """顯示國籍"""
        print(f"{self.name}的國籍是: {self.country}")

    def set_age(self, value):
        """修改年齡"""
        self.__age = value

    def get_age(self):
        """獲取年齡"""
        return self.__age

    @classmethod
    def add_obj(cls):
        cls.object_count += 1


if __name__ == '__main__':
    # 實例化
    user = Person("北門吹雪", 20, "中國", "Cn")
    # 實例化一次則類變量增長一次
    Person.add_obj()

    user_two = Person("alex", 30, "美國", "En")
    Person.add_obj()

    # 打印被實例化幾回
    print(Person.object_count)

    # 類變量和屬性同名訪問，優先選擇實例
    print(user.language)