Author: LAPTOP-7V78BBO2\ydf19

README.md

@@ -1,3 +1,40 @@
+# 0 介绍36种设计模式（包括23种的变种和python独有例如猴子补丁），最最重要是介绍 oop四部转化公式！！！
+
+## 0.1 python36种设计模式
+
+一共有36种设计模式，23种里面有些还需要细分，你去看菜鸟教程网站的设计模式，那就不止罗列了23个例子，达到三十多种了，有些是变种，有些是python独有例如猴子补丁技术。
+
+## 0.2 介绍 oop四部转化公式，这是项目最重要的文档！！。
+
+
+介绍23种设计模式的博客 教程 网站文档 已经烂大街了，毫不稀奇。 
+
+但是这个项目里面介绍的 oop四部转化公式，是项目最重要的部分，没有任何人是我这么总结如何写oop代码的，学校老师和书本只会教你背诵
+封装 继承 多态 这几个词语本身.你只会看到下面这段类似的话:
+
+
+**面向对象编程（OOP）** 是一种以**对象**为核心的编程范式，将数据（属性）和操作（方法）封装成类，通过**继承**实现代码复用，**多态**实现灵活扩展。  适用于复杂系统（如游戏、GUI），代表语言：Java、C++、Python。
+
+**核心特点**：  
+1. **封装**：隐藏细节，暴露接口，增强安全性。  
+2. **继承**：子类复用父类功能，减少冗余代码。  
+3. **多态**：同一方法在不同类中有不同实现，提高灵活性。  
+
+**好处**：  
+✅ **模块化**：代码结构清晰，易于维护。  
+✅ **复用性**：继承减少重复开发。  
+✅ **扩展性**：新增功能不影响旧代码。  
+✅ **易协作**：对象抽象更贴近现实，方便团队开发。  
+
+
+
+
+然后呢，你背诵上面了这段话，并没有什么作用，因为话术很空洞很虚幻，说了好像又什么都没说，无法落地，没有给你实操步骤，也没有给你具体例子比较面向过程，没有比较根本原因为什么需要oop。
+
+
+
+
+# 1 为什么写项目很难下笔，尤其是开发一个框架要抓破脑袋思考设计几天几夜
 ```
 编程时候，设计新的模块或者项目，下不了笔，要思考三天三夜怎么设计，主要是没学设计模式。
 
@@ -20,7 +57,7 @@
 ```
 
 
-## 一些介绍
+# 2 一些介绍
 学弟啊，你代码能不能不要写得这么烂
 https://www.toutiao.com/a6739759206997426696/
 
@@ -38,13 +75,103 @@ https://www.zhihu.com/question/25432487
 https://zhuanlan.zhihu.com/p/19835717
 
 
