diff --git a/README.md b/README.md
index ba5d4b92617fefe890bc499d17b3c553b5ccf766..3801f881d383097ebc1b0e4ca8789209faab0846 100644
--- a/README.md
+++ b/README.md
@@ -1,14 +1,24 @@
 # 写作角度
 本人增删改查程序员出身，目前从事数据科学，看到一些数据科学从业者编程技能不足，同时也是为了提升自己的编程能力，顾计划站在数据科学的角度书写此书。
-# 适合人群
-已经熟悉Python基本语法及标准库，有简单的代码经验
+
+# 前置知识
+* 了解Python基本语法，可以看懂基本的python代码
+* 有代码经验可以更好的体会到设计模式的用途，没有代码也可阅读在自己的项目中使用
+
 # 设计模式的作用
 在制作软件的过程中，设计模式可能是新手最容易忽略的基础技能，软件（脚本）没有良好的结构，在升级演进的过程一定会浪费需要时间。相应的，如果在软件建立的过程中，拥有可维护、易拓展的良好结构，那么一定有利于后续的升级开发。
-# 写作结构
-每一种设计模式先用极简的语言介绍核心思想
-再结合数据科学的实际情况，给出简洁的Python语言的实现
-结合代码解释具体思路
-说明这种模式的应用场景
-给出应用该设计模式的实例
+
+# 写作结
+1. 每一种设计模式先介绍核心思想
+1. 在设计模式实现的代码中，通过详细的代码注释来说明设计模式的思想与原理，使读者通过阅读代码就可以学习设计模式
+1. 在main()方法中的注释里，进行对数据模式的总结性称述
+
+# 贡献指南
+* （强制）Python代码必须符合PEP8风格
+* （强制）每个设计模式单独为一个文件，并在文件头进行对此模式详细的说明
+* （强制）设计模式的实现必须以数据科学背景简单抽象情况举例
+* （强制）任何修改请向dev分支推送pull request
+* （推荐）请优先共享Python的代码，但也接受任何代码但实现
+
 # 设计模式总结
-创建型的设计模式共有5种类型：工厂方法、抽象工厂、建造者、原型、单例
\ No newline at end of file
+创建型的设计模式共有5种类型：工厂方法、抽象工厂、建造者、原型、单例模式
diff --git a/python/creational/abstract_factor.py b/python/creational/abstract_factor.py
index 8761623fbd904f167571fd273864212657673019..9d6ebe73172044e164045e422593a4137f7adc32 100644
--- a/python/creational/abstract_factor.py
+++ b/python/creational/abstract_factor.py
@@ -27,36 +27,34 @@ class DataSet(object):
         raise NotImplementedError
 
 
-class Image(DataSet):
-    """继承自Data父类，假设这是一组图片数据"""
+class DataSetA(DataSet):
+    """继承自DataSet父类，假设这是一组图片数据"""
 
     def content(self) -> None:
         """
         重载
-        图片数据集的内容
 
-        返回：假设返回了一组图片
+        返回：数据集A
         """
-        print("Image!")
+        print("A!")
 
     def __str__(self) -> str:
-        return f"Image<{self.name}>"
+        return f"A<{self.name}>"
 
 
-class Text(DataSet):
-    """同样继承自Data父类，假设这一组文字数据集"""
+class DataSetB(DataSet):
+    """同样继承自DataSet父类，假设这一组文字数据集"""
 
     def content(self) -> None:
         """
         重载
-        文字数据集的内容
 
-        返回：假设返回了一组字符
+        返回：数据集B
         """
-        print("Text!")
+        print("B!")
 
     def __str__(self) -> str:
-        return f"Text<{self.name}>"
+        return f"B<{self.name}>"
 
 
 class AbstractDataFactory(object):
@@ -75,7 +73,7 @@ class AbstractDataFactory(object):
         """获得不同类型的数据
 
         参数：
-            name: 数据集的名字
+            name: 用户自定义数据集的名字
         """
 
         data_set = self.data_factory(name)
@@ -86,17 +84,17 @@ class AbstractDataFactory(object):
 def main():
     """抽象工厂的核心思想：通过通过同样的j声明不同类型的工厂，生产出不同的类"""
     # 声明了一个文字类的数据集工厂
