python oop培訓文檔裏面的正宗oop、多個函數間反覆return傳參、多個文件無限複製粘貼扣字、無效廢物滑稽類4種方式的例子。（2）

時間 2019-11-06

標籤 python oop 培訓文檔裏面正宗多個函數反覆 return 文件無限複製粘貼無效廢物滑稽方式例子欄目 Python 简体版

原文原文鏈接

python編程範式培訓文檔，主要是結合4種代碼和，對oop和麪向過程編程區別和oop轉化公式培訓。 html

接這一篇。python

把文檔裏面說的幾種範式發出來。程序員

4種編程範式實現一我的吃喝拉撒長身體的代碼。語法很簡單，思想模擬了全部程序員寫代碼時候的代碼規劃設計想法。算法

0.我不反對複製粘貼的寫法，能夠百度搜索複製粘貼網上現有的，但反對總是寫新代碼就把本身的舊代碼整個複製幾億次，而後在代碼文件裏面扣字造成新代碼，我不肯意接受這樣的項目。若是寫代碼是使用這樣的方式，那就不能好高騖遠裝逼搞leetcode算法，實際上咱們項目代碼裏面我看也沒有任何算法，反而是不會設計模式面向對象會對項目形成不少嚴重不利影響和拖累任務進度。編程

一、開門見山，發正宗oop設計模式

# coding=utf8
"""
一、實現人的功能。oop寫法，使用類/對象 加 方法。
二、重要是要理解面向對象裏面的封裝，封裝是最重要的特色，寫出沒有體現出封裝特色的類就是無效廢物類就是面向過程的類。
三、這種寫法清晰明瞭，類/對象 加 方法 的寫法 幾乎和模塊文件加全局變量加函數的寫法思路是如出一轍的，只是把命名空間下沉了一級，就能毫無曲折的實現了多實例的要求。繼不繼承都是次要的，最最最重要是看封裝，不要把注意力重點放在這裏面的繼承了，只是順便演示一個繼承是如何減小代碼實現不一樣點而已。繼承不是面向對象必須的，封裝纔是。
四、使用oop時候，在實現時候更爲簡單，幾乎行雲流水，不須要考慮頻繁的考慮傳參和return
出狀態（變量）給外部。在調用時候也更具有一致性，在調用處只須要一個實例化出一個對象，類的外部只須要一個變量表明此實例便可。不然使用面向過程還須要模擬多實例，在調用處最少須要保存 名字 體重 身高三個變量，而且每次調用函數都須要傳入和保存return出來的值，這樣調用起來反覆傳參和return修改外部變量，調用起來複雜和看起來亂七八糟的調用形式不具有一致性。
"""

"""
得出轉化公式的規律：
1、針對全局變量加函數無限複製粘貼扣字的寫法，
1） 模塊級降級爲類名
2） 全局變量改爲實例屬性
3） 函數改成方法

2、針對頻繁return和大量重複傳參的寫法
一、轉化公式1
0）在腦殼中重構，把寫法形式改爲全局變量加函數的寫法，此時不用擔憂全局變量是惟一的，不用大量重複傳參和return，全部須要傳參和return的都想象成使用全局變量和操做全局變量。
1） 模塊級降級爲類名
2） 全局變量改爲實例屬性
3） 函數改成方法
後面三個步驟是同樣的。全局變量變爲實例屬性後，每次實例化後每一個對象的實例屬性都是互不干擾的。每一個對象能夠看做爲一個模塊級寫法的 模塊文件的無限深拷貝。

二、轉化公式2
1） 新增一個類
2）把重複傳參和return的形參，全都去掉，改爲實例屬性
3） 函數改成方法。

對任何面向過程寫法，使用轉化公式，必定就能夠修改爲oop，然來的代碼思惟不須要作任何改變，只要按這個公式就能夠改造。（前提是知足須要使用oop的兩個條件，才須要改造）
對新寫的代碼，也能夠按然來的想法寫，說的是在腦殼裏面那麼寫（否則真那麼寫，再修改，浪費花時間），而後按照此公式轉化後寫在ide裏面。
"""

