面向對象三大特性編寫面向對象程序,self究竟是誰

 

1、函數式編程和麪向對象的對比

 

　　面向過程：根據業務邏輯從上到下寫壘代碼；

 

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

 

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

 

　　面向過程編程最易被初學者接受，其每每用一長段代碼來實現指定功能，開發過程當中最多見的操做就是粘貼複製，即：將以前實現的代碼塊複製到現需功能處。

 

　　round 1 請開發一個消息提醒的功能（郵件/短信/微信）

 

  函數式

 

  面向對象

 

　　經過第一輪對比，咱們發現：

 

　　　　函數式的特色是：定義簡單，調用簡單；

 

　　　　面向對象的特色是：定義複雜，調用複雜，其好處是進行了歸類，將某些相似的函數寫在了一塊兒。

 

總結：一、函數式編程可能會比面向對象好；

 

         二、python中支持兩種編程方式；

 

         三、面向對象編程方式格式以下：

 

                定義：

 

                            class 類名:                        -- 定義了一個類          

 

                                   def 函數名(self):        -- 在類中編寫了一個"方法"

 

                                          pass

 

                調用：

 

                            x1 = 類名()                        -- 建立了一個對象/實例化一個對象

 

                            x1.函數名()                         -- 經過對象調用其中一個方法.

 

         四、面向對象編程示例：

 

    class Account:
        def login(self):
            user = input('請輸入用戶名:')
            pwd = input('請輸入密碼:')
            if user == 'alex' and pwd == 'sb':
                print('登陸成功')
            else:
                print('登陸失敗')

    obj = Account()
    obj.login()

 

　　round 2 打印：完成如下功能：

 

              老狗/20歲/男/上山去砍柴

 

              老狗/20歲/男/開車去東北

 

              老狗/20歲/男/喜歡大寶劍

 

  函數版本

 

  面向對象版本

 

總結：一、構造方法

 

　　# 示例一：
　　class Foo:

    　　def __init__(self,name):     # 構造方法,目的是進行數據初始化.
        　　self.name = name
        　　self.age = 18    # 也能夠指定值，不必定非要傳參

　　obj = Foo("alex")  
　　# 經過構造方法,能夠將數據進行打包,之後使用時,去其中獲取便可.

    # 示例二：
　　class Bar:
    　　pass 
　　obj = Bar()

 

　　  二、面向對象編程應用：

 

              2.1 將數據封裝到對象中，以供本身在方法中調用，以下示例：

 

　　class FileHandler:
    　　def __init__(self, file_path):
        　　self.file_path = file_path
        　　self.f = open(self.file_path, 'rb')

    　　def read_first(self):
        　　# self.f.read()
        　　# ...
       
    　　def read_last(self):
        　　# self.f.read()
        　　# ...
        
    　　def read_second(self):
        　　# self.f...
        　　# ...

　　obj = FileHandler('C:/xx/xx.log')
　　obj.read_first()
　　obj.read_last()
　　obj.read_second()
　　obj.f.close()

 

　　　　2.2 將數據封裝到對象中，以供其餘函數調用，以下示例：

 

　　def new_func(arg):
    　　arg.k1
    　　arg.k2
    　　arg.k6

　　class Foo:
    　　def __init__(self,k1,k2,k6):
        　　self.k1 = k1
        　　self.k2 = k2
        　　self.k6 = k6

　　obj = Foo(11,22,66)
　　new_func(obj)

 

　　注：Java和C#只支持面向對象編程，而python比較靈活既支持面向對象編程也支持函數式編程。

 

2、面向對象代碼如何編寫

 

       一、面向對象代碼語法規則，以下示例：

 

　　class Foo:

    　　def __init__(self, name):
        　　self.name = name

    　　def detail(self, msg):
        　　print(self.name, msg)

　　obj = Foo("alex")
　　obj.detail("hello world")

 

　　二、何時寫面向對象代碼？如何寫？

 

              2.1 反向：歸類 + 提取公共值；

 

              2.2 正向：在指定類中編寫和當前類相關的全部代碼 + 提取公共值；以下示例：

 

　　class Person:
    　　def __init__(self, na, gen, age, fig):
        　　self.name = na
        　　self.gender = gen
        　　self.age = age
        　　self.fight = fig

    　　def grassland(self):
        　　self.fight = self.fight - 10

    　　def practice(self):
        　　self.fight = self.fight + 90

    　　def incest(self):
        　　self.fight = self.fight - 666

　　cang = Person('蒼井井', '女', 18, 1000)  # 建立蒼井井角色
　　dong = Person('東尼木木', '男', 20, 1800)  # 建立東尼木木角色
　　bo = Person('波多多', '女', 19, 2500)  # 建立波多多角色

　　dong.grassland()

 

2、面向對象三大特徵：封裝、繼承、多態

 

       一、封裝

 

              1.1 將相關方法封裝到一個類中，以下示例：

 

　　class Message:
    　　def email(self):pass
    　　def msg(self):pass
    　　def wechat(self):pass

 

　　　　1.2 將數據封裝到一個對象中，以下示例：

 

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

　　obj = Person('alex', 18, '男')

 

　　二、繼承（原則：先在本身類中找，沒有就去父類中找），以下示例：

 

　　class SuperBase:
    　　def f3(self):
        　　print('f3')

　　class Base(SuperBase):  # 父類, 也稱基類
    　　def f2(self):
        　　print('f2')

　　class Foo(Base):  # 子類,也稱派生類
    　　def f1(self):
        　　print('f1')

　　obj = Foo()
　　obj.f1()
　　obj.f2()
　　obj.f3()
　　# 父類和子類都是相對的，此例中Base是SupperBase的子類，是Foo的父類

 

總結：1）繼承編寫規則，以下：

 

　　　　         class Foo(父類名):

 

　　　　　　　　pass

 

　　   2）支持多繼承，即一個子類能夠有多個父類（先找左邊父類，再找右邊）；

 

          3）爲何要有繼承和多繼承？提升代碼的可重用性；

 

繼承的相關練習題：

 

　　class Base1:
    　　def f1(self):
        　　print('base1.f1')
    　　def f2(self):
        　　print('base1.f2')

　　class Base2:
    　　def f1(self):
        　　print('base2.f1')

    　　def f2(self):
        　　print('base2.f2')

    　　def f3(self):
        　　print('base2.f3')
        　　self.f1()

　　class Foo(Base1,Base2):
    　　def f0(self):
        　　print('foo.f0')
        　　self.f3()
　　obj = Foo()   # 實例化Foo類的一個obj對象
　　obj.f0()
　　# 結果爲：
　　# foo.f0
　　# base2.f3
　　# base1.f1

 

總結：1）多繼承先找左邊；

 

        2）明確self究竟是誰，self是哪一個類的對象，那麼就從該類開始找(本身沒有就找父類)；

 

　　三、多態

 

              鴨子模型，只要能夠嘎嘎叫就是鴨子。因爲Python函數傳參時，無需指定類型。

 

    def func(arg): # arg能夠是多種類型,只要其中有send方法便可.
        arg.send()

 

              多態就是多種形態或多種狀態，因爲python原生支持多態，因此沒有特殊性，以下是體現python原生多態的示例：

 

  python原生多態示例