一、面向對象簡介

　　Python設計之初，就是一門面向對象的語言，在Python中一切皆對象，而且在Python中創建一個對象也很簡單，今天我們就來學習一下Python的面向對象的知識。

二、兩種編程方式

在C#、Java中，只能使用面向對象編程，在Ruby、Python中可以使用函數編程以及面向對象進行編程。

函數式編程

def fetch(backend):
    pass
def add_record(backend,record):
    pass
fetch("www.oldboy.org")
add_record("www.oldboy.org",xxxxx)

面向對象編程

class Oldboy:#類，用來封裝幾個函數

    def fetch(self,backend):#self是python內部傳的，用戶我們傳值時
        pass        #傳的第一個參數直接給backend
     
    def add_record(self,backend,record):
        pass

obj = Oldboy()
obj.fetch()

　　函數在類的外面就叫做函數，在類的裏面就叫做方法，面向對象的情況下想要執行函數時需要根據這個類創建一個對象,通過對象訪問函數。

　　一般函數式編程的函數為模塊的成員，而面向對象編程，類是模塊的成員，函數是類的成員。

　　面向對象的程序設計的核心是對象（上帝式思維），要理解對象為何物，必須把自己當成上帝，上帝眼裏世間存在的萬物皆為對象，不存在的也可以創造出來。對象是特征和技能的結合，其中特征和技能分別對應對象的數據屬性和方法屬性。
優點是：解決了程序的擴展性。對某一個對象單獨修改，會立刻反映到整個體系中，如對遊戲中一個人物參數的特征和技能修改都很容易。
缺點：可控性差，無法向面向過程的程序設計流水線式的可以很精準的預測問題的處理流程與結果，面向對象的程序一旦開始就由對象之間的交互解決問題，即便是上帝也無法預測最終結果。於是我們經常看到一個遊戲人某一參數的修改極有可能導致陰霸的技能出現，一刀砍死3個人，這個遊戲就失去平衡。

三、面向對象深度解析

1.關於self的解析

2.封裝

class Oldboy:

　　def fetch(self):
        print(self.backend)#因為參數self傳的值為對象obj1，所以可以用self代替obj1
 
　　def add_record(self,record):
    　　pass
obj1 = Oldboy()
obj1.backend = "alexsel"#這個參數，和obj1一起被存入內存
#封裝的非主流的方式
obj1.fetch()#由於backend和obj1一起存入內存，所以不用再吧backend傳過去，直接
            #在函數裏用self.backend使用

obj2 = Oldboy()
obj2.backend = "ALEXSEL"
obj2.fetch()

這裏也顯示出了self的作用，self可以標識對象，由於給兩個對象傳入的參數輸不同，調用類的方法的時候，輸出的內容就不同，這就是self的功能。

應用：
當有幾個函數要傳的參數相同時，封裝比較簡便

3.構造方法__init__

當使用類創建對象的時候（obj = Foo()），默認執行__init__方法

class Foo:
    def __init__(self, bk):  ##這個self為創建的對象，創建對象時默認執行__init__
        print("init")  ##所以可把需要多次傳的參數在這裏創建，代替上面那個
        self.name = "alex"  ##非主流的方法
        self.favor = bk
        print(self.favor)


# 創建對象，實例，並將“xxx”封裝到對象裏
obj1 = Foo("xxx")  # 創建對象時，類裏就會執行__init__方法（函數），這個xxx就傳入到__init__的bk參數中
obj2 = Foo("sss")


輸出結果：
init
xxx
init
sss

使用場景：當同一類型的的方法具有相同的參數時，直接封裝到對象即可。
使用場景：把類當成模板，創建多個對象（對象內封裝的數據可以不一樣）。

四、上手練習

針對剛才了解的知識，我們進行一個簡單的練習，輸出同樣的結果下，不同的兩種寫法，熟悉類中方法和屬性的使用。

寫法一：

