python oop培训文档里面的 正宗oop、多个函数间反复return传参、多个文件无限复制粘贴扣字、无效废物滑稽类4种方式的例子。（2）

python编程范式培训文档，主要是结合4种代码和，对oop和面向过程编程区别和oop转化公式培训。

接这一篇。

把文档里面说的几种范式发出来。

4种编程范式实现一个人吃喝拉撒长身体的代码。语法很简单，思想模拟了所有程序员写代码时候的代码规划设计想法。

0.我不反对复制粘贴的写法，可以百度搜索复制粘贴网上现有的，但反对老是写新代码就把自己的旧代码整个复制几亿次，然后在代码文件里面扣字形成新代码，我不愿意接受这样的项目。如果写代码是使用这样的方式，那就不能好高骛远装逼搞leetcode算法，实际上我们项目代码里面我看也没有任何算法，反而是不会设计模式 面向对象会对项目造成很多严重不利影响和拖累任务进度。

1、开门见山，发正宗oop

# coding=utf8
"""
1、实现人的功能。oop写法，使用类/对象 加 方法。
2、重要是要理解面向对象里面的封装，封装是最重要的特点，写出没有体现出封装特点的类就是无效废物类就是面向过程的类。
3、这种写法清晰明了，类/对象 加 方法 的写法 几乎和模块文件加全局变量加函数的写法思路是一模一样的，只是把命名空间下沉了一级，就能毫无曲折的实现了多实例的要求。继不继承都是次要的，最最最重要是看封装，不要把注意力重点放在这里面的继承了，只是顺便演示一个继承是如何减少代码实现不同点而已。继承不是面向对象必须的，封装才是。
4、使用oop时候，在实现时候更为简单，几乎行云流水，不需要考虑频繁的考虑传参和return
出状态（变量）给外部。在调用时候也更具备一致性，在调用处只需要一个实例化出一个对象，类的外部只需要一个变量代表此实例即可。否则使用面向过程还需要模拟多实例，在调用处最少需要保存 名字 体重 身高三个变量，并且每次调用函数都需要传入和保存return出来的值，这样调用起来反复传参和return修改外部变量，调用起来复杂和看起来乱七八糟的调用形式不具备一致性。
"""

"""
得出转化公式的规律：
一、针对全局变量加函数无限复制粘贴扣字的写法，
1） 模块级降级为类名
2） 全局变量改成实例属性
3） 函数改为方法

二、针对频繁return和大量重复传参的写法
1、转化公式1
0）在脑袋中重构，把写法形式改成全局变量加函数的写法，此时不用担心全局变量是唯一的，不用大量重复传参和return，所有需要传参和return的都想象成使用全局变量和操作全局变量。
1） 模块级降级为类名
2） 全局变量改成实例属性
3） 函数改为方法
后面三个步骤是一样的。全局变量变为实例属性后，每次实例化后每个对象的实例属性都是互不干扰的。每个对象可以看作为一个模块级写法的 模块文件的无限深拷贝。

2、转化公式2
1） 新增一个类
2）把重复传参和return的形参，全都去掉，改成实例属性
3） 函数改为方法。

对任何面向过程写法，使用转化公式，一定就可以修改成oop，然来的代码思维不需要做任何改变，只要按这个公式就可以改造。（前提是满足需要使用oop的两个条件，才需要改造）
对新写的代码，也可以按然来的想法写，说的是在脑袋里面那么写（不然真那么写，再修改，浪费花时间），然后按照此公式转化后写在ide里面。
"""

"""
最重要是理解：  命名空间  全局变量  实例属性  多实例需求  函数和方法 的关系，搞清楚了，写oop十分之简单，不会造成极端面向过程的曲折写法。
在word文档中会写更详细的解释。
"""

"""
常见问题解答
1、是不是所有代码都要用oop？
答：不是，按照上面的方式判断用那种方式好，目的是要简单代码少就可以，便于维护扩展就好。
2、函数和类上面区别？
没有区别，就像问人和走路有什么区别，猪和吃饭有什么区别，问得牛头不对马嘴的伪问题，函数和方法才可以比较。类（对象）和模块才有可比性，必须要搞清楚原因，不然脑袋中有这个比较的想法那就不可能写得了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()

以下为模拟low写法

2、多个函数间反复频繁return 传参.即使实现男女不复制文件扣字来实现，那也要多加一个性别参数，如果撒尿被很多函数调用了，那很多函数都要入参加性别。

实现男的

# -*- 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函数。

实现女的

# -*- 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)

3、全局变量 加 函数的写法，比上面反复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()

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 由于是使用的全局变量，只能完成一个单例的情况，只能完成小明这一个人，无法同时完成小明和小王，如果需要使用小王，必须复制粘贴扣字。

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 由于是使用的全局变量，只能完成一个单例的情况，只能完成小明这一个人，无法同时完成小明和小王，如果需要使用小王，必须复制粘贴扣字。

4、无效废物装逼类。 有些人发现第三方包的大神那么流弊，里面那么多类，觉得类肯定狠流弊，没有理解到封装这一最基本要义的内涵，导致写出来的类是废物滑稽类，没作用。

这三个类如此轻易的使用静态方法类方法 实例方法自由转化代码能正常运行，这种九成九是废物类。仍然使用反复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)

5、具体4种写法分别代表什么范式的编程，可以见注释。然后根据对例子来掌握万能oop转化公式。

6、由于我们是多平台开发，公司里每个项目都是多个业务平台，每个项目至少是5个到30个平台左右，所以真实例子远比例子里面那几个实现小红小王小明的代码相似重复程度吓人数十倍，代码太长了就不贴这里了。主要是不掌握oop 和不了解设计模式造成的。这也是我写代码经常减少百分之八九十行的主要原因。

7、真实编程时候，不精通oop和面向过程区别，几乎很难抽象一个类，因为我这里举例的是一个人，真正写代码时候不可能那么巧刚好业务中需要抽象出一个动物，然后想着围绕这个动物类型写他的属性和方法。所以一定要学习oop转化公式，和知道oop和面向过程编程的本质区别，这样在 写代码时候才会不纠结怎么抽象，和写类还是写函数，不会情不自禁的复制粘贴扣字，不会写新代码开不了头，可以下笔如流水。