"""
最重要是理解：  命名空間  全局變量  實例屬性  多實例需求  函數和方法 的關係，搞清楚了，寫oop十分之簡單，不會形成極端面向過程的曲折寫法。
在word文檔中會寫更詳細的解釋。
"""

"""
常見問題解答
一、是否是全部代碼都要用oop？
答：不是，按照上面的方式判斷用那種方式好，目的是要簡單代碼少就能夠，便於維護擴展就好。
二、函數和類上面區別？
沒有區別，就像問人和走路有什麼區別，豬和吃飯有什麼區別，問得牛頭不對馬嘴的僞問題，函數和方法才能夠比較。類（對象）和模塊纔有可比性，必需要搞清楚緣由，否則腦殼中有這個比較的想法那就不可能寫得了oop。
面向過程是 文件模塊名.eat(狗的名字，shit)
oop是  狗.eat(shit)
"""


"""
編程範式
1.1 方式一，平鋪指令。 從上往下疊加指令，適合簡單的獨立腳本。不須要和沒機會被別的模塊導入。
1.2 方式二，面向過程函數式編程。適合實現獨立的轉化功能，基本原理是要實現轉化 y = f(x)，適合函數無依賴狀態（不須要在多個函數中頻繁的傳入和return相贊成義的參數）。
1.3 方式三，oop編程.適合多個函數間須要使用同一個變量，而且須要多實例（若是使在使用面向過程時候須要使用函數頻繁的return各類狀態/變量由類外使用多個參數來保存這些值和傳入這些值，那就是也判斷爲須要多實例），必須同時知足這兩個條件，才使用oop好，不然不須要oop。（但單例模式爲了控制靈活的初始化傳參，通常也用類的方式）
1.4 網上說的簡單用面向過程，複雜的用面向對象，這簡直是錯誤的廢話。簡單和複雜界定不了，即便是一個簡單的查詢價格，通過大量平臺的重寫對比，oop都能比面向過程減小70%行以上的代碼，因此用網上這句話來判斷用什麼方式來寫代碼是錯誤的。只要嚴格使用上面描述的判斷方式，就能很容易知道在什麼場景何時使用哪一種方式好了，不須要oop嗨寫成類就是沒理解好oop能更好地解決什麼。
1.5 要多使用oop，但不要寫成純靜態或者半靜態的無效廢物類。 面向過程必定能夠搞定一切，可是實現麻煩、調用更麻煩，那就不適合面向過程了。好比猴子補丁能夠搞定繼承，閉包能夠搞定封裝，可是沒什麼好處，實現麻煩。先要轉oop，只有放棄極端面向過程，不對面向過程過度的偏執和喜歡，才能開始學習更多設計模式。
"""


class Person:

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

    def show_weight(self):
        print(f'{self.name} 的體重是： {self.weight} 千克')

    def show_height(self):
        print(f'{self.name} 的身高是： {self.height} 釐米')

    def grow_weight(self, growing_weight):   # 增長的體重是可變的外界傳來的，須要做爲方法的參數傳進來，不可避免。
        print(f'{self.name} 的體重增長 {growing_weight} 千克')
        self.weight += growing_weight

    def grow_height(self, growing_height):
        print(f'{self.name} 的身高增長 {growing_height} 釐米')
        self.height += growing_height

    def pee(self):
        """
        舉個影響屬性的例子，上衛生間小便,會致使體重減小。
        :return:
        """
        self._reduce_weight_because_of_pee()

    def _reduce_weight_because_of_pee(self):
        self.weight = self.weight - 0.1


class Boy(Person):
    # REMIND 須要實現不一樣之處
    def pee(self):
        print(f'{self.name} 站着小便')
        super(Boy, self).pee()


class Girl(Person):
    # REMIND 須要實現不一樣之處
    def pee(self):
        print(f'{self.name} 蹲着小便')
        super(Girl, self).pee()