-    factory = AbstractDataFactory(Text)
-    # 给这个数据集起名 NLP
-    data_set = factory.get_data_set("NLP")
-    # 查看 NLP 数据集的内容
-    data_set.content()  # Here is your data Text<A> Text!
-    # factor 变成了图像类的数据集工厂
-    factory = AbstractDataFactory(Image)
-    # 起名 CV 数据集
-    data_set = factory.get_data_set("CV")
-    # 查看 CV 数据集的内容
-    data_set.content()  # Here is your data Image<B> Image!
+    factory = AbstractDataFactory(DataSetA)
+    # 给这个数据集命名为public_dataset
+    data_set = factory.get_data_set("public_dataset")
+    # 调用了DataSetA的content()方法
+    data_set.content()  # A!
+    # factor变成了图像类的数据集工厂
+    factory = AbstractDataFactory(DataSetB)
+    # 给这个数据集命名为private_dataset
+    data_set = factory.get_data_set("private_dataset")
+    # 调用了DatasetB类content()方法
+    data_set.content()  # B!
 
 
 if __name__ == "__main__":
diff --git a/python/creational/factor.py b/python/creational/factor.py
deleted file mode 100644
index b55f366d0a4b96c89adaa946ecbe39b08e3ecde9..0000000000000000000000000000000000000000
--- a/python/creational/factor.py
+++ /dev/null
@@ -1,27 +0,0 @@
-class TextLoader:
-    def get_data(self) -> str:
-        return "This is a text!"
-
-
-class ImageLoader:
-    def get_data(self) -> str:
-        return "This is a image!"
-
-
-class DataLoaderFactory:
-    def get_loader(self, type: str = "Image") -> object:
-        """工厂方法"""
-        loaders = {
-            "Image": ImageLoader,
-            "Text": TextLoader,
-        }
-        return loaders[type]()
-
-
-if __name__ == "__main__":
-    # 创建数据加载器工厂
-    factory = DataLoaderFactory()
-    image, text = factory.get_loader(
-        type="Image"), factory.get_loader(type="Text")
-    # 输出加载的数据
-    print(image.get_data(), text.get_data())
diff --git a/python/creational/factory.py b/python/creational/factory.py
new file mode 100644
index 0000000000000000000000000000000000000000..a8b9f01af8346606fcfae6bffa12fdc9b3099275
--- /dev/null
+++ b/python/creational/factory.py
@@ -0,0 +1,71 @@
+"""
+工厂模式：
+类似工厂里通过流水线生产产品一样，工厂方法通过统一的接口（类比流水线）生产类（类比流水线生产的产品）。工厂模式的关键在于在创建类的时候并不需要明确的调用构造器而是通过工厂方法来创建需要的类。
+
+本例：
+假设本工程具具有多个模型，多个数据需要使用，我们在main()中通过同一个工厂方法来初始化不同的类。
+"""
+
+
+class ImageData(object):
+    """某个图像数据集"""
+
+    def get_data(self) -> str:
+        """假设这是加载数据集的函数
+
+        返回：数据集
+        """
+        return "Images"
+
+
+class ModelA(object):
+    """某个模型"""
+
+    def get_model(self) -> str:
+        """假设这个方法可以得到模型
+
+        返回：模型A
+        """
+        return "ModelA"
+
+
+class ModelB(object):
+    """另一个预训练模型"""
+
+    def get_model(self) -> str:
+        """假设这个方法可以得到模型
+
+        返回：模型B
+        """
+        return "ModelB"
+
+
+class DatasetFactory(object):
+    @staticmethod
+    def get(name: str) -> object:
+        """工厂方法的实现关键在于在于将需要用的类（本例中为数据集）集中管理起来，这里使用factories变量来注册所有的数据集
+
+        参数：
+            name：不同数据集的名称
+        """
+        # 注册数据集的名称与对应的类
+        factories = {
+            "DataSet": ImageData,
+            "A": ModelA,
+            "B": ModelB
+        }
+        return factories[name]()
+
+
+def main():
+    """工厂模式的核心思想：通过统一的接口创建类"""
+    # factory.get就是这个统一的接口
+    data = DatasetFactory.get("DataSet")
+    print(data.get_data())
+    # 通过name参数分别加载A和B两个模型
+    A, B = DatasetFactory.get("A"), DatasetFactory.get("B")
+    print(A.get_model(), B.get_model())
+
+
+if __name__ == "__main__":
+    main()