class activity:
    def __init__(self,name,age,gender):
        self.FlyAnAeroplane = "{:s},{:s},{:s},去開飛機".format(name,age,gender)
        self.GoToSchool = "{:s},{:s},{:s},去學校".format(name,age,gender)
        self.Farm = "{:s},{:s},{:s},去種田".format(name,age,gender)
    def FlyAnAeroplane_one(self):
        print(self.FlyAnAeroplane)
    def GoToSchool_one(self):
        print(self.GoToSchool)
    def Farm_one(self):
        print(self.Farm)


obj = activity("alexsel","10","男")
obj.FlyAnAeroplane_one()
obj.GoToSchool_one()
obj.Farm_one()
obj2 = activity("eric","60","男")
obj2.FlyAnAeroplane_one()
obj2.GoToSchool_one()
obj2.Farm_one()


輸出結果：
alexsel,10,男,去開飛機
alexsel,10,男,去學校
alexsel,10,男,去種田
eric,60,男,去開飛機
eric,60,男,去學校
eric,60,男,去種田

寫法二：

class Foo:
    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender

    def kaifeiji(self):
        print("%s,%s歲,%s,去開飛機" % (self.name, self.age, self.gender))

    def quxuexiao(self):
        print("%s,%s歲,%s,去學校" % (self.name, self.age, self.gender))

    def quzhongtian(self):
        print("%s,%s歲,%s,去種田" % (self.name, self.age, self.gender))


alexsel = Foo(‘alexsel‘, 10, ‘男‘)
alexsel.kaifeiji()
alexsel.quxuexiao()
alexsel.quzhongtian()

eric = Foo(‘eric‘, 90, ‘男‘)
eric.kaifeiji()
eric.quxuexiao()
eric.quzhongtian()


輸出結果：
alexsel,10歲,男,去開飛機
alexsel,10歲,男,去學校
alexsel,10歲,男,去種田
eric,90歲,男,去開飛機
eric,90歲,男,去學校
eric,90歲,男,去種田

五、項目練習

在寫這個項目之前，我們首先學習一下pickel模塊。

pickle可以將任何數據類型序列化，pickle只能在python中使用，pickle模塊用於將內存中的python對象序列化成字節流，並可以寫入任何類似文件對象中；它也可以根據序列化的字節流進行反序列化，將字節流還原為內存中的對象。

pickle使用dump方法將內存對象序列化：

import pickle

li = list(range(1,3))
dbfile = open(‘pickle_list‘, ‘wb‘)    #必須以2進制打開文件，否則pickle無法將對象序列化只文件
pickle.dump(li, dbfile)
dbfile.close()

以上代碼即將list對象li序列化至文件“pickle_list"中，下次再次運行時，可以通過pickle的load方法恢復list對象：

import pickle

dbfile = open(‘pickle_list‘, ‘rb‘)
li = pickle.load(dbfile)
dbfile.close()

開始項目練習

import pickle

class Person:
    def __init__(self,name,age,weight):
        self.Name = name
        self.Age = age
        self.Weight = weight

    def eat(self):
        self.Weight = self.Weight + 2   #每次吃飯，體重加1

    def fitness(self):
        self.Weight = self.Weight - 1   #每次健身，體重減1



xiaoming = pickle.load(open("fitnessgame.obb","rb"))
if xiaoming:            #判斷是否有小明這個對象，沒有創建小明對象
    print(xiaoming.Weight)
    xiaoming.fitness()
    xiaoming.fitness()
    xiaoming.fitness()
    print(xiaoming.Weight)
    pickle.dump(xiaoming,open("fitnessgame.obb","wb"))
else:
    xiaoming  = Person("小明","10歲",200)
    xiaoming.fitness()
    xiaoming.eat()
    xiaoming.eat()
    xiaoming.eat()
    xiaoming.eat()
    print(xiaoming.Weight)
    pickle.dump(xiaoming,open("fitnessgame.obb","wb"))

明天我們接著講面向對象，明天繼續講面向對象中的繼承。

Python學習：14.Python面向對象（一）