if __name__ == "__main__":
    # 在調用處只須要實例化一個對象，不須要學極端面向過程編程，保存不少個變量。
    xiaomin = Boy('小明', 120, 30)
    xiaowang = Boy('小王', 130, 32)
    xiaomin.grow_height(5)
    xiaomin.grow_weight(1)
    xiaomin.show_height()
    xiaomin.show_weight()
    xiaomin.pee()
    xiaomin.show_weight()
    # REMIND 這裏實例化兩個男孩，緣由是模擬須要多實例，模擬每一個對象的屬性是互不干擾的，小明增加體重不會影響到小王的體重。
    # REMIND 若是是使用全局變量 + 函數 或者類名加靜態屬性（類屬性），則會發生互相干擾，正由於這樣行不通再加上不使用oop面向對象，就會形成須要寫成在一組函數中頻繁return和傳參，實現上覆雜曲折，也很差讀懂。這種寫法現象在可預訂平臺的酒店價格解析裏面體現得十分之嚴重，因爲多個函數中頻繁傳參和return，有的參數命名是同一個東西，可是在各個函數中形參的名字取得又不同，不只在維護代碼時候難以搞懂，在實現的時候也是麻煩曲折不少。
    print('— ' * 30)
    xiaowang.show_height()
    xiaowang.show_weight()
    xiaowang.grow_height(6)
    xiaowang.grow_weight(2)
    xiaowang.show_height()
    xiaowang.show_weight()
    xiaowang.pee()
    xiaowang.show_weight()

    print('* ' * 30)
    xiaohong = Boy('小紅', 110, 25)
    xiaohong.grow_height(3)
    xiaohong.grow_weight(0.5)
    xiaohong.show_height()
    xiaohong.show_weight()
    xiaohong.pee()
    xiaohong.show_weight()

View Code

如下爲模擬low寫法閉包

二、多個函數間反覆頻繁return 傳參.即便實現男女不復制文件扣字來實現，那也要多加一個性別參數，若是撒尿被不少函數調用了，那不少函數都要入參加性別。ide

實現男的函數式編程

# -*- coding: utf-8 -*-
# @Author  : ydf

"""
演示使用極端面向過程來寫，因爲沒有封裝，沒有成員變量和全局變量，因此形成須要在多個函數中頻繁重複傳參和return
不管是實現仍是調用都更爲複雜。
"""


def show_weight(name, weight):
    print(f'{name} 的體重是： {weight} 千克')


def show_height(xingmin, height):  # xingmin: xingmin也是表明姓名，故意弄成形參不是name，面向過程就會有這種搞不清楚一個參數在不一樣函數中是否是同一個意義的大缺點。
    print(f'{xingmin} 的身高是： {height} 釐米')


def grow_weight(name, weight, growing_weight):
    weight += growing_weight
    print(f'{name} 的體重增長 {growing_weight} 千克')
    return weight  # 必須把結果return到外部保存


def grow_height(xinmin, height, growing_height):
    print(f'{xinmin} 的身高增長 {growing_height} 釐米')
    height += growing_height
    return height  # 必須把結果return到外部保存



def pee(name, weight):
    """
    由於小便會致使體重發生變化，必須把原來的體重傳進來。
    """
    print(f'{name} 站着小便')
    return _reduce_weight_because_of_pee(weight)  # 必須把結果return到外部保存


def _reduce_weight_because_of_pee(tizhong):
    tizhong = tizhong - 0.1  # 體重的別名tizhong和weight是同樣的，面向過程不使用實例屬性，在不少函數中大量重複傳參，形參就會可能不一致，致使看不懂代碼。
    return tizhong