-## 介绍神级别通用固定oop转化公式，写代码下笔时候行云流水。
+# 3 介绍神级别通用固定oop 4步转化公式，写代码下笔时候行云流水（只需学习这套固定面向过程转oop 4步走转化公式，远强于背诵设计模式）。
+
+**使用这个公式，不需要背设计模式，不需要每次写新文件先花几天想破头皮怎么设计布局代码成为高扩展和高维护。**
+
+
+[忘掉设计模式，使用最强最稳定最有固定套路的万能编程思维-python oop四步转化公式](https://github.com/ydf0509/python36patterns/tree/master/%E5%BF%98%E6%8E%89%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F%EF%BC%8C%E4%BD%BF%E7%94%A8%E6%9C%80%E5%BC%BA%E6%9C%80%E7%A8%B3%E5%AE%9A%E6%9C%80%E6%9C%89%E5%A5%97%E8%B7%AF%E7%9A%84%E4%B8%87%E8%83%BD%E7%BC%96%E7%A8%8B%E6%80%9D%E7%BB%B4-python%20oop%E5%9B%9B%E6%AD%A5%E8%BD%AC%E5%8C%96%E5%85%AC%E5%BC%8F%E3%80%82)
+
+
+这个oop四步走转化公式是最重要的，其他的36个设计模式python例子你在很多地方都能看到类似的。
+
+先简要说明四步转化公式，具体的看上面链接的文档
+
+## 3.1 四步走转化公式，具体步骤如下
+
+### 第0步，按照模块+函数写python代码，脑子里面打草稿，写全局变量多多益善
+
+**第0步是灵魂步骤，后面3步是死板的代码形式转化。你不做这一步，直接做后面三步，那就是写出无效废物装逼滑稽类，因为写出来也是面向过程的类。**
+
+python模块文件下面多写全局变量，全局变量要多多益善；       
+多个函数之间不要疯狂传递一大堆相同名字或意义的入参；      
+每个函数末尾不要疯狂return一大堆中间状态变量；       
+不要把这些return出来的变量，频繁传递给另外一个函数；   
+
+**你应该尽可能全部设计成全局变量，然后每个函数里面去修改这一堆全局变量，这样就大幅避免了多个函数频繁传递一大堆入参，也不需要每个函数末尾疯狂return一大堆中间状态变量。**
+
+这一步是脑子打草稿，多写全局变量，每个函数少传一大堆入参，少写return一大堆结果变量。 
+
+这一步和老师教你要少写全局变量不同，似乎是反智，但请往下看。
+
+### 第1步 模块降级为类名
+
+就是要把模块级代码移到class 类下面
+
+写个class 类，就是把你之前脑子打的草稿，模块 + 全局变量 + 函数，改成 类+实例属性+实例方法
+
+### 第2步 全局变量降级为实例属性
 
-使用这个公式，不需要背设计模式，不需要每次写新文件先花几天想破头皮怎么设计布局代码成为高扩展和高维护。
+之前为什么让你多写全局变量，就是为了这一步，全局变量降级为实例属性。你以为最终目的是为了多写全局变量吗？多写全局变量肯定是不行的是反语言的。
 
-## 常见问题回答
+### 第3步 函数降级为实例方法
 
-1、老是纠结类和函数？类和函数有什么区别。
+函数改为实例方法，但是函数第一个入参要加个self。
+
+之前模块函数里面直接用全局变量 var_xx，现在实例方法里面读取和修这个"全局变量"，使用 self.var_xx。
+
+## 3.2 oop 四步走转化公式的说明：
+
+转化oop要有灵魂的第0步，如果跳过此步骤，直接执行第1到3步，就会想当然以为转化oop就是函数外面加个class关键字外壳，觉得转化没用。   
+那是因为你不按照我说的步骤走，造成写成了无效废物装逼滑稽面向过程类，当然会觉得不需要转化。oop要的是内涵不要搞形式class外壳。
+
+## 3.3 为什么要 oop 四步走转化，说明最根本核心原因
+
+### 3.1 直接 模块级 + 多多益善的全局变量 + 函数  有什么问题？
+
+```
+最根本原因是因为模块是单例的，模块的变量是全局唯一的，例如按照第五章的代码你 描述一个人 吃喝拉撒(函数) 影响人的身高体重（全局变量）。
+
+如果你要调用 小红 小明 小黄 小黑 4个人吃喝拉撒，由于全局变量只有一份，那会互相影响，因为全局变量没有隔离。小红调用吃饭，为什么要增加小明的体重？
+
+所以你为了避免这种全局变量不适合多个人调用吃喝拉撒的问题，就写出了类似5.1教程的代码，写成了多个函数间疯狂传参，疯狂return一大堆变量，把这些变量再外部保存，并在函数间传来传去。
+```
+
+### 3.2 使用oop的天然多实例，每个实例的属性互不干扰的特性，天然解决全局变量只有一份的问题
+
+```
+既想写代码简单粗暴，全局变量加函数的思维，又要解决 全局变量只有一个，不能隔离的问题。那就是使用oop开发代码，     
+oop的类天然就是多实例的，每个实例的属性是互不干扰的，天然解决全局变量只有一份的问题。
+
+oop写代码后，类的每个对象的方法访问和修改实例属性，就像函数里面操作全局变量那样丝滑，并且是每个实例的属性天生是各自的，不会互相干扰的。      
+你调用 小红.吃饭()  再也不用担心影响到 小明.体重 了。
+```
+### 3.3 不要用辩证法说有时候面向过程编程有时候更有优势 之类的话！
+
+有的人就是杠精，我说 "考公务员都是精致的利己主义者，就是为了工资高 永不失业 退休金高"；   
+他却辩证法说 "也有考公务员是为了成为高尚的人民公仆，例如雷锋就是不喜欢钱，就是喜欢把国家发的工资和退休金都捐给农村老人用"。
+
+```
+最怕有的人，完全不去思考为什么需要oop，自己懒得要死，上来就来一句 "有时候面向过程编程更简单更好" 的话 或者 "只有大项目才需要oop" 的话。
+
+不要这么使用辩证法偷懒好吗。我没说过任何场景一定要用oop，最最关键的判断依据是你需不需要多实例， 你不需要多实例那就可以不要面向对象写法,
+也不需要单例模式装逼写个类，你直接模块加函数就好了，反正不需要全局变量隔离的需求。
+
+例如本文档第5章节，描写一个人吃喝拉撒运动影响了身高体重，这个需求是非常非常简单吧，绝对是你口中的小项目，绝对是你认为的不需要oop。
+但事实就是，用oop来完成需求，比面向过程写法实现时候简单多了，最重要的是调用时候简单太多了。
+
+为什么我写的所有包，例如 funboost  nb_time nb_log都很好用，都是用法十分简单但功能十分强大的python包，原因就是在于此。     
+假如你来封装python三方包或框架给别人用，如果你不按我的思路写代码，就会造成不仅你自己实现框架时候很麻烦、很难扩展、爱出错、不好维护，    
+更重要的是你把这个包发布出来后，即使功能能达到目的，但用户会感觉极端难使用、不好用、不方便。
+例如5.1写法封装的模块，用户来调用人.吃饭() 和人.撒尿() ,用户需要风控传一大堆入参和接受并保存一大堆返回，体验太差了。
+```
+
+- **需要多实例** → 用OOP
+- **不需要多实例** → 用面向过程（模块+函数）
+
+# 4 常见问题回答
+
+## 4.1 老是纠结类和函数？类和函数有什么区别。
 
 ```
 问函数和类的区别，这简直是牛头不对马嘴的伪问题。
@@ -61,12 +188,13 @@ https://zhuanlan.zhihu.com/p/19835717
 
 所以如果需要多实例，类 + 方法 + 实例属性(成员变量) 远好于 模块 + 函数 + 全局变量。
 模块 + 函数 + 全局变量 由于要模拟多实例，使全局变量（状态） 不唯一，大部分情况下需要写成 函数反复传参和反复return。
-这种面向过程的封装的写法曲折程度毫无疑问被oop暴击了，面向过程导致写代码慢想破头皮搞一堆传参和return。何况oop不只有封装还有继承和多态。
+这种面向过程的封装的写法曲折程度毫无疑问被oop暴击了，面向过程导致写代码慢想破头皮搞一堆传参和return。
+何况oop不只有封装还有继承和多态。
 
 能写类的人100%就能写函数，能写函数的人不一定能写类（说的是真oop的类，排除无效废物面向过程滑稽类），这是不可逆的。
 ```
 
-2、 不学设计模式的坏处
+## 4.2 不学设计模式的坏处
 
 ```
 只爱学python语法，只学怎么使用if else break， 学字典 列表怎么用，代码就很low
@@ -75,15 +203,15 @@ https://zhuanlan.zhihu.com/p/19835717
 写新文件要想破头皮三天三夜才能开始下笔。
 ```
 
-## ！【重要】 简单例子说明极端面向过程编程非常愚蠢low
+# 5【重要】 简单例子说明极端面向过程编程非常愚蠢low，代码模拟人 吃喝拉撒导致身高体重变化。
 
 情不自禁纯粹极端面向过程编程还是c语言中毒了，从来都不使用面向对象，不用提设计模式。
 
-有些人完全没思考过面向对象，一味的只会说大型项目才需要面向对象，小项目面向过程更合适。简直是胡说八道，不看场景只看项目大小。
+有些人完全没思考过面向对象，一味的只会说"大型项目才需要面向对象，小项目面向过程更合适"。简直是胡说八道，不看场景只看项目大小。
 
-比如一个简单需求，描写人,吃饭 增加体重和身高，拉尿体重降低。需求是非常非常的简单了吧，绝对是非常小的项目，单个文件就好了，来验证下是不是小项目面向过程最好。
+比如一个简单需求，描写人,吃饭 增加体重和身高，拉尿体重降低。需求是非常非常的简单了吧，绝对是非常小的项目，单个文件就好了，来验证下是不是小项目面向过程就好了。
 
-面向过程来实现，看看代码实现多垃圾，调用时候多么麻烦。
+## 5.1 面向过程来实现，看看代码实现时候有多垃圾麻烦，调用时候多么麻烦。
 ```python
 # 吃饭函数
 def eat(name, height, weight, food_weight):
@@ -115,16 +243,16 @@ if __name__ == "__main__":
     print(f"小明 初始状态 - 身高: {xiaoming_height} 厘米，体重: {xiaoming_weight} 千克")
     print(f"小红 初始状态 - 身高: {xiaohong_height} 厘米，体重: {xiaohong_weight} 千克")
 
-    # 小明吃饭和拉尿
+    # 小明吃饭和拉尿，调用封装的函数太恶心了，传了一大堆入参，还要return一大堆变量，还要在调用处保存这些变量
     xiaoming_height, xiaoming_weight = eat("小明", xiaoming_height, xiaoming_weight, 2)
     xiaoming_height, xiaoming_weight = pee("小明", xiaoming_height, xiaoming_weight, 1)
 
-    # 小红吃饭和拉尿
+    # 小红吃饭和拉尿，调用封装的函数太恶心了，传了一大堆入参，还要return一大堆变量，还要在调用处保存这些变量
     xiaohong_height, xiaohong_weight = eat("小红", xiaohong_height, xiaohong_weight, 3)
     xiaohong_height, xiaohong_weight = pee("小红", xiaohong_height, xiaohong_weight, 2)
 ```
 
-面向对象来实现，看看代码实现多简单调用多方便
+## 5.2 面向对象来实现，看看代码实现多简单调用多方便
 ```python
 class Person:
     def __init__(self, name, height, weight):
@@ -151,11 +279,11 @@ if __name__ == "__main__":
     xiaoming = Person("小明", 170, 60)
     xiaohong = Person("小红", 160, 50)
 
-    # 小明吃饭和拉尿
+    # 小明吃饭和拉尿， 调用太爽了，不用传一大堆入参，不用return一大堆变量，不用在调用处保存这些变量
     xiaoming.eat(2)
     xiaoming.pee(1)
 
-    # 小红吃饭和拉尿
+    # 小红吃饭和拉尿，调用太爽了，不用传一大堆入参，不用return一大堆变量，不用在调用处保存这些变量
     xiaohong.eat(3)
     xiaohong.pee(2)
 ```
@@ -179,4 +307,14 @@ if __name__ == "__main__":
 
 ```
 
-#### 只需要按文档的面向过程转 oop 4步走里面的固定公式，全局变量->实例属性，函数->方法 降维转化，就可以设计出强大的代码，无需死记硬背23种设计模式。
+# 6 再次说明，项目最重要的是oop四步走转化公式
+
+**只需要按文档的面向过程转 oop 4步走里面的固定公式，全局变量->实例属性，函数->方法 降维转化，就可以设计出强大的代码，无需死记硬背23种设计模式。**
+
+
+
+
+
+
+
+