main.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# **知识图谱构建**\n",
    "大致分为以下几步\n",
    "\n",
    "1、数据预处理\n",
    "\n",
    "2、切分文段\n",
    "\n",
    "3、输入大模型\n",
    "\n",
    "4、反馈整合输出\n",
    "\n",
    "5、分步重构"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **数据预处理**\n",
    "\n",
    "目标：在不使用ocr的情况下，将文件转成合适长度的文本段落\n",
    "\n",
    "数据源：规整的docx类型，以及内容为图像的pdf文件\n",
    "\n",
    "开源库：**python-docx**，内容按段落切分，没有“页”以及“目录”的操作api\n",
    "\n",
    "**PyMuPDF**，内容按页切分，输入文件需为含有文本信息的pdf文件\n",
    "\n",
    "处理方式：将docx转成pdf然后按照pdf进行数据读取和按页切分"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 将目录数据转成实体关系数据以及切片数据\n",
    "from buildKG.str2json import indexstr2json,str2json\n",
    "from buildKG.docx2request import group_paragraphs_by_token_limit,extract_text_from_pages,group_page_by_token_limit\n",
    "from buildKG.forest import Node,Edge,Forest\n",
    "\n",
    "from http import HTTPStatus\n",
    "from dashscope import Generation\n",
    "from dashscope.api_entities.dashscope_response import Role\n",
    "import dashscope\n",
    "import time\n",
    "import random\n",
    "import os\n",
    "import fitz  # PyMuPDF\n",
    "import copy\n",
    "dashscope.api_key = \"sk-8cdfdc6958a7408492d465269349299f\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "下面不好用，要windows系统，我直接wps转pdf,当然不转直接拿langchain的Unstructured来做也可以，同样问题也有不如WPS docx转pdf 人工选取 目录页数快"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # docx转pdf \n",
    "# from docx2pdf import convert\n",
    "\n",
    "# # 指定.docx文件路径和.pdf输出路径\n",
    "# docx_file_path = './data/（139） 3D打印技术基础（第三版）-朱红,易杰,谢丹-华中科技大学出版社.docx'\n",
    "# pdf_output_path = './data_pdf/（139） 3D打印技术基础（第三版）-朱红,易杰,谢丹-华中科技大学出版社.pdf'\n",
    "\n",
    "# # 执行转换\n",
    "# convert(docx_file_path, pdf_output_path)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **文段切分**\n",
    "目标：选取合适大小的文本段落为单元任务，去让大模型进行归纳总结\n",
    "\n",
    "1、直接按长度进行划分：很碎，造成野节点非常多，不能作为一个方案\n",
    "\n",
    "2、按章节进行划分：不够细致，大多数只挺留在了第一级\n",
    "\n",
    "3、按小节进行划分：很深，很杂，会把很多一个定义下的大段文本作为输出，同样野节点非常多\n",
    "\n",
    "处理方式：\n",
    "\n",
    "按章节进行划分的方式，以章节名作为一级子节点，后续野子节点置于一级子节点上"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 目录起始页\n",
    "# 若篇幅过长，则手动切分目录，对目录进行分批处理\n",
    "start_page = 3\n",
    "end_page = 4\n",
    "pdf_output_path = './pdf/面向对象.pdf'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 执行目录提取\n",
    "request=extract_text_from_pages(pdf_output_path, start_page, end_page)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**将切分好的目录数据给到大模型，让大模型总结目录**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "nodes_array=[]\n",
    "edges_array=[]\n",
    "pages_array=[]\n",
    "pages_part_array=[]\n",
    "chapter_name_array=[]\n",
    "log=[]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "```json\n",
      "{\n",
      "  \"slices\": [\n",
      "    {\n",
      "      \"chapter_name\": \"数据库设计\",\n",
      "      \"page\": \"213\",\n",
      "      \"entries\": [\n",
      "        {\n",
      "          \"entry_name\": \"逻辑模型和物理模型\",\n",
      "          \"page\": \"213\"\n",
      "        },\n",
      "        {\n",
      "          \"entry_name\": \"关系数据库模型\",\n",
      "          \"page\": \"215\"\n",
      "        },\n",
      "        {\n",
      "          \"entry_name\": \"将 E-R 图转化成关系\",\n",
      "          \"page\": \"216\"\n",
      "        },\n",
      "        {\n",
      "          \"entry_name\": \"设计字段\",\n",
      "          \"page\": \"222\"\n",
      "        },\n",
      "        {\n",
      "          \"entry_name\": \"代码设计\",\n",
      "          \"page\": \"225\"\n",
      "        }\n",
      "      ]\n",
      "    },\n",
      "    {\n",
      "      \"chapter_name\": \"输出、输入与用户界面设计\",\n",
      "      \"page\": \"230\",\n",
      "      \"entries\": [\n",
      "        {\n",
      "          \"entry_name\": \"输出设计\",\n",
      "          \"page\": \"230\"\n",
      "        },\n",
      "        {\n",
      "          \"entry_name\": \"输入设计\",\n",
      "          \"page\": \"233\"\n",
      "        },\n",
      "        {\n",
      "          \"entry_name\": \"用户界面设计\",\n",
      "          \"page\": \"241\"\n",
      "        },\n",
      "        {\n",
      "          \"entry_name\": \"输入输出界面示例\",\n",
      "          \"page\": \"251\"\n",
      "        }\n",
      "      ]\n",
      "    },\n",
      "    {\n",
      "      \"chapter_name\": \"系统实现与运行\",\n",
      "      \"page\": \"256\",\n",
      "      \"entries\": [\n",
      "        {\n",
      "          \"entry_name\": \"软件实现\",\n",
      "          \"page\": \"256\"\n",
      "        },\n",
      "        {\n",
      "          \"entry_name\": \"软件测试\",\n",
      "          \"page\": \"259\"\n",
      "        },\n",
      "        {\n",
      "          \"entry_name\": \"白盒测试技术\",\n",
      "          \"page\": \"263\"\n",
      "        },\n",
      "        {\n",
      "          \"entry_name\": \"黑盒测试技术\",\n",
      "          \"page\": \"272\"\n",
      "        },\n",
      "        {\n",
      "          \"entry_name\": \"网络实现\",\n",
      "          \"page\": \"275\"\n",
      "        },\n",
      "        {\n",
      "          \"entry_name\": \"数据库实现\",\n",
      "          \"page\": \"275\"\n",
      "        },\n",
      "        {\n",
      "          \"entry_name\": \"系统转换\",\n",
      "          \"page\": \"276\"\n",
      "        },\n",
      "        {\n",
      "          \"entry_name\": \"系统运行与支持\",\n",
      "          \"page\": \"278\"\n",
      "        }\n",
      "      ]\n",
      "    },\n",
      "    {\n",
      "      \"chapter_name\": \"面向对象开发概述\",\n",
      "      \"page\": \"293\",\n",
      "      \"entries\": [\n",
      "        {\n",
      "          \"entry_name\": \"面向对象相关概念\",\n",
      "          \"page\": \"293\"\n",
      "        },\n",
      "        {\n",
      "          \"entry_name\": \"面向对象的特性\",\n",
      "          \"page\": \"295\"\n",
      "        },\n",
      "        {\n",
      "          \"entry_name\": \"面向对象开发的主要方法\",\n",
      "          \"page\": \"296\"\n",
      "        }\n",
      "      ]\n",
      "    },\n",
      "    {\n",
      "      \"chapter_name\": \"UML\",\n",
      "      \"page\": \"301\",\n",
      "      \"entries\": [\n",
      "        {\n",
      "          \"entry_name\": \"UML 概述\",\n",
      "          \"page\": \"301\"\n",
      "        },\n",
      "        {\n",
      "          \"entry_name\": \"用例图\",\n",
      "          \"page\": \"305\"\n",
      "        },\n",
      "        {\n",
      "          \"entry_name\": \"类图和对象图\",\n",
      "          \"page\": \"313\"\n",
      "        },\n",
      "        {\n",
      "          \"entry_name\": \"状态图\",\n",
      "          \"page\": \"323\"\n",
      "        },\n",
      "        {\n",
      "          \"entry_name\": \"活动图\",\n",
      "          \"page\": \"325\"\n",
      "        },\n",
      "        {\n",
      "          \"entry_name\": \"顺序图\",\n",
      "          \"page\": \"330\"\n",
      "        },\n",
      "        {\n",
      "          \"entry_name\": \"协作图\",\n",
      "          \"page\": \"334\"\n",
      "        },\n",
      "        {\n",
      "          \"entry_name\": \"组件图\",\n",
      "          \"page\": \"337\"\n",
      "        },\n",
      "        {\n",
      "          \"entry_name\": \"部署图\",\n",
      "          \"page\": \"340\"\n",
      "        },\n",
      "        {\n",
      "          \"entry_name\": \"包图\",\n",
      "          \"page\": \"342\"\n",
      "        }\n",
      "      ]\n",
      "    },\n",
      "    {\n",
      "      \"chapter_name\": \"面向对象需求理解\",\n",
      "      \"page\": \"347\",\n",
      "      \"entries\": [\n",
      "        {\n",
      "          \"entry_name\": \"基于 UML 的系统开发过程\",\n",
      "          \"page\": \"347\"\n",
      "        },\n",
      "        {\n",
      "          \"entry_name\": \"理解需求\",\n",
      "          \"page\": \"351\"\n",
      "        },\n",
      "        {\n",
      "          \"entry_name\": \"案例——电子培训系统的需求理解\",\n",
      "          \"page\": \"361\"\n",
      "        }\n",
      "      ]\n",
      "    },\n",
      "    {\n",
      "      \"chapter_name\": \"面向对象分析\",\n",
      "      \"page\": \"373\",\n",
      "      \"entries\": [\n",
      "        {\n",
      "          \"entry_name\": \"领域建模\",\n",
      "          \"page\": \"374\"\n",
      "        },\n",
      "        {\n",
      "          \"entry_name\": \"行为建模\",\n",
      "          \"page\": \"384\"\n",
      "        },\n",
      "        {\n",
      "          \"entry_name\": \"案例——网上商店客户订单处理系统分析\",\n",
      "          \"page\": \"388\"\n",
      "        }\n",
      "      ]\n",
      "    },\n",
      "    {\n",
      "      \"chapter_name\": \"面向对象设计\",\n",
      "      \"page\": \"400\",\n",
      "      \"entries\": [\n",
      "        {\n",
      "          \"entry_name\": \"系统设计与 UML\",\n",
      "          \"page\": \"400\"\n",
      "        },\n",
      "        {\n",
      "          \"entry_name\": \"通用职责分配软件模式\",\n",
      "          \"page\": \"404\"\n",
      "        },\n",
      "        {\n",
      "          \"entry_name\": \"类的设计\",\n",
      "          \"page\": \"410\"\n",
      "        },\n",
      "        {\n",
      "          \"entry_name\": \"接口设计\",\n",
      "          \"page\": \"415\"\n",
      "        },\n",
      "        {\n",
      "          \"entry_name\": \"包设计\",\n",
      "          \"page\": \"419\"\n",
      "        },\n",
      "        {\n",
      "          \"entry_name\": \"数据库设计\",\n",
      "          \"page\": \"423\"\n",
      "        }\n",
      "      ]\n",
      "    },\n",
      "    {\n",
      "      \"chapter_name\": \"面向对象实现\",\n",
      "      \"page\": \"432\",\n",
      "      \"entries\": [\n",
      "        {\n",
      "          \"entry_name\": \"设计映射到代码\",\n",
      "          \"page\": \"432\"\n",
      "        },\n",
      "        {\n",
      "          \"entry_name\": \"面向对象程序设计\",\n",
      "          \"page\": \"435\"\n",
      "        },\n",
      "        {\n",
      "          \"entry_name\": \"面向对象测试策略\",\n",
      "          \"page\": \"437\"\n",
      "        },\n",
      "        {\n",
      "          \"entry_name\": \"设计测试用例\",\n",
      "          \"page\": \"439\"\n",
      "        }\n",
      "      ]\n",
      "    }\n",
      "  ]\n",
      "}\n",
      "```\n"
     ]
    }
   ],
   "source": [
    "prompt = \"\"\"\n",
    "    在接下来的对话中，你需要遵循以下规则：\n",
    "    你是一台用于处理文本数据的AI系统。你的任务是处理我上传的文本文件，并按照以下要求进行操作：\n",
    "    - 输出标准JSON格式的切片结果。\n",
    "    - 剔除文件中的所有乱码（乱码不包括英文）。\n",
    "    - 处理英文的时候 请保留英文的原格式，包括括号。\n",
    "    - 根据你的判断，可以筛选无意义的、与目录无关的句子。但是要确保没有改变原意，保留了原本的信息量。\n",
    "    - 确保没有信息遗漏，不要缺省任何有效信息。\n",
    "    - 按照章节、小节，对内容进行切片，构建树状JSON结构，请确保你输出的JSON的格式规范。\n",
    "    - 请严格参考格式示例:\n",
    "    {\n",
    "      \"slices\": [\n",
    "        {\n",
    "      \"chapter_name\": \"(章节去除编号对应名称）\",\n",
    "      \"page\": \"（章节对应页码）\",\n",
    "      \"entries\": [\n",
    "        {\n",
    "          \"entry_name\": \"（小节去除编号对应名称）\",\n",
    "          \"page\": \"（小节对应页码）\",\n",
    "        }\n",
    "        {\n",
    "          \"entry_name\": \"（小节去除编号对应名称）\",\n",
    "          \"page\": \"（小节对应页码）\",\n",
    "        }\n",
    "      ]\n",
    "    },\n",
    "      ]\n",
    "    }\n",
    "    - 确保每一个条目都被完整地处理，不漏切片。\n",
    "    - 对chapter_name、entries中的属性，请不要带上任何标号性质的前缀，并对你提取到的名称进行概括\n",
    "    - 不要输出sub_entries\n",
    "    - 你不需要确认收到，请从第一条讯息开始，直接开始生成完整准确的输出，不允许输出json之外的内容\n",
    "    - 不要输出json格式之外的部分\n",
    "\"\"\"\n",
    "\n",
    "messages = [{'role': Role.SYSTEM, 'content': prompt},\n",
    "            {'role': Role.USER, 'content': request}]\n",
    "response = Generation.call(\n",
    "    Generation.Models.qwen_max_longcontext,\n",
    "    messages=messages,\n",
    "    result_format='message',  # set the result to be \"message\" format.\n",
    ")\n",
    "if response.status_code == HTTPStatus.OK:\n",
    "    # append result to messages.\n",
    "    raw_string=response.output.choices[0]['message']['content']\n",
    "    print(raw_string)\n",
    "    # 节点，边，页数，小节名称，章节名称\n",
    "    nodes_array,edges_array,pages_array,pages_part_array,chapter_name_array=indexstr2json(raw_string)\n",
    "else:\n",
    "    print('Request id: %s, Status code: %s, error code: %s, error message: %s' % (\n",
    "        response.request_id, response.status_code,\n",
    "        response.code, response.message\n",
    "    ))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**章节列表**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "46\n"
     ]
    }
   ],
   "source": [
    "# 检查LLM输出是否带有章节号，是否带有小节等会污染节点的内容\n",
    "part_array=copy.copy(nodes_array)\n",
    "print(len(part_array))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['信息系统开发概述',\n",
       " '信息系统开发路线、方法与工具',\n",
       " '信息系统项目管理',\n",
       " '需求获取',\n",
       " '过程建模',\n",
       " '数据建模',\n",
       " '应用架构设计',\n",
       " '软件过程设计',\n",
       " '数据库设计',\n",
       " '输出、输入与用户界面设计',\n",
       " '系统实现与运行',\n",
       " '面向对象开发概述',\n",
       " 'UML',\n",
       " '面向对象需求理解',\n",
       " '面向对象分析',\n",
       " '面向对象设计',\n",
       " '面向对象实现']"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 结果保存\n",
    "import pickle\n",
    "# 节点\n",
    "with open('node.pkl', 'wb') as f:\n",
    "    pickle.dump(nodes_array, f)\n",
    "# 边\n",
    "with open('edge.pkl', 'wb') as f:\n",
    "    pickle.dump(edges_array, f)\n",
    "# 报错日志\n",
    "with open('log.pkl', 'wb') as f:\n",
    "    pickle.dump(log, f)\n",
    "# 章节加小节列表\n",
    "with open('part_array.pkl', 'wb') as f:\n",
    "    pickle.dump(part_array, f)\n",
    "# 小节页数\n",
    "with open('pages_array.pkl', 'wb') as f:\n",
    "    pickle.dump(pages_array, f)\n",
    "# 小节列表\n",
    "with open('pages_part_array.pkl', 'wb') as f:\n",
    "    pickle.dump(pages_part_array, f)\n",
    "# 章节名称\n",
    "with open('chapter_name_array.pkl','wb')as f:\n",
    "    pickle.dump(chapter_name_array, f)\n",
    "# 章节与小节之间的边关系\n",
    "with open('chapter_edge_array.pkl','wb')as f:\n",
    "    pickle.dump(edges_array, f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['信息系统开发概述',\n",
       " '信息系统开发路线、方法与工具',\n",
       " '信息系统项目管理',\n",
       " '需求获取',\n",
       " '过程建模',\n",
       " '数据建模',\n",
       " '应用架构设计',\n",
       " '软件过程设计',\n",
       " '数据库设计',\n",
       " '输出、输入与用户界面设计',\n",
       " '系统实现与运行',\n",
       " '面向对象开发概述',\n",
       " 'UML',\n",
       " '面向对象需求理解',\n",
       " '面向对象分析',\n",
       " '面向对象设计',\n",
       " '面向对象实现']"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 如果页数过多，目录无法实现一次生成可以使用这个做分批处理\n",
    "import pickle\n",
    "with open('node.pkl', 'rb') as f:\n",
    "    nodes_array = pickle.load(f)+nodes_array\n",
    "with open('edge.pkl', 'rb') as f:\n",
    "    edges_array = pickle.load(f)+edges_array\n",
    "with open('log.pkl', 'rb') as f:\n",
    "    log = pickle.load(f)+log\n",
    "with open('part_array.pkl', 'rb') as f:\n",
    "    part_array = pickle.load(f)+part_array\n",
    "with open('pages_array.pkl', 'rb') as f:\n",
    "    pages_array = pickle.load(f)+pages_array\n",
    "with open('pages_part_array.pkl', 'rb') as f:\n",
    "    pages_part_array = pickle.load(f)+pages_part_array\n",
    "with open('chapter_name_array.pkl', 'rb') as f:\n",
    "    chapter_name_array = pickle.load(f)+chapter_name_array\n",
    "with open('chapter_edge_array.pkl', 'rb') as f:\n",
    "    chapter_edge_array=pickle.load(f)+edges_array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 重新加载\n",
    "import pickle\n",
    "with open('node.pkl', 'rb') as f:\n",
    "    nodes_array = pickle.load(f)\n",
    "with open('edge.pkl', 'rb') as f:\n",
    "    edges_array = pickle.load(f)\n",
    "with open('log.pkl', 'rb') as f:\n",
    "    log = pickle.load(f)\n",
    "with open('part_array.pkl', 'rb') as f:\n",
    "    part_array = pickle.load(f)\n",
    "with open('pages_array.pkl', 'rb') as f:\n",
    "    pages_array = pickle.load(f)\n",
    "with open('pages_part_array.pkl', 'rb') as f:\n",
    "    pages_part_array = pickle.load(f)\n",
    "with open('chapter_name_array.pkl', 'rb') as f:\n",
    "    chapter_name_array = pickle.load(f)\n",
    "with open('chapter_edge_array.pkl', 'rb') as f:\n",
    "    chapter_edge_array=pickle.load(f)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**对应页数**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 这段代码不能重复跑，pages_array需要重新生成\n",
    "\n",
    "# 对于一些目录页数不参与文件内页数的我们可以执行下面这两行\n",
    "# pages_array=[page+end_page for page in pages_array]\n",
    "# pages_array=sorted(pages_array)\n",
    "# 补充尾页信息\n",
    "# 打开 PDF 文件\n",
    "pdf_document = fitz.open(pdf_output_path)\n",
    "    # 获取总页数\n",
    "total_pages = pdf_document.page_count\n",
    "pages_array.append(total_pages)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **3.输入提示词设计**\n",
    "\n",
    "目标：指引大模型更好的利用资源优势实现按照固定格式的输出\n",
    "\n",
    "携带上下文：影响输出格式，输出很杂，会导致实体中有大段文本出现\n",
    "\n",
    "不携带上下文：不够细致\n",
    "\n",
    "改进方向：\n",
    "围绕目录信息，将章节内部信息给到大模型，让大模型去执行抽取任务"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "————————————第1章————————————\n",
      "{\n",
      "  \"point\": [\n",
      "    \"系统\",\n",
      "    \"系统的基本概念\",\n",
      "    \"系统的目标\",\n",
      "    \"系统的边界\",\n",
      "    \"构件\",\n",
      "    \"构件之间的关系\",\n",
      "    \"环境\",\n",
      "    \"接口\",\n",
      "    \"输入\",\n",
      "    \"输出\",\n",
      "    \"约束\",\n",
      "    \"信息系统\",\n",
      "    \"信息系统的创始人\",\n",
      "    \"Gordon B. Davis\",\n",
      "    \"信息系统定义\",\n",
      "    \"薛华成教授的观点\",\n",
      "    \"信息系统特征\",\n",
      "    \"人机信息系统\",\n",
      "    \"企业管理信息系统\",\n",
      "    \"信息技术\",\n",
      "    \"信息技术定义\",\n",
      "    \"信息和通信技术\",\n",
      "    \"信息技术的应用\",\n",
      "    \"计算机硬件和软件\",\n",
      "    \"网络和通讯技术\",\n",
      "    \"应用软件开发工具\",\n",
      "    \"信息系统在商业中的角色\",\n",
      "    \"基于信息技术的组织管理方案\",\n",
      "    \"信息技术体系结构\",\n",
      "    \"企业战略目标\",\n",
      "    \"系统方法\",\n",
      "    \"系统方法作为方法论\",\n",
      "    \"整体性\",\n",
      "    \"结构性\",\n",
      "    \"关联性\",\n",
      "    \"功能性\",\n",
      "    \"信息系统的功能结构\",\n",
      "    \"输入功能\",\n",
      "    \"存储功能\",\n",
      "    \"处理功能\",\n",
      "    \"输出功能\",\n",
      "    \"控制功能\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"系统\", \"属于\", \"系统的基本概念\"],\n",
      "    [\"系统的目标\", \"属于\", \"系统的基本概念\"],\n",
      "    [\"系统的目标\", \"是\", \"达到某种目的\"],\n",
      "    [\"系统的目标\", \"举例\", \"快餐店系统的主要目标\"],\n",
      "    [\"系统边界\", \"属于\", \"系统的基本概念\"],\n",
      "    [\"构件\", \"属于\", \"系统的基本概念\"],\n",
      "    [\"构件之间的关系\", \"属于\", \"系统的基本概念\"],\n",
      "    [\"环境\", \"属于\", \"系统的基本概念\"],\n",
      "    [\"接口\", \"属于\", \"系统的基本概念\"],\n",
      "    [\"输入\", \"属于\", \"系统的基本概念\"],\n",
      "    [\"输出\", \"属于\", \"系统的基本概念\"],\n",
      "    [\"约束\", \"属于\", \"系统的基本概念\"],\n",
      "    [\"信息系统\", \"属于\", \"信息系统的基本概念\"],\n",
      "    [\"Gordon B. Davis\", \"提出\", \"信息系统概念\"],\n",
      "    [\"信息系统定义\", \"由\", \"Gordon B. Davis 提出\"],\n",
      "    [\"薛华成教授的观点\", \"解释\", \"信息系统\"],\n",
      "    [\"人机信息系统\", \"属于\", \"信息系统\"],\n",
      "    [\"企业管理信息系统\", \"是\", \"信息系统的组成模块\"],\n",
      "    [\"信息技术\", \"属于\", \"信息系统的基本概念\"],\n",
      "    [\"信息技术定义\", \"描述\", \"信息技术\"],\n",
      "    [\"信息和通信技术\", \"等同于\", \"信息技术\"],\n",
      "    [\"信息技术的应用\", \"包括\", \"计算机硬件和软件\"],\n",
      "    [\"信息技术的应用\", \"包括\", \"网络和通讯技术\"],\n",
      "    [\"信息技术的应用\", \"包括\", \"应用软件开发工具\"],\n",
      "    [\"信息系统在商业中的角色\", \"是解决\", \"环境提出的挑战\"],\n",
      "    [\"基于信息技术的组织管理方案\", \"属于\", \"信息系统\"],\n",
      "    [\"信息技术体系结构\", \"包含\", \"管理成分\"],\n",
      "    [\"信息技术体系结构\", \"包含\", \"技术成分\"],\n",
      "    [\"系统方法\", \"用于理解\", \"系统组织方式及工作原理\"],\n",
      "    [\"整体性\", \"属于\", \"系统方法要点\"],\n",
      "    [\"结构性\", \"属于\", \"系统方法要点\"],\n",
      "    [\"关联性\", \"属于\", \"系统方法要点\"],\n",
      "    [\"功能性\", \"属于\", \"系统方法要点\"],\n",
      "    [\"信息系统的功能结构\", \"属于\", \"信息系统的基本概念\"],\n",
      "    [\"输入功能\", \"属于\", \"信息系统的功能结构\"],\n",
      "    [\"存储功能\", \"属于\", \"信息系统的功能结构\"],\n",
      "    [\"处理功能\", \"属于\", \"信息系统的功能结构\"],\n",
      "    [\"输出功能\", \"属于\", \"信息系统的功能结构\"],\n",
      "    [\"控制功能\", \"属于\", \"信息系统的功能结构\"]\n",
      "  ]\n",
      "}\n",
      "3151\n",
      "sleep:37.68447173840948秒\n",
      "————————————第2章————————————\n",
      "{\n",
      "  \"point\": [\n",
      "    \"信息系统的结构\",\n",
      "    \"信息系统功能结构\",\n",
      "    \"输入功能\",\n",
      "    \"存储功能\",\n",
      "    \"处理功能\",\n",
      "    \"输出功能\",\n",
      "    \"控制功能\",\n",
      "    \"信息系统的应用结构\",\n",
      "    \"市场子系统\",\n",
      "    \"财会子系统\",\n",
      "    \"人事子系统\",\n",
      "    \"生产子系统\",\n",
      "    \"供运子系统\",\n",
      "    \"战略层系统\",\n",
      "    \"管理层系统\",\n",
      "    \"知识层系统\",\n",
      "    \"操作层系统\",\n",
      "    \"信息系统的软件结构\",\n",
      "    \"功能-层次矩阵\",\n",
      "    \"事务处理信息系统\",\n",
      "    \"管理信息系统\",\n",
      "    \"办公自动化系统\",\n",
      "    \"知识工作系统\",\n",
      "    \"决策支持系统\",\n",
      "    \"经理信息系统\",\n",
      "    \"事务处理系统(TPS)\",\n",
      "    \"数据收集\",\n",
      "    \"数据编辑\",\n",
      "    \"数据修改\",\n",
      "    \"数据处理\",\n",
      "    \"数据存储\",\n",
      "    \"文档生成\",\n",
      "    \"超市销售终端系统(Point-of-Sales)\",\n",
      "    \"管理信息系统(MIS)\",\n",
      "    \"执行支持系统\",\n",
      "    \"决策支持系统(DSS)\",\n",
      "    \"专家系统\",\n",
      "    \"办公自动化信息系统(OAS)\",\n",
      "    \"工作流\",\n",
      "    \"协同工作\",\n",
      "    \"知识管理\",\n",
      "    \"公文处理\",\n",
      "    \"行政办公\",\n",
      "    \"知识工作系统(KWS)\",\n",
      "    \"计算机辅助设计(CAD)系统\",\n",
      "    \"虚拟现实系统(Virtual Reality System)\",\n",
      "    \"决策支持信息系统(DSS)\",\n",
      "    \"数据部分\",\n",
      "    \"模型部分\",\n",
      "    \"推理部分\",\n",
      "    \"人机交互部分\",\n",
      "    \"经理信息系统(EIS)\",\n",
      "    \"数据仓库\",\n",
      "    \"向下挖掘能力\",\n",
      "    \"灵活的数据表达形式\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"信息系统的功能结构\", \"属于\", \"信息系统的结构\"],\n",
      "    [\"输入功能\", \"属于\", \"信息系统的功能结构\"],\n",
      "    [\"存储功能\", \"属于\", \"信息系统的功能结构\"],\n",
      "    [\"处理功能\", \"属于\", \"信息系统的功能结构\"],\n",
      "    [\"输出功能\", \"属于\", \"信息系统的功能结构\"],\n",
      "    [\"控制功能\", \"属于\", \"信息系统的功能结构\"],\n",
      "    [\"信息系统的应用结构\", \"属于\", \"信息系统的结构\"],\n",
      "    [\"市场子系统\", \"属于\", \"信息系统的应用结构\"],\n",
      "    [\"财会子系统\", \"属于\", \"信息系统的应用结构\"],\n",
      "    [\"人事子系统\", \"属于\", \"信息系统的应用结构\"],\n",
      "    [\"生产子系统\", \"属于\", \"信息系统的应用结构\"],\n",
      "    [\"供运子系统\", \"属于\", \"信息系统的应用结构\"],\n",
      "    [\"战略层系统\", \"属于\", \"信息系统的应用结构(按照服务对象划分)\"],\n",
      "    [\"管理层系统\", \"属于\", \"信息系统的应用结构(按照服务对象划分)\"],\n",
      "    [\"知识层系统\", \"属于\", \"信息系统的应用结构(按照服务对象划分)\"],\n",
      "    [\"操作层系统\", \"属于\", \"信息系统的应用结构(按照服务对象划分)\"],\n",
      "    [\"信息系统的软件结构\", \"属于\", \"信息系统的结构\"],\n",
      "    [\"事务处理信息系统\", \"属于\", \"信息系统分类\"],\n",
      "    [\"管理信息系统(MIS)\", \"属于\", \"信息系统分类\"],\n",
      "    [\"办公自动化系统\", \"属于\", \"信息系统分类\"],\n",
      "    [\"知识工作系统\", \"属于\", \"信息系统分类\"],\n",
      "    [\"决策支持系统(DSS)\", \"属于\", \"信息系统分类\"],\n",
      "    [\"经理信息系统(EIS)\", \"属于\", \"信息系统分类\"],\n",
      "    [\"事务处理系统(TPS)\", \"属于\", \"信息系统分类\"],\n",
      "    [\"数据收集\", \"属于\", \"事务处理系统(TPS)的功能\"],\n",
      "    [\"数据编辑\", \"属于\", \"事务处理系统(TPS)的功能\"],\n",
      "    [\"数据修改\", \"属于\", \"事务处理系统(TPS)的功能\"],\n",
      "    [\"数据处理\", \"属于\", \"事务处理系统(TPS)的功能\"],\n",
      "    [\"数据存储\", \"属于\", \"事务处理系统(TPS)的功能\"],\n",
      "    [\"文档生成\", \"属于\", \"事务处理系统(TPS)的功能\"]\n",
      "  ]\n",
      "}\n",
      "5234\n",
      "sleep:37.102125037779146秒\n",
      "————————————第3章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"信息系统开发过程\",\n",
      "    \"系统规划\",\n",
      "    \"组织战略规划的组成部分\",\n",
      "    \"信息系统规划的主要目标\",\n",
      "    \"明确系统整个生命周期内的发展方向、系统规模和开发计划\",\n",
      "    \"组建信息系统项目团队\",\n",
      "    \"指导委员会（信息化领导小组）\",\n",
      "    \"项目开发小组\",\n",
      "    \"确定信息系统项目优先顺序\",\n",
      "    \"环境评价和初步调查\",\n",
      "    \"业务愿景\",\n",
      "    \"信息系统项目的范围\",\n",
      "    \"特定项目计划\",\n",
      "    \"进度安排\",\n",
      "    \"资源分配\",\n",
      "    \"项目成本控制\",\n",
      "    \"项目质量控制\",\n",
      "    \"信息系统项目范围\",\n",
      "    \"项目活动开展\",\n",
      "    \"项目启动大会\",\n",
      "    \"项目背景\",\n",
      "    \"目标和远景\",\n",
      "    \"项目组织结构、角色及其职责\",\n",
      "    \"沟通计划\",\n",
      "    \"项目范围结构化\",\n",
      "    \"项目全景图\",\n",
      "    \"主要业务过程描述\",\n",
      "    \"项目计划\",\n",
      "    \"里程碑\",\n",
      "    \"关键路径\",\n",
      "    \"重点阶段内容\",\n",
      "    \"PDSP项目定义的软件过程\",\n",
      "    \"风险和问题管理办法\",\n",
      "    \"系统分析\",\n",
      "    \"需求理解与确定\",\n",
      "    \"现行系统详细调查\",\n",
      "    \"组织结构与功能分析\",\n",
      "    \"业务流程和数据流分析\",\n",
      "    \"新系统的逻辑需求\",\n",
      "    \"逻辑方案建立\",\n",
      "    \"需求表达与结构化\",\n",
      "    \"需求说明书\",\n",
      "    \"系统设计\",\n",
      "    \"技术蓝图设计\",\n",
      "    \"体系架构设计\",\n",
      "    \"子系统功能划分\",\n",
      "    \"信息系统环境配置\",\n",
      "    \"详细设计\",\n",
      "    \"数据库设计\",\n",
      "    \"代码设计\",\n",
      "    \"输入输出设计\",\n",
      "    \"用户界面设计\",\n",
      "    \"系统设计说明书\",\n",
      "    \"体系架构设计的任务\",\n",
      "    \"选择应用体系模式\",\n",
      "    \"模块化\",\n",
      "    \"详细设计任务\",\n",
      "    \"算法和数据结构设计\",\n",
      "    \"数据库设计的内容\",\n",
      "    \"输入输出及界面设计\",\n",
      "    \"代码设计的目的\",\n",
      "    \"系统实现\",\n",
      "    \"软硬件环境配置\",\n",
      "    \"开发环境及工具选择\",\n",
      "    \"编程与测试\",\n",
      "    \"网络、数据库建立与测试\",\n",
      "    \"用户培训\",\n",
      "    \"数据转换\",\n",
      "    \"系统交接\",\n",
      "    \"可运行的系统\",\n",
      "    \"系统转换管理\",\n",
      "    \"用户方独立承担维护工作\",\n",
      "    \"系统全面移交\",\n",
      "    \"系统维护\",\n",
      "    \"日常维护\",\n",
      "    \"新需求满足\",\n",
      "    \"技术支持\",\n",
      "    \"运行情况监控\",\n",
      "    \"问题解决\",\n",
      "    \"系统改进与完善\",\n",
      "    \"系统日常维护制度\",\n",
      "    \"系统维护人员培训\",\n",
      "    \"新业务需求实现\",\n",
      "    \"SDLC各阶段交付成果\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"系统规划\", \"属于\", \"信息系统开发过程\"],\n",
      "    [\"组织战略规划的组成部分\", \"属于\", \"系统规划\"],\n",
      "    [\"信息系统规划的主要目标\", \"属于\", \"系统规划\"],\n",
      "    [\"组建信息系统项目团队\", \"属于\", \"系统规划\"],\n",
      "    [\"确定信息系统项目优先顺序\", \"属于\", \"系统规划\"],\n",
      "    [\"环境评价和初步调查\", \"属于\", \"确定信息系统项目优先顺序\"],\n",
      "    [\"业务愿景\", \"属于\", \"确定信息系统项目优先顺序\"],\n",
      "    [\"信息系统项目的范围\", \"属于\", \"确定信息系统项目优先顺序\"],\n",
      "    [\"项目启动大会\", \"属于\", \"系统规划\"],\n",
      "    [\"系统分析\", \"属于\", \"信息系统开发过程\"],\n",
      "    [\"需求理解与确定\", \"属于\", \"系统分析\"],\n",
      "    [\"需求表达与结构化\", \"属于\", \"系统分析\"],\n",
      "    [\"系统设计\", \"属于\", \"信息系统开发过程\"],\n",
      "    [\"体系架构设计\", \"属于\", \"系统设计\"],\n",
      "    [\"详细设计\", \"属于\", \"系统设计\"],\n",
      "    [\"系统实现\", \"属于\", \"信息系统开发过程\"],\n",
      "    [\"编程与测试\", \"属于\", \"系统实现\"],\n",
      "    [\"系统转换\", \"属于\", \"系统实现\"],\n",
      "    [\"系统维护\", \"属于\", \"信息系统开发过程\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "3877\n",
      "sleep:38.26388308459153秒\n",
      "————————————第4章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"系统维护\",\n",
      "    \"日常维护\",\n",
      "    \"新需求满足\",\n",
      "    \"技术支持\",\n",
      "    \"信息系统项目规划书\",\n",
      "    \"需求结构化\",\n",
      "    \"信息系统需求说明书\",\n",
      "    \"体系结构设计\",\n",
      "    \"详细设计\",\n",
      "    \"应用架构设计\",\n",
      "    \"功能模块设计\",\n",
      "    \"数据库设计\",\n",
      "    \"输入输出和用户界面设计\",\n",
      "    \"代码设计\",\n",
      "    \"信息系统设计说明书\",\n",
      "    \"网络组建与测试\",\n",
      "    \"数据库建立与测试\",\n",
      "    \"编程与测试\",\n",
      "    \"系统切换\",\n",
      "    \"用户培训\",\n",
      "    \"运行维护阶段交付成果\",\n",
      "    \"可以运行的系统\",\n",
      "    \"程序代码及文档\",\n",
      "    \"培训文档\",\n",
      "    \"用户使用说明书\",\n",
      "    \"变更的程序代码和文档\",\n",
      "    \"维护说明书\",\n",
      "    \"信息系统的相关角色\",\n",
      "    \"开发方\",\n",
      "    \"用户\",\n",
      "    \"系统所有者\",\n",
      "    \"管理阶层\",\n",
      "    \"业务价值\",\n",
      "    \"成本与收益权衡\",\n",
      "    \"信息系统用户\",\n",
      "    \"内部信息系统用户\",\n",
      "    \"外部信息系统用户\",\n",
      "    \"办事员和服务人员\",\n",
      "    \"技术人员和专业人员\",\n",
      "    \"主管\",\n",
      "    \"中层经理\",\n",
      "    \"高层经理\",\n",
      "    \"顾客\",\n",
      "    \"供应商\",\n",
      "    \"合作伙伴\",\n",
      "    \"雇员\",\n",
      "    \"远程和移动用户\",\n",
      "    \"事务处理速度和正确性\",\n",
      "    \"数据分析\",\n",
      "    \"信息系统设计员\",\n",
      "    \"技术方案\",\n",
      "    \"计算机文件\",\n",
      "    \"数据库\",\n",
      "    \"输入输出\",\n",
      "    \"屏幕界面\",\n",
      "    \"网络\",\n",
      "    \"程序设计\",\n",
      "    \"信息系统构造人员\",\n",
      "    \"信息系统构件搭建\",\n",
      "    \"网络搭建\",\n",
      "    \"数据库安装\",\n",
      "    \"软件安装\",\n",
      "    \"程序编写\",\n",
      "    \"应用程序员\",\n",
      "    \"系统程序员\",\n",
      "    \"数据库程序员\",\n",
      "    \"网络管理员\",\n",
      "    \"安全管理员\",\n",
      "    \"web 站点管理员\",\n",
      "    \"软件集成员\",\n",
      "    \"信息系统分析员\",\n",
      "    \"业务问题研究\",\n",
      "    \"信息需求转换\",\n",
      "    \"规格说明\",\n",
      "    \"分析技能\",\n",
      "    \"技术技能\",\n",
      "    \"管理技能\",\n",
      "    \"人际关系技能\",\n",
      "    \"项目经理\",\n",
      "    \"项目团队组建\",\n",
      "    \"任务分派\",\n",
      "    \"资源管理\",\n",
      "    \"高效完成项目目标\",\n",
      "    \"人际沟通\",\n",
      "    \"领导力\",\n",
      "    \"沟通能力\",\n",
      "    \"客户关系管理\",\n",
      "    \"解决技术问题\",\n",
      "    \"冲突管理\",\n",
      "    \"团队管理\",\n",
      "    \"风险和变更管理\",\n",
      "    \"信息系统各种角色比较\",\n",
      "    \"费用\",\n",
      "    \"效果\",\n",
      "    \"价值\",\n",
      "    \"易学易用性\",\n",
      "    \"IT 选择\",\n",
      "    \"信息系统实现的技术问题\",\n",
      "    \"组织存在的问题和需求\",\n",
      "    \"协调与管理\",\n",
      "    \"进度安排\",\n",
      "    \"预算\",\n",
      "    \"客户满意度\",\n",
      "    \"技术标准\",\n",
      "    \"信息系统质量\",\n",
      "    \"计划监视控制项目\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"系统维护\", \"属于\", \"运行维护阶段\"],\n",
      "    [\"日常维护\", \"属于\", \"系统维护\"],\n",
      "    [\"新需求满足\", \"属于\", \"系统维护\"],\n",
      "    [\"技术支持\", \"属于\", \"系统维护\"],\n",
      "    [\"信息系统项目规划书\", \"属于\", \"规划阶段交付成果\"],\n",
      "    [\"需求结构化\", \"属于\", \"分析阶段\"],\n",
      "    [\"信息系统需求说明书\", \"属于\", \"分析阶段交付成果\"],\n",
      "    [\"体系结构设计\", \"属于\", \"设计阶段\"],\n",
      "    [\"详细设计\", \"属于\", \"设计阶段\"],\n",
      "    [\"应用架构设计\", \"属于\", \"设计阶段\"],\n",
      "    [\"功能模块设计\", \"属于\", \"设计阶段\"],\n",
      "    [\"数据库设计\", \"属于\", \"设计阶段\"],\n",
      "    [\"输入输出和用户界面设计\", \"属于\", \"设计阶段\"],\n",
      "    [\"代码设计\", \"属于\", \"设计阶段\"],\n",
      "    [\"信息系统设计说明书\", \"属于\", \"设计阶段交付成果\"],\n",
      "    [\"网络组建与测试\", \"属于\", \"实现阶段\"],\n",
      "    [\"数据库建立与测试\", \"属于\", \"实现阶段\"],\n",
      "    [\"编程与测试\", \"属于\", \"实现阶段\"],\n",
      "    [\"系统切换\", \"属于\", \"实现阶段\"],\n",
      "    [\"用户培训\", \"属于\", \"实现阶段\"],\n",
      "    [\"运行维护阶段交付成果\", \"包括\", \"变更的程序代码和文档\"],\n",
      "    [\"运行维护阶段交付成果\", \"包括\", \"维护说明书\"],\n",
      "    [\"系统所有者\", \"属于\", \"信息系统的相关角色\"],\n",
      "    [\"管理阶层\", \"属于\", \"系统所有者的来源\"],\n",
      "    [\"业务价值\", \"关注于\", \"系统所有者\"],\n",
      "    [\"成本与收益权衡\", \"关注于\", \"系统所有者\"],\n",
      "    [\"信息系统用户\", \"属于\", \"信息系统的相关角色\"],\n",
      "    [\"内部信息系统用户\", \"属于\", \"信息系统用户\"],\n",
      "    [\"外部信息系统用户\", \"属于\", \"信息系统用户\"],\n",
      "    [\"办事员和服务人员\", \"属于\", \"内部信息系统用户\"],\n",
      "    [\"技术人员和专业人员\", \"属于\", \"内部信息系统用户\"],\n",
      "    [\"主管\", \"属于\", \"内部信息系统用户\"],\n",
      "    [\"中层经理\", \"属于\", \"内部信息系统用户\"],\n",
      "    [\"高层经理\", \"属于\", \"内部信息系统用户\"],\n",
      "    [\"信息系统设计员\", \"属于\", \"信息系统的相关角色\"],\n",
      "    [\"技术方案\", \"由\", \"信息系统设计员\"],\n",
      "    [\"信息系统构造人员\", \"属于\", \"信息系统的相关角色\"],\n",
      "    [\"信息系统构件搭建\", \"由\", \"信息系统构造人员\"],\n",
      "    [\"信息系统分析员\", \"属于\", \"信息系统的相关角色\"],\n",
      "    [\"业务问题研究\", \"由\", \"信息系统分析员\"],\n",
      "    [\"规格说明\", \"由\", \"信息系统分析员生成\"],\n",
      "    [\"项目经理\", \"属于\", \"信息系统的相关角色\"],\n",
      "    [\"项目团队组建\", \"由\", \"项目经理\"],\n",
      "    [\"任务分派\", \"由\", \"项目经理\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "3646\n",
      "sleep:38.557286945105815秒\n",
      "————————————第5章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"信息系统\",\n",
      "    \"用户\",\n",
      "    \"使用信息系统\",\n",
      "    \"功能\",\n",
      "    \"易学易用性\",\n",
      "    \"业务需求\",\n",
      "    \"办事员\",\n",
      "    \"事务处理正确性\",\n",
      "    \"速度\",\n",
      "    \"主管和经理\",\n",
      "    \"数据分析\",\n",
      "    \"解决问题能力\",\n",
      "    \"信息系统设计员\",\n",
      "    \"业务需求转换\",\n",
      "    \"技术方案\",\n",
      "    \"IT 选择\",\n",
      "    \"IT 设计\",\n",
      "    \"信息系统构造人员\",\n",
      "    \"信息系统构件\",\n",
      "    \"信息系统实现\",\n",
      "    \"技术问题\",\n",
      "    \"信息系统分析员\",\n",
      "    \"组织职能理解\",\n",
      "    \"开发过程中的问题解决\",\n",
      "    \"项目经理\",\n",
      "    \"项目组领导\",\n",
      "    \"开发任务完成\",\n",
      "    \"进度安排\",\n",
      "    \"预算\",\n",
      "    \"客户满意度\",\n",
      "    \"技术标准\",\n",
      "    \"信息系统质量\",\n",
      "    \"计划、监视、控制项目\",\n",
      "    \"本章小结\",\n",
      "    \"信息系统开发的整体框架\",\n",
      "    \"主要过程\",\n",
      "    \"项目管理过程\",\n",
      "    \"主要角色\",\n",
      "    \"工具方法与技术\",\n",
      "    \"信息系统分析与设计\",\n",
      "    \"组织过程\",\n",
      "    \"计算机支持的信息系统\",\n",
      "    \"开发与维护\",\n",
      "    \"信息系统类型\",\n",
      "    \"事务处理信息系统\",\n",
      "    \"管理信息系统\",\n",
      "    \"决策支持信息系统\",\n",
      "    \"信息系统开发生命周期(SDLC)\",\n",
      "    \"规划阶段\",\n",
      "    \"分析阶段\",\n",
      "    \"设计阶段\",\n",
      "    \"实施阶段\",\n",
      "    \"维护阶段\",\n",
      "    \"案例分析\",\n",
      "    \"校园二手书交易平台\",\n",
      "    \"系统需求分析\",\n",
      "    \"二手书店\",\n",
      "    \"旧书分类\",\n",
      "    \"藏书\",\n",
      "    \"教辅书\",\n",
      "    \"过期期刊\",\n",
      "    \"C2B2C 业务模式\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"用户\", \"属于\", \"信息系统\"],\n",
      "    [\"办事员\", \"关注\", \"事务处理正确性\"],\n",
      "    [\"办事员\", \"关注\", \"速度\"],\n",
      "    [\"主管和经理\", \"关注\", \"数据分析\"],\n",
      "    [\"主管和经理\", \"关注\", \"解决问题能力\"],\n",
      "    [\"信息系统设计员\", \"将\", \"业务需求转换\"],\n",
      "    [\"信息系统设计员\", \"关注\", \"IT 选择\"],\n",
      "    [\"信息系统设计员\", \"关注\", \"IT 设计\"],\n",
      "    [\"信息系统构造人员\", \"根据\", \"信息系统设计人员的设计说明\"],\n",
      "    [\"信息系统构造人员\", \"关注\", \"信息系统实现的技术问题\"],\n",
      "    [\"信息系统分析员\", \"理解\", \"组织及其职能\"],\n",
      "    [\"信息系统分析员\", \"关注\", \"组织存在的问题和需求\"],\n",
      "    [\"项目经理\", \"领导\", \"项目组成员\"],\n",
      "    [\"项目经理\", \"关注\", \"进度安排\"],\n",
      "    [\"项目经理\", \"关注\", \"预算\"],\n",
      "    [\"项目经理\", \"关注\", \"客户满意度\"],\n",
      "    [\"项目经理\", \"关注\", \"技术标准\"],\n",
      "    [\"项目经理\", \"关注\", \"信息系统质量\"],\n",
      "    [\"项目经理\", \"关注\", \"计划、监视、控制项目\"],\n",
      "    [\"信息系统开发生命周期(SDLC)\", \"分为\", \"规划阶段\"],\n",
      "    [\"信息系统开发生命周期(SDLC)\", \"分为\", \"分析阶段\"],\n",
      "    [\"信息系统开发生命周期(SDLC)\", \"分为\", \"设计阶段\"],\n",
      "    [\"信息系统开发生命周期(SDLC)\", \"分为\", \"实施阶段\"],\n",
      "    [\"信息系统开发生命周期(SDLC)\", \"分为\", \"维护阶段\"],\n",
      "    [\"本章小结\", \"涵盖\", \"信息系统开发的主要过程\"],\n",
      "    [\"本章小结\", \"涵盖\", \"项目管理过程\"],\n",
      "    [\"本章小结\", \"涵盖\", \"主要角色\"],\n",
      "    [\"本章小结\", \"涵盖\", \"工具方法与技术\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "1604\n",
      "sleep:37.88468915256394秒\n",
      "————————————第6章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"案例分析——校园二手书交易平台的设计与实现\",\n",
      "    \"系统需求分析\",\n",
      "    \"业务流程分析\",\n",
      "    \"系统设计\",\n",
      "    \"系统实现\",\n",
      "    \"用户管理模块\",\n",
      "    \"商品管理模块\",\n",
      "    \"订单管理模块\",\n",
      "    \"预约管理模块\",\n",
      "    \"系统设置模块\",\n",
      "    \"管理员设置模块\",\n",
      "    \"分类管理模块\",\n",
      "    \"登录模块\",\n",
      "    \"学院表\",\n",
      "    \"宿舍表\",\n",
      "    \"系统信息表\",\n",
      "    \"商品详细表\",\n",
      "    \"商品实体表\",\n",
      "    \"用户表\",\n",
      "    \"订单表\",\n",
      "    \"预约表\",\n",
      "    \"预约单明细表\",\n",
      "    \"管理员表\",\n",
      "    \"三层架构\",\n",
      "    \"BLL（业务逻辑层）\",\n",
      "    \"DAL（数据访问层）\",\n",
      "    \"表示层\",\n",
      "    \"ASP.NET Web Form\",\n",
      "    \"C#编程\",\n",
      "    \"LINQ技术\",\n",
      "    \"数据库设计\",\n",
      "    \"ERD设计\",\n",
      "    \"CSS界面设计\",\n",
      "    \"AJAX技术\",\n",
      "    \"纯CSS实现下拉列表功能\",\n",
      "    \"分类树状递归输出\",\n",
      "    \"LINQ实现数据库操作\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"系统需求分析\", \"属于\", \"案例分析——校园二手书交易平台的设计与实现\"],\n",
      "    [\"业务流程分析\", \"属于\", \"案例分析——校园二手书交易平台的设计与实现\"],\n",
      "    [\"系统设计\", \"属于\", \"案例分析——校园二手书交易平台的设计与实现\"],\n",
      "    [\"系统实现\", \"属于\", \"案例分析——校园二手书交易平台的设计与实现\"],\n",
      "    [\"用户管理模块\", \"属于\", \"系统设计\"],\n",
      "    [\"商品管理模块\", \"属于\", \"系统设计\"],\n",
      "    [\"订单管理模块\", \"属于\", \"系统设计\"],\n",
      "    [\"预约管理模块\", \"属于\", \"系统设计\"],\n",
      "    [\"系统设置模块\", \"属于\", \"系统设计\"],\n",
      "    [\"管理员设置模块\", \"属于\", \"系统设计\"],\n",
      "    [\"分类管理模块\", \"属于\", \"系统设计\"],\n",
      "    [\"登录模块\", \"属于\", \"系统设计\"],\n",
      "    [\"学院表\", \"属于\", \"数据库设计\"],\n",
      "    [\"宿舍表\", \"属于\", \"数据库设计\"],\n",
      "    [\"系统信息表\", \"属于\", \"数据库设计\"],\n",
      "    [\"商品详细表\", \"属于\", \"数据库设计\"],\n",
      "    [\"商品实体表\", \"属于\", \"数据库设计\"],\n",
      "    [\"用户表\", \"属于\", \"数据库设计\"],\n",
      "    [\"订单表\", \"属于\", \"数据库设计\"],\n",
      "    [\"预约表\", \"属于\", \"数据库设计\"],\n",
      "    [\"预约单明细表\", \"属于\", \"数据库设计\"],\n",
      "    [\"管理员表\", \"属于\", \"数据库设计\"],\n",
      "    [\"三层架构\", \"用于\", \"系统实现\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "10930\n",
      "sleep:37.91836573344718秒\n",
      "————————————第7章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"信息系统开发路线概述\",\n",
      "    \"信息系统开发是一个庞大的系统工程\",\n",
      "    \"科学的开发方法和过程化的开发步骤\",\n",
      "    \"信息系统开发方法学\",\n",
      "    \"开发规律\",\n",
      "    \"开发过程的认知体系\",\n",
      "    \"分析设计的一般理论\",\n",
      "    \"具体的开发工具和技术\",\n",
      "    \"信息系统开发路线的选择依据\",\n",
      "    \"系统开发的目标\",\n",
      "    \"资源\",\n",
      "    \"成本\",\n",
      "    \"典型的信息系统开发路线\",\n",
      "    \"模型驱动开发路线\",\n",
      "    \"可视化分析与设计\",\n",
      "    \"模型在业务与 IT 工作流程中的作用\",\n",
      "    \"导出相应代码\",\n",
      "    \"面向过程方法（Process Oriented）\",\n",
      "    \"数据流图\",\n",
      "    \"实体关系图\",\n",
      "    \"面向数据方法（Data Oriented）\",\n",
      "    \"信息模型\",\n",
      "    \"全企业共享数据库\",\n",
      "    \"面向对象的方法（Object Oriented）\",\n",
      "    \"对象类\",\n",
      "    \"结构化系统开发方法（SSAD）\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"信息系统开发路线概述\", \"属于\", \"第 2 章 信息系统开发路线、方法与工具\"],\n",
      "    [\"信息系统开发是一个庞大的系统工程\", \"属于\", \"信息系统开发路线概述\"],\n",
      "    [\"科学的开发方法和过程化的开发步骤\", \"属于\", \"信息系统开发路线概述\"],\n",
      "    [\"信息系统开发方法学\", \"属于\", \"信息系统开发路线概述\"],\n",
      "    [\"开发规律\", \"属于\", \"信息系统开发方法学\"],\n",
      "    [\"开发过程的认知体系\", \"属于\", \"信息系统开发方法学\"],\n",
      "    [\"分析设计的一般理论\", \"属于\", \"信息系统开发方法学\"],\n",
      "    [\"具体的开发工具和技术\", \"属于\", \"信息系统开发方法学\"],\n",
      "    [\"信息系统开发路线的选择依据\", \"属于\", \"信息系统开发路线概述\"],\n",
      "    [\"系统开发的目标\", \"属于\", \"信息系统开发路线的选择依据\"],\n",
      "    [\"资源\", \"属于\", \"信息系统开发路线的选择依据\"],\n",
      "    [\"成本\", \"属于\", \"信息系统开发路线的选择依据\"],\n",
      "    [\"典型的信息系统开发路线\", \"属于\", \"第 2 章 信息系统开发路线、方法与工具\"],\n",
      "    [\"模型驱动开发路线\", \"属于\", \"第 2 章 信息系统开发路线、方法与工具\"],\n",
      "    [\"可视化分析与设计\", \"属于\", \"模型驱动开发路线\"],\n",
      "    [\"模型在业务与 IT 工作流程中的作用\", \"属于\", \"模型驱动开发路线\"],\n",
      "    [\"导出相应代码\", \"属于\", \"模型驱动开发路线\"],\n",
      "    [\"面向过程方法（Process Oriented）\", \"属于\", \"模型驱动开发路线\"],\n",
      "    [\"数据流图\", \"属于\", \"面向过程方法（Process Oriented）\"],\n",
      "    [\"实体关系图\", \"属于\", \"面向过程方法（Process Oriented）\"],\n",
      "    [\"面向数据方法（Data Oriented）\", \"属于\", \"模型驱动开发路线\"],\n",
      "    [\"信息模型\", \"属于\", \"面向数据方法（Data Oriented）\"],\n",
      "    [\"全企业共享数据库\", \"属于\", \"面向数据方法（Data Oriented）\"],\n",
      "    [\"面向对象的方法（Object Oriented）\", \"属于\", \"模型驱动开发路线\"],\n",
      "    [\"对象类\", \"属于\", \"面向对象的方法（Object Oriented）\"],\n",
      "    [\"结构化系统开发方法（SSAD）\", \"属于\", \"面向过程方法\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "1857\n",
      "sleep:37.79446798876179秒\n",
      "————————————第8章————————————\n",
      "{\n",
      "  \"point\": [\n",
      "    \"模型驱动开发路线\",\n",
      "    \"面向过程方法\",\n",
      "    \"结构化系统开发方法（SSAD）\",\n",
      "    \"数据流程图\",\n",
      "    \"实体关系图\",\n",
      "    \"系统分析模型\",\n",
      "    \"设计模型\",\n",
      "    \"关系数据库\",\n",
      "    \"面向数据方法\",\n",
      "    \"信息工程方法\",\n",
      "    \"数据驱动\",\n",
      "    \"业务驱动\",\n",
      "    \"企业规划\",\n",
      "    \"业务域分析\",\n",
      "    \"系统设计\",\n",
      "    \"构造\",\n",
      "    \"面向对象方法\",\n",
      "    \"统一建模语言（UML）\",\n",
      "    \"封装性\",\n",
      "    \"继承性\",\n",
      "    \"多态性\",\n",
      "    \"快速应用开发路线（RAD）\",\n",
      "    \"迭代式开发\",\n",
      "    \"敏捷式开发\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"面向过程方法\", \"属于\", \"模型驱动开发路线\"],\n",
      "    [\"结构化系统开发方法（SSAD）\", \"属于\", \"面向过程方法\"],\n",
      "    [\"数据流程图\", \"属于\", \"结构化系统开发方法（SSAD）\"],\n",
      "    [\"实体关系图\", \"属于\", \"结构化系统开发方法（SSAD）\"],\n",
      "    [\"系统分析模型\", \"导出自\", \"结构化系统开发方法（SSAD）\"],\n",
      "    [\"设计模型\", \"转换为\", \"系统分析模型\"],\n",
      "    [\"面向数据方法\", \"属于\", \"模型驱动开发路线\"],\n",
      "    [\"信息工程方法\", \"属于\", \"面向数据方法\"],\n",
      "    [\"数据驱动\", \"属于\", \"信息工程方法\"],\n",
      "    [\"业务驱动\", \"属于\", \"信息工程方法\"],\n",
      "    [\"企业规划\", \"阶段属于\", \"信息工程方法\"],\n",
      "    [\"业务域分析\", \"阶段属于\", \"信息工程方法\"],\n",
      "    [\"系统设计\", \"阶段属于\", \"信息工程方法\"],\n",
      "    [\"构造\", \"阶段属于\", \"信息工程方法\"],\n",
      "    [\"面向对象方法\", \"属于\", \"模型驱动开发路线\"],\n",
      "    [\"统一建模语言（UML）\", \"与\", \"面向对象方法\"],\n",
      "    [\"封装性\", \"特征属于\", \"面向对象方法\"],\n",
      "    [\"继承性\", \"特征属于\", \"面向对象方法\"],\n",
      "    [\"多态性\", \"特征属于\", \"面向对象方法\"],\n",
      "    [\"快速应用开发路线（RAD）\", \"属于\", \"模型驱动开发路线\"],\n",
      "    [\"迭代式开发\", \"开发方式属于\", \"快速应用开发路线（RAD）\"],\n",
      "    [\"敏捷式开发\", \"开发方式属于\", \"快速应用开发路线（RAD）\"]\n",
      "  ]\n",
      "}\n",
      "4533\n",
      "sleep:38.76363740442803秒\n",
      "————————————第9章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"快速应用开发路线\",\n",
      "    \"Rapid Application Development (RAD)\",\n",
      "    \"用户深入参与\",\n",
      "    \"系统工作原型\",\n",
      "    \"目标系统\",\n",
      "    \"研讨会\",\n",
      "    \"系统所有者\",\n",
      "    \"用户\",\n",
      "    \"分析员\",\n",
      "    \"设计人员\",\n",
      "    \"构造人员\",\n",
      "    \"迭代的构造方法\",\n",
      "    \"需求分析阶段\",\n",
      "    \"设计阶段\",\n",
      "    \" CASE 工具\",\n",
      "    \"JAD 会议\",\n",
      "    \"可视化编程语言\",\n",
      "    \"编码\",\n",
      "    \"实施过程\",\n",
      "    \"迭代式开发\",\n",
      "    \"敏捷式开发\",\n",
      "    \"原型法\",\n",
      "    \"探索型原型\",\n",
      "    \"实验型原型\",\n",
      "    \"演化型原型\",\n",
      "    \"识别基本需求\",\n",
      "    \"设计初始原型\",\n",
      "    \"原型评价与反馈\",\n",
      "    \"技术蓝图\",\n",
      "    \"修订和提高原型\",\n",
      "    \"敏捷开发\",\n",
      "    \"极限编程(XP)\",\n",
      "    \"Scrum\",\n",
      "    \"水晶方法(Crystal Methods)\",\n",
      "    \"特征驱动开发(FDD)\",\n",
      "    \"自适应软件开发(ASD)\",\n",
      "    \"动态系统开发方法(DSDM)\",\n",
      "    \"计划\",\n",
      "    \"简单设计\",\n",
      "    \"编程\",\n",
      "    \"测试\",\n",
      "    \"商用软件包开发路线\",\n",
      "    \"商用应用软件包\",\n",
      "    \"封装式软件方案\",\n",
      "    \"购买现成商用软件\",\n",
      "    \"技术市场调研\",\n",
      "    \"供应商提交建议方案\",\n",
      "    \"需求方案说明书(RFP)\",\n",
      "    \"差距分析\",\n",
      "    \"附加软件需求\",\n",
      "    \"新增软件需求\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"快速应用开发路线\", \"属于\", \"系统开发策略\"],\n",
      "    [\"用户深入参与\", \"属于\", \"快速应用开发路线\"],\n",
      "    [\"系统工作原型\", \"属于\", \"快速应用开发路线\"],\n",
      "    [\"目标系统\", \"属于\", \"快速应用开发路线\"],\n",
      "    [\"研讨会\", \"属于\", \"快速应用开发路线\"],\n",
      "    [\"CASE 工具\", \"属于\", \"快速应用开发路线\"],\n",
      "    [\"JAD 会议\", \"属于\", \"快速应用开发路线\"],\n",
      "    [\"可视化编程语言\", \"属于\", \"快速应用开发路线\"],\n",
      "    [\"迭代式开发\", \"属于\", \"快速应用开发路线\"],\n",
      "    [\"敏捷式开发\", \"属于\", \"快速应用开发路线\"],\n",
      "    [\"探索型原型\", \"属于\", \"原型法\"],\n",
      "    [\"实验型原型\", \"属于\", \"原型法\"],\n",
      "    [\"演化型原型\", \"属于\", \"原型法\"],\n",
      "    [\"识别基本需求\", \"属于\", \"迭代式开发\"],\n",
      "    [\"设计初始原型\", \"属于\", \"迭代式开发\"],\n",
      "    [\"原型评价与反馈\", \"属于\", \"迭代式开发\"],\n",
      "    [\"修订和提高原型\", \"属于\", \"迭代式开发\"],\n",
      "    [\"敏捷开发\", \"属于\", \"系统开发策略\"],\n",
      "    [\"极限编程(XP)\", \"属于\", \"敏捷开发\"],\n",
      "    [\"Scrum\", \"属于\", \"敏捷开发\"],\n",
      "    [\"水晶方法(Crystal Methods)\", \"属于\", \"敏捷开发\"],\n",
      "    [\"特征驱动开发(FDD)\", \"属于\", \"敏捷开发\"],\n",
      "    [\"自适应软件开发(ASD)\", \"属于\", \"敏捷开发\"],\n",
      "    [\"动态系统开发方法(DSDM)\", \"属于\", \"敏捷开发\"],\n",
      "    [\"商用软件包开发路线\", \"属于\", \"系统开发策略\"],\n",
      "    [\"商用应用软件包\", \"属于\", \"商用软件包开发路线\"],\n",
      "    [\"封装式软件方案\", \"属于\", \"商用软件包开发路线\"],\n",
      "    [\"购买现成商用软件\", \"属于\", \"商用软件包开发路线\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "3503\n",
      "sleep:37.796130439169325秒\n",
      "————————————第10章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"商用软件包开发路线\",\n",
      "    \"商用软件包\",\n",
      "    \"购买现成商用软件\",\n",
      "    \"技术市场调研\",\n",
      "    \"业务需求分析阶段\",\n",
      "    \"候选的软件包供应商\",\n",
      "    \"需求方案说明书 RFP\",\n",
      "    \"业务和技术需求评价\",\n",
      "    \"软件合同和订单\",\n",
      "    \"安装和维护服务合同\",\n",
      "    \"现有业务过程定制\",\n",
      "    \"差距分析\",\n",
      "    \"附加软件需求\",\n",
      "    \"新增软件需求\",\n",
      "    \"基本软件安装与测试\",\n",
      "    \"软件包二次开发\",\n",
      "    \"通用功能\",\n",
      "    \"优先考虑使用软件包的情况\",\n",
      "    \"缺少内部开发人员\",\n",
      "    \"微机系统\",\n",
      "    \"开发时间缩短\",\n",
      "    \"维护工作减轻\",\n",
      "    \"组织内部阻力减少\",\n",
      "    \"功能较为简单\",\n",
      "    \"难以满足特殊要求\",\n",
      "    \"客户化\",\n",
      "    \"前端程序\",\n",
      "    \"后端程序\",\n",
      "    \"实施费用随客户化增加\",\n",
      "    \"利用软件包开发系统的步骤\",\n",
      "    \"系统分析\",\n",
      "    \"解决方案比较\",\n",
      "    \"开发策略选择\",\n",
      "    \"软件包供应商选择\",\n",
      "    \"软件包评价与选择\",\n",
      "    \"系统设计\",\n",
      "    \"客户需求裁剪\",\n",
      "    \"技术人员培训\",\n",
      "    \"客户化设计\",\n",
      "    \"业务流程设计\",\n",
      "    \"编程调试转换安装修改\",\n",
      "    \"程序接口设计\",\n",
      "    \"文档制作\",\n",
      "    \"切换测试\",\n",
      "    \"用户培训\",\n",
      "    \"运行与维护\",\n",
      "    \"改错与升级\",\n",
      "    \"选择合适的开发路线与方法\",\n",
      "    \"用户需求明确性\",\n",
      "    \"快速应用开发\",\n",
      "    \"原型\",\n",
      "    \"XP 方法\",\n",
      "    \"新技术熟悉程度\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"商用软件包\", \"属于\", \"商用软件包开发路线\"],\n",
      "    [\"购买现成商用软件\", \"属于\", \"商用软件包开发路线\"],\n",
      "    [\"技术市场调研\", \"属于\", \"购买现成商用软件\"],\n",
      "    [\"业务需求分析阶段\", \"属于\", \"购买现成商用软件\"],\n",
      "    [\"候选的软件包供应商\", \"属于\", \"购买现成商用软件\"],\n",
      "    [\"需求方案说明书 RFP\", \"用于\", \"购买现成商用软件\"],\n",
      "    [\"业务和技术需求评价\", \"属于\", \"购买现成商用软件\"],\n",
      "    [\"软件合同和订单\", \"属于\", \"购买现成商用软件\"],\n",
      "    [\"安装和维护服务合同\", \"属于\", \"购买现成商用软件\"],\n",
      "    [\"现有业务过程定制\", \"属于\", \"购买现成商用软件\"],\n",
      "    [\"差距分析\", \"属于\", \"购买现成商用软件\"],\n",
      "    [\"附加软件需求\", \"属于\", \"购买现成商用软件\"],\n",
      "    [\"新增软件需求\", \"属于\", \"购买现成商用软件\"],\n",
      "    [\"基本软件安装与测试\", \"属于\", \"购买现成商用软件\"],\n",
      "    [\"软件包二次开发\", \"属于\", \"商用软件包开发路线\"],\n",
      "    [\"通用功能\", \"属于\", \"软件包二次开发\"],\n",
      "    [\"优先考虑使用软件包的情况\", \"属于\", \"软件包二次开发\"],\n",
      "    [\"缺少内部开发人员\", \"属于\", \"优先考虑使用软件包的情况\"],\n",
      "    [\"微机系统\", \"属于\", \"优先考虑使用软件包的情况\"],\n",
      "    [\"开发时间缩短\", \"属于\", \"软件包二次开发的优点\"],\n",
      "    [\"维护工作减轻\", \"属于\", \"软件包二次开发的优点\"],\n",
      "    [\"组织内部阻力减少\", \"属于\", \"软件包二次开发的优点\"],\n",
      "    [\"功能较为简单\", \"属于\", \"利用软件包开发的缺点\"],\n",
      "    [\"难以满足特殊要求\", \"属于\", \"利用软件包开发的缺点\"],\n",
      "    [\"客户化\", \"属于\", \"利用软件包开发的缺点\"],\n",
      "    [\"前端程序\", \"属于\", \"利用软件包开发的缺点\"],\n",
      "    [\"后端程序\", \"属于\", \"利用软件包开发的缺点\"],\n",
      "    [\"实施费用随客户化增加\", \"属于\", \"利用软件包开发的缺点\"],\n",
      "    [\"利用软件包开发系统的步骤\", \"属于\", \"商用软件包开发路线\"],\n",
      "    [\"系统分析\", \"属于\", \"利用软件包开发系统的步骤\"],\n",
      "    [\"解决方案比较\", \"属于\", \"系统分析\"],\n",
      "    [\"开发策略选择\", \"属于\", \"系统分析\"],\n",
      "    [\"软件包供应商选择\", \"属于\", \"系统分析\"],\n",
      "    [\"软件包评价与选择\", \"属于\", \"系统分析\"],\n",
      "    [\"系统设计\", \"属于\", \"利用软件包开发系统的步骤\"],\n",
      "    [\"客户需求裁剪\", \"属于\", \"系统设计\"],\n",
      "    [\"技术人员培训\", \"属于\", \"系统设计\"],\n",
      "    [\"客户化设计\", \"属于\", \"系统设计\"],\n",
      "    [\"业务流程设计\", \"属于\", \"系统设计\"],\n",
      "    [\"编程调试转换安装修改\", \"属于\", \"利用软件包开发系统的步骤\"],\n",
      "    [\"程序接口设计\", \"属于\", \"利用软件包开发系统的步骤\"],\n",
      "    [\"文档制作\", \"属于\", \"利用软件包开发系统的步骤\"],\n",
      "    [\"切换测试\", \"属于\", \"利用软件包开发系统的步骤\"],\n",
      "    [\"用户培训\", \"属于\", \"利用软件包开发系统的步骤\"],\n",
      "    [\"运行与维护\", \"属于\", \"利用软件包开发系统的步骤\"],\n",
      "    [\"改错与升级\", \"属于\", \"利用软件包开发系统的步骤\"],\n",
      "    [\"选择合适的开发路线与方法\", \"属于\", \"商用软件包开发路线\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "3937\n",
      "sleep:38.36691732912291秒\n",
      "————————————第11章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"选择合适的开发路线与方法\",\n",
      "    \"实施的费用随客户化工作量增大而上升\",\n",
      "    \"利用软件包开发系统的步骤\",\n",
      "    \"系统分析\",\n",
      "    \"明确原系统问题和需求\",\n",
      "    \"比较不同开发策略\",\n",
      "    \"选择是否利用软件包开发\",\n",
      "    \"选择软件包供应商\",\n",
      "    \"评价并选择软件包\",\n",
      "    \"系统设计\",\n",
      "    \"裁剪用户需求以适应软件包功能\",\n",
      "    \"培训技术人员\",\n",
      "    \"完成客户化设计\",\n",
      "    \"新的业务流程设计\",\n",
      "    \"编程、调试、转换、安装、修改、程序接口设计、文档制作、切换、测试、用户培训\",\n",
      "    \"运行与维护、改错与升级\",\n",
      "    \"用户需求的明确性\",\n",
      "    \"快速应用开发（RAD）\",\n",
      "    \"原型法\",\n",
      "    \"XP 方法\",\n",
      "    \"技术的熟悉程度\",\n",
      "    \"抛弃式原型方法\",\n",
      "    \"系统复杂性\",\n",
      "    \"传统结构化方法\",\n",
      "    \"系统可靠性\",\n",
      "    \"抛弃式原型\",\n",
      "    \"项目进度\",\n",
      "    \"RAD 和敏捷方法\",\n",
      "    \"进度可视性\",\n",
      "    \"CASE（Computer Aided Software Engineering）\",\n",
      "    \"自动化工具与技术\",\n",
      "    \"CASE 工具分类\",\n",
      "    \"需求分析工具\",\n",
      "    \"软件设计工具\",\n",
      "    \"数据库设计工具\",\n",
      "    \"项目管理工具\",\n",
      "    \"程序设计工具\",\n",
      "    \"测试工具\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"实施的费用随客户化工作量增大而上升\", \"属于\", \"选择合适的开发路线与方法\"],\n",
      "    [\"利用软件包开发系统的步骤\", \"属于\", \"选择合适的开发路线与方法\"],\n",
      "    [\"系统分析\", \"属于\", \"利用软件包开发系统的步骤\"],\n",
      "    [\"明确原系统问题和需求\", \"属于\", \"系统分析\"],\n",
      "    [\"比较不同开发策略\", \"属于\", \"系统分析\"],\n",
      "    [\"选择是否利用软件包开发\", \"属于\", \"系统分析\"],\n",
      "    [\"选择软件包供应商\", \"属于\", \"系统分析\"],\n",
      "    [\"评价并选择软件包\", \"属于\", \"系统分析\"],\n",
      "    [\"系统设计\", \"属于\", \"利用软件包开发系统的步骤\"],\n",
      "    [\"裁剪用户需求以适应软件包功能\", \"属于\", \"系统设计\"],\n",
      "    [\"培训技术人员\", \"属于\", \"系统设计\"],\n",
      "    [\"完成客户化设计\", \"属于\", \"系统设计\"],\n",
      "    [\"新的业务流程设计\", \"属于\", \"系统设计\"],\n",
      "    [\"编程、调试、转换、安装、修改、程序接口设计、文档制作、切换、测试、用户培训\", \"属于\", \"利用软件包开发系统的步骤\"],\n",
      "    [\"运行与维护、改错与升级\", \"属于\", \"利用软件包开发系统的步骤\"],\n",
      "    [\"用户需求的明确性\", \"属于\", \"选择合适的开发路线与方法\"],\n",
      "    [\"快速应用开发（RAD）\", \"属于\", \"根据用户需求的明确性选择开发方法\"],\n",
      "    [\"原型法\", \"属于\", \"根据用户需求的明确性选择开发方法\"],\n",
      "    [\"XP 方法\", \"属于\", \"根据用户需求的明确性选择开发方法\"],\n",
      "    [\"技术的熟悉程度\", \"属于\", \"选择合适的开发路线与方法\"],\n",
      "    [\"抛弃式原型方法\", \"属于\", \"根据对技术的熟悉程度选择开发方法\"],\n",
      "    [\"系统复杂性\", \"属于\", \"选择合适的开发路线与方法\"],\n",
      "    [\"传统结构化方法\", \"属于\", \"根据系统复杂性选择开发方法\"],\n",
      "    [\"系统可靠性\", \"属于\", \"选择合适的开发路线与方法\"],\n",
      "    [\"抛弃式原型\", \"属于\", \"根据系统可靠性选择开发方法\"],\n",
      "    [\"项目进度\", \"属于\", \"选择合适的开发路线与方法\"],\n",
      "    [\"RAD 和敏捷方法\", \"属于\", \"根据项目进度选择开发方法\"],\n",
      "    [\"进度可视性\", \"属于\", \"选择合适的开发路线与方法\"],\n",
      "    [\"CASE（Computer Aided Software Engineering）\", \"属于\", \"自动化工具与技术\"],\n",
      "    [\"CASE 工具分类\", \"属于\", \"自动化工具与技术\"],\n",
      "    [\"需求分析工具\", \"属于\", \"CASE 工具分类\"],\n",
      "    [\"软件设计工具\", \"属于\", \"CASE 工具分类\"],\n",
      "    [\"数据库设计工具\", \"属于\", \"CASE 工具分类\"],\n",
      "    [\"项目管理工具\", \"属于\", \"CASE 工具分类\"],\n",
      "    [\"程序设计工具\", \"属于\", \"CASE 工具分类\"],\n",
      "    [\"测试工具\", \"属于\", \"CASE 工具分类\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "2656\n",
      "sleep:38.07920525159286秒\n",
      "————————————第12章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"自动化工具与技术\",\n",
      "    \"CASE(Computer Aided Software Engineering)\",\n",
      "    \"减少重复工作量\",\n",
      "    \"全面支持开发步骤\",\n",
      "    \"系统可靠性\",\n",
      "    \"项目进度\",\n",
      "    \"进度可视性\",\n",
      "    \"RAD 和敏捷方法\",\n",
      "    \"CASE 工具分类\",\n",
      "    \"需求分析工具\",\n",
      "    \"软件设计工具\",\n",
      "    \"数据库设计工具\",\n",
      "    \"项目管理工具\",\n",
      "    \"程序设计工具\",\n",
      "    \"测试工具\",\n",
      "    \"基于 CASE 的系统开发过程\",\n",
      "    \"数据生成\",\n",
      "    \"应用生成\",\n",
      "    \"数据流程图\",\n",
      "    \"矩阵图\",\n",
      "    \"原型技术\",\n",
      "    \"编码生成\",\n",
      "    \"文档生成\",\n",
      "    \"设计检测\",\n",
      "    \"维护设计规范\",\n",
      "    \"CASE 工具的特点\",\n",
      "    \"自动化作业\",\n",
      "    \"错误减少\",\n",
      "    \"合法性检测功能\",\n",
      "    \"原型法功能\",\n",
      "    \"信息储存库\",\n",
      "    \"加快开发速度\",\n",
      "    \"简化开发管理与维护\",\n",
      "    \"CASE 局限性\",\n",
      "    \"依赖于具体开发方法\",\n",
      "    \"无法自动生成特定功能系统\",\n",
      "    \"无法实现特定接口\",\n",
      "    \"不能自动进行系统分析\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"CASE(Computer Aided Software Engineering)\",\"属于\",\"自动化工具与技术\"],\n",
      "    [\"减少重复工作量\",\"属于\",\"CASE(Computer Aided Software Engineering)\"],\n",
      "    [\"全面支持开发步骤\",\"属于\",\"CASE(Computer Aided Software Engineering)\"],\n",
      "    [\"系统可靠性\",\"考虑采用\",\"抛弃式原型\"],\n",
      "    [\"项目进度\",\"适合采用\",\"RAD 和敏捷方法\"],\n",
      "    [\"进度可视性\",\"通过\",\"RAD 方法增加\"],\n",
      "    [\"CASE 工具分类\",\"属于\",\"自动化工具与技术\"],\n",
      "    [\"需求分析工具\",\"属于\",\"CASE 工具分类\"],\n",
      "    [\"软件设计工具\",\"属于\",\"CASE 工具分类\"],\n",
      "    [\"数据库设计工具\",\"属于\",\"CASE 工具分类\"],\n",
      "    [\"项目管理工具\",\"属于\",\"CASE 工具分类\"],\n",
      "    [\"程序设计工具\",\"属于\",\"CASE 工具分类\"],\n",
      "    [\"测试工具\",\"属于\",\"CASE 工具分类\"],\n",
      "    [\"基于 CASE 的系统开发过程\",\"属于\",\"自动化工具与技术\"],\n",
      "    [\"数据生成\",\"部分\",\"基于 CASE 的系统开发过程\"],\n",
      "    [\"应用生成\",\"部分\",\"基于 CASE 的系统开发过程\"],\n",
      "    [\"原型技术\",\"在\",\"基于 CASE 的开发中强调\"],\n",
      "    [\"编码生成\",\"在\",\"基于 CASE 的开发中自动化\"],\n",
      "    [\"文档生成\",\"在\",\"基于 CASE 的开发中自动化\"],\n",
      "    [\"设计检测\",\"在\",\"基于 CASE 的开发中自动化\"],\n",
      "    [\"CASE 工具的特点\",\"描述\",\"CASE\"],\n",
      "    [\"自动化作业\",\"特点\",\"CASE 工具\"],\n",
      "    [\"错误减少\",\"特点\",\"CASE 工具\"],\n",
      "    [\"合法性检测功能\",\"特点\",\"CASE 工具\"],\n",
      "    [\"原型法功能\",\"特点\",\"CASE 工具\"],\n",
      "    [\"信息储存库\",\"核心部分\",\"CASE 工具包\"],\n",
      "    [\"加快开发速度\",\"特点\",\"CASE 工具\"],\n",
      "    [\"简化开发管理与维护\",\"特点\",\"CASE 工具\"],\n",
      "    [\"CASE 局限性\",\"属于\",\"CASE\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "3088\n",
      "sleep:38.74171227029683秒\n",
      "————————————第13章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"CASE工具的特点\",\n",
      "    \"系统开发过程中的自动化作业\",\n",
      "    \"错误减少\",\n",
      "    \"合法性检测功能\",\n",
      "    \"数据流图的自动平衡\",\n",
      "    \"数据完整性和一致性校核\",\n",
      "    \"原型法功能\",\n",
      "    \"信息储存库\",\n",
      "    \"软件开发速度加快\",\n",
      "    \"软件开发管理与维护简化\",\n",
      "    \"CASE局限性：辅助开发工具\",\n",
      "    \"依赖具体开发方法\",\n",
      "    \"无法自动生成特定功能系统\",\n",
      "    \"无法实现与数据库和第四代语言接口\",\n",
      "    \"不能自动进行系统分析\",\n",
      "    \"信息系统开发过程要求一致性与规范性\",\n",
      "    \"CASE工具在系统开发中的应用\",\n",
      "    \"范围定义\",\n",
      "    \"问题分析\",\n",
      "    \"需求分析\",\n",
      "    \"逻辑设计\",\n",
      "    \"决策分析\",\n",
      "    \"物理设计和集成\",\n",
      "    \"构造和测试\",\n",
      "    \"安装和发布\",\n",
      "    \"运行和维护\",\n",
      "    \"跨生命周期活动\",\n",
      "    \"Computer-Assisted Software Engineering (CASE)\",\n",
      "    \"计算机辅助系统建模工具\",\n",
      "    \"Erwin\",\n",
      "    \"System Architect\",\n",
      "    \"ROSE\",\n",
      "    \"应用开发环境\",\n",
      "    \"Websphere\",\n",
      "    \"J Builder\",\n",
      "    \"Visual Studio.net\",\n",
      "    \"PowerBuilder\",\n",
      "    \"项目和过程管理器\",\n",
      "    \"Project\",\n",
      "    \"Sybase公司的PowerDesigner\",\n",
      "    \"业务或系统分析人员\",\n",
      "    \"设计人员\",\n",
      "    \"数据库管理员(DBA)\",\n",
      "    \"开发人员\",\n",
      "    \"模块化结构\",\n",
      "    \"购买和扩展灵活性\",\n",
      "    \"项目规模和范围适应性\",\n",
      "    \"PowerDesigner的建模解决方案\",\n",
      "    \"灵活的分析和设计特性\",\n",
      "    \"数据库或数据仓库创建\",\n",
      "    \"直观符号表示\",\n",
      "    \"标准化交流和通讯\",\n",
      "    \"非技术人员展示\",\n",
      "    \"过程建模\",\n",
      "    \"组织和记录数据结构和流向\",\n",
      "    \"业务过程建模(BPM)\",\n",
      "    \"Process（过程）\",\n",
      "    \"Flow（流程）\",\n",
      "    \"Decision（决策点）\",\n",
      "    \"Synchronization（并发与同步）\",\n",
      "    \"Resource（资源）\",\n",
      "    \"Message Format（过程间数据交互）\",\n",
      "    \"电子订单处理流程建模实例\",\n",
      "    \"数据建模\",\n",
      "    \"组织和记录系统数据\",\n",
      "    \"业务需求定义\",\n",
      "    \"概念数据模型(CDM)\",\n",
      "    \"实体添加属性\",\n",
      "    \"设置主键和数据类型\",\n",
      "    \"check model功能\",\n",
      "    \"模型正确性检查\",\n",
      "    \"售票系统概念数据模型实例\",\n",
      "    \"物理数据模型(PDM)\",\n",
      "    \"CDM与PDM相互转化\",\n",
      "    \"面向对象模型生成\",\n",
      "    \"正向工程\",\n",
      "    \"模型导入数据库\",\n",
      "    \"建立ODBC数据源\",\n",
      "    \"连接ODBC数据源\",\n",
      "    \"导入数据库\",\n",
      "    \"逆向工程\",\n",
      "    \"数据库导入模型\",\n",
      "    \"对象建模\",\n",
      "    \"辨识系统环境中对象及其关系\",\n",
      "    \"面向对象模型\",\n",
      "    \"用例图(Use Case Diagram)\",\n",
      "    \"类图(Class Diagram)\",\n",
      "    \"状态图(Statechart Diagram)\",\n",
      "    \"顺序图(Sequence Diagram)\",\n",
      "    \"协作图(Collaboration Diagram)\",\n",
      "    \"电脑工作状态图实例\",\n",
      "    \"饮料贩卖机工作顺序图实例\",\n",
      "    \"饮料贩卖机工作协作图实例\",\n",
      "    \"报告生成工具及模板\",\n",
      "    \"报告语言、字体、模板形式选择\",\n",
      "    \"显示项目自定义\",\n",
      "    \"报告生成格式（RTF、HTML等）\",\n",
      "    \"信息系统模型开发报告\",\n",
      "    \"HTML版本信息系统开发报告实例\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"CASE工具的特点\", \"属于\", \"CASE工具\"],\n",
      "    [\"系统开发过程中的自动化作业\", \"属于\", \"CASE工具的特点\"],\n",
      "    [\"错误减少\", \"属于\", \"CASE工具的特点\"],\n",
      "    [\"合法性检测功能\", \"属于\", \"CASE工具的特点\"],\n",
      "    [\"数据流图的自动平衡\", \"属于\", \"CASE工具的特点\"],\n",
      "    [\"数据完整性和一致性校核\", \"属于\", \"CASE工具的特点\"],\n",
      "    [\"原型法功能\", \"属于\", \"CASE工具的特点\"],\n",
      "    [\"信息储存库\", \"属于\", \"CASE工具的特点\"],\n",
      "    [\"软件开发速度加快\", \"属于\", \"CASE工具的特点\"],\n",
      "    [\"软件开发管理与维护简化\", \"属于\", \"CASE工具的特点\"],\n",
      "    [\"CASE局限性：辅助开发工具\", \"属于\", \"CASE工具\"],\n",
      "    [\"依赖具体开发方法\", \"属于\", \"CASE局限性\"],\n",
      "    [\"无法自动生成特定功能系统\", \"属于\", \"CASE局限性\"],\n",
      "    [\"无法实现与数据库和第四代语言接口\", \"属于\", \"CASE局限性\"],\n",
      "    [\"不能自动进行系统分析\", \"属于\", \"CASE局限性\"],\n",
      "    [\"CASE工具在系统开发中的应用\", \"属于\", \"案例\"],\n",
      "    [\"计算机辅助系统建模工具\", \"属于\", \"CASE工具\"],\n",
      "    [\"应用开发环境\", \"属于\", \"CASE工具\"],\n",
      "    [\"项目和过程管理器\", \"属于\", \"CASE工具\"],\n",
      "    [\"Sybase公司的PowerDesigner\", \"属于\", \"CASE工具\"],\n",
      "    [\"业务过程建模(BPM)\", \"属于\", \"PowerDesigner\"],\n",
      "    [\"Process、Flow、Decision、Synchronization、Resource、Message Format\", \"属于\", \"BPM\"],\n",
      "    [\"电子订单处理流程建模实例\", \"属于\", \"过程建模\"],\n",
      "    [\"概念数据模型(CDM)\", \"属于\", \"数据建模\"],\n",
      "    [\"实体添加属性、设置主键和数据类型\", \"属于\", \"CDM\"],\n",
      "    [\"check model功能\", \"属于\", \"CDM\"],\n",
      "    [\"售票系统概念数据模型实例\", \"属于\", \"CDM\"],\n",
      "    [\"物理数据模型(PDM)\", \"属于\", \"数据建模\"],\n",
      "    [\"CDM与PDM相互转化\", \"关联于\", \"数据建模\"],\n",
      "    [\"面向对象模型\", \"属于\", \"PowerDesigner\"],\n",
      "    [\"正向工程\", \"应用于\", \"模型与数据库连接\"],\n",
      "    [\"逆向工程\", \"应用于\", \"模型与数据库连接\"],\n",
      "    [\"对象建模\", \"属于\", \"PowerDesigner\"],\n",
      "    [\"面向对象模型\", \"包含\", \"用例图、类图、状态图、顺序图、协作图\"],\n",
      "    [\"电脑工作状态图实例\", \"属于\", \"对象建模\"],\n",
      "    [\"饮料贩卖机工作顺序图实例\", \"属于\", \"对象建模\"],\n",
      "    [\"饮料贩卖机工作协作图实例\", \"属于\", \"对象建模\"],\n",
      "    [\"报告生成工具及模板\", \"属于\", \"PowerDesigner\"],\n",
      "    [\"HTML版本信息系统开发报告实例\", \"属于\", \"报告生成\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "4645\n",
      "sleep:37.56234754119277秒\n",
      "————————————第14章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"信息系统开发报告\",\n",
      "    \"PowerDesigner\",\n",
      "    \"信息系统开发路线\",\n",
      "    \"正向工程\",\n",
      "    \"Access数据库\",\n",
      "    \"CASE工具概述\",\n",
      "    \"基于CASE的系统开发过程\",\n",
      "    \"信息系统开发可以遵循的不同路线\",\n",
      "    \"CASE工具在系统开发中的主要作用\",\n",
      "    \"访问信息系统部门了解项目特点及开发方法\",\n",
      "    \"自动化工具的功能分类\",\n",
      "    \"ERP项目开发路线选择\",\n",
      "    \"项目管理过程\",\n",
      "    \"项目经理所需的技能\",\n",
      "    \"项目发起、规划、执行和终结阶段的技能和活动\",\n",
      "    \"关键路径规划\",\n",
      "    \"甘特图\",\n",
      "    \"网络图\",\n",
      "    \"商用项目管理软件包\",\n",
      "    \"信息系统项目管理\",\n",
      "    \"项目管理生命周期\",\n",
      "    \"项目范围确定\",\n",
      "    \"计划制定\",\n",
      "    \"人员安排\",\n",
      "    \"组织结构\",\n",
      "    \"指导与控制\",\n",
      "    \"系统质量、项目完成时间和成本权衡\",\n",
      "    \"项目成功的可能性\",\n",
      "    \"项目发起阶段\",\n",
      "    \"项目规模评估\",\n",
      "    \"项目范围和复杂性评估\",\n",
      "    \"支持后续活动的规程建立\",\n",
      "    \"成立项目发起团队\",\n",
      "    \"建立与客户之间的关系\",\n",
      "    \"制定项目发起计划\",\n",
      "    \"制定管理规程\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"PowerDesigner\", \"属于\", \"信息系统开发工具\"],\n",
      "    [\"信息系统开发路线\", \"属于\", \"本章小结\"],\n",
      "    [\"正向工程\", \"属于\", \"PowerDesigner 功能\"],\n",
      "    [\"Access数据库\", \"涉及\", \"正向工程问题\"],\n",
      "    [\"CASE工具概述\", \"属于\", \"本章内容\"],\n",
      "    [\"基于CASE的系统开发过程\", \"属于\", \"本章内容\"],\n",
      "    [\"ERP项目开发路线选择\", \"属于\", \"思考与练习\"],\n",
      "    [\"项目管理过程\", \"属于\", \"第3章学习目标\"],\n",
      "    [\"项目经理所需的技能\", \"属于\", \"第3章学习目标\"],\n",
      "    [\"项目发起、规划、执行和终结阶段的技能和活动\", \"属于\", \"第3章学习目标\"],\n",
      "    [\"关键路径规划\", \"属于\", \"第3章学习目标\"],\n",
      "    [\"甘特图\", \"用于\", \"项目进度表示\"],\n",
      "    [\"网络图\", \"用于\", \"项目进度表示\"],\n",
      "    [\"商用项目管理软件包\", \"应用于\", \"项目进度管理\"],\n",
      "    [\"信息系统项目管理\", \"定义为\", \"管理过程\"],\n",
      "    [\"项目管理生命周期\", \"包含\", \"四个阶段\"],\n",
      "    [\"项目发起阶段\", \"属于\", \"项目管理生命周期\"],\n",
      "    [\"成立项目发起团队\", \"属于\", \"项目发起阶段活动\"],\n",
      "    [\"建立与客户之间的关系\", \"属于\", \"项目发起阶段活动\"],\n",
      "    [\"制定项目发起计划\", \"属于\", \"项目发起阶段活动\"],\n",
      "    [\"建立管理规程\", \"属于\", \"项目发起阶段活动\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "1909\n",
      "sleep:38.8194568502301秒\n",
      "————————————第15章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"信息系统项目管理\",\n",
      "    \"项目管理过程\",\n",
      "    \"项目经理的技能\",\n",
      "    \"项目发起阶段\",\n",
      "    \"规划项目\",\n",
      "    \"执行项目\",\n",
      "    \"终结项目\",\n",
      "    \"项目发起的主要任务和活动\",\n",
      "    \"成立项目发起团队\",\n",
      "    \"建立与客户之间的关系\",\n",
      "    \"制定项目发起计划\",\n",
      "    \"建立管理规程\",\n",
      "    \"建立项目管理环境和项目工作手册\",\n",
      "    \"项目工作手册内容\",\n",
      "    \"项目范围和风险\",\n",
      "    \"管理规程\",\n",
      "    \"数据描述\",\n",
      "    \"过程描述\",\n",
      "    \"团队函件\",\n",
      "    \"工作声明\",\n",
      "    \"项目进度\",\n",
      "    \"项目规划主要内容\",\n",
      "    \"描述项目范围、候选方案、可行性\",\n",
      "    \"将项目分解为可管理的任务\",\n",
      "    \"估算资源并创建资源规划\",\n",
      "    \"制定初步进度\",\n",
      "    \"制定通信计划\",\n",
      "    \"确定项目标准和规程\",\n",
      "    \"识别和评估风险\",\n",
      "    \"创建初步的预算\",\n",
      "    \"开发工作陈述\",\n",
      "    \"建立基线项目计划\",\n",
      "    \"项目执行阶段\",\n",
      "    \"执行基线项目计划\",\n",
      "    \"按照基线项目计划监督项目进展\",\n",
      "    \"管理基线项目计划的变更\",\n",
      "    \"维护项目工作手册\",\n",
      "    \"沟通项目状况\",\n",
      "    \"资源调配技术\",\n",
      "    \"项目组沟通方式\",\n",
      "    \"项目终结阶段\",\n",
      "    \"结束项目\",\n",
      "    \"项目评估\",\n",
      "    \"终止项目合同\",\n",
      "    \"单纯式项目组织\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"项目发起阶段\", \"属于\", \"信息系统项目管理生命周期\"],\n",
      "    [\"规划项目\", \"属于\", \"信息系统项目管理生命周期\"],\n",
      "    [\"执行项目\", \"属于\", \"信息系统项目管理生命周期\"],\n",
      "    [\"终结项目\", \"属于\", \"信息系统项目管理生命周期\"],\n",
      "    [\"成立项目发起团队\", \"属于\", \"项目发起的主要任务和活动\"],\n",
      "    [\"建立与客户之间的关系\", \"属于\", \"项目发起的主要任务和活动\"],\n",
      "    [\"制定项目发起计划\", \"属于\", \"项目发起的主要任务和活动\"],\n",
      "    [\"建立管理规程\", \"属于\", \"项目发起的主要任务和活动\"],\n",
      "    [\"建立项目管理环境和项目工作手册\", \"属于\", \"项目发起的主要任务和活动\"],\n",
      "    [\"项目规划主要内容\", \"属于\", \"项目规划\"],\n",
      "    [\"描述项目范围、候选方案、可行性\", \"属于\", \"项目规划主要内容\"],\n",
      "    [\"将项目分解为可管理的任务\", \"属于\", \"项目规划主要内容\"],\n",
      "    [\"估算资源并创建资源规划\", \"属于\", \"项目规划主要内容\"],\n",
      "    [\"制定初步进度\", \"属于\", \"项目规划主要内容\"],\n",
      "    [\"制定通信计划\", \"属于\", \"项目规划主要内容\"],\n",
      "    [\"确定项目标准和规程\", \"属于\", \"项目规划主要内容\"],\n",
      "    [\"识别和评估风险\", \"属于\", \"项目规划主要内容\"],\n",
      "    [\"创建初步的预算\", \"属于\", \"项目规划主要内容\"],\n",
      "    [\"开发工作陈述\", \"属于\", \"项目规划主要内容\"],\n",
      "    [\"建立基线项目计划\", \"属于\", \"项目规划主要内容\"],\n",
      "    [\"执行基线项目计划\", \"属于\", \"项目执行阶段\"],\n",
      "    [\"按照基线项目计划监督项目进展\", \"属于\", \"项目执行阶段\"],\n",
      "    [\"管理基线项目计划的变更\", \"属于\", \"项目执行阶段\"],\n",
      "    [\"维护项目工作手册\", \"属于\", \"项目执行阶段\"],\n",
      "    [\"沟通项目状况\", \"属于\", \"项目执行阶段\"],\n",
      "    [\"结束项目\", \"属于\", \"项目终结阶段\"],\n",
      "    [\"项目评估\", \"属于\", \"项目终结阶段\"],\n",
      "    [\"终止项目合同\", \"属于\", \"项目终结阶段\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "3144\n",
      "sleep:37.85050783543947秒\n",
      "————————————第16章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"项目终结\",\n",
      "    \"结束项目\",\n",
      "    \"完成对项目组成员的绩效和薪资的鉴定\",\n",
      "    \"通知各利益相关方\",\n",
      "    \"完成所有项目文档和财务记录\",\n",
      "    \"项目评估\",\n",
      "    \"审查项目交付品、创建过程及管理优点和缺点\",\n",
      "    \"终止项目合同\",\n",
      "    \"确保合同条款满足并书面同意\",\n",
      "    \"项目组织\",\n",
      "    \"单纯式项目组织\",\n",
      "    \"项目经理对项目拥有完全自主权\",\n",
      "    \"成员只需面对一个老板\",\n",
      "    \"沟通层级短，决策形成快\",\n",
      "    \"荣誉感和使命感高\",\n",
      "    \"人员与设备无法共用，资源浪费\",\n",
      "    \"组织目标和策略易被忽略\",\n",
      "    \"职能部门与新科技脱节\",\n",
      "    \"项目小组成员完成项目即解散，导致项目延误风险\",\n",
      "    \"职能性项目组织\",\n",
      "    \"项目建立在职能部门中\",\n",
      "    \"成员可以同时参与多个项目\",\n",
      "    \"专业技能不会因人员离开而遗失\",\n",
      "    \"成员有机会升迁\",\n",
      "    \"职能部门处理技术问题能力强\",\n",
      "    \"项目与职能部门需要无直接相关性的地方易被忽略\",\n",
      "    \"客户的需求容易被忽略\",\n",
      "    \"矩阵式项目组织\",\n",
      "    \"项目组成员由不同职能部门提供\",\n",
      "    \"项目经理决定工作内容和完成时间\",\n",
      "    \"职能部门经理控制人员和技术\",\n",
      "    \"强化与职能部门的沟通\",\n",
      "    \"项目经理对项目成败负责\",\n",
      "    \"降低资源重复\",\n",
      "    \"执行上级组织政策\",\n",
      "    \"项目可获得较多支持\",\n",
      "    \"受职能部门和项目组双重管理\",\n",
      "    \"项目经理需较强的谈判技巧\",\n",
      "    \"项目组成员不易全心投入项目\",\n",
      "    \"项目管理技术\",\n",
      "    \"工作分解结构\",\n",
      "    \"WBS\",\n",
      "    \"将项目层次化分解为开发阶段、活动和任务\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"结束项目\", \"属于\", \"项目终结\"],\n",
      "    [\"完成对项目组成员的绩效和薪资的鉴定\", \"属于\", \"结束项目\"],\n",
      "    [\"通知各利益相关方\", \"属于\", \"结束项目\"],\n",
      "    [\"完成所有项目文档和财务记录\", \"属于\", \"结束项目\"],\n",
      "    [\"项目评估\", \"属于\", \"项目终结\"],\n",
      "    [\"审查项目交付品、创建过程及管理优点和缺点\", \"属于\", \"项目评估\"],\n",
      "    [\"终止项目合同\", \"属于\", \"项目终结\"],\n",
      "    [\"确保合同条款满足并书面同意\", \"属于\", \"终止项目合同\"],\n",
      "    [\"单纯式项目组织\", \"属于\", \"项目组织\"],\n",
      "    [\"项目经理对项目拥有完全自主权\", \"属于\", \"单纯式项目组织\"],\n",
      "    [\"成员只需面对一个老板\", \"属于\", \"单纯式项目组织\"],\n",
      "    [\"沟通层级短，决策形成快\", \"属于\", \"单纯式项目组织\"],\n",
      "    [\"荣誉感和使命感高\", \"属于\", \"单纯式项目组织\"],\n",
      "    [\"人员与设备无法共用，资源浪费\", \"属于\", \"单纯式项目组织\"],\n",
      "    [\"组织目标和策略易被忽略\", \"属于\", \"单纯式项目组织\"],\n",
      "    [\"职能部门与新科技脱节\", \"属于\", \"单纯式项目组织\"],\n",
      "    [\"项目小组成员完成项目即解散，导致项目延误风险\", \"属于\", \"单纯式项目组织\"],\n",
      "    [\"职能性项目组织\", \"属于\", \"项目组织\"],\n",
      "    [\"项目建立在职能部门中\", \"属于\", \"职能性项目组织\"],\n",
      "    [\"成员可以同时参与多个项目\", \"属于\", \"职能性项目组织\"],\n",
      "    [\"专业技能不会因人员离开而遗失\", \"属于\", \"职能性项目组织\"],\n",
      "    [\"成员有机会升迁\", \"属于\", \"职能性项目组织\"],\n",
      "    [\"职能部门处理技术问题能力强\", \"属于\", \"职能性项目组织\"],\n",
      "    [\"项目与职能部门需要无直接相关性的地方易被忽略\", \"属于\", \"职能性项目组织\"],\n",
      "    [\"客户的需求容易被忽略\", \"属于\", \"职能性项目组织\"],\n",
      "    [\"矩阵式项目组织\", \"属于\", \"项目组织\"],\n",
      "    [\"项目组成员由不同职能部门提供\", \"属于\", \"矩阵式项目组织\"],\n",
      "    [\"项目经理决定工作内容和完成时间\", \"属于\", \"矩阵式项目组织\"],\n",
      "    [\"职能部门经理控制人员和技术\", \"属于\", \"矩阵式项目组织\"],\n",
      "    [\"强化与职能部门的沟通\", \"属于\", \"矩阵式项目组织\"],\n",
      "    [\"项目经理对项目成败负责\", \"属于\", \"矩阵式项目组织\"],\n",
      "    [\"降低资源重复\", \"属于\", \"矩阵式项目组织\"],\n",
      "    [\"执行上级组织政策\", \"属于\", \"矩阵式项目组织\"],\n",
      "    [\"项目可获得较多支持\", \"属于\", \"矩阵式项目组织\"],\n",
      "    [\"受职能部门和项目组双重管理\", \"属于\", \"矩阵式项目组织\"],\n",
      "    [\"项目经理需较强的谈判技巧\", \"属于\", \"矩阵式项目组织\"],\n",
      "    [\"项目组成员不易全心投入项目\", \"属于\", \"矩阵式项目组织\"],\n",
      "    [\"项目管理技术\", \"属于\", \"项目组织\"],\n",
      "    [\"工作分解结构\", \"属于\", \"项目管理技术\"],\n",
      "    [\"WBS\", \"属于\", \"工作分解结构\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "2281\n",
      "sleep:37.957391130064984秒\n",
      "————————————第17章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"项目管理技术\",\n",
      "    \"工作分解结构\",\n",
      "    \"强化与职能部门的沟通\",\n",
      "    \"项目经理对项目负成败的责任\",\n",
      "    \"降低资源重复\",\n",
      "    \"执行上级组织的政策\",\n",
      "    \"项目可获得较多的支持\",\n",
      "    \"受职能部门和项目组的双重管理\",\n",
      "    \"项目经理需要较强的谈判技巧\",\n",
      "    \"项目组成员不容易全心投入项目\",\n",
      "    \"职能经理\",\n",
      "    \"总经理\",\n",
      "    \"项目A\",\n",
      "    \"项目B\",\n",
      "    \"WBS\",\n",
      "    \"工作包\",\n",
      "    \"80小时法则或两周法则\",\n",
      "    \"需求分析\",\n",
      "    \"定义阶段\",\n",
      "    \"开发活动\",\n",
      "    \"开发任务\",\n",
      "    \"层次分解\",\n",
      "    \"依赖关系\",\n",
      "    \"关键路径\",\n",
      "    \"甘特图(Gantt Chart)\",\n",
      "    \"进度计划方法\",\n",
      "    \"单项工程内容进度\",\n",
      "    \"子任务\",\n",
      "    \"开始时间\",\n",
      "    \"完成时间\",\n",
      "    \"持续时间\",\n",
      "    \"直观表达\",\n",
      "    \"广泛理解\",\n",
      "    \"易于掌握\",\n",
      "    \"应用范围\",\n",
      "    \"局限性\",\n",
      "    \"网络分析\",\n",
      "    \"计划评审技术（PERT）\",\n",
      "    \"科学计划管理技术\",\n",
      "    \"概率论\",\n",
      "    \"β分布原理\",\n",
      "    \"乐观工期a\",\n",
      "    \"最可能工期m\",\n",
      "    \"悲观工期b\",\n",
      "    \"作业时间估计\",\n",
      "    \"网络计算\",\n",
      "    \"最早开始时间ES\",\n",
      "    \"最早结束时间EF\",\n",
      "    \"最晚开始时间LS\",\n",
      "    \"最晚结束时间LF\",\n",
      "    \"浮动时间TF\",\n",
      "    \"前推法(Forward Pass)\",\n",
      "    \"逆推法(Backward Pass)\",\n",
      "    \"关键路径\",\n",
      "    \"关键任务\",\n",
      "    \"浮动时间(slack time)\",\n",
      "    \"资源配置\",\n",
      "    \"延迟影响\",\n",
      "    \"系统规划\",\n",
      "    \"系统分析\",\n",
      "    \"系统设计\",\n",
      "    \"子系统编制调试\",\n",
      "    \"用户培训\",\n",
      "    \"系统调试准备\",\n",
      "    \"软硬件准备\",\n",
      "    \"系统调试\",\n",
      "    \"系统转换\",\n",
      "    \"维护评价\",\n",
      "    \"建立数据库\",\n",
      "    \"网络计算表\",\n",
      "    \"关键路线\",\n",
      "    \"案例：某系统开发项目管理\",\n",
      "    \"网上订餐系统\",\n",
      "    \"协商范围阶段\",\n",
      "    \"系统分析阶段\",\n",
      "    \"系统设计阶段\",\n",
      "    \"原型制造阶段\",\n",
      "    \"设备评估阶段\",\n",
      "    \"原型测试阶段\",\n",
      "    \"记录设备报告阶段\",\n",
      "    \"记录方式报告阶段\",\n",
      "    \"记录最终报告阶段\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"工作分解结构\", \"属于\", \"项目管理技术\"],\n",
      "    [\"强化与职能部门的沟通\", \"属于\", \"项目管理的优点\"],\n",
      "    [\"项目经理对项目负成败的责任\", \"属于\", \"项目管理的优点\"],\n",
      "    [\"降低资源重复\", \"属于\", \"项目管理的优点\"],\n",
      "    [\"执行上级组织的政策\", \"属于\", \"项目管理的优点\"],\n",
      "    [\"项目可获得较多的支持\", \"属于\", \"项目管理的优点\"],\n",
      "    [\"受职能部门和项目组的双重管理\", \"属于\", \"项目管理的缺点\"],\n",
      "    [\"项目经理需要较强的谈判技巧\", \"属于\", \"项目管理的缺点\"],\n",
      "    [\"项目组成员不容易全心投入项目\", \"属于\", \"项目管理的缺点\"],\n",
      "    [\"WBS\", \"属于\", \"工作分解结构\"],\n",
      "    [\"工作包\", \"属于\", \"WBS\"],\n",
      "    [\"80小时法则或两周法则\", \"属于\", \"WBS\"],\n",
      "    [\"需求分析\", \"属于\", \"WBS 分解过程\"],\n",
      "    [\"定义阶段\", \"属于\", \"WBS 分解过程\"],\n",
      "    [\"开发活动\", \"属于\", \"WBS 层次分解\"],\n",
      "    [\"开发任务\", \"属于\", \"WBS 层次分解\"],\n",
      "    [\"层次分解\", \"属于\", \"WBS\"],\n",
      "    [\"依赖关系\", \"关联于\", \"WBS\"],\n",
      "    [\"关键路径\", \"关联于\", \"WBS\"],\n",
      "    [\"甘特图(Gantt Chart)\", \"属于\", \"项目管理技术\"],\n",
      "    [\"进度计划方法\", \"描述\", \"甘特图\"],\n",
      "    [\"单项工程内容进度\", \"表示于\", \"甘特图\"],\n",
      "    [\"子任务\", \"在甘特图中表示\", \"开始时间和完成时间\"],\n",
      "    [\"80小时法则或两周法则\", \"应用于\", \"工作包定义\"],\n",
      "    [\"计划评审技术（PERT）\", \"属于\", \"项目管理技术\"],\n",
      "    [\"概率论\", \"引用于\", \"PERT 的作业时间估计\"],\n",
      "    [\"β分布原理\", \"引用于\", \"PERT 的作业时间估计\"],\n",
      "    [\"乐观工期a\", \"属于\", \"PERT 作业时间估计参数\"],\n",
      "    [\"最可能工期m\", \"属于\", \"PERT 作业时间估计参数\"],\n",
      "    [\"悲观工期b\", \"属于\", \"PERT 作业时间估计参数\"],\n",
      "    [\"网络计算\", \"包括\", \"最早开始时间ES、最早结束时间EF计算\"],\n",
      "    [\"网络计算\", \"包括\", \"最晚开始时间LS、最晚结束时间LF计算\"],\n",
      "    [\"网络计算\", \"包括\", \"浮动时间TF计算\"],\n",
      "    [\"前推法(Forward Pass)\", \"用于\", \"最早时间计算\"],\n",
      "    [\"逆推法(Backward Pass)\", \"用于\", \"最晚时间计算\"],\n",
      "    [\"关键路径\", \"通过\", \"网络计算确定\"],\n",
      "    [\"关键任务\", \"位于\", \"关键路径上\"],\n",
      "    [\"浮动时间\", \"关联于\", \"非关键任务\"],\n",
      "    [\"网上订餐系统\", \"属于\", \"案例：某系统开发项目管理\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "4773\n",
      "sleep:38.018014756612956秒\n",
      "————————————第18章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"案例：某系统开发项目管理\",\n",
      "    \"协商范围阶段\",\n",
      "    \"系统分析\",\n",
      "    \"1. 收集需求\",\n",
      "    \"2. 分析过程\",\n",
      "    \"3. 分析数据\",\n",
      "    \"系统设计\",\n",
      "    \"4. 设计过程\",\n",
      "    \"5. 设计数据\",\n",
      "    \"6. 设计屏幕\",\n",
      "    \"7. 设计报告\",\n",
      "    \"系统实现\",\n",
      "    \"8. 程序\",\n",
      "    \"9. 测试和文档\",\n",
      "    \"10. 安装\",\n",
      "    \"估计任务周期和任务之间依赖关系\",\n",
      "    \"分配资源\",\n",
      "    \"监督和控制项目进展\",\n",
      "    \"项目经理角色\",\n",
      "    \"项目发起\",\n",
      "    \"项目规划\",\n",
      "    \"项目执行\",\n",
      "    \"项目终结\",\n",
      "    \"甘特图\",\n",
      "    \"网络图\",\n",
      "    \"关键路径规划\",\n",
      "    \"自动化工具支持\",\n",
      "    \"案例分析\",\n",
      "    \"银行前置机的软件系统项目\",\n",
      "    \"项目经理小丁\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"协商范围阶段\", \"属于\", \"案例：某系统开发项目管理\"],\n",
      "    [\"系统分析\", \"属于\", \"案例：某系统开发项目管理\"],\n",
      "    [\"收集需求\", \"属于\", \"系统分析\"],\n",
      "    [\"分析过程\", \"属于\", \"系统分析\"],\n",
      "    [\"分析数据\", \"属于\", \"系统分析\"],\n",
      "    [\"系统设计\", \"属于\", \"案例：某系统开发项目管理\"],\n",
      "    [\"设计过程\", \"属于\", \"系统设计\"],\n",
      "    [\"设计数据\", \"属于\", \"系统设计\"],\n",
      "    [\"设计屏幕\", \"属于\", \"系统设计\"],\n",
      "    [\"设计报告\", \"属于\", \"系统设计\"],\n",
      "    [\"系统实现\", \"属于\", \"案例：某系统开发项目管理\"],\n",
      "    [\"程序\", \"属于\", \"系统实现\"],\n",
      "    [\"测试和文档\", \"属于\", \"系统实现\"],\n",
      "    [\"安装\", \"属于\", \"系统实现\"],\n",
      "    [\"估计任务周期和任务之间依赖关系\", \"属于\", \"案例：某系统开发项目管理\"],\n",
      "    [\"分配资源\", \"属于\", \"案例：某系统开发项目管理\"],\n",
      "    [\"监督和控制项目进展\", \"属于\", \"案例：某系统开发项目管理\"],\n",
      "    [\"项目经理角色\", \"属于\", \"本章小结\"],\n",
      "    [\"项目发起\", \"属于\", \"项目经理角色\"],\n",
      "    [\"项目规划\", \"属于\", \"项目经理角色\"],\n",
      "    [\"项目执行\", \"属于\", \"项目经理角色\"],\n",
      "    [\"项目终结\", \"属于\", \"项目经理角色\"],\n",
      "    [\"甘特图\", \"提及\", \"项目管理图形化技术\"],\n",
      "    [\"网络图\", \"提及\", \"项目管理图形化技术\"],\n",
      "    [\"关键路径规划\", \"属于\", \"网络图\"],\n",
      "    [\"自动化工具支持\", \"属于\", \"项目管理辅助手段\"],\n",
      "    [\"案例分析\", \"属于\", \"案例：某系统开发项目管理\"],\n",
      "    [\"银行前置机的软件系统项目\", \"属于\", \"案例分析\"],\n",
      "    [\"项目经理小丁\", \"担任\", \"案例分析\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "2871\n",
      "sleep:37.43477548314939秒\n",
      "————————————第19章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"本章小结\",\n",
      "    \"管理信息系统项目\",\n",
      "    \"项目经理\",\n",
      "    \"技术和管理技能\",\n",
      "    \"确定项目的规模、范围和资源需求\",\n",
      "    \"满足客户的要求\",\n",
      "    \"预算约束\",\n",
      "    \"时间约束\",\n",
      "    \"项目发起\",\n",
      "    \"评估项目的大小、范围和复杂性\",\n",
      "    \"建立支持后续项目活动的规程\",\n",
      "    \"项目规划\",\n",
      "    \"定义清楚的、离散的活动\",\n",
      "    \"完成每个活动需要做的工作\",\n",
      "    \"项目执行\",\n",
      "    \"将计划付诸于行动\",\n",
      "    \"项目终结\",\n",
      "    \"把项目带到结束\",\n",
      "    \"甘特图\",\n",
      "    \"显示活动的开始、工期和结束\",\n",
      "    \"网络图\",\n",
      "    \"关键路径规划技术\",\n",
      "    \"活动之间的相互关系\",\n",
      "    \"关键路径规划\",\n",
      "    \"项目活动顺序和工期\",\n",
      "    \"项目完成日期\",\n",
      "    \"松弛时间\",\n",
      "    \"项目进展监控\",\n",
      "    \"自动化工具\",\n",
      "    \"项目经理支持\",\n",
      "    \"任务定义和排序\",\n",
      "    \"任务资源分配\",\n",
      "    \"任务和资源修改能力\",\n",
      "    \"案例分析\",\n",
      "    \"系统集成公司\",\n",
      "    \"销售部\",\n",
      "    \"软件开发部\",\n",
      "    \"系统网络部\",\n",
      "    \"银行前置机软件系统项目\",\n",
      "    \"合同规定\",\n",
      "    \"试运行时间要求\",\n",
      "    \"项目经理小丁\",\n",
      "    \"系统分析工作经历\",\n",
      "    \"首次担任项目经理\",\n",
      "    \"兼任系统分析\",\n",
      "    \"项目团队成员构成\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"本章小结\", \"包含\", \"管理信息系统项目\"],\n",
      "    [\"本章小结\", \"包含\", \"项目经理\"],\n",
      "    [\"项目经理\", \"具备\", \"技术和管理技能\"],\n",
      "    [\"项目经理\", \"负责\", \"确定项目的规模、范围和资源需求\"],\n",
      "    [\"项目经理\", \"保证\", \"满足客户的要求\"],\n",
      "    [\"项目经理\", \"在\", \"预算约束\"],\n",
      "    [\"项目经理\", \"在\", \"时间约束\"],\n",
      "    [\"项目经理\", \"执行\", \"项目发起\"],\n",
      "    [\"项目发起\", \"包括\", \"评估项目的大小、范围和复杂性\"],\n",
      "    [\"项目发起\", \"包括\", \"建立支持后续项目活动的规程\"],\n",
      "    [\"项目经理\", \"执行\", \"项目规划\"],\n",
      "    [\"项目规划\", \"涉及\", \"定义清楚的、离散的活动\"],\n",
      "    [\"项目规划\", \"涉及\", \"完成每个活动需要做的工作\"],\n",
      "    [\"项目经理\", \"执行\", \"项目执行\"],\n",
      "    [\"项目执行\", \"是\", \"将计划付诸于行动\"],\n",
      "    [\"项目经理\", \"执行\", \"项目终结\"],\n",
      "    [\"项目终结\", \"指向\", \"把项目带到结束\"],\n",
      "    [\"项目管理工具\", \"包含\", \"甘特图\"],\n",
      "    [\"甘特图\", \"展示\", \"活动的开始、工期和结束\"],\n",
      "    [\"项目管理工具\", \"包含\", \"网络图\"],\n",
      "    [\"网络图\", \"属于\", \"关键路径规划技术\"],\n",
      "    [\"网络图\", \"描绘\", \"活动之间的相互关系\"],\n",
      "    [\"关键路径规划\", \"影响\", \"项目活动顺序和工期\"],\n",
      "    [\"项目监控\", \"使用\", \"甘特图\"],\n",
      "    [\"项目监控\", \"使用\", \"网络图\"],\n",
      "    [\"项目经理\", \"利用\", \"自动化工具\"],\n",
      "    [\"自动化工具\", \"支持\", \"任务定义和排序\"],\n",
      "    [\"自动化工具\", \"支持\", \"任务资源分配\"],\n",
      "    [\"自动化工具\", \"支持\", \"任务和资源修改能力\"],\n",
      "    [\"本章小结\", \"包含\", \"案例分析\"],\n",
      "    [\"案例分析\", \"提及\", \"系统集成公司\"],\n",
      "    [\"案例分析\", \"提及\", \"销售部\"],\n",
      "    [\"案例分析\", \"提及\", \"软件开发部\"],\n",
      "    [\"案例分析\", \"提及\", \"系统网络部\"],\n",
      "    [\"案例分析\", \"描述\", \"银行前置机软件系统项目\"],\n",
      "    [\"项目经理小丁\", \"担任\", \"首次担任项目经理\"],\n",
      "    [\"项目经理小丁\", \"有经验于\", \"系统分析工作\"],\n",
      "    [\"项目经理小丁\", \"在项目中\", \"兼任系统分析\"],\n",
      "    [\"案例分析\", \"列出\", \"项目团队成员构成\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "1905\n",
      "sleep:37.68857886398994秒\n",
      "————————————第20章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"案例分析\",\n",
      "    \"项目经理角色\",\n",
      "    \"项目管理流程\",\n",
      "    \"项目发起阶段\",\n",
      "    \"项目规划阶段\",\n",
      "    \"项目执行阶段\",\n",
      "    \"项目终结阶段\",\n",
      "    \"甘特图\",\n",
      "    \"网络图\",\n",
      "    \"关键路径法\",\n",
      "    \"WBS（工作分解结构）\",\n",
      "    \"风险管理\",\n",
      "    \"沟通与管理问题\",\n",
      "    \"项目进度监控\",\n",
      "    \"里程碑\",\n",
      "    \"任务依赖关系\",\n",
      "    \"期望时间计算\",\n",
      "    \"最早结束时间(EF)\",\n",
      "    \"最晚结束时间(LF)\",\n",
      "    \"松弛时间\",\n",
      "    \"关键路径确定\",\n",
      "    \"需求获取\",\n",
      "    \"访谈技术\",\n",
      "    \"观察工作者方式\",\n",
      "    \"业务文档分析\",\n",
      "    \"计算机支持\",\n",
      "    \"联合应用设计会议\",\n",
      "    \"原型方法\",\n",
      "    \"现代化需求获取方法\",\n",
      "    \"网络应用开发\",\n",
      "    \"系统需求获取的重要性\",\n",
      "    \"需求结构化\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"案例分析\", \"属于\", \"本章内容\"],\n",
      "    [\"项目经理角色\", \"属于\", \"案例分析\"],\n",
      "    [\"项目管理流程\", \"属于\", \"案例分析\"],\n",
      "    [\"项目发起阶段\", \"属于\", \"项目管理流程\"],\n",
      "    [\"项目规划阶段\", \"属于\", \"项目管理流程\"],\n",
      "    [\"项目执行阶段\", \"属于\", \"项目管理流程\"],\n",
      "    [\"项目终结阶段\", \"属于\", \"项目管理流程\"],\n",
      "    [\"甘特图\", \"属于\", \"项目管理工具\"],\n",
      "    [\"网络图\", \"属于\", \"项目管理工具\"],\n",
      "    [\"关键路径法\", \"属于\", \"项目管理工具\"],\n",
      "    [\"WBS（工作分解结构）\", \"属于\", \"项目规划阶段\"],\n",
      "    [\"风险管理\", \"属于\", \"项目发起阶段\"],\n",
      "    [\"沟通与管理问题\", \"属于\", \"案例分析\"],\n",
      "    [\"项目进度监控\", \"属于\", \"项目管理流程\"],\n",
      "    [\"里程碑\", \"用于\", \"项目进度管理\"],\n",
      "    [\"任务依赖关系\", \"用于\", \"项目计划制定\"],\n",
      "    [\"期望时间计算\", \"属于\", \"活动时间估算\"],\n",
      "    [\"最早结束时间(EF)\", \"用于\", \"项目进度计算\"],\n",
      "    [\"最晚结束时间(LF)\", \"用于\", \"项目进度计算\"],\n",
      "    [\"松弛时间\", \"用于\", \"项目进度控制\"],\n",
      "    [\"关键路径确定\", \"属于\", \"网络图应用\"],\n",
      "    [\"需求获取\", \"属于\", \"系统分析\"],\n",
      "    [\"访谈技术\", \"属于\", \"需求获取方法\"],\n",
      "    [\"观察工作者方式\", \"属于\", \"需求获取方法\"],\n",
      "    [\"业务文档分析\", \"属于\", \"需求获取方法\"],\n",
      "    [\"计算机支持\", \"用于\", \"需求获取过程\"],\n",
      "    [\"联合应用设计会议\", \"属于\", \"需求获取活动\"],\n",
      "    [\"原型方法\", \"属于\", \"需求获取方法\"],\n",
      "    [\"现代化需求获取方法\", \"用于\", \"系统开发生命周期\"],\n",
      "    [\"网络应用开发\", \"涉及\", \"需求获取技术\"],\n",
      "    [\"系统需求获取的重要性\", \"属于\", \"第4章内容\"],\n",
      "    [\"需求结构化\", \"属于\", \"系统分析阶段\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "3667\n",
      "sleep:38.22656910644351秒\n",
      "————————————第21章————————————\n",
      "{  \n",
      "  \"point\": [\n",
      "    \"需求获取的重要性\",\n",
      "    \"需求获取的过程和方法\",\n",
      "    \"访谈的选择与访谈计划的制订\",\n",
      "    \"观察工作者方式确定系统需求的优缺点\",\n",
      "    \"计算支持在需求获取中的作用\",\n",
      "    \"联合应用设计会议的参与和计划\",\n",
      "    \"原型在需求获取过程中的应用\",\n",
      "    \"现代化方法确定需求\",\n",
      "    \"需求获取技术在网络应用开发中的应用\",\n",
      "    \"系统需求概述\",\n",
      "    \"需求获取是系统分析的一部分\",\n",
      "    \"需求获取涉及的主要技能\",\n",
      "    \"需求获取失败的严重后果\",\n",
      "    \"系统分析员在需求获取中的角色\",\n",
      "    \"全面确定需求的重要性\",\n",
      "    \"需求获取中用户类需要和限制的理解\",\n",
      "    \"系统功能需求的来源\",\n",
      "    \"客户需求理解的重要性\",\n",
      "    \"客户—开发者合作对于需求获取成功的关键性\",\n",
      "    \"影响客户确定需求顺利的因素\",\n",
      "    \"信息系统开发者在需求获取中存在的问题\",\n",
      "    \"系统需求分类\",\n",
      "    \"用户视角下的系统需求\",\n",
      "    \"开发者视角下的系统需求\",\n",
      "    \"业务需求的定义\",\n",
      "    \"用户需求的定义\",\n",
      "    \"功能需求的定义及举例（图书管理系统）\",\n",
      "    \"非功能需求的定义\",\n",
      "    \"常见的非功能需求及其说明\",\n",
      "    \"需求分析故事：沟通误解与需求确认的重要性\",\n",
      "    \"需求获取过程中严谨询问和确定需求的必要性\",\n",
      "    \"不同用户关注点对需求的影响\",\n",
      "    \"多角度掂量和评估客户需求\",\n",
      "    \"项目经理在需求获取阶段的经验教训\",\n",
      "    \"寻找问题解决方案的五个步骤摘要\",\n",
      "    \"对专业的新理解：思考比单纯技术更重要\",\n",
      "    \"需求获取过程\",\n",
      "    \"需求获取阶段收集信息的途径\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"需求获取的重要性\", \"属于\", \"系统需求概述\"],\n",
      "    [\"需求获取的过程和方法\", \"属于\", \"系统需求概述\"],\n",
      "    [\"访谈的选择与访谈计划的制订\", \"属于\", \"需求获取的过程和方法\"],\n",
      "    [\"观察工作者方式确定系统需求的优缺点\", \"属于\", \"需求获取的过程和方法\"],\n",
      "    [\"计算支持在需求获取中的作用\", \"属于\", \"需求获取的过程和方法\"],\n",
      "    [\"联合应用设计会议的参与和计划\", \"属于\", \"需求获取的过程和方法\"],\n",
      "    [\"原型在需求获取过程中的应用\", \"属于\", \"需求获取的过程和方法\"],\n",
      "    [\"现代化方法确定需求\", \"属于\", \"需求获取的过程和方法\"],\n",
      "    [\"需求获取技术在网络应用开发中的应用\", \"属于\", \"系统需求概述\"],\n",
      "    [\"系统需求概述\", \"属于\", \"第4章 需求获取\"],\n",
      "    [\"需求获取是系统分析的一部分\", \"属于\", \"系统需求概述\"],\n",
      "    [\"需求获取涉及的主要技能\", \"属于\", \"系统需求概述\"],\n",
      "    [\"需求获取失败的严重后果\", \"属于\", \"系统需求概述\"],\n",
      "    [\"系统分析员在需求获取中的角色\", \"属于\", \"系统需求概述\"],\n",
      "    [\"全面确定需求的重要性\", \"属于\", \"系统需求概述\"],\n",
      "    [\"需求获取中用户类需要和限制的理解\", \"属于\", \"系统需求概述\"],\n",
      "    [\"系统功能需求的来源\", \"属于\", \"系统需求概述\"],\n",
      "    [\"客户需求理解的重要性\", \"属于\", \"系统需求概述\"],\n",
      "    [\"客户—开发者合作对于需求获取成功的关键性\", \"属于\", \"系统需求概述\"],\n",
      "    [\"影响客户确定需求顺利的因素\", \"属于\", \"系统需求概述\"],\n",
      "    [\"信息系统开发者在需求获取中存在的问题\", \"属于\", \"系统需求概述\"],\n",
      "    [\"系统需求分类\", \"属于\", \"系统需求概述\"],\n",
      "    [\"用户视角下的系统需求\", \"属于\", \"系统需求分类\"],\n",
      "    [\"开发者视角下的系统需求\", \"属于\", \"系统需求分类\"],\n",
      "    [\"业务需求\", \"属于\", \"系统需求分类\"],\n",
      "    [\"用户需求\", \"属于\", \"系统需求分类\"],\n",
      "    [\"功能需求\", \"属于\", \"系统需求分类\"],\n",
      "    [\"非功能需求\", \"属于\", \"系统需求分类\"]\n",
      "  ]\n",
      "}\n",
      "4907\n",
      "sleep:37.66966592673149秒\n",
      "————————————第22章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"需求获取过程\",\n",
      "    \"了解用户需求\",\n",
      "    \"分析用户需求\",\n",
      "    \"编写需求文档\",\n",
      "    \"评审需求文档\",\n",
      "    \"需求管理\",\n",
      "    \"需求变更\",\n",
      "    \"需求跟踪\",\n",
      "    \"访谈\",\n",
      "    \"观察和分析文档的笔记\",\n",
      "    \"书面信息来源\",\n",
      "    \"基于计算机的信息来源\",\n",
      "    \"需求获取途径\",\n",
      "    \"确定问题来源\",\n",
      "    \"确定问题所属者\",\n",
      "    \"发现真正问题所在\",\n",
      "    \"在特定层面上理解问题\",\n",
      "    \"寻求合理解决方案\",\n",
      "    \"质疑是否需要解决问题\",\n",
      "    \"多样化思考\",\n",
      "    \"需求获取活动\",\n",
      "    \"识别系统用户\",\n",
      "    \"用户调研与访谈\",\n",
      "    \"访谈结果整理\",\n",
      "    \"访谈结果呈现\",\n",
      "    \"需求的一致性\",\n",
      "    \"需求规格说明\",\n",
      "    \"需求陈述内容\",\n",
      "    \"功能需求\",\n",
      "    \"非功能需求\",\n",
      "    \"约束条件\",\n",
      "    \"接口需求\",\n",
      "    \"需求文档评审\",\n",
      "    \"用户评审\",\n",
      "    \"同行评审\",\n",
      "    \"需求基线\",\n",
      "    \"需求变更请求\",\n",
      "    \"变更影响分析\",\n",
      "    \"变更批准\",\n",
      "    \"变更执行\",\n",
      "    \"变更测试\",\n",
      "    \"变更结束\",\n",
      "    \"需求跟踪矩阵\",\n",
      "    \"需求跟踪目的\",\n",
      "    \"需求与设计一致性\",\n",
      "    \"需求获取方法\",\n",
      "    \"传统需求收集方法\",\n",
      "    \"名义团体技术\",\n",
      "    \"原型构建\",\n",
      "    \"联合应用设计会议\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"需求获取过程\", \"包含\", \"了解用户需求\"],\n",
      "    [\"需求获取过程\", \"包含\", \"分析用户需求\"],\n",
      "    [\"需求获取过程\", \"包含\", \"编写需求文档\"],\n",
      "    [\"需求获取过程\", \"包含\", \"评审需求文档\"],\n",
      "    [\"需求获取过程\", \"包含\", \"需求管理\"],\n",
      "    [\"需求管理\", \"包含\", \"需求变更\"],\n",
      "    [\"需求管理\", \"包含\", \"需求跟踪\"],\n",
      "    [\"需求获取途径\", \"属于\", \"需求获取过程\"],\n",
      "    [\"了解用户需求\", \"属于\", \"需求获取过程\"],\n",
      "    [\"分析用户需求\", \"属于\", \"需求获取过程\"],\n",
      "    [\"编写需求文档\", \"属于\", \"需求获取过程\"],\n",
      "    [\"评审需求文档\", \"属于\", \"需求获取过程\"],\n",
      "    [\"访谈\", \"属于\", \"需求获取方法\"],\n",
      "    [\"观察和分析文档的笔记\", \"属于\", \"需求获取途径\"],\n",
      "    [\"书面信息来源\", \"属于\", \"需求获取途径\"],\n",
      "    [\"基于计算机的信息来源\", \"属于\", \"需求获取途径\"],\n",
      "    [\"需求变更\", \"属于\", \"需求管理\"],\n",
      "    [\"需求跟踪\", \"属于\", \"需求管理\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "4587\n",
      "sleep:38.35536829995321秒\n",
      "————————————第23章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"需求获取的方法\",\n",
      "    \"需求跟踪矩阵\",\n",
      "    \"访谈\",\n",
      "    \"访谈前提\",\n",
      "    \"关键的信息持有者\",\n",
      "    \"访谈准备\",\n",
      "    \"用户访谈和调研的准备\",\n",
      "    \"访谈提纲\",\n",
      "    \"联合应用设计(JAD)\",\n",
      "    \"名义团体技术(NGT)\",\n",
      "    \"直接观察用户\",\n",
      "    \"文档、文件、表格抽样\",\n",
      "    \"书面工作规程\",\n",
      "    \"业务表格\",\n",
      "    \"现有系统产生的报告\",\n",
      "    \"联合应用设计会议的角色\",\n",
      "    \"JAD会议经理\",\n",
      "    \"用户\",\n",
      "    \"管理者\",\n",
      "    \"发起人\",\n",
      "    \"系统分析员\",\n",
      "    \"抄写员\",\n",
      "    \"IS人员\",\n",
      "    \"原型法\",\n",
      "    \"需求调查分析\",\n",
      "    \"需求原型设计\",\n",
      "    \"需求评审\",\n",
      "    \"原型法适用情况\",\n",
      "    \"原型法缺点\",\n",
      "    \"客户关系管理系统的需求获取案例\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"需求跟踪矩阵\", \"属于\", \"需求获取的方法\"],\n",
      "    [\"访谈\", \"属于\", \"需求获取的方法\"],\n",
      "    [\"访谈前提\", \"属于\", \"访谈\"],\n",
      "    [\"关键的信息持有者\", \"属于\", \"访谈前提\"],\n",
      "    [\"访谈准备\", \"属于\", \"访谈\"],\n",
      "    [\"用户访谈和调研的准备\", \"属于\", \"访谈准备\"],\n",
      "    [\"访谈提纲\", \"属于\", \"访谈准备\"],\n",
      "    [\"联合应用设计(JAD)\", \"属于\", \"需求获取的方法\"],\n",
      "    [\"名义团体技术(NGT)\", \"属于\", \"需求获取的方法\"],\n",
      "    [\"直接观察用户\", \"属于\", \"需求获取的方法\"],\n",
      "    [\"文档、文件、表格抽样\", \"属于\", \"需求获取的方法\"],\n",
      "    [\"书面工作规程\", \"属于\", \"文档、文件、表格抽样\"],\n",
      "    [\"业务表格\", \"属于\", \"文档、文件、表格抽样\"],\n",
      "    [\"现有系统产生的报告\", \"属于\", \"文档、文件、表格抽样\"],\n",
      "    [\"联合应用设计会议的角色\", \"属于\", \"联合应用设计(JAD)\"],\n",
      "    [\"JAD会议经理\", \"属于\", \"联合应用设计会议的角色\"],\n",
      "    [\"用户\", \"属于\", \"联合应用设计会议的角色\"],\n",
      "    [\"管理者\", \"属于\", \"联合应用设计会议的角色\"],\n",
      "    [\"发起人\", \"属于\", \"联合应用设计会议的角色\"],\n",
      "    [\"系统分析员\", \"属于\", \"联合应用设计会议的角色\"],\n",
      "    [\"抄写员\", \"属于\", \"联合应用设计会议的角色\"],\n",
      "    [\"IS人员\", \"属于\", \"联合应用设计会议的角色\"],\n",
      "    [\"原型法\", \"属于\", \"需求获取的方法\"],\n",
      "    [\"需求调查分析\", \"属于\", \"原型法\"],\n",
      "    [\"需求原型设计\", \"属于\", \"原型法\"],\n",
      "    [\"需求评审\", \"属于\", \"原型法\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "4537\n",
      "sleep:38.429378191476864秒\n",
      "————————————第24章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"案例分析——客户关系管理系统的需求获取\",\n",
      "    \"系统简化原型\",\n",
      "    \"需求原型设计要求\",\n",
      "    \"充分考虑系统的设计与实现\",\n",
      "    \"仿真实际系统的操作界面\",\n",
      "    \"单机安装运行\",\n",
      "    \"演示数据的存储方式\",\n",
      "    \"功能帮助按钮\",\n",
      "    \"标注详细说明复杂功能\",\n",
      "    \"运行稳定，硬件要求低\",\n",
      "    \"需求评审\",\n",
      "    \"评审团成员构成\",\n",
      "    \"评审依据\",\n",
      "    \"评审目标\",\n",
      "    \"需求分析说明书的要求\",\n",
      "    \"需求评审报告的作用\",\n",
      "    \"原型法进行需求获取的应用情况\",\n",
      "    \"原型法的缺点\",\n",
      "    \"正式系统需求文档的缺失\",\n",
      "    \"针对最初用户的局限性\",\n",
      "    \"忽略与其他系统的共享和交互\",\n",
      "    \"绕过 SDLC 中的检查\",\n",
      "    \"音像连锁店的客户关系管理系统\",\n",
      "    \"基于 WEB 的系统\",\n",
      "    \"信息服务功能\",\n",
      "    \"客户需求调研方案\",\n",
      "    \"系统所有者面谈问题设置\",\n",
      "    \"公司整体发展战略\",\n",
      "    \"预期效果\",\n",
      "    \"项目预算\",\n",
      "    \"项目工期\",\n",
      "    \"系统预期使用寿命\",\n",
      "    \"系统处理能力\",\n",
      "    \"系统使用部门及权限分配\",\n",
      "    \"信息公开程度\",\n",
      "    \"客户反馈处理\",\n",
      "    \"响应新产品请求的时间\",\n",
      "    \"更新库存信息时间\",\n",
      "    \"系统用户调研策略\",\n",
      "    \"门店经理面谈问题设置\",\n",
      "    \"现有客户服务内容\",\n",
      "    \"租赁期限\",\n",
      "    \"新产品请求收集处理\",\n",
      "    \"客户调查表问题设置\",\n",
      "    \"产品评价反馈\",\n",
      "    \"新产品需求告知方式\",\n",
      "    \"租赁到期查询\",\n",
      "    \"优惠续借\",\n",
      "    \"库存查询\",\n",
      "    \"子女购买租赁商品信息\",\n",
      "    \"库存管理员实地访问面谈问题设置\",\n",
      "    \"库存策略\",\n",
      "    \"库存信息流动\",\n",
      "    \"供应商接口预留\",\n",
      "    \"门店间库存差异\",\n",
      "    \"最低订购点\",\n",
      "    \"订单发货周期\",\n",
      "    \"本章小结\",\n",
      "    \"需求获取过程\",\n",
      "    \"用户访谈\",\n",
      "    \"现场调研\",\n",
      "    \"收集报告表格规程\",\n",
      "    \"需求管理\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"需求原型设计要求\", \"属于\", \"需求原型设计\"],\n",
      "    [\"充分考虑系统的设计与实现\", \"属于\", \"需求原型设计要求\"],\n",
      "    [\"仿真实际系统的操作界面\", \"属于\", \"需求原型设计要求\"],\n",
      "    [\"单机安装运行\", \"属于\", \"需求原型设计要求\"],\n",
      "    [\"演示数据的存储方式\", \"属于\", \"需求原型设计要求\"],\n",
      "    [\"功能帮助按钮\", \"属于\", \"需求原型设计要求\"],\n",
      "    [\"标注详细说明复杂功能\", \"属于\", \"需求原型设计要求\"],\n",
      "    [\"运行稳定，硬件要求低\", \"属于\", \"需求原型设计要求\"],\n",
      "    [\"需求评审\", \"属于\", \"案例分析——客户关系管理系统的需求获取\"],\n",
      "    [\"评审团成员构成\", \"属于\", \"需求评审\"],\n",
      "    [\"评审依据\", \"属于\", \"需求评审\"],\n",
      "    [\"评审目标\", \"属于\", \"需求评审\"],\n",
      "    [\"需求分析说明书的要求\", \"属于\", \"评审目标\"],\n",
      "    [\"需求评审报告的作用\", \"属于\", \"需求评审\"],\n",
      "    [\"原型法进行需求获取的应用情况\", \"属于\", \"案例分析——客户关系管理系统的需求获取\"],\n",
      "    [\"原型法的缺点\", \"属于\", \"原型法进行需求获取\"],\n",
      "    [\"正式系统需求文档的缺失\", \"属于\", \"原型法的缺点\"],\n",
      "    [\"针对最初用户的局限性\", \"属于\", \"原型法的缺点\"],\n",
      "    [\"忽略与其他系统的共享和交互\", \"属于\", \"原型法的缺点\"],\n",
      "    [\"绕过 SDLC 中的检查\", \"属于\", \"原型法的缺点\"],\n",
      "    [\"音像连锁店的客户关系管理系统\", \"属于\", \"案例分析——客户关系管理系统的需求获取\"],\n",
      "    [\"基于 WEB 的系统\", \"属于\", \"音像连锁店的客户关系管理系统\"],\n",
      "    [\"信息服务功能\", \"属于\", \"音像连锁店的客户关系管理系统\"],\n",
      "    [\"客户需求调研方案\", \"属于\", \"案例分析——客户关系管理系统的需求获取\"],\n",
      "    [\"系统所有者面谈问题设置\", \"属于\", \"客户需求调研方案\"],\n",
      "    [\"公司整体发展战略\", \"属于\", \"系统所有者面谈问题设置\"],\n",
      "    [\"预期效果\", \"属于\", \"系统所有者面谈问题设置\"],\n",
      "    [\"项目预算\", \"属于\", \"系统所有者面谈问题设置\"],\n",
      "    [\"项目工期\", \"属于\", \"系统所有者面谈问题设置\"],\n",
      "    [\"系统预期使用寿命\", \"属于\", \"系统所有者面谈问题设置\"],\n",
      "    [\"系统处理能力\", \"属于\", \"系统所有者面谈问题设置\"],\n",
      "    [\"系统使用部门及权限分配\", \"属于\", \"系统所有者面谈问题设置\"],\n",
      "    [\"信息公开程度\", \"属于\", \"系统所有者面谈问题设置\"],\n",
      "    [\"客户反馈处理\", \"属于\", \"系统所有者面谈问题设置\"],\n",
      "    [\"响应新产品请求的时间\", \"属于\", \"系统所有者面谈问题设置\"],\n",
      "    [\"更新库存信息时间\", \"属于\", \"系统所有者面谈问题设置\"],\n",
      "    [\"系统用户调研策略\", \"属于\", \"客户需求调研方案\"],\n",
      "    [\"门店经理面谈问题设置\", \"属于\", \"系统用户调研策略\"],\n",
      "    [\"现有客户服务内容\", \"属于\", \"门店经理面谈问题设置\"],\n",
      "    [\"租赁期限\", \"属于\", \"门店经理面谈问题设置\"],\n",
      "    [\"新产品请求收集处理\", \"属于\", \"门店经理面谈问题设置\"],\n",
      "    [\"客户调查表问题设置\", \"属于\", \"系统用户调研策略\"],\n",
      "    [\"产品评价反馈\", \"属于\", \"客户调查表问题设置\"],\n",
      "    [\"新产品需求告知方式\", \"属于\", \"客户调查表问题设置\"],\n",
      "    [\"租赁到期查询\", \"属于\", \"客户调查表问题设置\"],\n",
      "    [\"优惠续借\", \"属于\", \"客户调查表问题设置\"],\n",
      "    [\"库存查询\", \"属于\", \"客户调查表问题设置\"],\n",
      "    [\"子女购买租赁商品信息\", \"属于\", \"客户调查表问题设置\"],\n",
      "    [\"库存管理员实地访问面谈问题设置\", \"属于\", \"客户需求调研方案\"],\n",
      "    [\"库存策略\", \"属于\", \"库存管理员实地访问面谈问题设置\"],\n",
      "    [\"库存信息流动\", \"属于\", \"库存管理员实地访问面谈问题设置\"],\n",
      "    [\"供应商接口预留\", \"属于\", \"库存管理员实地访问面谈问题设置\"],\n",
      "    [\"门店间库存差异\", \"属于\", \"库存管理员实地访问面谈问题设置\"],\n",
      "    [\"最低订购点\", \"属于\", \"库存管理员实地访问面谈问题设置\"],\n",
      "    [\"订单发货周期\", \"属于\", \"库存管理员实地访问面谈问题设置\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "3621\n",
      "sleep:38.45387622555948秒\n",
      "————————————第25章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"本章小结\",\n",
      "    \"需求获取\",\n",
      "    \"了解用户需求\",\n",
      "    \"分析用户需求\",\n",
      "    \"编写需求文档\",\n",
      "    \"评审需求文档\",\n",
      "    \"需求管理\",\n",
      "    \"系统分析员\",\n",
      "    \"用户访谈\",\n",
      "    \"现场调研\",\n",
      "    \"收集报告\",\n",
      "    \"表格和规程\",\n",
      "    \"人事档案系统\",\n",
      "    \"人事变动管理\",\n",
      "    \"访谈提纲设计\",\n",
      "    \"账单系统调研\",\n",
      "    \"调研提纲设计\",\n",
      "    \"电信设备供应商案例\",\n",
      "    \"需求获取问题\",\n",
      "    \"需求获取改进方式\",\n",
      "    \"过程建模\",\n",
      "    \"逻辑过程建模\",\n",
      "    \"数据流图\",\n",
      "    \"绘制数据流图\",\n",
      "    \"过程模型\",\n",
      "    \"数据如何流过系统\",\n",
      "    \"数据流之间的关系\",\n",
      "    \"数据储存\",\n",
      "    \"数据变更或转换过程\",\n",
      "    \"逻辑模型\",\n",
      "    \"非技术性图形化表示\",\n",
      "    \"概念模型\",\n",
      "    \"业务模型\",\n",
      "    \"消除实现方式偏见\",\n",
      "    \"降低丢失业务需求风险\",\n",
      "    \"非技术性语言沟通\",\n",
      "    \"过程建模技术\",\n",
      "    \"记录系统过程\",\n",
      "    \"系统过程的逻辑、策略和程序\",\n",
      "    \"数据流程图\",\n",
      "    \"数据转换和流动状况\",\n",
      "    \"内部逻辑概括描述\",\n",
      "    \"理解与表达用户需求\",\n",
      "    \"用户沟通交流工具\",\n",
      "    \"新系统逻辑模型\",\n",
      "    \"数据流程图的基本符号\",\n",
      "    \"外部实体\",\n",
      "    \"处理过程\",\n",
      "    \"数据存储\",\n",
      "    \"系统中数据流\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"需求获取\", \"属于\", \"本章小结\"],\n",
      "    [\"了解用户需求\", \"属于\", \"需求获取\"],\n",
      "    [\"分析用户需求\", \"属于\", \"需求获取\"],\n",
      "    [\"编写需求文档\", \"属于\", \"需求获取\"],\n",
      "    [\"评审需求文档\", \"属于\", \"需求获取\"],\n",
      "    [\"需求管理\", \"属于\", \"需求获取\"],\n",
      "    [\"逻辑过程建模\", \"属于\", \"过程建模\"],\n",
      "    [\"数据流图\", \"属于\", \"过程建模\"],\n",
      "    [\"绘制数据流图\", \"属于\", \"数据流图\"],\n",
      "    [\"过程模型\", \"属于\", \"数据流图\"],\n",
      "    [\"逻辑模型\", \"属于\", \"过程建模\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "1859\n",
      "sleep:38.39630280809745秒\n",
      "————————————第26章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"过程建模\",\n",
      "    \"逻辑过程建模\",\n",
      "    \"数据流图绘制规则\",\n",
      "    \"低层次图形分解\",\n",
      "    \"高层与低层数据流图平衡\",\n",
      "    \"四种类型的数据流图区别\",\n",
      "    \"当前的物理流程图\",\n",
      "    \"当前的逻辑流程图\",\n",
      "    \"新的物理流程图\",\n",
      "    \"新的逻辑流程图\",\n",
      "    \"信息系统分析支持\",\n",
      "    \"规范化方法表达需求\",\n",
      "    \"数据流图（DFD）\",\n",
      "    \"过程模型\",\n",
      "    \"逻辑模型\",\n",
      "    \"非技术性图形化表示\",\n",
      "    \"概念模型\",\n",
      "    \"业务模型\",\n",
      "    \"消除实现方式偏见\",\n",
      "    \"降低丢失业务需求风险\",\n",
      "    \"与最终用户沟通\",\n",
      "    \"数据流图的概念和作用\",\n",
      "    \"系统数据转换和流动状况描述\",\n",
      "    \"内部逻辑概括\",\n",
      "    \"理解用户需求工具\",\n",
      "    \"用户沟通交流工具\",\n",
      "    \"新系统逻辑模型组成部分\",\n",
      "    \"数据流程图基本符号\",\n",
      "    \"外部实体\",\n",
      "    \"处理过程\",\n",
      "    \"数据存储\",\n",
      "    \"系统中数据流\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"逻辑过程建模\", \"属于\", \"过程建模\"],\n",
      "    [\"数据流图绘制规则\", \"属于\", \"过程建模\"],\n",
      "    [\"低层次图形分解\", \"属于\", \"过程建模\"],\n",
      "    [\"高层与低层数据流图平衡\", \"属于\", \"过程建模\"],\n",
      "    [\"四种类型的数据流图区别\", \"属于\", \"过程建模\"],\n",
      "    [\"当前的物理流程图\", \"属于\", \"四种类型的数据流图区别\"],\n",
      "    [\"当前的逻辑流程图\", \"属于\", \"四种类型的数据流图区别\"],\n",
      "    [\"新的物理流程图\", \"属于\", \"四种类型的数据流图区别\"],\n",
      "    [\"新的逻辑流程图\", \"属于\", \"四种类型的数据流图区别\"],\n",
      "    [\"信息系统分析支持\", \"属于\", \"过程建模\"],\n",
      "    [\"规范化方法表达需求\", \"属于\", \"过程建模\"],\n",
      "    [\"数据流图（DFD）\", \"属于\", \"过程建模\"],\n",
      "    [\"过程模型\", \"由\", \"数据流图（DFD）\"],\n",
      "    [\"逻辑模型\", \"属于\", \"过程建模\"],\n",
      "    [\"非技术性图形化表示\", \"属于\", \"逻辑模型\"],\n",
      "    [\"概念模型\", \"等于\", \"逻辑模型\"],\n",
      "    [\"业务模型\", \"等于\", \"逻辑模型\"],\n",
      "    [\"数据流图的概念和作用\", \"属于\", \"数据流图（DFD）\"],\n",
      "    [\"系统数据转换和流动状况描述\", \"属于\", \"数据流图（DFD）\"],\n",
      "    [\"内部逻辑概括\", \"属于\", \"数据流图（DFD）\"],\n",
      "    [\"理解用户需求工具\", \"属于\", \"数据流图（DFD）\"],\n",
      "    [\"用户沟通交流工具\", \"属于\", \"数据流图（DFD）\"],\n",
      "    [\"新系统逻辑模型组成部分\", \"属于\", \"数据流图（DFD）\"],\n",
      "    [\"数据流程图基本符号\", \"属于\", \"数据流图（DFD）\"],\n",
      "    [\"外部实体\", \"是\", \"数据流程图基本符号组成部分\"],\n",
      "    [\"处理过程\", \"是\", \"数据流程图基本符号组成部分\"],\n",
      "    [\"数据存储\", \"是\", \"数据流程图基本符号组成部分\"],\n",
      "    [\"系统中数据流\", \"是\", \"数据流程图基本符号组成部分\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "1573\n",
      "sleep:38.19041117756646秒\n",
      "————————————第27章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"过程建模\",\n",
      "    \"逻辑过程建模\",\n",
      "    \"数据流图\",\n",
      "    \"当前的物理流程图\",\n",
      "    \"当前的逻辑流程图\",\n",
      "    \"新的物理流程图\",\n",
      "    \"新的逻辑流程图\",\n",
      "    \"信息系统需求规范化表达\",\n",
      "    \"数据如何流过系统\",\n",
      "    \"数据流之间的关系\",\n",
      "    \"数据如何储存\",\n",
      "    \"过程模型\",\n",
      "    \"逻辑模型\",\n",
      "    \"非技术性的图形化表示\",\n",
      "    \"概念模型\",\n",
      "    \"业务模型\",\n",
      "    \"消除实现方式偏见\",\n",
      "    \"降低丢失业务需求风险\",\n",
      "    \"与最终用户沟通交流\",\n",
      "    \"数据流程图的概念和作用\",\n",
      "    \"内部逻辑概况和细节\",\n",
      "    \"理解表达用户需求\",\n",
      "    \"外部实体\",\n",
      "    \"源点/终点\",\n",
      "    \"数据输入源点\",\n",
      "    \"数据输出终点\",\n",
      "    \"指明系统边界\",\n",
      "    \"过程\",\n",
      "    \"处理或转换\",\n",
      "    \"功能过程\",\n",
      "    \"事件过程\",\n",
      "    \"基本过程\",\n",
      "    \"数据输入\",\n",
      "    \"数据处理\",\n",
      "    \"数据输出\",\n",
      "    \"数据流\",\n",
      "    \"流动中的数据\",\n",
      "    \"组合数据流\",\n",
      "    \"分支的数据流\",\n",
      "    \"数据存储\",\n",
      "    \"静止的数据\",\n",
      "    \"文件和数据库\",\n",
      "    \"数据流图的绘制\",\n",
      "    \"分层方法\",\n",
      "    \"顶层图\",\n",
      "    \"环境图\",\n",
      "    \"0层图\",\n",
      "    \"中间层流图\",\n",
      "    \"基本处理\",\n",
      "    \"食品订单系统\",\n",
      "    \"环境边界\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"数据流图\", \"属于\", \"过程建模\"],\n",
      "    [\"逻辑过程建模\", \"属于\", \"过程建模\"],\n",
      "    [\"当前的物理流程图\", \"属于\", \"数据流图\"],\n",
      "    [\"当前的逻辑流程图\", \"属于\", \"数据流图\"],\n",
      "    [\"新的物理流程图\", \"属于\", \"数据流图\"],\n",
      "    [\"新的逻辑流程图\", \"属于\", \"数据流图\"],\n",
      "    [\"逻辑模型\", \"属于\", \"过程建模\"],\n",
      "    [\"数据流程图的概念和作用\", \"属于\", \"数据流图\"],\n",
      "    [\"外部实体\", \"属于\", \"数据流图\"],\n",
      "    [\"过程\", \"属于\", \"数据流图\"],\n",
      "    [\"数据流\", \"属于\", \"数据流图\"],\n",
      "    [\"数据存储\", \"属于\", \"数据流图\"],\n",
      "    [\"数据流图的绘制\", \"属于\", \"数据流图\"],\n",
      "    [\"顶层图\", \"属于\", \"数据流图的绘制\"],\n",
      "    [\"0层图\", \"属于\", \"数据流图的绘制\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "2878\n",
      "sleep:38.765470768616495秒\n",
      "————————————第28章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"分层数据流程图\",\n",
      "    \"顶层图\",\n",
      "    \"环境图\",\n",
      "    \"0 层数据流图\",\n",
      "    \"中间层流图\",\n",
      "    \"基本处理\",\n",
      "    \"父图\",\n",
      "    \"子图\",\n",
      "    \"食品订餐系统\",\n",
      "    \"接收并转换客户订单过程\",\n",
      "    \"更新已销售文件过程\",\n",
      "    \"更新库存文件过程\",\n",
      "    \"产生管理报告过程\",\n",
      "    \"数据存储\",\n",
      "    \"数据流规则\",\n",
      "    \"命名规则\",\n",
      "    \"过程规则\",\n",
      "    \"数据存储规则\",\n",
      "    \"外部实体规则\",\n",
      "    \"数据流规则\",\n",
      "    \"DFD 的分解\",\n",
      "    \"功能分解\",\n",
      "    \"基本 DFD\",\n",
      "    \"平衡 DFD\",\n",
      "    \"组合数据流\",\n",
      "    \"组件数据流\",\n",
      "    \"过程逻辑\",\n",
      "    \"结构化语言\",\n",
      "    \"决策表\",\n",
      "    \"决策树\",\n",
      "    \"顺序结构\",\n",
      "    \"判断结构\",\n",
      "    \"循环结构\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"顶层图\", \"属于\", \"分层数据流程图\"],\n",
      "    [\"环境图\", \"等于\", \"顶层图\"],\n",
      "    [\"0 层数据流图\", \"属于\", \"分层数据流程图\"],\n",
      "    [\"中间层流图\", \"细化\", \"上层父图\"],\n",
      "    [\"基本处理\", \"组成\", \"底层\"],\n",
      "    [\"子图\", \"属于\", \"父图\"],\n",
      "    [\"接收并转换客户订单过程\", \"属于\", \"食品订餐系统\"],\n",
      "    [\"更新已销售文件过程\", \"属于\", \"食品订餐系统\"],\n",
      "    [\"更新库存文件过程\", \"属于\", \"食品订餐系统\"],\n",
      "    [\"产生管理报告过程\", \"属于\", \"食品订餐系统\"],\n",
      "    [\"数据存储\", \"关联于\", \"数据流\"],\n",
      "    [\"数据流规则\", \"应用于\", \"分层数据流程图\"],\n",
      "    [\"命名规则\", \"属于\", \"数据流规则\"],\n",
      "    [\"过程规则\", \"属于\", \"数据流规则\"],\n",
      "    [\"数据存储规则\", \"属于\", \"数据流规则\"],\n",
      "    [\"外部实体规则\", \"属于\", \"数据流规则\"],\n",
      "    [\"数据流规则\", \"属于\", \"数据流规则\"],\n",
      "    [\"DFD 的分解\", \"涉及\", \"分层数据流程图\"],\n",
      "    [\"功能分解\", \"实现\", \"DFD 的分解\"],\n",
      "    [\"基本 DFD\", \"为\", \"最低层次的 DFD\"],\n",
      "    [\"平衡 DFD\", \"保证\", \"输入和输出的一致性\"],\n",
      "    [\"组合数据流\", \"可以分解为\", \"组件数据流\"],\n",
      "    [\"过程逻辑\", \"描述\", \"DFD 中的基本过程\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "4409\n",
      "sleep:38.276028753028115秒\n",
      "————————————第29章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"过程逻辑\",\n",
      "    \"管控数据流图的高级规则\",\n",
      "    \"组合数据流分解\",\n",
      "    \"过程输入与输出的关系\",\n",
      "    \"在最底层DFD中添加新数据流的原因\",\n",
      "    \"避免数据流线交叉的方法\",\n",
      "    \"数据流图的作用\",\n",
      "    \"数据流图与程序流程图的区别\",\n",
      "    \"逻辑模型的有效沟通\",\n",
      "    \"结构化语言\",\n",
      "    \"顺序结构\",\n",
      "    \"祈使语句\",\n",
      "    \"选择结构\",\n",
      "    \"多重选择\",\n",
      "    \"Do-Until循环\",\n",
      "    \"Do-While循环\",\n",
      "    \"决策表\",\n",
      "    \"条件段\",\n",
      "    \"行动段\",\n",
      "    \"规则\",\n",
      "    \"规则合并\",\n",
      "    \"无关条件\",\n",
      "    \"构造决策表的基本步骤\",\n",
      "    \"决策树\",\n",
      "    \"决策点\",\n",
      "    \"行动\",\n",
      "    \"邮寄包收费标准问题逻辑建模\",\n",
      "    \"数据字典\",\n",
      "    \"数据项\",\n",
      "    \"数据结构\",\n",
      "    \"数据流\",\n",
      "    \"数据存储\",\n",
      "    \"处理功能\",\n",
      "    \"外部项\",\n",
      "    \"数据项字典内容\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"过程逻辑\", \"属于\", \"第五章\"],\n",
      "    [\"管控数据流图的高级规则\", \"属于\", \"过程逻辑\"],\n",
      "    [\"组合数据流分解\", \"属于\", \"管控数据流图的高级规则\"],\n",
      "    [\"过程输入与输出的关系\", \"属于\", \"管控数据流图的高级规则\"],\n",
      "    [\"在最底层DFD中添加新数据流的原因\", \"属于\", \"管控数据流图的高级规则\"],\n",
      "    [\"避免数据流线交叉的方法\", \"属于\", \"管控数据流图的高级规则\"],\n",
      "    [\"数据流图的作用\", \"属于\", \"过程逻辑\"],\n",
      "    [\"数据流图与程序流程图的区别\", \"属于\", \"过程逻辑\"],\n",
      "    [\"逻辑模型的有效沟通\", \"属于\", \"过程逻辑\"],\n",
      "    [\"结构化语言\", \"属于\", \"过程逻辑\"],\n",
      "    [\"顺序结构\", \"属于\", \"结构化语言\"],\n",
      "    [\"祈使语句\", \"属于\", \"顺序结构\"],\n",
      "    [\"选择结构\", \"属于\", \"结构化语言\"],\n",
      "    [\"多重选择\", \"属于\", \"选择结构\"],\n",
      "    [\"Do-Until循环\", \"属于\", \"结构化语言\"],\n",
      "    [\"Do-While循环\", \"属于\", \"结构化语言\"],\n",
      "    [\"决策表\", \"属于\", \"过程逻辑\"],\n",
      "    [\"条件段\", \"属于\", \"决策表\"],\n",
      "    [\"行动段\", \"属于\", \"决策表\"],\n",
      "    [\"规则\", \"属于\", \"决策表\"],\n",
      "    [\"规则合并\", \"属于\", \"决策表\"],\n",
      "    [\"无关条件\", \"属于\", \"决策表\"],\n",
      "    [\"构造决策表的基本步骤\", \"属于\", \"决策表\"],\n",
      "    [\"决策树\", \"属于\", \"过程逻辑\"],\n",
      "    [\"决策点\", \"属于\", \"决策树\"],\n",
      "    [\"行动\", \"属于\", \"决策树\"],\n",
      "    [\"邮寄包收费标准问题逻辑建模\", \"涉及\", \"结构化语言,决策表,决策树\"],\n",
      "    [\"数据字典\", \"属于\", \"第五章\"],\n",
      "    [\"数据项\", \"属于\", \"数据字典\"],\n",
      "    [\"数据结构\", \"属于\", \"数据字典\"],\n",
      "    [\"数据流\", \"属于\", \"数据字典\"],\n",
      "    [\"数据存储\", \"属于\", \"数据字典\"],\n",
      "    [\"处理功能\", \"属于\", \"数据字典\"],\n",
      "    [\"外部项\", \"属于\", \"数据字典\"],\n",
      "    [\"数据项字典内容\", \"属于\", \"数据项\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "4949\n",
      "sleep:38.21245123876274秒\n",
      "————————————第30章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"数据字典\",\n",
      "    \"数据分析任务\",\n",
      "    \"数据流程图成分\",\n",
      "    \"数据项\",\n",
      "    \"数据结构\",\n",
      "    \"数据流\",\n",
      "    \"数据存储\",\n",
      "    \"过程\",\n",
      "    \"手工方式生成数据字典\",\n",
      "    \"计算机辅助生成数据字典\",\n",
      "    \"动态数据\",\n",
      "    \"静态数据\",\n",
      "    \"数据项名称\",\n",
      "    \"数据项类型\",\n",
      "    \"数据项长度\",\n",
      "    \"取值范围和含义\",\n",
      "    \"数据结构组成\",\n",
      "    \"数据流表示符号\",\n",
      "    \"数据流组成\",\n",
      "    \"数据流来源\",\n",
      "    \"数据流去向\",\n",
      "    \"数据流流通量\",\n",
      "    \"过程名\",\n",
      "    \"触发条件\",\n",
      "    \"优先级\",\n",
      "    \"输入输出\",\n",
      "    \"过程逻辑\",\n",
      "    \"数据存储名称\",\n",
      "    \"流入流出的数据流\",\n",
      "    \"数据存储组成\",\n",
      "    \"组织方式\",\n",
      "    \"查询要求\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"数据项\", \"属于\", \"数据字典\"],\n",
      "    [\"数据结构\", \"属于\", \"数据字典\"],\n",
      "    [\"数据流\", \"属于\", \"数据字典\"],\n",
      "    [\"数据存储\", \"属于\", \"数据字典\"],\n",
      "    [\"过程\", \"属于\", \"数据字典\"],\n",
      "    [\"手工方式生成数据字典\", \"属于\", \"数据字典\"],\n",
      "    [\"计算机辅助生成数据字典\", \"属于\", \"数据字典\"],\n",
      "    [\"动态数据\", \"属于\", \"数据字典\"],\n",
      "    [\"静态数据\", \"属于\", \"数据字典\"],\n",
      "    [\"数据项名称\", \"属于\", \"数据项\"],\n",
      "    [\"数据项类型\", \"属于\", \"数据项\"],\n",
      "    [\"数据项长度\", \"属于\", \"数据项\"],\n",
      "    [\"取值范围和含义\", \"属于\", \"数据项\"],\n",
      "    [\"数据结构组成\", \"属于\", \"数据结构\"],\n",
      "    [\"数据流来源\", \"属于\", \"数据流\"],\n",
      "    [\"数据流去向\", \"属于\", \"数据流\"],\n",
      "    [\"数据流流通量\", \"属于\", \"数据流\"],\n",
      "    [\"过程名\", \"属于\", \"过程\"],\n",
      "    [\"触发条件\", \"属于\", \"过程\"],\n",
      "    [\"优先级\", \"属于\", \"过程\"],\n",
      "    [\"输入输出\", \"属于\", \"过程\"],\n",
      "    [\"过程逻辑\", \"属于\", \"过程\"],\n",
      "    [\"流入流出的数据流\", \"属于\", \"数据存储\"],\n",
      "    [\"数据存储组成\", \"属于\", \"数据存储\"],\n",
      "    [\"组织方式\", \"属于\", \"数据存储\"],\n",
      "    [\"查询要求\", \"属于\", \"数据存储\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "2894\n",
      "sleep:38.443148994567636秒\n",
      "————————————第31章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"过程建模步骤\",\n",
      "    \"数据流图\",\n",
      "    \"数据字典\",\n",
      "    \"系统分析\",\n",
      "    \"顶层数据流程图\",\n",
      "    \"一级分解数据流程图\",\n",
      "    \"二级分解数据流程图\",\n",
      "    \"销售处理功能\",\n",
      "    \"采购处理功能\",\n",
      "    \"会计处理功能\",\n",
      "    \"数据存储\",\n",
      "    \"数据流\",\n",
      "    \"数据项定义\",\n",
      "    \"数据处理字典\",\n",
      "    \"新系统顶层数据流程\",\n",
      "    \"系统目标\",\n",
      "    \"登记整理数据\",\n",
      "    \"核对顾客订货单\",\n",
      "    \"提供业务统计报表\",\n",
      "    \"各级查询\",\n",
      "    \"业务数据处理自动化\",\n",
      "    \"销售子系统\",\n",
      "    \"采购子系统\",\n",
      "    \"会计子系统\",\n",
      "    \"编辑处理\",\n",
      "    \"建立收款明细帐\",\n",
      "    \"编制报表处理\",\n",
      "    \"应收款明细帐\",\n",
      "    \"订单处理\",\n",
      "    \"缺货处理\",\n",
      "    \"自动登记新顾客数据\",\n",
      "    \"建立售货历史记录\",\n",
      "    \"修改库存记录\",\n",
      "    \"缺货单汇总\",\n",
      "    \"缺货货物统计\",\n",
      "    \"编发订货单\",\n",
      "    \"核对订货单\",\n",
      "    \"修改库存\",\n",
      "    \"数据汇总计算工作\",\n",
      "    \"报表编制打印\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"过程建模步骤\", \"属于\", \"百货商店业务管理信息系统\"],\n",
      "    [\"数据流图\", \"属于\", \"过程建模步骤\"],\n",
      "    [\"数据字典\", \"属于\", \"过程建模步骤\"],\n",
      "    [\"系统分析\", \"属于\", \"过程建模步骤\"],\n",
      "    [\"顶层数据流程图\", \"属于\", \"数据流图\"],\n",
      "    [\"一级分解数据流程图\", \"属于\", \"数据流图\"],\n",
      "    [\"二级分解数据流程图\", \"属于\", \"数据流图\"],\n",
      "    [\"销售处理功能\", \"属于\", \"二级分解数据流程图\"],\n",
      "    [\"采购处理功能\", \"属于\", \"二级分解数据流程图\"],\n",
      "    [\"会计处理功能\", \"属于\", \"二级分解数据流程图\"],\n",
      "    [\"数据存储\", \"属于\", \"数据流图\"],\n",
      "    [\"数据流\", \"属于\", \"数据流图\"],\n",
      "    [\"数据项定义\", \"属于\", \"数据字典\"],\n",
      "    [\"数据处理字典\", \"属于\", \"数据字典\"],\n",
      "    [\"新系统顶层数据流程\", \"属于\", \"顶层数据流程图\"],\n",
      "    [\"系统目标\", \"属于\", \"系统分析\"],\n",
      "    [\"登记整理数据\", \"属于\", \"系统目标\"],\n",
      "    [\"核对顾客订货单\", \"属于\", \"系统目标\"],\n",
      "    [\"提供业务统计报表\", \"属于\", \"系统目标\"],\n",
      "    [\"各级查询\", \"属于\", \"系统目标\"],\n",
      "    [\"业务数据处理自动化\", \"属于\", \"系统目标\"],\n",
      "    [\"销售子系统\", \"属于\", \"新系统\"],\n",
      "    [\"采购子系统\", \"属于\", \"新系统\"],\n",
      "    [\"会计子系统\", \"属于\", \"新系统\"],\n",
      "    [\"编辑处理\", \"属于\", \"销售处理功能\"],\n",
      "    [\"建立收款明细帐\", \"属于\", \"销售处理功能\"],\n",
      "    [\"编制报表处理\", \"属于\", \"会计处理功能\"],\n",
      "    [\"应收款明细帐\", \"流入\", \"建立收款明细帐\"],\n",
      "    [\"订单处理\", \"属于\", \"销售子系统\"],\n",
      "    [\"缺货处理\", \"属于\", \"销售子系统\"],\n",
      "    [\"自动登记新顾客数据\", \"属于\", \"销售子系统功能\"],\n",
      "    [\"建立售货历史记录\", \"属于\", \"销售子系统功能\"],\n",
      "    [\"修改库存记录\", \"属于\", \"销售子系统功能\"],\n",
      "    [\"缺货单汇总\", \"属于\", \"采购子系统功能\"],\n",
      "    [\"缺货货物统计\", \"属于\", \"采购子系统功能\"],\n",
      "    [\"编发订货单\", \"属于\", \"采购子系统功能\"],\n",
      "    [\"核对订货单\", \"属于\", \"采购子系统功能\"],\n",
      "    [\"修改库存\", \"属于\", \"采购子系统功能\"],\n",
      "    [\"数据汇总计算工作\", \"属于\", \"会计子系统功能\"],\n",
      "    [\"报表编制打印\", \"属于\", \"会计子系统功能\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "4141\n",
      "sleep:38.85921378125843秒\n",
      "————————————第32章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"结构化分析\",\n",
      "    \"数据流图（DFD）\",\n",
      "    \"数据字典（DD）\",\n",
      "    \"结构化语言\",\n",
      "    \"判定树\",\n",
      "    \"判定表\",\n",
      "    \"数据流程图分解法\",\n",
      "    \"子系统\",\n",
      "    \"数据接口\",\n",
      "    \"大学课程注册系统\",\n",
      "    \"图书馆外文采购室业务流程\",\n",
      "    \"设备购置流程\",\n",
      "    \"员工招聘系统\",\n",
      "    \"医院药房系统\",\n",
      "    \"政府采购流程\",\n",
      "    \"保险索赔财务系统\",\n",
      "    \"数据建模\",\n",
      "    \"实体类型\",\n",
      "    \"属性\",\n",
      "    \"多值属性\",\n",
      "    \"联系\",\n",
      "    \"度\",\n",
      "    \"基数\",\n",
      "    \"业务规则\",\n",
      "    \"关联实体\",\n",
      "    \"触发\",\n",
      "    \"超类\",\n",
      "    \"子类\",\n",
      "    \"对象\",\n",
      "    \"状态\",\n",
      "    \"行为\",\n",
      "    \"对象类\",\n",
      "    \"类图\",\n",
      "    \"操作\",\n",
      "    \"封装\",\n",
      "    \"关联角色\",\n",
      "    \"抽象类\",\n",
      "    \"多态性\",\n",
      "    \"聚合\",\n",
      "    \"合成\",\n",
      "    \"E-R 图\",\n",
      "    \"逻辑模型\",\n",
      "    \"物理数据模型\",\n",
      "    \"数据库建模\",\n",
      "    \"实体-关系模型\",\n",
      "    \"概念模型\",\n",
      "    \"现实世界\",\n",
      "    \"静态特性\",\n",
      "    \"数据库设计\",\n",
      "    \"实体\",\n",
      "    \"属性\",\n",
      "    \"联系\",\n",
      "    \"Martin 记法\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"结构化分析\", \"属于\", \"本章小结\"],\n",
      "    [\"数据流图（DFD）\", \"属于\", \"结构化分析\"],\n",
      "    [\"数据字典（DD）\", \"属于\", \"结构化分析\"],\n",
      "    [\"结构化语言\", \"属于\", \"结构化分析\"],\n",
      "    [\"判定树\", \"属于\", \"结构化分析\"],\n",
      "    [\"判定表\", \"属于\", \"结构化分析\"],\n",
      "    [\"数据流程图分解法\", \"属于\", \"结构化分析\"],\n",
      "    [\"子系统\", \"属于\", \"数据流程图分解法\"],\n",
      "    [\"数据接口\", \"属于\", \"数据流程图分解法\"],\n",
      "    [\"大学课程注册系统\", \"示例\", \"数据流程图分解法\"],\n",
      "    [\"图书馆外文采购室业务流程\", \"练习与思考\", \"本章小结\"],\n",
      "    [\"设备购置流程\", \"练习与思考\", \"本章小结\"],\n",
      "    [\"员工招聘系统\", \"练习与思考\", \"本章小结\"],\n",
      "    [\"医院药房系统\", \"练习与思考\", \"本章小结\"],\n",
      "    [\"政府采购流程\", \"练习与思考\", \"本章小结\"],\n",
      "    [\"保险索赔财务系统\", \"练习与思考\", \"本章小结\"],\n",
      "    [\"数据建模\", \"主题\", \"本章小结\"],\n",
      "    [\"实体类型\", \"属于\", \"数据建模\"],\n",
      "    [\"属性\", \"属于\", \"数据建模\"],\n",
      "    [\"多值属性\", \"属于\", \"数据建模\"],\n",
      "    [\"联系\", \"属于\", \"数据建模\"],\n",
      "    [\"度\", \"属于\", \"数据建模\"],\n",
      "    [\"基数\", \"属于\", \"数据建模\"],\n",
      "    [\"业务规则\", \"属于\", \"数据建模\"],\n",
      "    [\"关联实体\", \"属于\", \"数据建模\"],\n",
      "    [\"触发\", \"属于\", \"数据建模\"],\n",
      "    [\"超类\", \"属于\", \"数据建模\"],\n",
      "    [\"子类\", \"属于\", \"数据建模\"],\n",
      "    [\"对象\", \"属于\", \"数据建模\"],\n",
      "    [\"状态\", \"属于\", \"数据建模\"],\n",
      "    [\"行为\", \"属于\", \"数据建模\"],\n",
      "    [\"对象类\", \"属于\", \"数据建模\"],\n",
      "    [\"类图\", \"属于\", \"数据建模\"],\n",
      "    [\"操作\", \"属于\", \"数据建模\"],\n",
      "    [\"封装\", \"属于\", \"数据建模\"],\n",
      "    [\"关联角色\", \"属于\", \"数据建模\"],\n",
      "    [\"抽象类\", \"属于\", \"数据建模\"],\n",
      "    [\"多态性\", \"属于\", \"数据建模\"],\n",
      "    [\"聚合\", \"属于\", \"数据建模\"],\n",
      "    [\"合成\", \"属于\", \"数据建模\"],\n",
      "    [\"E-R 图\", \"属于\", \"数据建模\"],\n",
      "    [\"逻辑模型\", \"转换自\", \"数据建模\"],\n",
      "    [\"物理数据模型\", \"转换自\", \"逻辑模型\"],\n",
      "    [\"数据库建模\", \"等同于\", \"数据建模\"],\n",
      "    [\"实体-关系模型\", \"代表\", \"E-R 图\"],\n",
      "    [\"概念模型\", \"描述\", \"实体-关系模型\"],\n",
      "    [\"Martin 记法\", \"应用于\", \"E-R 图\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "3785\n",
      "sleep:37.467070448882296秒\n",
      "————————————第33章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"数据建模\",\n",
      "    \"实体类型\",\n",
      "    \"属性\",\n",
      "    \"多值属性\",\n",
      "    \"联系\",\n",
      "    \"度\",\n",
      "    \"基数\",\n",
      "    \"业务规则\",\n",
      "    \"关联实体\",\n",
      "    \"触发\",\n",
      "    \"超类\",\n",
      "    \"子类\",\n",
      "    \"对象\",\n",
      "    \"状态\",\n",
      "    \"行为\",\n",
      "    \"对象类\",\n",
      "    \"类图\",\n",
      "    \"操作\",\n",
      "    \"封装\",\n",
      "    \"关联角色\",\n",
      "    \"抽象类\",\n",
      "    \"多态性\",\n",
      "    \"聚合\",\n",
      "    \"合成\",\n",
      "    \"E-R 图\",\n",
      "    \"实体-联系模型\",\n",
      "    \"逻辑数据模型\",\n",
      "    \"概念数据建模\",\n",
      "    \"标识符\",\n",
      "    \"候选码\",\n",
      "    \"替代码\",\n",
      "    \"复合码\",\n",
      "    \"外码\",\n",
      "    \"主码\",\n",
      "    \"副码\",\n",
      "    \"子集准则\",\n",
      "    \"关系\",\n",
      "    \"双向关系\",\n",
      "    \"一元联系\",\n",
      "    \"递归联系\",\n",
      "    \"二元联系\",\n",
      "    \"三元联系\",\n",
      "    \"关联实体\",\n",
      "    \"运输模式\",\n",
      "    \"单位成本\",\n",
      "    \"修完日期\",\n",
      "    \"逻辑数据建模过程\",\n",
      "    \"基本实体确定\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"实体类型\", \"属于\", \"数据建模\"],\n",
      "    [\"属性\", \"属于\", \"实体类型\"],\n",
      "    [\"多值属性\", \"属于\", \"属性\"],\n",
      "    [\"联系\", \"属于\", \"数据建模\"],\n",
      "    [\"度\", \"属于\", \"联系\"],\n",
      "    [\"基数\", \"属于\", \"联系\"],\n",
      "    [\"业务规则\", \"属于\", \"数据建模\"],\n",
      "    [\"关联实体\", \"属于\", \"数据建模\"],\n",
      "    [\"触发\", \"属于\", \"数据建模\"],\n",
      "    [\"超类\", \"属于\", \"数据建模\"],\n",
      "    [\"子类\", \"属于\", \"数据建模\"],\n",
      "    [\"对象\", \"属于\", \"数据建模\"],\n",
      "    [\"状态\", \"属于\", \"对象\"],\n",
      "    [\"行为\", \"属于\", \"对象\"],\n",
      "    [\"对象类\", \"属于\", \"数据建模\"],\n",
      "    [\"类图\", \"属于\", \"数据建模\"],\n",
      "    [\"操作\", \"属于\", \"对象类\"],\n",
      "    [\"封装\", \"属于\", \"对象类\"],\n",
      "    [\"关联角色\", \"属于\", \"类图\"],\n",
      "    [\"抽象类\", \"属于\", \"类图\"],\n",
      "    [\"多态性\", \"属于\", \"类图\"],\n",
      "    [\"聚合\", \"属于\", \"类图\"],\n",
      "    [\"合成\", \"属于\", \"类图\"],\n",
      "    [\"E-R 图\", \"属于\", \"数据建模\"],\n",
      "    [\"实体-联系模型\", \"等于\", \"E-R 模型\"],\n",
      "    [\"逻辑数据模型\", \"属于\", \"数据建模\"],\n",
      "    [\"概念数据建模\", \"属于\", \"数据建模\"],\n",
      "    [\"标识符\", \"属于\", \"实体类型\"],\n",
      "    [\"候选码\", \"属于\", \"实体类型\"],\n",
      "    [\"替代码\", \"属于\", \"候选码\"],\n",
      "    [\"复合码\", \"属于\", \"实体类型\"],\n",
      "    [\"外码\", \"属于\", \"实体类型\"],\n",
      "    [\"主码\", \"属于\", \"实体类型\"],\n",
      "    [\"副码\", \"属于\", \"候选码\"],\n",
      "    [\"子集准则\", \"属于\", \"属性\"],\n",
      "    [\"一元联系\", \"属于\", \"联系\"],\n",
      "    [\"二元联系\", \"属于\", \"联系\"],\n",
      "    [\"三元联系\", \"属于\", \"联系\"],\n",
      "    [\"关联实体\", \"属于\", \"联系\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "5781\n",
      "sleep:37.61878425357778秒\n",
      "————————————第34章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"逻辑数据建模过程\",\n",
      "    \"确定基本实体\",\n",
      "    \"业务的主题/对象\",\n",
      "    \"业务使用的人、地方、东西、材料、事件\",\n",
      "    \"数据实体及其说明\",\n",
      "    \"主码\",\n",
      "    \"属性及副码\",\n",
      "    \"安全控制\",\n",
      "    \"数据的时间维\",\n",
      "    \"超类、子类、聚合\",\n",
      "    \"联系及其基数和度\",\n",
      "    \"完整性控制\",\n",
      "    \"最大最小基数\",\n",
      "    \"俱乐部会员系统\",\n",
      "    \"合同\",\n",
      "    \"会员\",\n",
      "    \"会员订单\",\n",
      "    \"事务\",\n",
      "    \"产品\",\n",
      "    \"促销\",\n",
      "    \"建立实体间的关联\",\n",
      "    \"实体实例的基数\",\n",
      "    \"一对一联系\",\n",
      "    \"一对多联系\",\n",
      "    \"多对多联系\",\n",
      "    \"主码和属性\",\n",
      "    \"主码确定原则\",\n",
      "    \"智能码\",\n",
      "    \"关联实体\",\n",
      "    \"规范化\",\n",
      "    \"第一范式\",\n",
      "    \"第二范式\",\n",
      "    \"第三范式\",\n",
      "    \"关系模式设计要求\",\n",
      "    \"无冗余性\",\n",
      "    \"灵活性\",\n",
      "    \"适应性\",\n",
      "    \"第一范式定义\",\n",
      "    \"职工关系表\",\n",
      "    \"1NF\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"确定基本实体\", \"属于\", \"逻辑数据建模过程\"],\n",
      "    [\"业务的主题/对象\", \"属于\", \"确定基本实体\"],\n",
      "    [\"业务使用的人、地方、东西、材料、事件\", \"属于\", \"确定基本实体\"],\n",
      "    [\"数据实体及其说明\", \"属于\", \"确定基本实体\"],\n",
      "    [\"主码\", \"属于\", \"确定基本实体\"],\n",
      "    [\"属性及副码\", \"属于\", \"确定基本实体\"],\n",
      "    [\"安全控制\", \"属于\", \"确定基本实体\"],\n",
      "    [\"数据的时间维\", \"属于\", \"确定基本实体\"],\n",
      "    [\"超类、子类、聚合\", \"属于\", \"确定基本实体\"],\n",
      "    [\"联系及其基数和度\", \"属于\", \"确定基本实体\"],\n",
      "    [\"完整性控制\", \"属于\", \"确定基本实体\"],\n",
      "    [\"最大最小基数\", \"属于\", \"确定基本实体\"],\n",
      "    [\"建立实体间的关联\", \"属于\", \"逻辑数据建模过程\"],\n",
      "    [\"实体实例的基数\", \"属于\", \"建立实体间的关联\"],\n",
      "    [\"一对一联系\", \"属于\", \"实体实例的基数\"],\n",
      "    [\"一对多联系\", \"属于\", \"实体实例的基数\"],\n",
      "    [\"多对多联系\", \"属于\", \"实体实例的基数\"],\n",
      "    [\"主码和属性\", \"属于\", \"逻辑数据建模过程\"],\n",
      "    [\"智能码\", \"属于\", \"主码和属性\"],\n",
      "    [\"规范化\", \"属于\", \"逻辑数据建模过程\"],\n",
      "    [\"第一范式\", \"属于\", \"规范化\"],\n",
      "    [\"第二范式\", \"属于\", \"规范化\"],\n",
      "    [\"第三范式\", \"属于\", \"规范化\"],\n",
      "    [\"关系模式设计要求\", \"属于\", \"规范化\"],\n",
      "    [\"无冗余性\", \"属于\", \"关系模式设计要求\"],\n",
      "    [\"灵活性\", \"属于\", \"关系模式设计要求\"],\n",
      "    [\"适应性\", \"属于\", \"关系模式设计要求\"],\n",
      "    [\"第一范式定义\", \"属于\", \"第一范式\"],\n",
      "    [\"职工关系表\", \"用于举例\", \"第一范式\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "3063\n",
      "sleep:38.41168608557021秒\n",
      "————————————第35章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"规范化\",\n",
      "    \"第一范式(1NF)\",\n",
      "    \"第二范式(2NF)\",\n",
      "    \"第三范式(3NF)\",\n",
      "    \"主码\",\n",
      "    \"数据冗余\",\n",
      "    \"无冗余\",\n",
      "    \"灵活适应性\",\n",
      "    \"实体\",\n",
      "    \"属性\",\n",
      "    \"不可再分的数据项\",\n",
      "    \"完全依赖于主码\",\n",
      "    \"传递依赖\",\n",
      "    \"关系模式分解\",\n",
      "    \"数据-过程模型映射\",\n",
      "    \"CRUD 矩阵\",\n",
      "    \"数据存储\",\n",
      "    \"系统完整性\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"第一范式(1NF)\",\"属于\",\"规范化\"],\n",
      "    [\"第二范式(2NF)\",\"属于\",\"规范化\"],\n",
      "    [\"第三范式(3NF)\",\"属于\",\"规范化\"],\n",
      "    [\"主码\",\"在\",\"规范化\"],\n",
      "    [\"数据冗余\",\"处理方式\",\"规范化\"],\n",
      "    [\"无冗余\",\"要求\",\"规范化\"],\n",
      "    [\"灵活适应性\",\"设计目标\",\"规范化\"],\n",
      "    [\"实体\",\"属性设计\",\"规范化\"],\n",
      "    [\"不可再分的数据项\",\"定义\",\"第一范式(1NF)\"],\n",
      "    [\"完全依赖于主码\",\"条件\",\"第二范式(2NF)\"],\n",
      "    [\"传递依赖\",\"消除\",\"第三范式(3NF)\"],\n",
      "    [\"关系模式分解\",\"实现手段\",\"规范化\"],\n",
      "    [\"数据-过程模型映射\",\"与规范化的关系\",\"规范化\"],\n",
      "    [\"CRUD 矩阵\",\"用于\",\"数据-过程模型映射\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "2511\n",
      "sleep:38.15180602518168秒\n",
      "————————————第36章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"第三范式\",\n",
      "    \"2NF\",\n",
      "    \"传递依赖\",\n",
      "    \"关系规范化\",\n",
      "    \"数据冗余\",\n",
      "    \"一致性\",\n",
      "    \"数据库维护\",\n",
      "    \"数据-过程模型映射\",\n",
      "    \"实体\",\n",
      "    \"过程模型\",\n",
      "    \"CRUD 矩阵\",\n",
      "    \"系统完整性检查\",\n",
      "    \"客户应用处理\",\n",
      "    \"客户信用处理\",\n",
      "    \"客户地址变更处理\",\n",
      "    \"内部客户信用变更处理\",\n",
      "    \"新客户订单处理\",\n",
      "    \"客户订单取消\",\n",
      "    \"客户订单变更处理\",\n",
      "    \"新产品添加处理\",\n",
      "    \"新产品退市处理\",\n",
      "    \"产品价格变更处理\",\n",
      "    \"产品说明变更处理\",\n",
      "    \"产品库存调整处理\",\n",
      "    \"网上商店概念数据建模\",\n",
      "    \"基本实体识别\",\n",
      "    \"客户\",\n",
      "    \"库存\",\n",
      "    \"订单\",\n",
      "    \"购物车\",\n",
      "    \"客户 ID\",\n",
      "    \"客户信息\",\n",
      "    \"产品项目\",\n",
      "    \"产品简介\",\n",
      "    \"订单编号\",\n",
      "    \"订单详细信息\",\n",
      "    \"反馈码\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"第三范式\", \"属于\", \"关系规范化\"],\n",
      "    [\"2NF\", \"属于\", \"关系规范化\"],\n",
      "    [\"传递依赖\", \"属于\", \"关系规范化\"],\n",
      "    [\"数据冗余\", \"关联\", \"关系规范化\"],\n",
      "    [\"一致性\", \"关联\", \"关系规范化\"],\n",
      "    [\"数据库维护\", \"关联\", \"关系规范化\"],\n",
      "    [\"实体\", \"在\", \"数据-过程模型映射\"],\n",
      "    [\"过程模型\", \"在\", \"数据-过程模型映射\"],\n",
      "    [\"CRUD 矩阵\", \"用于\", \"数据-过程模型映射\"],\n",
      "    [\"系统完整性检查\", \"使用\", \"CRUD 矩阵\"],\n",
      "    [\"客户应用处理\", \"包含\", \"C(创建)\"],\n",
      "    [\"客户信用处理\", \"包含\", \"C(创建)\"],\n",
      "    [\"客户地址变更处理\", \"涉及\", \"客户实体\"],\n",
      "    [\"内部客户信用变更处理\", \"涉及\", \"客户实体\"],\n",
      "    [\"新客户订单处理\", \"包含\", \"R(读取), C(创建)\"],\n",
      "    [\"客户订单取消\", \"包含\", \"R(读取), D(删除)\"],\n",
      "    [\"客户订单变更处理\", \"包含\", \"R(读取), U(更新)\"],\n",
      "    [\"新产品添加处理\", \"包含\", \"R(读取), C(创建)\"],\n",
      "    [\"新产品退市处理\", \"包含\", \"R(读取), D(删除)\"],\n",
      "    [\"产品价格变更处理\", \"包含\", \"RU(读取和更新)\"],\n",
      "    [\"产品说明变更处理\", \"包含\", \"RU(读取和更新)\"],\n",
      "    [\"产品库存调整处理\", \"包含\", \"RU(读取和更新)\"],\n",
      "    [\"客户\", \"作为\", \"网上商店基本实体\"],\n",
      "    [\"库存\", \"作为\", \"网上商店基本实体\"],\n",
      "    [\"订单\", \"作为\", \"网上商店基本实体\"],\n",
      "    [\"购物车\", \"作为\", \"网上商店可能实体\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "2147\n",
      "sleep:37.70321350446353秒\n",
      "————————————第37章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"案例分析——某网上商店概念数据建模\",\n",
      "    \"确定基本实体\",\n",
      "    \"客户\",\n",
      "    \"库存\",\n",
      "    \"订单\",\n",
      "    \"购物车\",\n",
      "    \"产品项目需求\",\n",
      "    \"购买需求\",\n",
      "    \"浏览购物车\",\n",
      "    \"购物车中的项目\",\n",
      "    \"删除项\",\n",
      "    \"付账离开\",\n",
      "    \"企业客户\",\n",
      "    \"家庭办公客户\",\n",
      "    \"学生客户\",\n",
      "    \"库存信息\",\n",
      "    \"拥有关系\",\n",
      "    \"订购关系\",\n",
      "    \"包含关系\",\n",
      "    \"主码和属性\",\n",
      "    \"客户（客户 ID，地址，电话，E-mail，客户类型）\",\n",
      "    \"企业客户（客户 ID，公司名称，运输方式，采购者名称，传真）\",\n",
      "    \"家庭办公客户（客户 ID，客户姓名，公司姓名，传真）\",\n",
      "    \"学生客户（客户 ID，客户姓名，学校）\",\n",
      "    \"订单（订单 ID，发票 ID，客户 ID，收益编码，订单状态）\",\n",
      "    \"库存（库存 ID，名称，描述，规模，重量，材料，颜色，价格，提前期）\",\n",
      "    \"购物车（购物车 ID，客户 ID，库存 ID，材料，颜色，数量）\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"确定基本实体\", \"属于\", \"案例分析——某网上商店概念数据建模\"],\n",
      "    [\"客户\", \"属于\", \"确定基本实体\"],\n",
      "    [\"库存\", \"属于\", \"确定基本实体\"],\n",
      "    [\"订单\", \"属于\", \"确定基本实体\"],\n",
      "    [\"购物车\", \"属于\", \"确定基本实体\"],\n",
      "    [\"拥有关系\", \"属于\", \"确定实体间的关联\"],\n",
      "    [\"订购关系\", \"属于\", \"确定实体间的关联\"],\n",
      "    [\"包含关系\", \"属于\", \"确定实体间的关联\"],\n",
      "    [\"主码和属性\", \"属于\", \"案例分析——某网上商店概念数据建模\"],\n",
      "    [\"客户（客户 ID，地址，电话，E-mail，客户类型）\", \"属于\", \"主码和属性\"],\n",
      "    [\"企业客户（客户 ID，公司名称，运输方式，采购者名称，传真）\", \"属于\", \"主码和属性\"],\n",
      "    [\"家庭办公客户（客户 ID，客户姓名，公司姓名，传真）\", \"属于\", \"主码和属性\"],\n",
      "    [\"学生客户（客户 ID，客户姓名，学校）\", \"属于\", \"主码和属性\"],\n",
      "    [\"订单（订单 ID，发票 ID，客户 ID，收益编码，订单状态）\", \"属于\", \"主码和属性\"],\n",
      "    [\"库存（库存 ID，名称，描述，规模，重量，材料，颜色，价格，提前期）\", \"属于\", \"主码和属性\"],\n",
      "    [\"购物车（购物车 ID，客户 ID，库存 ID，材料，颜色，数量）\", \"属于\", \"主码和属性\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "3153\n",
      "sleep:37.891898334453764秒\n",
      "————————————第38章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"学生客户\",\n",
      "    \"订单实体\",\n",
      "    \"订单属性\",\n",
      "    \"发票 ID（FK）\",\n",
      "    \"客户 ID（FK）\",\n",
      "    \"退货码\",\n",
      "    \"订单状态\",\n",
      "    \"库存实体\",\n",
      "    \"库存属性\",\n",
      "    \"购物车实体\",\n",
      "    \"购物车属性\",\n",
      "    \"复杂属性表达\",\n",
      "    \"编码集\",\n",
      "    \"网络商店概念数据建模\",\n",
      "    \"本章总结\",\n",
      "    \"建造信息系统数据需求模型过程\",\n",
      "    \"实体-联系图\",\n",
      "    \"类图符号\",\n",
      "    \"概念数据模型构建\",\n",
      "    \"数据流\",\n",
      "    \"数据存储\",\n",
      "    \"关系\",\n",
      "    \"弱实体\",\n",
      "    \"关联实体\",\n",
      "    \"主码识别\",\n",
      "    \"软件培训项目建模\",\n",
      "    \"前提单元\",\n",
      "    \"学期指导老师分配\",\n",
      "    \"指导老师角色\",\n",
      "    \"采购请求流程\",\n",
      "    \"采购部门员工\",\n",
      "    \"采购流程审批\",\n",
      "    \"采购订单\",\n",
      "    \"系统应用架构\",\n",
      "    \"框架\",\n",
      "    \"分布式系统构件分布\",\n",
      "    \"应用架构设计\",\n",
      "    \"应用架构与框架的异同\",\n",
      "    \"基于主机的架构\",\n",
      "    \"文件服务器架构\",\n",
      "    \"客户/服务器架构\",\n",
      "    \"三层或N层客户/服务器架构\",\n",
      "    \"浏览器/服务器架构\",\n",
      "    \"系统应用架构特点\",\n",
      "    \"应用架构设计方式选择\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"订单实体\", \"属于\", \"本章总结\"],\n",
      "    [\"订单属性\", \"属于\", \"订单实体\"],\n",
      "    [\"发票 ID(FK)\", \"属于\", \"订单属性\"],\n",
      "    [\"客户 ID(FK)\", \"属于\", \"订单属性\"],\n",
      "    [\"退货码\", \"属于\", \"订单属性\"],\n",
      "    [\"订单状态\", \"属于\", \"订单属性\"],\n",
      "    [\"库存实体\", \"属于\", \"本章总结\"],\n",
      "    [\"库存属性\", \"属于\", \"库存实体\"],\n",
      "    [\"购物车实体\", \"属于\", \"本章总结\"],\n",
      "    [\"购物车属性\", \"属于\", \"购物车实体\"],\n",
      "    [\"复杂属性表达\", \"属于\", \"库存实体\"],\n",
      "    [\"编码集\", \"用于\", \"复杂属性表达\"],\n",
      "    [\"网络商店概念数据建模\", \"是本章内容\", \"本章总结\"],\n",
      "    [\"实体-联系图\", \"用于\", \"概念数据模型构建\"],\n",
      "    [\"类图符号\", \"用于\", \"概念数据模型构建\"],\n",
      "    [\"数据流\", \"与\", \"概念数据模型有关系\"],\n",
      "    [\"数据存储\", \"与\", \"概念数据模型有关系\"],\n",
      "    [\"弱实体\", \"在问题4中讨论\", \"本章思考与练习\"],\n",
      "    [\"关联实体\", \"在问题4中讨论\", \"本章思考与练习\"],\n",
      "    [\"主码识别\", \"在问题3、4中涉及\", \"本章思考与练习\"],\n",
      "    [\"软件培训项目建模\", \"作为练习要求\", \"本章思考与练习\"],\n",
      "    [\"学期指导老师分配\", \"在练习5中描述\", \"本章思考与练习\"],\n",
      "    [\"指导老师角色\", \"在练习5中提及\", \"本章思考与练习\"],\n",
      "    [\"采购请求流程\", \"在练习6中详细说明\", \"本章思考与练习\"],\n",
      "    [\"采购部门员工\", \"在练习6中扮演关键角色\", \"采购请求流程\"],\n",
      "    [\"采购流程审批\", \"属于\", \"采购请求流程\"],\n",
      "    [\"采购订单\", \"在采购流程中产生\", \"采购请求流程\"],\n",
      "    [\"系统应用架构\", \"为本章主题\", \"第7章\"],\n",
      "    [\"框架\", \"与应用架构对比\", \"第7章\"],\n",
      "    [\"分布式系统构件分布\", \"是应用架构设计考虑因素\", \"第7章\"],\n",
      "    [\"应用架构设计\", \"在第7章详细阐述\", \"第7章\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "3286\n",
      "sleep:37.87462202054962秒\n",
      "————————————第39章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"系统应用架构\",\n",
      "    \"定义\",\n",
      "    \"系统应用架构与框架的异同\",\n",
      "    \"典型的系统应用架构\",\n",
      "    \"基于主机的架构\",\n",
      "    \"文件服务器架构\",\n",
      "    \"客户/服务器架构\",\n",
      "    \"三层或 N 层客户/服务器架构\",\n",
      "    \"浏览器/服务器架构\",\n",
      "    \"特点\",\n",
      "    \"应用架构概述\",\n",
      "    \"应用架构与框架\",\n",
      "    \"逻辑层次\",\n",
      "    \"Martin Fowler 的逻辑层次划分\",\n",
      "    \"表示层\",\n",
      "    \"领域层\",\n",
      "    \"数据源层\",\n",
      "    \"Eric Evans 的逻辑层次划分\",\n",
      "    \"应用层\",\n",
      "    \"领域层\",\n",
      "    \"信息系统逻辑架构层次\",\n",
      "    \"表现层\",\n",
      "    \"表现逻辑层\",\n",
      "    \"应用逻辑层\",\n",
      "    \"业务逻辑层\",\n",
      "    \"数据处理层\",\n",
      "    \"数据层\",\n",
      "    \"硬件组成\",\n",
      "    \"客户计算机\",\n",
      "    \"服务器\",\n",
      "    \"网络\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"系统应用架构\",\"属于\",\"架构概述\"],\n",
      "    [\"系统应用架构的定义\",\"属于\",\"架构概述\"],\n",
      "    [\"系统应用架构与框架的异同\",\"属于\",\"架构概述\"],\n",
      "    [\"典型的系统应用架构\",\"属于\",\"架构概述\"],\n",
      "    [\"基于主机的架构\",\"属于\",\"典型的系统应用架构\"],\n",
      "    [\"文件服务器架构\",\"属于\",\"典型的系统应用架构\"],\n",
      "    [\"客户/服务器架构\",\"属于\",\"典型的系统应用架构\"],\n",
      "    [\"三层或 N 层客户/服务器架构\",\"属于\",\"典型的系统应用架构\"],\n",
      "    [\"浏览器/服务器架构\",\"属于\",\"典型的系统应用架构\"],\n",
      "    [\"应用架构与框架\",\"属于\",\"架构概述\"],\n",
      "    [\"逻辑层次\",\"属于\",\"应用架构\"],\n",
      "    [\"Martin Fowler 的逻辑层次划分\",\"属于\",\"应用架构\"],\n",
      "    [\"表示层\",\"属于\",\"Martin Fowler 的逻辑层次划分\"],\n",
      "    [\"领域层\",\"属于\",\"Martin Fowler 的逻辑层次划分\"],\n",
      "    [\"数据源层\",\"属于\",\"Martin Fowler 的逻辑层次划分\"],\n",
      "    [\"Eric Evans 的逻辑层次划分\",\"属于\",\"应用架构\"],\n",
      "    [\"应用层\",\"属于\",\"Eric Evans 的逻辑层次划分\"],\n",
      "    [\"领域层\",\"属于\",\"Eric Evans 的逻辑层次划分\"],\n",
      "    [\"信息系统逻辑架构层次\",\"属于\",\"架构概述\"],\n",
      "    [\"表现层\",\"属于\",\"信息系统逻辑架构层次\"],\n",
      "    [\"表现逻辑层\",\"属于\",\"信息系统逻辑架构层次\"],\n",
      "    [\"应用逻辑层\",\"属于\",\"信息系统逻辑架构层次\"],\n",
      "    [\"业务逻辑层\",\"属于\",\"应用逻辑层\"],\n",
      "    [\"数据处理层\",\"属于\",\"信息系统逻辑架构层次\"],\n",
      "    [\"数据层\",\"属于\",\"信息系统逻辑架构层次\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "2485\n",
      "sleep:37.97724890455228秒\n",
      "————————————第40章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"数据层\",\n",
      "    \"系统硬件组成\",\n",
      "    \"客户计算机\",\n",
      "    \"服务器\",\n",
      "    \"网络\",\n",
      "    \"主机小型机\",\n",
      "    \"微机\",\n",
      "    \"典型的系统应用架构\",\n",
      "    \"基于主机的服务器架构\",\n",
      "    \"简单架构\",\n",
      "    \"单点控制\",\n",
      "    \"性能瓶颈\",\n",
      "    \"服务器超负荷\",\n",
      "    \"响应时间减慢\",\n",
      "    \"文件服务器架构\",\n",
      "    \"局域网方案\",\n",
      "    \"客户端\",\n",
      "    \"服务器端\",\n",
      "    \"存储功能\",\n",
      "    \"表现逻辑\",\n",
      "    \"应用逻辑\",\n",
      "    \"数据处理逻辑\",\n",
      "    \"数据完整性\",\n",
      "    \"加锁机制\",\n",
      "    \"客户/服务器架构\",\n",
      "    \"分布式计算方案\",\n",
      "    \"胖客户\",\n",
      "    \"瘦客户\",\n",
      "    \"数据库服务器\",\n",
      "    \"事务服务器\",\n",
      "    \"应用服务器\",\n",
      "    \"信息和组件服务器\",\n",
      "    \"两层客户/服务器计算\",\n",
      "    \"C/S 结构\",\n",
      "    \"网络流量减少\",\n",
      "    \"数据库完整性维护\",\n",
      "    \"版本升级与维护\",\n",
      "    \"三层或 N 层客户/服务器架构\",\n",
      "    \"中间层\",\n",
      "    \"应用服务器端\",\n",
      "    \"业务逻辑\",\n",
      "    \"负载平衡\",\n",
      "    \"表现层\",\n",
      "    \"业务逻辑层\",\n",
      "    \"数据访问层\",\n",
      "    \"领域层\",\n",
      "    \"抽屉式架构\",\n",
      "    \"依赖关系解耦\",\n",
      "    \"浏览器/服务器架构\",\n",
      "    \"B/S 架构\",\n",
      "    \"Web 浏览器\",\n",
      "    \"Web 服务器\",\n",
      "    \"Java 技术\",\n",
      "    \"Servlets\",\n",
      "    \"Applets\",\n",
      "    \"HTML\",\n",
      "    \"XML\",\n",
      "    \"Web 系统构成\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"数据层\", \"属于\", \"典型的系统应用架构\"],\n",
      "    [\"系统硬件组成\", \"属于\", \"典型的系统应用架构\"],\n",
      "    [\"客户计算机\", \"属于\", \"系统硬件组成\"],\n",
      "    [\"服务器\", \"属于\", \"系统硬件组成\"],\n",
      "    [\"网络\", \"属于\", \"系统硬件组成\"],\n",
      "    [\"主机小型机\", \"属于\", \"服务器\"],\n",
      "    [\"微机\", \"属于\", \"服务器\"],\n",
      "    [\"基于主机的服务器架构\", \"属于\", \"典型的系统应用架构\"],\n",
      "    [\"简单架构\", \"属于\", \"基于主机的服务器架构\"],\n",
      "    [\"单点控制\", \"属于\", \"基于主机的服务器架构\"],\n",
      "    [\"性能瓶颈\", \"属于\", \"基于主机的服务器架构\"],\n",
      "    [\"服务器超负荷\", \"属于\", \"基于主机的服务器架构\"],\n",
      "    [\"响应时间减慢\", \"属于\", \"基于主机的服务器架构\"],\n",
      "    [\"文件服务器架构\", \"属于\", \"典型的系统应用架构\"],\n",
      "    [\"客户端\", \"属于\", \"文件服务器架构\"],\n",
      "    [\"服务器端\", \"属于\", \"文件服务器架构\"],\n",
      "    [\"存储功能\", \"属于\", \"服务器端\"],\n",
      "    [\"表现逻辑\", \"属于\", \"客户端\"],\n",
      "    [\"应用逻辑\", \"属于\", \"客户端\"],\n",
      "    [\"数据处理逻辑\", \"属于\", \"客户端\"],\n",
      "    [\"数据完整性\", \"属于\", \"文件服务器架构\"],\n",
      "    [\"加锁机制\", \"属于\", \"文件服务器架构\"],\n",
      "    [\"客户/服务器架构\", \"属于\", \"典型的系统应用架构\"],\n",
      "    [\"分布式计算方案\", \"属于\", \"客户/服务器架构\"],\n",
      "    [\"胖客户\", \"属于\", \"客户/服务器架构\"],\n",
      "    [\"瘦客户\", \"属于\", \"客户/服务器架构\"],\n",
      "    [\"数据库服务器\", \"属于\", \"客户/服务器架构\"],\n",
      "    [\"事务服务器\", \"属于\", \"客户/服务器架构\"],\n",
      "    [\"应用服务器\", \"属于\", \"客户/服务器架构\"],\n",
      "    [\"信息和组件服务器\", \"属于\", \"客户/服务器架构\"],\n",
      "    [\"两层客户/服务器计算\", \"属于\", \"客户/服务器架构\"],\n",
      "    [\"C/S 结构\", \"属于\", \"客户/服务器架构\"],\n",
      "    [\"网络流量减少\", \"属于\", \"客户/服务器架构\"],\n",
      "    [\"数据库完整性维护\", \"属于\", \"客户/服务器架构\"],\n",
      "    [\"版本升级与维护\", \"属于\", \"客户/服务器架构\"],\n",
      "    [\"三层或 N 层客户/服务器架构\", \"属于\", \"典型的系统应用架构\"],\n",
      "    [\"中间层\", \"属于\", \"三层或 N 层客户/服务器架构\"],\n",
      "    [\"应用服务器端\", \"属于\", \"三层或 N 层客户/服务器架构\"],\n",
      "    [\"业务逻辑\", \"属于\", \"应用服务器端\"],\n",
      "    [\"负载平衡\", \"相关于\", \"三层或 N 层客户/服务器架构\"],\n",
      "    [\"表现层\", \"属于\", \"三层或 N 层客户/服务器架构\"],\n",
      "    [\"业务逻辑层\", \"属于\", \"三层或 N 层客户/服务器架构\"],\n",
      "    [\"数据访问层\", \"属于\", \"三层或 N 层客户/服务器架构\"],\n",
      "    [\"领域层\", \"等同于\", \"业务逻辑层\"],\n",
      "    [\"浏览器/服务器架构\", \"属于\", \"典型的系统应用架构\"],\n",
      "    [\"Web 浏览器\", \"属于\", \"浏览器/服务器架构\"],\n",
      "    [\"Web 服务器\", \"属于\", \"浏览器/服务器架构\"],\n",
      "    [\"Java 技术\", \"应用于\", \"浏览器/服务器架构\"],\n",
      "    [\"HTML\", \"应用于\", \"浏览器/服务器架构\"],\n",
      "    [\"XML\", \"应用于\", \"浏览器/服务器架构\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "4890\n",
      "sleep:38.0461300703584秒\n",
      "————————————第41章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"应用架构举例\",\n",
      "    \"浏览器/服务器架构原理\",\n",
      "    \"Java技术\",\n",
      "    \"超文本标记语言：HTML\",\n",
      "    \"可扩展标记语言：XML\",\n",
      "    \"Web服务器端\",\n",
      "    \"应用服务器端\",\n",
      "    \"表现从这里发布\",\n",
      "    \"MVC架构\",\n",
      "    \"Model-View-Controller\",\n",
      "    \"Smalltalk-80语言中的MVC架构\",\n",
      "    \"Model对象\",\n",
      "    \"负责管理资料或文件\",\n",
      "    \"视图\",\n",
      "    \"控制器\",\n",
      "    \"用户操作\",\n",
      "    \"模型更新\",\n",
      "    \"通知机制\",\n",
      "    \"代码层次划分\",\n",
      "    \"业务逻辑/数据层\",\n",
      "    \"用户界面层\",\n",
      "    \"应用流程控制层\",\n",
      "    \"View的实现\",\n",
      "    \"Model的实现\",\n",
      "    \"Controller的实现\",\n",
      "    \"模块功能划分的优点\",\n",
      "    \"并行开发\",\n",
      "    \"项目进度加快\",\n",
      "    \"基于MVC架构的五层软件架构\",\n",
      "    \"Web层\",\n",
      "    \"Structs框架\",\n",
      "    \"Business Control层\",\n",
      "    \"Entity层\",\n",
      "    \"DBControl层\",\n",
      "    \"Hibernate框架\",\n",
      "    \"HibernatePO\",\n",
      "    \"POJO\",\n",
      "    \"VO\",\n",
      "    \"应用架构设计\",\n",
      "    \"Web采用Structs框架\",\n",
      "    \"人机交互\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"浏览器/服务器架构原理\", \"属于\", \"应用架构举例\"],\n",
      "    [\"Java技术\", \"属于\", \"浏览器/服务器架构原理\"],\n",
      "    [\"超文本标记语言：HTML\", \"属于\", \"浏览器/服务器架构原理\"],\n",
      "    [\"可扩展标记语言：XML\", \"属于\", \"浏览器/服务器架构原理\"],\n",
      "    [\"Web服务器端\", \"属于\", \"浏览器/服务器架构原理\"],\n",
      "    [\"应用服务器端\", \"属于\", \"浏览器/服务器架构原理\"],\n",
      "    [\"表现从这里发布\", \"属于\", \"Web服务器端\"],\n",
      "    [\"MVC架构\", \"属于\", \"应用架构举例\"],\n",
      "    [\"Model-View-Controller\", \"等于\", \"MVC架构\"],\n",
      "    [\"Smalltalk-80语言中的MVC架构\", \"属于\", \"MVC架构\"],\n",
      "    [\"Model对象\", \"属于\", \"MVC架构\"],\n",
      "    [\"视图\", \"属于\", \"MVC架构\"],\n",
      "    [\"控制器\", \"属于\", \"MVC架构\"],\n",
      "    [\"用户操作\", \"关联于\", \"视图\"],\n",
      "    [\"模型更新\", \"关联于\", \"控制器\"],\n",
      "    [\"通知机制\", \"存在于\", \"MVC架构\"],\n",
      "    [\"代码层次划分\", \"属于\", \"MVC架构\"],\n",
      "    [\"业务逻辑/数据层\", \"属于\", \"代码层次划分\"],\n",
      "    [\"用户界面层\", \"属于\", \"代码层次划分\"],\n",
      "    [\"应用流程控制层\", \"属于\", \"代码层次划分\"],\n",
      "    [\"View的实现\", \"属于\", \"用户界面层\"],\n",
      "    [\"Model的实现\", \"属于\", \"业务逻辑/数据层\"],\n",
      "    [\"Controller的实现\", \"属于\", \"应用流程控制层\"],\n",
      "    [\"模块功能划分的优点\", \"相关于\", \"MVC架构\"],\n",
      "    [\"并行开发\", \"得益于\", \"模块功能划分\"],\n",
      "    [\"项目进度加快\", \"得益于\", \"模块功能划分\"],\n",
      "    [\"基于MVC架构的五层软件架构\", \"属于\", \"应用架构举例\"],\n",
      "    [\"Web层\", \"属于\", \"基于MVC架构的五层软件架构\"],\n",
      "    [\"Structs框架\", \"应用于\", \"Web层\"],\n",
      "    [\"Business Control层\", \"属于\", \"基于MVC架构的五层软件架构\"],\n",
      "    [\"Entity层\", \"属于\", \"基于MVC架构的五层软件架构\"],\n",
      "    [\"DBControl层\", \"属于\", \"基于MVC架构的五层软件架构\"],\n",
      "    [\"Hibernate框架\", \"应用于\", \"DBControl层\"],\n",
      "    [\"HibernatePO\", \"属于\", \"DBControl层\"],\n",
      "    [\"应用架构设计\", \"详细描述\", \"基于MVC架构的五层软件架构\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "2465\n",
      "sleep:38.16190876503697秒\n",
      "————————————第42章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"应用架构设计\",\n",
      "    \"模块功能划分\",\n",
      "    \"代码修改过程中的模块隔离\",\n",
      "    \"MVC 架构\",\n",
      "    \"五个层次的软件架构\",\n",
      "    \"Web 层\",\n",
      "    \"Structs 框架\",\n",
      "    \"Business Control 层\",\n",
      "    \"Entity 层\",\n",
      "    \"DBControl 层\",\n",
      "    \"Hibernate 框架\",\n",
      "    \"数据架构设计\",\n",
      "    \"数据分布问题\",\n",
      "    \"数据分割\",\n",
      "    \"水平分割\",\n",
      "    \"垂直分割\",\n",
      "    \"数据复制\",\n",
      "    \"单服务器存储所有数据\",\n",
      "    \"不同服务器存储特定表\",\n",
      "    \"不同服务器存储特定表子集\",\n",
      "    \"主拷贝/主表与拷贝/复本\",\n",
      "    \"业务数据存储需求\",\n",
      "    \"过程架构设计\",\n",
      "    \"软件开发环境(SDE)\",\n",
      "    \"编辑器与编译器\",\n",
      "    \"事务监视器\",\n",
      "    \"文件管理系统或数据库系统\",\n",
      "    \"两层服务器架构的SDE特征\",\n",
      "    \"图形用户界面构建(RAD环境)\",\n",
      "    \"GUI相关系统事件自动生成模块代码\",\n",
      "    \"编程语言\",\n",
      "    \"数据库引擎连接\",\n",
      "    \"客户端复杂代码测试和调试环境\",\n",
      "    \"系统测试环境\",\n",
      "    \"最终用户报告创建工作\",\n",
      "    \"客户端帮助文件系统\",\n",
      "    \"多层服务器架构的SDE特征\",\n",
      "    \"异构计算平台支持\",\n",
      "    \"客户端与服务器代码生成和编程\",\n",
      "    \"可复用性\",\n",
      "    \"CASE工具\",\n",
      "    \"应用组件分割工具\",\n",
      "    \"客户端与服务器上的支持工具\",\n",
      "    \"跨平台能力\",\n",
      "    \"软件版本控制\",\n",
      "    \"应用管理\",\n",
      "    \"浏览器/服务器架构\",\n",
      "    \"快速应用开发工具\",\n",
      "    \"HTML\",\n",
      "    \"XML\",\n",
      "    \"CGI\",\n",
      "    \"网页编程语言（如JAVA）\",\n",
      "    \"网络架构设计\",\n",
      "    \"服务器物理位置\",\n",
      "    \"客户端物理位置\",\n",
      "    \"处理器说明\",\n",
      "    \"传输协议\",\n",
      "    \"网络架构示意图\",\n",
      "    \"服务台系统架构设计案例分析\",\n",
      "    \"服务台系统性能需求\",\n",
      "    \"B/S三层体系架构\",\n",
      "    \"非分布式部署环境\",\n",
      "    \"轻量级J2EE企业技术平台\",\n",
      "    \"Spring核心容器\",\n",
      "    \"Struts MVC实现\",\n",
      "    \"Hibernate持久层技术框架\",\n",
      "    \"开源框架的优势\",\n",
      "    \"IoC (Inverse of Control)技术\",\n",
      "    \"AOP(Aspect-oriented Programming)技术\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"模块功能划分\", \"属于\", \"应用架构设计\"],\n",
      "    [\"MVC 架构\", \"属于\", \"应用架构设计\"],\n",
      "    [\"Web 层\", \"属于\", \"MVC 架构\"],\n",
      "    [\"Structs 框架\", \"应用于\", \"Web 层\"],\n",
      "    [\"Business Control 层\", \"属于\", \"五个层次的软件架构\"],\n",
      "    [\"Entity 层\", \"属于\", \"五个层次的软件架构\"],\n",
      "    [\"DBControl 层\", \"属于\", \"五个层次的软件架构\"],\n",
      "    [\"Hibernate 框架\", \"应用于\", \"DBControl 层\"],\n",
      "    [\"数据架构设计\", \"属于\", \"应用架构设计\"],\n",
      "    [\"数据分割\", \"属于\", \"数据架构设计\"],\n",
      "    [\"水平分割\", \"属于\", \"数据分割\"],\n",
      "    [\"垂直分割\", \"属于\", \"数据分割\"],\n",
      "    [\"数据复制\", \"属于\", \"数据架构设计\"],\n",
      "    [\"过程架构设计\", \"属于\", \"应用架构设计\"],\n",
      "    [\"两层服务器架构的SDE特征\", \"属于\", \"过程架构设计\"],\n",
      "    [\"多层服务器架构的SDE特征\", \"属于\", \"过程架构设计\"],\n",
      "    [\"网络架构设计\", \"属于\", \"应用架构设计\"],\n",
      "    [\"服务台系统架构设计案例分析\", \"属于\", \"应用架构设计\"],\n",
      "    [\"轻量级J2EE企业技术平台\", \"应用于\", \"服务台系统\"],\n",
      "    [\"Spring核心容器\", \"应用于\", \"服务台系统\"],\n",
      "    [\"Struts MVC实现\", \"应用于\", \"服务台系统\"],\n",
      "    [\"Hibernate持久层技术框架\", \"应用于\", \"服务台系统\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "3472\n",
      "sleep:37.8992632450731秒\n",
      "————————————第43章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"案例分析——某服务台系统架构设计\",\n",
      "    \"服务台系统性能需求分析\",\n",
      "    \"中型规模企业\",\n",
      "    \"高端产品与服务\",\n",
      "    \"售前与售后服务\",\n",
      "    \"客户资源积累\",\n",
      "    \"客户忠诚度培养\",\n",
      "    \"服务中心建设\",\n",
      "    \"在线人数要求\",\n",
      "    \"在线时间要求\",\n",
      "    \"B/S三层体系架构\",\n",
      "    \"单数据库服务器\",\n",
      "    \"单Web服务器\",\n",
      "    \"非分布式部署环境\",\n",
      "    \"系统维护与升级成本\",\n",
      "    \"轻量级J2EE企业技术平台\",\n",
      "    \"J2EE稳定性\",\n",
      "    \"J2EE高性能\",\n",
      "    \"开发平台选择依据\",\n",
      "    \"轻量级J2EE架构\",\n",
      "    \"重量级EJB架构\",\n",
      "    \"系统维护性\",\n",
      "    \"系统更新性\",\n",
      "    \"Spring为核心容器的架构\",\n",
      "    \"Struts的MVC实现\",\n",
      "    \"Hibernate技术框架\",\n",
      "    \"持久层\",\n",
      "    \"开源框架优势\",\n",
      "    \"Spring版本2.02\",\n",
      "    \"IoC(控制反转)\",\n",
      "    \"自动装配\",\n",
      "    \"配置文件\",\n",
      "    \"AOP(面向方面编程)\",\n",
      "    \"事务处理支持\",\n",
      "    \"配置式事务声明\",\n",
      "    \"Hibernate版本3.2.2\",\n",
      "    \"ORM(Object Relationship Mapping)\",\n",
      "    \"对象关系映射\",\n",
      "    \"系统管理功能\",\n",
      "    \"复杂数据库操作自动化\",\n",
      "    \"Struts版本1.2.8\",\n",
      "    \"MVC2设计模式\",\n",
      "    \"数据模型层分离\",\n",
      "    \"中央控制器层分离\",\n",
      "    \"视图呈现层分离\",\n",
      "    \"系统升级维护成本降低\",\n",
      "    \"服务台系统开发环境\",\n",
      "    \"Windows XP sp2\",\n",
      "    \"JDK 5.0\",\n",
      "    \"嵌入式Tomcat 5.5.9\",\n",
      "    \"HSQL DB 1.8.0.7\",\n",
      "    \"Spring 2.0.2\",\n",
      "    \"Hibernate 3.2.2\",\n",
      "    \"Struts 1.2.8\",\n",
      "    \"Eclipse 3.2\",\n",
      "    \"IE 6.0\",\n",
      "    \"FireFox 2.0.2\",\n",
      "    \"技术标准\",\n",
      "    \"HTML 4.0\",\n",
      "    \"CSS 2.0\",\n",
      "    \"JSP 2.0\",\n",
      "    \"Servlet 2.4\",\n",
      "    \"服务台系统部署环境\",\n",
      "    \"操作系统与JRE环境\",\n",
      "    \"Win2003+\",\n",
      "    \"JRE 5.0\",\n",
      "    \"Web服务器\",\n",
      "    \"Tomcat 5.5.9兼容\",\n",
      "    \"JSP 2.0标准\",\n",
      "    \"Servlet 2.4标准\",\n",
      "    \"数据库服务器\",\n",
      "    \"Hibernate 3.2.2支持\",\n",
      "    \"MySQL 5.0+\",\n",
      "    \"客户端浏览器\",\n",
      "    \"IE 6.0+\",\n",
      "    \"服务器端硬件环境\",\n",
      "    \"数据库服务器与Web服务器分离\",\n",
      "    \"最低配置\",\n",
      "    \"内存要求\",\n",
      "    \"CPU要求\",\n",
      "    \"客户端硬件环境\",\n",
      "    \"推荐配置\",\n",
      "    \"最低配置要求\",\n",
      "    \"本章小结\",\n",
      "    \"应用架构\",\n",
      "    \"定义\",\n",
      "    \"特点\",\n",
      "    \"逻辑层次\",\n",
      "    \"典型应用架构类型\",\n",
      "    \"应用架构设计方法\",\n",
      "    \"系统需求综合考虑\",\n",
      "    \"设计方案提供\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"服务台系统性能需求分析\", \"属于\", \"案例分析——某服务台系统架构设计\"],\n",
      "    [\"中型规模企业\", \"属于\", \"服务台系统性能需求分析\"],\n",
      "    [\"高端产品与服务\", \"属于\", \"服务台系统性能需求分析\"],\n",
      "    [\"售前与售后服务\", \"属于\", \"服务台系统性能需求分析\"],\n",
      "    [\"客户资源积累\", \"属于\", \"服务台系统性能需求分析\"],\n",
      "    [\"客户忠诚度培养\", \"属于\", \"服务台系统性能需求分析\"],\n",
      "    [\"服务中心建设\", \"属于\", \"服务台系统性能需求分析\"],\n",
      "    [\"在线人数要求\", \"属于\", \"服务台系统性能需求分析\"],\n",
      "    [\"在线时间要求\", \"属于\", \"服务台系统性能需求分析\"],\n",
      "    [\"B/S三层体系架构\", \"属于\", \"服务台系统性能需求分析\"],\n",
      "    [\"单数据库服务器\", \"属于\", \"服务台系统性能需求分析\"],\n",
      "    [\"单Web服务器\", \"属于\", \"服务台系统性能需求分析\"],\n",
      "    [\"非分布式部署环境\", \"属于\", \"服务台系统性能需求分析\"],\n",
      "    [\"轻量级J2EE企业技术平台\", \"属于\", \"服务台系统性能需求分析\"],\n",
      "    [\"开发平台选择\", \"属于\", \"案例分析——某服务台系统架构设计\"],\n",
      "    [\"轻量级J2EE架构\", \"属于\", \"开发平台选择\"],\n",
      "    [\"重量级EJB架构\", \"属于\", \"开发平台选择\"],\n",
      "    [\"Spring为核心容器的架构\", \"属于\", \"开发平台选择\"],\n",
      "    [\"Struts的MVC实现\", \"属于\", \"开发平台选择\"],\n",
      "    [\"Hibernate技术框架\", \"属于\", \"开发平台选择\"],\n",
      "    [\"服务台系统开发环境\", \"属于\", \"案例分析——某服务台系统架构设计\"],\n",
      "    [\"服务台系统部署环境\", \"属于\", \"案例分析——某服务台系统架构设计\"],\n",
      "    [\"本章小结\", \"属于\", \"案例分析——某服务台系统架构设计\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "3099\n",
      "sleep:37.30399088568355秒\n",
      "————————————第44章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"本章小结\",\n",
      "    \"应用架构\",\n",
      "    \"定义\",\n",
      "    \"特点\",\n",
      "    \"逻辑层次\",\n",
      "    \"典型应用架构类型\",\n",
      "    \"应用架构设计方法\",\n",
      "    \"系统需求\",\n",
      "    \"设计方案\",\n",
      "    \"汽车零部件商店全国供应链系统\",\n",
      "    \"PC 办公功能\",\n",
      "    \"区域经理\",\n",
      "    \"销售促进\",\n",
      "    \"高速拨号线和调制解调器\",\n",
      "    \"分布式系统\",\n",
      "    \"客户机/服务器结构\",\n",
      "    \"访问已安装 LAN 的组织\",\n",
      "    \"文件服务器结构\",\n",
      "    \"应用程序\",\n",
      "    \"用户数\",\n",
      "    \"专业和技术性技巧\",\n",
      "    \"商业处理\",\n",
      "    \"数据操作\",\n",
      "    \"客户机/服务器结构\",\n",
      "    \"分布式处理环境\",\n",
      "    \"数据冲突管理\",\n",
      "    \"客户机/服务器结构优点\",\n",
      "    \"操作和管理问题\",\n",
      "    \"适用场景\",\n",
      "    \"浏览器/服务器模式电子商务网站\",\n",
      "    \"优点比较\",\n",
      "    \"适用场景\",\n",
      "    \"瘦客户技术\",\n",
      "    \"无线移动计算\",\n",
      "    \"掌上计算机\",\n",
      "    \"WPA电话\",\n",
      "    \"PDA\",\n",
      "    \"设备特征分析\",\n",
      "    \"屏幕尺寸\",\n",
      "    \"颜色\",\n",
      "    \"网络选项与速度\",\n",
      "    \"固定存储器\",\n",
      "    \"嵌入应用\",\n",
      "    \"软件过程设计\",\n",
      "    \"主要内容\",\n",
      "    \"总体设计\",\n",
      "    \"详细设计\",\n",
      "    \"模块化\",\n",
      "    \"抽象与信息隐蔽\",\n",
      "    \"模块独立性\",\n",
      "    \"设计工具\",\n",
      "    \"HIPO图\",\n",
      "    \"软件结构图\",\n",
      "    \"详细设计工具\",\n",
      "    \"特点比较\",\n",
      "    \"软件设计方法\",\n",
      "    \"适用情况\",\n",
      "    \"软件详细设计目标\",\n",
      "    \"过程设计方法\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"本章小结\", \"属于\", \"第8章\"],\n",
      "    [\"应用架构\", \"属于\", \"本章小结\"],\n",
      "    [\"定义\", \"属于\", \"应用架构\"],\n",
      "    [\"特点\", \"属于\", \"应用架构\"],\n",
      "    [\"逻辑层次\", \"属于\", \"应用架构\"],\n",
      "    [\"典型应用架构类型\", \"属于\", \"应用架构\"],\n",
      "    [\"应用架构设计方法\", \"属于\", \"应用架构\"],\n",
      "    [\"系统需求\", \"相关联\", \"设计方案\"],\n",
      "    [\"设计方案\", \"根据\", \"应用架构设计方法\"],\n",
      "    [\"汽车零部件商店全国供应链系统\", \"涉及\", \"应用架构设计问题\"],\n",
      "    [\"客户机/服务器结构\", \"推荐\", \"汽车零部件商店全国供应链系统\"],\n",
      "    [\"访问已安装LAN的组织\", \"用于分析\", \"客户机/服务器结构\"],\n",
      "    [\"文件服务器结构\", \"对比\", \"客户机/服务器结构\"],\n",
      "    [\"分布式处理环境\", \"探讨\", \"数据冲突管理\"],\n",
      "    [\"客户机/服务器结构优点\", \"讨论\", \"客户机/服务器结构\"],\n",
      "    [\"操作和管理问题\", \"关联于\", \"客户机/服务器结构\"],\n",
      "    [\"浏览器/服务器模式电子商务网站\", \"对比\", \"客户机/服务器结构\"],\n",
      "    [\"瘦客户技术\", \"应用于\", \"无线移动计算\"],\n",
      "    [\"掌上计算机,WPA电话,PDA\", \"包含于\", \"瘦客户技术\"],\n",
      "    [\"软件过程设计\", \"属于\", \"第8章\"],\n",
      "    [\"主要内容\", \"属于\", \"软件过程设计\"],\n",
      "    [\"总体设计\", \"属于\", \"软件过程设计主要内容\"],\n",
      "    [\"详细设计\", \"属于\", \"软件过程设计主要内容\"],\n",
      "    [\"模块化\", \"属于\", \"软件设计基本原理\"],\n",
      "    [\"抽象与信息隐蔽\", \"属于\", \"软件设计基本原理\"],\n",
      "    [\"模块独立性\", \"属于\", \"软件设计基本原理\"],\n",
      "    [\"HIPO图,软件结构图,详细设计工具\", \"属于\", \"软件设计工具\"],\n",
      "    [\"软件详细设计目标\", \"属于\", \"软件过程设计\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "2912\n",
      "sleep:37.75754457669194秒\n",
      "————————————第45章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"软件过程设计\",\n",
      "    \"主要内容\",\n",
      "    \"总体设计\",\n",
      "    \"详细设计\",\n",
      "    \"模块化\",\n",
      "    \"抽象与信息隐蔽\",\n",
      "    \"模块的独立性\",\n",
      "    \"HIPO 图\",\n",
      "    \"软件结构图\",\n",
      "    \"详细设计工具\",\n",
      "    \"软件结构设计方法\",\n",
      "    \"数据流图\",\n",
      "    \"数据字典\",\n",
      "    \"系统分析阶段\",\n",
      "    \"结构设计\",\n",
      "    \"过程设计\",\n",
      "    \"数据库设计\",\n",
      "    \"功能分解\",\n",
      "    \"IPO图\",\n",
      "    \"层次图\",\n",
      "    \"结构图\",\n",
      "    \"软件结构\",\n",
      "    \"模块\",\n",
      "    \"层次系统\",\n",
      "    \"详细设计目标\",\n",
      "    \"程序蓝图\",\n",
      "    \"编码阶段\",\n",
      "    \"质量保证\",\n",
      "    \"模块的基本属性\",\n",
      "    \"接口\",\n",
      "    \"功能\",\n",
      "    \"逻辑\",\n",
      "    \"状态\",\n",
      "    \"模块化原理\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"主要内容\", \"属于\", \"软件过程设计\"],\n",
      "    [\"总体设计\", \"属于\", \"主要内容\"],\n",
      "    [\"详细设计\", \"属于\", \"主要内容\"],\n",
      "    [\"模块化\", \"属于\", \"软件设计的基本原理\"],\n",
      "    [\"抽象与信息隐蔽\", \"属于\", \"软件设计的基本原理\"],\n",
      "    [\"模块的独立性\", \"属于\", \"软件设计的基本原理\"],\n",
      "    [\"HIPO 图\", \"属于\", \"软件设计工具\"],\n",
      "    [\"软件结构图\", \"属于\", \"软件设计工具\"],\n",
      "    [\"详细设计工具\", \"属于\", \"软件设计工具\"],\n",
      "    [\"功能分解\", \"属于\", \"过程设计主要内容\"],\n",
      "    [\"IPO图\", \"属于\", \"功能分解\"],\n",
      "    [\"层次图\", \"属于\", \"软件结构\"],\n",
      "    [\"结构图\", \"属于\", \"软件结构\"],\n",
      "    [\"模块\", \"属于\", \"软件结构\"],\n",
      "    [\"层次系统\", \"属于\", \"软件结构\"],\n",
      "    [\"详细设计目标\", \"属于\", \"详细设计\"],\n",
      "    [\"程序蓝图\", \"属于\", \"详细设计结果\"],\n",
      "    [\"编码阶段\", \"相关\", \"详细设计\"],\n",
      "    [\"模块的基本属性\", \"属于\", \"模块化原理\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "1793\n",
      "sleep:37.678936970006646秒\n",
      "————————————第46章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"详细设计\",\n",
      "    \"模块化\",\n",
      "    \"接口\",\n",
      "    \"功能\",\n",
      "    \"逻辑\",\n",
      "    \"状态\",\n",
      "    \"模块化的基本原理\",\n",
      "    \"复杂问题的分解\",\n",
      "    \"降低复杂性\",\n",
      "    \"减少开发工作量\",\n",
      "    \"开发成本\",\n",
      "    \"模块数量与模块接口的平衡\",\n",
      "    \"抽象\",\n",
      "    \"信息隐蔽\",\n",
      "    \"过程实体\",\n",
      "    \"模块独立性\",\n",
      "    \"子功能\",\n",
      "    \"耦合性\",\n",
      "    \"块间联系\",\n",
      "    \"模块间接口的复杂性\",\n",
      "    \"调用方式\",\n",
      "    \"传递的信息\",\n",
      "    \"无直接耦合\",\n",
      "    \"数据耦合\",\n",
      "    \"标记耦合\",\n",
      "    \"控制耦合\",\n",
      "    \"公共耦合\",\n",
      "    \"内容耦合\",\n",
      "    \"内聚性\",\n",
      "    \"块内联系\",\n",
      "    \"偶然内聚\",\n",
      "    \"逻辑内聚\",\n",
      "    \"时间内聚\",\n",
      "    \"通信内聚\",\n",
      "    \"顺序内聚\",\n",
      "    \"功能内聚\",\n",
      "    \"高内聚低耦合原则\",\n",
      "    \"软件设计工具\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"详细设计\", \"属于\", \"软件设计的基本原理\"],\n",
      "    [\"模块化\", \"属于\", \"软件设计的基本原理\"],\n",
      "    [\"接口\", \"属于\", \"模块化\"],\n",
      "    [\"功能\", \"属于\", \"模块化\"],\n",
      "    [\"逻辑\", \"属于\", \"模块化\"],\n",
      "    [\"状态\", \"属于\", \"模块化\"],\n",
      "    [\"模块化的基本原理\", \"属于\", \"软件设计的基本原理\"],\n",
      "    [\"复杂问题的分解\", \"属于\", \"模块化的基本原理\"],\n",
      "    [\"降低复杂性\", \"属于\", \"模块化的基本原理\"],\n",
      "    [\"减少开发工作量\", \"属于\", \"模块化的基本原理\"],\n",
      "    [\"开发成本\", \"属于\", \"模块化的基本原理\"],\n",
      "    [\"模块数量与模块接口的平衡\", \"属于\", \"模块化的基本原理\"],\n",
      "    [\"抽象\", \"属于\", \"软件设计的基本原理\"],\n",
      "    [\"信息隐蔽\", \"属于\", \"软件设计的基本原理\"],\n",
      "    [\"模块独立性\", \"属于\", \"软件设计的基本原理\"],\n",
      "    [\"子功能\", \"属于\", \"模块独立性\"],\n",
      "    [\"耦合性\", \"属于\", \"模块独立性\"],\n",
      "    [\"块间联系\", \"属于\", \"耦合性\"],\n",
      "    [\"模块间接口的复杂性\", \"属于\", \"耦合性\"],\n",
      "    [\"调用方式\", \"属于\", \"耦合性\"],\n",
      "    [\"传递的信息\", \"属于\", \"耦合性\"],\n",
      "    [\"无直接耦合\", \"属于\", \"耦合性类型\"],\n",
      "    [\"数据耦合\", \"属于\", \"耦合性类型\"],\n",
      "    [\"标记耦合\", \"属于\", \"耦合性类型\"],\n",
      "    [\"控制耦合\", \"属于\", \"耦合性类型\"],\n",
      "    [\"公共耦合\", \"属于\", \"耦合性类型\"],\n",
      "    [\"内容耦合\", \"属于\", \"耦合性类型\"],\n",
      "    [\"内聚性\", \"属于\", \"模块独立性\"],\n",
      "    [\"块内联系\", \"属于\", \"内聚性\"],\n",
      "    [\"偶然内聚\", \"属于\", \"内聚性类型\"],\n",
      "    [\"逻辑内聚\", \"属于\", \"内聚性类型\"],\n",
      "    [\"时间内聚\", \"属于\", \"内聚性类型\"],\n",
      "    [\"通信内聚\", \"属于\", \"内聚性类型\"],\n",
      "    [\"顺序内聚\", \"属于\", \"内聚性类型\"],\n",
      "    [\"功能内聚\", \"属于\", \"内聚性类型\"],\n",
      "    [\"高内聚低耦合原则\", \"属于\", \"模块独立性\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "2587\n",
      "sleep:37.020674956655576秒\n",
      "————————————第47章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"耦合性\",\n",
      "    \"内聚性\",\n",
      "    \"模块独立性\",\n",
      "    \"高内聚低耦合原则\",\n",
      "    \"HIPO图\",\n",
      "    \"HIPO分层图\",\n",
      "    \"IPO图\",\n",
      "    \"输入-处理-输出图\",\n",
      "    \"模块编号\",\n",
      "    \"可追踪性\",\n",
      "    \"软件设计工具\",\n",
      "    \"功能内聚\",\n",
      "    \"顺序内聚\",\n",
      "    \"时间内聚\",\n",
      "    \"通信内聚\",\n",
      "    \"偶然内聚\",\n",
      "    \"逻辑内聚\",\n",
      "    \"软件结构图\",\n",
      "    \"Yourdon的结构图\",\n",
      "    \"模块表示\",\n",
      "    \"调用关系\",\n",
      "    \"数据传递\",\n",
      "    \"控制传递\",\n",
      "    \"循环调用\",\n",
      "    \"选择调用\",\n",
      "    \"模块间接口\",\n",
      "    \"模块间的联系\",\n",
      "    \"层次图\",\n",
      "    \"结构图与层次图对比\",\n",
      "    \"模块选择调用\",\n",
      "    \"模块循环调用\",\n",
      "    \"扇入\",\n",
      "    \"扇出\",\n",
      "    \"深度\",\n",
      "    \"宽度\",\n",
      "    \"详细设计工具\",\n",
      "    \"程序流程图(PFC)\",\n",
      "    \"基本控制结构\",\n",
      "    \"顺序型\",\n",
      "    \"选择型\",\n",
      "    \"先判定型循环\",\n",
      "    \"后判定型循环\",\n",
      "    \"多情况选择型\",\n",
      "    \"盒图(N-S图)\",\n",
      "    \"结构化控制结构\",\n",
      "    \"调用子程序\",\n",
      "    \"问题分析图(PAD)\",\n",
      "    \"PAD符号\",\n",
      "    \"二维树形结构\",\n",
      "    \"程序层次\",\n",
      "    \"程序主线\",\n",
      "    \"面向数据流的设计方法\",\n",
      "    \"变换分析设计\",\n",
      "    \"事务分析设计\",\n",
      "    \"变换流\",\n",
      "    \"事务流\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"耦合性\", \"属于\", \"软件设计工具\"],\n",
      "    [\"内聚性\", \"属于\", \"软件设计工具\"],\n",
      "    [\"模块独立性\", \"属于\", \"软件设计工具\"],\n",
      "    [\"高内聚低耦合原则\", \"属于\", \"软件设计工具\"],\n",
      "    [\"HIPO图\", \"属于\", \"软件设计工具\"],\n",
      "    [\"HIPO分层图\", \"属于\", \"HIPO图\"],\n",
      "    [\"IPO图\", \"属于\", \"HIPO图\"],\n",
      "    [\"输入-处理-输出图\", \"同义于\", \"IPO图\"],\n",
      "    [\"模块编号\", \"用于\", \"HIPO图\"],\n",
      "    [\"可追踪性\", \"特征\", \"HIPO图\"],\n",
      "    [\"软件结构图\", \"属于\", \"软件设计工具\"],\n",
      "    [\"功能内聚\", \"类型\", \"内聚性\"],\n",
      "    [\"顺序内聚\", \"类型\", \"内聚性\"],\n",
      "    [\"时间内聚\", \"类型\", \"内聚性\"],\n",
      "    [\"通信内聚\", \"类型\", \"内聚性\"],\n",
      "    [\"偶然内聚\", \"类型\", \"内聚性\"],\n",
      "    [\"逻辑内聚\", \"类型\", \"内聚性\"],\n",
      "    [\"模块选择调用\", \"类型\", \"控制传递\"],\n",
      "    [\"模块循环调用\", \"类型\", \"控制传递\"],\n",
      "    [\"扇入\", \"属性\", \"软件结构图形态特征\"],\n",
      "    [\"扇出\", \"属性\", \"软件结构图形态特征\"],\n",
      "    [\"深度\", \"属性\", \"软件结构图形态特征\"],\n",
      "    [\"宽度\", \"属性\", \"软件结构图形态特征\"],\n",
      "    [\"详细设计工具\", \"阶段\", \"软件设计工具\"],\n",
      "    [\"程序流程图(PFC)\", \"工具\", \"详细设计工具\"],\n",
      "    [\"盒图(N-S图)\", \"工具\", \"详细设计工具\"],\n",
      "    [\"问题分析图(PAD)\", \"工具\", \"详细设计工具\"],\n",
      "    [\"变换分析设计\", \"方法\", \"面向数据流的设计方法\"],\n",
      "    [\"事务分析设计\", \"方法\", \"面向数据流的设计方法\"],\n",
      "    [\"变换流\", \"类型\", \"信息流\"],\n",
      "    [\"事务流\", \"类型\", \"信息流\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "4586\n",
      "sleep:38.47793672221975秒\n",
      "————————————第48章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"练习：画出下列伪码程序的程序流程图和盒图\",\n",
      "    \"PAD图\",\n",
      "    \"内嵌套层数增多时的问题\",\n",
      "    \"图形清晰性受影响\",\n",
      "    \"面向高级程序设计语言\",\n",
      "    \"FORTRAN\",\n",
      "    \"COBOL\",\n",
      "    \"PASCAL\",\n",
      "    \"图形符号与控制语句对应\",\n",
      "    \"PAD图转换为高级语言程序的容易性\",\n",
      "    \"8.4 软件结构设计方法\",\n",
      "    \"面向数据流的设计方法\",\n",
      "    \"系统化途径\",\n",
      "    \"信息流的关键考虑\",\n",
      "    \"数据流图描绘信息处理和流动情况\",\n",
      "    \"映射\",\n",
      "    \"数据流图变换成软件结构\",\n",
      "    \"结构化设计方法（SD 方法）\",\n",
      "    \"基于数据流的设计方法\",\n",
      "    \"结构化分析产生的数据流图为基础\",\n",
      "    \"映射成软件结构的步骤\",\n",
      "    \"信息流的类型\",\n",
      "    \"变换流\",\n",
      "    \"事务流\",\n",
      "    \"设计方法的划分\",\n",
      "    \"变换分析设计\",\n",
      "    \"事务分析设计\",\n",
      "    \"变换流的形式特征\",\n",
      "    \"输入通路\",\n",
      "    \"外部形式到内部形式的变换\",\n",
      "    \"变换中心\",\n",
      "    \"处理过程\",\n",
      "    \"输出通路\",\n",
      "    \"内部形式到外部形式的变换\",\n",
      "    \"变换流定义\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"练习：画出下列伪码程序的程序流程图和盒图\", \"属于\", \"该段落主题\"],\n",
      "    [\"PAD图\", \"属于\", \"面向高级程序设计语言\"],\n",
      "    [\"内嵌套层数增多时的问题\", \"属于\", \"PAD图\"],\n",
      "    [\"图形清晰性受影响\", \"属于\", \"内嵌套层数增多时的问题\"],\n",
      "    [\"FORTRAN\", \"属于\", \"面向高级程序设计语言\"],\n",
      "    [\"COBOL\", \"属于\", \"面向高级程序设计语言\"],\n",
      "    [\"PASCAL\", \"属于\", \"面向高级程序设计语言\"],\n",
      "    [\"图形符号与控制语句对应\", \"属于\", \"PAD图\"],\n",
      "    [\"PAD图转换为高级语言程序的容易性\", \"属于\", \"PAD图\"],\n",
      "    [\"8.4 软件结构设计方法\", \"属于\", \"该段落主题\"],\n",
      "    [\"面向数据流的设计方法\", \"属于\", \"8.4 软件结构设计方法\"],\n",
      "    [\"系统化途径\", \"属于\", \"面向数据流的设计方法\"],\n",
      "    [\"信息流的关键考虑\", \"属于\", \"系统需求分析阶段\"],\n",
      "    [\"数据流图描绘信息处理和流动情况\", \"属于\", \"信息流的关键考虑\"],\n",
      "    [\"映射\", \"属于\", \"面向数据流的设计方法\"],\n",
      "    [\"数据流图变换成软件结构\", \"属于\", \"面向数据流的设计方法\"],\n",
      "    [\"结构化设计方法（SD 方法）\", \"属于\", \"面向数据流的设计方法\"],\n",
      "    [\"基于数据流的设计方法\", \"属于\", \"结构化设计方法（SD 方法）\"],\n",
      "    [\"映射成软件结构的步骤\", \"属于\", \"结构化设计方法（SD 方法）\"],\n",
      "    [\"信息流的类型\", \"属于\", \"面向数据流的设计方法\"],\n",
      "    [\"变换流\", \"属于\", \"信息流的类型\"],\n",
      "    [\"事务流\", \"属于\", \"信息流的类型\"],\n",
      "    [\"设计方法的划分\", \"属于\", \"面向数据流的设计方法\"],\n",
      "    [\"变换分析设计\", \"属于\", \"设计方法的划分\"],\n",
      "    [\"事务分析设计\", \"属于\", \"设计方法的划分\"],\n",
      "    [\"变换流的形式特征\", \"属于\", \"变换分析设计\"],\n",
      "    [\"输入通路\", \"属于\", \"变换流的形式特征\"],\n",
      "    [\"外部形式到内部形式的变换\", \"属于\", \"变换流的形式特征\"],\n",
      "    [\"变换中心\", \"属于\", \"变换流的形式特征\"],\n",
      "    [\"处理过程\", \"属于\", \"变换流的形式特征\"],\n",
      "    [\"输出通路\", \"属于\", \"变换流的形式特征\"],\n",
      "    [\"内部形式到外部形式的变换\", \"属于\", \"变换流的形式特征\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "1697\n",
      "sleep:37.957700869549676秒\n",
      "————————————第49章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"软件结构设计方法\",\n",
      "    \"PAD图\",\n",
      "    \"高级程序设计语言\",\n",
      "    \"FORTRAN\",\n",
      "    \"COBOL\",\n",
      "    \"PASCAL\",\n",
      "    \"数据流图\",\n",
      "    \"结构化设计方法（SD 方法）\",\n",
      "    \"变换分析设计\",\n",
      "    \"事务分析设计\",\n",
      "    \"综合数据流图的映射\",\n",
      "    \"分层数据流图的映射\",\n",
      "    \"变换流\",\n",
      "    \"信息流\",\n",
      "    \"事务流\",\n",
      "    \"输入流\",\n",
      "    \"输出流\",\n",
      "    \"变换中心\",\n",
      "    \"逻辑输入\",\n",
      "    \"逻辑输出\",\n",
      "    \"物理输入\",\n",
      "    \"物理输出\",\n",
      "    \"时间\",\n",
      "    \"内部表示\",\n",
      "    \"外部表示\",\n",
      "    \"变换型数据流的设计步骤\",\n",
      "    \"顶层主模块Cm\",\n",
      "    \"输入模块\",\n",
      "    \"输出模块\",\n",
      "    \"变换模块\",\n",
      "    \"中下层模块设计\",\n",
      "    \"设计优化\",\n",
      "    \"输入部分的求精\",\n",
      "    \"输出部分的求精\",\n",
      "    \"变换部分的求精\",\n",
      "    \"高内聚低耦合原则\",\n",
      "    \"事务处理中心\",\n",
      "    \"接收分支\",\n",
      "    \"发送分支\",\n",
      "    \"调度模块\",\n",
      "    \"活动流通路映射\",\n",
      "    \"混合数据流图的设计思路\",\n",
      "    \"分层数据流图的映射策略\",\n",
      "    \"销售管理系统案例\",\n",
      "    \"订货处理子模块\",\n",
      "    \"进货处理\",\n",
      "    \"缺货处理\",\n",
      "    \"销售统计\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"软件结构设计方法\", \"包含\", \"变换分析设计\"],\n",
      "    [\"软件结构设计方法\", \"包含\", \"事务分析设计\"],\n",
      "    [\"软件结构设计方法\", \"包含\", \"综合数据流图的映射\"],\n",
      "    [\"软件结构设计方法\", \"包含\", \"分层数据流图的映射\"],\n",
      "    [\"PAD图\", \"属于\", \"面向高级程序设计语言\"],\n",
      "    [\"FORTRAN\", \"属于\", \"高级程序设计语言\"],\n",
      "    [\"COBOL\", \"属于\", \"高级程序设计语言\"],\n",
      "    [\"PASCAL\", \"属于\", \"高级程序设计语言\"],\n",
      "    [\"结构化设计方法（SD 方法）\", \"属于\", \"面向数据流的设计方法\"],\n",
      "    [\"变换分析设计\", \"属于\", \"软件结构设计方法\"],\n",
      "    [\"事务分析设计\", \"属于\", \"软件结构设计方法\"],\n",
      "    [\"变换流\", \"属于\", \"信息流\"],\n",
      "    [\"事务流\", \"属于\", \"信息流\"],\n",
      "    [\"变换型数据流的设计步骤\", \"属于\", \"变换分析设计\"],\n",
      "    [\"顶层主模块Cm\", \"属于\", \"变换型数据流的设计步骤\"],\n",
      "    [\"输入模块\", \"属于\", \"变换型数据流的设计步骤\"],\n",
      "    [\"输出模块\", \"属于\", \"变换型数据流的设计步骤\"],\n",
      "    [\"变换模块\", \"属于\", \"变换型数据流的设计步骤\"],\n",
      "    [\"中下层模块设计\", \"属于\", \"变换型数据流的设计步骤\"],\n",
      "    [\"输入部分的求精\", \"属于\", \"设计优化\"],\n",
      "    [\"输出部分的求精\", \"属于\", \"设计优化\"],\n",
      "    [\"变换部分的求精\", \"属于\", \"设计优化\"],\n",
      "    [\"事务处理中心\", \"属于\", \"事务分析设计\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "3926\n",
      "sleep:38.22946149707779秒\n",
      "————————————第50章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"软件详细设计\",\n",
      "    \"SA方法需求分析的过程模型\",\n",
      "    \"事务性流程图设计\",\n",
      "    \"软件结构图主图\",\n",
      "    \"下层结构图设计\",\n",
      "    \"订货处理模块的软件结构图\",\n",
      "    \"结构化程序设计\",\n",
      "    \"转移语句\",\n",
      "    \"顺序结构\",\n",
      "    \"选择（分支）结构\",\n",
      "    \"循环结构\",\n",
      "    \"程序设计目标\",\n",
      "    \"可维护性\",\n",
      "    \"可靠性\",\n",
      "    \"可理解性\",\n",
      "    \"效率\",\n",
      "    \"程序设计人员工作效率\",\n",
      "    \"软件开发工具\",\n",
      "    \"MIS生成器\",\n",
      "    \"程序效率与可维护性、可理解性的关系\",\n",
      "    \"大型程序设计要求\",\n",
      "    \"程序设计方法\",\n",
      "    \"自顶向下的结构化程序方法\",\n",
      "    \"模块独立性\",\n",
      "    \"模块大小划分\",\n",
      "    \"模块功能简单\",\n",
      "    \"共享功能模块集中\",\n",
      "    \"案例分析——百货商店业务管理信息系统过程建模\",\n",
      "    \"销售子系统\",\n",
      "    \"采购子系统\",\n",
      "    \"会计子系统\",\n",
      "    \"功能模块结构\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"事务性流程图设计\", \"属于\", \"SA方法需求分析的过程模型\"],\n",
      "    [\"软件结构图主图\", \"属于\", \"SA方法需求分析的过程模型\"],\n",
      "    [\"下层结构图设计\", \"属于\", \"SA方法需求分析的过程模型\"],\n",
      "    [\"订货处理模块的软件结构图\", \"属于\", \"下层结构图设计\"],\n",
      "    [\"顺序结构\", \"属于\", \"结构化程序设计\"],\n",
      "    [\"选择（分支）结构\", \"属于\", \"结构化程序设计\"],\n",
      "    [\"循环结构\", \"属于\", \"结构化程序设计\"],\n",
      "    [\"可维护性\", \"属于\", \"程序设计目标\"],\n",
      "    [\"可靠性\", \"属于\", \"程序设计目标\"],\n",
      "    [\"可理解性\", \"属于\", \"程序设计目标\"],\n",
      "    [\"效率\", \"属于\", \"程序设计目标\"],\n",
      "    [\"自顶向下的结构化程序方法\", \"属于\", \"程序设计方法\"],\n",
      "    [\"模块独立性\", \"属于\", \"自顶向下的结构化程序方法\"],\n",
      "    [\"模块大小划分\", \"属于\", \"自顶向下的结构化程序方法\"],\n",
      "    [\"模块功能简单\", \"属于\", \"自顶向下的结构化程序方法\"],\n",
      "    [\"共享功能模块集中\", \"属于\", \"自顶向下的结构化程序方法\"],\n",
      "    [\"销售子系统\", \"属于\", \"百货商店业务管理信息系统过程建模\"],\n",
      "    [\"采购子系统\", \"属于\", \"百货商店业务管理信息系统过程建模\"],\n",
      "    [\"会计子系统\", \"属于\", \"百货商店业务管理信息系统过程建模\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "2412\n",
      "sleep:37.998035162409494秒\n",
      "————————————第51章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"案例分析——百货商店业务管理信息系统过程建模\",\n",
      "    \"软件开发工程化方法\",\n",
      "    \"自顶向下的模块化程序设计\",\n",
      "    \"软件工程环境\",\n",
      "    \"提高软件开发效率\",\n",
      "    \"结构化程序方法\",\n",
      "    \"系统总体理解和把握\",\n",
      "    \"功能模块逐步求精\",\n",
      "    \"层次结构\",\n",
      "    \"底层模块特点\",\n",
      "    \"模块独立性原则\",\n",
      "    \"减少模块间耦合\",\n",
      "    \"模块大小划分原则\",\n",
      "    \"模块功能简单原则\",\n",
      "    \"共享功能模块集中原则\",\n",
      "    \"销售子系统\",\n",
      "    \"采购子系统\",\n",
      "    \"会计子系统\",\n",
      "    \"功能模块结构\",\n",
      "    \"控制结构\",\n",
      "    \"订单处理流程\",\n",
      "    \"编辑功能模块\",\n",
      "    \"检验核对功能模块\",\n",
      "    \"分类处理功能模块\",\n",
      "    \"库存细节处理\",\n",
      "    \"缺货单反馈\",\n",
      "    \"不合格订单处理\",\n",
      "    \"库存修改\",\n",
      "    \"销售记录建立\",\n",
      "    \"发货票开发\",\n",
      "    \"采购子系统控制流程\",\n",
      "    \"会计子系统控制流程\",\n",
      "    \"系统的IPO图\",\n",
      "    \"主控模块的IPO图\",\n",
      "    \"系统程序结构框图\",\n",
      "    \"销售业务流程图\",\n",
      "    \"采购业务流程图\",\n",
      "    \"会计业务流程图\",\n",
      "    \"系统实施阶段\",\n",
      "    \"编写计算机程序\",\n",
      "    \"程序调试\",\n",
      "    \"系统分调\",\n",
      "    \"总调\",\n",
      "    \"新旧系统切换\",\n",
      "    \"系统评价\",\n",
      "    \"系统评价文档\",\n",
      "    \"系统操作手册\",\n",
      "    \"软件过程设计基本原理\",\n",
      "    \"模块化\",\n",
      "    \"抽象与信息隐蔽\",\n",
      "    \"模块独立性\",\n",
      "    \"软件设计工具\",\n",
      "    \"HIPO图\",\n",
      "    \"软件结构图\",\n",
      "    \"详细设计工具\",\n",
      "    \"设计方法\",\n",
      "    \"变换分析设计\",\n",
      "    \"事务分析设计\",\n",
      "    \"综合数据流图映射\",\n",
      "    \"分层数据流图映射\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"案例分析——百货商店业务管理信息系统过程建模\", \"属于\", \"第5章案例分析\"],\n",
      "    [\"自顶向下的模块化程序设计\", \"属于\", \"软件开发工程化方法\"],\n",
      "    [\"模块独立性原则\", \"属于\", \"自顶向下的模块化程序设计\"],\n",
      "    [\"模块大小划分原则\", \"属于\", \"自顶向下的模块化程序设计\"],\n",
      "    [\"模块功能简单原则\", \"属于\", \"自顶向下的模块化程序设计\"],\n",
      "    [\"共享功能模块集中原则\", \"属于\", \"自顶向下的模块化程序设计\"],\n",
      "    [\"销售子系统\", \"属于\", \"百货商店业务管理信息系统过程建模\"],\n",
      "    [\"采购子系统\", \"属于\", \"百货商店业务管理信息系统过程建模\"],\n",
      "    [\"会计子系统\", \"属于\", \"百货商店业务管理信息系统过程建模\"],\n",
      "    [\"功能模块结构\", \"属于\", \"百货商店业务管理信息系统过程建模\"],\n",
      "    [\"订单处理流程\", \"属于\", \"销售子系统\"],\n",
      "    [\"编辑功能模块\", \"属于\", \"销售子系统\"],\n",
      "    [\"检验核对功能模块\", \"属于\", \"销售子系统\"],\n",
      "    [\"分类处理功能模块\", \"属于\", \"销售子系统\"],\n",
      "    [\"采购子系统控制流程\", \"属于\", \"百货商店业务管理信息系统过程建模\"],\n",
      "    [\"会计子系统控制流程\", \"属于\", \"百货商店业务管理信息系统过程建模\"],\n",
      "    [\"系统的IPO图\", \"属于\", \"百货商店业务管理信息系统过程建模\"],\n",
      "    [\"主控模块的IPO图\", \"属于\", \"系统的IPO图\"],\n",
      "    [\"系统程序结构框图\", \"属于\", \"百货商店业务管理信息系统过程建模\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "2334\n",
      "sleep:37.995784727244185秒\n",
      "————————————第52章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"本章小结\",\n",
      "    \"软件过程设计\",\n",
      "    \"基本原理\",\n",
      "    \"模块化\",\n",
      "    \"抽象与信息隐蔽\",\n",
      "    \"模块的独立性\",\n",
      "    \"软件设计工具\",\n",
      "    \"HIPO 图\",\n",
      "    \"软件结构图\",\n",
      "    \"详细设计工具\",\n",
      "    \"设计方法\",\n",
      "    \"变换分析设计\",\n",
      "    \"事务分析设计\",\n",
      "    \"综合数据流图的映射\",\n",
      "    \"分层数据流图的映射\",\n",
      "    \"系统实施\",\n",
      "    \"程序调试\",\n",
      "    \"系统分调\",\n",
      "    \"总调\",\n",
      "    \"新旧系统的切换\",\n",
      "    \"系统评价\",\n",
      "    \"系统评价文档\",\n",
      "    \"系统操作手册\",\n",
      "    \"数据库设计\",\n",
      "    \"学习目标\",\n",
      "    \"逻辑模型与物理模型的区别\",\n",
      "    \"逻辑模型转换成物理模型的规则\",\n",
      "    \"E-R 图转换为关系\",\n",
      "    \"合并冗余的关系\",\n",
      "    \"为关系设计字段\",\n",
      "    \"选择合适的数据类型\",\n",
      "    \"保证数据完整性的要求\",\n",
      "    \"代码含义及其作用\",\n",
      "    \"数据库物理设计\",\n",
      "    \"逻辑数据库模型\",\n",
      "    \"关系数据库模型\",\n",
      "    \"物理数据特征\",\n",
      "    \"系统界面的使用频率\",\n",
      "    \"数据库技术性能\",\n",
      "    \"输入输出设计\",\n",
      "    \"数据库建模和设计活动\",\n",
      "    \"系统开发过程\",\n",
      "    \"系统规划阶段\",\n",
      "    \"企业范围的数据模型\",\n",
      "    \"概念数据模型\",\n",
      "    \"实体\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"本章小结\", \"属于\", \"第8章\"],\n",
      "    [\"软件过程设计的基本原理\", \"属于\", \"软件过程设计\"],\n",
      "    [\"模块化\", \"属于\", \"软件过程设计的基本原理\"],\n",
      "    [\"抽象与信息隐蔽\", \"属于\", \"软件过程设计的基本原理\"],\n",
      "    [\"模块的独立性\", \"属于\", \"软件过程设计的基本原理\"],\n",
      "    [\"软件设计工具\", \"属于\", \"软件过程设计\"],\n",
      "    [\"HIPO 图\", \"属于\", \"软件设计工具\"],\n",
      "    [\"软件结构图\", \"属于\", \"软件设计工具\"],\n",
      "    [\"详细设计工具\", \"属于\", \"软件设计工具\"],\n",
      "    [\"设计方法\", \"属于\", \"软件过程设计\"],\n",
      "    [\"变换分析设计\", \"属于\", \"设计方法\"],\n",
      "    [\"事务分析设计\", \"属于\", \"设计方法\"],\n",
      "    [\"综合数据流图的映射\", \"属于\", \"设计方法\"],\n",
      "    [\"分层数据流图的映射\", \"属于\", \"设计方法\"],\n",
      "    [\"逻辑模型与物理模型的区别\", \"属于\", \"数据库设计的学习目标\"],\n",
      "    [\"逻辑模型转换成物理模型的规则\", \"属于\", \"数据库设计的学习目标\"],\n",
      "    [\"E-R 图转换为关系\", \"属于\", \"数据库设计的学习目标\"],\n",
      "    [\"合并冗余的关系\", \"属于\", \"数据库设计的学习目标\"],\n",
      "    [\"为关系设计字段\", \"属于\", \"数据库设计的学习目标\"],\n",
      "    [\"选择合适的数据类型\", \"属于\", \"数据库设计的学习目标\"],\n",
      "    [\"保证数据完整性的要求\", \"属于\", \"数据库设计的学习目标\"],\n",
      "    [\"数据库物理设计\", \"属于\", \"数据库设计\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "1889\n",
      "sleep:37.865435913429046秒\n",
      "————————————第53章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"逻辑模型\",\n",
      "    \"物理模型\",\n",
      "    \"数据库设计步骤\",\n",
      "    \"逻辑数据库模型\",\n",
      "    \"关系数据库模型\",\n",
      "    \"规范化方法\",\n",
      "    \"物理字段设计\",\n",
      "    \"数据量规划\",\n",
      "    \"实体的转换规则\",\n",
      "    \"标识主码\",\n",
      "    \"副码实现为索引\",\n",
      "    \"子集准则的非主属性建立索引\",\n",
      "    \"外键识别\",\n",
      "    \"属性的转换规则\",\n",
      "    \"字段实现\",\n",
      "    \"数据类型\",\n",
      "    \"字段大小\",\n",
      "    \"空或非空特性\",\n",
      "    \"域\",\n",
      "    \"默认值\",\n",
      "    \"关系特征\",\n",
      "    \"单元中的条目\",\n",
      "    \"列中的条目集合\",\n",
      "    \"唯一性\",\n",
      "    \"列顺序可交换\",\n",
      "    \"行顺序可任意\",\n",
      "    \"结构良好的关系\",\n",
      "    \"最小冗余度\",\n",
      "    \"允许插入、修改和删除行\",\n",
      "    \"冗余关系\",\n",
      "    \"主码\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"逻辑模型\", \"属于\", \"数据库设计\"],\n",
      "    [\"物理模型\", \"属于\", \"数据库设计\"],\n",
      "    [\"逻辑数据库模型\", \"属于\", \"逻辑模型\"],\n",
      "    [\"关系数据库模型\", \"属于\", \"物理模型\"],\n",
      "    [\"规范化方法\", \"用于\", \"逻辑数据库设计\"],\n",
      "    [\"物理字段设计\", \"属于\", \"物理模型设计\"],\n",
      "    [\"数据量规划\", \"属于\", \"物理模型设计\"],\n",
      "    [\"实体的转换规则\", \"应用于\", \"逻辑到物理模型转换\"],\n",
      "    [\"标识主码\", \"属于\", \"实体的转换规则\"],\n",
      "    [\"副码实现为索引\", \"属于\", \"实体的转换规则\"],\n",
      "    [\"子集准则的非主属性建立索引\", \"属于\", \"实体的转换规则\"],\n",
      "    [\"外键识别\", \"属于\", \"实体的转换规则\"],\n",
      "    [\"属性的转换规则\", \"应用于\", \"逻辑到物理模型转换\"],\n",
      "    [\"字段实现\", \"属于\", \"属性的转换规则\"],\n",
      "    [\"数据类型\", \"在\", \"属性的转换规则中考虑\"],\n",
      "    [\"字段大小\", \"在\", \"属性的转换规则中考虑\"],\n",
      "    [\"空或非空特性\", \"在\", \"属性的转换规则中考虑\"],\n",
      "    [\"域\", \"在\", \"属性的转换规则中考虑\"],\n",
      "    [\"默认值\", \"在\", \"属性的转换规则中考虑\"],\n",
      "    [\"关系特征\", \"描述\", \"关系数据库模型\"],\n",
      "    [\"最小冗余度\", \"是\", \"结构良好关系的要求\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "2973\n",
      "sleep:37.86980951624745秒\n",
      "————————————第54章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"关系数据库模型\",\n",
      "    \"数据库模型\",\n",
      "    \"层次和网络模型\",\n",
      "    \"面向对象的数据库模型\",\n",
      "    \"关系\",\n",
      "    \"二维数据表\",\n",
      "    \"属性\",\n",
      "    \"记录\",\n",
      "    \"员工表（1）\",\n",
      "    \"标识符属性\",\n",
      "    \"主码\",\n",
      "    \"非空的主码值\",\n",
      "    \"冗余度\",\n",
      "    \"结构良好的关系\",\n",
      "    \"最小冗余度\",\n",
      "    \"用户插入、修改和删除行\",\n",
      "    \"错误或不一致性\",\n",
      "    \"员工 2\",\n",
      "    \"冗余关系的表\",\n",
      "    \"规范化技术\",\n",
      "    \"复杂数据结构\",\n",
      "    \"简单、稳定数据结构\",\n",
      "    \"规范化方法\",\n",
      "    \"员工—课程关系\",\n",
      "    \"EMP 课程关系\",\n",
      "    \"E-R 图转化成关系\",\n",
      "    \"规范化的关系\",\n",
      "    \"人机界面设计\",\n",
      "    \"输入和输出的数据\",\n",
      "    \"概念数据模型\",\n",
      "    \"E-R 或类图\",\n",
      "    \"未来新增系统应用模块\",\n",
      "    \"新数据需求\",\n",
      "    \"实体\",\n",
      "    \"实体类型\",\n",
      "    \"关系转化步骤\",\n",
      "    \"表示实体\",\n",
      "    \"表示关系\",\n",
      "    \"规范化关系\",\n",
      "    \"合并关系\",\n",
      "    \"实体转换\",\n",
      "    \"常规实体类型\",\n",
      "    \"主码检验\",\n",
      "    \"唯一性\",\n",
      "    \"无冗余\",\n",
      "    \"冗余关系\",\n",
      "    \"员工家属实体\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"关系数据库模型\", \"属于\", \"数据库模型\"],\n",
      "    [\"层次和网络模型\", \"属于\", \"数据库模型\"],\n",
      "    [\"面向对象的数据库模型\", \"属于\", \"数据库模型\"],\n",
      "    [\"关系\", \"属于\", \"关系数据库模型\"],\n",
      "    [\"二维数据表\", \"属于\", \"关系\"],\n",
      "    [\"属性\", \"属于\", \"关系\"],\n",
      "    [\"记录\", \"属于\", \"关系\"],\n",
      "    [\"员工表（1）\", \"属于\", \"关系示例\"],\n",
      "    [\"标识符属性\", \"属于\", \"关系\"],\n",
      "    [\"主码\", \"属于\", \"关系\"],\n",
      "    [\"非空的主码值\", \"用于\", \"确定关系中的每一行\"],\n",
      "    [\"结构良好的关系\", \"具有\", \"最小冗余度\"],\n",
      "    [\"结构良好的关系\", \"允许\", \"用户插入、修改和删除行而不出现错误或不一致性\"],\n",
      "    [\"员工 2\", \"属于\", \"冗余关系示例\"],\n",
      "    [\"规范化技术\", \"应用于\", \"复杂数据结构到简单、稳定数据结构的转化\"],\n",
      "    [\"规范化方法\", \"用于\", \"解决员工 2 表的冗余问题\"],\n",
      "    [\"员工—课程关系\", \"由\", \"规范化方法产生\"],\n",
      "    [\"E-R 图转化成关系\", \"过程包括\", \"表示实体、表示关系、规范化关系和合并关系\"],\n",
      "    [\"规范化的关系\", \"结合\", \"已经存在的规范化关系\"],\n",
      "    [\"人机界面设计\", \"使用\", \"规范化关系作为输入和输出数据的基础\"],\n",
      "    [\"概念数据模型\", \"包含\", \"E-R 或类图\"],\n",
      "    [\"E-R 或类图\", \"用于识别\", \"未来新增系统应用模块的新数据需求\"],\n",
      "    [\"实体\", \"在 E-R 图中转换为\", \"关系\"],\n",
      "    [\"实体类型\", \"对应于\", \"关系\"],\n",
      "    [\"主码检验\", \"确保\", \"主码的唯一性和无冗余性\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "2744\n",
      "sleep:37.44977907907673秒\n",
      "————————————第55章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"将E-R图转化成关系\",\n",
      "    \"规范化技术\",\n",
      "    \"实体转换\",\n",
      "    \"关系转换\",\n",
      "    \"弱实体\",\n",
      "    \"主码\",\n",
      "    \"非主码属性\",\n",
      "    \"1：N关系转换方法\",\n",
      "    \"M：N关系转换方法\",\n",
      "    \"一元关系转换\",\n",
      "    \"递归外码\",\n",
      "    \"物料清单结构\",\n",
      "    \"关系合并\",\n",
      "    \"同义属性\",\n",
      "    \"异义属性\",\n",
      "    \"非主码间的依赖\",\n",
      "    \"类/子类关系\",\n",
      "    \"字段设计\",\n",
      "    \"数据类型选择\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"规范化技术\", \"应用于\", \"将E-R图转化成关系\"],\n",
      "    [\"实体转换\", \"属于\", \"将E-R图转化成关系\"],\n",
      "    [\"关系转换\", \"属于\", \"将E-R图转化成关系\"],\n",
      "    [\"弱实体\", \"在\", \"实体转换\"],\n",
      "    [\"主码\", \"用于\", \"实体转换和关系转换\"],\n",
      "    [\"非主码属性\", \"在\", \"实体转换\"],\n",
      "    [\"1：N关系转换方法\", \"是\", \"关系转换的一部分\"],\n",
      "    [\"M：N关系转换方法\", \"是\", \"关系转换的一部分\"],\n",
      "    [\"一元关系转换\", \"属于\", \"关系转换\"],\n",
      "    [\"递归外码\", \"在\", \"一元关系转换\"],\n",
      "    [\"物料清单结构\", \"通过\", \"M：N关系转换\"],\n",
      "    [\"关系合并\", \"是\", \"将E-R图转化成关系的后续步骤\"],\n",
      "    [\"同义属性\", \"处理方式\", \"关系合并\"],\n",
      "    [\"异义属性\", \"处理方式\", \"关系合并\"],\n",
      "    [\"非主码间的依赖\", \"可能导致的问题\", \"关系合并\"],\n",
      "    [\"类/子类关系\", \"处理方式\", \"关系合并\"],\n",
      "    [\"字段设计\", \"属于\", \"将E-R图转化成关系后的数据库设计阶段\"],\n",
      "    [\"数据类型选择\", \"在\", \"字段设计\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "5015\n",
      "sleep:38.08342422708604秒\n",
      "————————————第56章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"设计字段\",\n",
      "    \"字段\",\n",
      "    \"数据类型\",\n",
      "    \"最小化存储空间\",\n",
      "    \"表示所有可能的值\",\n",
      "    \"数据完整性\",\n",
      "    \"支持数据操作\",\n",
      "    \"Oracle 9i 数据类型\",\n",
      "    \"VARCHAR2\",\n",
      "    \"CHAR\",\n",
      "    \"LONG\",\n",
      "    \"NUMBER\",\n",
      "    \"日期（DATE）\",\n",
      "    \"二进制大对象（BLOB）\",\n",
      "    \"运算字段\",\n",
      "    \"派生字段\",\n",
      "    \"编码与压缩技术\",\n",
      "    \"数据完整性控制\",\n",
      "    \"缺省值\",\n",
      "    \"范围控制\",\n",
      "    \"参照完整性\",\n",
      "    \"空值控制\",\n",
      "    \"文件的控制策略\",\n",
      "    \"文件备份\",\n",
      "    \"安全性\",\n",
      "    \"编码或加密\",\n",
      "    \"用户验证\",\n",
      "    \"访问权限控制\",\n",
      "    \"数据拷贝与核对\",\n",
      "    \"代码设计\",\n",
      "    \"代码作用\",\n",
      "    \"唯一化\",\n",
      "    \"规范化\",\n",
      "    \"系统化\",\n",
      "    \"代码设计原则\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"字段\", \"属于\", \"设计字段\"],\n",
      "    [\"数据类型\", \"属于\", \"字段\"],\n",
      "    [\"最小化存储空间\", \"属于\", \"选择数据类型目标\"],\n",
      "    [\"表示所有可能的值\", \"属于\", \"选择数据类型目标\"],\n",
      "    [\"数据完整性\", \"属于\", \"选择数据类型目标\"],\n",
      "    [\"支持数据操作\", \"属于\", \"选择数据类型目标\"],\n",
      "    [\"VARCHAR2\", \"属于\", \"Oracle 9i 数据类型\"],\n",
      "    [\"CHAR\", \"属于\", \"Oracle 9i 数据类型\"],\n",
      "    [\"LONG\", \"属于\", \"Oracle 9i 数据类型\"],\n",
      "    [\"NUMBER\", \"属于\", \"Oracle 9i 数据类型\"],\n",
      "    [\"日期（DATE）\", \"属于\", \"Oracle 9i 数据类型\"],\n",
      "    [\"二进制大对象（BLOB）\", \"属于\", \"Oracle 9i 数据类型\"],\n",
      "    [\"运算字段\", \"属于\", \"字段\"],\n",
      "    [\"派生字段\", \"等同于\", \"运算字段\"],\n",
      "    [\"编码与压缩技术\", \"属于\", \"字段优化方法\"],\n",
      "    [\"数据完整性控制\", \"属于\", \"设计文件的控制策略\"],\n",
      "    [\"缺省值\", \"属于\", \"数据完整性控制方法\"],\n",
      "    [\"范围控制\", \"属于\", \"数据完整性控制方法\"],\n",
      "    [\"参照完整性\", \"属于\", \"数据完整性控制方法\"],\n",
      "    [\"空值控制\", \"属于\", \"数据完整性控制方法\"],\n",
      "    [\"文件备份\", \"属于\", \"文件的控制策略\"],\n",
      "    [\"安全性\", \"属于\", \"文件的控制策略\"],\n",
      "    [\"编码或加密\", \"属于\", \"安全性措施\"],\n",
      "    [\"用户验证\", \"属于\", \"安全性措施\"],\n",
      "    [\"访问权限控制\", \"属于\", \"安全性措施\"],\n",
      "    [\"数据拷贝与核对\", \"属于\", \"安全性措施\"],\n",
      "    [\"代码设计\", \"属于\", \"系统设计内容\"],\n",
      "    [\"唯一化\", \"属于\", \"代码作用\"],\n",
      "    [\"规范化\", \"属于\", \"代码作用\"],\n",
      "    [\"系统化\", \"属于\", \"代码作用\"],\n",
      "    [\"代码设计原则\", \"用于\", \"代码设计\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "4064\n",
      "sleep:37.7756813820745秒\n",
      "————————————第57章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"代码设计\",\n",
      "    \"数据安全性措施\",\n",
      "    \"唯一化\",\n",
      "    \"规范化\",\n",
      "    \"系统化\",\n",
      "    \"代码种类\",\n",
      "    \"顺序码\",\n",
      "    \"数字码\",\n",
      "    \"区间码\",\n",
      "    \"层次码\",\n",
      "    \"字符码\",\n",
      "    \"混合码\",\n",
      "    \"代码设计方法\",\n",
      "    \"线分类方法\",\n",
      "    \"面分类方法\",\n",
      "    \"线分类法特点\",\n",
      "    \"面分类法特点\",\n",
      "    \"代码校验\",\n",
      "    \"识别错误\",\n",
      "    \"易位错误\",\n",
      "    \"双易位错误\",\n",
      "    \"随机错误\",\n",
      "    \"校验位\",\n",
      "    \"输出设计目的\",\n",
      "    \"输出设计原则\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"唯一化\", \"属于\", \"代码设计\"],\n",
      "    [\"规范化\", \"属于\", \"代码设计\"],\n",
      "    [\"系统化\", \"属于\", \"代码设计\"],\n",
      "    [\"代码种类\", \"属于\", \"代码设计\"],\n",
      "    [\"顺序码\", \"属于\", \"代码种类\"],\n",
      "    [\"数字码\", \"属于\", \"代码种类\"],\n",
      "    [\"区间码\", \"属于\", \"数字码\"],\n",
      "    [\"层次码\", \"属于\", \"数字码\"],\n",
      "    [\"字符码\", \"属于\", \"代码种类\"],\n",
      "    [\"混合码\", \"属于\", \"代码种类\"],\n",
      "    [\"代码设计方法\", \"属于\", \"代码设计\"],\n",
      "    [\"线分类方法\", \"属于\", \"代码设计方法\"],\n",
      "    [\"面分类方法\", \"属于\", \"代码设计方法\"],\n",
      "    [\"线分类法特点\", \"属于\", \"线分类方法\"],\n",
      "    [\"面分类法特点\", \"属于\", \"面分类方法\"],\n",
      "    [\"代码校验\", \"属于\", \"代码设计\"],\n",
      "    [\"输出设计目的\", \"属于\", \"输出设计\"],\n",
      "    [\"输出设计原则\", \"属于\", \"输出设计\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "4599\n",
      "sleep:38.11577528205375秒\n",
      "————————————第58章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"输出设计\",\n",
      "    \"输出目的\",\n",
      "    \"中间输出\",\n",
      "    \"最终输出\",\n",
      "    \"输出设计原则1：易于阅读和理解\",\n",
      "    \"标题\",\n",
      "    \"日期和时间戳\",\n",
      "    \"节和标题\",\n",
      "    \"表格字段标签\",\n",
      "    \"缩写形式及图例\",\n",
      "    \"只打印或显示需要的信息\",\n",
      "    \"信息分布与边缘空格\",\n",
      "    \"导航和查找方便性\",\n",
      "    \"避免计算机行话和错误消息\",\n",
      "    \"按时提供输出\",\n",
      "    \"制作对用户有意义的输出\",\n",
      "    \"选择有效的输出方法\",\n",
      "    \"屏幕显示输出\",\n",
      "    \"打印机打印输出\",\n",
      "    \"文件输出\",\n",
      "    \"绘图输出\",\n",
      "    \"输出方式选择\",\n",
      "    \"屏幕显示输出特点\",\n",
      "    \"打印机打印输出特点\",\n",
      "    \"报表生成器设计\",\n",
      "    \"图形方式\",\n",
      "    \"报表生成器原理\",\n",
      "    \"图形格式输出\",\n",
      "    \"图形在决策支持中的优势\",\n",
      "    \"Excel在图形生成中的应用\",\n",
      "    \"图标表示\",\n",
      "    \"输出内容和格式的一致性\",\n",
      "    \"输出设计过程\",\n",
      "    \"确定系统输出需求\",\n",
      "    \"输出方式设计和设备选择\",\n",
      "    \"输出格式设计\",\n",
      "    \"设计、验证并测试输出\",\n",
      "    \"输出设计说明\",\n",
      "    \"输出设计说明书的内容\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"输出设计\", \"包含\", \"输出目的\"],\n",
      "    [\"输出设计\", \"包含\", \"中间输出\"],\n",
      "    [\"输出设计\", \"包含\", \"最终输出\"],\n",
      "    [\"输出设计\", \"包含\", \"输出设计原则1：易于阅读和理解\"],\n",
      "    [\"输出设计原则1：易于阅读和理解\", \"包含\", \"标题\"],\n",
      "    [\"输出设计原则1：易于阅读和理解\", \"包含\", \"日期和时间戳\"],\n",
      "    [\"输出设计原则1：易于阅读和理解\", \"包含\", \"节和标题\"],\n",
      "    [\"输出设计原则1：易于阅读和理解\", \"包含\", \"表格字段标签\"],\n",
      "    [\"输出设计原则1：易于阅读和理解\", \"包含\", \"缩写形式及图例\"],\n",
      "    [\"输出设计原则1：易于阅读和理解\", \"包含\", \"只打印或显示需要的信息\"],\n",
      "    [\"输出设计原则1：易于阅读和理解\", \"包含\", \"信息分布与边缘空格\"],\n",
      "    [\"输出设计原则1：易于阅读和理解\", \"包含\", \"导航和查找方便性\"],\n",
      "    [\"输出设计原则1：易于阅读和理解\", \"包含\", \"避免计算机行话和错误消息\"],\n",
      "    [\"输出设计\", \"包含\", \"按时提供输出\"],\n",
      "    [\"输出设计\", \"包含\", \"制作对用户有意义的输出\"],\n",
      "    [\"输出设计\", \"包含\", \"选择有效的输出方法\"],\n",
      "    [\"输出设计\", \"包含\", \"输出方式选择\"],\n",
      "    [\"输出方式选择\", \"包含\", \"屏幕显示输出\"],\n",
      "    [\"输出方式选择\", \"包含\", \"打印机打印输出\"],\n",
      "    [\"输出方式选择\", \"包含\", \"文件输出\"],\n",
      "    [\"输出方式选择\", \"包含\", \"绘图输出\"],\n",
      "    [\"输出设计\", \"包含\", \"报表生成器设计\"],\n",
      "    [\"输出设计\", \"包含\", \"图形方式\"],\n",
      "    [\"报表生成器设计\", \"属于\", \"输出设计\"],\n",
      "    [\"图形格式输出\", \"属于\", \"输出设计\"],\n",
      "    [\"输出设计过程\", \"属于\", \"输出设计\"],\n",
      "    [\"输出设计说明\", \"属于\", \"输出设计\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "3604\n",
      "sleep:37.93089033950152秒\n",
      "————————————第59章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"输出设计说明书\",\n",
      "    \"输出类型\",\n",
      "    \"内容\",\n",
      "    \"表格\",\n",
      "    \"介质和设备\",\n",
      "    \"输出信息使用情况\",\n",
      "    \"使用者\",\n",
      "    \"使用目的\",\n",
      "    \"信息量\",\n",
      "    \"输出周期\",\n",
      "    \"有效期\",\n",
      "    \"保管方法\",\n",
      "    \"输出份数\",\n",
      "    \"安全保密性要求\",\n",
      "    \"输出信息内容\",\n",
      "    \"数据结构\",\n",
      "    \"信息形式\",\n",
      "    \"数据类型\",\n",
      "    \"精度\",\n",
      "    \"取值范围\",\n",
      "    \"输出格式\",\n",
      "    \"表格、报告、图形\",\n",
      "    \"输出设备和介质\",\n",
      "    \"打印机、显示器\",\n",
      "    \"磁盘、磁带、纸张\",\n",
      "    \"输入设计\",\n",
      "    \"输入设计目的\",\n",
      "    \"正确性\",\n",
      "    \"快速、高效\",\n",
      "    \"输入数据原则\",\n",
      "    \"控制输入量\",\n",
      "    \"减少输入延迟\",\n",
      "    \"避免额外步骤\",\n",
      "    \"简化输入过程\",\n",
      "    \"减少输入错误\",\n",
      "    \"输入校验方法\",\n",
      "    \"有效性验证技术\",\n",
      "    \"输入方式选择\",\n",
      "    \"键盘输入\",\n",
      "    \"数模转换设备\",\n",
      "    \"网络通信输入设备\",\n",
      "    \"磁盘、光盘输入设备\",\n",
      "    \"输入方式的设计\",\n",
      "    \"输入设备选择\",\n",
      "    \"原始凭证格式设计\",\n",
      "    \"数据排列\",\n",
      "    \"归档\",\n",
      "    \"输入精度\",\n",
      "    \"智能输入方式\",\n",
      "    \"输入介质记录格式设计\",\n",
      "    \"方便人员录入\",\n",
      "    \"减少操作错误\",\n",
      "    \"输入控制与校验\",\n",
      "    \"类或构成测试\",\n",
      "    \"组合测试\",\n",
      "    \"期望值测试\",\n",
      "    \"缺失数据检查\",\n",
      "    \"图片/模版测试\",\n",
      "    \"范围测试\",\n",
      "    \"合理性测试\",\n",
      "    \"校验位\",\n",
      "    \"尺寸测试\",\n",
      "    \"取值测试\",\n",
      "    \"重复校验\",\n",
      "    \"人工校验\",\n",
      "    \"校验位校验\",\n",
      "    \"控制总数校验\",\n",
      "    \"数据类型校验\",\n",
      "    \"格式校验\",\n",
      "    \"逻辑校验\",\n",
      "    \"界限校验\",\n",
      "    \"记录计数校验\",\n",
      "    \"平衡校验\",\n",
      "    \"匹配校验\",\n",
      "    \"顺序校验\",\n",
      "    \"输入设计过程\",\n",
      "    \"输入数据内容的确定\",\n",
      "    \"输入方式和设备选择\",\n",
      "    \"输入数据的格式设计\",\n",
      "    \"输入数据的正确性校验\",\n",
      "    \"原型化工具\",\n",
      "    \"用户界面设计\",\n",
      "    \"显示风格\",\n",
      "    \"用户操作方式\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"输出设计说明书\", \"属于\", \"输出设计\"],\n",
      "    [\"输出信息使用情况\", \"属于\", \"输出设计说明书\"],\n",
      "    [\"输出信息内容\", \"属于\", \"输出设计说明书\"],\n",
      "    [\"输出格式\", \"属于\", \"输出设计说明书\"],\n",
      "    [\"输出设备和介质\", \"属于\", \"输出设计说明书\"],\n",
      "    [\"输入设计\", \"属于\", \"整体设计\"],\n",
      "    [\"输入设计目的\", \"属于\", \"输入设计\"],\n",
      "    [\"输入数据原则\", \"属于\", \"输入设计\"],\n",
      "    [\"输入方式选择\", \"属于\", \"输入设计\"],\n",
      "    [\"原始凭证格式设计\", \"属于\", \"输入设计\"],\n",
      "    [\"输入介质记录格式设计\", \"属于\", \"输入设计\"],\n",
      "    [\"输入控制与校验\", \"属于\", \"输入设计\"],\n",
      "    [\"输入设计过程\", \"属于\", \"输入设计\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "请注意，由于文本过长且涉及到的知识点众多，我仅提取了部分关键知识点及其归属关系。\n",
      "7585\n",
      "Error decoding JSON: Extra data: line 106 column 1 (char 1569)\n",
      "sleep:37.78662202200138秒\n",
      "————————————第60章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"用户界面设计\",\n",
      "    \"输入设备\",\n",
      "    \"条形码扫描设备\",\n",
      "    \"触摸屏\",\n",
      "    \"输入数据的格式设计\",\n",
      "    \"原始凭证格式设计\",\n",
      "    \"输入介质的格式设计\",\n",
      "    \"输入数据的正确性校验\",\n",
      "    \"常见校验方法\",\n",
      "    \"原型化工具\",\n",
      "    \"显示风格\",\n",
      "    \"用户操作方式\",\n",
      "    \"人机交互\",\n",
      "    \"认知心理学\",\n",
      "    \"界面工程学\",\n",
      "    \"语言学\",\n",
      "    \"可交互性原则\",\n",
      "    \"用户针对性原则\",\n",
      "    \"多种交互方式\",\n",
      "    \"反馈\",\n",
      "    \"状态信息\",\n",
      "    \"弹出提示信息\",\n",
      "    \"错误或警告信息\",\n",
      "    \"帮助功能\",\n",
      "    \"错误处理功能\",\n",
      "    \"信息显示原则\",\n",
      "    \"用户界面一致性\",\n",
      "    \"上下文相关的信息\",\n",
      "    \"窗口分割\",\n",
      "    \"提示信息\",\n",
      "    \"应用程序与界面相分离\",\n",
      "    \"图形用户界面(Graphic User Interface, GUI)\",\n",
      "    \"命令按钮\",\n",
      "    \"单选按钮\",\n",
      "    \"复选框\",\n",
      "    \"文本框\",\n",
      "    \"列表框\",\n",
      "    \"下拉式列表\",\n",
      "    \"组合框\",\n",
      "    \"滚动框\",\n",
      "    \"下拉式日历\",\n",
      "    \"滑动编辑日历\",\n",
      "    \"屏蔽编辑控件\",\n",
      "    \"省略控件\",\n",
      "    \"数字旋转器\",\n",
      "    \"组合复选框\",\n",
      "    \"树形复选框\",\n",
      "    \"控件布局\",\n",
      "    \"交互方式\",\n",
      "    \"指令语言交互\",\n",
      "    \"菜单交互\",\n",
      "    \"表单交互\",\n",
      "    \"基于对象的交互\",\n",
      "    \"自然语言交互\",\n",
      "    \"设计用户界面步骤\",\n",
      "    \"对话设计\",\n",
      "    \"对话图\",\n",
      "    \"用户界面原型\",\n",
      "    \"用户反馈\",\n",
      "    \"迭代修改\",\n",
      "    \"用户界面设计说明书\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"输入设备\", \"属于\", \"用户界面设计\"],\n",
      "    [\"条形码扫描设备\", \"属于\", \"输入设备\"],\n",
      "    [\"触摸屏\", \"属于\", \"输入设备\"],\n",
      "    [\"输入数据的格式设计\", \"属于\", \"用户界面设计\"],\n",
      "    [\"原始凭证格式设计\", \"属于\", \"输入数据的格式设计\"],\n",
      "    [\"输入介质的格式设计\", \"属于\", \"输入数据的格式设计\"],\n",
      "    [\"输入数据的正确性校验\", \"属于\", \"用户界面设计\"],\n",
      "    [\"原型化工具\", \"属于\", \"用户界面设计\"],\n",
      "    [\"显示风格\", \"属于\", \"用户界面设计\"],\n",
      "    [\"用户操作方式\", \"属于\", \"用户界面设计\"],\n",
      "    [\"可交互性原则\", \"属于\", \"用户界面设计\"],\n",
      "    [\"用户针对性原则\", \"属于\", \"可交互性原则\"],\n",
      "    [\"多种交互方式\", \"属于\", \"可交互性原则\"],\n",
      "    [\"反馈\", \"属于\", \"可交互性原则\"],\n",
      "    [\"状态信息\", \"属于\", \"反馈\"],\n",
      "    [\"弹出提示信息\", \"属于\", \"反馈\"],\n",
      "    [\"错误或警告信息\", \"属于\", \"反馈\"],\n",
      "    [\"帮助功能\", \"属于\", \"用户界面设计\"],\n",
      "    [\"错误处理功能\", \"属于\", \"用户界面设计\"],\n",
      "    [\"信息显示原则\", \"属于\", \"用户界面设计\"],\n",
      "    [\"用户界面一致性\", \"属于\", \"信息显示原则\"],\n",
      "    [\"上下文相关的信息\", \"属于\", \"信息显示原则\"],\n",
      "    [\"窗口分割\", \"属于\", \"信息显示原则\"],\n",
      "    [\"提示信息\", \"属于\", \"信息显示原则\"],\n",
      "    [\"应用程序与界面相分离\", \"属于\", \"用户界面设计\"],\n",
      "    [\"图形用户界面(Graphic User Interface, GUI)\", \"属于\", \"用户界面设计\"],\n",
      "    [\"命令按钮\", \"属于\", \"GUI 控件\"],\n",
      "    [\"单选按钮\", \"属于\", \"GUI 控件\"],\n",
      "    [\"复选框\", \"属于\", \"GUI 控件\"],\n",
      "    [\"文本框\", \"属于\", \"GUI 控件\"],\n",
      "    [\"列表框\", \"属于\", \"GUI 控件\"],\n",
      "    [\"下拉式列表\", \"属于\", \"GUI 控件\"],\n",
      "    [\"组合框\", \"属于\", \"GUI 控件\"],\n",
      "    [\"滚动框\", \"属于\", \"GUI 控件\"],\n",
      "    [\"交互方式\", \"属于\", \"用户界面设计\"],\n",
      "    [\"指令语言交互\", \"属于\", \"交互方式\"],\n",
      "    [\"菜单交互\", \"属于\", \"交互方式\"],\n",
      "    [\"表单交互\", \"属于\", \"交互方式\"],\n",
      "    [\"基于对象的交互\", \"属于\", \"交互方式\"],\n",
      "    [\"自然语言交互\", \"属于\", \"交互方式\"],\n",
      "    [\"设计用户界面步骤\", \"属于\", \"用户界面设计\"],\n",
      "    [\"对话设计\", \"属于\", \"设计用户界面步骤\"],\n",
      "    [\"对话图\", \"属于\", \"对话设计\"],\n",
      "    [\"用户界面原型\", \"属于\", \"设计用户界面步骤\"],\n",
      "    [\"用户反馈\", \"属于\", \"设计用户界面步骤\"],\n",
      "    [\"迭代修改\", \"属于\", \"设计用户界面步骤\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "7943\n",
      "sleep:37.691570256642244秒\n",
      "————————————第61章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"界面/对话名称\",\n",
      "    \"用户特征\",\n",
      "    \"任务特征\",\n",
      "    \"系统特征\",\n",
      "    \"环境特征\",\n",
      "    \"表/报表设计\",\n",
      "    \"对话顺序图\",\n",
      "    \"测试对象\",\n",
      "    \"测试方法\",\n",
      "    \"学习时间\",\n",
      "    \"运行速度\",\n",
      "    \"错误频率\",\n",
      "    \"使用持续时间\",\n",
      "    \"用户满意度和其他感觉\",\n",
      "    \"界面和对话设计说明书概要\",\n",
      "    \"输入输出界面示例\",\n",
      "    \"销售管理系统\",\n",
      "    \"商品查询界面\",\n",
      "    \"商品销售界面\",\n",
      "    \"商品出库和修改界面\",\n",
      "    \"商品销售历史界面\",\n",
      "    \"商品新建界面\",\n",
      "    \"输出设计\",\n",
      "    \"设计目的\",\n",
      "    \"设计原则\",\n",
      "    \"输入和输出方式选择\",\n",
      "    \"用户界面设计\",\n",
      "    \"设计原则\",\n",
      "    \"设计元素\",\n",
      "    \"交互方式\",\n",
      "    \"设计步骤\",\n",
      "    \"用户界面设计文档准备\",\n",
      "    \"输入和输出设计文档在用户界面设计中的应用\",\n",
      "    \"电子商务网站的用户界面设计策略分析\",\n",
      "    \"设计一致性对于建立顾客忠诚和信赖的重要性\",\n",
      "    \"个性化内容网站与客户化网站内容比较\",\n",
      "    \"凭证录入效率提高的原则\",\n",
      "    \"网上商务网站界面转换图设计\",\n",
      "    \"输入内容、方法和介质的设计\",\n",
      "    \"售票系统订单信息界面设计要求\",\n",
      "    \"系统实现与运行\",\n",
      "    \"系统组件开发\",\n",
      "    \"安装与测试\",\n",
      "    \"程序编写与测试\",\n",
      "    \"软件包安装\",\n",
      "    \"数据库建立与测试\",\n",
      "    \"计算机和网络设备选择\",\n",
      "    \"网络系统组建\",\n",
      "    \"系统移交与投入正常运营\",\n",
      "    \"旧系统到新系统的平稳转换\",\n",
      "    \"编码（程序编写）\",\n",
      "    \"程序设计语言选择\",\n",
      "    \"高级程序语言特点\",\n",
      "    \"模块化机制\",\n",
      "    \"独立编译机制\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"界面/对话名称\", \"属于\", \"界面/对话设计\"],\n",
      "    [\"用户特征\", \"属于\", \"界面/对话设计\"],\n",
      "    [\"任务特征\", \"属于\", \"界面/对话设计\"],\n",
      "    [\"系统特征\", \"属于\", \"界面/对话设计\"],\n",
      "    [\"环境特征\", \"属于\", \"界面/对话设计\"],\n",
      "    [\"表/报表设计\", \"属于\", \"界面/对话设计\"],\n",
      "    [\"对话顺序图\", \"属于\", \"界面/对话设计\"],\n",
      "    [\"测试对象\", \"属于\", \"测试和可用性评估\"],\n",
      "    [\"测试方法\", \"属于\", \"测试和可用性评估\"],\n",
      "    [\"学习时间\", \"属于\", \"测试结果\"],\n",
      "    [\"运行速度\", \"属于\", \"测试结果\"],\n",
      "    [\"错误频率\", \"属于\", \"测试结果\"],\n",
      "    [\"使用持续时间\", \"属于\", \"测试结果\"],\n",
      "    [\"用户满意度和其他感觉\", \"属于\", \"测试结果\"],\n",
      "    [\"商品查询界面\", \"属于\", \"输入输出界面示例\"],\n",
      "    [\"商品销售界面\", \"属于\", \"输入输出界面示例\"],\n",
      "    [\"商品出库和修改界面\", \"属于\", \"输入输出界面示例\"],\n",
      "    [\"商品销售历史界面\", \"属于\", \"输入输出界面示例\"],\n",
      "    [\"商品新建界面\", \"属于\", \"输入输出界面示例\"],\n",
      "    [\"输出设计\", \"属于\", \"输出、输入与用户界面设计理论\"],\n",
      "    [\"设计目的\", \"属于\", \"输出设计的基本理论\"],\n",
      "    [\"设计原则\", \"属于\", \"输出设计的基本理论\"],\n",
      "    [\"输入和输出方式选择\", \"属于\", \"输出设计的基本理论\"],\n",
      "    [\"用户界面设计\", \"属于\", \"本章内容\"],\n",
      "    [\"设计原则\", \"属于\", \"用户界面设计\"],\n",
      "    [\"设计元素\", \"属于\", \"用户界面设计\"],\n",
      "    [\"交互方式\", \"属于\", \"用户界面设计\"],\n",
      "    [\"设计步骤\", \"属于\", \"用户界面设计\"],\n",
      "    [\"用户界面设计文档准备\", \"属于\", \"思考与练习\"],\n",
      "    [\"输入和输出设计文档在用户界面设计中的应用\", \"属于\", \"思考与练习\"],\n",
      "    [\"电子商务网站的用户界面设计策略分析\", \"属于\", \"思考与练习\"],\n",
      "    [\"设计一致性对于建立顾客忠诚和信赖的重要性\", \"属于\", \"思考与练习\"],\n",
      "    [\"个性化内容网站与客户化网站内容比较\", \"属于\", \"思考与练习\"],\n",
      "    [\"凭证录入效率提高的原则\", \"属于\", \"思考与练习\"],\n",
      "    [\"网上商务网站界面转换图设计\", \"属于\", \"思考与练习\"],\n",
      "    [\"输入内容、方法和介质的设计\", \"属于\", \"思考与练习\"],\n",
      "    [\"售票系统订单信息界面设计要求\", \"属于\", \"思考与练习\"],\n",
      "    [\"系统实现与运行\", \"属于\", \"第11章内容\"],\n",
      "    [\"系统组件开发\", \"属于\", \"系统实现阶段的主要工作\"],\n",
      "    [\"安装与测试\", \"属于\", \"系统实现阶段的主要工作\"],\n",
      "    [\"程序编写与测试\", \"属于\", \"软件实现\"],\n",
      "    [\"软件包安装\", \"属于\", \"软件实现\"],\n",
      "    [\"数据库建立与测试\", \"属于\", \"软件实现\"],\n",
      "    [\"计算机和网络设备选择\", \"属于\", \"系统实现阶段的主要工作\"],\n",
      "    [\"网络系统组建\", \"属于\", \"系统实现阶段的主要工作\"],\n",
      "    [\"高级程序语言特点\", \"属于\", \"软件编程\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "请注意，由于文本中并未明确给出每个知识点之间的上下位关系或从属关系，所以这里的\"edge\"字段仅基于部分显而易见的关系进行了构建。实际的知识点间关系可能更为复杂，需要更深入地理解和分析原文才能完全准确构建。\n",
      "2951\n",
      "Error decoding JSON: Extra data: line 110 column 1 (char 2469)\n",
      "sleep:37.897677485468265秒\n",
      "————————————第62章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"软件实现\",\n",
      "    \"软件编程\",\n",
      "    \"选择程序设计语言\",\n",
      "    \"高级程序语言\",\n",
      "    \"汇编语言编码\",\n",
      "    \"编码风格\",\n",
      "    \"规范化程序内部的文档\",\n",
      "    \"规范数据说明\",\n",
      "    \"规范语句构造\",\n",
      "    \"规范输入输出\",\n",
      "    \"最大化效率\",\n",
      "    \"程序运行时间\",\n",
      "    \"存储器效率\",\n",
      "    \"输入输出的效率\",\n",
      "    \"软件包安装与测试\",\n",
      "    \"软件测试\",\n",
      "    \"单元测试\",\n",
      "    \"综合测试\",\n",
      "    \"测试目标\",\n",
      "    \"软件可靠性模型\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"软件编程\", \"属于\", \"软件实现\"],\n",
      "    [\"选择程序设计语言\", \"属于\", \"软件编程\"],\n",
      "    [\"高级程序语言\", \"属于\", \"选择程序设计语言\"],\n",
      "    [\"汇编语言编码\", \"属于\", \"选择程序设计语言\"],\n",
      "    [\"编码风格\", \"属于\", \"软件编程\"],\n",
      "    [\"规范化程序内部的文档\", \"属于\", \"编码风格\"],\n",
      "    [\"规范数据说明\", \"属于\", \"编码风格\"],\n",
      "    [\"规范语句构造\", \"属于\", \"编码风格\"],\n",
      "    [\"规范输入输出\", \"属于\", \"编码风格\"],\n",
      "    [\"最大化效率\", \"属于\", \"编码风格\"],\n",
      "    [\"程序运行时间\", \"属于\", \"最大化效率\"],\n",
      "    [\"存储器效率\", \"属于\", \"最大化效率\"],\n",
      "    [\"输入输出的效率\", \"属于\", \"最大化效率\"],\n",
      "    [\"软件包安装与测试\", \"属于\", \"软件实现\"],\n",
      "    [\"软件测试\", \"属于\", \"软件实现\"],\n",
      "    [\"单元测试\", \"属于\", \"软件测试\"],\n",
      "    [\"综合测试\", \"属于\", \"软件测试\"],\n",
      "    [\"测试目标\", \"属于\", \"软件测试\"],\n",
      "    [\"软件可靠性模型\", \"属于\", \"软件测试\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "3751\n",
      "sleep:38.123566651751105秒\n",
      "————————————第63章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"软件测试\",\n",
      "    \"单元测试\",\n",
      "    \"综合测试\",\n",
      "    \"调试\",\n",
      "    \"软件可靠性模型\",\n",
      "    \"测试目标\",\n",
      "    \"G..Myers的测试规则\",\n",
      "    \"测试准则\",\n",
      "    \"用户需求追溯\",\n",
      "    \"早期制定测试计划\",\n",
      "    \"Pareto原理应用\",\n",
      "    \"从小规模到大规模测试\",\n",
      "    \"独立第三方测试\",\n",
      "    \"穷举测试不可能\",\n",
      "    \"模块测试\",\n",
      "    \"集成测试\",\n",
      "    \"非渐增式测试方法\",\n",
      "    \"渐增式测试方法\",\n",
      "    \"系统测试\",\n",
      "    \"回归测试\",\n",
      "    \"调试引起的回归测试\",\n",
      "    \"确认测试\",\n",
      "    \"验收测试\",\n",
      "    \"黑盒测试法\",\n",
      "    \"Alpha测试\",\n",
      "    \"Beta测试\",\n",
      "    \"白盒测试技术\",\n",
      "    \"逻辑覆盖\",\n",
      "    \"语句覆盖\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"单元测试\", \"属于\", \"软件测试\"],\n",
      "    [\"综合测试\", \"属于\", \"软件测试\"],\n",
      "    [\"调试\", \"属于\", \"软件测试\"],\n",
      "    [\"软件可靠性模型\", \"涉及于\", \"软件测试\"],\n",
      "    [\"测试目标\", \"是\", \"软件测试的一部分\"],\n",
      "    [\"G..Myers的测试规则\", \"指导\", \"软件测试\"],\n",
      "    [\"用户需求追溯\", \"是\", \"测试准则之一\"],\n",
      "    [\"早期制定测试计划\", \"是\", \"测试准则之一\"],\n",
      "    [\"Pareto原理应用\", \"是\", \"测试准则之一\"],\n",
      "    [\"从小规模到大规模测试\", \"是\", \"测试准则之一\"],\n",
      "    [\"独立第三方测试\", \"是\", \"测试准则之一\"],\n",
      "    [\"穷举测试不可能\", \"是\", \"测试准则认识\"],\n",
      "    [\"模块测试\", \"属于\", \"测试步骤\"],\n",
      "    [\"集成测试\", \"属于\", \"测试步骤\"],\n",
      "    [\"非渐增式测试方法\", \"是\", \"集成测试方法\"],\n",
      "    [\"渐增式测试方法\", \"是\", \"集成测试方法\"],\n",
      "    [\"系统测试\", \"属于\", \"测试步骤\"],\n",
      "    [\"回归测试\", \"属于\", \"测试步骤\"],\n",
      "    [\"调试引起的回归测试\", \"属于\", \"回归测试\"],\n",
      "    [\"确认测试\", \"也称\", \"验收测试\"],\n",
      "    [\"验收测试\", \"属于\", \"测试步骤\"],\n",
      "    [\"黑盒测试法\", \"应用于\", \"确认测试\"],\n",
      "    [\"Alpha测试\", \"是\", \"验收测试类型\"],\n",
      "    [\"Beta测试\", \"是\", \"验收测试类型\"],\n",
      "    [\"白盒测试技术\", \"是\", \"测试方法\"],\n",
      "    [\"逻辑覆盖\", \"属于\", \"白盒测试技术\"],\n",
      "    [\"语句覆盖\", \"是\", \"逻辑覆盖的一种\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "4299\n",
      "sleep:38.05879962926484秒\n",
      "————————————第64章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"白盒测试技术\",\n",
      "    \"黑盒测试\",\n",
      "    \"逻辑覆盖\",\n",
      "    \"语句覆盖\",\n",
      "    \"判定覆盖\",\n",
      "    \"条件覆盖\",\n",
      "    \"判定/条件覆盖\",\n",
      "    \"条件组合覆盖\",\n",
      "    \"控制结构测试\",\n",
      "    \"基本路径测试\",\n",
      "    \"环形复杂度\",\n",
      "    \"独立路径的基本集合\",\n",
      "    \"循环测试\",\n",
      "    \"简单循环\",\n",
      "    \"串接循环\",\n",
      "    \"嵌套循环\",\n",
      "    \"等价类划分法\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"逻辑覆盖\", \"属于\", \"白盒测试技术\"],\n",
      "    [\"语句覆盖\", \"属于\", \"逻辑覆盖\"],\n",
      "    [\"判定覆盖\", \"属于\", \"逻辑覆盖\"],\n",
      "    [\"条件覆盖\", \"属于\", \"逻辑覆盖\"],\n",
      "    [\"判定/条件覆盖\", \"属于\", \"逻辑覆盖\"],\n",
      "    [\"条件组合覆盖\", \"属于\", \"逻辑覆盖\"],\n",
      "    [\"控制结构测试\", \"属于\", \"白盒测试技术\"],\n",
      "    [\"基本路径测试\", \"属于\", \"控制结构测试\"],\n",
      "    [\"环形复杂度\", \"属于\", \"基本路径测试\"],\n",
      "    [\"独立路径的基本集合\", \"属于\", \"基本路径测试\"],\n",
      "    [\"循环测试\", \"属于\", \"白盒测试技术\"],\n",
      "    [\"简单循环\", \"属于\", \"循环测试\"],\n",
      "    [\"串接循环\", \"属于\", \"循环测试\"],\n",
      "    [\"嵌套循环\", \"属于\", \"循环测试\"],\n",
      "    [\"等价类划分法\", \"属于\", \"黑盒测试\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "4947\n",
      "sleep:37.9049303881084秒\n",
      "————————————第65章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"黑盒测试技术\",\n",
      "    \"减少测试数的方法\",\n",
      "    \"串接循环的测试\",\n",
      "    \"功能测试\",\n",
      "    \"独立性测试\",\n",
      "    \"错误类型\",\n",
      "    \"测试过程阶段\",\n",
      "    \"设计黑盒测试方案考虑的问题\",\n",
      "    \"测试用例集标准\",\n",
      "    \"等价类划分法\",\n",
      "    \"有效等价类覆盖\",\n",
      "    \"无效等价类覆盖\",\n",
      "    \"划分等价类的经验\",\n",
      "    \"边界值分析法\",\n",
      "    \"边界情况错误高发\",\n",
      "    \"测试数据选取原则\",\n",
      "    \"联合使用等价划分和边界值分析\",\n",
      "    \"判定表/判定树\",\n",
      "    \"输入组合测试\",\n",
      "    \"错误推测法\",\n",
      "    \"常见错误推测\",\n",
      "    \"模块测试经验\",\n",
      "    \"遗漏或省略部分测试\",\n",
      "    \"已发现错误与未发现错误的关系\",\n",
      "    \"网络实现\",\n",
      "    \"网络类型与结构确定\",\n",
      "    \"网络设备和服务器选型安装\",\n",
      "    \"网络拓扑结构确定\",\n",
      "    \"布线系统选择\",\n",
      "    \"网络产品选型\",\n",
      "    \"通信线路选择\",\n",
      "    \"数据库实现\",\n",
      "    \"数据库结构定义\",\n",
      "    \"组织数据入库\",\n",
      "    \"数据库试运行\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"减少测试数的方法\", \"属于\", \"黑盒测试技术\"],\n",
      "    [\"串接循环的测试\", \"属于\", \"黑盒测试技术\"],\n",
      "    [\"功能测试\", \"属于\", \"黑盒测试技术\"],\n",
      "    [\"独立性测试\", \"属于\", \"黑盒测试技术\"],\n",
      "    [\"错误类型\", \"属于\", \"黑盒测试技术\"],\n",
      "    [\"测试过程阶段\", \"属于\", \"黑盒测试技术\"],\n",
      "    [\"设计黑盒测试方案考虑的问题\", \"属于\", \"黑盒测试技术\"],\n",
      "    [\"测试用例集标准\", \"属于\", \"黑盒测试技术\"],\n",
      "    [\"等价类划分法\", \"属于\", \"黑盒测试技术\"],\n",
      "    [\"有效等价类覆盖\", \"属于\", \"等价类划分法\"],\n",
      "    [\"无效等价类覆盖\", \"属于\", \"等价类划分法\"],\n",
      "    [\"划分等价类的经验\", \"属于\", \"等价类划分法\"],\n",
      "    [\"边界值分析法\", \"属于\", \"黑盒测试技术\"],\n",
      "    [\"边界情况错误高发\", \"属于\", \"边界值分析法\"],\n",
      "    [\"测试数据选取原则\", \"属于\", \"边界值分析法\"],\n",
      "    [\"联合使用等价划分和边界值分析\", \"属于\", \"黑盒测试技术\"],\n",
      "    [\"判定表/判定树\", \"属于\", \"黑盒测试技术\"],\n",
      "    [\"输入组合测试\", \"属于\", \"黑盒测试技术\"],\n",
      "    [\"错误推测法\", \"属于\", \"黑盒测试技术\"],\n",
      "    [\"常见错误推测\", \"属于\", \"错误推测法\"],\n",
      "    [\"模块测试经验\", \"属于\", \"错误推测法\"],\n",
      "    [\"遗漏或省略部分测试\", \"属于\", \"错误推测法\"],\n",
      "    [\"已发现错误与未发现错误的关系\", \"属于\", \"错误推测法\"],\n",
      "    [\"网络实现\", \"独立于\", \"黑盒测试技术\"],\n",
      "    [\"网络类型与结构确定\", \"属于\", \"网络实现\"],\n",
      "    [\"网络设备和服务器选型安装\", \"属于\", \"网络实现\"],\n",
      "    [\"网络拓扑结构确定\", \"属于\", \"网络实现\"],\n",
      "    [\"布线系统选择\", \"属于\", \"网络实现\"],\n",
      "    [\"网络产品选型\", \"属于\", \"网络实现\"],\n",
      "    [\"通信线路选择\", \"属于\", \"网络实现\"],\n",
      "    [\"数据库实现\", \"独立于\", \"黑盒测试技术\"],\n",
      "    [\"数据库结构定义\", \"属于\", \"数据库实现\"],\n",
      "    [\"组织数据入库\", \"属于\", \"数据库实现\"],\n",
      "    [\"数据库试运行\", \"属于\", \"数据库实现\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "4363\n",
      "sleep:38.107771474137635秒\n",
      "————————————第66章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"错误推测法\",\n",
      "    \"边界值分析\",\n",
      "    \"等价划分技术\",\n",
      "    \"测试方案设计\",\n",
      "    \"特殊容易出错情况\",\n",
      "    \"输入数据组合\",\n",
      "    \"测试人员经验\",\n",
      "    \"常见错误清单\",\n",
      "    \"模块测试经验\",\n",
      "    \"程序规格说明书遗漏处理\",\n",
      "    \"已发现错误数目与未发现错误数正比关系\",\n",
      "    \"网络实现\",\n",
      "    \"网络系统实现工作\",\n",
      "    \"通信线路连接设备\",\n",
      "    \"网络选型\",\n",
      "    \"布线\",\n",
      "    \"网络设备安装\",\n",
      "    \"服务器安装\",\n",
      "    \"网络系统调试\",\n",
      "    \"以太网\",\n",
      "    \"网络类型与结构确定\",\n",
      "    \"交换机\",\n",
      "    \"服务器型号选择\",\n",
      "    \"带宽确定\",\n",
      "    \"网络拓扑结构\",\n",
      "    \"星型布线\",\n",
      "    \"环形布线\",\n",
      "    \"结构化布线\",\n",
      "    \"信息点布局\",\n",
      "    \"网络产品选型\",\n",
      "    \"路由器设备\",\n",
      "    \"交换机设备\",\n",
      "    \"通信线路选择\",\n",
      "    \"双绞线\",\n",
      "    \"同轴电缆\",\n",
      "    \"光纤电缆\",\n",
      "    \"微波通信\",\n",
      "    \"卫星通信\",\n",
      "    \"数据库实现\",\n",
      "    \"数据库实施工作\",\n",
      "    \"定义数据库结构\",\n",
      "    \"组织数据入库\",\n",
      "    \"数据库试运行\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"错误推测法\", \"属于\", \"测试方案设计\"],\n",
      "    [\"边界值分析\", \"属于\", \"测试方案设计\"],\n",
      "    [\"等价划分技术\", \"属于\", \"测试方案设计\"],\n",
      "    [\"特殊容易出错情况\", \"属于\", \"错误推测法\"],\n",
      "    [\"输入数据组合\", \"属于\", \"错误推测法\"],\n",
      "    [\"模块测试经验\", \"属于\", \"错误推测法\"],\n",
      "    [\"程序规格说明书遗漏处理\", \"属于\", \"错误推测法\"],\n",
      "    [\"网络实现\", \"属于\", \"章节内容\"],\n",
      "    [\"网络系统实现工作\", \"属于\", \"网络实现\"],\n",
      "    [\"以太网\", \"属于\", \"网络类型与结构确定\"],\n",
      "    [\"交换机\", \"属于\", \"网络设备和服务器选型与安装\"],\n",
      "    [\"服务器型号选择\", \"属于\", \"网络设备和服务器选型与安装\"],\n",
      "    [\"带宽确定\", \"属于\", \"网络设备和服务器选型与安装\"],\n",
      "    [\"网络拓扑结构\", \"属于\", \"网络实现\"],\n",
      "    [\"星型布线\", \"属于\", \"网络拓扑结构\"],\n",
      "    [\"环形布线\", \"属于\", \"网络拓扑结构\"],\n",
      "    [\"结构化布线\", \"属于\", \"网络拓扑结构\"],\n",
      "    [\"网络产品选型\", \"属于\", \"网络实现\"],\n",
      "    [\"通信线路选择\", \"属于\", \"网络实现\"],\n",
      "    [\"数据库实现\", \"属于\", \"章节内容\"],\n",
      "    [\"数据库实施工作\", \"属于\", \"数据库实现\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "1817\n",
      "sleep:39.44136848892294秒\n",
      "————————————第67章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"错误推测法\",\n",
      "    \"边界值分析\",\n",
      "    \"等价划分技术\",\n",
      "    \"测试方案设计\",\n",
      "    \"常见错误清单\",\n",
      "    \"模块测试经验\",\n",
      "    \"输入数据特殊情况\",\n",
      "    \"输出数据特殊情况\",\n",
      "    \"遗漏或省略的程序规格说明书部分\",\n",
      "    \"已发现错误与未发现错误成正比现象\",\n",
      "    \"集中测试错误较多的程序段\",\n",
      "    \"计算机测试结合人工检查代码\",\n",
      "    \"共享变量引起错误的检测\",\n",
      "    \"网络实现\",\n",
      "    \"网络选型\",\n",
      "    \"布线\",\n",
      "    \"网络设备安装\",\n",
      "    \"服务器安装\",\n",
      "    \"网络系统调试\",\n",
      "    \"以太网\",\n",
      "    \"网络类型与结构确定\",\n",
      "    \"网络设备和服务器选型与安装\",\n",
      "    \"网络拓扑结构确定\",\n",
      "    \"星型布线\",\n",
      "    \"结构化布线\",\n",
      "    \"数据库实现\",\n",
      "    \"定义数据库结构\",\n",
      "    \"组织数据入库\",\n",
      "    \"数据库试运行\",\n",
      "    \"数据定义语言（DDL）\",\n",
      "    \"数据库逻辑结构\",\n",
      "    \"数据库物理结构\",\n",
      "    \"数据装载\",\n",
      "    \"筛选数据\",\n",
      "    \"转换数据格式\",\n",
      "    \"输入数据\",\n",
      "    \"校验数据\",\n",
      "    \"数据输入子系统\",\n",
      "    \"模拟数据\",\n",
      "    \"功能测试\",\n",
      "    \"性能测试\",\n",
      "    \"系统转换\",\n",
      "    \"直接转换法\",\n",
      "    \"平行转换法\",\n",
      "    \"试点过度法\",\n",
      "    \"分阶段转换法\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"错误推测法\", \"属于\", \"测试方案设计\"],\n",
      "    [\"边界值分析\", \"属于\", \"测试方案设计\"],\n",
      "    [\"等价划分技术\", \"属于\", \"测试方案设计\"],\n",
      "    [\"常见错误清单\", \"属于\", \"模块测试经验\"],\n",
      "    [\"输入数据特殊情况\", \"属于\", \"错误推测法\"],\n",
      "    [\"输出数据特殊情况\", \"属于\", \"错误推测法\"],\n",
      "    [\"遗漏或省略的程序规格说明书部分\", \"用于\", \"测试方案设计\"],\n",
      "    [\"已发现错误与未发现错误成正比现象\", \"应用于\", \"测试策略选择\"],\n",
      "    [\"集中测试错误较多的程序段\", \"属于\", \"错误推测法\"],\n",
      "    [\"计算机测试结合人工检查代码\", \"属于\", \"测试方案设计\"],\n",
      "    [\"共享变量引起错误的检测\", \"属于\", \"测试方案设计\"],\n",
      "    [\"网络实现\", \"包含\", \"网络选型\"],\n",
      "    [\"网络实现\", \"包含\", \"布线\"],\n",
      "    [\"网络实现\", \"包含\", \"网络设备安装\"],\n",
      "    [\"网络实现\", \"包含\", \"服务器安装\"],\n",
      "    [\"网络实现\", \"包含\", \"网络系统调试\"],\n",
      "    [\"数据库实现\", \"包含\", \"定义数据库结构\"],\n",
      "    [\"数据库实现\", \"包含\", \"组织数据入库\"],\n",
      "    [\"数据库实现\", \"包含\", \"数据库试运行\"],\n",
      "    [\"数据库试运行\", \"包含\", \"功能测试\"],\n",
      "    [\"数据库试运行\", \"包含\", \"性能测试\"],\n",
      "    [\"系统转换\", \"包含\", \"直接转换法\"],\n",
      "    [\"系统转换\", \"包含\", \"平行转换法\"],\n",
      "    [\"系统转换\", \"包含\", \"试点过度法\"],\n",
      "    [\"系统转换\", \"包含\", \"分阶段转换法\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "2345\n",
      "sleep:37.61500050726775秒\n",
      "————————————第68章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"数据库结构定义\",\n",
      "    \"数据装载\",\n",
      "    \"数据库试运行\",\n",
      "    \"系统转换\",\n",
      "    \"直接转换法\",\n",
      "    \"并行转换法\",\n",
      "    \"试点过度法\",\n",
      "    \"系统运行\",\n",
      "    \"系统支持与维护\",\n",
      "    \"程序维护\",\n",
      "    \"数据文件维护\",\n",
      "    \"代码维护\",\n",
      "    \"系统恢复\",\n",
      "    \"功能测试\",\n",
      "    \"性能测试\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"数据库结构定义\", \"属于\", \"系统转换\"],\n",
      "    [\"数据装载\", \"属于\", \"系统转换\"],\n",
      "    [\"数据库试运行\", \"属于\", \"系统转换\"],\n",
      "    [\"直接转换法\", \"属于\", \"系统转换\"],\n",
      "    [\"并行转换法\", \"属于\", \"系统转换\"],\n",
      "    [\"试点过度法\", \"属于\", \"系统转换\"],\n",
      "    [\"系统运行\", \"属于\", \"系统支持与维护\"],\n",
      "    [\"系统支持与维护\", \"属于\", \"系统转换\"],\n",
      "    [\"程序维护\", \"属于\", \"系统支持与维护\"],\n",
      "    [\"数据文件维护\", \"属于\", \"系统支持与维护\"],\n",
      "    [\"代码维护\", \"属于\", \"系统支持与维护\"],\n",
      "    [\"系统恢复\", \"属于\", \"系统支持与维护\"],\n",
      "    [\"功能测试\", \"属于\", \"数据库试运行\"],\n",
      "    [\"性能测试\", \"属于\", \"数据库试运行\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "2070\n",
      "sleep:37.84781511570773秒\n",
      "————————————第69章————————————\n",
      "根据你提供的文本，以下是按照要求提取的知识点和关系：\n",
      "\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"系统运行\",\n",
      "    \"日常管理\",\n",
      "    \"数据收集\",\n",
      "    \"数据整理\",\n",
      "    \"数据录入及处理结果的整理与分发\",\n",
      "    \"硬件管理\",\n",
      "    \"设施管理\",\n",
      "    \"技术支持\",\n",
      "    \"用户满意度调查\",\n",
      "    \"业务流程修改\",\n",
      "    \"额外培训\",\n",
      "    \"效率测试\",\n",
      "    \"多用户测试\",\n",
      "    \"页面显示测试\",\n",
      "    \"程序输入功能测试\",\n",
      "    \"程序输出功能测试\",\n",
      "    \"模块功能测试\",\n",
      "    \"信息发布测试内容\",\n",
      "    \"信息栏目管理流程测试\",\n",
      "    \"面向对象开发概述\",\n",
      "    \"实体与对象\",\n",
      "    \"数据封装\",\n",
      "    \"并行性\",\n",
      "    \"模块独立性\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"系统运行\", \"属于\", \"系统运行与支持\"],\n",
      "    [\"日常管理\", \"属于\", \"系统运行\"],\n",
      "    [\"数据收集\", \"属于\", \"系统运行\"],\n",
      "    [\"数据整理\", \"属于\", \"系统运行\"],\n",
      "    [\"数据录入及处理结果的整理与分发\", \"属于\", \"系统运行\"],\n",
      "    [\"硬件管理\", \"属于\", \"系统运行\"],\n",
      "    [\"设施管理\", \"属于\", \"系统运行\"],\n",
      "    [\"技术支持\", \"属于\", \"系统支持与维护\"],\n",
      "    [\"用户满意度调查\", \"属于\", \"技术支持\"],\n",
      "    [\"业务流程修改\", \"属于\", \"技术支持\"],\n",
      "    [\"额外培训\", \"属于\", \"技术支持\"],\n",
      "    [\"效率测试\", \"属于\", \"系统测试\"],\n",
      "    [\"多用户测试\", \"属于\", \"系统测试\"],\n",
      "    [\"页面显示测试\", \"属于\", \"程序输入功能测试\"],\n",
      "    [\"程序输入功能测试\", \"属于\", \"系统测试\"],\n",
      "    [\"程序输出功能测试\", \"属于\", \"系统测试\"],\n",
      "    [\"模块功能测试\", \"属于\", \"系统测试\"],\n",
      "    [\"信息发布测试内容\", \"属于\", \"系统测试\"],\n",
      "    [\"信息栏目管理流程测试\", \"属于\", \"系统实现阶段\"],\n",
      "    [\"面向对象开发概述\", \"属于\", \"系统设计方法\"],\n",
      "    [\"实体与对象\", \"属于\", \"面向对象开发概念\"],\n",
      "    [\"数据封装\", \"属于\", \"面向对象开发特点\"],\n",
      "    [\"并行性\", \"属于\", \"面向对象开发特点\"],\n",
      "    [\"模块独立性\", \"属于\", \"面向对象开发特点\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "\n",
      "注意：由于上下文较长，这里仅提取了部分重要知识点及其所属关系，完整的关系网络可能更复杂。同时，本答案没有完全按照严格的“知识点1, 属于, 知识点2”的格式列出所有关系，而是以JSON结构展示了较清晰的知识点分类和层次关系。\n",
      "11231\n",
      "Error decoding JSON: Expecting value: line 1 column 1 (char 0)\n",
      "sleep:38.60743620885127秒\n",
      "————————————第70章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"面向对象\",\n",
      "    \"面向对象基本思想\",\n",
      "    \"客观世界由对象组成\",\n",
      "    \"对象类\",\n",
      "    \"静态属性\",\n",
      "    \"动态属性\",\n",
      "    \"子类(派生类)\",\n",
      "    \"父类(基类)\",\n",
      "    \"层次结构的系统\",\n",
      "    \"实体与对象\",\n",
      "    \"对象特点\",\n",
      "    \"以数据为中心\",\n",
      "    \"主动性\",\n",
      "    \"数据封装\",\n",
      "    \"并行性\",\n",
      "    \"模块独立性\",\n",
      "    \"类与对象\",\n",
      "    \"类\",\n",
      "    \"对象共同特征\",\n",
      "    \"创建对象模板\",\n",
      "    \"对象是类的实例\",\n",
      "    \"状态S\",\n",
      "    \"操作1\",\n",
      "    \"操作2\",\n",
      "    \"操作3\",\n",
      "    \"Circle类示例\",\n",
      "    \"消息\",\n",
      "    \"要求对象执行操作的规格说明\",\n",
      "    \"接受消息的对象\",\n",
      "    \"消息选择符\",\n",
      "    \"参数\",\n",
      "    \"MyCircle.Show(GREEN)\",\n",
      "    \"属性\",\n",
      "    \"类中定义的数据\",\n",
      "    \"客观世界实体性质的抽象\",\n",
      "    \"操作\",\n",
      "    \"类的所有实例提供的功能或服务\",\n",
      "    \"方法\",\n",
      "    \"构造函数操作\",\n",
      "    \"查询操作\",\n",
      "    \"没有副作用的操作\",\n",
      "    \"访问对象状态但不改变状态\",\n",
      "    \"更新操作\",\n",
      "    \"有副作用的操作\",\n",
      "    \"改变对象状态\",\n",
      "    \"范围操作\",\n",
      "    \"应用于类而不是对象实例的操作\",\n",
      "    \"封装\",\n",
      "    \"信息隐藏\",\n",
      "    \"接口形式\",\n",
      "    \"私有数据\",\n",
      "    \"实现操作的代码\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"面向对象基本思想\", \"属于\", \"面向对象\"],\n",
      "    [\"客观世界由对象组成\", \"属于\", \"面向对象基本思想\"],\n",
      "    [\"对象类\", \"属于\", \"面向对象基本思想\"],\n",
      "    [\"静态属性\", \"属于\", \"对象类\"],\n",
      "    [\"动态属性\", \"属于\", \"对象类\"],\n",
      "    [\"子类(派生类)\", \"属于\", \"面向对象基本思想\"],\n",
      "    [\"父类(基类)\", \"属于\", \"面向对象基本思想\"],\n",
      "    [\"层次结构的系统\", \"属于\", \"面向对象基本思想\"],\n",
      "    [\"实体与对象\", \"属于\", \"面向对象相关概念\"],\n",
      "    [\"对象特点\", \"属于\", \"实体与对象\"],\n",
      "    [\"以数据为中心\", \"属于\", \"对象特点\"],\n",
      "    [\"主动性\", \"属于\", \"对象特点\"],\n",
      "    [\"数据封装\", \"属于\", \"对象特点\"],\n",
      "    [\"并行性\", \"属于\", \"对象特点\"],\n",
      "    [\"模块独立性\", \"属于\", \"对象特点\"],\n",
      "    [\"类与对象\", \"属于\", \"面向对象相关概念\"],\n",
      "    [\"类\", \"属于\", \"类与对象\"],\n",
      "    [\"对象共同特征\", \"属于\", \"类\"],\n",
      "    [\"创建对象模板\", \"属于\", \"类\"],\n",
      "    [\"对象是类的实例\", \"属于\", \"类与对象\"],\n",
      "    [\"状态S\", \"属于\", \"实体与对象\"],\n",
      "    [\"操作1\", \"属于\", \"实体与对象\"],\n",
      "    [\"操作2\", \"属于\", \"实体与对象\"],\n",
      "    [\"操作3\", \"属于\", \"实体与对象\"],\n",
      "    [\"Circle类示例\", \"属于\", \"类与对象\"],\n",
      "    [\"消息\", \"属于\", \"面向对象相关概念\"],\n",
      "    [\"要求对象执行操作的规格说明\", \"属于\", \"消息\"],\n",
      "    [\"接受消息的对象\", \"属于\", \"消息\"],\n",
      "    [\"消息选择符\", \"属于\", \"消息\"],\n",
      "    [\"参数\", \"属于\", \"消息\"],\n",
      "    [\"MyCircle.Show(GREEN)\", \"属于\", \"消息\"],\n",
      "    [\"属性\", \"属于\", \"面向对象相关概念\"],\n",
      "    [\"类中定义的数据\", \"属于\", \"属性\"],\n",
      "    [\"客观世界实体性质的抽象\", \"属于\", \"属性\"],\n",
      "    [\"操作\", \"属于\", \"面向对象相关概念\"],\n",
      "    [\"类的所有实例提供的功能或服务\", \"属于\", \"操作\"],\n",
      "    [\"方法\", \"属于\", \"操作\"],\n",
      "    [\"构造函数操作\", \"属于\", \"操作\"],\n",
      "    [\"查询操作\", \"属于\", \"操作\"],\n",
      "    [\"没有副作用的操作\", \"属于\", \"查询操作\"],\n",
      "    [\"访问对象状态但不改变状态\", \"属于\", \"查询操作\"],\n",
      "    [\"更新操作\", \"属于\", \"操作\"],\n",
      "    [\"有副作用的操作\", \"属于\", \"更新操作\"],\n",
      "    [\"改变对象状态\", \"属于\", \"更新操作\"],\n",
      "    [\"范围操作\", \"属于\", \"面向对象相关概念\"],\n",
      "    [\"应用于类而不是对象实例的操作\", \"属于\", \"范围操作\"],\n",
      "    [\"封装\", \"属于\", \"面向对象特性\"],\n",
      "    [\"信息隐藏\", \"属于\", \"封装\"],\n",
      "    [\"接口形式\", \"属于\", \"封装\"],\n",
      "    [\"私有数据\", \"属于\", \"封装\"],\n",
      "    [\"实现操作的代码\", \"属于\", \"封装\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "3261\n",
      "sleep:38.11574627490953秒\n",
      "————————————第71章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"面向对象的特性\",\n",
      "    \"封装\",\n",
      "    \"信息隐藏\",\n",
      "    \"类的外部视图\",\n",
      "    \"内部结构\",\n",
      "    \"操作实施细节\",\n",
      "    \"构造函数操作\",\n",
      "    \"创建实例\",\n",
      "    \"查询操作\",\n",
      "    \"无副作用的操作\",\n",
      "    \"访问对象状态\",\n",
      "    \"不改变状态\",\n",
      "    \"构造函数（constructor operation）\",\n",
      "    \"创建学生（create-student）\",\n",
      "    \"查询操作（query operation）\",\n",
      "    \"获取年级（get-year）\",\n",
      "    \"派生属性\",\n",
      "    \"年龄\",\n",
      "    \"更新操作（update operation）\",\n",
      "    \"有副作用的操作\",\n",
      "    \"改变对象状态\",\n",
      "    \"学生进级（promote-student）\",\n",
      "    \"注册（register-for）\",\n",
      "    \"范围操作（scope operation）\",\n",
      "    \"平均绩点（avg-gpa）\",\n",
      "    \"继承\",\n",
      "    \"子类自动共享基类数据和方法\",\n",
      "    \"传递性\",\n",
      "    \"单继承\",\n",
      "    \"多重继承\",\n",
      "    \"多态性\",\n",
      "    \"子类对象像父类对象使用\",\n",
      "    \"消息发送给父类或子类\",\n",
      "    \"类等级的行为共享\",\n",
      "    \"动态选用实现算法\",\n",
      "    \"Booch 的 OOD 方法\",\n",
      "    \"面向对象软件开发方法\",\n",
      "    \"设计阶段\",\n",
      "    \"微观过程\",\n",
      "    \"宏观过程\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"封装\", \"属于\", \"面向对象的特性\"],\n",
      "    [\"信息隐藏\", \"属于\", \"封装\"],\n",
      "    [\"查询操作\", \"属于\", \"操作类型\"],\n",
      "    [\"无副作用的操作\", \"属于\", \"查询操作\"],\n",
      "    [\"构造函数操作\", \"属于\", \"操作类型\"],\n",
      "    [\"创建学生（create-student）\", \"属于\", \"构造函数操作\"],\n",
      "    [\"获取年级（get-year）\", \"属于\", \"查询操作\"],\n",
      "    [\"年龄\", \"属于\", \"派生属性\"],\n",
      "    [\"更新操作（update operation）\", \"属于\", \"操作类型\"],\n",
      "    [\"有副作用的操作\", \"属于\", \"更新操作（update operation）\"],\n",
      "    [\"学生进级（promote-student）\", \"属于\", \"更新操作（update operation）\"],\n",
      "    [\"继承\", \"属于\", \"面向对象的特性\"],\n",
      "    [\"传递性\", \"属于\", \"继承\"],\n",
      "    [\"单继承\", \"属于\", \"继承\"],\n",
      "    [\"多重继承\", \"属于\", \"继承\"],\n",
      "    [\"多态性\", \"属于\", \"面向对象的特性\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "2194\n",
      "sleep:38.11098919489852秒\n",
      "————————————第72章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"面向对象开发的主要方法\",\n",
      "    \"继承\",\n",
      "    \"多态性\",\n",
      "    \"Booch 的 OOD 方法\",\n",
      "    \"微观过程\",\n",
      "    \"类和对象的识别\",\n",
      "    \"语义的识别\",\n",
      "    \"关系的识别\",\n",
      "    \"类和对象的实现\",\n",
      "    \"宏观过程\",\n",
      "    \"概念化、建立核心需求\",\n",
      "    \"分析和建立理想的行为模型\",\n",
      "    \"设计并创建体系结构\",\n",
      "    \"细化并完善和实现模型\",\n",
      "    \"维护、管理并提交模型\",\n",
      "    \"Coad/Yourdon 的 OOA-OOD 方法\",\n",
      "    \"五层模型体系\",\n",
      "    \"问题域的五层模型\",\n",
      "    \"对象定义规格的求精过程\",\n",
      "    \"数据模型与数据库设计\",\n",
      "    \"优化\",\n",
      "    \"Rumbaugh 的 OMT 方法\",\n",
      "    \"对象模型\",\n",
      "    \"动态模型\",\n",
      "    \"功能模型\",\n",
      "    \"系统分析\",\n",
      "    \"系统设计\",\n",
      "    \"对象设计\",\n",
      "    \"实现\",\n",
      "    \"Jacobson 方法（OOSE）\",\n",
      "    \"用例驱动\",\n",
      "    \"用例模型\",\n",
      "    \"问题域模型\",\n",
      "    \"分析模型\",\n",
      "    \"设计模型\",\n",
      "    \"实现模型\",\n",
      "    \"测试模型\",\n",
      "    \"UML\",\n",
      "    \"统一建模语言\",\n",
      "    \"视图\",\n",
      "    \"图\",\n",
      "    \"模型元素\",\n",
      "    \"通用机制\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"继承\", \"属于\", \"面向对象开发的主要方法\"],\n",
      "    [\"多态性\", \"属于\", \"面向对象开发的主要方法\"],\n",
      "    [\"Booch 的 OOD 方法\", \"属于\", \"面向对象开发的主要方法\"],\n",
      "    [\"微观过程\", \"属于\", \"Booch 的 OOD 方法\"],\n",
      "    [\"类和对象的识别\", \"属于\", \"微观过程\"],\n",
      "    [\"语义的识别\", \"属于\", \"微观过程\"],\n",
      "    [\"关系的识别\", \"属于\", \"微观过程\"],\n",
      "    [\"类和对象的实现\", \"属于\", \"微观过程\"],\n",
      "    [\"宏观过程\", \"属于\", \"Booch 的 OOD 方法\"],\n",
      "    [\"概念化、建立核心需求\", \"属于\", \"宏观过程\"],\n",
      "    [\"分析和建立理想的行为模型\", \"属于\", \"宏观过程\"],\n",
      "    [\"设计并创建体系结构\", \"属于\", \"宏观过程\"],\n",
      "    [\"细化并完善和实现模型\", \"属于\", \"宏观过程\"],\n",
      "    [\"维护、管理并提交模型\", \"属于\", \"宏观过程\"],\n",
      "    [\"Coad/Yourdon 的 OOA-OOD 方法\", \"属于\", \"面向对象开发的主要方法\"],\n",
      "    [\"五层模型体系\", \"属于\", \"Coad/Yourdon 的 OOA-OOD 方法\"],\n",
      "    [\"问题域的五层模型\", \"属于\", \"五层模型体系\"],\n",
      "    [\"对象定义规格的求精过程\", \"属于\", \"Coad/Yourdon 的 OOA-OOD 方法\"],\n",
      "    [\"数据模型与数据库设计\", \"属于\", \"Coad/Yourdon 的 OOA-OOD 方法\"],\n",
      "    [\"优化\", \"属于\", \"Coad/Yourdon 的 OOA-OOD 方法\"],\n",
      "    [\"Rumbaugh 的 OMT 方法\", \"属于\", \"面向对象开发的主要方法\"],\n",
      "    [\"对象模型\", \"属于\", \"Rumbaugh 的 OMT 方法\"],\n",
      "    [\"动态模型\", \"属于\", \"Rumbaugh 的 OMT 方法\"],\n",
      "    [\"功能模型\", \"属于\", \"Rumbaugh 的 OMT 方法\"],\n",
      "    [\"系统分析\", \"属于\", \"Rumbaugh 的 OMT 方法\"],\n",
      "    [\"系统设计\", \"属于\", \"Rumbaugh 的 OMT 方法\"],\n",
      "    [\"对象设计\", \"属于\", \"Rumbaugh 的 OMT 方法\"],\n",
      "    [\"实现\", \"属于\", \"Rumbaugh 的 OMT 方法\"],\n",
      "    [\"Jacobson 方法（OOSE）\", \"属于\", \"面向对象开发的主要方法\"],\n",
      "    [\"用例驱动\", \"属于\", \"Jacobson 方法（OOSE）\"],\n",
      "    [\"用例模型\", \"属于\", \"Jacobson 方法（OOSE）\"],\n",
      "    [\"问题域模型\", \"属于\", \"Jacobson 方法（OOSE）\"],\n",
      "    [\"分析模型\", \"属于\", \"Jacobson 方法（OOSE）\"],\n",
      "    [\"设计模型\", \"属于\", \"Jacobson 方法（OOSE）\"],\n",
      "    [\"实现模型\", \"属于\", \"Jacobson 方法（OOSE）\"],\n",
      "    [\"测试模型\", \"属于\", \"Jacobson 方法（OOSE）\"],\n",
      "    [\"UML\", \"属于\", \"面向对象开发的主要方法\"],\n",
      "    [\"视图\", \"属于\", \"UML\"],\n",
      "    [\"图\", \"属于\", \"UML\"],\n",
      "    [\"模型元素\", \"属于\", \"UML\"],\n",
      "    [\"通用机制\", \"属于\", \"UML\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "5166\n",
      "sleep:37.551445222108576秒\n",
      "————————————第73章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"UML\",\n",
      "    \"统一建模语言\",\n",
      "    \"视图\",\n",
      "    \"模型元素\",\n",
      "    \"通用机制\",\n",
      "    \"用例视图\",\n",
      "    \"逻辑视图\",\n",
      "    \"并发视图\",\n",
      "    \"组件视图\",\n",
      "    \"部署视图\",\n",
      "    \"类元\",\n",
      "    \"参与者\",\n",
      "    \"类和对象\",\n",
      "    \"状态\",\n",
      "    \"构件\",\n",
      "    \"接口\",\n",
      "    \"节点\",\n",
      "    \"子系统\",\n",
      "    \"用例\",\n",
      "    \"注释\",\n",
      "    \"关联\",\n",
      "    \"依赖\",\n",
      "    \"泛化\",\n",
      "    \"实现\",\n",
      "    \"使用\",\n",
      "    \"聚合\",\n",
      "    \"用例图\",\n",
      "    \"类图\",\n",
      "    \"对象图\",\n",
      "    \"包图\",\n",
      "    \"顺序图\",\n",
      "    \"协作图\",\n",
      "    \"状态图\",\n",
      "    \"活动图\",\n",
      "    \"组件图\",\n",
      "    \"配置图\",\n",
      "    \"构造型\",\n",
      "    \"约束\",\n",
      "    \"标签值\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"UML\", \"包含\", \"视图\"],\n",
      "    [\"UML\", \"包含\", \"模型元素\"],\n",
      "    [\"UML\", \"包含\", \"通用机制\"],\n",
      "    [\"视图\", \"包括\", \"用例视图\"],\n",
      "    [\"视图\", \"包括\", \"逻辑视图\"],\n",
      "    [\"视图\", \"包括\", \"并发视图\"],\n",
      "    [\"视图\", \"包括\", \"组件视图\"],\n",
      "    [\"视图\", \"包括\", \"部署视图\"],\n",
      "    [\"模型元素\", \"包含\", \"参与者\"],\n",
      "    [\"模型元素\", \"包含\", \"类和对象\"],\n",
      "    [\"模型元素\", \"包含\", \"状态\"],\n",
      "    [\"模型元素\", \"包含\", \"构件\"],\n",
      "    [\"模型元素\", \"包含\", \"接口\"],\n",
      "    [\"模型元素\", \"包含\", \"节点\"],\n",
      "    [\"模型元素\", \"包含\", \"子系统\"],\n",
      "    [\"模型元素\", \"包含\", \"用例\"],\n",
      "    [\"模型元素\", \"包含\", \"注释\"],\n",
      "    [\"类元之间关系\", \"包括\", \"关联\"],\n",
      "    [\"类元之间关系\", \"包括\", \"依赖\"],\n",
      "    [\"类元之间关系\", \"包括\", \"泛化\"],\n",
      "    [\"类元之间关系\", \"包括\", \"实现\"],\n",
      "    [\"类元之间关系\", \"包括\", \"使用\"],\n",
      "    [\"通用机制\", \"提供\", \"构造型\"],\n",
      "    [\"通用机制\", \"提供\", \"约束\"],\n",
      "    [\"通用机制\", \"提供\", \"标签值\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "3268\n",
      "sleep:38.20748210955916秒\n",
      "————————————第74章————————————\n",
      "{\n",
      "\"point\": [\"用例图\", \"参与者\", \"用例\", \"关联\", \"包含关系\", \"扩展关系\", \"泛化关系\", \"构造型\", \"约束\", \"标签值\", \"抽象用例\", \"基础用例\", \"扩展点\", \"风险分析\", \"交易估价\", \"进行交易\", \"设置边界\", \"更新账目\", \"评价贸易\", \"超越边界的交易\", \"权限控制\", \"执行交易\", \"交易债券\", \"交易股票\", \"交易期权\", \"人才需求登记\", \"人才需求审核\", \"招聘计划登记\", \"招聘信息发布\", \"面试管理\", \"人才储备管理\", \"录用管理\"],\n",
      "\"edge\": [\n",
      "  [\"参与者\", \"属于\", \"用例图\"],\n",
      "  [\"用例\", \"属于\", \"用例图\"],\n",
      "  [\"关联\", \"表示\", \"参与者与用例之间关系\"],\n",
      "  [\"包含关系\", \"属于\", \"用例之间关系\"],\n",
      "  [\"扩展关系\", \"属于\", \"用例之间关系\"],\n",
      "  [\"泛化关系\", \"属于\", \"用例之间关系\"],\n",
      "  [\"抽象用例\", \"属于\", \"用例\"],\n",
      "  [\"基础用例\", \"属于\", \"用例\"],\n",
      "  [\"扩展点\", \"属于\", \"扩展关系\"],\n",
      "  [\"风险分析\", \"通过包含关系相关联\", \"评价贸易\"],\n",
      "  [\"交易估价\", \"通过包含关系相关联\", \"评价贸易\"],\n",
      "  [\"进行交易\", \"作为基础用例\", \"超越边界的交易\"],\n",
      "  [\"权限控制\", \"示例了\", \"泛化关系\"],\n",
      "  [\"执行交易\", \"作为父用例\", \"交易债券, 交易股票, 交易期权\"],\n",
      "  [\"人才需求登记\", \"属于\", \"招聘管理用例图\"],\n",
      "  [\"人才需求审核\", \"属于\", \"招聘管理用例图\"],\n",
      "  [\"招聘计划登记\", \"属于\", \"招聘管理用例图\"],\n",
      "  [\"招聘信息发布\", \"属于\", \"招聘管理用例图\"],\n",
      "  [\"面试管理\", \"属于\", \"招聘管理用例图\"],\n",
      "  [\"人才储备管理\", \"属于\", \"招聘管理用例图\"],\n",
      "  [\"录用管理\", \"属于\", \"招聘管理用例图\"]\n",
      "]\n",
      "}\n",
      "4896\n",
      "sleep:37.6919112134697秒\n",
      "————————————第75章————————————\n",
      "{\"point\": [\"类图\", \"对象图\", \"用例关系准则\", \"抽象用例\", \"包含关系\", \"扩展关系\", \"基础用例\", \"用例\", \"参与者\", \"普通关联\", \"聚合关联\", \"组合聚集\", \"共享聚集\", \"泛化关联\", \"依赖关系\", \"实现关系\", \"派生属性\", \"派生关联\", \"抽象类\", \"接口\", \"版型(构造型)\", \"标记值\", \"约束\", \"对象图的表示方法\", \"状态图\", \"活动图\", \"顺序图\", \"协作图\", \"状态\", \"状态转移\", \"初态\", \"终态\", \"中间状态\"], \n",
      "\"edge\": [\n",
      "  [\"类图\", \"属于\", \"面向对象建模技术\"],\n",
      "  [\"对象图\", \"属于\", \"类图\"],\n",
      "  [\"用例关系准则\", \"属于\", \"需求澄清\"],\n",
      "  [\"抽象用例\", \"用于\", \"行为变体建模\"],\n",
      "  [\"包含关系\", \"用于\", \"共享行为片段\"],\n",
      "  [\"扩展关系\", \"用于\", \"增加可选特性\"],\n",
      "  [\"基础用例\", \"定义\", \"常规行为\"],\n",
      "  [\"普通关联\", \"属于\", \"类之间的关联\"],\n",
      "  [\"聚合关联\", \"包括\", \"组成聚合\", \"共享聚合\"],\n",
      "  [\"组合聚集\", \"描述\", \"部分与整体共存关系\"],\n",
      "  [\"共享聚集\", \"描述\", \"整体与部分的关系\"],\n",
      "  [\"泛化关联\", \"表示\", \"一般与特殊关系\"],\n",
      "  [\"依赖关系\", \"连接\", \"两个模型元素的语义关系\"],\n",
      "  [\"实现关系\", \"表示\", \"不同抽象层上的事务描述\"],\n",
      "  [\"派生属性\", \"来源于\", \"其他属性推演\"],\n",
      "  [\"派生关联\", \"来源于\", \"其他关联计算推演\"],\n",
      "  [\"抽象类\", \"特征\", \"不能直接实例化\"],\n",
      "  [\"接口\", \"是\", \"类的版型\"],\n",
      "  [\"版型(构造型)\", \"用于\", \"模型元素扩展\"],\n",
      "  [\"对象图\", \"实例化\", \"类图\"],\n",
      "  [\"状态图\", \"展示\", \"对象状态变迁\"],\n",
      "  [\"活动图\", \"描述\", \"用例或业务过程\"],\n",
      "  [\"顺序图\", \"体现\", \"交互性\"],\n",
      "  [\"协作图\", \"体现\", \"一组对象间的交互\"]\n",
      "]}\n",
      "5524\n",
      "sleep:38.548709652339085秒\n",
      "————————————第76章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"状态图\",\n",
      "    \"动态建模\",\n",
      "    \"行为描述\",\n",
      "    \"活动图\",\n",
      "    \"顺序图\",\n",
      "    \"协作图\",\n",
      "    \"状态\",\n",
      "    \"初态\",\n",
      "    \"终态\",\n",
      "    \"中间状态\",\n",
      "    \"状态转移\",\n",
      "    \"动作\",\n",
      "    \"状态名称\",\n",
      "    \"状态变量\",\n",
      "    \"活动表\",\n",
      "    \"状态转换\",\n",
      "    \"事件触发\",\n",
      "    \"守卫条件\",\n",
      "    \"动作表达式\",\n",
      "    \"电话系统的状态图\",\n",
      "    \"活动图描述\",\n",
      "    \"执行顺序\",\n",
      "    \"操作流程\",\n",
      "    \"用例处理流程\",\n",
      "    \"交互流程\",\n",
      "    \"控制转移箭头\",\n",
      "    \"并行执行\",\n",
      "    \"商务建模层次\",\n",
      "    \"业务过程建模\",\n",
      "    \"具体处理流程层次\",\n",
      "    \"用例的处理流程\",\n",
      "    \"内部类操作建模\",\n",
      "    \"过程控制流\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"状态图\", \"属于\", \"动态建模\"],\n",
      "    [\"活动图\", \"属于\", \"动态建模\"],\n",
      "    [\"顺序图\", \"属于\", \"动态建模\"],\n",
      "    [\"协作图\", \"属于\", \"动态建模\"],\n",
      "    [\"状态转移\", \"属于\", \"状态图\"],\n",
      "    [\"状态\", \"属于\", \"状态图\"],\n",
      "    [\"初态\", \"属于\", \"状态\"],\n",
      "    [\"终态\", \"属于\", \"状态\"],\n",
      "    [\"中间状态\", \"属于\", \"状态\"],\n",
      "    [\"活动表\", \"属于\", \"中间状态\"],\n",
      "    [\"状态转换\", \"属于\", \"状态图\"],\n",
      "    [\"事件触发\", \"关联于\", \"状态转换\"],\n",
      "    [\"守卫条件\", \"关联于\", \"状态转换\"],\n",
      "    [\"动作表达式\", \"关联于\", \"状态转换\"],\n",
      "    [\"电话系统的状态图\", \"示例\", \"状态图\"],\n",
      "    [\"活动图描述\", \"属于\", \"活动图\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "2001\n",
      "sleep:37.63586766160009秒\n",
      "————————————第77章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"活动图\",\n",
      "    \"描述系统中各种活动的执行顺序\",\n",
      "    \"用于描述一个操作中的各项活动执行流程\",\n",
      "    \"常被用来描述用例的处理流程\",\n",
      "    \"描述交互流程\",\n",
      "    \"活动\",\n",
      "    \"活动状态\",\n",
      "    \"带有圆形边线的矩形\",\n",
      "    \"包含活动的描述\",\n",
      "    \"完成转换\",\n",
      "    \"简单的完成转换用箭头表示\",\n",
      "    \"起点和终点符号\",\n",
      "    \"开始状态\",\n",
      "    \"结束状态\",\n",
      "    \"表示法与状态图一样\",\n",
      "    \"转移\",\n",
      "    \"显示控制流方向的开放箭头\",\n",
      "    \"泳道\",\n",
      "    \"顶部是对象或域的名字\",\n",
      "    \"矩形框包含活动\",\n",
      "    \"判定点\",\n",
      "    \"到达某个点做出判定或决策\",\n",
      "    \"守卫条件\",\n",
      "    \"两种表示方式\",\n",
      "    \"直接引出可能路径\",\n",
      "    \"菱形图标引出可能路径\",\n",
      "    \"并发路径\",\n",
      "    \"垂直黑色粗实线条表示\",\n",
      "    \"分叉路径\",\n",
      "    \"汇合路径\",\n",
      "    \"对象流\",\n",
      "    \"表示活动和对象之间的关系\",\n",
      "    \"输入或输出\",\n",
      "    \"信号\",\n",
      "    \"引起活动的发生\",\n",
      "    \"发送信号的图符\",\n",
      "    \"接收信号的图符\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"活动图\", \"属于\", \"描述系统中各种活动的执行顺序\"],\n",
      "    [\"活动状态\", \"属于\", \"活动\"],\n",
      "    [\"开始状态\", \"属于\", \"活动图\"],\n",
      "    [\"结束状态\", \"属于\", \"活动图\"],\n",
      "    [\"转移\", \"属于\", \"活动图\"],\n",
      "    [\"泳道\", \"属于\", \"活动图\"],\n",
      "    [\"判定点\", \"属于\", \"活动图\"],\n",
      "    [\"并发路径\", \"属于\", \"活动图\"],\n",
      "    [\"对象流\", \"属于\", \"活动图\"],\n",
      "    [\"信号\", \"属于\", \"活动图\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "2165\n",
      "sleep:38.11745324853223秒\n",
      "————————————第78章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"顺序图\",\n",
      "    \"时序图\",\n",
      "    \"对象\",\n",
      "    \"生命线\",\n",
      "    \"激活期\",\n",
      "    \"消息\",\n",
      "    \"激活：表示该对象正在执行某个操作\",\n",
      "    \"激活矩形\",\n",
      "    \"持续时间\",\n",
      "    \"对象的命名方式\",\n",
      "    \"ObjectName：ClassName\",\n",
      "    \"objectName：Classname\",\n",
      "    \"只显示对象名\",\n",
      "    \"只显示类名\",\n",
      "    \"即时创建对象\",\n",
      "    \"create消息\",\n",
      "    \"destroys消息\",\n",
      "    \"对象销毁\",\n",
      "    \"控制流过程中创建对象\",\n",
      "    \"调用消息\",\n",
      "    \"同步消息\",\n",
      "    \"异步消息\",\n",
      "    \"返回消息\",\n",
      "    \"非过程调用\",\n",
      "    \"阻止消息\",\n",
      "    \"超时消息\",\n",
      "    \"图书借阅顺序图\",\n",
      "    \"协作图\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"顺序图\", \"属于\", \"UML动态建模\"],\n",
      "    [\"时序图\", \"同义词\", \"顺序图\"],\n",
      "    [\"对象\", \"包含于\", \"顺序图\"],\n",
      "    [\"生命线\", \"属于\", \"顺序图\"],\n",
      "    [\"激活期\", \"属于\", \"顺序图\"],\n",
      "    [\"消息\", \"属于\", \"顺序图\"],\n",
      "    [\"激活：表示该对象正在执行某个操作\", \"属于\", \"激活期\"],\n",
      "    [\"即时创建对象\", \"属于\", \"顺序图\"],\n",
      "    [\"调用消息\", \"属于\", \"顺序图\"],\n",
      "    [\"同步消息\", \"同义词\", \"调用消息(早期版本)\"],\n",
      "    [\"异步消息\", \"属于\", \"顺序图\"],\n",
      "    [\"返回消息\", \"属于\", \"顺序图\"],\n",
      "    [\"阻止消息\", \"属于\", \"顺序图\"],\n",
      "    [\"超时消息\", \"属于\", \"顺序图\"],\n",
      "    [\"图书借阅顺序图\", \"示例\", \"顺序图\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "2109\n",
      "sleep:38.070327321220624秒\n",
      "————————————第79章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"协作图\",\n",
      "    \"参与者\",\n",
      "    \"对象\",\n",
      "    \"消息\",\n",
      "    \"链接\",\n",
      "    \"顺序\",\n",
      "    \"交互关系\",\n",
      "    \"空间\",\n",
      "    \"时间\",\n",
      "    \"序列化\",\n",
      "    \"序列ID号\",\n",
      "    \"迭代\",\n",
      "    \"控制流类型\",\n",
      "    \"单个对象发送消息到一组其他对象\",\n",
      "    \"多对象消息\",\n",
      "    \"条件\",\n",
      "    \"星号(*)\",\n",
      "    \"消息计数\",\n",
      "    \"消息多次发送\",\n",
      "    \"控制点条件\",\n",
      "    \"表达式计算结果\",\n",
      "    \"限制消息发送\",\n",
      "    \"组件图\",\n",
      "    \"软件组件\",\n",
      "    \"依赖关系\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"协作图\", \"属于\", \"UML\"],\n",
      "    [\"参与者\", \"在\", \"协作图\"],\n",
      "    [\"对象\", \"在\", \"协作图\"],\n",
      "    [\"消息\", \"在\", \"协作图\"],\n",
      "    [\"链接\", \"表示\", \"关联的实例化\"],\n",
      "    [\"顺序\", \"强调\", \"顺序图\"],\n",
      "    [\"交互关系\", \"强调\", \"协作图\"],\n",
      "    [\"空间\", \"侧重于\", \"协作图\"],\n",
      "    [\"时间\", \"侧重于\", \"顺序图\"],\n",
      "    [\"序列化\", \"通过\", \"添加序列ID号\"],\n",
      "    [\"迭代\", \"是\", \"控制流类型\"],\n",
      "    [\"单个对象发送消息到一组其他对象\", \"通过\", \"多重性指定\"],\n",
      "    [\"多对象消息\", \"用\", \"星号(*)标记\"],\n",
      "    [\"消息多次发送\", \"在\", \"协作图中建模\"],\n",
      "    [\"控制点条件\", \"用于\", \"限制消息发送\"],\n",
      "    [\"组件图\", \"描述\", \"软件组件及其依赖关系\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "2192\n",
      "sleep:38.05869731710961秒\n",
      "————————————第80章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"组件图\",\n",
      "    \"协作图\",\n",
      "    \"控制点条件\",\n",
      "    \"对象\",\n",
      "    \"消息传递顺序\",\n",
      "    \"协作图任务概括\",\n",
      "    \"迭代含义\",\n",
      "    \"Compiler\",\n",
      "    \"Program\",\n",
      "    \"FileSystem\",\n",
      "    \"File\",\n",
      "    \"LoadFile\",\n",
      "    \"Create Program()\",\n",
      "    \"AddFiles(Files)\",\n",
      "    \"Load(Program)\",\n",
      "    \"Compile(Options)\",\n",
      "    \"Save()\",\n",
      "    \"控制点条件表示法\",\n",
      "    \"ObjectA\",\n",
      "    \"ObjectB\",\n",
      "    \"ObjectC\",\n",
      "    \"Operation1\",\n",
      "    \"Operation2\",\n",
      "    \"GuardA\",\n",
      "    \"GuardB\",\n",
      "    \"组件\",\n",
      "    \"组件接口\",\n",
      "    \"依赖关系\",\n",
      "    \"替换组件\",\n",
      "    \"源代码组件\",\n",
      "    \"二进制目标码组件\",\n",
      "    \"可执行组件\",\n",
      "    \"文档组件\",\n",
      "    \"Calculator\",\n",
      "    \"组件实现\",\n",
      "    \"组件接口连接\",\n",
      "    \"版型化组件依赖关系\",\n",
      "    \"includes 版型\",\n",
      "    \"import 版型\",\n",
      "    \"implements 版型\",\n",
      "    \"Project.vbp\",\n",
      "    \"Global.bas\",\n",
      "    \"Collection.cls\",\n",
      "    \"接口矩形表示法\",\n",
      "    \"接口圆圈表示法\",\n",
      "    \"实现关系\",\n",
      "    \"Persistence\",\n",
      "    \"UserInterface\",\n",
      "    \"Save\",\n",
      "    \"Load\",\n",
      "    \"OpenDialog\",\n",
      "    \"FindDialog\",\n",
      "    \"EditDialog\",\n",
      "    \"extends 版型\",\n",
      "    \"部署图\",\n",
      "    \"配置图\",\n",
      "    \"物理配置情况\",\n",
      "    \"系统体系结构\",\n",
      "    \"组件部署\",\n",
      "    \"硬件联系\",\n",
      "    \"个人电脑PC\",\n",
      "    \"数据库服务器\",\n",
      "    \"VAX\",\n",
      "    \"服务器02\",\n",
      "    \"TCP/IP协议\",\n",
      "    \"DecNet协议\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"协作图\", \"属于\", \"练习内容\"],\n",
      "    [\"控制点条件\", \"属于\", \"协作图建模内容\"],\n",
      "    [\"组件图\", \"描述\", \"软件组件及依赖关系\"],\n",
      "    [\"组件\", \"属于\", \"组件图\"],\n",
      "    [\"组件接口\", \"与\", \"组件相关联\"],\n",
      "    [\"依赖关系\", \"属于\", \"组件图\"],\n",
      "    [\"版型化组件依赖关系\", \"属于\", \"依赖关系\"],\n",
      "    [\"接口矩形表示法\", \"和\", \"接口圆圈表示法\", \"都属于\", \"接口表示方法\"],\n",
      "    [\"Persistence\", \"包含于\", \"组件图\"],\n",
      "    [\"UserInterface\", \"包含于\", \"组件图\"],\n",
      "    [\"Save\", \"通过\", \"includes 版型\", \"关联于\", \"UserInterface\"],\n",
      "    [\"Load\", \"通过\", \"includes 版型\", \"关联于\", \"UserInterface\"],\n",
      "    [\"OpenDialog\", \"通过\", \"includes 版型\", \"关联于\", \"UserInterface\"],\n",
      "    [\"FindDialog\", \"通过\", \"includes 版型\", \"关联于\", \"UserInterface\"],\n",
      "    [\"EditDialog\", \"通过\", \"includes 版型\", \"关联于\", \"UserInterface\"],\n",
      "    [\"部署图\", \"也称为\", \"配置图\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "2089\n",
      "sleep:38.49717998756237秒\n",
      "————————————第81章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"部署图\",\n",
      "    \"配置图\",\n",
      "    \"物理配置情况\",\n",
      "    \"系统体系结构\",\n",
      "    \"组件在硬件上的部署\",\n",
      "    \"硬件之间的联系\",\n",
      "    \"系统拓扑的物理描述\",\n",
      "    \"节点\",\n",
      "    \"处理器\",\n",
      "    \"设备\",\n",
      "    \"计算机资源\",\n",
      "    \"外围硬件\",\n",
      "    \"接口\",\n",
      "    \"连接\",\n",
      "    \"物理连线\",\n",
      "    \"无线连接\",\n",
      "    \"通信关联\",\n",
      "    \"硬件间的通信\",\n",
      "    \"固化类型类\",\n",
      "    \"通信方法或协议\",\n",
      "    \"通用节点\",\n",
      "    \"实例化的节点\",\n",
      "    \"包图\",\n",
      "    \"类分组\",\n",
      "    \"命名空间\",\n",
      "    \"打包\",\n",
      "    \"文件夹图标\",\n",
      "    \"命名一个组\",\n",
      "    \"包的语法格式\",\n",
      "    \"对象\",\n",
      "    \"类名前追加名和双冒号\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"部署图\", \"属于\", \"系统设计\"],\n",
      "    [\"配置图\", \"等于\", \"部署图\"],\n",
      "    [\"物理配置情况\", \"包含于\", \"部署图\"],\n",
      "    [\"系统体系结构\", \"包含于\", \"部署图\"],\n",
      "    [\"组件在硬件上的部署\", \"描述于\", \"部署图\"],\n",
      "    [\"硬件之间的联系\", \"描述于\", \"部署图\"],\n",
      "    [\"节点\", \"是部署图中的元素\"],\n",
      "    [\"处理器\", \"是节点的一种类型\"],\n",
      "    [\"设备\", \"是节点的另一种类型\"],\n",
      "    [\"连接\", \"表示节点间的关系\", \"部署图\"],\n",
      "    [\"通信关联\", \"存在于\", \"部署图\"],\n",
      "    [\"通用节点\", \"在部署图中标识\"],\n",
      "    [\"实例化的节点\", \"在部署图中标识\"],\n",
      "    [\"包图\", \"与部署图并列\"],\n",
      "    [\"类分组\", \"通过\", \"包\"],\n",
      "    [\"命名空间\", \"由包提供\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "1584\n",
      "sleep:37.94944347729499秒\n",
      "————————————第82章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"包图\",\n",
      "    \"包\",\n",
      "    \"部署图\",\n",
      "    \"节点\",\n",
      "    \"实例化的节点\",\n",
      "    \"通信关联\",\n",
      "    \"泛化关系\",\n",
      "    \"依赖关系\",\n",
      "    \"细化关系\",\n",
      "    \"合并包\",\n",
      "    \"包之间的关系\",\n",
      "    \"包的表示方法\",\n",
      "    \"命名空间\",\n",
      "    \"全限定名\",\n",
      "    \"继承关系\",\n",
      "    \"包合并后的变换结果\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"包图\", \"包含\", \"包\"],\n",
      "    [\"包\", \"具有\", \"节点\"],\n",
      "    [\"部署图\", \"包含\", \"节点\"],\n",
      "    [\"实例化的节点\", \"属于\", \"节点\"],\n",
      "    [\"通信关联\", \"存在于\", \"部署图\"],\n",
      "    [\"泛化关系\", \"存在于\", \"包之间\"],\n",
      "    [\"依赖关系\", \"存在于\", \"包之间\"],\n",
      "    [\"细化关系\", \"存在于\", \"包之间\"],\n",
      "    [\"合并包\", \"是\", \"包之间的关系\"],\n",
      "    [\"包之间的关系\", \"包括\", \"泛化关系\"],\n",
      "    [\"包之间的关系\", \"包括\", \"依赖关系\"],\n",
      "    [\"包之间的关系\", \"包括\", \"细化关系\"],\n",
      "    [\"包的表示方法\", \"用于\", \"包\"],\n",
      "    [\"命名空间\", \"由\", \"包提供\"],\n",
      "    [\"全限定名\", \"在\", \"包合并后变换结果\"],\n",
      "    [\"继承关系\", \"在\", \"包合并后变换结果\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "请注意，由于文本中并未明确指出每个知识点间的“属于”关系，因此这里构建的关系基于知识点之间的逻辑联系和上下文语境。在原始文本中，“细化”、“泛化”、“依赖”等词语描述了包之间的关系，但没有直接说明“A 包属于 B 包”，故 JSON 中的关系表达遵循原文含义而非严格的“属于”关系。\n",
      "3262\n",
      "Error decoding JSON: Extra data: line 41 column 1 (char 676)\n",
      "sleep:38.14279250530295秒\n",
      "————————————第83章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"面向对象系统开发过程\",\n",
      "    \"基于 UML 的系统开发步骤\",\n",
      "    \"需求理解\",\n",
      "    \"系统分析\",\n",
      "    \"系统设计\",\n",
      "    \"系统实现\",\n",
      "    \"迭代开发的生命周期\",\n",
      "    \"用例建模\",\n",
      "    \"需求用例建模过程\",\n",
      "    \"业务参与者确定\",\n",
      "    \"用例图\",\n",
      "    \"类图\",\n",
      "    \"活动图\",\n",
      "    \"状态图\",\n",
      "    \"顺序图\",\n",
      "    \"协作图\",\n",
      "    \"部署图\",\n",
      "    \"组件图\",\n",
      "    \"对象图\",\n",
      "    \"测试脚本\",\n",
      "    \"用户界面原型\",\n",
      "    \"系统试运行\",\n",
      "    \"备份和恢复计划\",\n",
      "    \"系统边界界定\",\n",
      "    \"用例方法特点\",\n",
      "    \"用例定义系统功能使用环境\",\n",
      "    \"目标系统测试依据\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"基于 UML 的系统开发步骤\", \"属于\", \"面向对象系统开发过程\"],\n",
      "    [\"需求理解\", \"属于\", \"基于 UML 的系统开发步骤\"],\n",
      "    [\"系统分析\", \"属于\", \"基于 UML 的系统开发步骤\"],\n",
      "    [\"系统设计\", \"属于\", \"基于 UML 的系统开发步骤\"],\n",
      "    [\"系统实现\", \"属于\", \"基于 UML 的系统开发步骤\"],\n",
      "    [\"用例建模\", \"属于\", \"需求理解\"],\n",
      "    [\"需求用例建模过程\", \"属于\", \"需求理解\"],\n",
      "    [\"业务参与者确定\", \"属于\", \"需求用例建模过程\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "3441\n",
      "sleep:37.442278728738124秒\n",
      "————————————第84章————————————\n",
      "{ \"point\": [ \"理解需求\", \"用例建模\", \"系统边界\", \"业务参与者\", \"确定业务参与者\", \"系统功能的使用环境\", \"用例定义\", \"需求分析和设计分离\", \"目标系统测试\", \"构造需求用例模型\", \"业务需求用例\", \"用例模型图\", \"业务需求用例描述\", \"确定用例\", \"识别参与者\", \"必要用例\", \"用例抽取过程注意事项\", \"构造用例图\", \"用例关系\", \"泛化关系\", \"包含关系\", \"扩展关系\", \"用例说明\", \"简要说明\", \"用例场景\", \"事件流\", \"基本流\", \"备选流\", \"前置条件\", \"后置条件\", \"特殊需求\", \"用例图调整\", \"用例模型检查\", \"需求完备性检查\", \"简洁与重用性检查\", \"管理用例模型复杂度\", \"用例包\", \"电子培训系统的需求理解\", \"分析问题领域\" ],\n",
      "  \"edge\": [\n",
      "    [\"用例建模\", \"属于\", \"理解需求\"],\n",
      "    [\"系统边界\", \"属于\", \"理解需求\"],\n",
      "    [\"业务参与者\", \"属于\", \"理解需求\"],\n",
      "    [\"确定业务参与者\", \"属于\", \"理解需求\"],\n",
      "    [\"系统功能的使用环境\", \"属于\", \"理解需求\"],\n",
      "    [\"用例定义\", \"属于\", \"理解需求\"],\n",
      "    [\"需求分析和设计分离\", \"属于\", \"理解需求\"],\n",
      "    [\"目标系统测试\", \"属于\", \"理解需求\"],\n",
      "    [\"构造需求用例模型\", \"属于\", \"理解需求\"],\n",
      "    [\"业务需求用例\", \"属于\", \"构造需求用例模型\"],\n",
      "    [\"用例模型图\", \"属于\", \"构造需求用例模型\"],\n",
      "    [\"业务需求用例描述\", \"属于\", \"构造需求用例模型\"],\n",
      "    [\"确定用例\", \"属于\", \"理解需求\"],\n",
      "    [\"识别参与者\", \"属于\", \"确定业务参与者\"],\n",
      "    [\"必要用例\", \"属于\", \"确定用例\"],\n",
      "    [\"用例抽取过程注意事项\", \"属于\", \"确定用例\"],\n",
      "    [\"构造用例图\", \"属于\", \"理解需求\"],\n",
      "    [\"用例关系\", \"属于\", \"构造用例图\"],\n",
      "    [\"泛化关系\", \"属于\", \"用例关系\"],\n",
      "    [\"包含关系\", \"属于\", \"用例关系\"],\n",
      "    [\"扩展关系\", \"属于\", \"用例关系\"],\n",
      "    [\"用例说明\", \"属于\", \"理解需求\"],\n",
      "    [\"简要说明\", \"属于\", \"用例说明\"],\n",
      "    [\"用例场景\", \"属于\", \"用例说明\"],\n",
      "    [\"事件流\", \"属于\", \"用例场景\"],\n",
      "    [\"基本流\", \"属于\", \"事件流\"],\n",
      "    [\"备选流\", \"属于\", \"事件流\"],\n",
      "    [\"前置条件\", \"属于\", \"用例说明\"],\n",
      "    [\"后置条件\", \"属于\", \"用例说明\"],\n",
      "    [\"特殊需求\", \"属于\", \"用例说明\"],\n",
      "    [\"用例图调整\", \"属于\", \"理解需求\"],\n",
      "    [\"用例模型检查\", \"属于\", \"理解需求\"],\n",
      "    [\"需求完备性检查\", \"属于\", \"用例模型检查\"],\n",
      "    [\"简洁与重用性检查\", \"属于\", \"用例模型检查\"],\n",
      "    [\"管理用例模型复杂度\", \"属于\", \"理解需求\"],\n",
      "    [\"用例包\", \"属于\", \"管理用例模型复杂度\"],\n",
      "    [\"电子培训系统的需求理解\", \"属于\", \"理解需求\"],\n",
      "    [\"分析问题领域\", \"属于\", \"电子培训系统的需求理解\"]\n",
      "  ]\n",
      "}\n",
      "6721\n",
      "sleep:38.41495859087766秒\n",
      "————————————第85章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"用例模型\",\n",
      "    \"用例\",\n",
      "    \"参与者\",\n",
      "    \"用例包\",\n",
      "    \"管理用例模型复杂度\",\n",
      "    \"分析问题领域\",\n",
      "    \"用例图\",\n",
      "    \"教学管理\",\n",
      "    \"教务管理\",\n",
      "    \"系统服务\",\n",
      "    \"系统辅助功能\",\n",
      "    \"教学过程管理\",\n",
      "    \"课堂教学环境\",\n",
      "    \"网络学习环境\",\n",
      "    \"教案组织\",\n",
      "    \"自动教学\",\n",
      "    \"课堂教学\",\n",
      "    \"课终考试\",\n",
      "    \"教学活动信息管理\",\n",
      "    \"教学资源管理\",\n",
      "    \"教案管理\",\n",
      "    \"ABC e-Training 系统\",\n",
      "    \"系统范围和系统边界\",\n",
      "    \"财务系统\",\n",
      "    \"ABC e-Testing 系统\",\n",
      "    \"用户管理\",\n",
      "    \"培训点管理\",\n",
      "    \"辅助管理\",\n",
      "    \"教学活动\",\n",
      "    \"制作教案\",\n",
      "    \"查找/浏览教学资源\",\n",
      "    \"安装资源光盘\",\n",
      "    \"更新资源光盘\",\n",
      "    \"课堂测试\",\n",
      "    \"提问答疑\",\n",
      "    \"学生课前准备\",\n",
      "    \"课堂讨论\",\n",
      "    \"课堂练习\",\n",
      "    \"在线反馈\",\n",
      "    \"申请结业考试\",\n",
      "    \"参加考试\",\n",
      "    \"领取单次考试证书\",\n",
      "    \"换取综合证书\",\n",
      "    \"编辑电子教案\",\n",
      "    \"预览电子教案\",\n",
      "    \"修改电子教案\",\n",
      "    \"保存电子教案\",\n",
      "    \"上载电子教案\",\n",
      "    \"编辑电子教案用例\",\n",
      "    \"上载电子教案用例\",\n",
      "    \"预览电子教案用例\",\n",
      "    \"领域建模\",\n",
      "    \"发现类\",\n",
      "    \"类与对象\",\n",
      "    \"静态模型\",\n",
      "    \"动态行为模型\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"用例\", \"属于\", \"用例模型\"],\n",
      "    [\"参与者\", \"属于\", \"用例模型\"],\n",
      "    [\"用例包\", \"用于\", \"管理用例模型复杂度\"],\n",
      "    [\"分析问题领域\", \"属于\", \"需求理解阶段\"],\n",
      "    [\"用例图\", \"描绘\", \"用例模型\"],\n",
      "    [\"教学管理\", \"属于\", \"ABC e-Training 系统功能划分\"],\n",
      "    [\"教务管理\", \"属于\", \"ABC e-Training 系统功能划分\"],\n",
      "    [\"系统服务\", \"属于\", \"ABC e-Training 系统功能划分\"],\n",
      "    [\"系统辅助功能\", \"属于\", \"ABC e-Training 系统功能划分\"],\n",
      "    [\"教学过程管理\", \"包含\", \"课堂教学环境\"],\n",
      "    [\"教学过程管理\", \"包含\", \"网络学习环境\"],\n",
      "    [\"教学过程管理\", \"包含\", \"教案组织\"],\n",
      "    [\"教学过程管理\", \"包含\", \"自动教学\"],\n",
      "    [\"教学过程管理\", \"包含\", \"课堂教学\"],\n",
      "    [\"教学过程管理\", \"包含\", \"课终考试\"],\n",
      "    [\"教学过程管理\", \"包含\", \"教学活动信息管理\"],\n",
      "    [\"教学资源管理\", \"属于\", \"教学管理部分\"],\n",
      "    [\"教案管理\", \"属于\", \"教学管理部分\"],\n",
      "    [\"ABC e-Training 系统\", \"具有\", \"系统范围和系统边界\"],\n",
      "    [\"财务系统\", \"与\", \"ABC e-Training 系统存在系统边界\"],\n",
      "    [\"ABC e-Testing 系统\", \"与\", \"ABC e-Training 系统存在系统边界\"],\n",
      "    [\"用户管理\", \"是\", \"ABC e-Training 系统的用例\"],\n",
      "    [\"培训点管理\", \"是\", \"ABC e-Training 系统的用例\"],\n",
      "    [\"辅助管理\", \"是\", \"ABC e-Training 系统的用例\"],\n",
      "    [\"教学活动\", \"分解为\", \"制作教案子用例\"],\n",
      "    [\"制作教案\", \"进一步细化为\", \"编辑电子教案等子用例\"],\n",
      "    [\"编辑电子教案用例\", \"描述了\", \"编辑电子教案功能\"],\n",
      "    [\"上载电子教案用例\", \"描述了\", \"上载电子教案功能\"],\n",
      "    [\"预览电子教案用例\", \"描述了\", \"预览电子教案功能\"],\n",
      "    [\"发现类\", \"是\", \"领域建模的一部分\"],\n",
      "    [\"类与对象\", \"在\", \"领域建模中被识别\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "6625\n",
      "sleep:37.09350118474735秒\n",
      "————————————第86章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"领域建模\",\n",
      "    \"面向对象分析(OOA)\",\n",
      "    \"静态模型\",\n",
      "    \"动态行为模型\",\n",
      "    \"问题域\",\n",
      "    \"对象模型\",\n",
      "    \"类与对象\",\n",
      "    \"关联\",\n",
      "    \"属性\",\n",
      "    \"用例驱动方法\",\n",
      "    \"CRC 方法\",\n",
      "    \"名词短语方法\",\n",
      "    \"通用类模式方法\",\n",
      "    \"发现类\",\n",
      "    \"确定关联\",\n",
      "    \"确定属性\",\n",
      "    \"泛化关系\",\n",
      "    \"聚合关系\",\n",
      "    \"状态图\",\n",
      "    \"ATM系统案例\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"面向对象分析(OOA)\", \"属于\", \"领域建模\"],\n",
      "    [\"静态模型\", \"属于\", \"面向对象分析(OOA)\"],\n",
      "    [\"动态行为模型\", \"属于\", \"面向对象分析(OOA)\"],\n",
      "    [\"对象模型\", \"属于\", \"静态模型\"],\n",
      "    [\"关联\", \"属于\", \"静态模型\"],\n",
      "    [\"属性\", \"属于\", \"静态模型\"],\n",
      "    [\"用例驱动方法\", \"属于\", \"发现类的方法\"],\n",
      "    [\"CRC 方法\", \"属于\", \"发现类的方法\"],\n",
      "    [\"名词短语方法\", \"属于\", \"发现类的方法\"],\n",
      "    [\"通用类模式方法\", \"属于\", \"发现类的方法\"],\n",
      "    [\"确定关联\", \"属于\", \"面向对象分析(OOA)\"],\n",
      "    [\"确定属性\", \"属于\", \"面向对象分析(OOA)\"],\n",
      "    [\"泛化关系\", \"属于\", \"静态模型\"],\n",
      "    [\"聚合关系\", \"属于\", \"静态模型\"],\n",
      "    [\"状态图\", \"属于\", \"动态行为模型\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "7994\n",
      "sleep:37.70898828314256秒\n",
      "————————————第87章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"行为建模\",\n",
      "    \"系统分析阶段的行为建模\",\n",
      "    \"用例和对象类\",\n",
      "    \"静态结构\",\n",
      "    \"用户需求\",\n",
      "    \"系统目标\",\n",
      "    \"提取对象\",\n",
      "    \"对象类\",\n",
      "    \"用例分析\",\n",
      "    \"交互图\",\n",
      "    \"活动图\",\n",
      "    \"UML动态模型\",\n",
      "    \"状态模型\",\n",
      "    \"顺序模型\",\n",
      "    \"协作模型\",\n",
      "    \"活动建模\",\n",
      "    \"事件顺序\",\n",
      "    \"状态模型特点\",\n",
      "    \"对象生命周期\",\n",
      "    \"状态变迁\",\n",
      "    \"触发事件\",\n",
      "    \"动作\",\n",
      "    \"状态图\",\n",
      "    \"状态机\",\n",
      "    \"初始状态\",\n",
      "    \"终结状态\",\n",
      "    \"中间状态\",\n",
      "    \"状态转移\",\n",
      "    \"复印机状态转换图\",\n",
      "    \"楼层电梯状态图\",\n",
      "    \"订单处理与履行过程状态图\",\n",
      "    \"活动图描述\",\n",
      "    \"业务流程\",\n",
      "    \"业务对象\",\n",
      "    \"泳道\",\n",
      "    \"工作流的边界\",\n",
      "    \"活动状态\",\n",
      "    \"动作状态\",\n",
      "    \"复杂动作\",\n",
      "    \"活动状态展开\",\n",
      "    \"动作流\",\n",
      "    \"顺序动作流\",\n",
      "    \"条件分支\",\n",
      "    \"分支结合\",\n",
      "    \"对象流\",\n",
      "    \"信用账户开立活动图\",\n",
      "    \"顺序图\",\n",
      "    \"交互活动\",\n",
      "    \"参与对象\",\n",
      "    \"交互事件\",\n",
      "    \"生命线\",\n",
      "    \"激活期\",\n",
      "    \"同步消息\",\n",
      "    \"异步消息\",\n",
      "    \"循环结构\",\n",
      "    \"查找资源顺序图\",\n",
      "    \"网上商店客户订单处理系统\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"系统分析阶段的行为建模\", \"属于\", \"行为建模\"],\n",
      "    [\"用例和对象类\", \"属于\", \"系统分析阶段的行为建模\"],\n",
      "    [\"静态结构\", \"属于\", \"系统分析阶段的行为建模\"],\n",
      "    [\"用户需求\", \"属于\", \"系统分析阶段的行为建模\"],\n",
      "    [\"系统目标\", \"属于\", \"系统分析阶段的行为建模\"],\n",
      "    [\"提取对象\", \"属于\", \"系统分析阶段的行为建模\"],\n",
      "    [\"对象类\", \"属于\", \"系统分析阶段的行为建模\"],\n",
      "    [\"活动建模\", \"属于\", \"UML动态模型\"],\n",
      "    [\"状态模型\", \"属于\", \"UML动态模型\"],\n",
      "    [\"顺序模型\", \"属于\", \"UML动态模型\"],\n",
      "    [\"协作模型\", \"属于\", \"UML动态模型\"],\n",
      "    [\"状态图\", \"属于\", \"状态建模\"],\n",
      "    [\"状态机\", \"属于\", \"状态图\"],\n",
      "    [\"初始状态\", \"属于\", \"状态图\"],\n",
      "    [\"终结状态\", \"属于\", \"状态图\"],\n",
      "    [\"中间状态\", \"属于\", \"状态图\"],\n",
      "    [\"状态转移\", \"属于\", \"状态图\"],\n",
      "    [\"复印机状态转换图\", \"示例\", \"状态图\"],\n",
      "    [\"楼层电梯状态图\", \"练习\", \"状态图\"],\n",
      "    [\"订单处理与履行过程状态图\", \"练习\", \"状态图\"],\n",
      "    [\"活动图描述\", \"属于\", \"活动图\"],\n",
      "    [\"业务流程\", \"描述\", \"活动图\"],\n",
      "    [\"业务对象\", \"属于\", \"活动图\"],\n",
      "    [\"泳道\", \"属于\", \"活动图\"],\n",
      "    [\"工作流的边界\", \"确定\", \"活动图\"],\n",
      "    [\"活动状态\", \"属于\", \"活动图\"],\n",
      "    [\"动作状态\", \"属于\", \"活动图\"],\n",
      "    [\"复杂动作\", \"组成\", \"活动状态\"],\n",
      "    [\"活动状态展开\", \"用于\", \"复杂动作\"],\n",
      "    [\"动作流\", \"连接\", \"活动和动作状态\"],\n",
      "    [\"顺序动作流\", \"处理\", \"动作流\"],\n",
      "    [\"条件分支\", \"处理\", \"动作流\"],\n",
      "    [\"分支结合\", \"处理\", \"动作流\"],\n",
      "    [\"查找资源顺序图\", \"示例\", \"顺序图\"],\n",
      "    [\"网上商店客户订单处理系统\", \"案例分析\", \"行为建模\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "3784\n",
      "sleep:38.181856149573456秒\n",
      "————————————第88章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"案例——网上商店客户订单处理系统分析\",\n",
      "    \"用例图\",\n",
      "    \"活动图\",\n",
      "    \"类模型\",\n",
      "    \"顺序图\",\n",
      "    \"状态图\",\n",
      "    \"显示标准配置\",\n",
      "    \"建立组装配置\",\n",
      "    \"订购配置的计算机，询问销售人员\",\n",
      "    \"订购配置的计算机，确认并接受客户支付方式\",\n",
      "    \"通知仓库有新订单\",\n",
      "    \"订购配置的计算机，更新订单状态\",\n",
      "    \"客户\",\n",
      "    \"销售员\",\n",
      "    \"仓库\",\n",
      "    \"计算机（标准配置）\",\n",
      "    \"组装的计算机\",\n",
      "    \"配置项\",\n",
      "    \"订单\",\n",
      "    \"支付\",\n",
      "    \"发票\",\n",
      "    \"配送\",\n",
      "    \"ConfigurationWindow\",\n",
      "    \"Computer\",\n",
      "    \"StandardComputer\",\n",
      "    \"ConfiguredComputer\",\n",
      "    \"ConfigurationItem\",\n",
      "    \"Order\",\n",
      "    \"OrderWindow\",\n",
      "    \"Customer\",\n",
      "    \"Payment\",\n",
      "    \"发票状态图\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"案例——网上商店客户订单处理系统分析\", \"包含\", \"用例图\"],\n",
      "    [\"案例——网上商店客户订单处理系统分析\", \"包含\", \"活动图\"],\n",
      "    [\"案例——网上商店客户订单处理系统分析\", \"包含\", \"类模型\"],\n",
      "    [\"案例——网上商店客户订单处理系统分析\", \"包含\", \"顺序图\"],\n",
      "    [\"案例——网上商店客户订单处理系统分析\", \"包含\", \"状态图\"],\n",
      "    [\"用例图\", \"包含\", \"显示标准配置\"],\n",
      "    [\"用例图\", \"包含\", \"建立组装配置\"],\n",
      "    [\"用例图\", \"包含\", \"订购配置的计算机，询问销售人员\"],\n",
      "    [\"用例图\", \"包含\", \"订购配置的计算机，确认并接受客户支付方式\"],\n",
      "    [\"用例图\", \"包含\", \"通知仓库有新订单\"],\n",
      "    [\"用例图\", \"包含\", \"订购配置的计算机，更新订单状态\"],\n",
      "    [\"用例图\", \"参与者\", \"客户\"],\n",
      "    [\"用例图\", \"参与者\", \"销售员\"],\n",
      "    [\"用例图\", \"参与者\", \"仓库\"],\n",
      "    [\"类模型\", \"包含\", \"计算机（标准配置）\"],\n",
      "    [\"类模型\", \"包含\", \"组装的计算机\"],\n",
      "    [\"类模型\", \"包含\", \"配置项\"],\n",
      "    [\"类模型\", \"包含\", \"订单\"],\n",
      "    [\"类模型\", \"包含\", \"支付\"],\n",
      "    [\"类模型\", \"包含\", \"发票\"],\n",
      "    [\"类模型\", \"关联\", \"配送\"],\n",
      "    [\"顺序图\", \"涉及对象\", \"ConfigurationWindow\"],\n",
      "    [\"顺序图\", \"涉及对象\", \"Computer\"],\n",
      "    [\"顺序图\", \"涉及对象\", \"StandardComputer\"],\n",
      "    [\"顺序图\", \"涉及对象\", \"ConfiguredComputer\"],\n",
      "    [\"顺序图\", \"涉及对象\", \"ConfigurationItem\"],\n",
      "    [\"顺序图\", \"涉及对象\", \"Order\"],\n",
      "    [\"顺序图\", \"涉及对象\", \"OrderWindow\"],\n",
      "    [\"顺序图\", \"涉及对象\", \"Customer\"],\n",
      "    [\"顺序图\", \"涉及对象\", \"Payment\"],\n",
      "    [\"状态图\", \"描述对象\", \"发票\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "6872\n",
      "sleep:37.4018215676343秒\n",
      "————————————第89章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"系统设计与UML\",\n",
      "    \"面向对象设计\",\n",
      "    \"控制器\",\n",
      "    \"耦合\",\n",
      "    \"内聚\",\n",
      "    \"协作图\",\n",
      "    \"设计类图\",\n",
      "    \"组件图\",\n",
      "    \"部署图\",\n",
      "    \"关联\",\n",
      "    \"导航\",\n",
      "    \"包\",\n",
      "    \"泛化\",\n",
      "    \"聚合\",\n",
      "    \"通用职责分配软件模式(GRASP)\",\n",
      "    \"接口设计原则\",\n",
      "    \"包的设计原则\",\n",
      "    \"从UML图映射到数据库表的过程\",\n",
      "    \"关系约束检查策略\",\n",
      "    \"真实用例\",\n",
      "    \"报告\",\n",
      "    \"用户界面\",\n",
      "    \"系统体系结构\",\n",
      "    \"交互图\",\n",
      "    \"设计类图\",\n",
      "    \"数据库模式\",\n",
      "    \"协作图的绘制步骤\",\n",
      "    \"组件图\",\n",
      "    \"组件的复用性\",\n",
      "    \"组件间的联系\",\n",
      "    \"接口依赖\",\n",
      "    \"构造型\",\n",
      "    \"部署图\",\n",
      "    \"节点\",\n",
      "    \"联系\",\n",
      "    \"客户机/服务器结构\",\n",
      "    \"分布式系统\",\n",
      "    \"通用职责分配软件模式(GRASP)基本模式\",\n",
      "    \"信息专家模式\",\n",
      "    \"创建者模式\",\n",
      "    \"高内聚模式\",\n",
      "    \"低耦合模式\",\n",
      "    \"控制器模式\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"面向对象设计\", \"属于\", \"系统设计与UML\"],\n",
      "    [\"控制器\", \"属于\", \"面向对象设计\"],\n",
      "    [\"耦合\", \"属于\", \"面向对象设计\"],\n",
      "    [\"内聚\", \"属于\", \"面向对象设计\"],\n",
      "    [\"协作图\", \"属于\", \"面向对象设计\"],\n",
      "    [\"设计类图\", \"属于\", \"面向对象设计\"],\n",
      "    [\"组件图\", \"属于\", \"面向对象设计\"],\n",
      "    [\"部署图\", \"属于\", \"面向对象设计\"],\n",
      "    [\"关联\", \"属于\", \"面向对象设计\"],\n",
      "    [\"导航\", \"属于\", \"面向对象设计\"],\n",
      "    [\"包\", \"属于\", \"面向对象设计\"],\n",
      "    [\"泛化\", \"属于\", \"面向对象设计\"],\n",
      "    [\"聚合\", \"属于\", \"面向对象设计\"],\n",
      "    [\"通用职责分配软件模式(GRASP)\", \"属于\", \"系统设计与UML\"],\n",
      "    [\"接口设计原则\", \"属于\", \"系统设计与UML\"],\n",
      "    [\"包的设计原则\", \"属于\", \"系统设计与UML\"],\n",
      "    [\"从UML图映射到数据库表的过程\", \"属于\", \"系统设计与UML\"],\n",
      "    [\"关系约束检查策略\", \"属于\", \"系统设计与UML\"],\n",
      "    [\"真实用例\", \"属于\", \"系统设计的主要任务\"],\n",
      "    [\"报告\", \"属于\", \"系统设计的主要任务\"],\n",
      "    [\"用户界面\", \"属于\", \"系统设计的主要任务\"],\n",
      "    [\"系统体系结构\", \"属于\", \"系统设计的主要任务\"],\n",
      "    [\"交互图\", \"属于\", \"系统设计的主要任务\"],\n",
      "    [\"设计类图\", \"属于\", \"系统设计的主要任务\"],\n",
      "    [\"数据库模式\", \"属于\", \"系统设计的主要任务\"],\n",
      "    [\"协作图的绘制步骤\", \"属于\", \"协作图\"],\n",
      "    [\"组件图\", \"属于\", \"系统设计与UML\"],\n",
      "    [\"组件的复用性\", \"属于\", \"组件图\"],\n",
      "    [\"组件间的联系\", \"属于\", \"组件图\"],\n",
      "    [\"接口依赖\", \"属于\", \"组件图\"],\n",
      "    [\"部署图\", \"属于\", \"系统设计与UML\"],\n",
      "    [\"信息专家模式\", \"属于\", \"通用职责分配软件模式(GRASP)\"],\n",
      "    [\"创建者模式\", \"属于\", \"通用职责分配软件模式(GRASP)\"],\n",
      "    [\"高内聚模式\", \"属于\", \"通用职责分配软件模式(GRASP)\"],\n",
      "    [\"低耦合模式\", \"属于\", \"通用职责分配软件模式(GRASP)\"],\n",
      "    [\"控制器模式\", \"属于\", \"通用职责分配软件模式(GRASP)\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "4257\n",
      "sleep:37.68401725871818秒\n",
      "————————————第90章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"通用职责分配软件模式\",\n",
      "    \"GRASP\",\n",
      "    \"知道型职责\",\n",
      "    \"做型职责\",\n",
      "    \"信息专家模式\",\n",
      "    \"创建者模式\",\n",
      "    \"高内聚模式\",\n",
      "    \"低耦合模式\",\n",
      "    \"控制器模式\",\n",
      "    \"全局控制器\",\n",
      "    \"局部控制器\",\n",
      "    \"低耦合原则\",\n",
      "    \"高内聚原则\",\n",
      "    \"实体类\",\n",
      "    \"接口类\",\n",
      "    \"控制类\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"GRASP\", \"属于\", \"通用职责分配软件模式\"],\n",
      "    [\"知道型职责\", \"属于\", \"通用职责分配软件模式\"],\n",
      "    [\"做型职责\", \"属于\", \"通用职责分配软件模式\"],\n",
      "    [\"信息专家模式\", \"属于\", \"GRASP\"],\n",
      "    [\"创建者模式\", \"属于\", \"GRASP\"],\n",
      "    [\"高内聚模式\", \"属于\", \"GRASP\"],\n",
      "    [\"低耦合模式\", \"属于\", \"GRASP\"],\n",
      "    [\"控制器模式\", \"属于\", \"GRASP\"],\n",
      "    [\"全局控制器\", \"属于\", \"控制器模式\"],\n",
      "    [\"局部控制器\", \"属于\", \"控制器模式\"],\n",
      "    [\"低耦合原则\", \"属于\", \"低耦合模式\"],\n",
      "    [\"高内聚原则\", \"属于\", \"高内聚模式\"],\n",
      "    [\"实体类\", \"属于\", \"面向对象设计\"],\n",
      "    [\"接口类\", \"属于\", \"面向对象设计\"],\n",
      "    [\"控制类\", \"属于\", \"面向对象设计\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "4249\n",
      "sleep:38.25862640330727秒\n",
      "————————————第91章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"类的设计\",\n",
      "    \"高内聚模式\",\n",
      "    \"聚合度\",\n",
      "    \"Payment\",\n",
      "    \"POST\",\n",
      "    \"Sale\",\n",
      "    \"makePayment()\",\n",
      "    \"create()\",\n",
      "    \"addPayment()\",\n",
      "    \"实体类\",\n",
      "    \"接口类\",\n",
      "    \"控制类\",\n",
      "    \"持久存储体\",\n",
      "    \"数据库\",\n",
      "    \"文件\",\n",
      "    \"事件流\",\n",
      "    \"交互图\",\n",
      "    \"界面\",\n",
      "    \"窗口\",\n",
      "    \"对话框\",\n",
      "    \"屏幕\",\n",
      "    \"接口程序\",\n",
      "    \"业务规则逻辑\",\n",
      "    \"消息协调\",\n",
      "    \"顺序\",\n",
      "    \"面向对象设计类\",\n",
      "    \"依赖关系\",\n",
      "    \"导航能力\",\n",
      "    \"双向关联\",\n",
      "    \"单向关联\",\n",
      "    \"用户认证\",\n",
      "    \"密码修改\",\n",
      "    \"可见性\",\n",
      "    \"公共可见性\",\n",
      "    \"保护可见性\",\n",
      "    \"私有可见性\",\n",
      "    \"对象责任\",\n",
      "    \"协作\",\n",
      "    \"设计类图\",\n",
      "    \"协作图\",\n",
      "    \"概念模型\",\n",
      "    \"属性\",\n",
      "    \"方法\",\n",
      "    \"消息传递\",\n",
      "    \"导航箭头\",\n",
      "    \"关联\",\n",
      "    \"角色\",\n",
      "    \"单项连接\",\n",
      "    \"接口设计\",\n",
      "    \"封装\",\n",
      "    \"操作\",\n",
      "    \"组件\",\n",
      "    \"实现（realization）\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"高内聚模式\", \"属于\", \"类的设计\"],\n",
      "    [\"Payment\", \"属于\", \"类的设计\"],\n",
      "    [\"POST\", \"属于\", \"类的设计\"],\n",
      "    [\"Sale\", \"属于\", \"类的设计\"],\n",
      "    [\"makePayment()\", \"属于\", \"Payment\"],\n",
      "    [\"create()\", \"属于\", \"Payment\"],\n",
      "    [\"addPayment()\", \"属于\", \"Payment\"],\n",
      "    [\"实体类\", \"属于\", \"类的设计\"],\n",
      "    [\"接口类\", \"属于\", \"类的设计\"],\n",
      "    [\"控制类\", \"属于\", \"类的设计\"],\n",
      "    [\"持久存储体\", \"属于\", \"实体类\"],\n",
      "    [\"数据库\", \"属于\", \"持久存储体\"],\n",
      "    [\"文件\", \"属于\", \"持久存储体\"],\n",
      "    [\"接口类\", \"与\", \"系统与外界交界处\"],\n",
      "    [\"控制类\", \"协调\", \"接口类和实体类之间的消息\"],\n",
      "    [\"依赖关系\", \"属于\", \"设计类\"],\n",
      "    [\"导航能力\", \"属于\", \"设计类\"],\n",
      "    [\"可见性\", \"属于\", \"设计类\"],\n",
      "    [\"对象责任\", \"属于\", \"设计类\"],\n",
      "    [\"设计类图\", \"属于\", \"类的设计\"],\n",
      "    [\"协作图\", \"用于\", \"设计类图的创建\"],\n",
      "    [\"概念模型\", \"用于\", \"设计类图的创建\"],\n",
      "    [\"单项连接\", \"属于\", \"导航\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "3592\n",
      "sleep:38.607797910491556秒\n",
      "————————————第92章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"接口设计\",\n",
      "    \"面向对象设计\",\n",
      "    \"封装\",\n",
      "    \"类的接口\",\n",
      "    \"操作实现\",\n",
      "    \"控制按钮\",\n",
      "    \"接口与实现分离\",\n",
      "    \"面向接口编程\",\n",
      "    \"组件\",\n",
      "    \"提供接口\",\n",
      "    \"需求接口\",\n",
      "    \"供需关系\",\n",
      "    \"组件复用\",\n",
      "    \"组件替换\",\n",
      "    \"单个对象的接口设计\",\n",
      "    \"业务规则计算对象\",\n",
      "    \"业务逻辑处理对象\",\n",
      "    \"接口抽取\",\n",
      "    \"接口实现类\",\n",
      "    \"多个对象的接口设计\",\n",
      "    \"实体对象\",\n",
      "    \"行为模式\",\n",
      "    \"增删改查\",\n",
      "    \"抽象类\",\n",
      "    \"约束子类\",\n",
      "    \"相同行为提取\",\n",
      "    \"层次之间接口设计\",\n",
      "    \"应用架构分层\",\n",
      "    \"门面模式\",\n",
      "    \"减少交互复杂度\",\n",
      "    \"包设计\",\n",
      "    \"包的作用\",\n",
      "    \"自顶向下原则\",\n",
      "    \"职责集中原则\",\n",
      "    \"互不交叉原则\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"接口设计\", \"属于\", \"面向对象设计\"],\n",
      "    [\"封装\", \"属于\", \"面向对象设计\"],\n",
      "    [\"类的接口\", \"属于\", \"接口设计\"],\n",
      "    [\"操作实现\", \"属于\", \"类的接口\"],\n",
      "    [\"提供接口\", \"属于\", \"接口设计\"],\n",
      "    [\"需求接口\", \"属于\", \"接口设计\"],\n",
      "    [\"单个对象的接口设计\", \"属于\", \"接口设计\"],\n",
      "    [\"多个对象的接口设计\", \"属于\", \"接口设计\"],\n",
      "    [\"层次之间接口设计\", \"属于\", \"接口设计\"],\n",
      "    [\"包设计\", \"属于\", \"整体系统设计\"],\n",
      "    [\"自顶向下原则\", \"属于\", \"包设计\"],\n",
      "    [\"职责集中原则\", \"属于\", \"包设计\"],\n",
      "    [\"互不交叉原则\", \"属于\", \"包设计\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "2373\n",
      "sleep:38.50580306624263秒\n",
      "————————————第93章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"包设计\",\n",
      "    \"包\",\n",
      "    \"自顶向下原则\",\n",
      "    \"职责集中原则\",\n",
      "    \"互不交叉原则\",\n",
      "    \"分包设计原则\",\n",
      "    \"软件层次包\",\n",
      "    \"软件模块包\",\n",
      "    \"软件代码包\",\n",
      "    \"用例驱动的开发模式\",\n",
      "    \"业务用例\",\n",
      "    \"系统用例\",\n",
      "    \"软件架构和框架\",\n",
      "    \"软件层次包设计步骤\",\n",
      "    \"软件模块包设计\",\n",
      "    \"数据库设计\",\n",
      "    \"UML 类图映射为库表的原则\",\n",
      "    \"类和属性的实现\",\n",
      "    \"OID（对象标识符）\",\n",
      "    \"派生属性\",\n",
      "    \"多值属性\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"包设计\", \"包含\", \"包\"],\n",
      "    [\"包设计\", \"包含\", \"自顶向下原则\"],\n",
      "    [\"包设计\", \"包含\", \"职责集中原则\"],\n",
      "    [\"包设计\", \"包含\", \"互不交叉原则\"],\n",
      "    [\"包设计\", \"包含\", \"分包设计原则\"],\n",
      "    [\"分包设计原则\", \"包含\", \"自顶向下原则\"],\n",
      "    [\"分包设计原则\", \"包含\", \"职责集中原则\"],\n",
      "    [\"分包设计原则\", \"包含\", \"互不交叉原则\"],\n",
      "    [\"包设计\", \"包含\", \"软件层次包\"],\n",
      "    [\"包设计\", \"包含\", \"软件模块包\"],\n",
      "    [\"包设计\", \"包含\", \"软件代码包\"],\n",
      "    [\"软件模块包\", \"基于\", \"用例驱动的开发模式\"],\n",
      "    [\"用例驱动的开发模式\", \"包含\", \"业务用例\"],\n",
      "    [\"用例驱动的开发模式\", \"包含\", \"系统用例\"],\n",
      "    [\"包设计\", \"涉及\", \"软件架构和框架\"],\n",
      "    [\"包设计步骤\", \"包括\", \"设计软件层次包\"],\n",
      "    [\"包设计步骤\", \"包括\", \"设计软件模块包\"],\n",
      "    [\"包设计步骤\", \"包括\", \"设计软件代码包\"],\n",
      "    [\"数据库设计\", \"相关\", \"UML 类图映射为库表的原则\"],\n",
      "    [\"UML 类图映射为库表的原则\", \"涵盖\", \"类和属性的实现\"],\n",
      "    [\"类和属性的实现\", \"提及\", \"OID（对象标识符）\"],\n",
      "    [\"类和属性的实现\", \"处理\", \"派生属性\"],\n",
      "    [\"类和属性的实现\", \"处理\", \"多值属性\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "2917\n",
      "sleep:38.1836765618511秒\n",
      "————————————第94章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"数据库设计\",\n",
      "    \"软件层次包\",\n",
      "    \"设计代码包\",\n",
      "    \"类和属性的实现\",\n",
      "    \"关联的实现\",\n",
      "    \"1对1关联的实现\",\n",
      "    \"1对多关联的实现\",\n",
      "    \"多对多关联的实现\",\n",
      "    \"泛化的实现\",\n",
      "    \"聚合的实现\",\n",
      "    \"递归关联的实现\",\n",
      "    \"关系约束检查策略\",\n",
      "    \"父表操作的约束\",\n",
      "    \"子表操作的约束\",\n",
      "    \"UML类图映射为库表的原则\",\n",
      "    \"UML类图映射为数据库表的过程\",\n",
      "    \"主键唯一性策略选取\",\n",
      "    \"OID作为主键\",\n",
      "    \"派生属性映射\",\n",
      "    \"多值属性映射\",\n",
      "    \"域的使用\",\n",
      "    \"外键实现关联\",\n",
      "    \"强制（Mandatory）-可选（Optional）关联\",\n",
      "    \"继承的实现策略\",\n",
      "    \"单个数据库表映射策略\",\n",
      "    \"每个具体子类映射成单个数据库表策略\",\n",
      "    \"每个类均映射为数据库表策略\",\n",
      "    \"共享聚合的实现\",\n",
      "    \"组成聚合的实现\",\n",
      "    \"对象标识符OID\",\n",
      "    \"类之间的静态结构\",\n",
      "    \"报表操作\",\n",
      "    \"性能因素\",\n",
      "    \"完整性问题\",\n",
      "    \"冗余问题\",\n",
      "    \"数据表示不匹配\",\n",
      "    \"对象—关系服务\",\n",
      "    \"标准建模语言UML\",\n",
      "    \"类图与表的对应关系\",\n",
      "    \"UML类图到表的映射原则\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"类和属性的实现\", \"属于\", \"数据库设计\"],\n",
      "    [\"关联的实现\", \"属于\", \"数据库设计\"],\n",
      "    [\"1对1关联的实现\", \"属于\", \"关联的实现\"],\n",
      "    [\"1对多关联的实现\", \"属于\", \"关联的实现\"],\n",
      "    [\"多对多关联的实现\", \"属于\", \"关联的实现\"],\n",
      "    [\"泛化的实现\", \"属于\", \"数据库设计\"],\n",
      "    [\"聚合的实现\", \"属于\", \"数据库设计\"],\n",
      "    [\"递归关联的实现\", \"属于\", \"关联的实现\"],\n",
      "    [\"关系约束检查策略\", \"属于\", \"数据库设计\"],\n",
      "    [\"父表操作的约束\", \"属于\", \"关系约束检查策略\"],\n",
      "    [\"子表操作的约束\", \"属于\", \"关系约束检查策略\"],\n",
      "    [\"UML类图映射为库表的原则\", \"属于\", \"数据库设计\"],\n",
      "    [\"UML类图映射为数据库表的过程\", \"属于\", \"数据库设计\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "5967\n",
      "sleep:37.95912007051283秒\n",
      "————————————第95章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"面向对象实现\",\n",
      "    \"面向对象实现的两项工作\",\n",
      "    \"设计映射到代码\",\n",
      "    \"将设计类图到类的定义\",\n",
      "    \"从协作图到类方法的转换\",\n",
      "    \"类的定义\",\n",
      "    \"引用属性\",\n",
      "    \"简单属性\",\n",
      "    \"根据设计类图创建类的定义\",\n",
      "    \"Java 定义的 SalesLineItem 类\",\n",
      "    \"Subtotal 方法\",\n",
      "    \"引用属性的推导\",\n",
      "    \"协作图\",\n",
      "    \"根据协作图创建方法\",\n",
      "    \"POST 类\",\n",
      "    \"enterItem 协作图与 Java 方法定义\",\n",
      "    \"面向对象程序设计\",\n",
      "    \"良好的程序设计风格\",\n",
      "    \"可重用原则\",\n",
      "    \"提高方法内聚\",\n",
      "    \"减小方法规模\",\n",
      "    \"保持方法一致性\",\n",
      "    \"策略与实现分开\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"面向对象实现\",\"包括\",\"面向对象实现的两项工作\"],\n",
      "    [\"设计映射到代码\",\"属于\",\"面向对象实现的两项工作\"],\n",
      "    [\"将设计类图到类的定义\",\"属于\",\"设计映射到代码\"],\n",
      "    [\"从协作图到类方法的转换\",\"属于\",\"设计映射到代码\"],\n",
      "    [\"Java 定义的 SalesLineItem 类\",\"属于\",\"将设计类图到类的定义\"],\n",
      "    [\"Subtotal 方法\",\"属于\",\"Java 定义的 SalesLineItem 类\"],\n",
      "    [\"引用属性\",\"属于\",\"类的定义\"],\n",
      "    [\"简单属性\",\"属于\",\"类的定义\"],\n",
      "    [\"根据设计类图创建类的定义\",\"属于\",\"设计映射到代码\"],\n",
      "    [\"enterItem 协作图与 Java 方法定义\",\"属于\",\"根据协作图创建方法\"],\n",
      "    [\"面向对象程序设计\",\"在面向对象实现之后\"],\n",
      "    [\"可重用原则\",\"属于\",\"面向对象程序设计\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "2534\n",
      "sleep:38.17944646394617秒\n",
      "————————————第96章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"面向对象程序设计\",\n",
      "    \"良好的程序设计风格\",\n",
      "    \"可重用原则\",\n",
      "    \"提高方法的内聚\",\n",
      "    \"减小方法的规模\",\n",
      "    \"保持方法的一致性\",\n",
      "    \"策略与实现分开\",\n",
      "    \"全面覆盖\",\n",
      "    \"尽量不使用全局信息\",\n",
      "    \"利用继承机制\",\n",
      "    \"可扩充原则\",\n",
      "    \"封装实现策略\",\n",
      "    \"不要用一个方法遍历多条关联链\",\n",
      "    \"避免使用多分支语句\",\n",
      "    \"精心确定公有方法\",\n",
      "    \"健壮性原则\",\n",
      "    \"预防用户的操作错误\",\n",
      "    \"检查参数的合法性\",\n",
      "    \"不要预先确定限制条件\",\n",
      "    \"先测试后优化\",\n",
      "    \"面向对象测试策略\",\n",
      "    \"多态\",\n",
      "    \"继承\",\n",
      "    \"封装\",\n",
      "    \"面向对象软件测试层次\",\n",
      "    \"类测试\",\n",
      "    \"集成测试\",\n",
      "    \"系统测试\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"可重用原则\", \"属于\", \"面向对象程序设计\"],\n",
      "    [\"提高方法的内聚\", \"属于\", \"可重用原则\"],\n",
      "    [\"减小方法的规模\", \"属于\", \"可重用原则\"],\n",
      "    [\"保持方法的一致性\", \"属于\", \"可重用原则\"],\n",
      "    [\"策略与实现分开\", \"属于\", \"可重用原则\"],\n",
      "    [\"全面覆盖\", \"属于\", \"可重用原则\"],\n",
      "    [\"尽量不使用全局信息\", \"属于\", \"可重用原则\"],\n",
      "    [\"利用继承机制\", \"属于\", \"可重用原则\"],\n",
      "    [\"可扩充原则\", \"属于\", \"面向对象程序设计\"],\n",
      "    [\"封装实现策略\", \"属于\", \"可扩充原则\"],\n",
      "    [\"不要用一个方法遍历多条关联链\", \"属于\", \"可扩充原则\"],\n",
      "    [\"避免使用多分支语句\", \"属于\", \"可扩充原则\"],\n",
      "    [\"精心确定公有方法\", \"属于\", \"可扩充原则\"],\n",
      "    [\"健壮性原则\", \"属于\", \"面向对象程序设计\"],\n",
      "    [\"预防用户的操作错误\", \"属于\", \"健壮性原则\"],\n",
      "    [\"检查参数的合法性\", \"属于\", \"健壮性原则\"],\n",
      "    [\"不要预先确定限制条件\", \"属于\", \"健壮性原则\"],\n",
      "    [\"先测试后优化\", \"属于\", \"健壮性原则\"],\n",
      "    [\"面向对象测试策略\", \"属于\", \"面向对象程序设计\"],\n",
      "    [\"类测试\", \"属于\", \"面向对象软件测试层次\"],\n",
      "    [\"集成测试\", \"属于\", \"面向对象软件测试层次\"],\n",
      "    [\"系统测试\", \"属于\", \"面向对象软件测试层次\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "3050\n",
      "sleep:37.711308753463506秒\n",
      "————————————第97章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"面向对象测试策略\",\n",
      "    \"检查数据和参数\",\n",
      "    \"动态内存分配\",\n",
      "    \"先测试后优化\",\n",
      "    \"面向对象特点\",\n",
      "    \"多态\",\n",
      "    \"继承\",\n",
      "    \"封装\",\n",
      "    \"安全性\",\n",
      "    \"代码重用率\",\n",
      "    \"软件测试难度\",\n",
      "    \"传统软件测试技术\",\n",
      "    \"输入/处理/输出角度\",\n",
      "    \"面向对象程序设计\",\n",
      "    \"对象\",\n",
      "    \"属性(数据)\",\n",
      "    \"方法(操作)\",\n",
      "    \"封装体\",\n",
      "    \"面向对象测试层次\",\n",
      "    \"类测试\",\n",
      "    \"集成测试\",\n",
      "    \"系统测试\",\n",
      "    \"传统层次测试\",\n",
      "    \"继承关系\",\n",
      "    \"组装关系\",\n",
      "    \"测试计划\",\n",
      "    \"测试用例\",\n",
      "    \"执行测试\",\n",
      "    \"评价阶段\",\n",
      "    \"单元测试\",\n",
      "    \"类作为最小可测试单位\",\n",
      "    \"类测试内容\",\n",
      "    \"验证类实现与规格说明一致性\",\n",
      "    \"基于服务的测试\",\n",
      "    \"基于状态的测试\",\n",
      "    \"基于响应状态的测试\",\n",
      "    \"类测试方法举例\",\n",
      "    \"基于状态图的测试\",\n",
      "    \"基于活动图的测试\",\n",
      "    \"基于协作图的测试\",\n",
      "    \"基于状态模式的测试\",\n",
      "    \"集成测试\",\n",
      "    \"类间协作测试\",\n",
      "    \"基于场景的测试\",\n",
      "    \"用户行为\",\n",
      "    \"不正确的规约\",\n",
      "    \"子系统交互错误\",\n",
      "    \"行为测试\",\n",
      "    \"状态转换图\",\n",
      "    \"类的状态图\",\n",
      "    \"系统测试\",\n",
      "    \"用户需求为测试标准\",\n",
      "    \"面向对象分析结果\",\n",
      "    \"整体行为表现\",\n",
      "    \"开发设计再确认\",\n",
      "    \"测试大纲法\",\n",
      "    \"用例法\",\n",
      "    \"操作场景\",\n",
      "    \"回归测试\",\n",
      "    \"层次增量方式\",\n",
      "    \"测试用例推导\",\n",
      "    \"用例驱动开发模式\",\n",
      "    \"确定测试用例场景\",\n",
      "    \"前置条件\",\n",
      "    \"后置条件\",\n",
      "    \"ATM取款用例\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"面向对象测试策略\", \"属于\", \"面向对象\"],\n",
      "    [\"检查数据和参数\", \"属于\", \"面向对象测试策略\"],\n",
      "    [\"动态内存分配\", \"属于\", \"面向对象测试策略\"],\n",
      "    [\"先测试后优化\", \"属于\", \"面向对象测试策略\"],\n",
      "    [\"面向对象特点\", \"属于\", \"面向对象\"],\n",
      "    [\"多态\", \"属于\", \"面向对象特点\"],\n",
      "    [\"继承\", \"属于\", \"面向对象特点\"],\n",
      "    [\"封装\", \"属于\", \"面向对象特点\"],\n",
      "    [\"类测试\", \"属于\", \"面向对象测试层次\"],\n",
      "    [\"集成测试\", \"属于\", \"面向对象测试层次\"],\n",
      "    [\"系统测试\", \"属于\", \"面向对象测试层次\"],\n",
      "    [\"基于服务的测试\", \"属于\", \"类测试内容\"],\n",
      "    [\"基于状态的测试\", \"属于\", \"类测试内容\"],\n",
      "    [\"基于响应状态的测试\", \"属于\", \"类测试内容\"],\n",
      "    [\"基于场景的测试\", \"属于\", \"集成测试\"],\n",
      "    [\"行为测试\", \"属于\", \"集成测试\"],\n",
      "    [\"系统测试\", \"属于\", \"面向对象测试策略\"],\n",
      "    [\"回归测试\", \"属于\", \"面向对象测试策略\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "3066\n",
      "sleep:38.28616557154727秒\n",
      "————————————第98章————————————\n",
      "```json\n",
      "{\n",
      "  \"point\": [\n",
      "    \"基于场景的测试\",\n",
      "    \"行为测试\",\n",
      "    \"系统测试\",\n",
      "    \"面向对象的系统测试\",\n",
      "    \"回归测试\",\n",
      "    \"层次增量的测试模型\",\n",
      "    \"设计测试用例\",\n",
      "    \"确定测试用例场景\",\n",
      "    \"前置条件\",\n",
      "    \"后置条件\",\n",
      "    \"测试执行路径\",\n",
      "    \"测试优先级\",\n",
      "    \"测试用例设计\",\n",
      "    \"面向对象实现\",\n",
      "    \"面向对象测试目标\",\n",
      "    \"类的单元测试\",\n",
      "    \"基于线程或基于使用的集成测试\",\n",
      "    \"确认测试\",\n",
      "    \"基于情景的测试\"\n",
      "  ],\n",
      "  \"edge\": [\n",
      "    [\"基于场景的测试\", \"属于\", \"设计测试用例\"],\n",
      "    [\"行为测试\", \"属于\", \"设计测试用例\"],\n",
      "    [\"系统测试\", \"属于\", \"设计测试用例\"],\n",
      "    [\"面向对象的系统测试\", \"属于\", \"系统测试\"],\n",
      "    [\"回归测试\", \"属于\", \"设计测试用例\"],\n",
      "    [\"层次增量的测试模型\", \"属于\", \"回归测试\"],\n",
      "    [\"确定测试用例场景\", \"属于\", \"设计测试用例\"],\n",
      "    [\"前置条件\", \"属于\", \"确定测试用例场景\"],\n",
      "    [\"后置条件\", \"属于\", \"确定测试用例场景\"],\n",
      "    [\"测试执行路径\", \"属于\", \"设计测试用例\"],\n",
      "    [\"测试优先级\", \"属于\", \"设计测试用例\"],\n",
      "    [\"测试用例设计\", \"属于\", \"设计测试用例\"],\n",
      "    [\"面向对象实现\", \"提及\", \"本章小结\"],\n",
      "    [\"面向对象测试目标\", \"属于\", \"面向对象测试\"],\n",
      "    [\"类的单元测试\", \"属于\", \"面向对象测试\"],\n",
      "    [\"基于线程或基于使用的集成测试\", \"属于\", \"面向对象测试\"],\n",
      "    [\"确认测试\", \"属于\", \"面向对象测试\"],\n",
      "    [\"基于情景的测试\", \"属于\", \"面向对象测试\"]\n",
      "  ]\n",
      "}\n",
      "```\n",
      "2850\n",
      "sleep:38.29227009282259秒\n"
     ]
    }
   ],
   "source": [
    "\n",
    "node_array=copy.copy(part_array)\n",
    "debug_array=[]\n",
    "part_name=\"\"\n",
    "prompt = f\"\"\"\n",
    "    在接下来的对话中，你需要遵循以下规则：\n",
    "    你是一个擅长读书并总结的人，你的任务是处理我上传的课本选段，并按照以下要求进行操作：\n",
    "    - 输出标准JSON格式字符串。\n",
    "    - 剔除文件中的所有乱码（乱码不包括英文）。\n",
    "    - 处理英文的时候 请保留英文的原格式，包括括号。\n",
    "    - 我会告诉你这段文字的主题，你可以围绕着这个主题开始一层一层地梳理知识结构\n",
    "    - 你需要对文本内知识点进行提取，并列成列表，形成json字符串的point字段。\n",
    "    - 当你提取到一个知识点，在上下文寻找与他相关联的知识点，并进行提取\n",
    "    - 你需要对知识点与知识点之间的属于关系进行提取，将有属于关系的知识点两两之间形成(知识点1,属于，知识点2)的元组，并以列表的形式存进json字符串的edge字段\n",
    "    - 像\"一\"、\"二\"或是\"第一\"、\"第二\"等形式的序号字符，可用于帮助定位实体。标题之间的层级结构，也可以帮助构建属于关系。\n",
    "    - 这一节的名字叫{part_name},请围绕{part_name}进行知识点提取和属于关系识别\n",
    "    - 格式参考示例:\n",
    "    {{\n",
    "        \"point\": [\"数学\",\"线性代数\",\"矩阵\"],\n",
    "        \"edge\":[[\"线性代数\",\"属于\",\"数学\"],[\"矩阵\",\"属于\",\"线性代数\"]]\n",
    "    }}\n",
    "    - 请保证仅提取属于关系，被提取出的知识点一定有相应的关系。\n",
    "    你不需要确认收到，或是做出过多解释，直接开始生成完整准确的输出。\n",
    "\"\"\"\n",
    "    # 下面这段原本是写在提示词里面的，表征上下文，但是由于我们将提取目录中，构建关系的部分删去了，这部分写入提示词会导致边生成不出来，故注释掉\n",
    "    # - 同时你可以参考上下文中已经提取好的实例和关系,在生成答案的时候，你必须保证这些实例和关系不能改变，只能在这些基础之上新增实体和关系：\n",
    "    # {{\n",
    "    #     \"point\": {nodes_array},\n",
    "    #     \"edge\":  {edges_array}\n",
    "    # }}\n",
    "    # 实测加了这段话生成的内容边多了，但是很杂，影响最后生成结果且会造成各种生成的答案格式不正确等问题；但是理论上来说，我们需要上下文提示，下一期工程再改吧\n",
    "for i in range(0,len(pages_array)-1):\n",
    "    print(\"————————————第\"+str(i+1)+\"章————————————\")\n",
    "    start=pages_array[i]\n",
    "    end=pages_array[i+1]\n",
    "    part_name=pages_part_array[i]\n",
    "    prompt = f\"\"\"\n",
    "    在接下来的对话中，你需要遵循以下规则：\n",
    "    你是一个擅长读书并总结的人，你的任务是处理我上传的课本选段，并按照以下要求进行操作：\n",
    "    - 输出标准JSON格式字符串。\n",
    "    - 剔除文件中的所有乱码（乱码不包括英文）。\n",
    "    - 处理英文的时候 请保留英文的原格式，包括括号。\n",
    "    - 我会告诉你这段文字的主题，你可以围绕着这个主题开始一层一层地梳理知识结构\n",
    "    - 你需要对文本内知识点进行提取，并列成列表，形成json字符串的point字段。\n",
    "    - 当你提取到一个知识点，在上下文寻找与他相关联的知识点，并进行提取\n",
    "    - 你需要对知识点与知识点之间的属于关系进行提取，将有属于关系的知识点两两之间形成(知识点1,属于，知识点2)的元组，并以列表的形式存进json字符串的edge字段\n",
    "    - 像\"一\"、\"二\"或是\"第一\"、\"第二\"等形式的序号字符，可用于帮助定位实体。标题之间的层级结构，也可以帮助构建属于关系。\n",
    "    - 这一节的名字叫{part_name},请围绕{part_name}进行知识点提取和属于关系识别\n",
    "    - 格式参考示例:\n",
    "    {{\n",
    "        \"point\": [\"数学\",\"线性代数\",\"矩阵\"],\n",
    "        \"edge\":[[\"线性代数\",\"属于\",\"数学\"],[\"矩阵\",\"属于\",\"线性代数\"]]\n",
    "    }}\n",
    "    - 请保证仅提取属于关系，被提取出的知识点一定有相应的关系。\n",
    "    你不需要确认收到，或是做出过多解释，直接开始生成完整准确的输出。\n",
    "    \"\"\"\n",
    "    # 50000是token数量，可以用来选择单元切片的大小\n",
    "    # 经过我的测试，小节所表现出的效果不如章节，很乱很杂，当然也有可能是因为上下文提示词的原因\n",
    "    contents=group_page_by_token_limit(pdf_output_path,50000, start, end)\n",
    "    for content_id,content in enumerate(contents):\n",
    "        request=\"\"\n",
    "        for paragraph_id,paragraph in enumerate(content):\n",
    "            request+=paragraph\n",
    "            request+='\\n'\n",
    "        # messages.append({'role': Role.USER, 'content': request})\n",
    "        messages = [{'role': Role.SYSTEM, 'content': prompt},\n",
    "                {'role': Role.USER, 'content': request}]\n",
    "        response = Generation.call(\n",
    "            Generation.Models.qwen_max_longcontext,\n",
    "            messages=messages,\n",
    "            result_format='message',  # set the result to be \"message\" format.\n",
    "        )\n",
    "        if response.status_code == HTTPStatus.OK:\n",
    "            raw_string=response.output.choices[0]['message']['content']\n",
    "            print(raw_string)\n",
    "            print(response.usage[\"total_tokens\"])\n",
    "            # append result to messages.\n",
    "            nodes_array_n,edges_array_n=str2json(raw_string)\n",
    "            nodes_array+=[node for node in nodes_array_n if node not in nodes_array]\n",
    "            edges_array+=[edge for edge in edges_array_n if edge not in edges_array]\n",
    "            log.append((i,nodes_array_n,edges_array_n))\n",
    "            if nodes_array_n ==[] or edges_array_n==[]:\n",
    "                debug_array.append(i)\n",
    "        else:\n",
    "            print('Request id: %s, Status code: %s, error code: %s, error message: %s' % (\n",
    "                response.request_id, response.status_code,\n",
    "                response.code, response.message\n",
    "            ))\n",
    "            debug_array.append(i)\n",
    "            break\n",
    "        # api限制是1分钟调用一次\n",
    "        secs = random.normalvariate(38, 0.4)\n",
    "        if secs <= 30 or secs >= 45:\n",
    "            secs =40   # 太小或太大则重置为平均值\n",
    "        print(\"sleep:\"+str(secs)+\"秒\")\n",
    "        time.sleep(secs)       "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **4.反馈整合，xmind输出**\n",
    "\n",
    "构建了森林、边、节点类，用节点表征实体，用边表征属于关系，relationship表征其他关系\n",
    "遇到问题：\n",
    "1、有的边添加时间过长，但是从边上看暂未发现原因\n",
    "2、只添加其他关系不添加从属关系不能使节点被显示，我们在其他关系上也加了一个从属关系这会导致从属混乱，程序执行出错"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('信息系统的基本概念', '属于', '信息系统开发概述')\n",
      "('信息系统的结构', '属于', '信息系统开发概述')\n",
      "('信息系统开发过程', '属于', '信息系统开发概述')\n",
      "('信息系统的相关角色', '属于', '信息系统开发概述')\n",
      "('本章小结', '属于', '信息系统开发概述')\n",
      "('案例分析——校园二手书交易平台的设计与实现', '属于', '信息系统开发概述')\n",
      "('信息系统开发路线概述', '属于', '信息系统开发路线、方法与工具')\n",
      "('模型驱动开发路线', '属于', '信息系统开发路线、方法与工具')\n",
      "('快速应用开发路线', '属于', '信息系统开发路线、方法与工具')\n",
      "('商用软件包开发路线', '属于', '信息系统开发路线、方法与工具')\n",
      "('选择合适的开发路线与方法', '属于', '信息系统开发路线、方法与工具')\n",
      "('自动化工具与技术', '属于', '信息系统开发路线、方法与工具')\n",
      "('案例：CASE 工具在系统开发中的应用', '属于', '信息系统开发路线、方法与工具')\n",
      "('本章小结', '属于', '信息系统开发路线、方法与工具')\n",
      "('信息系统项目管理生命周期', '属于', '信息系统项目管理')\n",
      "('项目组织', '属于', '信息系统项目管理')\n",
      "('项目管理技术', '属于', '信息系统项目管理')\n",
      "('案例：某系统开发项目管理', '属于', '信息系统项目管理')\n",
      "('本章小结', '属于', '信息系统项目管理')\n",
      "('案例分析', '属于', '信息系统项目管理')\n",
      "('系统需求概述', '属于', '需求获取')\n",
      "('需求获取过程', '属于', '需求获取')\n",
      "('需求获取的方法', '属于', '需求获取')\n",
      "('案例分析——客户关系管理系统的需求获取', '属于', '需求获取')\n",
      "('本章小结', '属于', '需求获取')\n",
      "('过程建模', '属于', '过程建模')\n",
      "('数据流图', '属于', '过程建模')\n",
      "任务执行超时\n",
      "('2.0 层数据流图', '属于', '过程建模')\n",
      "任务执行超时\n",
      "('过程逻辑', '属于', '过程建模')\n",
      "任务执行超时\n",
      "('数据字典', '属于', '过程建模')\n",
      "任务执行超时\n",
      "('过程建模步骤', '属于', '过程建模')\n",
      "任务执行超时\n",
      "('本章小结', '属于', '过程建模')\n",
      "任务执行超时\n",
      "('数据建模相关概念', '属于', '数据建模')\n",
      "('逻辑数据建模过程', '属于', '数据建模')\n",
      "('规范化', '属于', '数据建模')\n",
      "('数据-过程模型映射', '属于', '数据建模')\n",
      "('案例分析——某网上商店概念数据建模', '属于', '数据建模')\n",
      "('本章总结', '属于', '数据建模')\n",
      "('架构概述', '属于', '应用架构设计')\n",
      "('典型的系统应用架构', '属于', '应用架构设计')\n",
      "('应用架构举例', '属于', '应用架构设计')\n",
      "('应用架构设计', '属于', '应用架构设计')\n",
      "('案例分析——某服务台系统架构设计', '属于', '应用架构设计')\n",
      "任务执行超时\n",
      "('本章小结', '属于', '应用架构设计')\n",
      "任务执行超时\n",
      "('过程设计主要内容', '属于', '软件过程设计')\n",
      "('软件设计的基本原理', '属于', '软件过程设计')\n",
      "('软件设计工具', '属于', '软件过程设计')\n",
      "('练习：画出下列伪码程序的程序流程图和盒图', '属于', '软件过程设计')\n",
      "('软件结构设计方法', '属于', '软件过程设计')\n",
      "('软件详细设计', '属于', '软件过程设计')\n",
      "('案例分析——百货商店业务管理信息系统过程建模', '属于', '软件过程设计')\n",
      "('本章小结', '属于', '软件过程设计')\n",
      "('逻辑模型和物理模型', '属于', '数据库设计')\n",
      "('关系数据库模型', '属于', '数据库设计')\n",
      "('将 E-R 图转化成关系', '属于', '数据库设计')\n",
      "('设计字段', '属于', '数据库设计')\n",
      "('代码设计', '属于', '数据库设计')\n",
      "('输出设计', '属于', '输出、输入与用户界面设计')\n",
      "('输入设计', '属于', '输出、输入与用户界面设计')\n",
      "('用户界面设计', '属于', '输出、输入与用户界面设计')\n",
      "('输入输出界面示例', '属于', '输出、输入与用户界面设计')\n",
      "('软件实现', '属于', '系统实现与运行')\n",
      "('软件测试', '属于', '系统实现与运行')\n",
      "('白盒测试技术', '属于', '系统实现与运行')\n",
      "('黑盒测试技术', '属于', '系统实现与运行')\n",
      "('网络实现', '属于', '系统实现与运行')\n",
      "('数据库实现', '属于', '系统实现与运行')\n",
      "('系统转换', '属于', '系统实现与运行')\n",
      "('系统运行与支持', '属于', '系统实现与运行')\n",
      "('面向对象相关概念', '属于', '面向对象开发概述')\n",
      "('面向对象的特性', '属于', '面向对象开发概述')\n",
      "('面向对象开发的主要方法', '属于', '面向对象开发概述')\n",
      "('UML 概述', '属于', 'UML')\n",
      "('用例图', '属于', 'UML')\n",
      "('类图和对象图', '属于', 'UML')\n",
      "('状态图', '属于', 'UML')\n",
      "('活动图', '属于', 'UML')\n",
      "('顺序图', '属于', 'UML')\n",
      "('协作图', '属于', 'UML')\n",
      "('组件图', '属于', 'UML')\n",
      "('部署图', '属于', 'UML')\n",
      "('包图', '属于', 'UML')\n",
      "('基于 UML 的系统开发过程', '属于', '面向对象需求理解')\n",
      "('理解需求', '属于', '面向对象需求理解')\n",
      "('案例——电子培训系统的需求理解', '属于', '面向对象需求理解')\n",
      "('领域建模', '属于', '面向对象分析')\n",
      "('行为建模', '属于', '面向对象分析')\n",
      "('案例——网上商店客户订单处理系统分析', '属于', '面向对象分析')\n",
      "('系统设计与 UML', '属于', '面向对象设计')\n",
      "('通用职责分配软件模式', '属于', '面向对象设计')\n",
      "('类的设计', '属于', '面向对象设计')\n",
      "('接口设计', '属于', '面向对象设计')\n",
      "('包设计', '属于', '面向对象设计')\n",
      "('数据库设计', '属于', '面向对象设计')\n",
      "('设计映射到代码', '属于', '面向对象实现')\n",
      "('面向对象程序设计', '属于', '面向对象实现')\n",
      "('面向对象测试策略', '属于', '面向对象实现')\n",
      "('设计测试用例', '属于', '面向对象实现')\n",
      "信息系统的基本概念\n",
      "['系统目标', '属于', '系统']\n",
      "['系统边界', '属于', '系统']\n",
      "['构件', '属于', '系统']\n",
      "['构件之间的关系', '属于', '系统']\n",
      "['环境', '属于', '系统']\n",
      "['接口', '属于', '系统']\n",
      "['输入', '属于', '系统']\n",
      "['输出', '属于', '系统']\n",
      "['约束', '属于', '系统']\n",
      "['信息系统', '属于', '系统']\n",
      "['信息系统目标', '属于', '信息系统']\n",
      "['信息系统边界', '属于', '信息系统']\n",
      "['信息系统构件', '属于', '信息系统']\n",
      "['构件之间关系', '属于', '信息系统']\n",
      "['环境', '属于', '信息系统']\n",
      "['信息系统接口', '属于', '信息系统']\n",
      "['系统输入', '属于', '信息系统']\n",
      "['系统输出', '属于', '信息系统']\n",
      "['系统约束', '属于', '信息系统']\n",
      "['信息系统的功能结构', '属于', '信息系统']\n",
      "['输入功能', '属于', '信息系统的功能结构']\n",
      "['存储功能', '属于', '信息系统的功能结构']\n",
      "['处理功能', '属于', '信息系统的功能结构']\n",
      "['输出功能', '属于', '信息系统的功能结构']\n",
      "['控制功能', '属于', '信息系统的功能结构']\n",
      "信息系统的基本概念\n",
      "['系统目标', '属于', '系统']\n",
      "['系统边界', '属于', '系统']\n",
      "['构件', '属于', '系统']\n",
      "['构件之间的关系', '属于', '系统']\n",
      "['环境', '属于', '系统']\n",
      "['接口', '属于', '系统']\n",
      "['输入', '属于', '系统']\n",
      "['输出', '属于', '系统']\n",
      "['约束', '属于', '系统']\n",
      "['信息系统', '属于', '系统']\n",
      "['信息系统目标', '属于', '信息系统']\n",
      "['信息系统边界', '属于', '信息系统']\n",
      "['信息系统构件', '属于', '信息系统']\n",
      "['构件之间关系', '属于', '信息系统']\n",
      "['环境', '属于', '信息系统']\n",
      "['信息系统接口', '属于', '信息系统']\n",
      "['系统输入', '属于', '信息系统']\n",
      "['系统输出', '属于', '信息系统']\n",
      "['系统约束', '属于', '信息系统']\n",
      "['信息系统的功能结构', '属于', '信息系统']\n",
      "['输入功能', '属于', '信息系统的功能结构']\n",
      "['存储功能', '属于', '信息系统的功能结构']\n",
      "['处理功能', '属于', '信息系统的功能结构']\n",
      "['输出功能', '属于', '信息系统的功能结构']\n",
      "['控制功能', '属于', '信息系统的功能结构']\n",
      "信息系统的基本概念\n",
      "['系统目标', '属于', '系统']\n",
      "['系统边界', '属于', '系统']\n",
      "['构件', '属于', '系统']\n",
      "['构件之间的关系', '属于', '系统']\n",
      "['环境', '属于', '系统']\n",
      "['接口', '属于', '系统']\n",
      "['输入', '属于', '系统']\n",
      "['输出', '属于', '系统']\n",
      "['约束', '属于', '系统']\n",
      "['信息系统', '属于', '系统']\n",
      "['信息系统目标', '属于', '信息系统']\n",
      "['信息系统边界', '属于', '信息系统']\n",
      "['信息系统构件', '属于', '信息系统']\n",
      "['构件之间关系', '属于', '信息系统']\n",
      "['环境', '属于', '信息系统']\n",
      "['信息系统接口', '属于', '信息系统']\n",
      "['系统输入', '属于', '信息系统']\n",
      "['系统输出', '属于', '信息系统']\n",
      "['系统约束', '属于', '信息系统']\n",
      "['信息系统的功能结构', '属于', '信息系统']\n",
      "['输入功能', '属于', '信息系统的功能结构']\n",
      "['存储功能', '属于', '信息系统的功能结构']\n",
      "['处理功能', '属于', '信息系统的功能结构']\n",
      "['输出功能', '属于', '信息系统的功能结构']\n",
      "['控制功能', '属于', '信息系统的功能结构']\n",
      "信息系统的基本概念\n",
      "['系统', '属于', '系统的基本概念']\n",
      "['系统的目标', '属于', '系统的基本概念']\n",
      "['系统的目标', '是', '达到某种目的']\n",
      "['系统的目标', '举例', '快餐店系统的主要目标']\n",
      "['系统边界', '属于', '系统的基本概念']\n",
      "['构件', '属于', '系统的基本概念']\n",
      "['构件之间的关系', '属于', '系统的基本概念']\n",
      "['环境', '属于', '系统的基本概念']\n",
      "['接口', '属于', '系统的基本概念']\n",
      "['输入', '属于', '系统的基本概念']\n",
      "['输出', '属于', '系统的基本概念']\n",
      "['约束', '属于', '系统的基本概念']\n",
      "['信息系统', '属于', '信息系统的基本概念']\n",
      "['Gordon B. Davis', '提出', '信息系统概念']\n",
      "['信息系统定义', '由', 'Gordon B. Davis 提出']\n",
      "['薛华成教授的观点', '解释', '信息系统']\n",
      "['人机信息系统', '属于', '信息系统']\n",
      "['企业管理信息系统', '是', '信息系统的组成模块']\n",
      "['信息技术', '属于', '信息系统的基本概念']\n",
      "['信息技术定义', '描述', '信息技术']\n",
      "['信息和通信技术', '等同于', '信息技术']\n",
      "['信息技术的应用', '包括', '计算机硬件和软件']\n",
      "['信息技术的应用', '包括', '网络和通讯技术']\n",
      "['信息技术的应用', '包括', '应用软件开发工具']\n",
      "['信息系统在商业中的角色', '是解决', '环境提出的挑战']\n",
      "['基于信息技术的组织管理方案', '属于', '信息系统']\n",
      "['信息技术体系结构', '包含', '管理成分']\n",
      "['信息技术体系结构', '包含', '技术成分']\n",
      "['系统方法', '用于理解', '系统组织方式及工作原理']\n",
      "['整体性', '属于', '系统方法要点']\n",
      "['结构性', '属于', '系统方法要点']\n",
      "['关联性', '属于', '系统方法要点']\n",
      "['功能性', '属于', '系统方法要点']\n",
      "['信息系统的功能结构', '属于', '信息系统的基本概念']\n",
      "['输入功能', '属于', '信息系统的功能结构']\n",
      "['存储功能', '属于', '信息系统的功能结构']\n",
      "['处理功能', '属于', '信息系统的功能结构']\n",
      "['输出功能', '属于', '信息系统的功能结构']\n",
      "['控制功能', '属于', '信息系统的功能结构']\n",
      "信息系统的结构\n",
      "['信息系统的功能结构', '属于', '信息系统的结构']\n",
      "['输入功能', '属于', '信息系统的功能结构']\n",
      "['存储功能', '属于', '信息系统的功能结构']\n",
      "['处理功能', '属于', '信息系统的功能结构']\n",
      "['输出功能', '属于', '信息系统的功能结构']\n",
      "['控制功能', '属于', '信息系统的功能结构']\n",
      "['信息系统的应用结构', '属于', '信息系统的结构']\n",
      "['市场子系统', '属于', '信息系统的应用结构']\n",
      "['财会子系统', '属于', '信息系统的应用结构']\n",
      "['人事子系统', '属于', '信息系统的应用结构']\n",
      "['生产子系统', '属于', '信息系统的应用结构']\n",
      "['供运子系统', '属于', '信息系统的应用结构']\n",
      "['战略层系统', '属于', '信息系统的应用结构(按照服务对象划分)']\n",
      "['管理层系统', '属于', '信息系统的应用结构(按照服务对象划分)']\n",
      "['知识层系统', '属于', '信息系统的应用结构(按照服务对象划分)']\n",
      "['操作层系统', '属于', '信息系统的应用结构(按照服务对象划分)']\n",
      "['信息系统的软件结构', '属于', '信息系统的结构']\n",
      "['事务处理信息系统', '属于', '信息系统分类']\n",
      "['管理信息系统(MIS)', '属于', '信息系统分类']\n",
      "['办公自动化系统', '属于', '信息系统分类']\n",
      "['知识工作系统', '属于', '信息系统分类']\n",
      "['决策支持系统(DSS)', '属于', '信息系统分类']\n",
      "['经理信息系统(EIS)', '属于', '信息系统分类']\n",
      "['事务处理系统(TPS)', '属于', '信息系统分类']\n",
      "['数据收集', '属于', '事务处理系统(TPS)的功能']\n",
      "['数据编辑', '属于', '事务处理系统(TPS)的功能']\n",
      "['数据修改', '属于', '事务处理系统(TPS)的功能']\n",
      "['数据处理', '属于', '事务处理系统(TPS)的功能']\n",
      "['数据存储', '属于', '事务处理系统(TPS)的功能']\n",
      "['文档生成', '属于', '事务处理系统(TPS)的功能']\n",
      "信息系统开发过程\n",
      "['系统规划', '属于', '信息系统开发过程']\n",
      "['组织战略规划的组成部分', '属于', '系统规划']\n",
      "['信息系统规划的主要目标', '属于', '系统规划']\n",
      "['组建信息系统项目团队', '属于', '系统规划']\n",
      "['确定信息系统项目优先顺序', '属于', '系统规划']\n",
      "['环境评价和初步调查', '属于', '确定信息系统项目优先顺序']\n",
      "['业务愿景', '属于', '确定信息系统项目优先顺序']\n",
      "['信息系统项目的范围', '属于', '确定信息系统项目优先顺序']\n",
      "['项目启动大会', '属于', '系统规划']\n",
      "['系统分析', '属于', '信息系统开发过程']\n",
      "['需求理解与确定', '属于', '系统分析']\n",
      "['需求表达与结构化', '属于', '系统分析']\n",
      "['系统设计', '属于', '信息系统开发过程']\n",
      "['体系架构设计', '属于', '系统设计']\n",
      "['详细设计', '属于', '系统设计']\n",
      "['系统实现', '属于', '信息系统开发过程']\n",
      "['编程与测试', '属于', '系统实现']\n",
      "['系统转换', '属于', '系统实现']\n",
      "['系统维护', '属于', '信息系统开发过程']\n",
      "信息系统的相关角色\n",
      "['系统维护', '属于', '运行维护阶段']\n",
      "['日常维护', '属于', '系统维护']\n",
      "['新需求满足', '属于', '系统维护']\n",
      "['技术支持', '属于', '系统维护']\n",
      "['信息系统项目规划书', '属于', '规划阶段交付成果']\n",
      "['需求结构化', '属于', '分析阶段']\n",
      "['信息系统需求说明书', '属于', '分析阶段交付成果']\n",
      "['体系结构设计', '属于', '设计阶段']\n",
      "['详细设计', '属于', '设计阶段']\n",
      "['应用架构设计', '属于', '设计阶段']\n",
      "任务执行超时\n",
      "['功能模块设计', '属于', '设计阶段']\n",
      "['数据库设计', '属于', '设计阶段']\n",
      "['输入输出和用户界面设计', '属于', '设计阶段']\n",
      "['代码设计', '属于', '设计阶段']\n",
      "['信息系统设计说明书', '属于', '设计阶段交付成果']\n",
      "['网络组建与测试', '属于', '实现阶段']\n",
      "['数据库建立与测试', '属于', '实现阶段']\n",
      "['编程与测试', '属于', '实现阶段']\n",
      "['系统切换', '属于', '实现阶段']\n",
      "['用户培训', '属于', '实现阶段']\n",
      "['运行维护阶段交付成果', '包括', '变更的程序代码和文档']\n",
      "['运行维护阶段交付成果', '包括', '维护说明书']\n",
      "['系统所有者', '属于', '信息系统的相关角色']\n",
      "['管理阶层', '属于', '系统所有者的来源']\n",
      "['业务价值', '关注于', '系统所有者']\n",
      "['成本与收益权衡', '关注于', '系统所有者']\n",
      "['信息系统用户', '属于', '信息系统的相关角色']\n",
      "['内部信息系统用户', '属于', '信息系统用户']\n",
      "['外部信息系统用户', '属于', '信息系统用户']\n",
      "['办事员和服务人员', '属于', '内部信息系统用户']\n",
      "['技术人员和专业人员', '属于', '内部信息系统用户']\n",
      "['主管', '属于', '内部信息系统用户']\n",
      "['中层经理', '属于', '内部信息系统用户']\n",
      "['高层经理', '属于', '内部信息系统用户']\n",
      "['信息系统设计员', '属于', '信息系统的相关角色']\n",
      "['技术方案', '由', '信息系统设计员']\n",
      "['信息系统构造人员', '属于', '信息系统的相关角色']\n",
      "['信息系统构件搭建', '由', '信息系统构造人员']\n",
      "['信息系统分析员', '属于', '信息系统的相关角色']\n",
      "['业务问题研究', '由', '信息系统分析员']\n",
      "['规格说明', '由', '信息系统分析员生成']\n",
      "['项目经理', '属于', '信息系统的相关角色']\n",
      "['项目团队组建', '由', '项目经理']\n",
      "['任务分派', '由', '项目经理']\n",
      "本章小结\n",
      "['用户', '属于', '信息系统']\n",
      "['办事员', '关注', '事务处理正确性']\n",
      "['办事员', '关注', '速度']\n",
      "['主管和经理', '关注', '数据分析']\n",
      "['主管和经理', '关注', '解决问题能力']\n",
      "['信息系统设计员', '将', '业务需求转换']\n",
      "['信息系统设计员', '关注', 'IT 选择']\n",
      "['信息系统设计员', '关注', 'IT 设计']\n",
      "['信息系统构造人员', '根据', '信息系统设计人员的设计说明']\n",
      "['信息系统构造人员', '关注', '信息系统实现的技术问题']\n",
      "['信息系统分析员', '理解', '组织及其职能']\n",
      "['信息系统分析员', '关注', '组织存在的问题和需求']\n",
      "['项目经理', '领导', '项目组成员']\n",
      "['项目经理', '关注', '进度安排']\n",
      "['项目经理', '关注', '预算']\n",
      "['项目经理', '关注', '客户满意度']\n",
      "['项目经理', '关注', '技术标准']\n",
      "['项目经理', '关注', '信息系统质量']\n",
      "['项目经理', '关注', '计划、监视、控制项目']\n",
      "['信息系统开发生命周期(SDLC)', '分为', '规划阶段']\n",
      "['信息系统开发生命周期(SDLC)', '分为', '分析阶段']\n",
      "['信息系统开发生命周期(SDLC)', '分为', '设计阶段']\n",
      "['信息系统开发生命周期(SDLC)', '分为', '实施阶段']\n",
      "['信息系统开发生命周期(SDLC)', '分为', '维护阶段']\n",
      "['本章小结', '涵盖', '信息系统开发的主要过程']\n",
      "['本章小结', '涵盖', '项目管理过程']\n",
      "['本章小结', '涵盖', '主要角色']\n",
      "['本章小结', '涵盖', '工具方法与技术']\n",
      "案例分析——校园二手书交易平台的设计与实现\n",
      "['系统需求分析', '属于', '案例分析——校园二手书交易平台的设计与实现']\n",
      "['业务流程分析', '属于', '案例分析——校园二手书交易平台的设计与实现']\n",
      "['系统设计', '属于', '案例分析——校园二手书交易平台的设计与实现']\n",
      "['系统实现', '属于', '案例分析——校园二手书交易平台的设计与实现']\n",
      "['用户管理模块', '属于', '系统设计']\n",
      "['商品管理模块', '属于', '系统设计']\n",
      "['订单管理模块', '属于', '系统设计']\n",
      "['预约管理模块', '属于', '系统设计']\n",
      "['系统设置模块', '属于', '系统设计']\n",
      "['管理员设置模块', '属于', '系统设计']\n",
      "['分类管理模块', '属于', '系统设计']\n",
      "['登录模块', '属于', '系统设计']\n",
      "['学院表', '属于', '数据库设计']\n",
      "['宿舍表', '属于', '数据库设计']\n",
      "['系统信息表', '属于', '数据库设计']\n",
      "['商品详细表', '属于', '数据库设计']\n",
      "['商品实体表', '属于', '数据库设计']\n",
      "['用户表', '属于', '数据库设计']\n",
      "['订单表', '属于', '数据库设计']\n",
      "['预约表', '属于', '数据库设计']\n",
      "['预约单明细表', '属于', '数据库设计']\n",
      "['管理员表', '属于', '数据库设计']\n",
      "['三层架构', '用于', '系统实现']\n",
      "信息系统开发路线概述\n",
      "['信息系统开发路线概述', '属于', '第 2 章 信息系统开发路线、方法与工具']\n",
      "['信息系统开发是一个庞大的系统工程', '属于', '信息系统开发路线概述']\n",
      "['科学的开发方法和过程化的开发步骤', '属于', '信息系统开发路线概述']\n",
      "['信息系统开发方法学', '属于', '信息系统开发路线概述']\n",
      "['开发规律', '属于', '信息系统开发方法学']\n",
      "['开发过程的认知体系', '属于', '信息系统开发方法学']\n",
      "['分析设计的一般理论', '属于', '信息系统开发方法学']\n",
      "['具体的开发工具和技术', '属于', '信息系统开发方法学']\n",
      "['信息系统开发路线的选择依据', '属于', '信息系统开发路线概述']\n",
      "['系统开发的目标', '属于', '信息系统开发路线的选择依据']\n",
      "['资源', '属于', '信息系统开发路线的选择依据']\n",
      "['成本', '属于', '信息系统开发路线的选择依据']\n",
      "['典型的信息系统开发路线', '属于', '第 2 章 信息系统开发路线、方法与工具']\n",
      "['模型驱动开发路线', '属于', '第 2 章 信息系统开发路线、方法与工具']\n",
      "['可视化分析与设计', '属于', '模型驱动开发路线']\n",
      "['模型在业务与 IT 工作流程中的作用', '属于', '模型驱动开发路线']\n",
      "['导出相应代码', '属于', '模型驱动开发路线']\n",
      "['面向过程方法（Process Oriented）', '属于', '模型驱动开发路线']\n",
      "['数据流图', '属于', '面向过程方法（Process Oriented）']\n",
      "任务执行超时\n",
      "['实体关系图', '属于', '面向过程方法（Process Oriented）']\n",
      "['面向数据方法（Data Oriented）', '属于', '模型驱动开发路线']\n",
      "['信息模型', '属于', '面向数据方法（Data Oriented）']\n",
      "['全企业共享数据库', '属于', '面向数据方法（Data Oriented）']\n",
      "['面向对象的方法（Object Oriented）', '属于', '模型驱动开发路线']\n",
      "['对象类', '属于', '面向对象的方法（Object Oriented）']\n",
      "['结构化系统开发方法（SSAD）', '属于', '面向过程方法']\n",
      "模型驱动开发路线\n",
      "['面向过程方法', '属于', '模型驱动开发路线']\n",
      "['结构化系统开发方法（SSAD）', '属于', '面向过程方法']\n",
      "['数据流程图', '属于', '结构化系统开发方法（SSAD）']\n",
      "['实体关系图', '属于', '结构化系统开发方法（SSAD）']\n",
      "['系统分析模型', '导出自', '结构化系统开发方法（SSAD）']\n",
      "['设计模型', '转换为', '系统分析模型']\n",
      "['面向数据方法', '属于', '模型驱动开发路线']\n",
      "['信息工程方法', '属于', '面向数据方法']\n",
      "['数据驱动', '属于', '信息工程方法']\n",
      "['业务驱动', '属于', '信息工程方法']\n",
      "['企业规划', '阶段属于', '信息工程方法']\n",
      "['业务域分析', '阶段属于', '信息工程方法']\n",
      "['系统设计', '阶段属于', '信息工程方法']\n",
      "['构造', '阶段属于', '信息工程方法']\n",
      "['面向对象方法', '属于', '模型驱动开发路线']\n",
      "['统一建模语言（UML）', '与', '面向对象方法']\n",
      "['封装性', '特征属于', '面向对象方法']\n",
      "['继承性', '特征属于', '面向对象方法']\n",
      "['多态性', '特征属于', '面向对象方法']\n",
      "['快速应用开发路线（RAD）', '属于', '模型驱动开发路线']\n",
      "['迭代式开发', '开发方式属于', '快速应用开发路线（RAD）']\n",
      "['敏捷式开发', '开发方式属于', '快速应用开发路线（RAD）']\n",
      "快速应用开发路线\n",
      "['快速应用开发路线', '属于', '系统开发策略']\n",
      "['用户深入参与', '属于', '快速应用开发路线']\n",
      "['系统工作原型', '属于', '快速应用开发路线']\n",
      "['目标系统', '属于', '快速应用开发路线']\n",
      "['研讨会', '属于', '快速应用开发路线']\n",
      "['CASE 工具', '属于', '快速应用开发路线']\n",
      "['JAD 会议', '属于', '快速应用开发路线']\n",
      "['可视化编程语言', '属于', '快速应用开发路线']\n",
      "['迭代式开发', '属于', '快速应用开发路线']\n",
      "['敏捷式开发', '属于', '快速应用开发路线']\n",
      "['探索型原型', '属于', '原型法']\n",
      "['实验型原型', '属于', '原型法']\n",
      "['演化型原型', '属于', '原型法']\n",
      "['识别基本需求', '属于', '迭代式开发']\n",
      "['设计初始原型', '属于', '迭代式开发']\n",
      "['原型评价与反馈', '属于', '迭代式开发']\n",
      "['修订和提高原型', '属于', '迭代式开发']\n",
      "['敏捷开发', '属于', '系统开发策略']\n",
      "['极限编程(XP)', '属于', '敏捷开发']\n",
      "['Scrum', '属于', '敏捷开发']\n",
      "['水晶方法(Crystal Methods)', '属于', '敏捷开发']\n",
      "['特征驱动开发(FDD)', '属于', '敏捷开发']\n",
      "['自适应软件开发(ASD)', '属于', '敏捷开发']\n",
      "['动态系统开发方法(DSDM)', '属于', '敏捷开发']\n",
      "['商用软件包开发路线', '属于', '系统开发策略']\n",
      "['商用应用软件包', '属于', '商用软件包开发路线']\n",
      "['封装式软件方案', '属于', '商用软件包开发路线']\n",
      "['购买现成商用软件', '属于', '商用软件包开发路线']\n",
      "商用软件包开发路线\n",
      "['商用软件包', '属于', '商用软件包开发路线']\n",
      "['购买现成商用软件', '属于', '商用软件包开发路线']\n",
      "['技术市场调研', '属于', '购买现成商用软件']\n",
      "['业务需求分析阶段', '属于', '购买现成商用软件']\n",
      "['候选的软件包供应商', '属于', '购买现成商用软件']\n",
      "['需求方案说明书 RFP', '用于', '购买现成商用软件']\n",
      "['业务和技术需求评价', '属于', '购买现成商用软件']\n",
      "['软件合同和订单', '属于', '购买现成商用软件']\n",
      "['安装和维护服务合同', '属于', '购买现成商用软件']\n",
      "['现有业务过程定制', '属于', '购买现成商用软件']\n",
      "['差距分析', '属于', '购买现成商用软件']\n",
      "['附加软件需求', '属于', '购买现成商用软件']\n",
      "['新增软件需求', '属于', '购买现成商用软件']\n",
      "['基本软件安装与测试', '属于', '购买现成商用软件']\n",
      "['软件包二次开发', '属于', '商用软件包开发路线']\n",
      "['通用功能', '属于', '软件包二次开发']\n",
      "['优先考虑使用软件包的情况', '属于', '软件包二次开发']\n",
      "['缺少内部开发人员', '属于', '优先考虑使用软件包的情况']\n",
      "['微机系统', '属于', '优先考虑使用软件包的情况']\n",
      "['开发时间缩短', '属于', '软件包二次开发的优点']\n",
      "['维护工作减轻', '属于', '软件包二次开发的优点']\n",
      "['组织内部阻力减少', '属于', '软件包二次开发的优点']\n",
      "['功能较为简单', '属于', '利用软件包开发的缺点']\n",
      "['难以满足特殊要求', '属于', '利用软件包开发的缺点']\n",
      "['客户化', '属于', '利用软件包开发的缺点']\n",
      "['前端程序', '属于', '利用软件包开发的缺点']\n",
      "['后端程序', '属于', '利用软件包开发的缺点']\n",
      "['实施费用随客户化增加', '属于', '利用软件包开发的缺点']\n",
      "['利用软件包开发系统的步骤', '属于', '商用软件包开发路线']\n",
      "['系统分析', '属于', '利用软件包开发系统的步骤']\n",
      "['解决方案比较', '属于', '系统分析']\n",
      "['开发策略选择', '属于', '系统分析']\n",
      "['软件包供应商选择', '属于', '系统分析']\n",
      "['软件包评价与选择', '属于', '系统分析']\n",
      "['系统设计', '属于', '利用软件包开发系统的步骤']\n",
      "['客户需求裁剪', '属于', '系统设计']\n",
      "['技术人员培训', '属于', '系统设计']\n",
      "['客户化设计', '属于', '系统设计']\n",
      "['业务流程设计', '属于', '系统设计']\n",
      "['编程调试转换安装修改', '属于', '利用软件包开发系统的步骤']\n",
      "['程序接口设计', '属于', '利用软件包开发系统的步骤']\n",
      "['文档制作', '属于', '利用软件包开发系统的步骤']\n",
      "['切换测试', '属于', '利用软件包开发系统的步骤']\n",
      "['用户培训', '属于', '利用软件包开发系统的步骤']\n",
      "['运行与维护', '属于', '利用软件包开发系统的步骤']\n",
      "['改错与升级', '属于', '利用软件包开发系统的步骤']\n",
      "['选择合适的开发路线与方法', '属于', '商用软件包开发路线']\n",
      "选择合适的开发路线与方法\n",
      "['实施的费用随客户化工作量增大而上升', '属于', '选择合适的开发路线与方法']\n",
      "['利用软件包开发系统的步骤', '属于', '选择合适的开发路线与方法']\n",
      "['系统分析', '属于', '利用软件包开发系统的步骤']\n",
      "['明确原系统问题和需求', '属于', '系统分析']\n",
      "['比较不同开发策略', '属于', '系统分析']\n",
      "['选择是否利用软件包开发', '属于', '系统分析']\n",
      "['选择软件包供应商', '属于', '系统分析']\n",
      "['评价并选择软件包', '属于', '系统分析']\n",
      "['系统设计', '属于', '利用软件包开发系统的步骤']\n",
      "['裁剪用户需求以适应软件包功能', '属于', '系统设计']\n",
      "['培训技术人员', '属于', '系统设计']\n",
      "['完成客户化设计', '属于', '系统设计']\n",
      "['新的业务流程设计', '属于', '系统设计']\n",
      "['编程、调试、转换、安装、修改、程序接口设计、文档制作、切换、测试、用户培训', '属于', '利用软件包开发系统的步骤']\n",
      "['运行与维护、改错与升级', '属于', '利用软件包开发系统的步骤']\n",
      "['用户需求的明确性', '属于', '选择合适的开发路线与方法']\n",
      "['快速应用开发（RAD）', '属于', '根据用户需求的明确性选择开发方法']\n",
      "['原型法', '属于', '根据用户需求的明确性选择开发方法']\n",
      "['XP 方法', '属于', '根据用户需求的明确性选择开发方法']\n",
      "['技术的熟悉程度', '属于', '选择合适的开发路线与方法']\n",
      "['抛弃式原型方法', '属于', '根据对技术的熟悉程度选择开发方法']\n",
      "['系统复杂性', '属于', '选择合适的开发路线与方法']\n",
      "['传统结构化方法', '属于', '根据系统复杂性选择开发方法']\n",
      "['系统可靠性', '属于', '选择合适的开发路线与方法']\n",
      "['抛弃式原型', '属于', '根据系统可靠性选择开发方法']\n",
      "['项目进度', '属于', '选择合适的开发路线与方法']\n",
      "['RAD 和敏捷方法', '属于', '根据项目进度选择开发方法']\n",
      "['进度可视性', '属于', '选择合适的开发路线与方法']\n",
      "['CASE（Computer Aided Software Engineering）', '属于', '自动化工具与技术']\n",
      "['CASE 工具分类', '属于', '自动化工具与技术']\n",
      "['需求分析工具', '属于', 'CASE 工具分类']\n",
      "['软件设计工具', '属于', 'CASE 工具分类']\n",
      "['数据库设计工具', '属于', 'CASE 工具分类']\n",
      "['项目管理工具', '属于', 'CASE 工具分类']\n",
      "['程序设计工具', '属于', 'CASE 工具分类']\n",
      "['测试工具', '属于', 'CASE 工具分类']\n",
      "自动化工具与技术\n",
      "['CASE(Computer Aided Software Engineering)', '属于', '自动化工具与技术']\n",
      "['减少重复工作量', '属于', 'CASE(Computer Aided Software Engineering)']\n",
      "['全面支持开发步骤', '属于', 'CASE(Computer Aided Software Engineering)']\n",
      "['系统可靠性', '考虑采用', '抛弃式原型']\n",
      "['项目进度', '适合采用', 'RAD 和敏捷方法']\n",
      "['进度可视性', '通过', 'RAD 方法增加']\n",
      "['CASE 工具分类', '属于', '自动化工具与技术']\n",
      "['需求分析工具', '属于', 'CASE 工具分类']\n",
      "['软件设计工具', '属于', 'CASE 工具分类']\n",
      "['数据库设计工具', '属于', 'CASE 工具分类']\n",
      "['项目管理工具', '属于', 'CASE 工具分类']\n",
      "['程序设计工具', '属于', 'CASE 工具分类']\n",
      "['测试工具', '属于', 'CASE 工具分类']\n",
      "['基于 CASE 的系统开发过程', '属于', '自动化工具与技术']\n",
      "['数据生成', '部分', '基于 CASE 的系统开发过程']\n",
      "['应用生成', '部分', '基于 CASE 的系统开发过程']\n",
      "['原型技术', '在', '基于 CASE 的开发中强调']\n",
      "['编码生成', '在', '基于 CASE 的开发中自动化']\n",
      "['文档生成', '在', '基于 CASE 的开发中自动化']\n",
      "['设计检测', '在', '基于 CASE 的开发中自动化']\n",
      "['CASE 工具的特点', '描述', 'CASE']\n",
      "['自动化作业', '特点', 'CASE 工具']\n",
      "['错误减少', '特点', 'CASE 工具']\n",
      "['合法性检测功能', '特点', 'CASE 工具']\n",
      "['原型法功能', '特点', 'CASE 工具']\n",
      "['信息储存库', '核心部分', 'CASE 工具包']\n",
      "['加快开发速度', '特点', 'CASE 工具']\n",
      "['简化开发管理与维护', '特点', 'CASE 工具']\n",
      "['CASE 局限性', '属于', 'CASE']\n",
      "案例：CASE 工具在系统开发中的应用\n",
      "['CASE工具的特点', '属于', 'CASE工具']\n",
      "['系统开发过程中的自动化作业', '属于', 'CASE工具的特点']\n",
      "['错误减少', '属于', 'CASE工具的特点']\n",
      "['合法性检测功能', '属于', 'CASE工具的特点']\n",
      "['数据流图的自动平衡', '属于', 'CASE工具的特点']\n",
      "['数据完整性和一致性校核', '属于', 'CASE工具的特点']\n",
      "['原型法功能', '属于', 'CASE工具的特点']\n",
      "['信息储存库', '属于', 'CASE工具的特点']\n",
      "['软件开发速度加快', '属于', 'CASE工具的特点']\n",
      "['软件开发管理与维护简化', '属于', 'CASE工具的特点']\n",
      "['CASE局限性：辅助开发工具', '属于', 'CASE工具']\n",
      "['依赖具体开发方法', '属于', 'CASE局限性']\n",
      "['无法自动生成特定功能系统', '属于', 'CASE局限性']\n",
      "['无法实现与数据库和第四代语言接口', '属于', 'CASE局限性']\n",
      "['不能自动进行系统分析', '属于', 'CASE局限性']\n",
      "['CASE工具在系统开发中的应用', '属于', '案例']\n",
      "['计算机辅助系统建模工具', '属于', 'CASE工具']\n",
      "['应用开发环境', '属于', 'CASE工具']\n",
      "['项目和过程管理器', '属于', 'CASE工具']\n",
      "['Sybase公司的PowerDesigner', '属于', 'CASE工具']\n",
      "['业务过程建模(BPM)', '属于', 'PowerDesigner']\n",
      "['Process、Flow、Decision、Synchronization、Resource、Message Format', '属于', 'BPM']\n",
      "['电子订单处理流程建模实例', '属于', '过程建模']\n",
      "任务执行超时\n",
      "['概念数据模型(CDM)', '属于', '数据建模']\n",
      "['实体添加属性、设置主键和数据类型', '属于', 'CDM']\n",
      "['check model功能', '属于', 'CDM']\n",
      "['售票系统概念数据模型实例', '属于', 'CDM']\n",
      "['物理数据模型(PDM)', '属于', '数据建模']\n",
      "['CDM与PDM相互转化', '关联于', '数据建模']\n",
      "['面向对象模型', '属于', 'PowerDesigner']\n",
      "['正向工程', '应用于', '模型与数据库连接']\n",
      "['逆向工程', '应用于', '模型与数据库连接']\n",
      "['对象建模', '属于', 'PowerDesigner']\n",
      "['面向对象模型', '包含', '用例图、类图、状态图、顺序图、协作图']\n",
      "['电脑工作状态图实例', '属于', '对象建模']\n",
      "['饮料贩卖机工作顺序图实例', '属于', '对象建模']\n",
      "['饮料贩卖机工作协作图实例', '属于', '对象建模']\n",
      "['报告生成工具及模板', '属于', 'PowerDesigner']\n",
      "['HTML版本信息系统开发报告实例', '属于', '报告生成']\n",
      "本章小结\n",
      "['PowerDesigner', '属于', '信息系统开发工具']\n",
      "['信息系统开发路线', '属于', '本章小结']\n",
      "['正向工程', '属于', 'PowerDesigner 功能']\n",
      "['Access数据库', '涉及', '正向工程问题']\n",
      "['CASE工具概述', '属于', '本章内容']\n",
      "['基于CASE的系统开发过程', '属于', '本章内容']\n",
      "['ERP项目开发路线选择', '属于', '思考与练习']\n",
      "['项目管理过程', '属于', '第3章学习目标']\n",
      "['项目经理所需的技能', '属于', '第3章学习目标']\n",
      "['项目发起、规划、执行和终结阶段的技能和活动', '属于', '第3章学习目标']\n",
      "['关键路径规划', '属于', '第3章学习目标']\n",
      "['甘特图', '用于', '项目进度表示']\n",
      "['网络图', '用于', '项目进度表示']\n",
      "['商用项目管理软件包', '应用于', '项目进度管理']\n",
      "['信息系统项目管理', '定义为', '管理过程']\n",
      "['项目管理生命周期', '包含', '四个阶段']\n",
      "['项目发起阶段', '属于', '项目管理生命周期']\n",
      "['成立项目发起团队', '属于', '项目发起阶段活动']\n",
      "['建立与客户之间的关系', '属于', '项目发起阶段活动']\n",
      "['制定项目发起计划', '属于', '项目发起阶段活动']\n",
      "['建立管理规程', '属于', '项目发起阶段活动']\n",
      "信息系统项目管理生命周期\n",
      "['项目发起阶段', '属于', '信息系统项目管理生命周期']\n",
      "['规划项目', '属于', '信息系统项目管理生命周期']\n",
      "['执行项目', '属于', '信息系统项目管理生命周期']\n",
      "['终结项目', '属于', '信息系统项目管理生命周期']\n",
      "['成立项目发起团队', '属于', '项目发起的主要任务和活动']\n",
      "['建立与客户之间的关系', '属于', '项目发起的主要任务和活动']\n",
      "['制定项目发起计划', '属于', '项目发起的主要任务和活动']\n",
      "['建立管理规程', '属于', '项目发起的主要任务和活动']\n",
      "['建立项目管理环境和项目工作手册', '属于', '项目发起的主要任务和活动']\n",
      "['项目规划主要内容', '属于', '项目规划']\n",
      "['描述项目范围、候选方案、可行性', '属于', '项目规划主要内容']\n",
      "['将项目分解为可管理的任务', '属于', '项目规划主要内容']\n",
      "['估算资源并创建资源规划', '属于', '项目规划主要内容']\n",
      "['制定初步进度', '属于', '项目规划主要内容']\n",
      "['制定通信计划', '属于', '项目规划主要内容']\n",
      "['确定项目标准和规程', '属于', '项目规划主要内容']\n",
      "['识别和评估风险', '属于', '项目规划主要内容']\n",
      "['创建初步的预算', '属于', '项目规划主要内容']\n",
      "['开发工作陈述', '属于', '项目规划主要内容']\n",
      "['建立基线项目计划', '属于', '项目规划主要内容']\n",
      "['执行基线项目计划', '属于', '项目执行阶段']\n",
      "['按照基线项目计划监督项目进展', '属于', '项目执行阶段']\n",
      "['管理基线项目计划的变更', '属于', '项目执行阶段']\n",
      "['维护项目工作手册', '属于', '项目执行阶段']\n",
      "['沟通项目状况', '属于', '项目执行阶段']\n",
      "['结束项目', '属于', '项目终结阶段']\n",
      "['项目评估', '属于', '项目终结阶段']\n",
      "['终止项目合同', '属于', '项目终结阶段']\n",
      "项目组织\n",
      "['结束项目', '属于', '项目终结']\n",
      "['完成对项目组成员的绩效和薪资的鉴定', '属于', '结束项目']\n",
      "['通知各利益相关方', '属于', '结束项目']\n",
      "['完成所有项目文档和财务记录', '属于', '结束项目']\n",
      "['项目评估', '属于', '项目终结']\n",
      "['审查项目交付品、创建过程及管理优点和缺点', '属于', '项目评估']\n",
      "['终止项目合同', '属于', '项目终结']\n",
      "['确保合同条款满足并书面同意', '属于', '终止项目合同']\n",
      "['单纯式项目组织', '属于', '项目组织']\n",
      "['项目经理对项目拥有完全自主权', '属于', '单纯式项目组织']\n",
      "['成员只需面对一个老板', '属于', '单纯式项目组织']\n",
      "['沟通层级短，决策形成快', '属于', '单纯式项目组织']\n",
      "['荣誉感和使命感高', '属于', '单纯式项目组织']\n",
      "['人员与设备无法共用，资源浪费', '属于', '单纯式项目组织']\n",
      "['组织目标和策略易被忽略', '属于', '单纯式项目组织']\n",
      "['职能部门与新科技脱节', '属于', '单纯式项目组织']\n",
      "['项目小组成员完成项目即解散，导致项目延误风险', '属于', '单纯式项目组织']\n",
      "['职能性项目组织', '属于', '项目组织']\n",
      "['项目建立在职能部门中', '属于', '职能性项目组织']\n",
      "['成员可以同时参与多个项目', '属于', '职能性项目组织']\n",
      "['专业技能不会因人员离开而遗失', '属于', '职能性项目组织']\n",
      "['成员有机会升迁', '属于', '职能性项目组织']\n",
      "['职能部门处理技术问题能力强', '属于', '职能性项目组织']\n",
      "['项目与职能部门需要无直接相关性的地方易被忽略', '属于', '职能性项目组织']\n",
      "['客户的需求容易被忽略', '属于', '职能性项目组织']\n",
      "['矩阵式项目组织', '属于', '项目组织']\n",
      "['项目组成员由不同职能部门提供', '属于', '矩阵式项目组织']\n",
      "['项目经理决定工作内容和完成时间', '属于', '矩阵式项目组织']\n",
      "['职能部门经理控制人员和技术', '属于', '矩阵式项目组织']\n",
      "['强化与职能部门的沟通', '属于', '矩阵式项目组织']\n",
      "['项目经理对项目成败负责', '属于', '矩阵式项目组织']\n",
      "['降低资源重复', '属于', '矩阵式项目组织']\n",
      "['执行上级组织政策', '属于', '矩阵式项目组织']\n",
      "['项目可获得较多支持', '属于', '矩阵式项目组织']\n",
      "['受职能部门和项目组双重管理', '属于', '矩阵式项目组织']\n",
      "['项目经理需较强的谈判技巧', '属于', '矩阵式项目组织']\n",
      "['项目组成员不易全心投入项目', '属于', '矩阵式项目组织']\n",
      "['项目管理技术', '属于', '项目组织']\n",
      "['工作分解结构', '属于', '项目管理技术']\n",
      "['WBS', '属于', '工作分解结构']\n",
      "项目管理技术\n",
      "['工作分解结构', '属于', '项目管理技术']\n",
      "['强化与职能部门的沟通', '属于', '项目管理的优点']\n",
      "['项目经理对项目负成败的责任', '属于', '项目管理的优点']\n",
      "['降低资源重复', '属于', '项目管理的优点']\n",
      "['执行上级组织的政策', '属于', '项目管理的优点']\n",
      "['项目可获得较多的支持', '属于', '项目管理的优点']\n",
      "['受职能部门和项目组的双重管理', '属于', '项目管理的缺点']\n",
      "['项目经理需要较强的谈判技巧', '属于', '项目管理的缺点']\n",
      "['项目组成员不容易全心投入项目', '属于', '项目管理的缺点']\n",
      "['WBS', '属于', '工作分解结构']\n",
      "['工作包', '属于', 'WBS']\n",
      "['80小时法则或两周法则', '属于', 'WBS']\n",
      "['需求分析', '属于', 'WBS 分解过程']\n",
      "['定义阶段', '属于', 'WBS 分解过程']\n",
      "['开发活动', '属于', 'WBS 层次分解']\n",
      "['开发任务', '属于', 'WBS 层次分解']\n",
      "['层次分解', '属于', 'WBS']\n",
      "['依赖关系', '关联于', 'WBS']\n",
      "['关键路径', '关联于', 'WBS']\n",
      "['甘特图(Gantt Chart)', '属于', '项目管理技术']\n",
      "['进度计划方法', '描述', '甘特图']\n",
      "['单项工程内容进度', '表示于', '甘特图']\n",
      "['子任务', '在甘特图中表示', '开始时间和完成时间']\n",
      "['80小时法则或两周法则', '应用于', '工作包定义']\n",
      "['计划评审技术（PERT）', '属于', '项目管理技术']\n",
      "['概率论', '引用于', 'PERT 的作业时间估计']\n",
      "['β分布原理', '引用于', 'PERT 的作业时间估计']\n",
      "['乐观工期a', '属于', 'PERT 作业时间估计参数']\n",
      "['最可能工期m', '属于', 'PERT 作业时间估计参数']\n",
      "['悲观工期b', '属于', 'PERT 作业时间估计参数']\n",
      "['网络计算', '包括', '最早开始时间ES、最早结束时间EF计算']\n",
      "['网络计算', '包括', '最晚开始时间LS、最晚结束时间LF计算']\n",
      "['网络计算', '包括', '浮动时间TF计算']\n",
      "['前推法(Forward Pass)', '用于', '最早时间计算']\n",
      "['逆推法(Backward Pass)', '用于', '最晚时间计算']\n",
      "['关键路径', '通过', '网络计算确定']\n",
      "['关键任务', '位于', '关键路径上']\n",
      "['浮动时间', '关联于', '非关键任务']\n",
      "['网上订餐系统', '属于', '案例：某系统开发项目管理']\n",
      "案例：某系统开发项目管理\n",
      "['协商范围阶段', '属于', '案例：某系统开发项目管理']\n",
      "['系统分析', '属于', '案例：某系统开发项目管理']\n",
      "['收集需求', '属于', '系统分析']\n",
      "['分析过程', '属于', '系统分析']\n",
      "['分析数据', '属于', '系统分析']\n",
      "['系统设计', '属于', '案例：某系统开发项目管理']\n",
      "['设计过程', '属于', '系统设计']\n",
      "['设计数据', '属于', '系统设计']\n",
      "['设计屏幕', '属于', '系统设计']\n",
      "['设计报告', '属于', '系统设计']\n",
      "['系统实现', '属于', '案例：某系统开发项目管理']\n",
      "['程序', '属于', '系统实现']\n",
      "['测试和文档', '属于', '系统实现']\n",
      "['安装', '属于', '系统实现']\n",
      "['估计任务周期和任务之间依赖关系', '属于', '案例：某系统开发项目管理']\n",
      "['分配资源', '属于', '案例：某系统开发项目管理']\n",
      "['监督和控制项目进展', '属于', '案例：某系统开发项目管理']\n",
      "['项目经理角色', '属于', '本章小结']\n",
      "['项目发起', '属于', '项目经理角色']\n",
      "['项目规划', '属于', '项目经理角色']\n",
      "['项目执行', '属于', '项目经理角色']\n",
      "['项目终结', '属于', '项目经理角色']\n",
      "['甘特图', '提及', '项目管理图形化技术']\n",
      "['网络图', '提及', '项目管理图形化技术']\n",
      "['关键路径规划', '属于', '网络图']\n",
      "['自动化工具支持', '属于', '项目管理辅助手段']\n",
      "['案例分析', '属于', '案例：某系统开发项目管理']\n",
      "['银行前置机的软件系统项目', '属于', '案例分析']\n",
      "['项目经理小丁', '担任', '案例分析']\n",
      "本章小结\n",
      "['本章小结', '包含', '管理信息系统项目']\n",
      "['本章小结', '包含', '项目经理']\n",
      "['项目经理', '具备', '技术和管理技能']\n",
      "['项目经理', '负责', '确定项目的规模、范围和资源需求']\n",
      "['项目经理', '保证', '满足客户的要求']\n",
      "['项目经理', '在', '预算约束']\n",
      "['项目经理', '在', '时间约束']\n",
      "['项目经理', '执行', '项目发起']\n",
      "['项目发起', '包括', '评估项目的大小、范围和复杂性']\n",
      "['项目发起', '包括', '建立支持后续项目活动的规程']\n",
      "['项目经理', '执行', '项目规划']\n",
      "['项目规划', '涉及', '定义清楚的、离散的活动']\n",
      "['项目规划', '涉及', '完成每个活动需要做的工作']\n",
      "['项目经理', '执行', '项目执行']\n",
      "['项目执行', '是', '将计划付诸于行动']\n",
      "['项目经理', '执行', '项目终结']\n",
      "['项目终结', '指向', '把项目带到结束']\n",
      "['项目管理工具', '包含', '甘特图']\n",
      "['甘特图', '展示', '活动的开始、工期和结束']\n",
      "['项目管理工具', '包含', '网络图']\n",
      "['网络图', '属于', '关键路径规划技术']\n",
      "['网络图', '描绘', '活动之间的相互关系']\n",
      "['关键路径规划', '影响', '项目活动顺序和工期']\n",
      "['项目监控', '使用', '甘特图']\n",
      "['项目监控', '使用', '网络图']\n",
      "['项目经理', '利用', '自动化工具']\n",
      "['自动化工具', '支持', '任务定义和排序']\n",
      "['自动化工具', '支持', '任务资源分配']\n",
      "['自动化工具', '支持', '任务和资源修改能力']\n",
      "['本章小结', '包含', '案例分析']\n",
      "['案例分析', '提及', '系统集成公司']\n",
      "['案例分析', '提及', '销售部']\n",
      "['案例分析', '提及', '软件开发部']\n",
      "['案例分析', '提及', '系统网络部']\n",
      "['案例分析', '描述', '银行前置机软件系统项目']\n",
      "['项目经理小丁', '担任', '首次担任项目经理']\n",
      "['项目经理小丁', '有经验于', '系统分析工作']\n",
      "['项目经理小丁', '在项目中', '兼任系统分析']\n",
      "['案例分析', '列出', '项目团队成员构成']\n",
      "案例分析\n",
      "['案例分析', '属于', '本章内容']\n",
      "['项目经理角色', '属于', '案例分析']\n",
      "['项目管理流程', '属于', '案例分析']\n",
      "['项目发起阶段', '属于', '项目管理流程']\n",
      "['项目规划阶段', '属于', '项目管理流程']\n",
      "['项目执行阶段', '属于', '项目管理流程']\n",
      "['项目终结阶段', '属于', '项目管理流程']\n",
      "['甘特图', '属于', '项目管理工具']\n",
      "['网络图', '属于', '项目管理工具']\n",
      "['关键路径法', '属于', '项目管理工具']\n",
      "['WBS（工作分解结构）', '属于', '项目规划阶段']\n",
      "['风险管理', '属于', '项目发起阶段']\n",
      "['沟通与管理问题', '属于', '案例分析']\n",
      "['项目进度监控', '属于', '项目管理流程']\n",
      "['里程碑', '用于', '项目进度管理']\n",
      "['任务依赖关系', '用于', '项目计划制定']\n",
      "['期望时间计算', '属于', '活动时间估算']\n",
      "['最早结束时间(EF)', '用于', '项目进度计算']\n",
      "['最晚结束时间(LF)', '用于', '项目进度计算']\n",
      "['松弛时间', '用于', '项目进度控制']\n",
      "['关键路径确定', '属于', '网络图应用']\n",
      "['需求获取', '属于', '系统分析']\n",
      "['访谈技术', '属于', '需求获取方法']\n",
      "['观察工作者方式', '属于', '需求获取方法']\n",
      "['业务文档分析', '属于', '需求获取方法']\n",
      "['计算机支持', '用于', '需求获取过程']\n",
      "['联合应用设计会议', '属于', '需求获取活动']\n",
      "['原型方法', '属于', '需求获取方法']\n",
      "['现代化需求获取方法', '用于', '系统开发生命周期']\n",
      "['网络应用开发', '涉及', '需求获取技术']\n",
      "['系统需求获取的重要性', '属于', '第4章内容']\n",
      "['需求结构化', '属于', '系统分析阶段']\n",
      "系统需求概述\n",
      "['需求获取的重要性', '属于', '系统需求概述']\n",
      "['需求获取的过程和方法', '属于', '系统需求概述']\n",
      "['访谈的选择与访谈计划的制订', '属于', '需求获取的过程和方法']\n",
      "['观察工作者方式确定系统需求的优缺点', '属于', '需求获取的过程和方法']\n",
      "['计算支持在需求获取中的作用', '属于', '需求获取的过程和方法']\n",
      "['联合应用设计会议的参与和计划', '属于', '需求获取的过程和方法']\n",
      "['原型在需求获取过程中的应用', '属于', '需求获取的过程和方法']\n",
      "['现代化方法确定需求', '属于', '需求获取的过程和方法']\n",
      "['需求获取技术在网络应用开发中的应用', '属于', '系统需求概述']\n",
      "['系统需求概述', '属于', '第4章 需求获取']\n",
      "['需求获取是系统分析的一部分', '属于', '系统需求概述']\n",
      "['需求获取涉及的主要技能', '属于', '系统需求概述']\n",
      "['需求获取失败的严重后果', '属于', '系统需求概述']\n",
      "['系统分析员在需求获取中的角色', '属于', '系统需求概述']\n",
      "['全面确定需求的重要性', '属于', '系统需求概述']\n",
      "['需求获取中用户类需要和限制的理解', '属于', '系统需求概述']\n",
      "['系统功能需求的来源', '属于', '系统需求概述']\n",
      "['客户需求理解的重要性', '属于', '系统需求概述']\n",
      "['客户—开发者合作对于需求获取成功的关键性', '属于', '系统需求概述']\n",
      "['影响客户确定需求顺利的因素', '属于', '系统需求概述']\n",
      "['信息系统开发者在需求获取中存在的问题', '属于', '系统需求概述']\n",
      "['系统需求分类', '属于', '系统需求概述']\n",
      "['用户视角下的系统需求', '属于', '系统需求分类']\n",
      "['开发者视角下的系统需求', '属于', '系统需求分类']\n",
      "['业务需求', '属于', '系统需求分类']\n",
      "['用户需求', '属于', '系统需求分类']\n",
      "['功能需求', '属于', '系统需求分类']\n",
      "['非功能需求', '属于', '系统需求分类']\n",
      "需求获取过程\n",
      "['需求获取过程', '包含', '了解用户需求']\n",
      "['需求获取过程', '包含', '分析用户需求']\n",
      "['需求获取过程', '包含', '编写需求文档']\n",
      "['需求获取过程', '包含', '评审需求文档']\n",
      "['需求获取过程', '包含', '需求管理']\n",
      "['需求管理', '包含', '需求变更']\n",
      "['需求管理', '包含', '需求跟踪']\n",
      "['需求获取途径', '属于', '需求获取过程']\n",
      "['了解用户需求', '属于', '需求获取过程']\n",
      "['分析用户需求', '属于', '需求获取过程']\n",
      "['编写需求文档', '属于', '需求获取过程']\n",
      "['评审需求文档', '属于', '需求获取过程']\n",
      "['访谈', '属于', '需求获取方法']\n",
      "['观察和分析文档的笔记', '属于', '需求获取途径']\n",
      "['书面信息来源', '属于', '需求获取途径']\n",
      "['基于计算机的信息来源', '属于', '需求获取途径']\n",
      "['需求变更', '属于', '需求管理']\n",
      "['需求跟踪', '属于', '需求管理']\n",
      "需求获取的方法\n",
      "['需求跟踪矩阵', '属于', '需求获取的方法']\n",
      "['访谈', '属于', '需求获取的方法']\n",
      "['访谈前提', '属于', '访谈']\n",
      "['关键的信息持有者', '属于', '访谈前提']\n",
      "['访谈准备', '属于', '访谈']\n",
      "['用户访谈和调研的准备', '属于', '访谈准备']\n",
      "['访谈提纲', '属于', '访谈准备']\n",
      "['联合应用设计(JAD)', '属于', '需求获取的方法']\n",
      "['名义团体技术(NGT)', '属于', '需求获取的方法']\n",
      "['直接观察用户', '属于', '需求获取的方法']\n",
      "['文档、文件、表格抽样', '属于', '需求获取的方法']\n",
      "['书面工作规程', '属于', '文档、文件、表格抽样']\n",
      "['业务表格', '属于', '文档、文件、表格抽样']\n",
      "['现有系统产生的报告', '属于', '文档、文件、表格抽样']\n",
      "['联合应用设计会议的角色', '属于', '联合应用设计(JAD)']\n",
      "['JAD会议经理', '属于', '联合应用设计会议的角色']\n",
      "['用户', '属于', '联合应用设计会议的角色']\n",
      "['管理者', '属于', '联合应用设计会议的角色']\n",
      "['发起人', '属于', '联合应用设计会议的角色']\n",
      "['系统分析员', '属于', '联合应用设计会议的角色']\n",
      "['抄写员', '属于', '联合应用设计会议的角色']\n",
      "['IS人员', '属于', '联合应用设计会议的角色']\n",
      "['原型法', '属于', '需求获取的方法']\n",
      "['需求调查分析', '属于', '原型法']\n",
      "['需求原型设计', '属于', '原型法']\n",
      "['需求评审', '属于', '原型法']\n",
      "案例分析——客户关系管理系统的需求获取\n",
      "['需求原型设计要求', '属于', '需求原型设计']\n",
      "['充分考虑系统的设计与实现', '属于', '需求原型设计要求']\n",
      "['仿真实际系统的操作界面', '属于', '需求原型设计要求']\n",
      "['单机安装运行', '属于', '需求原型设计要求']\n",
      "['演示数据的存储方式', '属于', '需求原型设计要求']\n",
      "['功能帮助按钮', '属于', '需求原型设计要求']\n",
      "['标注详细说明复杂功能', '属于', '需求原型设计要求']\n",
      "['运行稳定，硬件要求低', '属于', '需求原型设计要求']\n",
      "['需求评审', '属于', '案例分析——客户关系管理系统的需求获取']\n",
      "['评审团成员构成', '属于', '需求评审']\n",
      "['评审依据', '属于', '需求评审']\n",
      "['评审目标', '属于', '需求评审']\n",
      "['需求分析说明书的要求', '属于', '评审目标']\n",
      "['需求评审报告的作用', '属于', '需求评审']\n",
      "['原型法进行需求获取的应用情况', '属于', '案例分析——客户关系管理系统的需求获取']\n",
      "['原型法的缺点', '属于', '原型法进行需求获取']\n",
      "['正式系统需求文档的缺失', '属于', '原型法的缺点']\n",
      "['针对最初用户的局限性', '属于', '原型法的缺点']\n",
      "['忽略与其他系统的共享和交互', '属于', '原型法的缺点']\n",
      "['绕过 SDLC 中的检查', '属于', '原型法的缺点']\n",
      "['音像连锁店的客户关系管理系统', '属于', '案例分析——客户关系管理系统的需求获取']\n",
      "['基于 WEB 的系统', '属于', '音像连锁店的客户关系管理系统']\n",
      "['信息服务功能', '属于', '音像连锁店的客户关系管理系统']\n",
      "['客户需求调研方案', '属于', '案例分析——客户关系管理系统的需求获取']\n",
      "['系统所有者面谈问题设置', '属于', '客户需求调研方案']\n",
      "['公司整体发展战略', '属于', '系统所有者面谈问题设置']\n",
      "['预期效果', '属于', '系统所有者面谈问题设置']\n",
      "['项目预算', '属于', '系统所有者面谈问题设置']\n",
      "['项目工期', '属于', '系统所有者面谈问题设置']\n",
      "['系统预期使用寿命', '属于', '系统所有者面谈问题设置']\n",
      "['系统处理能力', '属于', '系统所有者面谈问题设置']\n",
      "['系统使用部门及权限分配', '属于', '系统所有者面谈问题设置']\n",
      "['信息公开程度', '属于', '系统所有者面谈问题设置']\n",
      "['客户反馈处理', '属于', '系统所有者面谈问题设置']\n",
      "['响应新产品请求的时间', '属于', '系统所有者面谈问题设置']\n",
      "['更新库存信息时间', '属于', '系统所有者面谈问题设置']\n",
      "['系统用户调研策略', '属于', '客户需求调研方案']\n",
      "['门店经理面谈问题设置', '属于', '系统用户调研策略']\n",
      "['现有客户服务内容', '属于', '门店经理面谈问题设置']\n",
      "['租赁期限', '属于', '门店经理面谈问题设置']\n",
      "['新产品请求收集处理', '属于', '门店经理面谈问题设置']\n",
      "['客户调查表问题设置', '属于', '系统用户调研策略']\n",
      "['产品评价反馈', '属于', '客户调查表问题设置']\n",
      "['新产品需求告知方式', '属于', '客户调查表问题设置']\n",
      "['租赁到期查询', '属于', '客户调查表问题设置']\n",
      "['优惠续借', '属于', '客户调查表问题设置']\n",
      "['库存查询', '属于', '客户调查表问题设置']\n",
      "['子女购买租赁商品信息', '属于', '客户调查表问题设置']\n",
      "['库存管理员实地访问面谈问题设置', '属于', '客户需求调研方案']\n",
      "['库存策略', '属于', '库存管理员实地访问面谈问题设置']\n",
      "['库存信息流动', '属于', '库存管理员实地访问面谈问题设置']\n",
      "['供应商接口预留', '属于', '库存管理员实地访问面谈问题设置']\n",
      "['门店间库存差异', '属于', '库存管理员实地访问面谈问题设置']\n",
      "['最低订购点', '属于', '库存管理员实地访问面谈问题设置']\n",
      "['订单发货周期', '属于', '库存管理员实地访问面谈问题设置']\n",
      "本章小结\n",
      "['需求获取', '属于', '本章小结']\n",
      "['了解用户需求', '属于', '需求获取']\n",
      "['分析用户需求', '属于', '需求获取']\n",
      "['编写需求文档', '属于', '需求获取']\n",
      "['评审需求文档', '属于', '需求获取']\n",
      "['需求管理', '属于', '需求获取']\n",
      "['逻辑过程建模', '属于', '过程建模']\n",
      "任务执行超时\n",
      "['数据流图', '属于', '过程建模']\n",
      "任务执行超时\n",
      "['绘制数据流图', '属于', '数据流图']\n",
      "任务执行超时\n",
      "['过程模型', '属于', '数据流图']\n",
      "任务执行超时\n",
      "['逻辑模型', '属于', '过程建模']\n",
      "任务执行超时\n",
      "过程建模\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "['逻辑过程建模', '属于', '过程建模']\n",
      "任务执行超时\n",
      "['数据流图绘制规则', '属于', '过程建模']\n",
      "任务执行超时\n",
      "['低层次图形分解', '属于', '过程建模']\n",
      "任务执行超时\n",
      "['高层与低层数据流图平衡', '属于', '过程建模']\n",
      "任务执行超时\n",
      "['四种类型的数据流图区别', '属于', '过程建模']\n",
      "任务执行超时\n",
      "['当前的物理流程图', '属于', '四种类型的数据流图区别']\n",
      "['当前的逻辑流程图', '属于', '四种类型的数据流图区别']\n",
      "['新的物理流程图', '属于', '四种类型的数据流图区别']\n",
      "['新的逻辑流程图', '属于', '四种类型的数据流图区别']\n",
      "['信息系统分析支持', '属于', '过程建模']\n",
      "任务执行超时\n",
      "['规范化方法表达需求', '属于', '过程建模']\n",
      "任务执行超时\n",
      "['数据流图（DFD）', '属于', '过程建模']\n",
      "任务执行超时\n",
      "['过程模型', '由', '数据流图（DFD）']\n",
      "['逻辑模型', '属于', '过程建模']\n",
      "任务执行超时\n",
      "['非技术性图形化表示', '属于', '逻辑模型']\n",
      "['概念模型', '等于', '逻辑模型']\n",
      "['业务模型', '等于', '逻辑模型']\n",
      "['数据流图的概念和作用', '属于', '数据流图（DFD）']\n",
      "['系统数据转换和流动状况描述', '属于', '数据流图（DFD）']\n",
      "['内部逻辑概括', '属于', '数据流图（DFD）']\n",
      "['理解用户需求工具', '属于', '数据流图（DFD）']\n",
      "['用户沟通交流工具', '属于', '数据流图（DFD）']\n",
      "['新系统逻辑模型组成部分', '属于', '数据流图（DFD）']\n",
      "['数据流程图基本符号', '属于', '数据流图（DFD）']\n",
      "['外部实体', '是', '数据流程图基本符号组成部分']\n",
      "['处理过程', '是', '数据流程图基本符号组成部分']\n",
      "['数据存储', '是', '数据流程图基本符号组成部分']\n",
      "['系统中数据流', '是', '数据流程图基本符号组成部分']\n",
      "数据流图\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "['数据流图', '属于', '过程建模']\n",
      "任务执行超时\n",
      "['逻辑过程建模', '属于', '过程建模']\n",
      "任务执行超时\n",
      "['当前的物理流程图', '属于', '数据流图']\n",
      "任务执行超时\n",
      "['当前的逻辑流程图', '属于', '数据流图']\n",
      "任务执行超时\n",
      "['新的物理流程图', '属于', '数据流图']\n",
      "任务执行超时\n",
      "['新的逻辑流程图', '属于', '数据流图']\n",
      "任务执行超时\n",
      "['逻辑模型', '属于', '过程建模']\n",
      "任务执行超时\n",
      "['数据流程图的概念和作用', '属于', '数据流图']\n",
      "任务执行超时\n",
      "['外部实体', '属于', '数据流图']\n",
      "任务执行超时\n",
      "['过程', '属于', '数据流图']\n",
      "任务执行超时\n",
      "['数据流', '属于', '数据流图']\n",
      "任务执行超时\n",
      "['数据存储', '属于', '数据流图']\n",
      "任务执行超时\n",
      "['数据流图的绘制', '属于', '数据流图']\n",
      "任务执行超时\n",
      "['顶层图', '属于', '数据流图的绘制']\n",
      "['0层图', '属于', '数据流图的绘制']\n",
      "2.0 层数据流图\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "['顶层图', '属于', '分层数据流程图']\n",
      "['环境图', '等于', '顶层图']\n",
      "['0 层数据流图', '属于', '分层数据流程图']\n",
      "['中间层流图', '细化', '上层父图']\n",
      "['基本处理', '组成', '底层']\n",
      "['子图', '属于', '父图']\n",
      "['接收并转换客户订单过程', '属于', '食品订餐系统']\n",
      "['更新已销售文件过程', '属于', '食品订餐系统']\n",
      "['更新库存文件过程', '属于', '食品订餐系统']\n",
      "['产生管理报告过程', '属于', '食品订餐系统']\n",
      "['数据存储', '关联于', '数据流']\n",
      "['数据流规则', '应用于', '分层数据流程图']\n",
      "['命名规则', '属于', '数据流规则']\n",
      "['过程规则', '属于', '数据流规则']\n",
      "['数据存储规则', '属于', '数据流规则']\n",
      "['外部实体规则', '属于', '数据流规则']\n",
      "['数据流规则', '属于', '数据流规则']\n",
      "['DFD 的分解', '涉及', '分层数据流程图']\n",
      "['功能分解', '实现', 'DFD 的分解']\n",
      "['基本 DFD', '为', '最低层次的 DFD']\n",
      "['平衡 DFD', '保证', '输入和输出的一致性']\n",
      "['组合数据流', '可以分解为', '组件数据流']\n",
      "['过程逻辑', '描述', 'DFD 中的基本过程']\n",
      "过程逻辑\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "['过程逻辑', '属于', '第五章']\n",
      "任务执行超时\n",
      "['管控数据流图的高级规则', '属于', '过程逻辑']\n",
      "任务执行超时\n",
      "['组合数据流分解', '属于', '管控数据流图的高级规则']\n",
      "['过程输入与输出的关系', '属于', '管控数据流图的高级规则']\n",
      "['在最底层DFD中添加新数据流的原因', '属于', '管控数据流图的高级规则']\n",
      "['避免数据流线交叉的方法', '属于', '管控数据流图的高级规则']\n",
      "['数据流图的作用', '属于', '过程逻辑']\n",
      "任务执行超时\n",
      "['数据流图与程序流程图的区别', '属于', '过程逻辑']\n",
      "任务执行超时\n",
      "['逻辑模型的有效沟通', '属于', '过程逻辑']\n",
      "任务执行超时\n",
      "['结构化语言', '属于', '过程逻辑']\n",
      "任务执行超时\n",
      "['顺序结构', '属于', '结构化语言']\n",
      "['祈使语句', '属于', '顺序结构']\n",
      "['选择结构', '属于', '结构化语言']\n",
      "['多重选择', '属于', '选择结构']\n",
      "['Do-Until循环', '属于', '结构化语言']\n",
      "['Do-While循环', '属于', '结构化语言']\n",
      "['决策表', '属于', '过程逻辑']\n",
      "任务执行超时\n",
      "['条件段', '属于', '决策表']\n",
      "['行动段', '属于', '决策表']\n",
      "['规则', '属于', '决策表']\n",
      "['规则合并', '属于', '决策表']\n",
      "['无关条件', '属于', '决策表']\n",
      "['构造决策表的基本步骤', '属于', '决策表']\n",
      "['决策树', '属于', '过程逻辑']\n",
      "任务执行超时\n",
      "['决策点', '属于', '决策树']\n",
      "['行动', '属于', '决策树']\n",
      "['邮寄包收费标准问题逻辑建模', '涉及', '结构化语言,决策表,决策树']\n",
      "['数据字典', '属于', '第五章']\n",
      "任务执行超时\n",
      "['数据项', '属于', '数据字典']\n",
      "任务执行超时\n",
      "['数据结构', '属于', '数据字典']\n",
      "任务执行超时\n",
      "['数据流', '属于', '数据字典']\n",
      "任务执行超时\n",
      "['数据存储', '属于', '数据字典']\n",
      "任务执行超时\n",
      "['处理功能', '属于', '数据字典']\n",
      "任务执行超时\n",
      "['外部项', '属于', '数据字典']\n",
      "任务执行超时\n",
      "['数据项字典内容', '属于', '数据项']\n",
      "数据字典\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "['数据项', '属于', '数据字典']\n",
      "任务执行超时\n",
      "['数据结构', '属于', '数据字典']\n",
      "任务执行超时\n",
      "['数据流', '属于', '数据字典']\n",
      "任务执行超时\n",
      "['数据存储', '属于', '数据字典']\n",
      "任务执行超时\n",
      "['过程', '属于', '数据字典']\n",
      "任务执行超时\n",
      "['手工方式生成数据字典', '属于', '数据字典']\n",
      "任务执行超时\n",
      "['计算机辅助生成数据字典', '属于', '数据字典']\n",
      "任务执行超时\n",
      "['动态数据', '属于', '数据字典']\n",
      "任务执行超时\n",
      "['静态数据', '属于', '数据字典']\n",
      "任务执行超时\n",
      "['数据项名称', '属于', '数据项']\n",
      "['数据项类型', '属于', '数据项']\n",
      "['数据项长度', '属于', '数据项']\n",
      "['取值范围和含义', '属于', '数据项']\n",
      "['数据结构组成', '属于', '数据结构']\n",
      "['数据流来源', '属于', '数据流']\n",
      "['数据流去向', '属于', '数据流']\n",
      "['数据流流通量', '属于', '数据流']\n",
      "['过程名', '属于', '过程']\n",
      "['触发条件', '属于', '过程']\n",
      "['优先级', '属于', '过程']\n",
      "['输入输出', '属于', '过程']\n",
      "['过程逻辑', '属于', '过程']\n",
      "\n",
      "['流入流出的数据流', '属于', '数据存储']\n",
      "['数据存储组成', '属于', '数据存储']\n",
      "['组织方式', '属于', '数据存储']\n",
      "['查询要求', '属于', '数据存储']\n",
      "过程建模步骤\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "['过程建模步骤', '属于', '百货商店业务管理信息系统']\n",
      "任务执行超时\n",
      "['数据流图', '属于', '过程建模步骤']\n",
      "任务执行超时\n",
      "['数据字典', '属于', '过程建模步骤']\n",
      "任务执行超时\n",
      "['系统分析', '属于', '过程建模步骤']\n",
      "任务执行超时\n",
      "['顶层数据流程图', '属于', '数据流图']\n",
      "任务执行超时\n",
      "['一级分解数据流程图', '属于', '数据流图']\n",
      "任务执行超时\n",
      "['二级分解数据流程图', '属于', '数据流图']\n",
      "任务执行超时\n",
      "['销售处理功能', '属于', '二级分解数据流程图']\n",
      "['采购处理功能', '属于', '二级分解数据流程图']\n",
      "['会计处理功能', '属于', '二级分解数据流程图']\n",
      "['数据存储', '属于', '数据流图']\n",
      "任务执行超时\n",
      "['数据流', '属于', '数据流图']\n",
      "任务执行超时\n",
      "['数据项定义', '属于', '数据字典']\n",
      "任务执行超时\n",
      "['数据处理字典', '属于', '数据字典']\n",
      "任务执行超时\n",
      "['新系统顶层数据流程', '属于', '顶层数据流程图']\n",
      "['系统目标', '属于', '系统分析']\n",
      "['登记整理数据', '属于', '系统目标']\n",
      "['核对顾客订货单', '属于', '系统目标']\n",
      "['提供业务统计报表', '属于', '系统目标']\n",
      "['各级查询', '属于', '系统目标']\n",
      "['业务数据处理自动化', '属于', '系统目标']\n",
      "['销售子系统', '属于', '新系统']\n",
      "['采购子系统', '属于', '新系统']\n",
      "['会计子系统', '属于', '新系统']\n",
      "['编辑处理', '属于', '销售处理功能']\n",
      "['建立收款明细帐', '属于', '销售处理功能']\n",
      "['编制报表处理', '属于', '会计处理功能']\n",
      "['应收款明细帐', '流入', '建立收款明细帐']\n",
      "['订单处理', '属于', '销售子系统']\n",
      "['缺货处理', '属于', '销售子系统']\n",
      "['自动登记新顾客数据', '属于', '销售子系统功能']\n",
      "['建立售货历史记录', '属于', '销售子系统功能']\n",
      "['修改库存记录', '属于', '销售子系统功能']\n",
      "['缺货单汇总', '属于', '采购子系统功能']\n",
      "['缺货货物统计', '属于', '采购子系统功能']\n",
      "['编发订货单', '属于', '采购子系统功能']\n",
      "['核对订货单', '属于', '采购子系统功能']\n",
      "['修改库存', '属于', '采购子系统功能']\n",
      "['数据汇总计算工作', '属于', '会计子系统功能']\n",
      "['报表编制打印', '属于', '会计子系统功能']\n",
      "本章小结\n",
      "['结构化分析', '属于', '本章小结']\n",
      "['数据流图（DFD）', '属于', '结构化分析']\n",
      "['数据字典（DD）', '属于', '结构化分析']\n",
      "['结构化语言', '属于', '结构化分析']\n",
      "['判定树', '属于', '结构化分析']\n",
      "['判定表', '属于', '结构化分析']\n",
      "['数据流程图分解法', '属于', '结构化分析']\n",
      "['子系统', '属于', '数据流程图分解法']\n",
      "['数据接口', '属于', '数据流程图分解法']\n",
      "['大学课程注册系统', '示例', '数据流程图分解法']\n",
      "['图书馆外文采购室业务流程', '练习与思考', '本章小结']\n",
      "['设备购置流程', '练习与思考', '本章小结']\n",
      "['员工招聘系统', '练习与思考', '本章小结']\n",
      "['医院药房系统', '练习与思考', '本章小结']\n",
      "['政府采购流程', '练习与思考', '本章小结']\n",
      "['保险索赔财务系统', '练习与思考', '本章小结']\n",
      "['数据建模', '主题', '本章小结']\n",
      "['实体类型', '属于', '数据建模']\n",
      "['属性', '属于', '数据建模']\n",
      "['多值属性', '属于', '数据建模']\n",
      "['联系', '属于', '数据建模']\n",
      "['度', '属于', '数据建模']\n",
      "['基数', '属于', '数据建模']\n",
      "['业务规则', '属于', '数据建模']\n",
      "['关联实体', '属于', '数据建模']\n",
      "['触发', '属于', '数据建模']\n",
      "['超类', '属于', '数据建模']\n",
      "['子类', '属于', '数据建模']\n",
      "['对象', '属于', '数据建模']\n",
      "['状态', '属于', '数据建模']\n",
      "['行为', '属于', '数据建模']\n",
      "['对象类', '属于', '数据建模']\n",
      "['类图', '属于', '数据建模']\n",
      "['操作', '属于', '数据建模']\n",
      "['封装', '属于', '数据建模']\n",
      "['关联角色', '属于', '数据建模']\n",
      "['抽象类', '属于', '数据建模']\n",
      "['多态性', '属于', '数据建模']\n",
      "['聚合', '属于', '数据建模']\n",
      "['合成', '属于', '数据建模']\n",
      "['E-R 图', '属于', '数据建模']\n",
      "['逻辑模型', '转换自', '数据建模']\n",
      "['物理数据模型', '转换自', '逻辑模型']\n",
      "['数据库建模', '等同于', '数据建模']\n",
      "['实体-关系模型', '代表', 'E-R 图']\n",
      "['概念模型', '描述', '实体-关系模型']\n",
      "['Martin 记法', '应用于', 'E-R 图']\n",
      "数据建模相关概念\n",
      "['实体类型', '属于', '数据建模']\n",
      "['属性', '属于', '实体类型']\n",
      "['多值属性', '属于', '属性']\n",
      "['联系', '属于', '数据建模']\n",
      "['度', '属于', '联系']\n",
      "['基数', '属于', '联系']\n",
      "['业务规则', '属于', '数据建模']\n",
      "['关联实体', '属于', '数据建模']\n",
      "['触发', '属于', '数据建模']\n",
      "['超类', '属于', '数据建模']\n",
      "['子类', '属于', '数据建模']\n",
      "['对象', '属于', '数据建模']\n",
      "['状态', '属于', '对象']\n",
      "['行为', '属于', '对象']\n",
      "['对象类', '属于', '数据建模']\n",
      "['类图', '属于', '数据建模']\n",
      "['操作', '属于', '对象类']\n",
      "['封装', '属于', '对象类']\n",
      "['关联角色', '属于', '类图']\n",
      "['抽象类', '属于', '类图']\n",
      "['多态性', '属于', '类图']\n",
      "['聚合', '属于', '类图']\n",
      "['合成', '属于', '类图']\n",
      "['E-R 图', '属于', '数据建模']\n",
      "['实体-联系模型', '等于', 'E-R 模型']\n",
      "['逻辑数据模型', '属于', '数据建模']\n",
      "['概念数据建模', '属于', '数据建模']\n",
      "['标识符', '属于', '实体类型']\n",
      "['候选码', '属于', '实体类型']\n",
      "['替代码', '属于', '候选码']\n",
      "['复合码', '属于', '实体类型']\n",
      "['外码', '属于', '实体类型']\n",
      "['主码', '属于', '实体类型']\n",
      "['副码', '属于', '候选码']\n",
      "['子集准则', '属于', '属性']\n",
      "['一元联系', '属于', '联系']\n",
      "['二元联系', '属于', '联系']\n",
      "['三元联系', '属于', '联系']\n",
      "['关联实体', '属于', '联系']\n",
      "逻辑数据建模过程\n",
      "['确定基本实体', '属于', '逻辑数据建模过程']\n",
      "['业务的主题/对象', '属于', '确定基本实体']\n",
      "['业务使用的人、地方、东西、材料、事件', '属于', '确定基本实体']\n",
      "['数据实体及其说明', '属于', '确定基本实体']\n",
      "['主码', '属于', '确定基本实体']\n",
      "['属性及副码', '属于', '确定基本实体']\n",
      "['安全控制', '属于', '确定基本实体']\n",
      "['数据的时间维', '属于', '确定基本实体']\n",
      "['超类、子类、聚合', '属于', '确定基本实体']\n",
      "['联系及其基数和度', '属于', '确定基本实体']\n",
      "['完整性控制', '属于', '确定基本实体']\n",
      "['最大最小基数', '属于', '确定基本实体']\n",
      "['建立实体间的关联', '属于', '逻辑数据建模过程']\n",
      "['实体实例的基数', '属于', '建立实体间的关联']\n",
      "['一对一联系', '属于', '实体实例的基数']\n",
      "['一对多联系', '属于', '实体实例的基数']\n",
      "['多对多联系', '属于', '实体实例的基数']\n",
      "['主码和属性', '属于', '逻辑数据建模过程']\n",
      "['智能码', '属于', '主码和属性']\n",
      "['规范化', '属于', '逻辑数据建模过程']\n",
      "['第一范式', '属于', '规范化']\n",
      "['第二范式', '属于', '规范化']\n",
      "['第三范式', '属于', '规范化']\n",
      "['关系模式设计要求', '属于', '规范化']\n",
      "['无冗余性', '属于', '关系模式设计要求']\n",
      "['灵活性', '属于', '关系模式设计要求']\n",
      "['适应性', '属于', '关系模式设计要求']\n",
      "['第一范式定义', '属于', '第一范式']\n",
      "['职工关系表', '用于举例', '第一范式']\n",
      "规范化\n",
      "['第一范式(1NF)', '属于', '规范化']\n",
      "['第二范式(2NF)', '属于', '规范化']\n",
      "['第三范式(3NF)', '属于', '规范化']\n",
      "['主码', '在', '规范化']\n",
      "['数据冗余', '处理方式', '规范化']\n",
      "['无冗余', '要求', '规范化']\n",
      "['灵活适应性', '设计目标', '规范化']\n",
      "['实体', '属性设计', '规范化']\n",
      "['不可再分的数据项', '定义', '第一范式(1NF)']\n",
      "['完全依赖于主码', '条件', '第二范式(2NF)']\n",
      "['传递依赖', '消除', '第三范式(3NF)']\n",
      "['关系模式分解', '实现手段', '规范化']\n",
      "['数据-过程模型映射', '与规范化的关系', '规范化']\n",
      "['CRUD 矩阵', '用于', '数据-过程模型映射']\n",
      "数据-过程模型映射\n",
      "['第三范式', '属于', '关系规范化']\n",
      "['2NF', '属于', '关系规范化']\n",
      "['传递依赖', '属于', '关系规范化']\n",
      "['数据冗余', '关联', '关系规范化']\n",
      "['一致性', '关联', '关系规范化']\n",
      "['数据库维护', '关联', '关系规范化']\n",
      "['实体', '在', '数据-过程模型映射']\n",
      "['过程模型', '在', '数据-过程模型映射']\n",
      "['CRUD 矩阵', '用于', '数据-过程模型映射']\n",
      "['系统完整性检查', '使用', 'CRUD 矩阵']\n",
      "['客户应用处理', '包含', 'C(创建)']\n",
      "['客户信用处理', '包含', 'C(创建)']\n",
      "['客户地址变更处理', '涉及', '客户实体']\n",
      "['内部客户信用变更处理', '涉及', '客户实体']\n",
      "['新客户订单处理', '包含', 'R(读取), C(创建)']\n",
      "['客户订单取消', '包含', 'R(读取), D(删除)']\n",
      "['客户订单变更处理', '包含', 'R(读取), U(更新)']\n",
      "['新产品添加处理', '包含', 'R(读取), C(创建)']\n",
      "['新产品退市处理', '包含', 'R(读取), D(删除)']\n",
      "['产品价格变更处理', '包含', 'RU(读取和更新)']\n",
      "['产品说明变更处理', '包含', 'RU(读取和更新)']\n",
      "['产品库存调整处理', '包含', 'RU(读取和更新)']\n",
      "['客户', '作为', '网上商店基本实体']\n",
      "['库存', '作为', '网上商店基本实体']\n",
      "['订单', '作为', '网上商店基本实体']\n",
      "['购物车', '作为', '网上商店可能实体']\n",
      "案例分析——某网上商店概念数据建模\n",
      "['确定基本实体', '属于', '案例分析——某网上商店概念数据建模']\n",
      "['客户', '属于', '确定基本实体']\n",
      "['库存', '属于', '确定基本实体']\n",
      "['订单', '属于', '确定基本实体']\n",
      "['购物车', '属于', '确定基本实体']\n",
      "['拥有关系', '属于', '确定实体间的关联']\n",
      "['订购关系', '属于', '确定实体间的关联']\n",
      "['包含关系', '属于', '确定实体间的关联']\n",
      "['主码和属性', '属于', '案例分析——某网上商店概念数据建模']\n",
      "['客户（客户 ID，地址，电话，E-mail，客户类型）', '属于', '主码和属性']\n",
      "['企业客户（客户 ID，公司名称，运输方式，采购者名称，传真）', '属于', '主码和属性']\n",
      "['家庭办公客户（客户 ID，客户姓名，公司姓名，传真）', '属于', '主码和属性']\n",
      "['学生客户（客户 ID，客户姓名，学校）', '属于', '主码和属性']\n",
      "['订单（订单 ID，发票 ID，客户 ID，收益编码，订单状态）', '属于', '主码和属性']\n",
      "['库存（库存 ID，名称，描述，规模，重量，材料，颜色，价格，提前期）', '属于', '主码和属性']\n",
      "['购物车（购物车 ID，客户 ID，库存 ID，材料，颜色，数量）', '属于', '主码和属性']\n",
      "本章总结\n",
      "['订单实体', '属于', '本章总结']\n",
      "['订单属性', '属于', '订单实体']\n",
      "['发票 ID(FK)', '属于', '订单属性']\n",
      "['客户 ID(FK)', '属于', '订单属性']\n",
      "['退货码', '属于', '订单属性']\n",
      "['订单状态', '属于', '订单属性']\n",
      "['库存实体', '属于', '本章总结']\n",
      "['库存属性', '属于', '库存实体']\n",
      "['购物车实体', '属于', '本章总结']\n",
      "['购物车属性', '属于', '购物车实体']\n",
      "['复杂属性表达', '属于', '库存实体']\n",
      "['编码集', '用于', '复杂属性表达']\n",
      "['网络商店概念数据建模', '是本章内容', '本章总结']\n",
      "['实体-联系图', '用于', '概念数据模型构建']\n",
      "['类图符号', '用于', '概念数据模型构建']\n",
      "['数据流', '与', '概念数据模型有关系']\n",
      "['数据存储', '与', '概念数据模型有关系']\n",
      "['弱实体', '在问题4中讨论', '本章思考与练习']\n",
      "['关联实体', '在问题4中讨论', '本章思考与练习']\n",
      "['主码识别', '在问题3、4中涉及', '本章思考与练习']\n",
      "['软件培训项目建模', '作为练习要求', '本章思考与练习']\n",
      "['学期指导老师分配', '在练习5中描述', '本章思考与练习']\n",
      "['指导老师角色', '在练习5中提及', '本章思考与练习']\n",
      "['采购请求流程', '在练习6中详细说明', '本章思考与练习']\n",
      "['采购部门员工', '在练习6中扮演关键角色', '采购请求流程']\n",
      "['采购流程审批', '属于', '采购请求流程']\n",
      "['采购订单', '在采购流程中产生', '采购请求流程']\n",
      "['系统应用架构', '为本章主题', '第7章']\n",
      "['框架', '与应用架构对比', '第7章']\n",
      "['分布式系统构件分布', '是应用架构设计考虑因素', '第7章']\n",
      "['应用架构设计', '在第7章详细阐述', '第7章']\n",
      "架构概述\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "['系统应用架构', '属于', '架构概述']\n",
      "任务执行超时\n",
      "['系统应用架构的定义', '属于', '架构概述']\n",
      "任务执行超时\n",
      "['系统应用架构与框架的异同', '属于', '架构概述']\n",
      "任务执行超时\n",
      "['典型的系统应用架构', '属于', '架构概述']\n",
      "任务执行超时\n",
      "['基于主机的架构', '属于', '典型的系统应用架构']\n",
      "任务执行超时\n",
      "['文件服务器架构', '属于', '典型的系统应用架构']\n",
      "任务执行超时\n",
      "['客户/服务器架构', '属于', '典型的系统应用架构']\n",
      "任务执行超时\n",
      "['三层或 N 层客户/服务器架构', '属于', '典型的系统应用架构']\n",
      "任务执行超时\n",
      "['浏览器/服务器架构', '属于', '典型的系统应用架构']\n",
      "任务执行超时\n",
      "['应用架构与框架', '属于', '架构概述']\n",
      "任务执行超时\n",
      "['逻辑层次', '属于', '应用架构']\n",
      "['Martin Fowler 的逻辑层次划分', '属于', '应用架构']\n",
      "['表示层', '属于', 'Martin Fowler 的逻辑层次划分']\n",
      "['领域层', '属于', 'Martin Fowler 的逻辑层次划分']\n",
      "['数据源层', '属于', 'Martin Fowler 的逻辑层次划分']\n",
      "['Eric Evans 的逻辑层次划分', '属于', '应用架构']\n",
      "['应用层', '属于', 'Eric Evans 的逻辑层次划分']\n",
      "['领域层', '属于', 'Eric Evans 的逻辑层次划分']\n",
      "['信息系统逻辑架构层次', '属于', '架构概述']\n",
      "任务执行超时\n",
      "['表现层', '属于', '信息系统逻辑架构层次']\n",
      "['表现逻辑层', '属于', '信息系统逻辑架构层次']\n",
      "['应用逻辑层', '属于', '信息系统逻辑架构层次']\n",
      "['业务逻辑层', '属于', '应用逻辑层']\n",
      "['数据处理层', '属于', '信息系统逻辑架构层次']\n",
      "['数据层', '属于', '信息系统逻辑架构层次']\n",
      "典型的系统应用架构\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "['数据层', '属于', '典型的系统应用架构']\n",
      "任务执行超时\n",
      "['系统硬件组成', '属于', '典型的系统应用架构']\n",
      "任务执行超时\n",
      "['客户计算机', '属于', '系统硬件组成']\n",
      "['服务器', '属于', '系统硬件组成']\n",
      "['网络', '属于', '系统硬件组成']\n",
      "['主机小型机', '属于', '服务器']\n",
      "['微机', '属于', '服务器']\n",
      "['基于主机的服务器架构', '属于', '典型的系统应用架构']\n",
      "任务执行超时\n",
      "['简单架构', '属于', '基于主机的服务器架构']\n",
      "['单点控制', '属于', '基于主机的服务器架构']\n",
      "['性能瓶颈', '属于', '基于主机的服务器架构']\n",
      "['服务器超负荷', '属于', '基于主机的服务器架构']\n",
      "['响应时间减慢', '属于', '基于主机的服务器架构']\n",
      "['文件服务器架构', '属于', '典型的系统应用架构']\n",
      "任务执行超时\n",
      "['客户端', '属于', '文件服务器架构']\n",
      "['服务器端', '属于', '文件服务器架构']\n",
      "['存储功能', '属于', '服务器端']\n",
      "['表现逻辑', '属于', '客户端']\n",
      "['应用逻辑', '属于', '客户端']\n",
      "['数据处理逻辑', '属于', '客户端']\n",
      "['数据完整性', '属于', '文件服务器架构']\n",
      "['加锁机制', '属于', '文件服务器架构']\n",
      "['客户/服务器架构', '属于', '典型的系统应用架构']\n",
      "任务执行超时\n",
      "['分布式计算方案', '属于', '客户/服务器架构']\n",
      "['胖客户', '属于', '客户/服务器架构']\n",
      "['瘦客户', '属于', '客户/服务器架构']\n",
      "['数据库服务器', '属于', '客户/服务器架构']\n",
      "['事务服务器', '属于', '客户/服务器架构']\n",
      "['应用服务器', '属于', '客户/服务器架构']\n",
      "['信息和组件服务器', '属于', '客户/服务器架构']\n",
      "['两层客户/服务器计算', '属于', '客户/服务器架构']\n",
      "['C/S 结构', '属于', '客户/服务器架构']\n",
      "['网络流量减少', '属于', '客户/服务器架构']\n",
      "['数据库完整性维护', '属于', '客户/服务器架构']\n",
      "['版本升级与维护', '属于', '客户/服务器架构']\n",
      "['三层或 N 层客户/服务器架构', '属于', '典型的系统应用架构']\n",
      "任务执行超时\n",
      "['中间层', '属于', '三层或 N 层客户/服务器架构']\n",
      "['应用服务器端', '属于', '三层或 N 层客户/服务器架构']\n",
      "['业务逻辑', '属于', '应用服务器端']\n",
      "['负载平衡', '相关于', '三层或 N 层客户/服务器架构']\n",
      "['表现层', '属于', '三层或 N 层客户/服务器架构']\n",
      "['业务逻辑层', '属于', '三层或 N 层客户/服务器架构']\n",
      "['数据访问层', '属于', '三层或 N 层客户/服务器架构']\n",
      "['领域层', '等同于', '业务逻辑层']\n",
      "['浏览器/服务器架构', '属于', '典型的系统应用架构']\n",
      "任务执行超时\n",
      "['Web 浏览器', '属于', '浏览器/服务器架构']\n",
      "['Web 服务器', '属于', '浏览器/服务器架构']\n",
      "['Java 技术', '应用于', '浏览器/服务器架构']\n",
      "['HTML', '应用于', '浏览器/服务器架构']\n",
      "['XML', '应用于', '浏览器/服务器架构']\n",
      "应用架构举例\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "['浏览器/服务器架构原理', '属于', '应用架构举例']\n",
      "任务执行超时\n",
      "['Java技术', '属于', '浏览器/服务器架构原理']\n",
      "['超文本标记语言：HTML', '属于', '浏览器/服务器架构原理']\n",
      "['可扩展标记语言：XML', '属于', '浏览器/服务器架构原理']\n",
      "['Web服务器端', '属于', '浏览器/服务器架构原理']\n",
      "['应用服务器端', '属于', '浏览器/服务器架构原理']\n",
      "['表现从这里发布', '属于', 'Web服务器端']\n",
      "['MVC架构', '属于', '应用架构举例']\n",
      "任务执行超时\n",
      "['Model-View-Controller', '等于', 'MVC架构']\n",
      "['Smalltalk-80语言中的MVC架构', '属于', 'MVC架构']\n",
      "['Model对象', '属于', 'MVC架构']\n",
      "['视图', '属于', 'MVC架构']\n",
      "['控制器', '属于', 'MVC架构']\n",
      "['用户操作', '关联于', '视图']\n",
      "['模型更新', '关联于', '控制器']\n",
      "['通知机制', '存在于', 'MVC架构']\n",
      "['代码层次划分', '属于', 'MVC架构']\n",
      "['业务逻辑/数据层', '属于', '代码层次划分']\n",
      "['用户界面层', '属于', '代码层次划分']\n",
      "['应用流程控制层', '属于', '代码层次划分']\n",
      "['View的实现', '属于', '用户界面层']\n",
      "['Model的实现', '属于', '业务逻辑/数据层']\n",
      "['Controller的实现', '属于', '应用流程控制层']\n",
      "['模块功能划分的优点', '相关于', 'MVC架构']\n",
      "['并行开发', '得益于', '模块功能划分']\n",
      "['项目进度加快', '得益于', '模块功能划分']\n",
      "['基于MVC架构的五层软件架构', '属于', '应用架构举例']\n",
      "任务执行超时\n",
      "['Web层', '属于', '基于MVC架构的五层软件架构']\n",
      "['Structs框架', '应用于', 'Web层']\n",
      "['Business Control层', '属于', '基于MVC架构的五层软件架构']\n",
      "['Entity层', '属于', '基于MVC架构的五层软件架构']\n",
      "['DBControl层', '属于', '基于MVC架构的五层软件架构']\n",
      "['Hibernate框架', '应用于', 'DBControl层']\n",
      "['HibernatePO', '属于', 'DBControl层']\n",
      "['应用架构设计', '详细描述', '基于MVC架构的五层软件架构']\n",
      "应用架构设计\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "['模块功能划分', '属于', '应用架构设计']\n",
      "任务执行超时\n",
      "['MVC 架构', '属于', '应用架构设计']\n",
      "任务执行超时\n",
      "['Web 层', '属于', 'MVC 架构']\n",
      "['Structs 框架', '应用于', 'Web 层']\n",
      "['Business Control 层', '属于', '五个层次的软件架构']\n",
      "['Entity 层', '属于', '五个层次的软件架构']\n",
      "['DBControl 层', '属于', '五个层次的软件架构']\n",
      "['Hibernate 框架', '应用于', 'DBControl 层']\n",
      "['数据架构设计', '属于', '应用架构设计']\n",
      "任务执行超时\n",
      "['数据分割', '属于', '数据架构设计']\n",
      "['水平分割', '属于', '数据分割']\n",
      "['垂直分割', '属于', '数据分割']\n",
      "['数据复制', '属于', '数据架构设计']\n",
      "['过程架构设计', '属于', '应用架构设计']\n",
      "任务执行超时\n",
      "['两层服务器架构的SDE特征', '属于', '过程架构设计']\n",
      "['多层服务器架构的SDE特征', '属于', '过程架构设计']\n",
      "['网络架构设计', '属于', '应用架构设计']\n",
      "任务执行超时\n",
      "['服务台系统架构设计案例分析', '属于', '应用架构设计']\n",
      "任务执行超时\n",
      "['轻量级J2EE企业技术平台', '应用于', '服务台系统']\n",
      "['Spring核心容器', '应用于', '服务台系统']\n",
      "['Struts MVC实现', '应用于', '服务台系统']\n",
      "['Hibernate持久层技术框架', '应用于', '服务台系统']\n",
      "案例分析——某服务台系统架构设计\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "任务执行超时\n",
      "['服务台系统性能需求分析', '属于', '案例分析——某服务台系统架构设计']\n",
      "任务执行超时\n",
      "['中型规模企业', '属于', '服务台系统性能需求分析']\n",
      "['高端产品与服务', '属于', '服务台系统性能需求分析']\n",
      "['售前与售后服务', '属于', '服务台系统性能需求分析']\n",
      "['客户资源积累', '属于', '服务台系统性能需求分析']\n",
      "['客户忠诚度培养', '属于', '服务台系统性能需求分析']\n",
      "['服务中心建设', '属于', '服务台系统性能需求分析']\n",
      "['在线人数要求', '属于', '服务台系统性能需求分析']\n",
      "['在线时间要求', '属于', '服务台系统性能需求分析']\n",
      "['B/S三层体系架构', '属于', '服务台系统性能需求分析']\n",
      "['单数据库服务器', '属于', '服务台系统性能需求分析']\n",
      "['单Web服务器', '属于', '服务台系统性能需求分析']\n",
      "['非分布式部署环境', '属于', '服务台系统性能需求分析']\n",
      "['轻量级J2EE企业技术平台', '属于', '服务台系统性能需求分析']\n",
      "['开发平台选择', '属于', '案例分析——某服务台系统架构设计']\n",
      "任务执行超时\n",
      "['轻量级J2EE架构', '属于', '开发平台选择']\n",
      "['重量级EJB架构', '属于', '开发平台选择']\n",
      "['Spring为核心容器的架构', '属于', '开发平台选择']\n",
      "['Struts的MVC实现', '属于', '开发平台选择']\n",
      "['Hibernate技术框架', '属于', '开发平台选择']\n",
      "['服务台系统开发环境', '属于', '案例分析——某服务台系统架构设计']\n",
      "任务执行超时\n",
      "['服务台系统部署环境', '属于', '案例分析——某服务台系统架构设计']\n",
      "任务执行超时\n",
      "['本章小结', '属于', '案例分析——某服务台系统架构设计']\n",
      "任务执行超时\n",
      "本章小结\n",
      "['本章小结', '属于', '第8章']\n",
      "['应用架构', '属于', '本章小结']\n",
      "['定义', '属于', '应用架构']\n",
      "['特点', '属于', '应用架构']\n",
      "['逻辑层次', '属于', '应用架构']\n",
      "['典型应用架构类型', '属于', '应用架构']\n",
      "['应用架构设计方法', '属于', '应用架构']\n",
      "['系统需求', '相关联', '设计方案']\n",
      "['设计方案', '根据', '应用架构设计方法']\n",
      "['汽车零部件商店全国供应链系统', '涉及', '应用架构设计问题']\n",
      "['客户机/服务器结构', '推荐', '汽车零部件商店全国供应链系统']\n",
      "['访问已安装LAN的组织', '用于分析', '客户机/服务器结构']\n",
      "['文件服务器结构', '对比', '客户机/服务器结构']\n",
      "['分布式处理环境', '探讨', '数据冲突管理']\n",
      "['客户机/服务器结构优点', '讨论', '客户机/服务器结构']\n",
      "['操作和管理问题', '关联于', '客户机/服务器结构']\n",
      "['浏览器/服务器模式电子商务网站', '对比', '客户机/服务器结构']\n",
      "['瘦客户技术', '应用于', '无线移动计算']\n",
      "['掌上计算机,WPA电话,PDA', '包含于', '瘦客户技术']\n",
      "['软件过程设计', '属于', '第8章']\n",
      "['主要内容', '属于', '软件过程设计']\n",
      "['总体设计', '属于', '软件过程设计主要内容']\n",
      "['详细设计', '属于', '软件过程设计主要内容']\n",
      "['模块化', '属于', '软件设计基本原理']\n",
      "['抽象与信息隐蔽', '属于', '软件设计基本原理']\n",
      "['模块独立性', '属于', '软件设计基本原理']\n",
      "['HIPO图,软件结构图,详细设计工具', '属于', '软件设计工具']\n",
      "['软件详细设计目标', '属于', '软件过程设计']\n",
      "过程设计主要内容\n",
      "['主要内容', '属于', '软件过程设计']\n",
      "['总体设计', '属于', '主要内容']\n",
      "['详细设计', '属于', '主要内容']\n",
      "['模块化', '属于', '软件设计的基本原理']\n",
      "['抽象与信息隐蔽', '属于', '软件设计的基本原理']\n",
      "['模块的独立性', '属于', '软件设计的基本原理']\n",
      "['HIPO 图', '属于', '软件设计工具']\n",
      "['软件结构图', '属于', '软件设计工具']\n",
      "['详细设计工具', '属于', '软件设计工具']\n",
      "['功能分解', '属于', '过程设计主要内容']\n",
      "['IPO图', '属于', '功能分解']\n",
      "['层次图', '属于', '软件结构']\n",
      "['结构图', '属于', '软件结构']\n",
      "['模块', '属于', '软件结构']\n",
      "['层次系统', '属于', '软件结构']\n",
      "['详细设计目标', '属于', '详细设计']\n",
      "['程序蓝图', '属于', '详细设计结果']\n",
      "['编码阶段', '相关', '详细设计']\n",
      "['模块的基本属性', '属于', '模块化原理']\n",
      "软件设计的基本原理\n",
      "['详细设计', '属于', '软件设计的基本原理']\n",
      "['模块化', '属于', '软件设计的基本原理']\n",
      "['接口', '属于', '模块化']\n",
      "['功能', '属于', '模块化']\n",
      "['逻辑', '属于', '模块化']\n",
      "['状态', '属于', '模块化']\n",
      "['模块化的基本原理', '属于', '软件设计的基本原理']\n",
      "['复杂问题的分解', '属于', '模块化的基本原理']\n",
      "['降低复杂性', '属于', '模块化的基本原理']\n",
      "['减少开发工作量', '属于', '模块化的基本原理']\n",
      "['开发成本', '属于', '模块化的基本原理']\n",
      "['模块数量与模块接口的平衡', '属于', '模块化的基本原理']\n",
      "['抽象', '属于', '软件设计的基本原理']\n",
      "['信息隐蔽', '属于', '软件设计的基本原理']\n",
      "['模块独立性', '属于', '软件设计的基本原理']\n",
      "['子功能', '属于', '模块独立性']\n",
      "['耦合性', '属于', '模块独立性']\n",
      "['块间联系', '属于', '耦合性']\n",
      "['模块间接口的复杂性', '属于', '耦合性']\n",
      "['调用方式', '属于', '耦合性']\n",
      "['传递的信息', '属于', '耦合性']\n",
      "['无直接耦合', '属于', '耦合性类型']\n",
      "['数据耦合', '属于', '耦合性类型']\n",
      "['标记耦合', '属于', '耦合性类型']\n",
      "['控制耦合', '属于', '耦合性类型']\n",
      "['公共耦合', '属于', '耦合性类型']\n",
      "['内容耦合', '属于', '耦合性类型']\n",
      "['内聚性', '属于', '模块独立性']\n",
      "['块内联系', '属于', '内聚性']\n",
      "['偶然内聚', '属于', '内聚性类型']\n",
      "['逻辑内聚', '属于', '内聚性类型']\n",
      "['时间内聚', '属于', '内聚性类型']\n",
      "['通信内聚', '属于', '内聚性类型']\n",
      "['顺序内聚', '属于', '内聚性类型']\n",
      "['功能内聚', '属于', '内聚性类型']\n",
      "['高内聚低耦合原则', '属于', '模块独立性']\n",
      "软件设计工具\n",
      "['耦合性', '属于', '软件设计工具']\n",
      "['内聚性', '属于', '软件设计工具']\n",
      "['模块独立性', '属于', '软件设计工具']\n",
      "['高内聚低耦合原则', '属于', '软件设计工具']\n",
      "['HIPO图', '属于', '软件设计工具']\n",
      "['HIPO分层图', '属于', 'HIPO图']\n",
      "['IPO图', '属于', 'HIPO图']\n",
      "['输入-处理-输出图', '同义于', 'IPO图']\n",
      "['模块编号', '用于', 'HIPO图']\n",
      "['可追踪性', '特征', 'HIPO图']\n",
      "['软件结构图', '属于', '软件设计工具']\n",
      "['功能内聚', '类型', '内聚性']\n",
      "['顺序内聚', '类型', '内聚性']\n",
      "['时间内聚', '类型', '内聚性']\n",
      "['通信内聚', '类型', '内聚性']\n",
      "['偶然内聚', '类型', '内聚性']\n",
      "['逻辑内聚', '类型', '内聚性']\n",
      "['模块选择调用', '类型', '控制传递']\n",
      "['模块循环调用', '类型', '控制传递']\n",
      "['扇入', '属性', '软件结构图形态特征']\n",
      "['扇出', '属性', '软件结构图形态特征']\n",
      "['深度', '属性', '软件结构图形态特征']\n",
      "['宽度', '属性', '软件结构图形态特征']\n",
      "['详细设计工具', '阶段', '软件设计工具']\n",
      "['程序流程图(PFC)', '工具', '详细设计工具']\n",
      "['盒图(N-S图)', '工具', '详细设计工具']\n",
      "['问题分析图(PAD)', '工具', '详细设计工具']\n",
      "['变换分析设计', '方法', '面向数据流的设计方法']\n",
      "['事务分析设计', '方法', '面向数据流的设计方法']\n",
      "['变换流', '类型', '信息流']\n",
      "['事务流', '类型', '信息流']\n",
      "练习：画出下列伪码程序的程序流程图和盒图\n",
      "['练习：画出下列伪码程序的程序流程图和盒图', '属于', '该段落主题']\n",
      "['PAD图', '属于', '面向高级程序设计语言']\n",
      "['内嵌套层数增多时的问题', '属于', 'PAD图']\n",
      "['图形清晰性受影响', '属于', '内嵌套层数增多时的问题']\n",
      "['FORTRAN', '属于', '面向高级程序设计语言']\n",
      "['COBOL', '属于', '面向高级程序设计语言']\n",
      "['PASCAL', '属于', '面向高级程序设计语言']\n",
      "['图形符号与控制语句对应', '属于', 'PAD图']\n",
      "['PAD图转换为高级语言程序的容易性', '属于', 'PAD图']\n",
      "['8.4 软件结构设计方法', '属于', '该段落主题']\n",
      "['面向数据流的设计方法', '属于', '8.4 软件结构设计方法']\n",
      "['系统化途径', '属于', '面向数据流的设计方法']\n",
      "['信息流的关键考虑', '属于', '系统需求分析阶段']\n",
      "['数据流图描绘信息处理和流动情况', '属于', '信息流的关键考虑']\n",
      "['映射', '属于', '面向数据流的设计方法']\n",
      "['数据流图变换成软件结构', '属于', '面向数据流的设计方法']\n",
      "['结构化设计方法（SD 方法）', '属于', '面向数据流的设计方法']\n",
      "['基于数据流的设计方法', '属于', '结构化设计方法（SD 方法）']\n",
      "['映射成软件结构的步骤', '属于', '结构化设计方法（SD 方法）']\n",
      "['信息流的类型', '属于', '面向数据流的设计方法']\n",
      "['变换流', '属于', '信息流的类型']\n",
      "['事务流', '属于', '信息流的类型']\n",
      "['设计方法的划分', '属于', '面向数据流的设计方法']\n",
      "['变换分析设计', '属于', '设计方法的划分']\n",
      "['事务分析设计', '属于', '设计方法的划分']\n",
      "['变换流的形式特征', '属于', '变换分析设计']\n",
      "['输入通路', '属于', '变换流的形式特征']\n",
      "['外部形式到内部形式的变换', '属于', '变换流的形式特征']\n",
      "['变换中心', '属于', '变换流的形式特征']\n",
      "['处理过程', '属于', '变换流的形式特征']\n",
      "['输出通路', '属于', '变换流的形式特征']\n",
      "['内部形式到外部形式的变换', '属于', '变换流的形式特征']\n",
      "软件结构设计方法\n",
      "['软件结构设计方法', '包含', '变换分析设计']\n",
      "['软件结构设计方法', '包含', '事务分析设计']\n",
      "['软件结构设计方法', '包含', '综合数据流图的映射']\n",
      "['软件结构设计方法', '包含', '分层数据流图的映射']\n",
      "['PAD图', '属于', '面向高级程序设计语言']\n",
      "['FORTRAN', '属于', '高级程序设计语言']\n",
      "['COBOL', '属于', '高级程序设计语言']\n",
      "['PASCAL', '属于', '高级程序设计语言']\n",
      "['结构化设计方法（SD 方法）', '属于', '面向数据流的设计方法']\n",
      "['变换分析设计', '属于', '软件结构设计方法']\n",
      "['事务分析设计', '属于', '软件结构设计方法']\n",
      "['变换流', '属于', '信息流']\n",
      "['事务流', '属于', '信息流']\n",
      "['变换型数据流的设计步骤', '属于', '变换分析设计']\n",
      "['顶层主模块Cm', '属于', '变换型数据流的设计步骤']\n",
      "['输入模块', '属于', '变换型数据流的设计步骤']\n",
      "['输出模块', '属于', '变换型数据流的设计步骤']\n",
      "['变换模块', '属于', '变换型数据流的设计步骤']\n",
      "['中下层模块设计', '属于', '变换型数据流的设计步骤']\n",
      "['输入部分的求精', '属于', '设计优化']\n",
      "['输出部分的求精', '属于', '设计优化']\n",
      "['变换部分的求精', '属于', '设计优化']\n",
      "['事务处理中心', '属于', '事务分析设计']\n",
      "软件详细设计\n",
      "['事务性流程图设计', '属于', 'SA方法需求分析的过程模型']\n",
      "['软件结构图主图', '属于', 'SA方法需求分析的过程模型']\n",
      "['下层结构图设计', '属于', 'SA方法需求分析的过程模型']\n",
      "['订货处理模块的软件结构图', '属于', '下层结构图设计']\n",
      "['顺序结构', '属于', '结构化程序设计']\n",
      "['选择（分支）结构', '属于', '结构化程序设计']\n",
      "['循环结构', '属于', '结构化程序设计']\n",
      "['可维护性', '属于', '程序设计目标']\n",
      "['可靠性', '属于', '程序设计目标']\n",
      "['可理解性', '属于', '程序设计目标']\n",
      "['效率', '属于', '程序设计目标']\n",
      "['自顶向下的结构化程序方法', '属于', '程序设计方法']\n",
      "['模块独立性', '属于', '自顶向下的结构化程序方法']\n",
      "['模块大小划分', '属于', '自顶向下的结构化程序方法']\n",
      "['模块功能简单', '属于', '自顶向下的结构化程序方法']\n",
      "['共享功能模块集中', '属于', '自顶向下的结构化程序方法']\n",
      "['销售子系统', '属于', '百货商店业务管理信息系统过程建模']\n",
      "['采购子系统', '属于', '百货商店业务管理信息系统过程建模']\n",
      "['会计子系统', '属于', '百货商店业务管理信息系统过程建模']\n",
      "案例分析——百货商店业务管理信息系统过程建模\n",
      "['案例分析——百货商店业务管理信息系统过程建模', '属于', '第5章案例分析']\n",
      "['自顶向下的模块化程序设计', '属于', '软件开发工程化方法']\n",
      "['模块独立性原则', '属于', '自顶向下的模块化程序设计']\n",
      "['模块大小划分原则', '属于', '自顶向下的模块化程序设计']\n",
      "['模块功能简单原则', '属于', '自顶向下的模块化程序设计']\n",
      "['共享功能模块集中原则', '属于', '自顶向下的模块化程序设计']\n",
      "['销售子系统', '属于', '百货商店业务管理信息系统过程建模']\n",
      "['采购子系统', '属于', '百货商店业务管理信息系统过程建模']\n",
      "['会计子系统', '属于', '百货商店业务管理信息系统过程建模']\n",
      "['功能模块结构', '属于', '百货商店业务管理信息系统过程建模']\n",
      "['订单处理流程', '属于', '销售子系统']\n",
      "['编辑功能模块', '属于', '销售子系统']\n",
      "['检验核对功能模块', '属于', '销售子系统']\n",
      "['分类处理功能模块', '属于', '销售子系统']\n",
      "['采购子系统控制流程', '属于', '百货商店业务管理信息系统过程建模']\n",
      "['会计子系统控制流程', '属于', '百货商店业务管理信息系统过程建模']\n",
      "['系统的IPO图', '属于', '百货商店业务管理信息系统过程建模']\n",
      "['主控模块的IPO图', '属于', '系统的IPO图']\n",
      "['系统程序结构框图', '属于', '百货商店业务管理信息系统过程建模']\n",
      "本章小结\n",
      "['本章小结', '属于', '第8章']\n",
      "['软件过程设计的基本原理', '属于', '软件过程设计']\n",
      "['模块化', '属于', '软件过程设计的基本原理']\n",
      "['抽象与信息隐蔽', '属于', '软件过程设计的基本原理']\n",
      "['模块的独立性', '属于', '软件过程设计的基本原理']\n",
      "['软件设计工具', '属于', '软件过程设计']\n",
      "['HIPO 图', '属于', '软件设计工具']\n",
      "['软件结构图', '属于', '软件设计工具']\n",
      "['详细设计工具', '属于', '软件设计工具']\n",
      "['设计方法', '属于', '软件过程设计']\n",
      "['变换分析设计', '属于', '设计方法']\n",
      "['事务分析设计', '属于', '设计方法']\n",
      "['综合数据流图的映射', '属于', '设计方法']\n",
      "['分层数据流图的映射', '属于', '设计方法']\n",
      "['逻辑模型与物理模型的区别', '属于', '数据库设计的学习目标']\n",
      "['逻辑模型转换成物理模型的规则', '属于', '数据库设计的学习目标']\n",
      "['E-R 图转换为关系', '属于', '数据库设计的学习目标']\n",
      "['合并冗余的关系', '属于', '数据库设计的学习目标']\n",
      "['为关系设计字段', '属于', '数据库设计的学习目标']\n",
      "['选择合适的数据类型', '属于', '数据库设计的学习目标']\n",
      "['保证数据完整性的要求', '属于', '数据库设计的学习目标']\n",
      "['数据库物理设计', '属于', '数据库设计']\n",
      "逻辑模型和物理模型\n",
      "['逻辑模型', '属于', '数据库设计']\n",
      "['物理模型', '属于', '数据库设计']\n",
      "['逻辑数据库模型', '属于', '逻辑模型']\n",
      "['关系数据库模型', '属于', '物理模型']\n",
      "['规范化方法', '用于', '逻辑数据库设计']\n",
      "['物理字段设计', '属于', '物理模型设计']\n",
      "['数据量规划', '属于', '物理模型设计']\n",
      "['实体的转换规则', '应用于', '逻辑到物理模型转换']\n",
      "['标识主码', '属于', '实体的转换规则']\n",
      "['副码实现为索引', '属于', '实体的转换规则']\n",
      "['子集准则的非主属性建立索引', '属于', '实体的转换规则']\n",
      "['外键识别', '属于', '实体的转换规则']\n",
      "['属性的转换规则', '应用于', '逻辑到物理模型转换']\n",
      "['字段实现', '属于', '属性的转换规则']\n",
      "['数据类型', '在', '属性的转换规则中考虑']\n",
      "['字段大小', '在', '属性的转换规则中考虑']\n",
      "['空或非空特性', '在', '属性的转换规则中考虑']\n",
      "['域', '在', '属性的转换规则中考虑']\n",
      "['默认值', '在', '属性的转换规则中考虑']\n",
      "['关系特征', '描述', '关系数据库模型']\n",
      "['最小冗余度', '是', '结构良好关系的要求']\n",
      "关系数据库模型\n",
      "['关系数据库模型', '属于', '数据库模型']\n",
      "['层次和网络模型', '属于', '数据库模型']\n",
      "任务执行超时\n",
      "['面向对象的数据库模型', '属于', '数据库模型']\n",
      "任务执行超时\n",
      "['关系', '属于', '关系数据库模型']\n",
      "任务执行超时\n",
      "['二维数据表', '属于', '关系']\n",
      "任务执行超时\n",
      "['属性', '属于', '关系']\n",
      "任务执行超时\n",
      "['记录', '属于', '关系']\n",
      "任务执行超时\n",
      "['员工表（1）', '属于', '关系示例']\n",
      "任务执行超时\n",
      "['标识符属性', '属于', '关系']\n",
      "任务执行超时\n",
      "['主码', '属于', '关系']\n",
      "任务执行超时\n",
      "['非空的主码值', '用于', '确定关系中的每一行']\n",
      "['结构良好的关系', '具有', '最小冗余度']\n",
      "['结构良好的关系', '允许', '用户插入、修改和删除行而不出现错误或不一致性']\n",
      "['员工 2', '属于', '冗余关系示例']\n",
      "任务执行超时\n",
      "['规范化技术', '应用于', '复杂数据结构到简单、稳定数据结构的转化']\n",
      "['规范化方法', '用于', '解决员工 2 表的冗余问题']\n",
      "['员工—课程关系', '由', '规范化方法产生']\n",
      "['E-R 图转化成关系', '过程包括', '表示实体、表示关系、规范化关系和合并关系']\n",
      "['规范化的关系', '结合', '已经存在的规范化关系']\n",
      "['人机界面设计', '使用', '规范化关系作为输入和输出数据的基础']\n",
      "['概念数据模型', '包含', 'E-R 或类图']\n",
      "['E-R 或类图', '用于识别', '未来新增系统应用模块的新数据需求']\n",
      "['实体', '在 E-R 图中转换为', '关系']\n",
      "['实体类型', '对应于', '关系']\n",
      "['主码检验', '确保', '主码的唯一性和无冗余性']\n",
      "将 E-R 图转化成关系\n",
      "['规范化技术', '应用于', '将E-R图转化成关系']\n",
      "['实体转换', '属于', '将E-R图转化成关系']\n",
      "['关系转换', '属于', '将E-R图转化成关系']\n",
      "['弱实体', '在', '实体转换']\n",
      "['主码', '用于', '实体转换和关系转换']\n",
      "['非主码属性', '在', '实体转换']\n",
      "['1：N关系转换方法', '是', '关系转换的一部分']\n",
      "['M：N关系转换方法', '是', '关系转换的一部分']\n",
      "['一元关系转换', '属于', '关系转换']\n",
      "['递归外码', '在', '一元关系转换']\n",
      "['物料清单结构', '通过', 'M：N关系转换']\n",
      "['关系合并', '是', '将E-R图转化成关系的后续步骤']\n",
      "['同义属性', '处理方式', '关系合并']\n",
      "['异义属性', '处理方式', '关系合并']\n",
      "['非主码间的依赖', '可能导致的问题', '关系合并']\n",
      "['类/子类关系', '处理方式', '关系合并']\n",
      "['字段设计', '属于', '将E-R图转化成关系后的数据库设计阶段']\n",
      "['数据类型选择', '在', '字段设计']\n",
      "设计字段\n",
      "['字段', '属于', '设计字段']\n",
      "['数据类型', '属于', '字段']\n",
      "['最小化存储空间', '属于', '选择数据类型目标']\n",
      "['表示所有可能的值', '属于', '选择数据类型目标']\n",
      "['数据完整性', '属于', '选择数据类型目标']\n",
      "['支持数据操作', '属于', '选择数据类型目标']\n",
      "['VARCHAR2', '属于', 'Oracle 9i 数据类型']\n",
      "['CHAR', '属于', 'Oracle 9i 数据类型']\n",
      "['LONG', '属于', 'Oracle 9i 数据类型']\n",
      "['NUMBER', '属于', 'Oracle 9i 数据类型']\n",
      "['日期（DATE）', '属于', 'Oracle 9i 数据类型']\n",
      "['二进制大对象（BLOB）', '属于', 'Oracle 9i 数据类型']\n",
      "['运算字段', '属于', '字段']\n",
      "['派生字段', '等同于', '运算字段']\n",
      "['编码与压缩技术', '属于', '字段优化方法']\n",
      "['数据完整性控制', '属于', '设计文件的控制策略']\n",
      "['缺省值', '属于', '数据完整性控制方法']\n",
      "['范围控制', '属于', '数据完整性控制方法']\n",
      "['参照完整性', '属于', '数据完整性控制方法']\n",
      "['空值控制', '属于', '数据完整性控制方法']\n",
      "['文件备份', '属于', '文件的控制策略']\n",
      "['安全性', '属于', '文件的控制策略']\n",
      "['编码或加密', '属于', '安全性措施']\n",
      "['用户验证', '属于', '安全性措施']\n",
      "['访问权限控制', '属于', '安全性措施']\n",
      "['数据拷贝与核对', '属于', '安全性措施']\n",
      "['代码设计', '属于', '系统设计内容']\n",
      "['唯一化', '属于', '代码作用']\n",
      "['规范化', '属于', '代码作用']\n",
      "['系统化', '属于', '代码作用']\n",
      "['代码设计原则', '用于', '代码设计']\n",
      "代码设计\n",
      "['唯一化', '属于', '代码设计']\n",
      "['规范化', '属于', '代码设计']\n",
      "['系统化', '属于', '代码设计']\n",
      "['代码种类', '属于', '代码设计']\n",
      "['顺序码', '属于', '代码种类']\n",
      "['数字码', '属于', '代码种类']\n",
      "['区间码', '属于', '数字码']\n",
      "['层次码', '属于', '数字码']\n",
      "['字符码', '属于', '代码种类']\n",
      "['混合码', '属于', '代码种类']\n",
      "['代码设计方法', '属于', '代码设计']\n",
      "['线分类方法', '属于', '代码设计方法']\n",
      "['面分类方法', '属于', '代码设计方法']\n",
      "['线分类法特点', '属于', '线分类方法']\n",
      "['面分类法特点', '属于', '面分类方法']\n",
      "['代码校验', '属于', '代码设计']\n",
      "['输出设计目的', '属于', '输出设计']\n",
      "['输出设计原则', '属于', '输出设计']\n",
      "输出设计\n",
      "['输出设计', '包含', '输出目的']\n",
      "['输出设计', '包含', '中间输出']\n",
      "['输出设计', '包含', '最终输出']\n",
      "['输出设计', '包含', '输出设计原则1：易于阅读和理解']\n",
      "['输出设计原则1：易于阅读和理解', '包含', '标题']\n",
      "['输出设计原则1：易于阅读和理解', '包含', '日期和时间戳']\n",
      "['输出设计原则1：易于阅读和理解', '包含', '节和标题']\n",
      "['输出设计原则1：易于阅读和理解', '包含', '表格字段标签']\n",
      "['输出设计原则1：易于阅读和理解', '包含', '缩写形式及图例']\n",
      "['输出设计原则1：易于阅读和理解', '包含', '只打印或显示需要的信息']\n",
      "['输出设计原则1：易于阅读和理解', '包含', '信息分布与边缘空格']\n",
      "['输出设计原则1：易于阅读和理解', '包含', '导航和查找方便性']\n",
      "['输出设计原则1：易于阅读和理解', '包含', '避免计算机行话和错误消息']\n",
      "['输出设计', '包含', '按时提供输出']\n",
      "['输出设计', '包含', '制作对用户有意义的输出']\n",
      "['输出设计', '包含', '选择有效的输出方法']\n",
      "['输出设计', '包含', '输出方式选择']\n",
      "['输出方式选择', '包含', '屏幕显示输出']\n",
      "['输出方式选择', '包含', '打印机打印输出']\n",
      "['输出方式选择', '包含', '文件输出']\n",
      "['输出方式选择', '包含', '绘图输出']\n",
      "['输出设计', '包含', '报表生成器设计']\n",
      "['输出设计', '包含', '图形方式']\n",
      "['报表生成器设计', '属于', '输出设计']\n",
      "['图形格式输出', '属于', '输出设计']\n",
      "['输出设计过程', '属于', '输出设计']\n",
      "['输出设计说明', '属于', '输出设计']\n",
      "输入设计\n",
      "用户界面设计\n",
      "['输入设备', '属于', '用户界面设计']\n",
      "['条形码扫描设备', '属于', '输入设备']\n",
      "['触摸屏', '属于', '输入设备']\n",
      "['输入数据的格式设计', '属于', '用户界面设计']\n",
      "['原始凭证格式设计', '属于', '输入数据的格式设计']\n",
      "['输入介质的格式设计', '属于', '输入数据的格式设计']\n",
      "['输入数据的正确性校验', '属于', '用户界面设计']\n",
      "['原型化工具', '属于', '用户界面设计']\n",
      "['显示风格', '属于', '用户界面设计']\n",
      "['用户操作方式', '属于', '用户界面设计']\n",
      "['可交互性原则', '属于', '用户界面设计']\n",
      "['用户针对性原则', '属于', '可交互性原则']\n",
      "['多种交互方式', '属于', '可交互性原则']\n",
      "['反馈', '属于', '可交互性原则']\n",
      "['状态信息', '属于', '反馈']\n",
      "['弹出提示信息', '属于', '反馈']\n",
      "['错误或警告信息', '属于', '反馈']\n",
      "['帮助功能', '属于', '用户界面设计']\n",
      "['错误处理功能', '属于', '用户界面设计']\n",
      "['信息显示原则', '属于', '用户界面设计']\n",
      "['用户界面一致性', '属于', '信息显示原则']\n",
      "['上下文相关的信息', '属于', '信息显示原则']\n",
      "['窗口分割', '属于', '信息显示原则']\n",
      "['提示信息', '属于', '信息显示原则']\n",
      "['应用程序与界面相分离', '属于', '用户界面设计']\n",
      "['图形用户界面(Graphic User Interface, GUI)', '属于', '用户界面设计']\n",
      "['命令按钮', '属于', 'GUI 控件']\n",
      "['单选按钮', '属于', 'GUI 控件']\n",
      "['复选框', '属于', 'GUI 控件']\n",
      "['文本框', '属于', 'GUI 控件']\n",
      "['列表框', '属于', 'GUI 控件']\n",
      "['下拉式列表', '属于', 'GUI 控件']\n",
      "['组合框', '属于', 'GUI 控件']\n",
      "['滚动框', '属于', 'GUI 控件']\n",
      "['交互方式', '属于', '用户界面设计']\n",
      "['指令语言交互', '属于', '交互方式']\n",
      "['菜单交互', '属于', '交互方式']\n",
      "['表单交互', '属于', '交互方式']\n",
      "['基于对象的交互', '属于', '交互方式']\n",
      "['自然语言交互', '属于', '交互方式']\n",
      "['设计用户界面步骤', '属于', '用户界面设计']\n",
      "['对话设计', '属于', '设计用户界面步骤']\n",
      "['对话图', '属于', '对话设计']\n",
      "['用户界面原型', '属于', '设计用户界面步骤']\n",
      "['用户反馈', '属于', '设计用户界面步骤']\n",
      "['迭代修改', '属于', '设计用户界面步骤']\n",
      "输入输出界面示例\n",
      "软件实现\n",
      "['软件编程', '属于', '软件实现']\n",
      "['选择程序设计语言', '属于', '软件编程']\n",
      "['高级程序语言', '属于', '选择程序设计语言']\n",
      "['汇编语言编码', '属于', '选择程序设计语言']\n",
      "['编码风格', '属于', '软件编程']\n",
      "['规范化程序内部的文档', '属于', '编码风格']\n",
      "['规范数据说明', '属于', '编码风格']\n",
      "['规范语句构造', '属于', '编码风格']\n",
      "['规范输入输出', '属于', '编码风格']\n",
      "['最大化效率', '属于', '编码风格']\n",
      "['程序运行时间', '属于', '最大化效率']\n",
      "['存储器效率', '属于', '最大化效率']\n",
      "['输入输出的效率', '属于', '最大化效率']\n",
      "['软件包安装与测试', '属于', '软件实现']\n",
      "['软件测试', '属于', '软件实现']\n",
      "['单元测试', '属于', '软件测试']\n",
      "['综合测试', '属于', '软件测试']\n",
      "['测试目标', '属于', '软件测试']\n",
      "['软件可靠性模型', '属于', '软件测试']\n",
      "软件测试\n",
      "['单元测试', '属于', '软件测试']\n",
      "['综合测试', '属于', '软件测试']\n",
      "['调试', '属于', '软件测试']\n",
      "['软件可靠性模型', '涉及于', '软件测试']\n",
      "['测试目标', '是', '软件测试的一部分']\n",
      "['G..Myers的测试规则', '指导', '软件测试']\n",
      "['用户需求追溯', '是', '测试准则之一']\n",
      "['早期制定测试计划', '是', '测试准则之一']\n",
      "['Pareto原理应用', '是', '测试准则之一']\n",
      "['从小规模到大规模测试', '是', '测试准则之一']\n",
      "['独立第三方测试', '是', '测试准则之一']\n",
      "['穷举测试不可能', '是', '测试准则认识']\n",
      "['模块测试', '属于', '测试步骤']\n",
      "['集成测试', '属于', '测试步骤']\n",
      "['非渐增式测试方法', '是', '集成测试方法']\n",
      "['渐增式测试方法', '是', '集成测试方法']\n",
      "['系统测试', '属于', '测试步骤']\n",
      "['回归测试', '属于', '测试步骤']\n",
      "['调试引起的回归测试', '属于', '回归测试']\n",
      "['确认测试', '也称', '验收测试']\n",
      "['验收测试', '属于', '测试步骤']\n",
      "['黑盒测试法', '应用于', '确认测试']\n",
      "['Alpha测试', '是', '验收测试类型']\n",
      "['Beta测试', '是', '验收测试类型']\n",
      "['白盒测试技术', '是', '测试方法']\n",
      "['逻辑覆盖', '属于', '白盒测试技术']\n",
      "['语句覆盖', '是', '逻辑覆盖的一种']\n",
      "白盒测试技术\n",
      "['逻辑覆盖', '属于', '白盒测试技术']\n",
      "['语句覆盖', '属于', '逻辑覆盖']\n",
      "['判定覆盖', '属于', '逻辑覆盖']\n",
      "['条件覆盖', '属于', '逻辑覆盖']\n",
      "['判定/条件覆盖', '属于', '逻辑覆盖']\n",
      "['条件组合覆盖', '属于', '逻辑覆盖']\n",
      "['控制结构测试', '属于', '白盒测试技术']\n",
      "['基本路径测试', '属于', '控制结构测试']\n",
      "['环形复杂度', '属于', '基本路径测试']\n",
      "['独立路径的基本集合', '属于', '基本路径测试']\n",
      "['循环测试', '属于', '白盒测试技术']\n",
      "['简单循环', '属于', '循环测试']\n",
      "['串接循环', '属于', '循环测试']\n",
      "['嵌套循环', '属于', '循环测试']\n",
      "['等价类划分法', '属于', '黑盒测试']\n",
      "黑盒测试技术\n",
      "['减少测试数的方法', '属于', '黑盒测试技术']\n",
      "['串接循环的测试', '属于', '黑盒测试技术']\n",
      "['功能测试', '属于', '黑盒测试技术']\n",
      "['独立性测试', '属于', '黑盒测试技术']\n",
      "['错误类型', '属于', '黑盒测试技术']\n",
      "['测试过程阶段', '属于', '黑盒测试技术']\n",
      "['设计黑盒测试方案考虑的问题', '属于', '黑盒测试技术']\n",
      "['测试用例集标准', '属于', '黑盒测试技术']\n",
      "['等价类划分法', '属于', '黑盒测试技术']\n",
      "['有效等价类覆盖', '属于', '等价类划分法']\n",
      "['无效等价类覆盖', '属于', '等价类划分法']\n",
      "['划分等价类的经验', '属于', '等价类划分法']\n",
      "['边界值分析法', '属于', '黑盒测试技术']\n",
      "['边界情况错误高发', '属于', '边界值分析法']\n",
      "['测试数据选取原则', '属于', '边界值分析法']\n",
      "['联合使用等价划分和边界值分析', '属于', '黑盒测试技术']\n",
      "['判定表/判定树', '属于', '黑盒测试技术']\n",
      "['输入组合测试', '属于', '黑盒测试技术']\n",
      "['错误推测法', '属于', '黑盒测试技术']\n",
      "['常见错误推测', '属于', '错误推测法']\n",
      "['模块测试经验', '属于', '错误推测法']\n",
      "['遗漏或省略部分测试', '属于', '错误推测法']\n",
      "['已发现错误与未发现错误的关系', '属于', '错误推测法']\n",
      "['网络实现', '独立于', '黑盒测试技术']\n",
      "['网络类型与结构确定', '属于', '网络实现']\n",
      "['网络设备和服务器选型安装', '属于', '网络实现']\n",
      "['网络拓扑结构确定', '属于', '网络实现']\n",
      "['布线系统选择', '属于', '网络实现']\n",
      "['网络产品选型', '属于', '网络实现']\n",
      "['通信线路选择', '属于', '网络实现']\n",
      "['数据库实现', '独立于', '黑盒测试技术']\n",
      "['数据库结构定义', '属于', '数据库实现']\n",
      "['组织数据入库', '属于', '数据库实现']\n",
      "['数据库试运行', '属于', '数据库实现']\n",
      "网络实现\n",
      "['错误推测法', '属于', '测试方案设计']\n",
      "['边界值分析', '属于', '测试方案设计']\n",
      "['等价划分技术', '属于', '测试方案设计']\n",
      "['特殊容易出错情况', '属于', '错误推测法']\n",
      "['输入数据组合', '属于', '错误推测法']\n",
      "['模块测试经验', '属于', '错误推测法']\n",
      "['程序规格说明书遗漏处理', '属于', '错误推测法']\n",
      "['网络实现', '属于', '章节内容']\n",
      "['网络系统实现工作', '属于', '网络实现']\n",
      "['以太网', '属于', '网络类型与结构确定']\n",
      "['交换机', '属于', '网络设备和服务器选型与安装']\n",
      "['服务器型号选择', '属于', '网络设备和服务器选型与安装']\n",
      "['带宽确定', '属于', '网络设备和服务器选型与安装']\n",
      "['网络拓扑结构', '属于', '网络实现']\n",
      "['星型布线', '属于', '网络拓扑结构']\n",
      "['环形布线', '属于', '网络拓扑结构']\n",
      "['结构化布线', '属于', '网络拓扑结构']\n",
      "['网络产品选型', '属于', '网络实现']\n",
      "['通信线路选择', '属于', '网络实现']\n",
      "['数据库实现', '属于', '章节内容']\n",
      "['数据库实施工作', '属于', '数据库实现']\n",
      "数据库实现\n",
      "['错误推测法', '属于', '测试方案设计']\n",
      "['边界值分析', '属于', '测试方案设计']\n",
      "['等价划分技术', '属于', '测试方案设计']\n",
      "['常见错误清单', '属于', '模块测试经验']\n",
      "['输入数据特殊情况', '属于', '错误推测法']\n",
      "['输出数据特殊情况', '属于', '错误推测法']\n",
      "['遗漏或省略的程序规格说明书部分', '用于', '测试方案设计']\n",
      "['已发现错误与未发现错误成正比现象', '应用于', '测试策略选择']\n",
      "['集中测试错误较多的程序段', '属于', '错误推测法']\n",
      "['计算机测试结合人工检查代码', '属于', '测试方案设计']\n",
      "['共享变量引起错误的检测', '属于', '测试方案设计']\n",
      "['网络实现', '包含', '网络选型']\n",
      "['网络实现', '包含', '布线']\n",
      "['网络实现', '包含', '网络设备安装']\n",
      "['网络实现', '包含', '服务器安装']\n",
      "['网络实现', '包含', '网络系统调试']\n",
      "['数据库实现', '包含', '定义数据库结构']\n",
      "['数据库实现', '包含', '组织数据入库']\n",
      "['数据库实现', '包含', '数据库试运行']\n",
      "['数据库试运行', '包含', '功能测试']\n",
      "['数据库试运行', '包含', '性能测试']\n",
      "['系统转换', '包含', '直接转换法']\n",
      "['系统转换', '包含', '平行转换法']\n",
      "['系统转换', '包含', '试点过度法']\n",
      "['系统转换', '包含', '分阶段转换法']\n",
      "系统转换\n",
      "['数据库结构定义', '属于', '系统转换']\n",
      "['数据装载', '属于', '系统转换']\n",
      "['数据库试运行', '属于', '系统转换']\n",
      "['直接转换法', '属于', '系统转换']\n",
      "['并行转换法', '属于', '系统转换']\n",
      "['试点过度法', '属于', '系统转换']\n",
      "['系统运行', '属于', '系统支持与维护']\n",
      "['系统支持与维护', '属于', '系统转换']\n",
      "['程序维护', '属于', '系统支持与维护']\n",
      "['数据文件维护', '属于', '系统支持与维护']\n",
      "['代码维护', '属于', '系统支持与维护']\n",
      "['系统恢复', '属于', '系统支持与维护']\n",
      "['功能测试', '属于', '数据库试运行']\n",
      "['性能测试', '属于', '数据库试运行']\n",
      "系统运行与支持\n",
      "面向对象相关概念\n",
      "['面向对象基本思想', '属于', '面向对象']\n",
      "['客观世界由对象组成', '属于', '面向对象基本思想']\n",
      "['对象类', '属于', '面向对象基本思想']\n",
      "['静态属性', '属于', '对象类']\n",
      "['动态属性', '属于', '对象类']\n",
      "['子类(派生类)', '属于', '面向对象基本思想']\n",
      "['父类(基类)', '属于', '面向对象基本思想']\n",
      "['层次结构的系统', '属于', '面向对象基本思想']\n",
      "['实体与对象', '属于', '面向对象相关概念']\n",
      "['对象特点', '属于', '实体与对象']\n",
      "['以数据为中心', '属于', '对象特点']\n",
      "['主动性', '属于', '对象特点']\n",
      "['数据封装', '属于', '对象特点']\n",
      "['并行性', '属于', '对象特点']\n",
      "['模块独立性', '属于', '对象特点']\n",
      "['类与对象', '属于', '面向对象相关概念']\n",
      "['类', '属于', '类与对象']\n",
      "['对象共同特征', '属于', '类']\n",
      "['创建对象模板', '属于', '类']\n",
      "['对象是类的实例', '属于', '类与对象']\n",
      "['状态S', '属于', '实体与对象']\n",
      "['操作1', '属于', '实体与对象']\n",
      "['操作2', '属于', '实体与对象']\n",
      "['操作3', '属于', '实体与对象']\n",
      "['Circle类示例', '属于', '类与对象']\n",
      "['消息', '属于', '面向对象相关概念']\n",
      "['要求对象执行操作的规格说明', '属于', '消息']\n",
      "['接受消息的对象', '属于', '消息']\n",
      "['消息选择符', '属于', '消息']\n",
      "['参数', '属于', '消息']\n",
      "['MyCircle.Show(GREEN)', '属于', '消息']\n",
      "['属性', '属于', '面向对象相关概念']\n",
      "['类中定义的数据', '属于', '属性']\n",
      "['客观世界实体性质的抽象', '属于', '属性']\n",
      "['操作', '属于', '面向对象相关概念']\n",
      "['类的所有实例提供的功能或服务', '属于', '操作']\n",
      "['方法', '属于', '操作']\n",
      "['构造函数操作', '属于', '操作']\n",
      "['查询操作', '属于', '操作']\n",
      "['没有副作用的操作', '属于', '查询操作']\n",
      "['访问对象状态但不改变状态', '属于', '查询操作']\n",
      "['更新操作', '属于', '操作']\n",
      "['有副作用的操作', '属于', '更新操作']\n",
      "['改变对象状态', '属于', '更新操作']\n",
      "['范围操作', '属于', '面向对象相关概念']\n",
      "['应用于类而不是对象实例的操作', '属于', '范围操作']\n",
      "['封装', '属于', '面向对象特性']\n",
      "['信息隐藏', '属于', '封装']\n",
      "['接口形式', '属于', '封装']\n",
      "['私有数据', '属于', '封装']\n",
      "['实现操作的代码', '属于', '封装']\n",
      "面向对象的特性\n",
      "['封装', '属于', '面向对象的特性']\n",
      "['信息隐藏', '属于', '封装']\n",
      "['查询操作', '属于', '操作类型']\n",
      "['无副作用的操作', '属于', '查询操作']\n",
      "['构造函数操作', '属于', '操作类型']\n",
      "['创建学生（create-student）', '属于', '构造函数操作']\n",
      "['获取年级（get-year）', '属于', '查询操作']\n",
      "['年龄', '属于', '派生属性']\n",
      "['更新操作（update operation）', '属于', '操作类型']\n",
      "['有副作用的操作', '属于', '更新操作（update operation）']\n",
      "['学生进级（promote-student）', '属于', '更新操作（update operation）']\n",
      "['继承', '属于', '面向对象的特性']\n",
      "['传递性', '属于', '继承']\n",
      "['单继承', '属于', '继承']\n",
      "['多重继承', '属于', '继承']\n",
      "['多态性', '属于', '面向对象的特性']\n",
      "面向对象开发的主要方法\n",
      "['继承', '属于', '面向对象开发的主要方法']\n",
      "['多态性', '属于', '面向对象开发的主要方法']\n",
      "['Booch 的 OOD 方法', '属于', '面向对象开发的主要方法']\n",
      "['微观过程', '属于', 'Booch 的 OOD 方法']\n",
      "['类和对象的识别', '属于', '微观过程']\n",
      "['语义的识别', '属于', '微观过程']\n",
      "['关系的识别', '属于', '微观过程']\n",
      "['类和对象的实现', '属于', '微观过程']\n",
      "['宏观过程', '属于', 'Booch 的 OOD 方法']\n",
      "['概念化、建立核心需求', '属于', '宏观过程']\n",
      "['分析和建立理想的行为模型', '属于', '宏观过程']\n",
      "['设计并创建体系结构', '属于', '宏观过程']\n",
      "['细化并完善和实现模型', '属于', '宏观过程']\n",
      "['维护、管理并提交模型', '属于', '宏观过程']\n",
      "['Coad/Yourdon 的 OOA-OOD 方法', '属于', '面向对象开发的主要方法']\n",
      "['五层模型体系', '属于', 'Coad/Yourdon 的 OOA-OOD 方法']\n",
      "['问题域的五层模型', '属于', '五层模型体系']\n",
      "['对象定义规格的求精过程', '属于', 'Coad/Yourdon 的 OOA-OOD 方法']\n",
      "['数据模型与数据库设计', '属于', 'Coad/Yourdon 的 OOA-OOD 方法']\n",
      "['优化', '属于', 'Coad/Yourdon 的 OOA-OOD 方法']\n",
      "['Rumbaugh 的 OMT 方法', '属于', '面向对象开发的主要方法']\n",
      "['对象模型', '属于', 'Rumbaugh 的 OMT 方法']\n",
      "['动态模型', '属于', 'Rumbaugh 的 OMT 方法']\n",
      "['功能模型', '属于', 'Rumbaugh 的 OMT 方法']\n",
      "['系统分析', '属于', 'Rumbaugh 的 OMT 方法']\n",
      "['系统设计', '属于', 'Rumbaugh 的 OMT 方法']\n",
      "['对象设计', '属于', 'Rumbaugh 的 OMT 方法']\n",
      "['实现', '属于', 'Rumbaugh 的 OMT 方法']\n",
      "['Jacobson 方法（OOSE）', '属于', '面向对象开发的主要方法']\n",
      "['用例驱动', '属于', 'Jacobson 方法（OOSE）']\n",
      "['用例模型', '属于', 'Jacobson 方法（OOSE）']\n",
      "['问题域模型', '属于', 'Jacobson 方法（OOSE）']\n",
      "['分析模型', '属于', 'Jacobson 方法（OOSE）']\n",
      "['设计模型', '属于', 'Jacobson 方法（OOSE）']\n",
      "['实现模型', '属于', 'Jacobson 方法（OOSE）']\n",
      "['测试模型', '属于', 'Jacobson 方法（OOSE）']\n",
      "['UML', '属于', '面向对象开发的主要方法']\n",
      "['视图', '属于', 'UML']\n",
      "['图', '属于', 'UML']\n",
      "['模型元素', '属于', 'UML']\n",
      "['通用机制', '属于', 'UML']\n",
      "UML 概述\n",
      "['UML', '包含', '视图']\n",
      "['UML', '包含', '模型元素']\n",
      "['UML', '包含', '通用机制']\n",
      "['视图', '包括', '用例视图']\n",
      "['视图', '包括', '逻辑视图']\n",
      "['视图', '包括', '并发视图']\n",
      "['视图', '包括', '组件视图']\n",
      "['视图', '包括', '部署视图']\n",
      "['模型元素', '包含', '参与者']\n",
      "['模型元素', '包含', '类和对象']\n",
      "['模型元素', '包含', '状态']\n",
      "['模型元素', '包含', '构件']\n",
      "['模型元素', '包含', '接口']\n",
      "['模型元素', '包含', '节点']\n",
      "['模型元素', '包含', '子系统']\n",
      "['模型元素', '包含', '用例']\n",
      "['模型元素', '包含', '注释']\n",
      "['类元之间关系', '包括', '关联']\n",
      "['类元之间关系', '包括', '依赖']\n",
      "['类元之间关系', '包括', '泛化']\n",
      "['类元之间关系', '包括', '实现']\n",
      "['类元之间关系', '包括', '使用']\n",
      "['通用机制', '提供', '构造型']\n",
      "['通用机制', '提供', '约束']\n",
      "['通用机制', '提供', '标签值']\n",
      "用例图\n",
      "['参与者', '属于', '用例图']\n",
      "['用例', '属于', '用例图']\n",
      "['关联', '表示', '参与者与用例之间关系']\n",
      "['包含关系', '属于', '用例之间关系']\n",
      "['扩展关系', '属于', '用例之间关系']\n",
      "['泛化关系', '属于', '用例之间关系']\n",
      "['抽象用例', '属于', '用例']\n",
      "['基础用例', '属于', '用例']\n",
      "['扩展点', '属于', '扩展关系']\n",
      "['风险分析', '通过包含关系相关联', '评价贸易']\n",
      "['交易估价', '通过包含关系相关联', '评价贸易']\n",
      "['进行交易', '作为基础用例', '超越边界的交易']\n",
      "['权限控制', '示例了', '泛化关系']\n",
      "['执行交易', '作为父用例', '交易债券, 交易股票, 交易期权']\n",
      "['人才需求登记', '属于', '招聘管理用例图']\n",
      "['人才需求审核', '属于', '招聘管理用例图']\n",
      "['招聘计划登记', '属于', '招聘管理用例图']\n",
      "['招聘信息发布', '属于', '招聘管理用例图']\n",
      "['面试管理', '属于', '招聘管理用例图']\n",
      "['人才储备管理', '属于', '招聘管理用例图']\n",
      "['录用管理', '属于', '招聘管理用例图']\n",
      "类图和对象图\n",
      "['类图', '属于', '面向对象建模技术']\n",
      "['对象图', '属于', '类图']\n",
      "['用例关系准则', '属于', '需求澄清']\n",
      "['抽象用例', '用于', '行为变体建模']\n",
      "['包含关系', '用于', '共享行为片段']\n",
      "['扩展关系', '用于', '增加可选特性']\n",
      "['基础用例', '定义', '常规行为']\n",
      "['普通关联', '属于', '类之间的关联']\n",
      "['聚合关联', '包括', '组成聚合', '共享聚合']\n",
      "['组合聚集', '描述', '部分与整体共存关系']\n",
      "['共享聚集', '描述', '整体与部分的关系']\n",
      "['泛化关联', '表示', '一般与特殊关系']\n",
      "['依赖关系', '连接', '两个模型元素的语义关系']\n",
      "['实现关系', '表示', '不同抽象层上的事务描述']\n",
      "['派生属性', '来源于', '其他属性推演']\n",
      "['派生关联', '来源于', '其他关联计算推演']\n",
      "['抽象类', '特征', '不能直接实例化']\n",
      "['接口', '是', '类的版型']\n",
      "['版型(构造型)', '用于', '模型元素扩展']\n",
      "['对象图', '实例化', '类图']\n",
      "['状态图', '展示', '对象状态变迁']\n",
      "['活动图', '描述', '用例或业务过程']\n",
      "['顺序图', '体现', '交互性']\n",
      "['协作图', '体现', '一组对象间的交互']\n",
      "状态图\n",
      "['状态图', '属于', '动态建模']\n",
      "['活动图', '属于', '动态建模']\n",
      "任务执行超时\n",
      "['顺序图', '属于', '动态建模']\n",
      "任务执行超时\n",
      "['协作图', '属于', '动态建模']\n",
      "任务执行超时\n",
      "['状态转移', '属于', '状态图']\n",
      "任务执行超时\n",
      "['状态', '属于', '状态图']\n",
      "任务执行超时\n",
      "['初态', '属于', '状态']\n",
      "任务执行超时\n",
      "['终态', '属于', '状态']\n",
      "任务执行超时\n",
      "['中间状态', '属于', '状态']\n",
      "任务执行超时\n",
      "['活动表', '属于', '中间状态']\n",
      "任务执行超时\n",
      "['状态转换', '属于', '状态图']\n",
      "任务执行超时\n",
      "['事件触发', '关联于', '状态转换']\n",
      "['守卫条件', '关联于', '状态转换']\n",
      "['动作表达式', '关联于', '状态转换']\n",
      "['电话系统的状态图', '示例', '状态图']\n",
      "['活动图描述', '属于', '活动图']\n",
      "任务执行超时\n",
      "活动图\n",
      "['活动图', '属于', '描述系统中各种活动的执行顺序']\n",
      "['活动状态', '属于', '活动']\n",
      "任务执行超时\n",
      "['开始状态', '属于', '活动图']\n",
      "任务执行超时\n",
      "['结束状态', '属于', '活动图']\n",
      "任务执行超时\n",
      "['转移', '属于', '活动图']\n",
      "任务执行超时\n",
      "['泳道', '属于', '活动图']\n",
      "任务执行超时\n",
      "['判定点', '属于', '活动图']\n",
      "任务执行超时\n",
      "['并发路径', '属于', '活动图']\n",
      "任务执行超时\n",
      "['对象流', '属于', '活动图']\n",
      "任务执行超时\n",
      "['信号', '属于', '活动图']\n",
      "任务执行超时\n",
      "顺序图\n",
      "['顺序图', '属于', 'UML动态建模']\n",
      "['时序图', '同义词', '顺序图']\n",
      "['对象', '包含于', '顺序图']\n",
      "['生命线', '属于', '顺序图']\n",
      "['激活期', '属于', '顺序图']\n",
      "['消息', '属于', '顺序图']\n",
      "['激活：表示该对象正在执行某个操作', '属于', '激活期']\n",
      "['即时创建对象', '属于', '顺序图']\n",
      "['调用消息', '属于', '顺序图']\n",
      "['同步消息', '同义词', '调用消息(早期版本)']\n",
      "['异步消息', '属于', '顺序图']\n",
      "['返回消息', '属于', '顺序图']\n",
      "['阻止消息', '属于', '顺序图']\n",
      "['超时消息', '属于', '顺序图']\n",
      "['图书借阅顺序图', '示例', '顺序图']\n",
      "协作图\n",
      "['协作图', '属于', 'UML']\n",
      "['参与者', '在', '协作图']\n",
      "['对象', '在', '协作图']\n",
      "['消息', '在', '协作图']\n",
      "['链接', '表示', '关联的实例化']\n",
      "['顺序', '强调', '顺序图']\n",
      "['交互关系', '强调', '协作图']\n",
      "['空间', '侧重于', '协作图']\n",
      "['时间', '侧重于', '顺序图']\n",
      "['序列化', '通过', '添加序列ID号']\n",
      "['迭代', '是', '控制流类型']\n",
      "['单个对象发送消息到一组其他对象', '通过', '多重性指定']\n",
      "['多对象消息', '用', '星号(*)标记']\n",
      "['消息多次发送', '在', '协作图中建模']\n",
      "['控制点条件', '用于', '限制消息发送']\n",
      "['组件图', '描述', '软件组件及其依赖关系']\n",
      "组件图\n",
      "['协作图', '属于', '练习内容']\n",
      "['控制点条件', '属于', '协作图建模内容']\n",
      "['组件图', '描述', '软件组件及依赖关系']\n",
      "['组件', '属于', '组件图']\n",
      "['组件接口', '与', '组件相关联']\n",
      "['依赖关系', '属于', '组件图']\n",
      "['版型化组件依赖关系', '属于', '依赖关系']\n",
      "['接口矩形表示法', '和', '接口圆圈表示法', '都属于', '接口表示方法']\n",
      "['Persistence', '包含于', '组件图']\n",
      "['UserInterface', '包含于', '组件图']\n",
      "['Save', '通过', 'includes 版型', '关联于', 'UserInterface']\n",
      "['Load', '通过', 'includes 版型', '关联于', 'UserInterface']\n",
      "['OpenDialog', '通过', 'includes 版型', '关联于', 'UserInterface']\n",
      "['FindDialog', '通过', 'includes 版型', '关联于', 'UserInterface']\n",
      "['EditDialog', '通过', 'includes 版型', '关联于', 'UserInterface']\n",
      "['部署图', '也称为', '配置图']\n",
      "部署图\n",
      "['部署图', '属于', '系统设计']\n",
      "['配置图', '等于', '部署图']\n",
      "['物理配置情况', '包含于', '部署图']\n",
      "['系统体系结构', '包含于', '部署图']\n",
      "['组件在硬件上的部署', '描述于', '部署图']\n",
      "['硬件之间的联系', '描述于', '部署图']\n",
      "['节点', '是部署图中的元素']\n",
      "['处理器', '是节点的一种类型']\n",
      "['设备', '是节点的另一种类型']\n",
      "['连接', '表示节点间的关系', '部署图']\n",
      "['通信关联', '存在于', '部署图']\n",
      "['通用节点', '在部署图中标识']\n",
      "['实例化的节点', '在部署图中标识']\n",
      "['包图', '与部署图并列']\n",
      "['类分组', '通过', '包']\n",
      "['命名空间', '由包提供']\n",
      "包图\n",
      "基于 UML 的系统开发过程\n",
      "['基于 UML 的系统开发步骤', '属于', '面向对象系统开发过程']\n",
      "['需求理解', '属于', '基于 UML 的系统开发步骤']\n",
      "['系统分析', '属于', '基于 UML 的系统开发步骤']\n",
      "['系统设计', '属于', '基于 UML 的系统开发步骤']\n",
      "['系统实现', '属于', '基于 UML 的系统开发步骤']\n",
      "['用例建模', '属于', '需求理解']\n",
      "['需求用例建模过程', '属于', '需求理解']\n",
      "['业务参与者确定', '属于', '需求用例建模过程']\n",
      "理解需求\n",
      "['用例建模', '属于', '理解需求']\n",
      "['系统边界', '属于', '理解需求']\n",
      "['业务参与者', '属于', '理解需求']\n",
      "['确定业务参与者', '属于', '理解需求']\n",
      "['系统功能的使用环境', '属于', '理解需求']\n",
      "['用例定义', '属于', '理解需求']\n",
      "['需求分析和设计分离', '属于', '理解需求']\n",
      "['目标系统测试', '属于', '理解需求']\n",
      "['构造需求用例模型', '属于', '理解需求']\n",
      "['业务需求用例', '属于', '构造需求用例模型']\n",
      "['用例模型图', '属于', '构造需求用例模型']\n",
      "['业务需求用例描述', '属于', '构造需求用例模型']\n",
      "['确定用例', '属于', '理解需求']\n",
      "['识别参与者', '属于', '确定业务参与者']\n",
      "['必要用例', '属于', '确定用例']\n",
      "['用例抽取过程注意事项', '属于', '确定用例']\n",
      "['构造用例图', '属于', '理解需求']\n",
      "['用例关系', '属于', '构造用例图']\n",
      "['泛化关系', '属于', '用例关系']\n",
      "['包含关系', '属于', '用例关系']\n",
      "['扩展关系', '属于', '用例关系']\n",
      "['用例说明', '属于', '理解需求']\n",
      "['简要说明', '属于', '用例说明']\n",
      "['用例场景', '属于', '用例说明']\n",
      "['事件流', '属于', '用例场景']\n",
      "['基本流', '属于', '事件流']\n",
      "['备选流', '属于', '事件流']\n",
      "['前置条件', '属于', '用例说明']\n",
      "['后置条件', '属于', '用例说明']\n",
      "['特殊需求', '属于', '用例说明']\n",
      "['用例图调整', '属于', '理解需求']\n",
      "['用例模型检查', '属于', '理解需求']\n",
      "['需求完备性检查', '属于', '用例模型检查']\n",
      "['简洁与重用性检查', '属于', '用例模型检查']\n",
      "['管理用例模型复杂度', '属于', '理解需求']\n",
      "['用例包', '属于', '管理用例模型复杂度']\n",
      "['电子培训系统的需求理解', '属于', '理解需求']\n",
      "['分析问题领域', '属于', '电子培训系统的需求理解']\n",
      "案例——电子培训系统的需求理解\n",
      "['用例', '属于', '用例模型']\n",
      "['参与者', '属于', '用例模型']\n",
      "['用例包', '用于', '管理用例模型复杂度']\n",
      "['分析问题领域', '属于', '需求理解阶段']\n",
      "['用例图', '描绘', '用例模型']\n",
      "['教学管理', '属于', 'ABC e-Training 系统功能划分']\n",
      "['教务管理', '属于', 'ABC e-Training 系统功能划分']\n",
      "['系统服务', '属于', 'ABC e-Training 系统功能划分']\n",
      "['系统辅助功能', '属于', 'ABC e-Training 系统功能划分']\n",
      "['教学过程管理', '包含', '课堂教学环境']\n",
      "['教学过程管理', '包含', '网络学习环境']\n",
      "['教学过程管理', '包含', '教案组织']\n",
      "['教学过程管理', '包含', '自动教学']\n",
      "['教学过程管理', '包含', '课堂教学']\n",
      "['教学过程管理', '包含', '课终考试']\n",
      "['教学过程管理', '包含', '教学活动信息管理']\n",
      "['教学资源管理', '属于', '教学管理部分']\n",
      "['教案管理', '属于', '教学管理部分']\n",
      "['ABC e-Training 系统', '具有', '系统范围和系统边界']\n",
      "['财务系统', '与', 'ABC e-Training 系统存在系统边界']\n",
      "['ABC e-Testing 系统', '与', 'ABC e-Training 系统存在系统边界']\n",
      "['用户管理', '是', 'ABC e-Training 系统的用例']\n",
      "['培训点管理', '是', 'ABC e-Training 系统的用例']\n",
      "['辅助管理', '是', 'ABC e-Training 系统的用例']\n",
      "['教学活动', '分解为', '制作教案子用例']\n",
      "['制作教案', '进一步细化为', '编辑电子教案等子用例']\n",
      "['编辑电子教案用例', '描述了', '编辑电子教案功能']\n",
      "['上载电子教案用例', '描述了', '上载电子教案功能']\n",
      "['预览电子教案用例', '描述了', '预览电子教案功能']\n",
      "['发现类', '是', '领域建模的一部分']\n",
      "['类与对象', '在', '领域建模中被识别']\n",
      "领域建模\n",
      "['面向对象分析(OOA)', '属于', '领域建模']\n",
      "['静态模型', '属于', '面向对象分析(OOA)']\n",
      "['动态行为模型', '属于', '面向对象分析(OOA)']\n",
      "['对象模型', '属于', '静态模型']\n",
      "['关联', '属于', '静态模型']\n",
      "['属性', '属于', '静态模型']\n",
      "['用例驱动方法', '属于', '发现类的方法']\n",
      "['CRC 方法', '属于', '发现类的方法']\n",
      "['名词短语方法', '属于', '发现类的方法']\n",
      "['通用类模式方法', '属于', '发现类的方法']\n",
      "['确定关联', '属于', '面向对象分析(OOA)']\n",
      "['确定属性', '属于', '面向对象分析(OOA)']\n",
      "['泛化关系', '属于', '静态模型']\n",
      "['聚合关系', '属于', '静态模型']\n",
      "['状态图', '属于', '动态行为模型']\n",
      "任务执行超时\n",
      "行为建模\n",
      "['系统分析阶段的行为建模', '属于', '行为建模']\n",
      "['用例和对象类', '属于', '系统分析阶段的行为建模']\n",
      "['静态结构', '属于', '系统分析阶段的行为建模']\n",
      "['用户需求', '属于', '系统分析阶段的行为建模']\n",
      "['系统目标', '属于', '系统分析阶段的行为建模']\n",
      "['提取对象', '属于', '系统分析阶段的行为建模']\n",
      "['对象类', '属于', '系统分析阶段的行为建模']\n",
      "['活动建模', '属于', 'UML动态模型']\n",
      "['状态模型', '属于', 'UML动态模型']\n",
      "['顺序模型', '属于', 'UML动态模型']\n",
      "['协作模型', '属于', 'UML动态模型']\n",
      "['状态图', '属于', '状态建模']\n",
      "\n",
      "['状态机', '属于', '状态图']\n",
      "任务执行超时\n",
      "['初始状态', '属于', '状态图']\n",
      "任务执行超时\n",
      "['终结状态', '属于', '状态图']\n",
      "任务执行超时\n",
      "['中间状态', '属于', '状态图']\n",
      "任务执行超时\n",
      "['状态转移', '属于', '状态图']\n",
      "任务执行超时\n",
      "['复印机状态转换图', '示例', '状态图']\n",
      "['楼层电梯状态图', '练习', '状态图']\n",
      "['订单处理与履行过程状态图', '练习', '状态图']\n",
      "['活动图描述', '属于', '活动图']\n",
      "任务执行超时\n",
      "['业务流程', '描述', '活动图']\n",
      "['业务对象', '属于', '活动图']\n",
      "任务执行超时\n",
      "['泳道', '属于', '活动图']\n",
      "任务执行超时\n",
      "['工作流的边界', '确定', '活动图']\n",
      "['活动状态', '属于', '活动图']\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[5], line 12\u001b[0m\n\u001b[1;32m     10\u001b[0m     part\u001b[38;5;241m=\u001b[39mpart_array[\u001b[38;5;28mid\u001b[39m]\n\u001b[1;32m     11\u001b[0m     \u001b[38;5;28mprint\u001b[39m(part)\n\u001b[0;32m---> 12\u001b[0m     \u001b[43mforest\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbuild_forest\u001b[49m\u001b[43m(\u001b[49m\u001b[43mnodes_array_i\u001b[49m\u001b[43m,\u001b[49m\u001b[43medges_array_i\u001b[49m\u001b[43m,\u001b[49m\u001b[43mpart\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m     13\u001b[0m forest\u001b[38;5;241m.\u001b[39mbuild_kg(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m面向对象\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n",
      "File \u001b[0;32m/mnt/d/Docx2KG/buildKG/forest.py:124\u001b[0m, in \u001b[0;36mForest.build_forest\u001b[0;34m(self, nodes, edges, part_name)\u001b[0m\n\u001b[1;32m    <a href='file:///mnt/d/Docx2KG/buildKG/forest.py?line=120'>121</a>\u001b[0m     target_node \u001b[39m=\u001b[39m Node(target_name)\n\u001b[1;32m    <a href='file:///mnt/d/Docx2KG/buildKG/forest.py?line=121'>122</a>\u001b[0m     \u001b[39mself\u001b[39m\u001b[39m.\u001b[39madd_node(target_node)\n\u001b[0;32m--> <a href='file:///mnt/d/Docx2KG/buildKG/forest.py?line=123'>124</a>\u001b[0m edge \u001b[39m=\u001b[39m Edge(source_node, relation, target_node)\n\u001b[1;32m    <a href='file:///mnt/d/Docx2KG/buildKG/forest.py?line=124'>125</a>\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39madd_edge(edge)\n",
      "File \u001b[0;32m/mnt/d/Docx2KG/buildKG/forest.py:32\u001b[0m, in \u001b[0;36mEdge.__init__\u001b[0;34m(self, source, relation, target)\u001b[0m\n\u001b[1;32m     <a href='file:///mnt/d/Docx2KG/buildKG/forest.py?line=29'>30</a>\u001b[0m signal\u001b[39m.\u001b[39malarm(timeout_seconds)\n\u001b[1;32m     <a href='file:///mnt/d/Docx2KG/buildKG/forest.py?line=30'>31</a>\u001b[0m \u001b[39mtry\u001b[39;00m:\n\u001b[0;32m---> <a href='file:///mnt/d/Docx2KG/buildKG/forest.py?line=31'>32</a>\u001b[0m     \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mbuild(source,relation,target)\n\u001b[1;32m     <a href='file:///mnt/d/Docx2KG/buildKG/forest.py?line=32'>33</a>\u001b[0m     signal\u001b[39m.\u001b[39malarm(\u001b[39m0\u001b[39m)\n\u001b[1;32m     <a href='file:///mnt/d/Docx2KG/buildKG/forest.py?line=33'>34</a>\u001b[0m \u001b[39mexcept\u001b[39;00m \u001b[39mException\u001b[39;00m \u001b[39mas\u001b[39;00m e:\n\u001b[1;32m     <a href='file:///mnt/d/Docx2KG/buildKG/forest.py?line=34'>35</a>\u001b[0m     \u001b[39m# print(\"超时\")\u001b[39;00m\n",
      "File \u001b[0;32m/mnt/d/Docx2KG/buildKG/forest.py:44\u001b[0m, in \u001b[0;36mEdge.build\u001b[0;34m(self, source, relation, target)\u001b[0m\n\u001b[1;32m     <a href='file:///mnt/d/Docx2KG/buildKG/forest.py?line=41'>42</a>\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mbuild\u001b[39m(\u001b[39mself\u001b[39m,source,relation,target):\n\u001b[1;32m     <a href='file:///mnt/d/Docx2KG/buildKG/forest.py?line=42'>43</a>\u001b[0m     \u001b[39mif\u001b[39;00m relation\u001b[39m==\u001b[39m\u001b[39m\"\u001b[39m\u001b[39m属于\u001b[39m\u001b[39m\"\u001b[39m:\n\u001b[0;32m---> <a href='file:///mnt/d/Docx2KG/buildKG/forest.py?line=43'>44</a>\u001b[0m         target\u001b[39m.\u001b[39;49mnode_topic\u001b[39m.\u001b[39;49maddSubTopic(source\u001b[39m.\u001b[39;49mnode_topic)\n\u001b[1;32m     <a href='file:///mnt/d/Docx2KG/buildKG/forest.py?line=44'>45</a>\u001b[0m     \u001b[39melse\u001b[39;00m:\n\u001b[1;32m     <a href='file:///mnt/d/Docx2KG/buildKG/forest.py?line=45'>46</a>\u001b[0m         sheet\u001b[39m.\u001b[39mcreateRelationship(source\u001b[39m.\u001b[39mnode_topic, target\u001b[39m.\u001b[39mnode_topic, relation)\n",
      "File \u001b[0;32m~/.cache/pypoetry/virtualenvs/bisheng-wP9oaGSh-py3.10/lib/python3.10/site-packages/xmind/core/topic.py:344\u001b[0m, in \u001b[0;36mTopicElement.addSubTopic\u001b[0;34m(self, topic, index, topics_type)\u001b[0m\n\u001b[1;32m    <a href='file:///root/.cache/pypoetry/virtualenvs/bisheng-wP9oaGSh-py3.10/lib/python3.10/site-packages/xmind/core/topic.py?line=341'>342</a>\u001b[0m topic_list \u001b[39m=\u001b[39m []\n\u001b[1;32m    <a href='file:///root/.cache/pypoetry/virtualenvs/bisheng-wP9oaGSh-py3.10/lib/python3.10/site-packages/xmind/core/topic.py?line=342'>343</a>\u001b[0m \u001b[39mfor\u001b[39;00m i \u001b[39min\u001b[39;00m topics\u001b[39m.\u001b[39mgetChildNodesByTagName(const\u001b[39m.\u001b[39mTAG_TOPIC):\n\u001b[0;32m--> <a href='file:///root/.cache/pypoetry/virtualenvs/bisheng-wP9oaGSh-py3.10/lib/python3.10/site-packages/xmind/core/topic.py?line=343'>344</a>\u001b[0m     topic_list\u001b[39m.\u001b[39mappend(TopicElement(i, owner_workbook))\n\u001b[1;32m    <a href='file:///root/.cache/pypoetry/virtualenvs/bisheng-wP9oaGSh-py3.10/lib/python3.10/site-packages/xmind/core/topic.py?line=345'>346</a>\u001b[0m \u001b[39mif\u001b[39;00m index \u001b[39m<\u001b[39m \u001b[39m0\u001b[39m \u001b[39mor\u001b[39;00m index \u001b[39m>\u001b[39m\u001b[39m=\u001b[39m \u001b[39mlen\u001b[39m(topic_list):\n\u001b[1;32m    <a href='file:///root/.cache/pypoetry/virtualenvs/bisheng-wP9oaGSh-py3.10/lib/python3.10/site-packages/xmind/core/topic.py?line=346'>347</a>\u001b[0m     topics\u001b[39m.\u001b[39mappendChild(topic)\n",
      "File \u001b[0;32m~/.cache/pypoetry/virtualenvs/bisheng-wP9oaGSh-py3.10/lib/python3.10/site-packages/xmind/core/topic.py:40\u001b[0m, in \u001b[0;36mTopicElement.__init__\u001b[0;34m(self, node, ownerWorkbook)\u001b[0m\n\u001b[1;32m     <a href='file:///root/.cache/pypoetry/virtualenvs/bisheng-wP9oaGSh-py3.10/lib/python3.10/site-packages/xmind/core/topic.py?line=36'>37</a>\u001b[0m \u001b[39msuper\u001b[39m(TopicElement, \u001b[39mself\u001b[39m)\u001b[39m.\u001b[39m\u001b[39m__init__\u001b[39m(node, ownerWorkbook)\n\u001b[1;32m     <a href='file:///root/.cache/pypoetry/virtualenvs/bisheng-wP9oaGSh-py3.10/lib/python3.10/site-packages/xmind/core/topic.py?line=38'>39</a>\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39maddIdAttribute(const\u001b[39m.\u001b[39mATTR_ID)\n\u001b[0;32m---> <a href='file:///root/.cache/pypoetry/virtualenvs/bisheng-wP9oaGSh-py3.10/lib/python3.10/site-packages/xmind/core/topic.py?line=39'>40</a>\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49msetAttribute(const\u001b[39m.\u001b[39;49mATTR_TIMESTAMP, \u001b[39mint\u001b[39;49m(utils\u001b[39m.\u001b[39;49mget_current_time()))\n",
      "File \u001b[0;32m~/.cache/pypoetry/virtualenvs/bisheng-wP9oaGSh-py3.10/lib/python3.10/site-packages/xmind/core/__init__.py:258\u001b[0m, in \u001b[0;36mElement.setAttribute\u001b[0;34m(self, attr_name, attr_value)\u001b[0m\n\u001b[1;32m    <a href='file:///root/.cache/pypoetry/virtualenvs/bisheng-wP9oaGSh-py3.10/lib/python3.10/site-packages/xmind/core/__init__.py?line=252'>253</a>\u001b[0m \u001b[39m\u001b[39m\u001b[39m\"\"\"\u001b[39;00m\n\u001b[1;32m    <a href='file:///root/.cache/pypoetry/virtualenvs/bisheng-wP9oaGSh-py3.10/lib/python3.10/site-packages/xmind/core/__init__.py?line=253'>254</a>\u001b[0m \u001b[39mSet attribute to element. Please notice that if ``attr_value`` is\u001b[39;00m\n\u001b[1;32m    <a href='file:///root/.cache/pypoetry/virtualenvs/bisheng-wP9oaGSh-py3.10/lib/python3.10/site-packages/xmind/core/__init__.py?line=254'>255</a>\u001b[0m \u001b[39mNone and attribute with specified ``attr_name`` is exist, attribute will be removed.\u001b[39;00m\n\u001b[1;32m    <a href='file:///root/.cache/pypoetry/virtualenvs/bisheng-wP9oaGSh-py3.10/lib/python3.10/site-packages/xmind/core/__init__.py?line=255'>256</a>\u001b[0m \u001b[39m\"\"\"\u001b[39;00m\n\u001b[1;32m    <a href='file:///root/.cache/pypoetry/virtualenvs/bisheng-wP9oaGSh-py3.10/lib/python3.10/site-packages/xmind/core/__init__.py?line=256'>257</a>\u001b[0m \u001b[39mif\u001b[39;00m attr_value \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[0;32m--> <a href='file:///root/.cache/pypoetry/virtualenvs/bisheng-wP9oaGSh-py3.10/lib/python3.10/site-packages/xmind/core/__init__.py?line=257'>258</a>\u001b[0m     \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_node\u001b[39m.\u001b[39;49msetAttribute(attr_name, \u001b[39mstr\u001b[39;49m(attr_value))\n\u001b[1;32m    <a href='file:///root/.cache/pypoetry/virtualenvs/bisheng-wP9oaGSh-py3.10/lib/python3.10/site-packages/xmind/core/__init__.py?line=258'>259</a>\u001b[0m \u001b[39melif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_node\u001b[39m.\u001b[39mhasAttribute(attr_name):\n\u001b[1;32m    <a href='file:///root/.cache/pypoetry/virtualenvs/bisheng-wP9oaGSh-py3.10/lib/python3.10/site-packages/xmind/core/__init__.py?line=259'>260</a>\u001b[0m     \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_node\u001b[39m.\u001b[39mremoveAttribute(attr_name)\n",
      "File \u001b[0;32m/usr/lib/python3.10/xml/dom/minidom.py:755\u001b[0m, in \u001b[0;36mElement.setAttribute\u001b[0;34m(self, attname, value)\u001b[0m\n\u001b[1;32m    <a href='file:///usr/lib/python3.10/xml/dom/minidom.py?line=752'>753</a>\u001b[0m     \u001b[39mself\u001b[39m\u001b[39m.\u001b[39msetAttributeNode(attr)\n\u001b[1;32m    <a href='file:///usr/lib/python3.10/xml/dom/minidom.py?line=753'>754</a>\u001b[0m \u001b[39melif\u001b[39;00m value \u001b[39m!=\u001b[39m attr\u001b[39m.\u001b[39mvalue:\n\u001b[0;32m--> <a href='file:///usr/lib/python3.10/xml/dom/minidom.py?line=754'>755</a>\u001b[0m     attr\u001b[39m.\u001b[39;49mvalue \u001b[39m=\u001b[39m value\n\u001b[1;32m    <a href='file:///usr/lib/python3.10/xml/dom/minidom.py?line=755'>756</a>\u001b[0m     \u001b[39mif\u001b[39;00m attr\u001b[39m.\u001b[39misId:\n\u001b[1;32m    <a href='file:///usr/lib/python3.10/xml/dom/minidom.py?line=756'>757</a>\u001b[0m         _clear_id_cache(\u001b[39mself\u001b[39m)\n",
      "File \u001b[0;32m/usr/lib/python3.10/xml/dom/minidom.py:396\u001b[0m, in \u001b[0;36mAttr._set_value\u001b[0;34m(self, value)\u001b[0m\n\u001b[1;32m    <a href='file:///usr/lib/python3.10/xml/dom/minidom.py?line=393'>394</a>\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mchildNodes[\u001b[39m0\u001b[39m]\u001b[39m.\u001b[39mdata \u001b[39m=\u001b[39m value\n\u001b[1;32m    <a href='file:///usr/lib/python3.10/xml/dom/minidom.py?line=394'>395</a>\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mownerElement \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[0;32m--> <a href='file:///usr/lib/python3.10/xml/dom/minidom.py?line=395'>396</a>\u001b[0m     _clear_id_cache(\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mownerElement)\n\u001b[1;32m    <a href='file:///usr/lib/python3.10/xml/dom/minidom.py?line=396'>397</a>\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mchildNodes[\u001b[39m0\u001b[39m]\u001b[39m.\u001b[39mdata \u001b[39m=\u001b[39m value\n",
      "File \u001b[0;32m/usr/lib/python3.10/xml/dom/minidom.py:1542\u001b[0m, in \u001b[0;36m_clear_id_cache\u001b[0;34m(node)\u001b[0m\n\u001b[1;32m   <a href='file:///usr/lib/python3.10/xml/dom/minidom.py?line=1539'>1540</a>\u001b[0m     node\u001b[39m.\u001b[39m_id_cache\u001b[39m.\u001b[39mclear()\n\u001b[1;32m   <a href='file:///usr/lib/python3.10/xml/dom/minidom.py?line=1540'>1541</a>\u001b[0m     node\u001b[39m.\u001b[39m_id_search_stack \u001b[39m=\u001b[39m \u001b[39mNone\u001b[39;00m\n\u001b[0;32m-> <a href='file:///usr/lib/python3.10/xml/dom/minidom.py?line=1541'>1542</a>\u001b[0m \u001b[39melif\u001b[39;00m _in_document(node):\n\u001b[1;32m   <a href='file:///usr/lib/python3.10/xml/dom/minidom.py?line=1542'>1543</a>\u001b[0m     node\u001b[39m.\u001b[39mownerDocument\u001b[39m.\u001b[39m_id_cache\u001b[39m.\u001b[39mclear()\n\u001b[1;32m   <a href='file:///usr/lib/python3.10/xml/dom/minidom.py?line=1543'>1544</a>\u001b[0m     node\u001b[39m.\u001b[39mownerDocument\u001b[39m.\u001b[39m_id_search_stack\u001b[39m=\u001b[39m \u001b[39mNone\u001b[39;00m\n",
      "File \u001b[0;32m/usr/lib/python3.10/xml/dom/minidom.py:297\u001b[0m, in \u001b[0;36m_in_document\u001b[0;34m(node)\u001b[0m\n\u001b[1;32m    <a href='file:///usr/lib/python3.10/xml/dom/minidom.py?line=294'>295</a>\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m_in_document\u001b[39m(node):\n\u001b[1;32m    <a href='file:///usr/lib/python3.10/xml/dom/minidom.py?line=295'>296</a>\u001b[0m     \u001b[39m# return True iff node is part of a document tree\u001b[39;00m\n\u001b[0;32m--> <a href='file:///usr/lib/python3.10/xml/dom/minidom.py?line=296'>297</a>\u001b[0m     \u001b[39mwhile\u001b[39;00m node \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[1;32m    <a href='file:///usr/lib/python3.10/xml/dom/minidom.py?line=297'>298</a>\u001b[0m         \u001b[39mif\u001b[39;00m node\u001b[39m.\u001b[39mnodeType \u001b[39m==\u001b[39m Node\u001b[39m.\u001b[39mDOCUMENT_NODE:\n\u001b[1;32m    <a href='file:///usr/lib/python3.10/xml/dom/minidom.py?line=298'>299</a>\u001b[0m             \u001b[39mreturn\u001b[39;00m \u001b[39mTrue\u001b[39;00m\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "# 构建xmind\n",
    "forest = Forest()\n",
    "forest.build_forest(chapter_name_array,[],None)\n",
    "for chapter in chapter_name_array:\n",
    "    chapter_edges=[edge for edge in chapter_edge_array if edge[2]==chapter]\n",
    "    chapter_nodes=[edge[0] for edge in chapter_edges]\n",
    "    forest.build_forest(chapter_nodes,chapter_edges,chapter)\n",
    "for l in log:\n",
    "    id,nodes_array_i,edges_array_i=l\n",
    "    part=part_array[id]\n",
    "    print(part)\n",
    "    forest.build_forest(nodes_array_i,edges_array_i,part)\n",
    "forest.build_kg(\"面向对象\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **5.分步重构**\n",
    "主要是两方面的工作：\n",
    "1.选段重新输入大模型\n",
    "2.大模型生成结果保存"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**大模型生成结果保存**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pickle\n",
    "with open('node.pkl', 'wb') as f:\n",
    "    pickle.dump(nodes_array, f)\n",
    "with open('edge.pkl', 'wb') as f:\n",
    "    pickle.dump(edges_array, f)\n",
    "with open('log.pkl', 'wb') as f:\n",
    "    pickle.dump(log, f)\n",
    "with open('part_array.pkl', 'wb') as f:\n",
    "    pickle.dump(part_array, f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pickle\n",
    "with open('node.pkl', 'rb') as f:\n",
    "    nodes_array = pickle.load(f)\n",
    "with open('edge.pkl', 'rb') as f:\n",
    "    edges_array = pickle.load(f)\n",
    "with open('log.pkl', 'rb') as f:\n",
    "    log = pickle.load(f)\n",
    "with open('part_array.pkl', 'rb') as f:\n",
    "    part_array = pickle.load(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**选段重新输入大模型**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[81, 58, 60, 68]\n"
     ]
    }
   ],
   "source": [
    "# 这块主要是为了处理出现错误的流程,当然如果觉得生成效果不够理想，也可以通过更改debug_array去将选中章节添加入重新生成的段落\n",
    "# 错误出现的主要原因是：1、文段过长，2、输出格式出错，3、请求过快或网络连接不稳定，4、请求文段中含有敏感文段\n",
    "# debug_array=[4, 9, 11, 13, 17, 25]\n",
    "debug_array=list(set(debug_array))\n",
    "print(debug_array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "————————————第0次请求————————————\n"
     ]
    },
    {
     "ename": "NameError",
     "evalue": "name 'prompt' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[8], line 15\u001b[0m\n\u001b[1;32m     13\u001b[0m     request\u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[38;5;124m'\u001b[39m\n\u001b[1;32m     14\u001b[0m \u001b[38;5;66;03m# messages.append({'role': Role.USER, 'content': request})\u001b[39;00m\n\u001b[0;32m---> 15\u001b[0m messages \u001b[38;5;241m=\u001b[39m [{\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mrole\u001b[39m\u001b[38;5;124m'\u001b[39m: Role\u001b[38;5;241m.\u001b[39mSYSTEM, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mcontent\u001b[39m\u001b[38;5;124m'\u001b[39m: \u001b[43mprompt\u001b[49m},\n\u001b[1;32m     16\u001b[0m         {\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mrole\u001b[39m\u001b[38;5;124m'\u001b[39m: Role\u001b[38;5;241m.\u001b[39mUSER, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mcontent\u001b[39m\u001b[38;5;124m'\u001b[39m: request}]\n\u001b[1;32m     17\u001b[0m response \u001b[38;5;241m=\u001b[39m Generation\u001b[38;5;241m.\u001b[39mcall(\n\u001b[1;32m     18\u001b[0m     Generation\u001b[38;5;241m.\u001b[39mModels\u001b[38;5;241m.\u001b[39mqwen_max_longcontext,\n\u001b[1;32m     19\u001b[0m     messages\u001b[38;5;241m=\u001b[39mmessages,\n\u001b[1;32m     20\u001b[0m     result_format\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mmessage\u001b[39m\u001b[38;5;124m'\u001b[39m,  \u001b[38;5;66;03m# set the result to be \"message\" format.\u001b[39;00m\n\u001b[1;32m     21\u001b[0m )\n\u001b[1;32m     22\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m response\u001b[38;5;241m.\u001b[39mstatus_code \u001b[38;5;241m==\u001b[39m HTTPStatus\u001b[38;5;241m.\u001b[39mOK:\n",
      "\u001b[0;31mNameError\u001b[0m: name 'prompt' is not defined"
     ]
    }
   ],
   "source": [
    "debug_id=0\n",
    "while debug_id<len(debug_array):\n",
    "    i=debug_array[debug_id]\n",
    "    start=pages_array[i]\n",
    "    end=pages_array[i+1]\n",
    "    contents=group_page_by_token_limit(pdf_output_path,50000, start, end)\n",
    "    debug_state=True\n",
    "    for content_id,content in enumerate(contents):\n",
    "        request=\"\"\n",
    "        print(\"————————————第\"+str(content_id)+\"次请求————————————\")\n",
    "        for paragraph_id,paragraph in enumerate(content):\n",
    "            request+=paragraph\n",
    "            request+='\\n'\n",
    "        # messages.append({'role': Role.USER, 'content': request})\n",
    "        messages = [{'role': Role.SYSTEM, 'content': prompt},\n",
    "                {'role': Role.USER, 'content': request}]\n",
    "        response = Generation.call(\n",
    "            Generation.Models.qwen_max_longcontext,\n",
    "            messages=messages,\n",
    "            result_format='message',  # set the result to be \"message\" format.\n",
    "        )\n",
    "        if response.status_code == HTTPStatus.OK:\n",
    "            raw_string=response.output.choices[0]['message']['content']\n",
    "            print(raw_string)\n",
    "            print(response.usage[\"total_tokens\"])\n",
    "            # append result to messages.\n",
    "            nodes_array_n,edges_array_n=str2json(raw_string.replace(\"'\", '\"'))\n",
    "            nodes_array+=[node for node in nodes_array_n if node not in nodes_array]\n",
    "            edges_array+=[edge for edge in edges_array_n if edge not in edges_array]\n",
    "            log.append((i,nodes_array_n,edges_array_n))\n",
    "        else:\n",
    "            print('Request id: %s, Status code: %s, error code: %s, error message: %s' % (\n",
    "                response.request_id, response.status_code,\n",
    "                response.code, response.message\n",
    "            ))\n",
    "            debug_state=False\n",
    "            break\n",
    "        secs = random.normalvariate(80, 0.4)\n",
    "        if secs <= 60 or secs >= 120:\n",
    "            secs =80   # 太小则重置为平均值\n",
    "        print(\"sleep:\"+str(secs)+\"秒\")\n",
    "        time.sleep(secs)\n",
    "    if debug_state:\n",
    "        debug_id+=1"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "3a43079d299c63bb783284bcb9ac9bc1e3eed3f0314f470cf5a5fdc85cb444e2"
  },
  "kernelspec": {
   "display_name": "docx2kg",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}