if __name__ == '__main__':
    # 極端面向過程不只須要致使頻繁傳參和return，還要在調用時候設置不少個外部變量來保存狀態，若是屬性/狀態越多，須要外部保存的變量就越多。
    xiaomin_name = '小明'
    xioamin_height = 120
    xiaomin_weight = 30
    show_height(xiaomin_name, xioamin_height)
    show_weight(xiaomin_name, xiaomin_weight)
    xioamin_height = grow_height(xiaomin_name, xioamin_height, 5)
    xiaomin_weight = grow_weight(xiaomin_name, xiaomin_weight, 1)  # 體重發生了變化，必須把結果return出來保存
    show_height(xiaomin_name, xioamin_height)
    show_weight(xiaomin_name, xiaomin_weight)  # 展現體重，須要把變化後的體重傳進來
    xiaomin_weight = pee(xiaomin_name, xiaomin_weight)  # 連上個廁所都須要把體重參數傳進來，這樣大量傳參簡直不要太low
    show_weight(xiaomin_name, xiaomin_weight)

    print('& ' * 100)

    # 頻繁重複傳參和retutn主要是爲了多實例，否則全局變量加函數就搞定了。演示面向過程實現多實例的需求，因爲各類變量都是在調用地方傳入和保存，因此這種面向過程的地方能夠實現多實例，爲了實現多實例致使重複傳參和頻繁return，致使代碼不管在自己實現寫法仍是調用上，都極爲複雜。例如演示這種方式實現多實例小王

    # xiaowang_name = '小王'
    # xioamin_height = 130
    # xiaowang_weight = 35
    # show_height(xiaowang_name, xioamin_height)
    # show_weight(xiaowang_name, xiaowang_weight)
    # xioamin_height = grow_height(xiaowang_name, xioamin_height, 6)
    # xiaowang_weight = grow_weight(xiaowang_name, xiaowang_weight, 2)
    # show_height(xiaowang_name, xioamin_height)
    # show_weight(xiaowang_name, xiaowang_weight)
    # xiaowang_weight = pee(xiaowang_name, xiaowang_weight)
    # show_weight(xiaowang_name, xiaowang_weight)

    # 這樣的寫法，若是要實現小紅，那就十分麻煩了，由於小紅的pee函數確定不能這麼運行。若是直接在此處修改函數,那代碼就不能兼容小明 小王。致使又要全盤複製文件，庵後扣字，來重寫pee函數。

View Code

實現女的函數

# -*- coding: utf-8 -*-
# @Author  : ydf

"""
複製粘貼扣字實現不一樣之處
演示使用極端面向過程來寫，因爲沒有封裝，沒有成員變量和全局變量，因此形成須要頻繁傳參和return.對於實現不一樣點全盤容易陷入複製文件全流程。
女得有的函數不一樣。

"""


def show_weight(name, weight):
    print(f'{name} 的體重是： {weight} 千克')


def show_height(xingmin, height):  # xingmin: xingmin也是表明姓名，故意弄成形參不是name，面向過程就會有這種搞不清楚一個參數在不一樣函數中是否是同一個意義的大缺點。
    print(f'{xingmin} 的身高是： {height} 釐米')


def grow_weight(name, weight, growing_weight):
    weight += growing_weight
    print(f'{name} 的體重增長 {growing_weight} 千克')
    return weight  # 必須把結果return到外部保存


def grow_height(xinmin, height, growing_height):
    print(f'{xinmin} 的身高增長 {growing_height} 釐米')
    height += growing_height
    return height  # 必須把結果return到外部保存


def pee(name, weight):
    """
    由於小便會致使體重發生變化，必須把原來的體重傳進來。
    """
    print(f'{name} 蹲着小便')
    return _reduce_weight_because_of_pee(weight)  # 必須把結果return到外部保存


def _reduce_weight_because_of_pee(tizhong):
    tizhong = tizhong - 0.001  # 體重的別名tizhong和weight是同樣的，面向過程不使用實例屬性，在不少函數中大量重複傳參，形參就會可能不一致，致使看不懂代碼。
    return tizhong


if __name__ == '__main__':
    xiaohong_name = '小紅'
    xiaohong_height = 110
    xiaohong_weight = 25
    show_height(xiaohong_name, xiaohong_height)
    show_weight(xiaohong_name, xiaohong_weight)
    xiaohong_height = grow_height(xiaohong_name, xiaohong_height, 5)
    xiaohong_weight = grow_weight(xiaohong_name, xiaohong_weight, 1)  # 體重發生了變化，必須把結果return出來保存
    show_height(xiaohong_name, xiaohong_height)
    show_weight(xiaohong_name, xiaohong_weight)  # 展現體重，須要把變化後的體重傳進來
    xiaohong_weight = pee(xiaohong_name, xiaohong_weight)  # 連上個廁所都須要把體重參數傳進來，而後還要保存新結果，這樣大量傳參簡直不要太low
    show_weight(xiaohong_name, xiaohong_weight)

