diff --git a/README.md b/README.md
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..ba5d4b92617fefe890bc499d17b3c553b5ccf766 100644
--- a/README.md
+++ b/README.md
@@ -0,0 +1,14 @@
+# 写作角度
+本人增删改查程序员出身，目前从事数据科学，看到一些数据科学从业者编程技能不足，同时也是为了提升自己的编程能力，顾计划站在数据科学的角度书写此书。
+# 适合人群
+已经熟悉Python基本语法及标准库，有简单的代码经验
+# 设计模式的作用
+在制作软件的过程中，设计模式可能是新手最容易忽略的基础技能，软件（脚本）没有良好的结构，在升级演进的过程一定会浪费需要时间。相应的，如果在软件建立的过程中，拥有可维护、易拓展的良好结构，那么一定有利于后续的升级开发。
+# 写作结构
+每一种设计模式先用极简的语言介绍核心思想
+再结合数据科学的实际情况，给出简洁的Python语言的实现
+结合代码解释具体思路
+说明这种模式的应用场景
+给出应用该设计模式的实例
+# 设计模式总结
+创建型的设计模式共有5种类型：工厂方法、抽象工厂、建造者、原型、单例
\ No newline at end of file
diff --git a/python/creational/abstract_factor.py b/python/creational/abstract_factor.py
index 8cae887e9486a0d6a3ea32fd6e88048007c27f9b..8761623fbd904f167571fd273864212657673019 100644
--- a/python/creational/abstract_factor.py
+++ b/python/creational/abstract_factor.py
@@ -1,9 +1,16 @@
-from typing import NoReturn, Type
+"""
+抽象工厂模式：
+抽象工厂提供了一个统一的接口，来创建一组相同功能的类。
+
+这个例子设计的情景：
+假设我们的系统需要加载不同数据集用于验证我们的模型，我们希望加载的数据集之间可以通过一个接口互相替换，不需要我们修改我们模型的代码。
+"""
+from typing import Type
 
 
 class DataSet(object):
     """
-    数据类的父类，抽象出这一类的最基本的要素与功能
+    数据类的父类，抽象出数据集这一类的最基本的要素与功能
 
     属性：
         name: 所有的数据都有一个可读的名字，本例抽象出这一个属性做演示
@@ -12,7 +19,7 @@ class DataSet(object):
     def __init__(self, name: str) -> None:
         self.name = name
 
-    def content(self) -> NoReturn:
+    def content(self) -> None:
         """数据集的内容"""
         raise NotImplementedError
 
@@ -23,7 +30,7 @@ class DataSet(object):
 class Image(DataSet):
     """继承自Data父类，假设这是一组图片数据"""
 
-    def content(self) -> NoReturn:
+    def content(self) -> None:
         """
         重载
         图片数据集的内容
@@ -39,7 +46,7 @@ class Image(DataSet):
 class Text(DataSet):
     """同样继承自Data父类，假设这一组文字数据集"""
 
-    def content(self) -> NoReturn:
+    def content(self) -> None:
         """
         重载
         文字数据集的内容
@@ -76,8 +83,8 @@ class AbstractDataFactory(object):
         return data_set
 
 
-# 抽象工厂的核心思想：声明不同类型的工厂，生产出不同的类
-if __name__ == "__main__":
+def main():
+    """抽象工厂的核心思想：通过通过同样的j声明不同类型的工厂，生产出不同的类"""
     # 声明了一个文字类的数据集工厂
     factory = AbstractDataFactory(Text)
     # 给这个数据集起名 NLP
@@ -90,3 +97,7 @@ if __name__ == "__main__":
     data_set = factory.get_data_set("CV")
     # 查看 CV 数据集的内容
     data_set.content()  # Here is your data Image<B> Image!
+
+
+if __name__ == "__main__":
+    main()
diff --git a/python/creational/factor.py b/python/creational/factor.py
index b55f366d0a4b96c89adaa946ecbe39b08e3ecde9..a7e53bd0e097393c14e9e04438303222756e9fca 100644
--- a/python/creational/factor.py
+++ b/python/creational/factor.py
@@ -1,27 +1,71 @@
-class TextLoader:
-    def get_data(self) -> str:
-        return "This is a text!"
+"""
+工厂模式：
+类似工厂里通过流水线生产产品一样，工厂方法通过统一的接口（类比流水线）生产类（类比流水线生产的产品）。工厂模式的关键在于在创建类的时候并不需要明确的调用构造器而是通过工厂方法来创建需要的类。
+
+本例：
+假设本工程具具有多个模型，多个数据需要使用，我们在main()中通过同一个工厂方法来初始化不同的类。
+"""
 
 
-class ImageLoader:
+class ImageData(object):
+    """某个图像数据集"""
+
     def get_data(self) -> str:
-        return "This is a image!"
+        """假设这是加载数据集的函数
+
+        返回：数据集
+        """
+        return "Images"
+
+
+class ModelA(object):
+    """某个模型"""
+
+    def get_model(self) -> str:
+        """假设这个方法可以得到模型
+
+        返回：模型A
+        """
+        return "ModelA"
 
 
-class DataLoaderFactory:
-    def get_loader(self, type: str = "Image") -> object:
-        """工厂方法"""
-        loaders = {
-            "Image": ImageLoader,
-            "Text": TextLoader,
+class ModelB(object):
+    """另一个预训练模型"""
+
+    def get_model(self) -> str:
+        """假设这个方法可以得到模型
+
+        返回：模型B
+        """
+        return "ModelB"
+
+
+class DatasetFactory(object):
+    def get(self, name: str) -> object:
+        """工厂方法的实现关键在于在于将需要用的类（本例中为数据集）集中管理起来，这里使用factories变量来注册所有的数据集
+
+        参数：
+            name：不同数据集的名称
+        """
+        # 注册数据集的名称与对应的类
+        factories = {
+            "DataSet": ImageData,
+            "A": ModelA,
+            "B": ModelB
         }
-        return loaders[type]()
+        return factories[name]()
+
+
+def main():
+    """工厂模式的核心思想：通过统一的接口创建类"""
+    factory = DatasetFactory()
+    # factory.get就是这个统一的接口
+    data = factory.get("DataSet")
+    print(data.get_data())
+    # 通过name参数分别加载A和B两个模型
+    A, B = factory.get("A"), factory.get("B")
+    print(A.get_model(), B.get_model())
 
 
 if __name__ == "__main__":
-    # 创建数据加载器工厂
-    factory = DataLoaderFactory()
-    image, text = factory.get_loader(
-        type="Image"), factory.get_loader(type="Text")
-    # 输出加载的数据
-    print(image.get_data(), text.get_data())
+    main()