Python學習總結（四）：面向對象編程，轉換思惟

        從這節開始，咱們將要接觸編程思想——面向對象編程，很重要！！！學過C或者Java都知道，無論是面向過程仍是面向對象，想要完全掌握，必須理解這種程序設計思想，這樣才能熟練的編程，而不是盲目的死記硬背，重要的是編程思想，其餘的都是思想演變而來，正所謂：知其然知其因此然。下面來講畫下重點：

     （1）類和實例

        類（Class）是抽象出來的模板，實例（Instance）是根據類建立出來的具體對象。打個比方：汽車是類，而奧迪就是實例，是汽車的一個具體對象，它包含汽車的全部特徵，不一樣的汽車只是數據參數不一樣而已。

# 類
class Student(object):
    def __init__(self, name, score):
        self.__name = name
        self.__score = score
        print('the isinstance %s:%s' % (self.__name, self.__score))
    
    def print_score(self):
        print('%s：%s' % (self.__name,  self.__score))

if __name__ == '__main__':
    A = Student('Ada', 89)  # 對象A
    B = Student('Bob', 56)  # 對象B
    A.print_score()

輸出：
the isinstance Ada:89
the isinstance Bob:56
Ada：89

        上面是類的基本定義格式，object是繼承的父類，如無特定繼承的類，則這是全部類最終都會繼承的類。__init__()是一個初始化方法，是個特殊的方法，第一個參數是self，實例化時沒必要傳對應參數，表示建立的實例自己，在方法中加入了一個打印，是爲了方便理解，print_score()是一個自定義的方法，根據輸出內容能夠看出：實例化的過程就是__init__()的一種隱式調用，將參數傳給了self。

     （2）三大特性：封裝、繼承、多態

• 封裝：直接在類的內部定義訪問數據的方法，經過對象直接或者self間接獲取被封裝的內容；
• 繼承：子繼承父的內容，被繼承的class稱爲基類、父類或超類；
• 多態：可對不一樣類的對象使用一樣的操做；

# 類-繼承和多態
class Animal(object):
    def run(self):
        print('Animal is running...')


class Cat(Animal):
    def run(self):
        print('Cat is running...')


class Dog(Animal):
    def run(self):
        print('Dog is running...')

    def eat(self):
        print('Dog is eating...')

if __name__ == '__main__':
    cat = Cat()
    cat.run()

         從代碼中能夠看出：Cat和Dog類都繼承了Animal類，一樣也就繼承了父類的方法run()，這裏Cat和Dog類中都從新構造了run()方法，若不從新構造則直接調用父類的run()，而在Dog類中新增了新的方法eat()，也能夠看出，子類在繼承父類的方法的同時，也能增長本身的一些方法。另外，python是一種多態語言，崇尚鴨子類型，關於它的概念這裏不作敘述，可自行百度

     （3）面向對象高級編程

        Python內置的@property裝飾器就是負責把一個方法變成屬性調用的，在咱們定義數據庫字段類的時候，每每須要對其中的類屬性作一些限制，通常用get和set方法來寫,那在python中，咱們該怎麼作可以少寫代碼，又能優雅的實現想要的限制，減小錯誤的發生呢，這時候就須要咱們的@property：

class Student(object):
    @property
    def score(self):
        return self._score

    @score.setter
    def score(self, value):
        if not isinstance(value, int):
            raise ValueError('score must be an integer!')
        if value < 0 or value > 100:
            raise ValueError('score must between 0~100!')
        self._score = value


if __name__ == '__main__':
    k = Student()
    k.score = 99
    print(k.score)

        上面的代碼，把get方法變爲屬性只須要加上@property裝飾器便可，此時@property自己又會建立另一個裝飾器@score.setter，負責把set方法變成給屬性賦值,這麼作完後，咱們調用起來既可控又方便。

        Python容許使用多重繼承，經過多重繼承，一個子類就能夠同時得到多個父類的全部功能，MixIn就是一種常見的設計。

class Person(object):
    pass

class Student(Person):
    pass

class Teacher(Person):
    pass

class SkillMixin(object):
    pass

class BasketballMixin(SkillMixin):
    def skill(self):
        return 'basketball'

class FootballMixin(SkillMixin):
    def skill(self):
        return 'football'

class BStudent(Student, BasketballMixin):
    pass

class FTeacher(Teacher, FootballMixin):
    pass

s = BStudent()
print(s.skill())

t = FTeacher()
print(t.skill())

         定製類、枚舉類、元類的使用，更加豐富了程序開發，這裏再也不詳述，有興趣的能夠百度查看具體的用法：

# 定製類、枚舉類、元類(metaclass)

from enum import Enum, unique


class Student(object):
    def __init__(self, name):
        self.name = name

    def __str__(self):
        return 'Student object (name：%s)' % self.name
    __repr__ = __str__


Month = Enum('Month', ('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 
             'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'))

# metaclass是類的模板，因此必須從`type`類型派生：


class ListMetaclass(type):
    def __new__(cls, name, bases, attrs):
        attrs['add'] = lambda self, value: self.append(value)
        return type.__new__(cls, name, bases, attrs)


class MyList(list, metaclass=ListMetaclass):
    pass


@unique
class Weekday(Enum):
    Sun = 0
    Mon = 1
    Tue = 2
    Wed = 3
    Thu = 4
    Fri = 5
    Sat = 6

if __name__ == '__main__':
    print(Student('Ada'))
    for name, member in Month.__members__.items():
        # value屬性則是自動賦給成員的int常量，默認從1開始計數
        print(name, '=>', member, ',', member.value) 
    L = MyList()
    L.add(1)
    print(L)

        寫的不是很全，但對於面向對象編程來講要掌握的基本也就這些了。