View Code

三、全局變量加函數的寫法，比上面反覆return傳參容易理解和寫，但因爲模塊是單例，贊成解釋器上下文中要實現多我的，須要不由自主的無限複製粘貼扣字。

xiaohong.py

# -*- coding: utf-8 -*-
# @Author  : ydf
"""
模擬無限複製粘貼扣字low模式
全局變量加函數寫法，能夠作到少傳參 少return，看起來也很簡潔，實現簡單清晰。
但模塊是惟一的，全局變量在模塊也是惟一的，沒法進行多實例方面的需求，通常都不多這樣寫，但有不用oop，因此會形成通常喜歡使用頻繁return和大量重複傳參的寫法。
"""

name = '小紅'
height = 100
weight = 28


def show_weight():
    print(f'{name} 的體重是： {weight} 千克')


def show_height():
    print(f'{name} 的身高是： {height} 釐米')


def grow_weight(growing_weight):
    global weight
    print(f'{name} 的體重增長 {growing_weight} 千克')
    weight += growing_weight


def grow_height(growing_height):
    global height
    print(f'{name} 的身高增長 {growing_height} 釐米')
    height += growing_height


def pee():
    """
    舉個影響屬性的例子，上衛生間小便,會致使體重減小。
    :return:
    """
    # REMIND 女得不一樣，須要複製粘貼扣字整個流程。
    print(f'{name} 蹲着小便')
    _reduce_weight_because_of_pee()


def _reduce_weight_because_of_pee():
    global weight
    weight = weight - 0.1


if __name__ == '__main__':
    show_height()
    show_weight()
    grow_height(5)
    grow_weight(1)
    show_height()
    show_weight()
    pee()
    show_weight()

View Code

xiaoming.py

# -*- coding: utf-8 -*-
# @Author  : ydf

"""
模擬無限複製粘貼扣字low模式
全局變量加函數寫法，能夠作到少傳參 少return，看起來也很簡潔，實現簡單清晰。
但模塊是惟一的，全局變量在模塊也是惟一的，沒法進行多實例方面的需求，通常都不多這樣寫，但有不用oop，因此會形成通常喜歡使用頻繁return和大量重複傳參的寫法。

"""

name = '小明'
height = 130
weight = 30


def show_weight():
    print(f'{name} 的體重是： {weight} 千克')


def show_height():
    print(f'{name} 的身高是： {height} 釐米')


def grow_weight(growing_weight):
    global weight
    print(f'{name} 的體重增長 {growing_weight} 千克')
    weight += growing_weight


def grow_height(growing_height):
    global height
    print(f'{name} 的身高增長 {growing_height} 釐米')
    height += growing_height


def pee():
    """
    舉個影響屬性的例子，上衛生間小便,會致使體重減小。
    :return:
    """
    print(f'{name} 站着小便')
    _reduce_weight_because_of_pee()


def _reduce_weight_because_of_pee():
    global weight
    weight = weight - 0.1


if __name__ == '__main__':
    show_height()
    show_weight()
    grow_height(5)
    grow_weight(1)
    show_height()
    show_weight()
    pee()
    show_weight()

    # REMIND 因爲是使用的全局變量，只能完成一個單例的狀況，只能完成小明這一我的，沒法同時完成小明和小王，若是須要使用小王，必須複製粘貼扣字。

View Code

xiaowang.py

# -*- coding: utf-8 -*-
# @Author  : ydf
"""
模擬無限複製粘貼扣字low模式
全局變量加函數寫法，能夠作到少傳參 少return，看起來也很簡潔，實現簡單清晰。
但模塊是惟一的，全局變量在模塊也是惟一的，沒法進行多實例方面的需求，通常都不多這樣寫，但有不用oop，因此會形成通常喜歡使用頻繁return和大量重複傳參的寫法。

"""

name = '小王'
height = 140
weight = 32


def show_weight():
    print(f'{name} 的體重是： {weight} 千克')


def show_height():
    print(f'{name} 的身高是： {height} 釐米')


def grow_weight(growing_weight):
    global weight
    print(f'{name} 的體重增長 {growing_weight} 千克')
    weight += growing_weight


def grow_height(growing_height):
    global height
    print(f'{name} 的身高增長 {growing_height} 釐米')
    height += growing_height


def pee():
    """
    舉個影響屬性的例子，上衛生間小便,會致使體重減小。
    :return:
    """
    print(f'{name} 站着小便')
    _reduce_weight_because_of_pee()


def _reduce_weight_because_of_pee():
    global weight
    weight = weight - 0.1


if __name__ == '__main__':
    show_height()
    show_weight()
    grow_height(5)
    grow_weight(1)
    show_height()
    show_weight()
    pee()
    show_weight()

    # REMIND 因爲是使用的全局變量，只能完成一個單例的狀況，只能完成小明這一我的，沒法同時完成小明和小王，若是須要使用小王，必須複製粘貼扣字。

View Code

四、無效廢物裝逼類。有些人發現第三方包的大神那麼流弊，裏面那麼多類，以爲類確定狠流弊，沒有理解到封裝這一最基本要義的內涵，致使寫出來的類是廢物滑稽類，沒做用。

這三個類如此輕易的使用靜態方法類方法實例方法自由轉化代碼能正常運行，這種九成九是廢物類。仍然使用反覆return 頻繁傳參的方式來實現，沒有封裝的特色，因此是廢物類。不能心太急着寫類，致使寫出這樣的滑稽類，或者即便沒例子裏面的這麼極端，但也存在oo不完全的狀況。再次印證了，我從沒說寫類就流弊了，是要寫有用的類才能夠。

# -*- coding: utf-8 -*-
# @Author  : ydf
"""
面向過程寫得無效廢物類，沒有封裝，大量rentun，這樣寫的類沒有任何做用。
和person_f文件的寫法是同樣的。
"""


class Person:
    def show_weight(self, name, weight):
        print(f'{name} 的體重是： {weight} 千克')

    def show_height(self, xingmin, height):  # xingmin: xingmin也是表明姓名，故意弄成形參不是name，面向過程就會有這種搞不清楚一個參數在不一樣函數中是否是同一個意義的大缺點。
        print(f'{xingmin} 的身高是： {height} 釐米')

    def grow_weight(self, name, weight, growing_weight):
        weight += growing_weight
        print(f'{name} 的體重增長 {growing_weight} 千克')
        return weight  # 必須把結果return到外部保存

    def grow_height(self, xinmin, height, growing_height):
        print(f'{xinmin} 的身高增長 {growing_height} 釐米')
        height += growing_height
        return height  # 必須把結果return到外部保存

    def pee(self, name, weight):
        """
        由於小便會致使體重發生變化，必須把原來的體重傳進來。
        """
        print(f'{name} 蹲着小便')
        return self._reduce_weight_because_of_pee(weight)  # 必須把結果return到外部保存

    def _reduce_weight_because_of_pee(self, tizhong):
        tizhong = tizhong - 0.1  # 體重的別名tizhong和weight是同樣的，面向過程不使用實例屬性，在不少函數中大量重複傳參，形參就會可能不一致，致使看不懂代碼。
        return tizhong


class Person2:
    @classmethod
    def show_weight(cls, name, weight):
        print(f'{name} 的體重是： {weight} 千克')

    @classmethod
    def show_height(cls, xingmin, height):  # xingmin: xingmin也是表明姓名，故意弄成形參不是name，面向過程就會有這種搞不清楚一個參數在不一樣函數中是否是同一個意義的大缺點。
        print(f'{xingmin} 的身高是： {height} 釐米')

    @classmethod
    def grow_weight(cls, name, weight, growing_weight):
        weight += growing_weight
        print(f'{name} 的體重增長 {growing_weight} 千克')
        return weight  # 必須把結果return到外部保存

    @classmethod
    def grow_height(cls, xinmin, height, growing_height):
        print(f'{xinmin} 的身高增長 {growing_height} 釐米')
        height += growing_height
        return height  # 必須把結果return到外部保存

    @classmethod
    def pee(cls, name, weight):
        """
        由於小便會致使體重發生變化，必須把原來的體重傳進來。
        """
        print(f'{name} 蹲着小便')
        return cls._reduce_weight_because_of_pee(weight)  # 必須把結果return到外部保存

    @classmethod
    def _reduce_weight_because_of_pee(cls, tizhong):
        tizhong = tizhong - 0.1  # 體重的別名tizhong和weight是同樣的，面向過程不使用實例屬性，在不少函數中大量重複傳參，形參就會可能不一致，致使看不懂代碼。
        return tizhong


class Person3:
    @staticmethod
    def show_weight(name, weight):
        print(f'{name} 的體重是： {weight} 千克')

    @staticmethod
    def show_height(xingmin, height):  # xingmin: xingmin也是表明姓名，故意弄成形參不是name，面向過程就會有這種搞不清楚一個參數在不一樣函數中是否是同一個意義的大缺點。
        print(f'{xingmin} 的身高是： {height} 釐米')

    @staticmethod
    def grow_weight(name, weight, growing_weight):
        weight += growing_weight
        print(f'{name} 的體重增長 {growing_weight} 千克')
        return weight  # 必須把結果return到外部保存

    @staticmethod
    def grow_height(xinmin, height, growing_height):
        print(f'{xinmin} 的身高增長 {growing_height} 釐米')
        height += growing_height
        return height  # 必須把結果return到外部保存

    @staticmethod
    def pee(name, weight):
        """
        由於小便會致使體重發生變化，必須把原來的體重傳進來。
        """
        print(f'{name} 蹲着小便')
        return Person3._reduce_weight_because_of_pee(weight)  # 必須把結果return到外部保存

    @staticmethod
    def _reduce_weight_because_of_pee(tizhong):
        tizhong = tizhong - 0.1  # 體重的別名tizhong和weight是同樣的，面向過程不使用實例屬性，在不少函數中大量重複傳參，形參就會可能不一致，致使看不懂代碼。
        return tizhong


if __name__ == '__main__':
    """
    person1是無效廢物類，由於他改爲  person2 person3，下面的調用還能正常運行，因此是個廢物類。
    """
    xiaohong = Person3()
    xiaohong_name = '小紅'
    xiaohong_height = 110
    xiaohong_weight = 25
    xiaohong.show_height(xiaohong_name, xiaohong_height)
    xiaohong.show_weight(xiaohong_name, xiaohong_weight)
    xiaohong_height = xiaohong.grow_height(xiaohong_name, xiaohong_height, 5)
    xiaohong_weight = xiaohong.grow_weight(xiaohong_name, xiaohong_weight, 1)  # 體重發生了變化，必須把結果return出來保存
    xiaohong.show_height(xiaohong_name, xiaohong_height)
    xiaohong.show_weight(xiaohong_name, xiaohong_weight)  # 展現體重，須要把變化後的體重傳進來
    xiaohong_weight = xiaohong.pee(xiaohong_name, xiaohong_weight)  # 連上個廁所都須要把體重參數傳進來，而後還要保存新結果，這樣大量傳參簡直不要太low
    xiaohong.show_weight(xiaohong_name, xiaohong_weight)

View Code

五、具體4種寫法分別表明什麼範式的編程，能夠見註釋。而後根據對例子來掌握萬能oop轉化公式。

六、因爲咱們是多平臺開發，公司裏每一個項目都是多個業務平臺，每一個項目至少是5個到30個平臺左右，因此真實例子遠比例子裏面那幾個實現小紅小王小明的代碼類似重複程度嚇人數十倍，代碼太長了就不貼這裏了。主要是不掌握oop 和不瞭解設計模式形成的。這也是我寫代碼常常減小百分之八九十行的主要緣由。

七、真實編程時候，不精通oop和麪向過程區別，幾乎很難抽象一個類，由於我這裏舉例的是一我的，真正寫代碼時候不可能那麼巧恰好業務中須要抽象出一個動物，而後想着圍繞這個動物類型寫他的屬性和方法。因此必定要學習oop轉化公式，和知道oop和麪向過程編程的本質區別，這樣在寫代碼時候纔會不糾結怎麼抽象，和寫類仍是寫函數，不會不由自主的複製粘貼扣字，不會寫新代碼開不了頭，能夠下筆如流水。