python --> ( 难度等级: [0, 1) || 挂载数据: 无 ) 
├── Python初阶 --> ( 难度等级: [0.0, 0.25) || 挂载数据: 无 ) 
│   ├── 预备知识 --> ( 难度等级: [0.0, 0.05) || 挂载数据: 无 ) 
│   │   ├── Python简介 --> ( 难度等级: [0.0, 0.0071) || 挂载数据: 无 ) 
│   │   │   └── Python都能做什么 --> ( 难度等级: [0.0, 0.0071) || 挂载数据: 无 ) 
│   │   ├── 程序设计思想 --> ( 难度等级: [0.0071, 0.0143) || 挂载数据: 无 ) 
│   │   ├── 安装Python --> ( 难度等级: [0.0143, 0.0214) || 挂载数据: 无 ) 
│   │   │   ├── Windows安装Python --> ( 难度等级: [0.0143, 0.0167) || 挂载数据: 无 ) 
│   │   │   ├── Linux安装Python --> ( 难度等级: [0.0167, 0.019) || 挂载数据: 无 ) 
│   │   │   └── MacOS安装Python --> ( 难度等级: [0.019, 0.0214) || 挂载数据: 无 ) 
│   │   ├── 运行方式 --> ( 难度等级: [0.0214, 0.0286) || 挂载数据: 无 ) 
│   │   │   ├── 以交互方式运行 --> ( 难度等级: [0.0214, 0.025) || 挂载数据: qa: 10 ) 
│   │   │   └── 以脚本方式运行 --> ( 难度等级: [0.025, 0.0286) || 挂载数据: qa: 5 ) 
│   │   ├── 常用开发工具 --> ( 难度等级: [0.0286, 0.0357) || 挂载数据: 无 ) 
│   │   │   ├── typing --- 类型提示支持 --> ( 难度等级: [0.0286, 0.029) || 挂载数据: 无 ) 
│   │   │   ├── pydoc --- 文档生成器和在线帮助系统 --> ( 难度等级: [0.029, 0.0295) || 挂载数据: 无 ) 
│   │   │   ├── Python Development Mode --> ( 难度等级: [0.0295, 0.0299) || 挂载数据: 无 ) 
│   │   │   ├── Effects of the Python Development Mode --> ( 难度等级: [0.0299, 0.0304) || 挂载数据: qa: 1 ) 
│   │   │   ├── ResourceWarning Example --> ( 难度等级: [0.0304, 0.0308) || 挂载数据: 无 ) 
│   │   │   ├── Bad file descriptor error example --> ( 难度等级: [0.0308, 0.0312) || 挂载数据: qa: 10 ) 
│   │   │   ├── doctest --- 测试交互性的Python示例 --> ( 难度等级: [0.0312, 0.0317) || 挂载数据: 无 ) 
│   │   │   ├── unittest --- 单元测试框架 --> ( 难度等级: [0.0317, 0.0321) || 挂载数据: 无 ) 
│   │   │   ├── unittest.mock --- mock对象库 --> ( 难度等级: [0.0321, 0.0326) || 挂载数据: 无 ) 
│   │   │   ├── unittest.mock上手指南 --> ( 难度等级: [0.0326, 0.033) || 挂载数据: 无 ) 
│   │   │   ├── 2to3 - 自动将Python 2 代码转为Python 3 代码 --> ( 难度等级: [0.033, 0.0335) || 挂载数据: 无 ) 
│   │   │   ├── test ---  Python回归测试包 --> ( 难度等级: [0.0335, 0.0339) || 挂载数据: 无 ) 
│   │   │   ├── test.support --- Utilities for the Python test suite --> ( 难度等级: [0.0339, 0.0344) || 挂载数据: 无 ) 
│   │   │   ├── test.support.socket_helper --- Utilities for socket tests --> ( 难度等级: [0.0344, 0.0348) || 挂载数据: 无 ) 
│   │   │   ├── test.support.script_helper --- Utilities for the Python execution tests --> ( 难度等级: [0.0348, 0.0353) || 挂载数据: 无 ) 
│   │   │   └── test.support.bytecode_helper --- Support tools for testing correct bytecode generation --> ( 难度等级: [0.0353, 0.0357) || 挂载数据: 无 ) 
│   │   ├── 编码规范 --> ( 难度等级: [0.0357, 0.0429) || 挂载数据: 无 ) 
│   │   └── 模块管理 --> ( 难度等级: [0.0429, 0.05) || 挂载数据: 无 ) 
│   │       └── pip --> ( 难度等级: [0.0429, 0.05) || 挂载数据: qa: 10 ) 
│   ├── 基础语法 --> ( 难度等级: [0.05, 0.1) || 挂载数据: 无 ) 
│   │   ├── 缩进规则 --> ( 难度等级: [0.05, 0.055) || 挂载数据: 无 ) 
│   │   │   └── 建议使用4个空格 --> ( 难度等级: [0.05, 0.055) || 挂载数据: qa: 1 ) 
│   │   ├── 基础知识 --> ( 难度等级: [0.055, 0.06) || 挂载数据: 无 ) 
│   │   │   ├── 注释 --> ( 难度等级: [0.055, 0.0554) || 挂载数据: 无 ) 
│   │   │   │   └── 如何编写注释 --> ( 难度等级: [0.055, 0.0554) || 挂载数据: qa: 9 ) 
│   │   │   ├── 变量 --> ( 难度等级: [0.0554, 0.0557) || 挂载数据: qa: 2 ) 
│   │   │   │   ├── 变量的命名和使用 --> ( 难度等级: [0.0554, 0.0555) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用变量时避免命名错误 --> ( 难度等级: [0.0555, 0.0556) || 挂载数据: 无 ) 
│   │   │   │   └── 变量是标签 --> ( 难度等级: [0.0556, 0.0557) || 挂载数据: qa: 10 ) 
│   │   │   ├── 语句 --> ( 难度等级: [0.0557, 0.0561) || 挂载数据: qa: 2 ) 
│   │   │   │   ├── 表达式语句 --> ( 难度等级: [0.0557, 0.0557) || 挂载数据: 无 ) 
│   │   │   │   ├── 赋值语句 --> ( 难度等级: [0.0557, 0.0558) || 挂载数据: 无 ) 
│   │   │   │   ├── assert语句 --> ( 难度等级: [0.0558, 0.0558) || 挂载数据: qa: 6 ) 
│   │   │   │   ├── return语句 --> ( 难度等级: [0.0558, 0.0558) || 挂载数据: qa: 3 ) 
│   │   │   │   ├── yield语句 --> ( 难度等级: [0.0558, 0.0559) || 挂载数据: 无 ) 
│   │   │   │   ├── raise语句 --> ( 难度等级: [0.0559, 0.0559) || 挂载数据: 无 ) 
│   │   │   │   ├── break语句 --> ( 难度等级: [0.0559, 0.0559) || 挂载数据: 无 ) 
│   │   │   │   ├── continue语句 --> ( 难度等级: [0.0559, 0.056) || 挂载数据: 无 ) 
│   │   │   │   ├── import语句 --> ( 难度等级: [0.056, 0.056) || 挂载数据: qa: 8 ) 
│   │   │   │   ├── global语句 --> ( 难度等级: [0.056, 0.056) || 挂载数据: qa: 5 ) 
│   │   │   │   └── nonlocal语句 --> ( 难度等级: [0.056, 0.0561) || 挂载数据: 无 ) 
│   │   │   ├── 标识符 --> ( 难度等级: [0.0561, 0.0564) || 挂载数据: 无 ) 
│   │   │   ├── 命名规则 --> ( 难度等级: [0.0564, 0.0568) || 挂载数据: 无 ) 
│   │   │   ├── 运算与表达式 --> ( 难度等级: [0.0568, 0.0571) || 挂载数据: 无 ) 
│   │   │   ├── 代码风格 --> ( 难度等级: [0.0571, 0.0575) || 挂载数据: 无 ) 
│   │   │   ├── 交互式解释器 --> ( 难度等级: [0.0575, 0.0579) || 挂载数据: 无 ) 
│   │   │   ├── 算法是什么 --> ( 难度等级: [0.0579, 0.0582) || 挂载数据: qa: 4 ) 
│   │   │   ├── 获取用户输入 --> ( 难度等级: [0.0582, 0.0586) || 挂载数据: 无 ) 
│   │   │   ├── 保存并执行程序 --> ( 难度等级: [0.0586, 0.0589) || 挂载数据: 无 ) 
│   │   │   │   ├── 从命令提示符运行Python脚本 --> ( 难度等级: [0.0586, 0.0588) || 挂载数据: 无 ) 
│   │   │   │   └── 让脚本像普通程序一样 --> ( 难度等级: [0.0588, 0.0589) || 挂载数据: 无 ) 
│   │   │   ├── 起步 --> ( 难度等级: [0.0589, 0.0593) || 挂载数据: 无 ) 
│   │   │   │   ├── 搭建编程环境 --> ( 难度等级: [0.0589, 0.059) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Python版本 --> ( 难度等级: [0.0589, 0.059) || 挂载数据: qa: 4 ) 
│   │   │   │   │   ├── 运行Python代码片段 --> ( 难度等级: [0.059, 0.059) || 挂载数据: 无 ) 
│   │   │   │   │   └── SublimeText简介 --> ( 难度等级: [0.059, 0.059) || 挂载数据: 无 ) 
│   │   │   │   ├── 在不同操作系统中搭建Python编程环境 --> ( 难度等级: [0.059, 0.0591) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 在Windows系统中搭建Python编程环境 --> ( 难度等级: [0.059, 0.059) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 在macOS系统中搭建Python编程环境 --> ( 难度等级: [0.059, 0.0591) || 挂载数据: 无 ) 
│   │   │   │   │   └── 在Linux系统中搭建Python编程环境 --> ( 难度等级: [0.0591, 0.0591) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 运行HelloWorld程序 --> ( 难度等级: [0.0591, 0.0592) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 配置SublimeText以使用正确的Python版本 --> ( 难度等级: [0.0591, 0.0592) || 挂载数据: qa: 1 ) 
│   │   │   │   │   └── 运行程序hello_world.py --> ( 难度等级: [0.0592, 0.0592) || 挂载数据: qa: 10 ) 
│   │   │   │   └── 从终端运行Python程序 --> ( 难度等级: [0.0592, 0.0593) || 挂载数据: 无 ) 
│   │   │   │       └── 在Windows系统中从终端运行Python程序 --> ( 难度等级: [0.0592, 0.0593) || 挂载数据: qa: 1 ) 
│   │   │   ├── 列表简介 --> ( 难度等级: [0.0593, 0.0596) || 挂载数据: 无 ) 
│   │   │   │   ├── 修改、添加和删除元素 --> ( 难度等级: [0.0593, 0.0594) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 修改列表元素 --> ( 难度等级: [0.0593, 0.0593) || 挂载数据: qa: 7 ) 
│   │   │   │   │   ├── 在列表中添加元素 --> ( 难度等级: [0.0593, 0.0594) || 挂载数据: qa: 3 ) 
│   │   │   │   │   └── 从列表中删除元素 --> ( 难度等级: [0.0594, 0.0594) || 挂载数据: qa: 10 ) 
│   │   │   │   ├── 组织列表 --> ( 难度等级: [0.0594, 0.0595) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 使用方法sort对列表永久排序 --> ( 难度等级: [0.0594, 0.0594) || 挂载数据: qa: 6 ) 
│   │   │   │   │   ├── 使用函数sorted对列表临时排序 --> ( 难度等级: [0.0594, 0.0595) || 挂载数据: qa: 1 ) 
│   │   │   │   │   ├── 倒着打印列表 --> ( 难度等级: [0.0595, 0.0595) || 挂载数据: qa: 1 ) 
│   │   │   │   │   └── 确定列表的长度 --> ( 难度等级: [0.0595, 0.0595) || 挂载数据: 无 ) 
│   │   │   │   └── 使用列表时避免索引错误 --> ( 难度等级: [0.0595, 0.0596) || 挂载数据: 无 ) 
│   │   │   └── 测试代码 --> ( 难度等级: [0.0596, 0.06) || 挂载数据: 无 ) 
│   │   │       └── 测试函数 --> ( 难度等级: [0.0596, 0.06) || 挂载数据: 无 ) 
│   │   ├── 函数 --> ( 难度等级: [0.06, 0.065) || 挂载数据: 无 ) 
│   │   │   ├── 函数定义def --> ( 难度等级: [0.06, 0.0601) || 挂载数据: qa: 4 ) 
│   │   │   ├── 参数var --> ( 难度等级: [0.0601, 0.0603) || 挂载数据: 无 ) 
│   │   │   ├── 返回值return --> ( 难度等级: [0.0603, 0.0604) || 挂载数据: 无 ) 
│   │   │   ├── 参数传递 --> ( 难度等级: [0.0604, 0.0605) || 挂载数据: 无 ) 
│   │   │   ├── 函数调用 --> ( 难度等级: [0.0605, 0.0607) || 挂载数据: qa: 1 ) 
│   │   │   ├── 函数递归 --> ( 难度等级: [0.0607, 0.0608) || 挂载数据: 无 ) 
│   │   │   ├── 函数编写风格 --> ( 难度等级: [0.0608, 0.0609) || 挂载数据: 无 ) 
│   │   │   ├── 调用函数 --> ( 难度等级: [0.0609, 0.0611) || 挂载数据: 无 ) 
│   │   │   ├── 函数的参数 --> ( 难度等级: [0.0611, 0.0612) || 挂载数据: 无 ) 
│   │   │   ├── 递归函数 --> ( 难度等级: [0.0612, 0.0613) || 挂载数据: qa: 1 ) 
│   │   │   ├── None值 --> ( 难度等级: [0.0613, 0.0614) || 挂载数据: qa: 3 ) 
│   │   │   ├── 调用栈 --> ( 难度等级: [0.0614, 0.0616) || 挂载数据: 无 ) 
│   │   │   ├── 局部和全局作用域 --> ( 难度等级: [0.0616, 0.0617) || 挂载数据: 无 ) 
│   │   │   │   ├── 局部变量不能在全局作用域内使用 --> ( 难度等级: [0.0616, 0.0616) || 挂载数据: 无 ) 
│   │   │   │   ├── 局部作用域不能使用其他局部作用域内的变量 --> ( 难度等级: [0.0616, 0.0617) || 挂载数据: 无 ) 
│   │   │   │   └── 全局变量可以在局部作用域中读取 --> ( 难度等级: [0.0617, 0.0617) || 挂载数据: 无 ) 
│   │   │   ├── 异常处理 --> ( 难度等级: [0.0617, 0.0618) || 挂载数据: 无 ) 
│   │   │   ├── 把函数视作对象 --> ( 难度等级: [0.0618, 0.062) || 挂载数据: 无 ) 
│   │   │   ├── 可调用对象 --> ( 难度等级: [0.062, 0.0621) || 挂载数据: 无 ) 
│   │   │   ├── 用户定义的可调用类型 --> ( 难度等级: [0.0621, 0.0622) || 挂载数据: 无 ) 
│   │   │   ├── 函数内省 --> ( 难度等级: [0.0622, 0.0624) || 挂载数据: 无 ) 
│   │   │   ├── 从定位参数到仅限关键字参数 --> ( 难度等级: [0.0624, 0.0625) || 挂载数据: 无 ) 
│   │   │   ├── 获取关于参数的信息 --> ( 难度等级: [0.0625, 0.0626) || 挂载数据: 无 ) 
│   │   │   ├── 支持函数式编程的包 --> ( 难度等级: [0.0626, 0.0628) || 挂载数据: 无 ) 
│   │   │   ├── 传递实参 --> ( 难度等级: [0.0628, 0.0629) || 挂载数据: 无 ) 
│   │   │   │   ├── 位置实参 --> ( 难度等级: [0.0628, 0.0628) || 挂载数据: qa: 2 ) 
│   │   │   │   ├── 关键字实参 --> ( 难度等级: [0.0628, 0.0628) || 挂载数据: 无 ) 
│   │   │   │   ├── 默认值 --> ( 难度等级: [0.0628, 0.0628) || 挂载数据: 无 ) 
│   │   │   │   ├── 等效的函数调用 --> ( 难度等级: [0.0628, 0.0629) || 挂载数据: 无 ) 
│   │   │   │   └── 避免实参错误 --> ( 难度等级: [0.0629, 0.0629) || 挂载数据: 无 ) 
│   │   │   ├── 返回值 --> ( 难度等级: [0.0629, 0.063) || 挂载数据: 无 ) 
│   │   │   │   ├── 返回简单值 --> ( 难度等级: [0.0629, 0.0629) || 挂载数据: 无 ) 
│   │   │   │   ├── 让实参变成可选的 --> ( 难度等级: [0.0629, 0.063) || 挂载数据: 无 ) 
│   │   │   │   └── 返回字典 --> ( 难度等级: [0.063, 0.063) || 挂载数据: qa: 4 ) 
│   │   │   ├── 传递列表 --> ( 难度等级: [0.063, 0.0632) || 挂载数据: 无 ) 
│   │   │   │   ├── 在函数中修改列表 --> ( 难度等级: [0.063, 0.0631) || 挂载数据: qa: 3 ) 
│   │   │   │   └── 禁止函数修改列表 --> ( 难度等级: [0.0631, 0.0632) || 挂载数据: 无 ) 
│   │   │   ├── 传递任意数量的实参 --> ( 难度等级: [0.0632, 0.0633) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用任意数量的关键字实参 --> ( 难度等级: [0.0632, 0.0632) || 挂载数据: qa: 2 ) 
│   │   │   │   ├── 导入特定的函数 --> ( 难度等级: [0.0632, 0.0632) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用as给函数指定别名 --> ( 难度等级: [0.0632, 0.0632) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 使用as给模块指定别名 --> ( 难度等级: [0.0632, 0.0633) || 挂载数据: 无 ) 
│   │   │   │   └── 导入模块中的所有函数 --> ( 难度等级: [0.0633, 0.0633) || 挂载数据: 无 ) 
│   │   │   ├── 函数编写指南 --> ( 难度等级: [0.0633, 0.0634) || 挂载数据: qa: 1 ) 
│   │   │   ├── 编写可接受任意数量参数的函数 --> ( 难度等级: [0.0634, 0.0636) || 挂载数据: 无 ) 
│   │   │   ├── 编写只接受关键字参数的函数 --> ( 难度等级: [0.0636, 0.0637) || 挂载数据: 无 ) 
│   │   │   ├── 将元数据信息附加到函数参数上 --> ( 难度等级: [0.0637, 0.0638) || 挂载数据: 无 ) 
│   │   │   ├── 从函数中返回多个值 --> ( 难度等级: [0.0638, 0.0639) || 挂载数据: 无 ) 
│   │   │   ├── 定义带有默认参数的函数 --> ( 难度等级: [0.0639, 0.0641) || 挂载数据: 无 ) 
│   │   │   ├── 定义匿名或内联函数 --> ( 难度等级: [0.0641, 0.0642) || 挂载数据: 无 ) 
│   │   │   ├── 在匿名函数中绑定变量的值 --> ( 难度等级: [0.0642, 0.0643) || 挂载数据: qa: 1 ) 
│   │   │   ├── 让带有N个参数的可调用对象以较少的参数形式调用 --> ( 难度等级: [0.0643, 0.0645) || 挂载数据: 无 ) 
│   │   │   ├── 用函数替代只有单个方法的类 --> ( 难度等级: [0.0645, 0.0646) || 挂载数据: qa: 1 ) 
│   │   │   ├── 在回调函数中携带额外的状态 --> ( 难度等级: [0.0646, 0.0647) || 挂载数据: 无 ) 
│   │   │   ├── 内联回调函数 --> ( 难度等级: [0.0647, 0.0649) || 挂载数据: 无 ) 
│   │   │   └── 访问定义在闭包内的变量 --> ( 难度等级: [0.0649, 0.065) || 挂载数据: 无 ) 
│   │   ├── 类 --> ( 难度等级: [0.065, 0.07) || 挂载数据: qa: 3 ) 
│   │   │   ├── 类定义class --> ( 难度等级: [0.065, 0.0653) || 挂载数据: qa: 5 ) 
│   │   │   ├── 作用域和命名空间 --> ( 难度等级: [0.0653, 0.0655) || 挂载数据: 无 ) 
│   │   │   ├── 对象 --> ( 难度等级: [0.0655, 0.0658) || 挂载数据: 无 ) 
│   │   │   ├── 属性和方法 --> ( 难度等级: [0.0658, 0.066) || 挂载数据: 无 ) 
│   │   │   │   ├── 模拟数值类型 --> ( 难度等级: [0.0658, 0.0658) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 字符串表示形式 --> ( 难度等级: [0.0658, 0.0659) || 挂载数据: 无 ) 
│   │   │   │   └── 自定义的布尔值 --> ( 难度等级: [0.0659, 0.066) || 挂载数据: 无 ) 
│   │   │   ├── 类编码风格 --> ( 难度等级: [0.066, 0.0663) || 挂载数据: 无 ) 
│   │   │   ├── 初探类 --> ( 难度等级: [0.0663, 0.0665) || 挂载数据: 无 ) 
│   │   │   │   ├── 类定义语法 --> ( 难度等级: [0.0663, 0.0663) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 类对象 --> ( 难度等级: [0.0663, 0.0664) || 挂载数据: qa: 1 ) 
│   │   │   │   └── 方法对象 --> ( 难度等级: [0.0664, 0.0665) || 挂载数据: 无 ) 
│   │   │   ├── 补充说明 --> ( 难度等级: [0.0665, 0.0668) || 挂载数据: 无 ) 
│   │   │   ├── 私有变量 --> ( 难度等级: [0.0668, 0.067) || 挂载数据: 无 ) 
│   │   │   ├── 生成器表达式 --> ( 难度等级: [0.067, 0.0673) || 挂载数据: 无 ) 
│   │   │   ├── 类到底是什么 --> ( 难度等级: [0.0673, 0.0675) || 挂载数据: qa: 1 ) 
│   │   │   ├── 创建自定义类 --> ( 难度等级: [0.0675, 0.0678) || 挂载数据: qa: 1 ) 
│   │   │   ├── 再谈隐藏 --> ( 难度等级: [0.0678, 0.068) || 挂载数据: 无 ) 
│   │   │   ├── 类的命名空间 --> ( 难度等级: [0.068, 0.0683) || 挂载数据: 无 ) 
│   │   │   ├── 指定超类 --> ( 难度等级: [0.0683, 0.0685) || 挂载数据: 无 ) 
│   │   │   ├── 深入探讨继承 --> ( 难度等级: [0.0685, 0.0688) || 挂载数据: 无 ) 
│   │   │   ├── 多个超类 --> ( 难度等级: [0.0688, 0.069) || 挂载数据: 无 ) 
│   │   │   ├── 接口和内省 --> ( 难度等级: [0.069, 0.0693) || 挂载数据: 无 ) 
│   │   │   │   ├── Python文化中的接口和协议 --> ( 难度等级: [0.069, 0.069) || 挂载数据: 无 ) 
│   │   │   │   ├── Python喜欢序列 --> ( 难度等级: [0.069, 0.0691) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用猴子补丁在运行时实现协议 --> ( 难度等级: [0.0691, 0.0691) || 挂载数据: 无 ) 
│   │   │   │   ├── Alex Martelli的水禽 --> ( 难度等级: [0.0691, 0.0691) || 挂载数据: 无 ) 
│   │   │   │   ├── 定义抽象基类的子类 --> ( 难度等级: [0.0691, 0.0691) || 挂载数据: 无 ) 
│   │   │   │   ├── 标准库中的抽象基类 --> ( 难度等级: [0.0691, 0.0692) || 挂载数据: 无 ) 
│   │   │   │   ├── 定义并使用一个抽象基类 --> ( 难度等级: [0.0692, 0.0692) || 挂载数据: 无 ) 
│   │   │   │   ├── Tombola子类的测试方法 --> ( 难度等级: [0.0692, 0.0692) || 挂载数据: 无 ) 
│   │   │   │   ├── Python使用register的方式 --> ( 难度等级: [0.0692, 0.0692) || 挂载数据: 无 ) 
│   │   │   │   └── 鹅的行为有可能像鸭子 --> ( 难度等级: [0.0692, 0.0693) || 挂载数据: 无 ) 
│   │   │   ├── 抽象基类 --> ( 难度等级: [0.0693, 0.0695) || 挂载数据: 无 ) 
│   │   │   ├── 导入类 --> ( 难度等级: [0.0695, 0.0698) || 挂载数据: 无 ) 
│   │   │   │   ├── 导入单个类 --> ( 难度等级: [0.0695, 0.0696) || 挂载数据: 无 ) 
│   │   │   │   ├── 在一个模块中存储多个类 --> ( 难度等级: [0.0696, 0.0696) || 挂载数据: 无 ) 
│   │   │   │   ├── 从一个模块中导入多个类 --> ( 难度等级: [0.0696, 0.0697) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 导入模块中的所有类 --> ( 难度等级: [0.0697, 0.0697) || 挂载数据: 无 ) 
│   │   │   │   └── 自定义工作流程 --> ( 难度等级: [0.0697, 0.0698) || 挂载数据: 无 ) 
│   │   │   └── Python标准库 --> ( 难度等级: [0.0698, 0.07) || 挂载数据: 无 ) 
│   │   ├── 顺序语句结构 --> ( 难度等级: [0.07, 0.075) || 挂载数据: 无 ) 
│   │   ├── 条件和分支 --> ( 难度等级: [0.075, 0.08) || 挂载数据: 无 ) 
│   │   │   ├── if --> ( 难度等级: [0.075, 0.0754) || 挂载数据: 无 ) 
│   │   │   │   ├── if-else语句 --> ( 难度等级: [0.075, 0.0751) || 挂载数据: qa: 10 ) 
│   │   │   │   ├── if-elif-else结构 --> ( 难度等级: [0.0751, 0.0752) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 省略else代码块 --> ( 难度等级: [0.0752, 0.0752) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用if语句处理列表 --> ( 难度等级: [0.0752, 0.0753) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 检查特殊元素 --> ( 难度等级: [0.0752, 0.0753) || 挂载数据: 无 ) 
│   │   │   │   │   └── 确定列表不是空的 --> ( 难度等级: [0.0753, 0.0753) || 挂载数据: qa: 6 ) 
│   │   │   │   └── 设置if语句的格式 --> ( 难度等级: [0.0753, 0.0754) || 挂载数据: 无 ) 
│   │   │   ├── elif --> ( 难度等级: [0.0754, 0.0758) || 挂载数据: 无 ) 
│   │   │   ├── else --> ( 难度等级: [0.0758, 0.0762) || 挂载数据: 无 ) 
│   │   │   ├── 条件判断 --> ( 难度等级: [0.0762, 0.0765) || 挂载数据: qa: 3 ) 
│   │   │   ├── 这正是布尔值的用武之地 --> ( 难度等级: [0.0765, 0.0769) || 挂载数据: 无 ) 
│   │   │   ├── 代码块嵌套 --> ( 难度等级: [0.0769, 0.0773) || 挂载数据: 无 ) 
│   │   │   │   ├── 字典列表 --> ( 难度等级: [0.0769, 0.0771) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 在字典中存储列表 --> ( 难度等级: [0.0771, 0.0772) || 挂载数据: 无 ) 
│   │   │   │   └── 在字典中存储字典 --> ( 难度等级: [0.0772, 0.0773) || 挂载数据: 无 ) 
│   │   │   ├── 检查是否相等 --> ( 难度等级: [0.0773, 0.0777) || 挂载数据: qa: 1 ) 
│   │   │   ├── 检查是否相等时忽略大小写 --> ( 难度等级: [0.0777, 0.0781) || 挂载数据: 无 ) 
│   │   │   ├── 检查是否不相等 --> ( 难度等级: [0.0781, 0.0785) || 挂载数据: 无 ) 
│   │   │   ├── 数值比较 --> ( 难度等级: [0.0785, 0.0788) || 挂载数据: 无 ) 
│   │   │   ├── 检查多个条件 --> ( 难度等级: [0.0788, 0.0792) || 挂载数据: 无 ) 
│   │   │   ├── 检查特定值是否包含在列表中 --> ( 难度等级: [0.0792, 0.0796) || 挂载数据: 无 ) 
│   │   │   └── 布尔表达式 --> ( 难度等级: [0.0796, 0.08) || 挂载数据: 无 ) 
│   │   ├── 循环 --> ( 难度等级: [0.08, 0.085) || 挂载数据: 无 ) 
│   │   │   ├── for --> ( 难度等级: [0.08, 0.0806) || 挂载数据: qa: 7 ) 
│   │   │   ├── while --> ( 难度等级: [0.0806, 0.0811) || 挂载数据: qa: 3 ) 
│   │   │   ├── break --> ( 难度等级: [0.0811, 0.0817) || 挂载数据: qa: 2 ) 
│   │   │   ├── continue --> ( 难度等级: [0.0817, 0.0822) || 挂载数据: qa: 1 ) 
│   │   │   ├── 循环判断 --> ( 难度等级: [0.0822, 0.0828) || 挂载数据: 无 ) 
│   │   │   ├── 迭代字典 --> ( 难度等级: [0.0828, 0.0833) || 挂载数据: 无 ) 
│   │   │   ├── 一些迭代工具 --> ( 难度等级: [0.0833, 0.0839) || 挂载数据: 无 ) 
│   │   │   ├── 跳出循环 --> ( 难度等级: [0.0839, 0.0844) || 挂载数据: 无 ) 
│   │   │   └── 循环中的else子句 --> ( 难度等级: [0.0844, 0.085) || 挂载数据: qa: 3 ) 
│   │   ├── 数据类型 --> ( 难度等级: [0.085, 0.09) || 挂载数据: 无 ) 
│   │   │   ├── 整型 --> ( 难度等级: [0.085, 0.0853) || 挂载数据: 无 ) 
│   │   │   ├── 浮点型 --> ( 难度等级: [0.0853, 0.0855) || 挂载数据: 无 ) 
│   │   │   ├── 布尔型 --> ( 难度等级: [0.0855, 0.0858) || 挂载数据: 无 ) 
│   │   │   ├── 字符串 --> ( 难度等级: [0.0858, 0.0861) || 挂载数据: qa: 2 ) 
│   │   │   │   ├── 单引号字符串以及对引号转义 --> ( 难度等级: [0.0858, 0.0858) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 拼接字符串 --> ( 难度等级: [0.0858, 0.0858) || 挂载数据: 无 ) 
│   │   │   │   ├── 字符串表示str和repr --> ( 难度等级: [0.0858, 0.0859) || 挂载数据: qa: 3 ) 
│   │   │   │   ├── 长字符串、原始字符串和字节 --> ( 难度等级: [0.0859, 0.0859) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 字符串基本操作 --> ( 难度等级: [0.0859, 0.0859) || 挂载数据: 无 ) 
│   │   │   │   ├── 设置字符串的格式：精简版 --> ( 难度等级: [0.0859, 0.0859) || 挂载数据: qa: 2 ) 
│   │   │   │   │   └── 替换字段名 --> ( 难度等级: [0.0859, 0.0859) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用方法修改字符串的大小写 --> ( 难度等级: [0.0859, 0.086) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用制表符或换行符来添加空白 --> ( 难度等级: [0.086, 0.086) || 挂载数据: 无 ) 
│   │   │   │   ├── 删除空白 --> ( 难度等级: [0.086, 0.086) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用字符串时避免语法错误 --> ( 难度等级: [0.086, 0.086) || 挂载数据: qa: 3 ) 
│   │   │   │   └── 字符串编码转换 --> ( 难度等级: [0.086, 0.0861) || 挂载数据: qa: 2 ) 
│   │   │   │       ├── 使用encode方法编码 --> ( 难度等级: [0.086, 0.086) || 挂载数据: qa: 2 ) 
│   │   │   │       └── 使用decode方法解码 --> ( 难度等级: [0.086, 0.0861) || 挂载数据: 无 ) 
│   │   │   ├── datetime --- 基本的日期和时间类型 --> ( 难度等级: [0.0861, 0.0863) || 挂载数据: 无 ) 
│   │   │   ├── zoneinfo --- IANA时区支持 --> ( 难度等级: [0.0863, 0.0866) || 挂载数据: 无 ) 
│   │   │   ├── calendar --- 日历相关函数 --> ( 难度等级: [0.0866, 0.0868) || 挂载数据: 无 ) 
│   │   │   ├── collections --- 容器数据类型 --> ( 难度等级: [0.0868, 0.0871) || 挂载数据: qa: 1 ) 
│   │   │   ├── collections.abc --- 容器的抽象基类 --> ( 难度等级: [0.0871, 0.0874) || 挂载数据: 无 ) 
│   │   │   ├── heapq --- 堆队列算法 --> ( 难度等级: [0.0874, 0.0876) || 挂载数据: 无 ) 
│   │   │   ├── bisect --- 数组二分查找算法 --> ( 难度等级: [0.0876, 0.0879) || 挂载数据: 无 ) 
│   │   │   ├── array --- 高效的数值数组 --> ( 难度等级: [0.0879, 0.0882) || 挂载数据: qa: 1 ) 
│   │   │   ├── weakref --- 弱引用 --> ( 难度等级: [0.0882, 0.0884) || 挂载数据: 无 ) 
│   │   │   ├── types --- 动态类型创建和内置类型名称 --> ( 难度等级: [0.0884, 0.0887) || 挂载数据: 无 ) 
│   │   │   ├── copy --- 浅层 (shallow) 和深层 (deep) 复制操作 --> ( 难度等级: [0.0887, 0.0889) || 挂载数据: qa: 1 ) 
│   │   │   ├── pprint --- 数据美化输出 --> ( 难度等级: [0.0889, 0.0892) || 挂载数据: 无 ) 
│   │   │   ├── reprlib --- 另一种repr 实现 --> ( 难度等级: [0.0892, 0.0895) || 挂载数据: 无 ) 
│   │   │   ├── enum --- 对枚举的支持 --> ( 难度等级: [0.0895, 0.0897) || 挂载数据: 无 ) 
│   │   │   └── graphlib --- Functionality to operate with graph-like structures --> ( 难度等级: [0.0897, 0.09) || 挂载数据: 无 ) 
│   │   ├── 内置类 --> ( 难度等级: [0.09, 0.095) || 挂载数据: 无 ) 
│   │   │   ├── 列表：list --> ( 难度等级: [0.09, 0.0908) || 挂载数据: 无 ) 
│   │   │   │   ├── 函数list --> ( 难度等级: [0.09, 0.0901) || 挂载数据: qa: 10 ) 
│   │   │   │   ├── 基本的列表操作 --> ( 难度等级: [0.0901, 0.0901) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 遍历整个列表 --> ( 难度等级: [0.0901, 0.0901) || 挂载数据: qa: 1 ) 
│   │   │   │   │   │   ├── 深入研究循环 --> ( 难度等级: [0.0901, 0.0901) || 挂载数据: qa: 6 ) 
│   │   │   │   │   │   ├── 在for循环中执行更多操作 --> ( 难度等级: [0.0901, 0.0901) || 挂载数据: qa: 10 ) 
│   │   │   │   │   │   └── 在for循环结束后执行一些操作 --> ( 难度等级: [0.0901, 0.0901) || 挂载数据: qa: 1 ) 
│   │   │   │   │   ├── 避免缩进错误 --> ( 难度等级: [0.0901, 0.0901) || 挂载数据: qa: 2 ) 
│   │   │   │   │   │   ├── 忘记缩进 --> ( 难度等级: [0.0901, 0.0901) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── 忘记缩进额外的代码行 --> ( 难度等级: [0.0901, 0.0901) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── 不必要的缩进 --> ( 难度等级: [0.0901, 0.0901) || 挂载数据: qa: 2 ) 
│   │   │   │   │   │   ├── 循环后不必要的缩进 --> ( 难度等级: [0.0901, 0.0901) || 挂载数据: 无 ) 
│   │   │   │   │   │   └── 遗漏了冒号 --> ( 难度等级: [0.0901, 0.0901) || 挂载数据: qa: 1 ) 
│   │   │   │   │   ├── 创建数值列表 --> ( 难度等级: [0.0901, 0.0901) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── 使用range创建数字列表 --> ( 难度等级: [0.0901, 0.0901) || 挂载数据: qa: 6 ) 
│   │   │   │   │   │   ├── 对数字列表执行简单的统计计算 --> ( 难度等级: [0.0901, 0.0901) || 挂载数据: qa: 3 ) 
│   │   │   │   │   │   └── 列表解析 --> ( 难度等级: [0.0901, 0.0901) || 挂载数据: qa: 10 ) 
│   │   │   │   │   └── 设置代码格式 --> ( 难度等级: [0.0901, 0.0901) || 挂载数据: 无 ) 
│   │   │   │   │       ├── 格式设置指南 --> ( 难度等级: [0.0901, 0.0901) || 挂载数据: 无 ) 
│   │   │   │   │       ├── 行长 --> ( 难度等级: [0.0901, 0.0901) || 挂载数据: 无 ) 
│   │   │   │   │       ├── 空行 --> ( 难度等级: [0.0901, 0.0901) || 挂载数据: 无 ) 
│   │   │   │   │       └── 其他格式设置指南 --> ( 难度等级: [0.0901, 0.0901) || 挂载数据: qa: 10 ) 
│   │   │   │   ├── 列表方法 --> ( 难度等级: [0.0901, 0.0902) || 挂载数据: 无 ) 
│   │   │   │   ├── 列表数据类型 --> ( 难度等级: [0.0902, 0.0902) || 挂载数据: 无 ) 
│   │   │   │   ├── 增强的赋值操作 --> ( 难度等级: [0.0902, 0.0903) || 挂载数据: 无 ) 
│   │   │   │   ├── 序列数据类型 --> ( 难度等级: [0.0903, 0.0903) || 挂载数据: 无 ) 
│   │   │   │   ├── 引用 --> ( 难度等级: [0.0903, 0.0904) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 访问列表元素 --> ( 难度等级: [0.0904, 0.0904) || 挂载数据: 无 ) 
│   │   │   │   ├── 索引从0而不是1开始 --> ( 难度等级: [0.0904, 0.0905) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用列表中的各个值 --> ( 难度等级: [0.0905, 0.0906) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 遍历切片 --> ( 难度等级: [0.0906, 0.0906) || 挂载数据: 无 ) 
│   │   │   │   ├── 复制列表 --> ( 难度等级: [0.0906, 0.0907) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 列表的创建和删除 --> ( 难度等级: [0.0907, 0.0907) || 挂载数据: 无 ) 
│   │   │   │   ├── 对列表进行统计计算 --> ( 难度等级: [0.0907, 0.0908) || 挂载数据: 无 ) 
│   │   │   │   └── 对列表进行排序 --> ( 难度等级: [0.0908, 0.0908) || 挂载数据: 无 ) 
│   │   │   ├── 字典：dict --> ( 难度等级: [0.0908, 0.0917) || 挂载数据: qa: 3 ) 
│   │   │   │   ├── 访问字典中的值 --> ( 难度等级: [0.0908, 0.0909) || 挂载数据: 无 ) 
│   │   │   │   ├── 添加键值对 --> ( 难度等级: [0.0909, 0.091) || 挂载数据: 无 ) 
│   │   │   │   ├── 先创建一个空字典 --> ( 难度等级: [0.091, 0.0911) || 挂载数据: 无 ) 
│   │   │   │   ├── 修改字典中的值 --> ( 难度等级: [0.0911, 0.0912) || 挂载数据: qa: 2 ) 
│   │   │   │   ├── 删除键值对 --> ( 难度等级: [0.0912, 0.0912) || 挂载数据: 无 ) 
│   │   │   │   ├── 由类似对象组成的字典 --> ( 难度等级: [0.0912, 0.0913) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用get来访问值 --> ( 难度等级: [0.0913, 0.0914) || 挂载数据: qa: 3 ) 
│   │   │   │   ├── 遍历字典 --> ( 难度等级: [0.0914, 0.0915) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 遍历所有键值对 --> ( 难度等级: [0.0914, 0.0914) || 挂载数据: qa: 10 ) 
│   │   │   │   │   ├── 遍历字典中的所有键 --> ( 难度等级: [0.0914, 0.0915) || 挂载数据: qa: 2 ) 
│   │   │   │   │   ├── 按特定顺序遍历字典中的所有键 --> ( 难度等级: [0.0915, 0.0915) || 挂载数据: 无 ) 
│   │   │   │   │   └── 遍历字典中的所有值 --> ( 难度等级: [0.0915, 0.0915) || 挂载数据: qa: 10 ) 
│   │   │   │   ├── 访问字典 --> ( 难度等级: [0.0915, 0.0916) || 挂载数据: 无 ) 
│   │   │   │   └── 字典推导式 --> ( 难度等级: [0.0916, 0.0917) || 挂载数据: qa: 1 ) 
│   │   │   ├── 元组：tuple --> ( 难度等级: [0.0917, 0.0925) || 挂载数据: 无 ) 
│   │   │   │   ├── 定义元组 --> ( 难度等级: [0.0917, 0.0918) || 挂载数据: 无 ) 
│   │   │   │   ├── 遍历元组中的所有值 --> ( 难度等级: [0.0918, 0.0919) || 挂载数据: 无 ) 
│   │   │   │   ├── 修改元组变量 --> ( 难度等级: [0.0919, 0.0921) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 访问元组元素 --> ( 难度等级: [0.0921, 0.0922) || 挂载数据: 无 ) 
│   │   │   │   ├── 修改元组 --> ( 难度等级: [0.0922, 0.0924) || 挂载数据: qa: 3 ) 
│   │   │   │   └── 元组推导式 --> ( 难度等级: [0.0924, 0.0925) || 挂载数据: 无 ) 
│   │   │   ├── 集合：set --> ( 难度等级: [0.0925, 0.0933) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 创建集合 --> ( 难度等级: [0.0925, 0.0929) || 挂载数据: qa: 3 ) 
│   │   │   │   └── 集合的交集、并集和差集运算 --> ( 难度等级: [0.0929, 0.0933) || 挂载数据: 无 ) 
│   │   │   ├── 整型：int --> ( 难度等级: [0.0933, 0.0942) || 挂载数据: qa: 3 ) 
│   │   │   └── 字符串：str --> ( 难度等级: [0.0942, 0.095) || 挂载数据: qa: 6 ) 
│   │   └── 常用内置函数 --> ( 难度等级: [0.095, 0.1) || 挂载数据: 无 ) 
│   │       ├── help --> ( 难度等级: [0.095, 0.0954) || 挂载数据: 无 ) 
│   │       ├── input --> ( 难度等级: [0.0954, 0.0958) || 挂载数据: qa: 2 ) 
│   │       ├── print --> ( 难度等级: [0.0958, 0.0962) || 挂载数据: qa: 10 ) 
│   │       ├── range --> ( 难度等级: [0.0962, 0.0965) || 挂载数据: qa: 5 ) 
│   │       ├── format --> ( 难度等级: [0.0965, 0.0969) || 挂载数据: qa: 6 ) 
│   │       ├── len --> ( 难度等级: [0.0969, 0.0973) || 挂载数据: qa: 1 ) 
│   │       ├── sorted --> ( 难度等级: [0.0973, 0.0977) || 挂载数据: qa: 5 ) 
│   │       ├── open --> ( 难度等级: [0.0977, 0.0981) || 挂载数据: qa: 1 ) 
│   │       ├── dir --> ( 难度等级: [0.0981, 0.0985) || 挂载数据: 无 ) 
│   │       ├── enumerate/zip --> ( 难度等级: [0.0985, 0.0988) || 挂载数据: qa: 3 ) 
│   │       ├── type/isinstance --> ( 难度等级: [0.0988, 0.0992) || 挂载数据: 无 ) 
│   │       ├── min/max/sum --> ( 难度等级: [0.0992, 0.0996) || 挂载数据: qa: 3 ) 
│   │       └── abs/round/pow/divmod --> ( 难度等级: [0.0996, 0.1) || 挂载数据: 无 ) 
│   ├── 进阶语法 --> ( 难度等级: [0.1, 0.15) || 挂载数据: 无 ) 
│   │   ├── 列表推导式 --> ( 难度等级: [0.1, 0.105) || 挂载数据: 无 ) 
│   │   ├── 三元表达式 --> ( 难度等级: [0.105, 0.11) || 挂载数据: qa: 1 ) 
│   │   │   ├── 算术转换 --> ( 难度等级: [0.105, 0.1053) || 挂载数据: 无 ) 
│   │   │   ├── 原子 --> ( 难度等级: [0.1053, 0.1057) || 挂载数据: 无 ) 
│   │   │   ├── 原型 --> ( 难度等级: [0.1057, 0.106) || 挂载数据: 无 ) 
│   │   │   ├── await表达式 --> ( 难度等级: [0.106, 0.1063) || 挂载数据: qa: 3 ) 
│   │   │   ├── 幂运算符 --> ( 难度等级: [0.1063, 0.1067) || 挂载数据: 无 ) 
│   │   │   ├── 一元算术和位运算 --> ( 难度等级: [0.1067, 0.107) || 挂载数据: 无 ) 
│   │   │   ├── 二元算术运算符 --> ( 难度等级: [0.107, 0.1073) || 挂载数据: 无 ) 
│   │   │   ├── 移位运算 --> ( 难度等级: [0.1073, 0.1077) || 挂载数据: qa: 1 ) 
│   │   │   ├── 比较运算 --> ( 难度等级: [0.1077, 0.108) || 挂载数据: 无 ) 
│   │   │   ├── 布尔运算 --> ( 难度等级: [0.108, 0.1083) || 挂载数据: 无 ) 
│   │   │   ├── 赋值表达式 --> ( 难度等级: [0.1083, 0.1087) || 挂载数据: qa: 1 ) 
│   │   │   ├── 条件表达式 --> ( 难度等级: [0.1087, 0.109) || 挂载数据: 无 ) 
│   │   │   ├── 表达式列表 --> ( 难度等级: [0.109, 0.1093) || 挂载数据: 无 ) 
│   │   │   ├── 求值顺序 --> ( 难度等级: [0.1093, 0.1097) || 挂载数据: 无 ) 
│   │   │   └── 运算符优先级 --> ( 难度等级: [0.1097, 0.11) || 挂载数据: 无 ) 
│   │   ├── 断言 --> ( 难度等级: [0.11, 0.115) || 挂载数据: 无 ) 
│   │   ├── with-as --> ( 难度等级: [0.115, 0.12) || 挂载数据: 无 ) 
│   │   ├── 异常捕获预处理 --> ( 难度等级: [0.12, 0.125) || 挂载数据: 无 ) 
│   │   │   ├── try-catch-finally --> ( 难度等级: [0.12, 0.1225) || 挂载数据: 无 ) 
│   │   │   └── 异常捕获 --> ( 难度等级: [0.1225, 0.125) || 挂载数据: 无 ) 
│   │   ├── 字符串方法 --> ( 难度等级: [0.125, 0.13) || 挂载数据: 无 ) 
│   │   │   ├── find --> ( 难度等级: [0.125, 0.1255) || 挂载数据: qa: 5 ) 
│   │   │   ├── index --> ( 难度等级: [0.1255, 0.1259) || 挂载数据: qa: 4 ) 
│   │   │   ├── join --> ( 难度等级: [0.1259, 0.1264) || 挂载数据: qa: 2 ) 
│   │   │   ├── lower --> ( 难度等级: [0.1264, 0.1268) || 挂载数据: qa: 2 ) 
│   │   │   ├── replace --> ( 难度等级: [0.1268, 0.1273) || 挂载数据: qa: 2 ) 
│   │   │   ├── split --> ( 难度等级: [0.1273, 0.1277) || 挂载数据: qa: 3 ) 
│   │   │   ├── strip --> ( 难度等级: [0.1277, 0.1282) || 挂载数据: 无 ) 
│   │   │   ├── translate --> ( 难度等级: [0.1282, 0.1286) || 挂载数据: 无 ) 
│   │   │   ├── upper --> ( 难度等级: [0.1286, 0.1291) || 挂载数据: 无 ) 
│   │   │   ├── center --> ( 难度等级: [0.1291, 0.1295) || 挂载数据: 无 ) 
│   │   │   └── 判断字符串是否满足特定的条件 --> ( 难度等级: [0.1295, 0.13) || 挂载数据: qa: 1 ) 
│   │   ├── lambda函数 --> ( 难度等级: [0.13, 0.135) || 挂载数据: qa: 1 ) 
│   │   │   ├── 迭代器 --> ( 难度等级: [0.13, 0.1313) || 挂载数据: 无 ) 
│   │   │   │   ├── 迭代器协议 --> ( 难度等级: [0.13, 0.1306) || 挂载数据: 无 ) 
│   │   │   │   └── 从迭代器创建序列 --> ( 难度等级: [0.1306, 0.1313) || 挂载数据: 无 ) 
│   │   │   ├── 生成器 --> ( 难度等级: [0.1313, 0.1325) || 挂载数据: 无 ) 
│   │   │   │   ├── 创建生成器 --> ( 难度等级: [0.1313, 0.1315) || 挂载数据: qa: 6 ) 
│   │   │   │   ├── 递归式生成器 --> ( 难度等级: [0.1315, 0.1318) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 通用生成器 --> ( 难度等级: [0.1318, 0.132) || 挂载数据: 无 ) 
│   │   │   │   ├── 生成器的方法 --> ( 难度等级: [0.132, 0.1323) || 挂载数据: 无 ) 
│   │   │   │   └── 模拟生成器 --> ( 难度等级: [0.1323, 0.1325) || 挂载数据: 无 ) 
│   │   │   ├── 装饰器 --> ( 难度等级: [0.1325, 0.1338) || 挂载数据: qa: 1 ) 
│   │   │   └── 闭包 --> ( 难度等级: [0.1338, 0.135) || 挂载数据: 无 ) 
│   │   ├── 文件 --> ( 难度等级: [0.135, 0.14) || 挂载数据: 无 ) 
│   │   │   ├── 打开文件 --> ( 难度等级: [0.135, 0.1363) || 挂载数据: qa: 10 ) 
│   │   │   ├── 文件基本方法 --> ( 难度等级: [0.1363, 0.1375) || 挂载数据: 无 ) 
│   │   │   ├── 文件内容迭代 --> ( 难度等级: [0.1375, 0.1388) || 挂载数据: 无 ) 
│   │   │   │   ├── 每次一个字符（或字节） --> ( 难度等级: [0.1375, 0.1378) || 挂载数据: 无 ) 
│   │   │   │   ├── 每次一行 --> ( 难度等级: [0.1378, 0.138) || 挂载数据: 无 ) 
│   │   │   │   ├── 读取所有内容 --> ( 难度等级: [0.138, 0.1383) || 挂载数据: qa: 9 ) 
│   │   │   │   ├── 使用fileinput实现延迟行迭代 --> ( 难度等级: [0.1383, 0.1385) || 挂载数据: 无 ) 
│   │   │   │   └── 文件迭代器 --> ( 难度等级: [0.1385, 0.1388) || 挂载数据: 无 ) 
│   │   │   └── 文件的基本方法 --> ( 难度等级: [0.1388, 0.14) || 挂载数据: 无 ) 
│   │   │       ├── 读取和写入 --> ( 难度等级: [0.1388, 0.139) || 挂载数据: 无 ) 
│   │   │       ├── 使用管道重定向输出 --> ( 难度等级: [0.139, 0.1393) || 挂载数据: 无 ) 
│   │   │       ├── 读取和写入行 --> ( 难度等级: [0.1393, 0.1395) || 挂载数据: 无 ) 
│   │   │       ├── 关闭文件 --> ( 难度等级: [0.1395, 0.1398) || 挂载数据: qa: 10 ) 
│   │   │       └── 使用文件的基本方法 --> ( 难度等级: [0.1398, 0.14) || 挂载数据: qa: 1 ) 
│   │   ├── 常用标准库 --> ( 难度等级: [0.14, 0.145) || 挂载数据: 无 ) 
│   │   │   ├── datetime --> ( 难度等级: [0.14, 0.1405) || 挂载数据: qa: 1 ) 
│   │   │   ├── json --> ( 难度等级: [0.1405, 0.1409) || 挂载数据: 无 ) 
│   │   │   ├── math --> ( 难度等级: [0.1409, 0.1414) || 挂载数据: 无 ) 
│   │   │   ├── os --> ( 难度等级: [0.1414, 0.1418) || 挂载数据: qa: 5 ) 
│   │   │   ├── random --> ( 难度等级: [0.1418, 0.1423) || 挂载数据: qa: 7 ) 
│   │   │   ├── re --> ( 难度等级: [0.1423, 0.1427) || 挂载数据: qa: 9 ) 
│   │   │   ├── sys --> ( 难度等级: [0.1427, 0.1432) || 挂载数据: qa: 5 ) 
│   │   │   ├── time --> ( 难度等级: [0.1432, 0.1436) || 挂载数据: 无 ) 
│   │   │   ├── urllib --> ( 难度等级: [0.1436, 0.1441) || 挂载数据: qa: 3 ) 
│   │   │   ├── fileinput --> ( 难度等级: [0.1441, 0.1445) || 挂载数据: 无 ) 
│   │   │   └── 其他有趣的标准模块 --> ( 难度等级: [0.1445, 0.145) || 挂载数据: 无 ) 
│   │   └── 字符编码与解码 --> ( 难度等级: [0.145, 0.15) || 挂载数据: 无 ) 
│   │       └── 理解内码和字节码的概念 --> ( 难度等级: [0.145, 0.15) || 挂载数据: 无 ) 
│   ├── 面向对象编程 --> ( 难度等级: [0.15, 0.2) || 挂载数据: 无 ) 
│   │   ├── 类和对象的概念 --> ( 难度等级: [0.15, 0.1571) || 挂载数据: 无 ) 
│   │   ├── 类成员 --> ( 难度等级: [0.1571, 0.1643) || 挂载数据: 无 ) 
│   │   ├── 面向对象三要素 --> ( 难度等级: [0.1643, 0.1714) || 挂载数据: 无 ) 
│   │   │   ├── 封装 --> ( 难度等级: [0.1643, 0.1667) || 挂载数据: 无 ) 
│   │   │   ├── 继承 --> ( 难度等级: [0.1667, 0.169) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 子类的方法__init__ --> ( 难度等级: [0.1667, 0.1675) || 挂载数据: qa: 2 ) 
│   │   │   │   ├── 重写父类的方法 --> ( 难度等级: [0.1675, 0.1683) || 挂载数据: 无 ) 
│   │   │   │   └── 模拟实物 --> ( 难度等级: [0.1683, 0.169) || 挂载数据: 无 ) 
│   │   │   └── 多态 --> ( 难度等级: [0.169, 0.1714) || 挂载数据: 无 ) 
│   │   ├── 创建类 --> ( 难度等级: [0.1714, 0.1786) || 挂载数据: 无 ) 
│   │   ├── 抽象类 --> ( 难度等级: [0.1786, 0.1857) || 挂载数据: 无 ) 
│   │   ├── 访问限制 --> ( 难度等级: [0.1857, 0.1929) || 挂载数据: 无 ) 
│   │   └── 获取对象信息 --> ( 难度等级: [0.1929, 0.2) || 挂载数据: 无 ) 
│   └── 其他 --> ( 难度等级: [0.2, 0.25) || 挂载数据: 无 ) 
│       ├── 命令行与环境 --> ( 难度等级: [0.2, 0.2005) || 挂载数据: 无 ) 
│       │   ├── 命令行 --> ( 难度等级: [0.2, 0.2003) || 挂载数据: 无 ) 
│       │   │   ├── 接口选项 --> ( 难度等级: [0.2, 0.2001) || 挂载数据: 无 ) 
│       │   │   ├── 通用选项 --> ( 难度等级: [0.2001, 0.2001) || 挂载数据: qa: 1 ) 
│       │   │   ├── 其他选项 --> ( 难度等级: [0.2001, 0.2002) || 挂载数据: qa: 2 ) 
│       │   │   └── 不应当使用的选项 --> ( 难度等级: [0.2002, 0.2003) || 挂载数据: 无 ) 
│       │   └── 环境变量 --> ( 难度等级: [0.2003, 0.2005) || 挂载数据: 无 ) 
│       │       └── 调试模式变量 --> ( 难度等级: [0.2003, 0.2005) || 挂载数据: 无 ) 
│       ├── 在Unix平台中使用Python --> ( 难度等级: [0.2005, 0.2011) || 挂载数据: 无 ) 
│       │   ├── 获取最新版本的Python --> ( 难度等级: [0.2005, 0.2007) || 挂载数据: 无 ) 
│       │   │   ├── 在Linux中 --> ( 难度等级: [0.2005, 0.2006) || 挂载数据: qa: 10 ) 
│       │   │   ├── 在FreeBSD和OpenBSD上 --> ( 难度等级: [0.2006, 0.2007) || 挂载数据: 无 ) 
│       │   │   └── 在OpenSolaris系统上 --> ( 难度等级: [0.2007, 0.2007) || 挂载数据: 无 ) 
│       │   ├── 构建Python --> ( 难度等级: [0.2007, 0.2009) || 挂载数据: 无 ) 
│       │   └── 杂项 --> ( 难度等级: [0.2009, 0.2011) || 挂载数据: 无 ) 
│       ├── 在Windows上使用Python --> ( 难度等级: [0.2011, 0.2016) || 挂载数据: 无 ) 
│       │   ├── 完整安装程序 --> ( 难度等级: [0.2011, 0.2011) || 挂载数据: 无 ) 
│       │   │   ├── 安装步骤 --> ( 难度等级: [0.2011, 0.2011) || 挂载数据: qa: 2 ) 
│       │   │   ├── 删除MAX_PATH限制 --> ( 难度等级: [0.2011, 0.2011) || 挂载数据: qa: 1 ) 
│       │   │   ├── 无UI安装 --> ( 难度等级: [0.2011, 0.2011) || 挂载数据: qa: 1 ) 
│       │   │   ├── 免下载安装 --> ( 难度等级: [0.2011, 0.2011) || 挂载数据: 无 ) 
│       │   │   └── 修改安装 --> ( 难度等级: [0.2011, 0.2011) || 挂载数据: 无 ) 
│       │   ├── Microsoft Store包 --> ( 难度等级: [0.2011, 0.2012) || 挂载数据: qa: 1 ) 
│       │   ├── nuget.org安装包 --> ( 难度等级: [0.2012, 0.2012) || 挂载数据: 无 ) 
│       │   ├── 可嵌入的包 --> ( 难度等级: [0.2012, 0.2012) || 挂载数据: 无 ) 
│       │   │   ├── Python应用程序 --> ( 难度等级: [0.2012, 0.2012) || 挂载数据: qa: 1 ) 
│       │   │   └── 嵌入Python --> ( 难度等级: [0.2012, 0.2012) || 挂载数据: qa: 2 ) 
│       │   ├── 替代捆绑包 --> ( 难度等级: [0.2012, 0.2013) || 挂载数据: 无 ) 
│       │   ├── 配置Python --> ( 难度等级: [0.2013, 0.2013) || 挂载数据: 无 ) 
│       │   │   └── 查找Python可执行文件 --> ( 难度等级: [0.2013, 0.2013) || 挂载数据: 无 ) 
│       │   ├── UTF-8 模式 --> ( 难度等级: [0.2013, 0.2014) || 挂载数据: qa: 4 ) 
│       │   ├── 适用于Windows的Python启动器 --> ( 难度等级: [0.2014, 0.2014) || 挂载数据: 无 ) 
│       │   │   ├── 入门 --> ( 难度等级: [0.2014, 0.2014) || 挂载数据: 无 ) 
│       │   │   │   ├── 从虚拟环境 --> ( 难度等级: [0.2014, 0.2014) || 挂载数据: 无 ) 
│       │   │   │   ├── 从脚本 --> ( 难度等级: [0.2014, 0.2014) || 挂载数据: qa: 1 ) 
│       │   │   │   └── 从文件关联 --> ( 难度等级: [0.2014, 0.2014) || 挂载数据: 无 ) 
│       │   │   ├── Shebang Lines --> ( 难度等级: [0.2014, 0.2014) || 挂载数据: 无 ) 
│       │   │   ├── shebang lines的参数 --> ( 难度等级: [0.2014, 0.2014) || 挂载数据: 无 ) 
│       │   │   ├── 自定义 --> ( 难度等级: [0.2014, 0.2014) || 挂载数据: 无 ) 
│       │   │   │   ├── 通过INI文件自定义 --> ( 难度等级: [0.2014, 0.2014) || 挂载数据: 无 ) 
│       │   │   │   └── 自定义默认的Python版本 --> ( 难度等级: [0.2014, 0.2014) || 挂载数据: qa: 1 ) 
│       │   │   └── 诊断 --> ( 难度等级: [0.2014, 0.2014) || 挂载数据: 无 ) 
│       │   ├── 查找模块 --> ( 难度等级: [0.2014, 0.2015) || 挂载数据: 无 ) 
│       │   ├── 附加模块 --> ( 难度等级: [0.2015, 0.2015) || 挂载数据: 无 ) 
│       │   │   ├── PyWin32 --> ( 难度等级: [0.2015, 0.2015) || 挂载数据: 无 ) 
│       │   │   ├── cx_Freeze --> ( 难度等级: [0.2015, 0.2015) || 挂载数据: 无 ) 
│       │   │   └── WConio --> ( 难度等级: [0.2015, 0.2015) || 挂载数据: 无 ) 
│       │   ├── 在Windows上编译Python --> ( 难度等级: [0.2015, 0.2016) || 挂载数据: qa: 7 ) 
│       │   └── 其他平台 --> ( 难度等级: [0.2016, 0.2016) || 挂载数据: qa: 1 ) 
│       ├── 在苹果系统上使用Python --> ( 难度等级: [0.2016, 0.2021) || 挂载数据: 无 ) 
│       │   ├── 获取和安装MacPython --> ( 难度等级: [0.2016, 0.2017) || 挂载数据: 无 ) 
│       │   │   ├── 如何运行Python脚本 --> ( 难度等级: [0.2016, 0.2016) || 挂载数据: 无 ) 
│       │   │   ├── 运行有图形界面的脚本 --> ( 难度等级: [0.2016, 0.2017) || 挂载数据: 无 ) 
│       │   │   └── 配置 --> ( 难度等级: [0.2017, 0.2017) || 挂载数据: qa: 1 ) 
│       │   │       ├── 提取常量 --> ( 难度等级: [0.2017, 0.2017) || 挂载数据: qa: 7 ) 
│       │   │       └── 配置文件 --> ( 难度等级: [0.2017, 0.2017) || 挂载数据: 无 ) 
│       │   ├── IDE --> ( 难度等级: [0.2017, 0.2018) || 挂载数据: qa: 3 ) 
│       │   ├── 安装额外的Python包 --> ( 难度等级: [0.2018, 0.2019) || 挂载数据: 无 ) 
│       │   ├── Mac上的图形界面编程 --> ( 难度等级: [0.2019, 0.202) || 挂载数据: 无 ) 
│       │   ├── 在Mac上分发Python应用程序 --> ( 难度等级: [0.202, 0.202) || 挂载数据: 无 ) 
│       │   └── 其他资源 --> ( 难度等级: [0.202, 0.2021) || 挂载数据: 无 ) 
│       ├── 编辑器和集成开发环境 --> ( 难度等级: [0.2021, 0.2027) || 挂载数据: qa: 1 ) 
│       ├── Python解释器 --> ( 难度等级: [0.2027, 0.2032) || 挂载数据: 无 ) 
│       │   ├── 调用解释器 --> ( 难度等级: [0.2027, 0.2029) || 挂载数据: qa: 1 ) 
│       │   │   ├── 传入参数 --> ( 难度等级: [0.2027, 0.2028) || 挂载数据: 无 ) 
│       │   │   └── 交互模式 --> ( 难度等级: [0.2028, 0.2029) || 挂载数据: qa: 2 ) 
│       │   └── 解释器的运行环境 --> ( 难度等级: [0.2029, 0.2032) || 挂载数据: qa: 1 ) 
│       │       └── 源文件的字符编码 --> ( 难度等级: [0.2029, 0.2032) || 挂载数据: 无 ) 
│       ├── Python速览 --> ( 难度等级: [0.2032, 0.2037) || 挂载数据: 无 ) 
│       │   ├── Python用作计算器 --> ( 难度等级: [0.2032, 0.2035) || 挂载数据: qa: 1 ) 
│       │   │   └── 数字 --> ( 难度等级: [0.2032, 0.2035) || 挂载数据: qa: 1 ) 
│       │   └── 走向编程的第一步 --> ( 难度等级: [0.2035, 0.2037) || 挂载数据: 无 ) 
│       ├── 其他流程控制工具 --> ( 难度等级: [0.2037, 0.2043) || 挂载数据: 无 ) 
│       │   ├── range 函数 --> ( 难度等级: [0.2037, 0.2038) || 挂载数据: qa: 1 ) 
│       │   ├── pass语句 --> ( 难度等级: [0.2038, 0.2039) || 挂载数据: qa: 1 ) 
│       │   ├── 定义函数 --> ( 难度等级: [0.2039, 0.204) || 挂载数据: qa: 3 ) 
│       │   │   ├── 向函数传递信息 --> ( 难度等级: [0.2039, 0.204) || 挂载数据: 无 ) 
│       │   │   └── 实参和形参 --> ( 难度等级: [0.204, 0.204) || 挂载数据: 无 ) 
│       │   ├── 函数定义详解 --> ( 难度等级: [0.204, 0.2041) || 挂载数据: 无 ) 
│       │   │   ├── 默认值参数 --> ( 难度等级: [0.204, 0.2041) || 挂载数据: 无 ) 
│       │   │   ├── 关键字参数 --> ( 难度等级: [0.2041, 0.2041) || 挂载数据: 无 ) 
│       │   │   ├── 特殊参数 --> ( 难度等级: [0.2041, 0.2041) || 挂载数据: 无 ) 
│       │   │   │   ├── 位置或关键字参数 --> ( 难度等级: [0.2041, 0.2041) || 挂载数据: 无 ) 
│       │   │   │   ├── 仅位置参数 --> ( 难度等级: [0.2041, 0.2041) || 挂载数据: 无 ) 
│       │   │   │   ├── 仅限关键字参数 --> ( 难度等级: [0.2041, 0.2041) || 挂载数据: 无 ) 
│       │   │   │   └── 函数示例 --> ( 难度等级: [0.2041, 0.2041) || 挂载数据: 无 ) 
│       │   │   ├── 任意实参列表 --> ( 难度等级: [0.2041, 0.2041) || 挂载数据: 无 ) 
│       │   │   ├── 解包实参列表 --> ( 难度等级: [0.2041, 0.2041) || 挂载数据: 无 ) 
│       │   │   ├── Lambda表达式 --> ( 难度等级: [0.2041, 0.2041) || 挂载数据: qa: 2 ) 
│       │   │   ├── 文档字符串 --> ( 难度等级: [0.2041, 0.2041) || 挂载数据: 无 ) 
│       │   │   └── 函数注解 --> ( 难度等级: [0.2041, 0.2041) || 挂载数据: 无 ) 
│       │   └── 小插曲：编码风格 --> ( 难度等级: [0.2041, 0.2043) || 挂载数据: 无 ) 
│       ├── 数据结构 --> ( 难度等级: [0.2043, 0.2048) || 挂载数据: 无 ) 
│       │   ├── 列表详解 --> ( 难度等级: [0.2043, 0.2043) || 挂载数据: qa: 2 ) 
│       │   │   ├── 用列表实现堆栈 --> ( 难度等级: [0.2043, 0.2043) || 挂载数据: 无 ) 
│       │   │   ├── 用列表实现队列 --> ( 难度等级: [0.2043, 0.2043) || 挂载数据: 无 ) 
│       │   │   └── 嵌套的列表推导式 --> ( 难度等级: [0.2043, 0.2043) || 挂载数据: 无 ) 
│       │   ├── del语句 --> ( 难度等级: [0.2043, 0.2044) || 挂载数据: 无 ) 
│       │   ├── 循环的技巧 --> ( 难度等级: [0.2044, 0.2045) || 挂载数据: 无 ) 
│       │   ├── 深入条件控制 --> ( 难度等级: [0.2045, 0.2046) || 挂载数据: 无 ) 
│       │   ├── 序列和其他类型的比较 --> ( 难度等级: [0.2046, 0.2046) || 挂载数据: 无 ) 
│       │   ├── 序列构成的数组 --> ( 难度等级: [0.2046, 0.2047) || 挂载数据: 无 ) 
│       │   │   ├── 内置序列类型概览 --> ( 难度等级: [0.2046, 0.2046) || 挂载数据: 无 ) 
│       │   │   ├── 元组不仅仅是不可变的列表 --> ( 难度等级: [0.2046, 0.2047) || 挂载数据: 无 ) 
│       │   │   ├── 序列的增量赋值 --> ( 难度等级: [0.2047, 0.2047) || 挂载数据: 无 ) 
│       │   │   ├── list.sort方法和内置函数sorted --> ( 难度等级: [0.2047, 0.2047) || 挂载数据: 无 ) 
│       │   │   ├── 用bisect来管理已排序的序列 --> ( 难度等级: [0.2047, 0.2047) || 挂载数据: qa: 1 ) 
│       │   │   └── 当列表不是首选时 --> ( 难度等级: [0.2047, 0.2047) || 挂载数据: 无 ) 
│       │   └── 文本和字节序列 --> ( 难度等级: [0.2047, 0.2048) || 挂载数据: 无 ) 
│       │       ├── 字节概要 --> ( 难度等级: [0.2047, 0.2047) || 挂载数据: 无 ) 
│       │       ├── 基本的编解码器 --> ( 难度等级: [0.2047, 0.2047) || 挂载数据: 无 ) 
│       │       ├── 处理文本文件 --> ( 难度等级: [0.2047, 0.2047) || 挂载数据: 无 ) 
│       │       ├── 为了正确比较而规范化Unicode字符串 --> ( 难度等级: [0.2047, 0.2048) || 挂载数据: 无 ) 
│       │       ├── Unicode文本排序 --> ( 难度等级: [0.2048, 0.2048) || 挂载数据: 无 ) 
│       │       ├── Unicode数据库 --> ( 难度等级: [0.2048, 0.2048) || 挂载数据: 无 ) 
│       │       └── 支持字符串和字节序列的双模式API --> ( 难度等级: [0.2048, 0.2048) || 挂载数据: qa: 1 ) 
│       ├── 模块 --> ( 难度等级: [0.2048, 0.2053) || 挂载数据: 无 ) 
│       │   ├── 模块详解 --> ( 难度等级: [0.2048, 0.2048) || 挂载数据: 无 ) 
│       │   │   ├── 以脚本方式执行模块 --> ( 难度等级: [0.2048, 0.2048) || 挂载数据: 无 ) 
│       │   │   ├── 模块搜索路径 --> ( 难度等级: [0.2048, 0.2048) || 挂载数据: qa: 1 ) 
│       │   │   └── “已编译的” Python文件 --> ( 难度等级: [0.2048, 0.2048) || 挂载数据: 无 ) 
│       │   ├── 标准模块 --> ( 难度等级: [0.2048, 0.2049) || 挂载数据: 无 ) 
│       │   ├── dir 函数 --> ( 难度等级: [0.2049, 0.2049) || 挂载数据: 无 ) 
│       │   ├── 包 --> ( 难度等级: [0.2049, 0.2049) || 挂载数据: 无 ) 
│       │   │   ├── 从包中导入 * --> ( 难度等级: [0.2049, 0.2049) || 挂载数据: qa: 1 ) 
│       │   │   ├── 子包参考 --> ( 难度等级: [0.2049, 0.2049) || 挂载数据: 无 ) 
│       │   │   └── 多目录中的包 --> ( 难度等级: [0.2049, 0.2049) || 挂载数据: qa: 4 ) 
│       │   ├── 安装第三方模块 --> ( 难度等级: [0.2049, 0.205) || 挂载数据: qa: 4 ) 
│       │   ├── Pillow --> ( 难度等级: [0.205, 0.205) || 挂载数据: 无 ) 
│       │   ├── requests --> ( 难度等级: [0.205, 0.2051) || 挂载数据: qa: 10 ) 
│       │   ├── chardet --> ( 难度等级: [0.2051, 0.2051) || 挂载数据: 无 ) 
│       │   ├── psutil --> ( 难度等级: [0.2051, 0.2051) || 挂载数据: 无 ) 
│       │   ├── cmath和复数 --> ( 难度等级: [0.2051, 0.2052) || 挂载数据: 无 ) 
│       │   ├── 回到未来 --> ( 难度等级: [0.2052, 0.2052) || 挂载数据: 无 ) 
│       │   ├── 模块就是程序 --> ( 难度等级: [0.2052, 0.2052) || 挂载数据: 无 ) 
│       │   ├── 模块是用来下定义的 --> ( 难度等级: [0.2052, 0.2053) || 挂载数据: 无 ) 
│       │   └── 让模块可用 --> ( 难度等级: [0.2053, 0.2053) || 挂载数据: 无 ) 
│       ├── 输入与输出 --> ( 难度等级: [0.2053, 0.2059) || 挂载数据: 无 ) 
│       │   ├── 更复杂的输出格式 --> ( 难度等级: [0.2053, 0.2055) || 挂载数据: qa: 10 ) 
│       │   │   ├── 格式化字符串字面值 --> ( 难度等级: [0.2053, 0.2054) || 挂载数据: 无 ) 
│       │   │   ├── 字符串format 方法 --> ( 难度等级: [0.2054, 0.2054) || 挂载数据: qa: 3 ) 
│       │   │   ├── 手动格式化字符串 --> ( 难度等级: [0.2054, 0.2054) || 挂载数据: 无 ) 
│       │   │   └── 旧式字符串格式化方法 --> ( 难度等级: [0.2054, 0.2055) || 挂载数据: 无 ) 
│       │   ├── 读写文件 --> ( 难度等级: [0.2055, 0.2056) || 挂载数据: qa: 3 ) 
│       │   │   ├── 文件对象的方法 --> ( 难度等级: [0.2055, 0.2055) || 挂载数据: 无 ) 
│       │   │   ├── 使用json保存结构化数据 --> ( 难度等级: [0.2055, 0.2055) || 挂载数据: 无 ) 
│       │   │   ├── 文件读写过程 --> ( 难度等级: [0.2055, 0.2055) || 挂载数据: qa: 5 ) 
│       │   │   ├── 用shelve模块保存变量 --> ( 难度等级: [0.2055, 0.2056) || 挂载数据: 无 ) 
│       │   │   └── 用pprint.pformat函数保存变量 --> ( 难度等级: [0.2056, 0.2056) || 挂载数据: 无 ) 
│       │   ├── 使用input函数输入 --> ( 难度等级: [0.2056, 0.2057) || 挂载数据: qa: 4 ) 
│       │   └── 使用print函数输出 --> ( 难度等级: [0.2057, 0.2059) || 挂载数据: qa: 8 ) 
│       ├── 错误和异常 --> ( 难度等级: [0.2059, 0.2064) || 挂载数据: 无 ) 
│       │   ├── 句法错误 --> ( 难度等级: [0.2059, 0.2059) || 挂载数据: 无 ) 
│       │   ├── 异常 --> ( 难度等级: [0.2059, 0.2059) || 挂载数据: 无 ) 
│       │   ├── 处理异常 --> ( 难度等级: [0.2059, 0.206) || 挂载数据: qa: 1 ) 
│       │   ├── 触发异常 --> ( 难度等级: [0.206, 0.206) || 挂载数据: 无 ) 
│       │   ├── 异常链 --> ( 难度等级: [0.206, 0.2061) || 挂载数据: 无 ) 
│       │   ├── 用户自定义异常 --> ( 难度等级: [0.2061, 0.2061) || 挂载数据: qa: 1 ) 
│       │   ├── 定义清理操作 --> ( 难度等级: [0.2061, 0.2061) || 挂载数据: 无 ) 
│       │   ├── 预定义的清理操作 --> ( 难度等级: [0.2061, 0.2062) || 挂载数据: 无 ) 
│       │   ├── 异常是什么 --> ( 难度等级: [0.2062, 0.2062) || 挂载数据: 无 ) 
│       │   ├── 让事情沿你指定的轨道出错 --> ( 难度等级: [0.2062, 0.2063) || 挂载数据: qa: 8 ) 
│       │   │   └── 自定义的异常类 --> ( 难度等级: [0.2062, 0.2063) || 挂载数据: 无 ) 
│       │   ├── 捕获异常 --> ( 难度等级: [0.2063, 0.2063) || 挂载数据: 无 ) 
│       │   │   ├── 不用提供参数 --> ( 难度等级: [0.2063, 0.2063) || 挂载数据: 无 ) 
│       │   │   ├── 多个except子句 --> ( 难度等级: [0.2063, 0.2063) || 挂载数据: qa: 1 ) 
│       │   │   ├── 一箭双雕 --> ( 难度等级: [0.2063, 0.2063) || 挂载数据: 无 ) 
│       │   │   ├── 捕获对象 --> ( 难度等级: [0.2063, 0.2063) || 挂载数据: 无 ) 
│       │   │   ├── 一网打尽 --> ( 难度等级: [0.2063, 0.2063) || 挂载数据: 无 ) 
│       │   │   ├── 万事大吉时 --> ( 难度等级: [0.2063, 0.2063) || 挂载数据: 无 ) 
│       │   │   └── 最后 --> ( 难度等级: [0.2063, 0.2063) || 挂载数据: 无 ) 
│       │   ├── 异常之禅 --> ( 难度等级: [0.2063, 0.2063) || 挂载数据: 无 ) 
│       │   └── 不那么异常的情况 --> ( 难度等级: [0.2063, 0.2064) || 挂载数据: qa: 5 ) 
│       ├── 标准库简介 --> ( 难度等级: [0.2064, 0.2069) || 挂载数据: 无 ) 
│       │   ├── 操作系统接口 --> ( 难度等级: [0.2064, 0.2064) || 挂载数据: 无 ) 
│       │   ├── 文件通配符 --> ( 难度等级: [0.2064, 0.2064) || 挂载数据: 无 ) 
│       │   ├── 命令行参数 --> ( 难度等级: [0.2064, 0.2065) || 挂载数据: 无 ) 
│       │   ├── 错误输出重定向和程序终止 --> ( 难度等级: [0.2065, 0.2065) || 挂载数据: 无 ) 
│       │   ├── 字符串模式匹配 --> ( 难度等级: [0.2065, 0.2065) || 挂载数据: 无 ) 
│       │   ├── 数学 --> ( 难度等级: [0.2065, 0.2065) || 挂载数据: 无 ) 
│       │   ├── 互联网访问 --> ( 难度等级: [0.2065, 0.2066) || 挂载数据: 无 ) 
│       │   ├── 日期和时间 --> ( 难度等级: [0.2066, 0.2066) || 挂载数据: qa: 1 ) 
│       │   ├── 数据压缩 --> ( 难度等级: [0.2066, 0.2066) || 挂载数据: 无 ) 
│       │   ├── 性能测量 --> ( 难度等级: [0.2066, 0.2066) || 挂载数据: 无 ) 
│       │   ├── 质量控制 --> ( 难度等级: [0.2066, 0.2067) || 挂载数据: 无 ) 
│       │   ├── 自带电池 --> ( 难度等级: [0.2067, 0.2067) || 挂载数据: 无 ) 
│       │   ├── 格式化输出 --> ( 难度等级: [0.2067, 0.2067) || 挂载数据: qa: 1 ) 
│       │   ├── 模板 --> ( 难度等级: [0.2067, 0.2068) || 挂载数据: 无 ) 
│       │   ├── 使用二进制数据记录格式 --> ( 难度等级: [0.2068, 0.2068) || 挂载数据: 无 ) 
│       │   ├── 多线程 --> ( 难度等级: [0.2068, 0.2068) || 挂载数据: 无 ) 
│       │   ├── 日志 --> ( 难度等级: [0.2068, 0.2068) || 挂载数据: 无 ) 
│       │   ├── 弱引用 --> ( 难度等级: [0.2068, 0.2069) || 挂载数据: 无 ) 
│       │   ├── 用于操作列表的工具 --> ( 难度等级: [0.2069, 0.2069) || 挂载数据: 无 ) 
│       │   └── 十进制浮点运算 --> ( 难度等级: [0.2069, 0.2069) || 挂载数据: 无 ) 
│       ├── 交互式编辑和编辑历史 --> ( 难度等级: [0.2069, 0.2074) || 挂载数据: 无 ) 
│       │   ├── Tab补全和编辑历史 --> ( 难度等级: [0.2069, 0.2072) || 挂载数据: 无 ) 
│       │   └── 默认交互式解释器的替代品 --> ( 难度等级: [0.2072, 0.2074) || 挂载数据: 无 ) 
│       ├── 浮点算术：争议和限制 --> ( 难度等级: [0.2074, 0.208) || 挂载数据: 无 ) 
│       │   └── 表示性错误 --> ( 难度等级: [0.2074, 0.208) || 挂载数据: 无 ) 
│       ├── 概述 --> ( 难度等级: [0.208, 0.2085) || 挂载数据: 无 ) 
│       │   ├── 其他实现 --> ( 难度等级: [0.208, 0.2082) || 挂载数据: 无 ) 
│       │   ├── 标注 --> ( 难度等级: [0.2082, 0.2083) || 挂载数据: 无 ) 
│       │   └── 可用性注释 --> ( 难度等级: [0.2083, 0.2085) || 挂载数据: 无 ) 
│       ├── 词法分析 --> ( 难度等级: [0.2085, 0.209) || 挂载数据: 无 ) 
│       │   ├── 行结构 --> ( 难度等级: [0.2085, 0.2086) || 挂载数据: qa: 1 ) 
│       │   ├── 其他形符 --> ( 难度等级: [0.2086, 0.2087) || 挂载数据: 无 ) 
│       │   ├── 字面值 --> ( 难度等级: [0.2087, 0.2088) || 挂载数据: 无 ) 
│       │   ├── 运算符 --> ( 难度等级: [0.2088, 0.2089) || 挂载数据: 无 ) 
│       │   │   ├── 赋值运算符 --> ( 难度等级: [0.2088, 0.2089) || 挂载数据: qa: 2 ) 
│       │   │   ├── 比较（关系）运算符 --> ( 难度等级: [0.2089, 0.2089) || 挂载数据: 无 ) 
│       │   │   ├── 逻辑运算符 --> ( 难度等级: [0.2089, 0.2089) || 挂载数据: 无 ) 
│       │   │   └── 位运算符 --> ( 难度等级: [0.2089, 0.2089) || 挂载数据: qa: 2 ) 
│       │   └── 分隔符 --> ( 难度等级: [0.2089, 0.209) || 挂载数据: 无 ) 
│       ├── 数据模型 --> ( 难度等级: [0.209, 0.2096) || 挂载数据: 无 ) 
│       │   ├── 标准类型层级结构 --> ( 难度等级: [0.209, 0.2092) || 挂载数据: 无 ) 
│       │   ├── 特殊方法名称 --> ( 难度等级: [0.2092, 0.2094) || 挂载数据: 无 ) 
│       │   └── 协程 --> ( 难度等级: [0.2094, 0.2096) || 挂载数据: 无 ) 
│       │       ├── 生成器如何进化成协程 --> ( 难度等级: [0.2094, 0.2094) || 挂载数据: 无 ) 
│       │       ├── 用作协程的生成器的基本行为 --> ( 难度等级: [0.2094, 0.2094) || 挂载数据: 无 ) 
│       │       ├── 预激协程的装饰器 --> ( 难度等级: [0.2094, 0.2095) || 挂载数据: 无 ) 
│       │       ├── 让协程返回值 --> ( 难度等级: [0.2095, 0.2095) || 挂载数据: qa: 1 ) 
│       │       ├── 使用yield from --> ( 难度等级: [0.2095, 0.2095) || 挂载数据: 无 ) 
│       │       ├── yield from的意义 --> ( 难度等级: [0.2095, 0.2095) || 挂载数据: qa: 1 ) 
│       │       └── 使用案例：使用协程做离散事件仿真 --> ( 难度等级: [0.2095, 0.2096) || 挂载数据: 无 ) 
│       ├── 执行模型 --> ( 难度等级: [0.2096, 0.2101) || 挂载数据: 无 ) 
│       │   ├── 程序的结构 --> ( 难度等级: [0.2096, 0.2098) || 挂载数据: qa: 4 ) 
│       │   └── 命名与绑定 --> ( 难度等级: [0.2098, 0.2101) || 挂载数据: 无 ) 
│       ├── 导入系统 --> ( 难度等级: [0.2101, 0.2106) || 挂载数据: 无 ) 
│       │   ├── importlib --> ( 难度等级: [0.2101, 0.2102) || 挂载数据: 无 ) 
│       │   ├── 搜索 --> ( 难度等级: [0.2102, 0.2102) || 挂载数据: 无 ) 
│       │   ├── 加载 --> ( 难度等级: [0.2102, 0.2103) || 挂载数据: qa: 1 ) 
│       │   ├── 基于路径的查找器 --> ( 难度等级: [0.2103, 0.2104) || 挂载数据: 无 ) 
│       │   ├── 替换标准导入系统 --> ( 难度等级: [0.2104, 0.2104) || 挂载数据: qa: 5 ) 
│       │   ├── 包相对导入 --> ( 难度等级: [0.2104, 0.2105) || 挂载数据: 无 ) 
│       │   ├── 有关__main__的特殊事项 --> ( 难度等级: [0.2105, 0.2106) || 挂载数据: qa: 3 ) 
│       │   └── 参考文献 --> ( 难度等级: [0.2106, 0.2106) || 挂载数据: 无 ) 
│       ├── 复合语句 --> ( 难度等级: [0.2106, 0.2112) || 挂载数据: 无 ) 
│       │   ├── while语句 --> ( 难度等级: [0.2106, 0.2107) || 挂载数据: 无 ) 
│       │   ├── try语句 --> ( 难度等级: [0.2107, 0.2109) || 挂载数据: 无 ) 
│       │   ├── with语句 --> ( 难度等级: [0.2109, 0.211) || 挂载数据: qa: 1 ) 
│       │   ├── 函数定义 --> ( 难度等级: [0.211, 0.2111) || 挂载数据: qa: 2 ) 
│       │   └── 类定义 --> ( 难度等级: [0.2111, 0.2112) || 挂载数据: 无 ) 
│       ├── 顶级组件 --> ( 难度等级: [0.2112, 0.2117) || 挂载数据: 无 ) 
│       │   ├── 完整的Python程序 --> ( 难度等级: [0.2112, 0.2113) || 挂载数据: 无 ) 
│       │   │   ├── 使用文本编辑器 --> ( 难度等级: [0.2112, 0.2112) || 挂载数据: 无 ) 
│       │   │   └── Python代码运行助手 --> ( 难度等级: [0.2112, 0.2113) || 挂载数据: 无 ) 
│       │   ├── 文件输入 --> ( 难度等级: [0.2113, 0.2114) || 挂载数据: qa: 1 ) 
│       │   ├── 交互式输入 --> ( 难度等级: [0.2114, 0.2116) || 挂载数据: 无 ) 
│       │   └── 表达式输入 --> ( 难度等级: [0.2116, 0.2117) || 挂载数据: 无 ) 
│       ├── 完整的语法规范 --> ( 难度等级: [0.2117, 0.2122) || 挂载数据: 无 ) 
│       ├── 内置常量 --> ( 难度等级: [0.2122, 0.2128) || 挂载数据: 无 ) 
│       │   └── 由site模块添加的常量 --> ( 难度等级: [0.2122, 0.2128) || 挂载数据: 无 ) 
│       ├── 内置类型 --> ( 难度等级: [0.2128, 0.2133) || 挂载数据: 无 ) 
│       │   ├── 逻辑值检测 --> ( 难度等级: [0.2128, 0.2128) || 挂载数据: 无 ) 
│       │   ├── 布尔运算 --- and, or, not --> ( 难度等级: [0.2128, 0.2128) || 挂载数据: qa: 6 ) 
│       │   ├── 比较 --> ( 难度等级: [0.2128, 0.2129) || 挂载数据: 无 ) 
│       │   ├── 数字类型 --- int, float, complex --> ( 难度等级: [0.2129, 0.2129) || 挂载数据: qa: 4 ) 
│       │   ├── 迭代器类型 --> ( 难度等级: [0.2129, 0.213) || 挂载数据: 无 ) 
│       │   ├── 序列类型 --- list, tuple, range --> ( 难度等级: [0.213, 0.213) || 挂载数据: qa: 2 ) 
│       │   ├── 文本序列类型 --- str --> ( 难度等级: [0.213, 0.2131) || 挂载数据: qa: 1 ) 
│       │   ├── 二进制序列类型 --- bytes, bytearray, memoryview --> ( 难度等级: [0.2131, 0.2131) || 挂载数据: 无 ) 
│       │   ├── 集合类型 --- set, frozenset --> ( 难度等级: [0.2131, 0.2131) || 挂载数据: 无 ) 
│       │   ├── 映射类型 --- dict --> ( 难度等级: [0.2131, 0.2132) || 挂载数据: 无 ) 
│       │   ├── 上下文管理器类型 --> ( 难度等级: [0.2132, 0.2132) || 挂载数据: 无 ) 
│       │   ├── Generic Alias Type --> ( 难度等级: [0.2132, 0.2133) || 挂载数据: 无 ) 
│       │   └── 其他内置类型 --> ( 难度等级: [0.2133, 0.2133) || 挂载数据: qa: 2 ) 
│       ├── 内置异常 --> ( 难度等级: [0.2133, 0.2138) || 挂载数据: 无 ) 
│       │   ├── 基类 --> ( 难度等级: [0.2133, 0.2135) || 挂载数据: 无 ) 
│       │   ├── 警告 --> ( 难度等级: [0.2135, 0.2137) || 挂载数据: qa: 1 ) 
│       │   └── 异常层次结构 --> ( 难度等级: [0.2137, 0.2138) || 挂载数据: 无 ) 
│       ├── 文本处理服务 --> ( 难度等级: [0.2138, 0.2144) || 挂载数据: 无 ) 
│       │   ├── string --- 常见的字符串操作 --> ( 难度等级: [0.2138, 0.2139) || 挂载数据: qa: 5 ) 
│       │   ├── re --- 正则表达式操作 --> ( 难度等级: [0.2139, 0.214) || 挂载数据: 无 ) 
│       │   ├── difflib --- 计算差异的辅助工具 --> ( 难度等级: [0.214, 0.214) || 挂载数据: 无 ) 
│       │   ├── textwrap --- 文本自动换行与填充 --> ( 难度等级: [0.214, 0.2141) || 挂载数据: 无 ) 
│       │   ├── unicodedata --- Unicode数据库 --> ( 难度等级: [0.2141, 0.2142) || 挂载数据: 无 ) 
│       │   ├── stringprep --- 因特网字符串预备 --> ( 难度等级: [0.2142, 0.2142) || 挂载数据: 无 ) 
│       │   ├── readline --- GNU readline接口 --> ( 难度等级: [0.2142, 0.2143) || 挂载数据: qa: 3 ) 
│       │   └── rlcompleter --- GNU readline的补全函数 --> ( 难度等级: [0.2143, 0.2144) || 挂载数据: 无 ) 
│       ├── 二进制数据服务 --> ( 难度等级: [0.2144, 0.2149) || 挂载数据: 无 ) 
│       │   ├── struct --- 将字节串解读为打包的二进制数据 --> ( 难度等级: [0.2144, 0.2146) || 挂载数据: qa: 1 ) 
│       │   └── codecs --- 编解码器注册和相关基类 --> ( 难度等级: [0.2146, 0.2149) || 挂载数据: 无 ) 
│       ├── 函数式编程模块 --> ( 难度等级: [0.2149, 0.2154) || 挂载数据: 无 ) 
│       │   ├── itertools --- 为高效循环而创建迭代器的函数 --> ( 难度等级: [0.2149, 0.2151) || 挂载数据: 无 ) 
│       │   ├── functools --- 高阶函数和可调用对象上的操作 --> ( 难度等级: [0.2151, 0.2152) || 挂载数据: 无 ) 
│       │   └── operator --- 标准运算符替代函数 --> ( 难度等级: [0.2152, 0.2154) || 挂载数据: 无 ) 
│       ├── 数据持久化 --> ( 难度等级: [0.2154, 0.216) || 挂载数据: 无 ) 
│       │   ├── pickle --- Python对象序列化 --> ( 难度等级: [0.2154, 0.2155) || 挂载数据: 无 ) 
│       │   ├── copyreg --- 注册配合pickle模块使用的函数 --> ( 难度等级: [0.2155, 0.2156) || 挂载数据: qa: 1 ) 
│       │   ├── shelve --- Python对象持久化 --> ( 难度等级: [0.2156, 0.2157) || 挂载数据: 无 ) 
│       │   ├── marshal --- 内部Python对象序列化 --> ( 难度等级: [0.2157, 0.2158) || 挂载数据: 无 ) 
│       │   ├── dbm --- Unix "数据库" 接口 --> ( 难度等级: [0.2158, 0.2159) || 挂载数据: 无 ) 
│       │   └── sqlite3 --- SQLite数据库DB-API 2.0 接口模块 --> ( 难度等级: [0.2159, 0.216) || 挂载数据: 无 ) 
│       ├── 文件格式 --> ( 难度等级: [0.216, 0.2165) || 挂载数据: 无 ) 
│       │   ├── csv --- CSV文件读写 --> ( 难度等级: [0.216, 0.2161) || 挂载数据: qa: 1 ) 
│       │   ├── configparser --- 配置文件解析器 --> ( 难度等级: [0.2161, 0.2162) || 挂载数据: 无 ) 
│       │   ├── netrc --- netrc文件处理 --> ( 难度等级: [0.2162, 0.2163) || 挂载数据: 无 ) 
│       │   ├── xdrlib --- 编码与解码XDR数据 --> ( 难度等级: [0.2163, 0.2164) || 挂载数据: 无 ) 
│       │   └── plistlib --- 生成与解析Apple .plist文件 --> ( 难度等级: [0.2164, 0.2165) || 挂载数据: 无 ) 
│       ├── 加密服务 --> ( 难度等级: [0.2165, 0.217) || 挂载数据: 无 ) 
│       │   ├── hashlib --- 安全哈希与消息摘要 --> ( 难度等级: [0.2165, 0.2167) || 挂载数据: 无 ) 
│       │   ├── hmac --- 基于密钥的消息验证 --> ( 难度等级: [0.2167, 0.2168) || 挂载数据: 无 ) 
│       │   └── secrets --- 生成管理密码的安全随机数 --> ( 难度等级: [0.2168, 0.217) || 挂载数据: 无 ) 
│       ├── 通用操作系统服务 --> ( 难度等级: [0.217, 0.2176) || 挂载数据: 无 ) 
│       │   ├── os --- 多种操作系统接口 --> ( 难度等级: [0.217, 0.2171) || 挂载数据: 无 ) 
│       │   ├── io --- 处理流的核心工具 --> ( 难度等级: [0.2171, 0.2171) || 挂载数据: 无 ) 
│       │   ├── time --- 时间的访问和转换 --> ( 难度等级: [0.2171, 0.2171) || 挂载数据: 无 ) 
│       │   ├── argparse --- 命令行选项、参数和子命令解析器 --> ( 难度等级: [0.2171, 0.2172) || 挂载数据: 无 ) 
│       │   ├── getopt --- C风格的命令行选项解析器 --> ( 难度等级: [0.2172, 0.2172) || 挂载数据: 无 ) 
│       │   ├── logging --- Python的日志记录工具 --> ( 难度等级: [0.2172, 0.2172) || 挂载数据: 无 ) 
│       │   ├── logging.config --- 日志记录配置 --> ( 难度等级: [0.2172, 0.2173) || 挂载数据: 无 ) 
│       │   ├── logging.handlers --- 日志处理程序 --> ( 难度等级: [0.2173, 0.2173) || 挂载数据: 无 ) 
│       │   ├── getpass --- 便携式密码输入工具 --> ( 难度等级: [0.2173, 0.2173) || 挂载数据: 无 ) 
│       │   ├── curses --- 终端字符单元显示的处理 --> ( 难度等级: [0.2173, 0.2174) || 挂载数据: 无 ) 
│       │   ├── curses.textpad --- 用于curses程序的文本输入控件 --> ( 难度等级: [0.2174, 0.2174) || 挂载数据: 无 ) 
│       │   ├── curses.ascii --- 用于ASCII字符的工具 --> ( 难度等级: [0.2174, 0.2174) || 挂载数据: 无 ) 
│       │   ├── curses.panel --- curses的面板栈扩展 --> ( 难度等级: [0.2174, 0.2175) || 挂载数据: 无 ) 
│       │   ├── platform ---  获取底层平台的标识数据 --> ( 难度等级: [0.2175, 0.2175) || 挂载数据: 无 ) 
│       │   ├── errno --- 标准errno系统符号 --> ( 难度等级: [0.2175, 0.2175) || 挂载数据: qa: 2 ) 
│       │   └── ctypes --- Python的外部函数库 --> ( 难度等级: [0.2175, 0.2176) || 挂载数据: 无 ) 
│       ├── 并发执行 --> ( 难度等级: [0.2176, 0.2181) || 挂载数据: 无 ) 
│       │   ├── threading --- 基于线程的并行 --> ( 难度等级: [0.2176, 0.2176) || 挂载数据: 无 ) 
│       │   ├── multiprocessing --- 基于进程的并行 --> ( 难度等级: [0.2176, 0.2177) || 挂载数据: 无 ) 
│       │   ├── multiprocessing.shared_memory --- 可从进程直接访问的共享内存 --> ( 难度等级: [0.2177, 0.2177) || 挂载数据: 无 ) 
│       │   ├── concurrent包 --> ( 难度等级: [0.2177, 0.2178) || 挂载数据: 无 ) 
│       │   ├── concurrent.futures --- 启动并行任务 --> ( 难度等级: [0.2178, 0.2178) || 挂载数据: 无 ) 
│       │   ├── subprocess --- 子进程管理 --> ( 难度等级: [0.2178, 0.2179) || 挂载数据: qa: 3 ) 
│       │   ├── sched --- 事件调度器 --> ( 难度等级: [0.2179, 0.2179) || 挂载数据: 无 ) 
│       │   ├── queue --- 一个同步的队列类 --> ( 难度等级: [0.2179, 0.218) || 挂载数据: 无 ) 
│       │   ├── contextvars --- 上下文变量 --> ( 难度等级: [0.218, 0.218) || 挂载数据: 无 ) 
│       │   └── _thread --- 底层多线程API --> ( 难度等级: [0.218, 0.2181) || 挂载数据: qa: 1 ) 
│       ├── 网络和进程间通信 --> ( 难度等级: [0.2181, 0.2186) || 挂载数据: 无 ) 
│       │   ├── asyncio --- 异步I/O --> ( 难度等级: [0.2181, 0.2181) || 挂载数据: 无 ) 
│       │   ├── socket --- 底层网络接口 --> ( 难度等级: [0.2181, 0.2182) || 挂载数据: 无 ) 
│       │   ├── ssl --- 套接字对象的TLS/SSL包装器 --> ( 难度等级: [0.2182, 0.2183) || 挂载数据: 无 ) 
│       │   ├── select --- 等待I/O完成 --> ( 难度等级: [0.2183, 0.2183) || 挂载数据: 无 ) 
│       │   ├── selectors --- 高级I/O复用库 --> ( 难度等级: [0.2183, 0.2184) || 挂载数据: qa: 1 ) 
│       │   ├── asyncore --- 异步套接字处理器 --> ( 难度等级: [0.2184, 0.2184) || 挂载数据: 无 ) 
│       │   ├── asynchat --- 异步套接字指令/响应处理程序 --> ( 难度等级: [0.2184, 0.2185) || 挂载数据: 无 ) 
│       │   ├── signal --- 设置异步事件处理程序 --> ( 难度等级: [0.2185, 0.2186) || 挂载数据: 无 ) 
│       │   └── mmap --- 内存映射文件支持 --> ( 难度等级: [0.2186, 0.2186) || 挂载数据: 无 ) 
│       ├── 互联网数据处理 --> ( 难度等级: [0.2186, 0.2191) || 挂载数据: qa: 1 ) 
│       │   ├── email --- 电子邮件与MIME处理包 --> ( 难度等级: [0.2186, 0.2187) || 挂载数据: 无 ) 
│       │   ├── json --- JSON编码和解码器 --> ( 难度等级: [0.2187, 0.2188) || 挂载数据: 无 ) 
│       │   ├── mailcap --- Mailcap文件处理 --> ( 难度等级: [0.2188, 0.2188) || 挂载数据: 无 ) 
│       │   ├── mailbox --- 操作多种格式的邮箱 --> ( 难度等级: [0.2188, 0.2189) || 挂载数据: 无 ) 
│       │   ├── mimetypes --- 映射文件名到MIME类型 --> ( 难度等级: [0.2189, 0.2189) || 挂载数据: 无 ) 
│       │   ├── base64 --- Base16, Base32, Base64, Base85 数据编码 --> ( 难度等级: [0.2189, 0.219) || 挂载数据: 无 ) 
│       │   ├── binascii --- 二进制和ASCII码互转 --> ( 难度等级: [0.219, 0.2191) || 挂载数据: qa: 2 ) 
│       │   └── quopri --- 编码与解码经过MIME转码的可打印数据 --> ( 难度等级: [0.2191, 0.2191) || 挂载数据: 无 ) 
│       ├── 结构化标记处理工具 --> ( 难度等级: [0.2191, 0.2197) || 挂载数据: 无 ) 
│       │   ├── html --- 超文本标记语言支持 --> ( 难度等级: [0.2191, 0.2192) || 挂载数据: 无 ) 
│       │   ├── html.parser --- 简单的HTML和XHTML解析器 --> ( 难度等级: [0.2192, 0.2192) || 挂载数据: 无 ) 
│       │   ├── html.entities --- HTML一般实体的定义 --> ( 难度等级: [0.2192, 0.2193) || 挂载数据: 无 ) 
│       │   ├── XML处理模块 --> ( 难度等级: [0.2193, 0.2193) || 挂载数据: 无 ) 
│       │   ├── xml.etree.ElementTree ---  ElementTree XML API --> ( 难度等级: [0.2193, 0.2194) || 挂载数据: 无 ) 
│       │   ├── xml.dom --- 文档对象模型API --> ( 难度等级: [0.2194, 0.2194) || 挂载数据: 无 ) 
│       │   ├── xml.dom.minidom --- Minimal DOM implementation --> ( 难度等级: [0.2194, 0.2194) || 挂载数据: 无 ) 
│       │   ├── xml.dom.pulldom --- 支持构建部分DOM树 --> ( 难度等级: [0.2194, 0.2195) || 挂载数据: 无 ) 
│       │   ├── xml.sax --- 支持SAX2 解析器 --> ( 难度等级: [0.2195, 0.2195) || 挂载数据: 无 ) 
│       │   ├── xml.sax.handler --- SAX处理程序的基类 --> ( 难度等级: [0.2195, 0.2196) || 挂载数据: 无 ) 
│       │   ├── xml.sax.saxutils --- SAX工具集 --> ( 难度等级: [0.2196, 0.2196) || 挂载数据: 无 ) 
│       │   ├── xml.sax.xmlreader --- 用于XML解析器的接口 --> ( 难度等级: [0.2196, 0.2196) || 挂载数据: 无 ) 
│       │   └── xml.parsers.expat --- Fast XML parsing using Expat --> ( 难度等级: [0.2196, 0.2197) || 挂载数据: 无 ) 
│       ├── 互联网协议和支持 --> ( 难度等级: [0.2197, 0.2202) || 挂载数据: 无 ) 
│       │   ├── webbrowser --- 方便的Web浏览器控制器 --> ( 难度等级: [0.2197, 0.2197) || 挂载数据: 无 ) 
│       │   ├── cgi --- Common Gateway Interface support --> ( 难度等级: [0.2197, 0.2197) || 挂载数据: 无 ) 
│       │   ├── cgitb --- 用于CGI脚本的回溯管理器 --> ( 难度等级: [0.2197, 0.2197) || 挂载数据: 无 ) 
│       │   ├── wsgiref --- WSGI Utilities and Reference Implementation --> ( 难度等级: [0.2197, 0.2198) || 挂载数据: 无 ) 
│       │   ├── urllib --- URL处理模块 --> ( 难度等级: [0.2198, 0.2198) || 挂载数据: 无 ) 
│       │   ├── urllib.request --- 用于打开URL的可扩展库 --> ( 难度等级: [0.2198, 0.2198) || 挂载数据: 无 ) 
│       │   ├── urllib.response --- urllib使用的Response类 --> ( 难度等级: [0.2198, 0.2198) || 挂载数据: qa: 1 ) 
│       │   ├── urllib.parse用于解析URL --> ( 难度等级: [0.2198, 0.2198) || 挂载数据: qa: 1 ) 
│       │   ├── urllib.error --- urllib.request引发的异常类 --> ( 难度等级: [0.2198, 0.2199) || 挂载数据: qa: 3 ) 
│       │   ├── urllib.robotparser --- robots.txt语法分析程序 --> ( 难度等级: [0.2199, 0.2199) || 挂载数据: 无 ) 
│       │   ├── http --- HTTP模块 --> ( 难度等级: [0.2199, 0.2199) || 挂载数据: 无 ) 
│       │   ├── http.client --- HTTP协议客户端 --> ( 难度等级: [0.2199, 0.2199) || 挂载数据: 无 ) 
│       │   ├── ftplib --- FTP协议客户端 --> ( 难度等级: [0.2199, 0.2199) || 挂载数据: 无 ) 
│       │   ├── poplib --- POP3 协议客户端 --> ( 难度等级: [0.2199, 0.2199) || 挂载数据: 无 ) 
│       │   ├── imaplib --- IMAP4 协议客户端 --> ( 难度等级: [0.2199, 0.22) || 挂载数据: 无 ) 
│       │   ├── nntplib --- NNTP protocol client --> ( 难度等级: [0.22, 0.22) || 挂载数据: 无 ) 
│       │   ├── smtplib ---SMTP协议客户端 --> ( 难度等级: [0.22, 0.22) || 挂载数据: 无 ) 
│       │   ├── smtpd --- SMTP服务器 --> ( 难度等级: [0.22, 0.22) || 挂载数据: 无 ) 
│       │   ├── telnetlib -- Telnet客户端 --> ( 难度等级: [0.22, 0.22) || 挂载数据: 无 ) 
│       │   ├── uuid --- UUID objects according to <strong>RFC 4122</strong> --> ( 难度等级: [0.22, 0.2201) || 挂载数据: 无 ) 
│       │   ├── socketserver --- A framework for network servers --> ( 难度等级: [0.2201, 0.2201) || 挂载数据: qa: 5 ) 
│       │   ├── http.server --- HTTP服务器 --> ( 难度等级: [0.2201, 0.2201) || 挂载数据: 无 ) 
│       │   ├── http.cookies --- HTTP状态管理 --> ( 难度等级: [0.2201, 0.2201) || 挂载数据: qa: 1 ) 
│       │   ├── http.cookiejar —— HTTP客户端的Cookie处理 --> ( 难度等级: [0.2201, 0.2201) || 挂载数据: 无 ) 
│       │   ├── xmlrpc --- XMLRPC服务端与客户端模块 --> ( 难度等级: [0.2201, 0.2202) || 挂载数据: 无 ) 
│       │   ├── xmlrpc.client --- XML-RPC客户端访问 --> ( 难度等级: [0.2202, 0.2202) || 挂载数据: 无 ) 
│       │   ├── xmlrpc.server --- 基本XML-RPC服务器 --> ( 难度等级: [0.2202, 0.2202) || 挂载数据: 无 ) 
│       │   └── ipaddress --- IPv4/IPv6 操作库 --> ( 难度等级: [0.2202, 0.2202) || 挂载数据: 无 ) 
│       ├── 多媒体服务 --> ( 难度等级: [0.2202, 0.2207) || 挂载数据: 无 ) 
│       │   ├── audioop --- 处理原始音频数据 --> ( 难度等级: [0.2202, 0.2203) || 挂载数据: 无 ) 
│       │   ├── aifc --- 读写AIFF和AIFC文件 --> ( 难度等级: [0.2203, 0.2203) || 挂载数据: 无 ) 
│       │   ├── sunau --- 读写Sun AU文件 --> ( 难度等级: [0.2203, 0.2204) || 挂载数据: 无 ) 
│       │   ├── wave --- 读写WAV格式文件 --> ( 难度等级: [0.2204, 0.2204) || 挂载数据: 无 ) 
│       │   ├── chunk --- 读取IFF分块数据 --> ( 难度等级: [0.2204, 0.2205) || 挂载数据: 无 ) 
│       │   ├── colorsys --- 颜色系统间的转换 --> ( 难度等级: [0.2205, 0.2206) || 挂载数据: 无 ) 
│       │   ├── imghdr --- 推测图像类型 --> ( 难度等级: [0.2206, 0.2206) || 挂载数据: 无 ) 
│       │   ├── sndhdr --- 推测声音文件的类型 --> ( 难度等级: [0.2206, 0.2207) || 挂载数据: 无 ) 
│       │   └── ossaudiodev --- Access to OSS-compatible audio devices --> ( 难度等级: [0.2207, 0.2207) || 挂载数据: qa: 1 ) 
│       ├── 国际化 --> ( 难度等级: [0.2207, 0.2213) || 挂载数据: 无 ) 
│       │   ├── gettext --- 多语种国际化服务 --> ( 难度等级: [0.2207, 0.221) || 挂载数据: 无 ) 
│       │   └── locale --- 国际化服务 --> ( 难度等级: [0.221, 0.2213) || 挂载数据: 无 ) 
│       ├── 程序框架 --> ( 难度等级: [0.2213, 0.2218) || 挂载数据: 无 ) 
│       │   ├── turtle --- 海龟绘图 --> ( 难度等级: [0.2213, 0.2215) || 挂载数据: qa: 6 ) 
│       │   ├── cmd --- 支持面向行的命令解释器 --> ( 难度等级: [0.2215, 0.2216) || 挂载数据: qa: 3 ) 
│       │   └── shlex --- Simple lexical analysis --> ( 难度等级: [0.2216, 0.2218) || 挂载数据: 无 ) 
│       ├── Tk图形用户界面(GUI) --> ( 难度等级: [0.2218, 0.2223) || 挂载数据: 无 ) 
│       │   ├── tkinter --- Tcl/Tk的Python接口 --> ( 难度等级: [0.2218, 0.2219) || 挂载数据: qa: 2 ) 
│       │   ├── tkinter.colorchooser --- 颜色选择对话框 --> ( 难度等级: [0.2219, 0.2219) || 挂载数据: 无 ) 
│       │   ├── tkinter.font --- Tkinter字体封装 --> ( 难度等级: [0.2219, 0.222) || 挂载数据: 无 ) 
│       │   ├── Tkinter对话框 --> ( 难度等级: [0.222, 0.222) || 挂载数据: 无 ) 
│       │   ├── tkinter.messagebox --- Tkinter消息提示 --> ( 难度等级: [0.222, 0.2221) || 挂载数据: qa: 2 ) 
│       │   ├── tkinter.scrolledtext --- 滚动文字控件 --> ( 难度等级: [0.2221, 0.2221) || 挂载数据: 无 ) 
│       │   ├── tkinter.dnd --- 拖放操作支持 --> ( 难度等级: [0.2221, 0.2221) || 挂载数据: 无 ) 
│       │   ├── tkinter.ttk --- Tk主题部件 --> ( 难度等级: [0.2221, 0.2222) || 挂载数据: 无 ) 
│       │   ├── tkinter.tix --- Extension widgets for Tk --> ( 难度等级: [0.2222, 0.2222) || 挂载数据: qa: 1 ) 
│       │   ├── IDLE --> ( 难度等级: [0.2222, 0.2223) || 挂载数据: qa: 7 ) 
│       │   └── 其他图形用户界面（GUI）包 --> ( 难度等级: [0.2223, 0.2223) || 挂载数据: 无 ) 
│       ├── 调试和分析 --> ( 难度等级: [0.2223, 0.2229) || 挂载数据: 无 ) 
│       │   ├── 审计事件表 --> ( 难度等级: [0.2223, 0.2224) || 挂载数据: 无 ) 
│       │   ├── bdb --- Debugger framework --> ( 难度等级: [0.2224, 0.2224) || 挂载数据: 无 ) 
│       │   ├── faulthandler --- Dump the Python traceback --> ( 难度等级: [0.2224, 0.2225) || 挂载数据: 无 ) 
│       │   ├── pdb --- Python的调试器 --> ( 难度等级: [0.2225, 0.2225) || 挂载数据: 无 ) 
│       │   ├── Python Profilers分析器 --> ( 难度等级: [0.2225, 0.2226) || 挂载数据: 无 ) 
│       │   ├── timeit --- 测量小代码片段的执行时间 --> ( 难度等级: [0.2226, 0.2226) || 挂载数据: qa: 4 ) 
│       │   ├── trace --- 跟踪Python语句执行 --> ( 难度等级: [0.2226, 0.2227) || 挂载数据: 无 ) 
│       │   ├── tracemalloc --- 跟踪内存分配 --> ( 难度等级: [0.2227, 0.2227) || 挂载数据: 无 ) 
│       │   ├── 抛出异常 --> ( 难度等级: [0.2227, 0.2228) || 挂载数据: 无 ) 
│       │   ├── 取得回溯字符串 --> ( 难度等级: [0.2228, 0.2228) || 挂载数据: qa: 1 ) 
│       │   └── Mu的调试器 --> ( 难度等级: [0.2228, 0.2229) || 挂载数据: 无 ) 
│       ├── 软件打包和分发 --> ( 难度等级: [0.2229, 0.2234) || 挂载数据: 无 ) 
│       │   ├── distutils --- 构建和安装Python模块 --> ( 难度等级: [0.2229, 0.223) || 挂载数据: 无 ) 
│       │   ├── ensurepip --- Bootstrapping the pip installer --> ( 难度等级: [0.223, 0.2231) || 挂载数据: 无 ) 
│       │   ├── venv --- 创建虚拟环境 --> ( 难度等级: [0.2231, 0.2233) || 挂载数据: 无 ) 
│       │   └── zipapp --- Manage executable Python zip archives --> ( 难度等级: [0.2233, 0.2234) || 挂载数据: 无 ) 
│       ├── Python运行时服务 --> ( 难度等级: [0.2234, 0.2239) || 挂载数据: 无 ) 
│       │   ├── sysconfig --- Provide access to Python's configuration information --> ( 难度等级: [0.2234, 0.2234) || 挂载数据: 无 ) 
│       │   ├── builtins --- 内建对象 --> ( 难度等级: [0.2234, 0.2235) || 挂载数据: 无 ) 
│       │   ├── __main__ --- 顶层脚本环境 --> ( 难度等级: [0.2235, 0.2235) || 挂载数据: 无 ) 
│       │   ├── warnings --- Warning control --> ( 难度等级: [0.2235, 0.2236) || 挂载数据: qa: 1 ) 
│       │   ├── dataclasses --- 数据类 --> ( 难度等级: [0.2236, 0.2236) || 挂载数据: 无 ) 
│       │   ├── contextlib --- 为with语句上下文提供的工具 --> ( 难度等级: [0.2236, 0.2236) || 挂载数据: 无 ) 
│       │   ├── abc --- 抽象基类 --> ( 难度等级: [0.2236, 0.2237) || 挂载数据: 无 ) 
│       │   ├── atexit --- 退出处理器 --> ( 难度等级: [0.2237, 0.2237) || 挂载数据: 无 ) 
│       │   ├── traceback --- 打印或检索堆栈回溯 --> ( 难度等级: [0.2237, 0.2238) || 挂载数据: qa: 3 ) 
│       │   ├── __future__ --- Future语句定义 --> ( 难度等级: [0.2238, 0.2238) || 挂载数据: 无 ) 
│       │   ├── gc --- 垃圾回收器接口 --> ( 难度等级: [0.2238, 0.2239) || 挂载数据: 无 ) 
│       │   ├── inspect --- 检查对象 --> ( 难度等级: [0.2239, 0.2239) || 挂载数据: 无 ) 
│       │   └── site —— 指定域的配置钩子 --> ( 难度等级: [0.2239, 0.2239) || 挂载数据: 无 ) 
│       ├── 自定义Python解释器 --> ( 难度等级: [0.2239, 0.2245) || 挂载数据: 无 ) 
│       │   ├── code --- 解释器基类 --> ( 难度等级: [0.2239, 0.2242) || 挂载数据: qa: 2 ) 
│       │   └── codeop --- 编译Python代码 --> ( 难度等级: [0.2242, 0.2245) || 挂载数据: 无 ) 
│       ├── 导入模块 --> ( 难度等级: [0.2245, 0.225) || 挂载数据: 无 ) 
│       │   ├── zipimport --- 从Zip存档中导入模块 --> ( 难度等级: [0.2245, 0.2246) || 挂载数据: 无 ) 
│       │   ├── pkgutil --- 包扩展工具 --> ( 难度等级: [0.2246, 0.2246) || 挂载数据: 无 ) 
│       │   ├── modulefinder --- 查找脚本使用的模块 --> ( 难度等级: [0.2246, 0.2247) || 挂载数据: 无 ) 
│       │   ├── runpy --- Locating and executing Python modules --> ( 难度等级: [0.2247, 0.2248) || 挂载数据: 无 ) 
│       │   ├── importlib --- import的实现 --> ( 难度等级: [0.2248, 0.2249) || 挂载数据: 无 ) 
│       │   └── Using importlib.metadata --> ( 难度等级: [0.2249, 0.225) || 挂载数据: qa: 1 ) 
│       ├── Python语言服务 --> ( 难度等级: [0.225, 0.2255) || 挂载数据: 无 ) 
│       │   ├── parser --- 访问Python解析树 --> ( 难度等级: [0.225, 0.225) || 挂载数据: 无 ) 
│       │   ├── ast --- 抽象语法树 --> ( 难度等级: [0.225, 0.2251) || 挂载数据: 无 ) 
│       │   ├── symtable --- Access to the compiler's symbol tables --> ( 难度等级: [0.2251, 0.2251) || 挂载数据: 无 ) 
│       │   ├── symbol --- 与Python解析树一起使用的常量 --> ( 难度等级: [0.2251, 0.2252) || 挂载数据: 无 ) 
│       │   ├── token --- 与Python解析树一起使用的常量 --> ( 难度等级: [0.2252, 0.2252) || 挂载数据: qa: 1 ) 
│       │   ├── keyword --- 检验Python关键字 --> ( 难度等级: [0.2252, 0.2252) || 挂载数据: qa: 1 ) 
│       │   ├── tokenize --- 对Python代码使用的标记解析器 --> ( 难度等级: [0.2252, 0.2253) || 挂载数据: qa: 1 ) 
│       │   ├── tabnanny --- 模糊缩进检测 --> ( 难度等级: [0.2253, 0.2253) || 挂载数据: 无 ) 
│       │   ├── pyclbr --- Python模块浏览器支持 --> ( 难度等级: [0.2253, 0.2254) || 挂载数据: 无 ) 
│       │   ├── py_compile --- 编译Python源文件 --> ( 难度等级: [0.2254, 0.2254) || 挂载数据: 无 ) 
│       │   ├── compileall --- Byte-compile Python libraries --> ( 难度等级: [0.2254, 0.2255) || 挂载数据: qa: 1 ) 
│       │   ├── dis --- Python字节码反汇编器 --> ( 难度等级: [0.2255, 0.2255) || 挂载数据: 无 ) 
│       │   └── pickletools --- pickle开发者工具集 --> ( 难度等级: [0.2255, 0.2255) || 挂载数据: 无 ) 
│       ├── 杂项服务 --> ( 难度等级: [0.2255, 0.2261) || 挂载数据: 无 ) 
│       │   └── formatter --- 通用格式化输出 --> ( 难度等级: [0.2255, 0.2261) || 挂载数据: 无 ) 
│       ├── Windows系统相关模块 --> ( 难度等级: [0.2261, 0.2266) || 挂载数据: 无 ) 
│       │   ├── msilib --- Read and write Microsoft Installer files --> ( 难度等级: [0.2261, 0.2262) || 挂载数据: qa: 4 ) 
│       │   ├── msvcrt --- 来自MS VC++ 运行时的有用例程 --> ( 难度等级: [0.2262, 0.2263) || 挂载数据: 无 ) 
│       │   ├── winreg --- Windows注册表访问 --> ( 难度等级: [0.2263, 0.2265) || 挂载数据: qa: 1 ) 
│       │   └── winsound --- Sound-playing interface for Windows --> ( 难度等级: [0.2265, 0.2266) || 挂载数据: 无 ) 
│       ├── Unix专有服务 --> ( 难度等级: [0.2266, 0.2271) || 挂载数据: 无 ) 
│       │   ├── posix --- 最常见的POSIX系统调用 --> ( 难度等级: [0.2266, 0.2266) || 挂载数据: 无 ) 
│       │   ├── pwd --- 用户密码数据库 --> ( 难度等级: [0.2266, 0.2267) || 挂载数据: 无 ) 
│       │   ├── spwd --- The shadow password database --> ( 难度等级: [0.2267, 0.2267) || 挂载数据: qa: 1 ) 
│       │   ├── grp --- 组数据库 --> ( 难度等级: [0.2267, 0.2268) || 挂载数据: 无 ) 
│       │   ├── crypt --- Function to check Unix passwords --> ( 难度等级: [0.2268, 0.2268) || 挂载数据: qa: 5 ) 
│       │   ├── termios --- POSIX风格的tty控制 --> ( 难度等级: [0.2268, 0.2268) || 挂载数据: 无 ) 
│       │   ├── tty --- 终端控制功能 --> ( 难度等级: [0.2268, 0.2269) || 挂载数据: 无 ) 
│       │   ├── pty --- 伪终端工具 --> ( 难度等级: [0.2269, 0.2269) || 挂载数据: 无 ) 
│       │   ├── fcntl --- The fcntl and ioctl system calls --> ( 难度等级: [0.2269, 0.227) || 挂载数据: qa: 1 ) 
│       │   ├── pipes --- 终端管道接口 --> ( 难度等级: [0.227, 0.227) || 挂载数据: 无 ) 
│       │   ├── resource --- Resource usage information --> ( 难度等级: [0.227, 0.227) || 挂载数据: qa: 5 ) 
│       │   ├── nis --- Sun的NIS (黄页) 接口 --> ( 难度等级: [0.227, 0.2271) || 挂载数据: 无 ) 
│       │   └── Unix syslog库例程 --> ( 难度等级: [0.2271, 0.2271) || 挂载数据: 无 ) 
│       ├── 被取代的模块 --> ( 难度等级: [0.2271, 0.2277) || 挂载数据: 无 ) 
│       │   ├── optparse --- 解析器的命令行选项 --> ( 难度等级: [0.2271, 0.2274) || 挂载数据: 无 ) 
│       │   └── imp --- Access the import internals --> ( 难度等级: [0.2274, 0.2277) || 挂载数据: 无 ) 
│       ├── 未创建文档的模块 --> ( 难度等级: [0.2277, 0.2282) || 挂载数据: 无 ) 
│       │   └── 平台特定模块 --> ( 难度等级: [0.2277, 0.2282) || 挂载数据: 无 ) 
│       ├── Python基础 --> ( 难度等级: [0.2282, 0.2287) || 挂载数据: 无 ) 
│       │   ├── 在交互式环境中输入表达式 --> ( 难度等级: [0.2282, 0.2283) || 挂载数据: 无 ) 
│       │   ├── 字符串连接和复制 --> ( 难度等级: [0.2283, 0.2284) || 挂载数据: 无 ) 
│       │   ├── 在变量中保存值 --> ( 难度等级: [0.2284, 0.2285) || 挂载数据: qa: 1 ) 
│       │   │   └── 变量名 --> ( 难度等级: [0.2284, 0.2285) || 挂载数据: qa: 2 ) 
│       │   ├── 第一个程序 --> ( 难度等级: [0.2285, 0.2286) || 挂载数据: qa: 8 ) 
│       │   └── 程序剖析 --> ( 难度等级: [0.2286, 0.2287) || 挂载数据: 无 ) 
│       │       ├── print函数 --> ( 难度等级: [0.2286, 0.2286) || 挂载数据: qa: 3 ) 
│       │       ├── input函数 --> ( 难度等级: [0.2286, 0.2287) || 挂载数据: qa: 1 ) 
│       │       ├── 输出用户的名字 --> ( 难度等级: [0.2287, 0.2287) || 挂载数据: qa: 1 ) 
│       │       └── len函数 --> ( 难度等级: [0.2287, 0.2287) || 挂载数据: qa: 1 ) 
│       ├── 高级特性 --> ( 难度等级: [0.2287, 0.2293) || 挂载数据: 无 ) 
│       │   ├── 切片 --> ( 难度等级: [0.2287, 0.2289) || 挂载数据: 无 ) 
│       │   ├── 迭代 --> ( 难度等级: [0.2289, 0.2291) || 挂载数据: 无 ) 
│       │   └── 列表生成式 --> ( 难度等级: [0.2291, 0.2293) || 挂载数据: 无 ) 
│       ├── 函数式编程 --> ( 难度等级: [0.2293, 0.2298) || 挂载数据: 无 ) 
│       │   ├── 高阶函数 --> ( 难度等级: [0.2293, 0.2294) || 挂载数据: 无 ) 
│       │   │   ├── map/reduce --> ( 难度等级: [0.2293, 0.2293) || 挂载数据: qa: 6 ) 
│       │   │   └── filter --> ( 难度等级: [0.2293, 0.2294) || 挂载数据: 无 ) 
│       │   ├── 返回函数 --> ( 难度等级: [0.2294, 0.2295) || 挂载数据: qa: 1 ) 
│       │   ├── 匿名函数 --> ( 难度等级: [0.2295, 0.2297) || 挂载数据: 无 ) 
│       │   └── 偏函数 --> ( 难度等级: [0.2297, 0.2298) || 挂载数据: 无 ) 
│       ├── 面向对象高级编程 --> ( 难度等级: [0.2298, 0.2303) || 挂载数据: 无 ) 
│       │   ├── 使用__slots__ --> ( 难度等级: [0.2298, 0.2299) || 挂载数据: 无 ) 
│       │   ├── 使用@property --> ( 难度等级: [0.2299, 0.2301) || 挂载数据: qa: 2 ) 
│       │   ├── 定制类 --> ( 难度等级: [0.2301, 0.2302) || 挂载数据: 无 ) 
│       │   └── 使用枚举类 --> ( 难度等级: [0.2302, 0.2303) || 挂载数据: 无 ) 
│       ├── IO编程 --> ( 难度等级: [0.2303, 0.2309) || 挂载数据: 无 ) 
│       │   ├── StringIO和BytesIO --> ( 难度等级: [0.2303, 0.2305) || 挂载数据: 无 ) 
│       │   ├── 操作文件和目录 --> ( 难度等级: [0.2305, 0.2307) || 挂载数据: 无 ) 
│       │   └── 序列化 --> ( 难度等级: [0.2307, 0.2309) || 挂载数据: 无 ) 
│       ├── 进程和线程 --> ( 难度等级: [0.2309, 0.2314) || 挂载数据: 无 ) 
│       │   ├── 多进程 --> ( 难度等级: [0.2309, 0.231) || 挂载数据: 无 ) 
│       │   ├── ThreadLocal --> ( 难度等级: [0.231, 0.2311) || 挂载数据: 无 ) 
│       │   ├── 进程vs. 线程 --> ( 难度等级: [0.2311, 0.2313) || 挂载数据: qa: 5 ) 
│       │   └── 分布式进程 --> ( 难度等级: [0.2313, 0.2314) || 挂载数据: 无 ) 
│       ├── 正则表达式 --> ( 难度等级: [0.2314, 0.2319) || 挂载数据: qa: 6 ) 
│       ├── 常用内建模块 --> ( 难度等级: [0.2319, 0.2324) || 挂载数据: 无 ) 
│       │   ├── collections --> ( 难度等级: [0.2319, 0.232) || 挂载数据: 无 ) 
│       │   ├── base64 --> ( 难度等级: [0.232, 0.232) || 挂载数据: 无 ) 
│       │   ├── struct --> ( 难度等级: [0.232, 0.2321) || 挂载数据: 无 ) 
│       │   ├── hashlib --> ( 难度等级: [0.2321, 0.2322) || 挂载数据: 无 ) 
│       │   ├── hmac --> ( 难度等级: [0.2322, 0.2322) || 挂载数据: 无 ) 
│       │   ├── itertools --> ( 难度等级: [0.2322, 0.2323) || 挂载数据: 无 ) 
│       │   ├── contextlib --> ( 难度等级: [0.2323, 0.2323) || 挂载数据: 无 ) 
│       │   ├── XML --> ( 难度等级: [0.2323, 0.2324) || 挂载数据: 无 ) 
│       │   └── HTMLParser --> ( 难度等级: [0.2324, 0.2324) || 挂载数据: 无 ) 
│       ├── virtualenv --> ( 难度等级: [0.2324, 0.233) || 挂载数据: 无 ) 
│       ├── 图形界面 --> ( 难度等级: [0.233, 0.2335) || 挂载数据: 无 ) 
│       │   └── 海龟绘图 --> ( 难度等级: [0.233, 0.2335) || 挂载数据: 无 ) 
│       ├── 网络编程 --> ( 难度等级: [0.2335, 0.234) || 挂载数据: 无 ) 
│       │   ├── TCP/IP简介 --> ( 难度等级: [0.2335, 0.2336) || 挂载数据: 无 ) 
│       │   ├── TCP编程 --> ( 难度等级: [0.2336, 0.2337) || 挂载数据: 无 ) 
│       │   ├── UDP编程 --> ( 难度等级: [0.2337, 0.2338) || 挂载数据: 无 ) 
│       │   ├── 几个网络模块 --> ( 难度等级: [0.2338, 0.2339) || 挂载数据: 无 ) 
│       │   │   ├── 模块socket --> ( 难度等级: [0.2338, 0.2338) || 挂载数据: qa: 1 ) 
│       │   │   └── 模块urllib和urllib2 --> ( 难度等级: [0.2338, 0.2339) || 挂载数据: qa: 1 ) 
│       │   ├── SocketServer及相关的类 --> ( 难度等级: [0.2339, 0.234) || 挂载数据: 无 ) 
│       │   └── Twisted --> ( 难度等级: [0.234, 0.234) || 挂载数据: 无 ) 
│       │       ├── 下载并安装Twisted --> ( 难度等级: [0.234, 0.234) || 挂载数据: qa: 3 ) 
│       │       └── 编写Twisted服务器 --> ( 难度等级: [0.234, 0.234) || 挂载数据: 无 ) 
│       ├── 电子邮件 --> ( 难度等级: [0.234, 0.2346) || 挂载数据: 无 ) 
│       │   ├── SMTP发送邮件 --> ( 难度等级: [0.234, 0.2343) || 挂载数据: qa: 2 ) 
│       │   └── POP3收取邮件 --> ( 难度等级: [0.2343, 0.2346) || 挂载数据: 无 ) 
│       ├── 访问数据库 --> ( 难度等级: [0.2346, 0.2351) || 挂载数据: 无 ) 
│       │   ├── 使用SQLite --> ( 难度等级: [0.2346, 0.2348) || 挂载数据: 无 ) 
│       │   ├── 使用MySQL --> ( 难度等级: [0.2348, 0.2349) || 挂载数据: 无 ) 
│       │   └── 使用SQLAlchemy --> ( 难度等级: [0.2349, 0.2351) || 挂载数据: qa: 1 ) 
│       ├── Web开发 --> ( 难度等级: [0.2351, 0.2356) || 挂载数据: 无 ) 
│       │   ├── HTTP协议简介 --> ( 难度等级: [0.2351, 0.2352) || 挂载数据: 无 ) 
│       │   ├── HTML简介 --> ( 难度等级: [0.2352, 0.2354) || 挂载数据: 无 ) 
│       │   ├── WSGI接口 --> ( 难度等级: [0.2354, 0.2355) || 挂载数据: 无 ) 
│       │   └── 使用Web框架 --> ( 难度等级: [0.2355, 0.2356) || 挂载数据: 无 ) 
│       ├── 异步IO --> ( 难度等级: [0.2356, 0.2362) || 挂载数据: 无 ) 
│       │   ├── asyncio --> ( 难度等级: [0.2356, 0.2358) || 挂载数据: 无 ) 
│       │   ├── async/await --> ( 难度等级: [0.2358, 0.236) || 挂载数据: 无 ) 
│       │   └── aiohttp --> ( 难度等级: [0.236, 0.2362) || 挂载数据: 无 ) 
│       ├── 使用MicroPython --> ( 难度等级: [0.2362, 0.2367) || 挂载数据: 无 ) 
│       │   ├── 搭建开发环境 --> ( 难度等级: [0.2362, 0.2363) || 挂载数据: 无 ) 
│       │   ├── 控制小车 --> ( 难度等级: [0.2363, 0.2364) || 挂载数据: 无 ) 
│       │   ├── 遥控小车 --> ( 难度等级: [0.2364, 0.2366) || 挂载数据: 无 ) 
│       │   └── 遥控转向 --> ( 难度等级: [0.2366, 0.2367) || 挂载数据: 无 ) 
│       ├── 当索引行不通时 --> ( 难度等级: [0.2367, 0.2372) || 挂载数据: 无 ) 
│       │   └── 字典的用途 --> ( 难度等级: [0.2367, 0.2372) || 挂载数据: 无 ) 
│       ├── 抽象 --> ( 难度等级: [0.2372, 0.2378) || 挂载数据: 无 ) 
│       │   ├── 懒惰是一种美德 --> ( 难度等级: [0.2372, 0.2374) || 挂载数据: 无 ) 
│       │   ├── 自定义函数 --> ( 难度等级: [0.2374, 0.2375) || 挂载数据: qa: 1 ) 
│       │   │   └── 给函数编写文档 --> ( 难度等级: [0.2374, 0.2375) || 挂载数据: qa: 8 ) 
│       │   ├── 参数魔法 --> ( 难度等级: [0.2375, 0.2376) || 挂载数据: 无 ) 
│       │   │   ├── 值从哪里来 --> ( 难度等级: [0.2375, 0.2375) || 挂载数据: qa: 1 ) 
│       │   │   ├── 我能修改参数吗 --> ( 难度等级: [0.2375, 0.2376) || 挂载数据: qa: 1 ) 
│       │   │   ├── 收集参数 --> ( 难度等级: [0.2376, 0.2376) || 挂载数据: 无 ) 
│       │   │   └── 分配参数 --> ( 难度等级: [0.2376, 0.2376) || 挂载数据: qa: 1 ) 
│       │   └── 递归 --> ( 难度等级: [0.2376, 0.2378) || 挂载数据: qa: 3 ) 
│       │       ├── 两个经典案例：阶乘和幂 --> ( 难度等级: [0.2376, 0.2377) || 挂载数据: qa: 1 ) 
│       │       └── 另一个经典案例：二分查找 --> ( 难度等级: [0.2377, 0.2378) || 挂载数据: qa: 1 ) 
│       ├── 再谈抽象 --> ( 难度等级: [0.2378, 0.2383) || 挂载数据: 无 ) 
│       │   ├── 对象魔法 --> ( 难度等级: [0.2378, 0.238) || 挂载数据: 无 ) 
│       │   └── 关于面向对象设计的一些思考 --> ( 难度等级: [0.238, 0.2383) || 挂载数据: 无 ) 
│       ├── 开箱即用 --> ( 难度等级: [0.2383, 0.2388) || 挂载数据: 无 ) 
│       │   └── 探索模块 --> ( 难度等级: [0.2383, 0.2388) || 挂载数据: 无 ) 
│       │       ├── 模块包含什么 --> ( 难度等级: [0.2383, 0.2384) || 挂载数据: 无 ) 
│       │       ├── 使用help获取帮助 --> ( 难度等级: [0.2384, 0.2386) || 挂载数据: qa: 2 ) 
│       │       ├── 文档 --> ( 难度等级: [0.2386, 0.2387) || 挂载数据: 无 ) 
│       │       └── 使用源代码 --> ( 难度等级: [0.2387, 0.2388) || 挂载数据: 无 ) 
│       ├── 图形用户界面 --> ( 难度等级: [0.2388, 0.2394) || 挂载数据: 无 ) 
│       │   ├── 创建GUI示例应用程序 --> ( 难度等级: [0.2388, 0.2391) || 挂载数据: 无 ) 
│       │   │   ├── 初探 --> ( 难度等级: [0.2388, 0.2389) || 挂载数据: 无 ) 
│       │   │   ├── 布局 --> ( 难度等级: [0.2389, 0.239) || 挂载数据: 无 ) 
│       │   │   ├── 事件处理 --> ( 难度等级: [0.239, 0.239) || 挂载数据: 无 ) 
│       │   │   └── 最终的程序 --> ( 难度等级: [0.239, 0.2391) || 挂载数据: qa: 1 ) 
│       │   └── 使用其他GUI工具包 --> ( 难度等级: [0.2391, 0.2394) || 挂载数据: 无 ) 
│       ├── 数据库支持 --> ( 难度等级: [0.2394, 0.2399) || 挂载数据: 无 ) 
│       │   └── Python数据库API --> ( 难度等级: [0.2394, 0.2399) || 挂载数据: 无 ) 
│       │       ├── 全局变量 --> ( 难度等级: [0.2394, 0.2396) || 挂载数据: qa: 2 ) 
│       │       └── 连接和游标 --> ( 难度等级: [0.2396, 0.2399) || 挂载数据: 无 ) 
│       │           ├── 使用SocketServer实现分叉和线程化 --> ( 难度等级: [0.2396, 0.2398) || 挂载数据: 无 ) 
│       │           └── 使用select和poll实现异步I/O --> ( 难度等级: [0.2398, 0.2399) || 挂载数据: qa: 1 ) 
│       ├── Python和Web --> ( 难度等级: [0.2399, 0.2404) || 挂载数据: 无 ) 
│       │   ├── 屏幕抓取 --> ( 难度等级: [0.2399, 0.2401) || 挂载数据: qa: 1 ) 
│       │   │   ├── Tidy和XHTML解析 --> ( 难度等级: [0.2399, 0.24) || 挂载数据: qa: 1 ) 
│       │   │   └── Beautiful Soup --> ( 难度等级: [0.24, 0.2401) || 挂载数据: 无 ) 
│       │   ├── 使用CGI创建动态网页 --> ( 难度等级: [0.2401, 0.2402) || 挂载数据: 无 ) 
│       │   │   ├── 第一步：准备Web服务器 --> ( 难度等级: [0.2401, 0.2401) || 挂载数据: 无 ) 
│       │   │   ├── 第二步：添加!#行 --> ( 难度等级: [0.2401, 0.2401) || 挂载数据: qa: 1 ) 
│       │   │   ├── 第三步：设置文件权限 --> ( 难度等级: [0.2401, 0.2401) || 挂载数据: 无 ) 
│       │   │   ├── CGI安全风险 --> ( 难度等级: [0.2401, 0.2402) || 挂载数据: 无 ) 
│       │   │   ├── 简单的CGI脚本 --> ( 难度等级: [0.2402, 0.2402) || 挂载数据: 无 ) 
│       │   │   ├── 使用cgitb进行调试 --> ( 难度等级: [0.2402, 0.2402) || 挂载数据: qa: 1 ) 
│       │   │   ├── 使用模块cgi --> ( 难度等级: [0.2402, 0.2402) || 挂载数据: 无 ) 
│       │   │   └── 简单的表单 --> ( 难度等级: [0.2402, 0.2402) || 挂载数据: 无 ) 
│       │   └── Web服务：更高级的抓取 --> ( 难度等级: [0.2402, 0.2404) || 挂载数据: 无 ) 
│       │       ├── RSS和相关内容 --> ( 难度等级: [0.2402, 0.2403) || 挂载数据: 无 ) 
│       │       ├── 使用XML-RPC进行远程过程调用 --> ( 难度等级: [0.2403, 0.2404) || 挂载数据: 无 ) 
│       │       └── SOAP --> ( 难度等级: [0.2404, 0.2404) || 挂载数据: 无 ) 
│       ├── 测试基础 --> ( 难度等级: [0.2404, 0.241) || 挂载数据: qa: 2 ) 
│       │   ├── 先测试再编码 --> ( 难度等级: [0.2404, 0.2406) || 挂载数据: 无 ) 
│       │   │   ├── 准确的需求说明 --> ( 难度等级: [0.2404, 0.2405) || 挂载数据: 无 ) 
│       │   │   ├── 做好应对变化的准备 --> ( 难度等级: [0.2405, 0.2405) || 挂载数据: qa: 1 ) 
│       │   │   └── 测试四步曲 --> ( 难度等级: [0.2405, 0.2406) || 挂载数据: 无 ) 
│       │   ├── 测试工具 --> ( 难度等级: [0.2406, 0.2408) || 挂载数据: 无 ) 
│       │   │   ├── doctest --> ( 难度等级: [0.2406, 0.2407) || 挂载数据: 无 ) 
│       │   │   └── unittest --> ( 难度等级: [0.2407, 0.2408) || 挂载数据: qa: 2 ) 
│       │   └── 超越单元测试 --> ( 难度等级: [0.2408, 0.241) || 挂载数据: 无 ) 
│       │       ├── 使用PyChecker和PyLint检查源代码 --> ( 难度等级: [0.2408, 0.2409) || 挂载数据: 无 ) 
│       │       └── 性能分析 --> ( 难度等级: [0.2409, 0.241) || 挂载数据: 无 ) 
│       ├── 扩展Python --> ( 难度等级: [0.241, 0.2415) || 挂载数据: 无 ) 
│       │   ├── 鱼和熊掌兼得 --> ( 难度等级: [0.241, 0.2411) || 挂载数据: 无 ) 
│       │   ├── 简单易行的方式：Jython和IronPython --> ( 难度等级: [0.2411, 0.2413) || 挂载数据: qa: 1 ) 
│       │   └── 编写C语言扩展 --> ( 难度等级: [0.2413, 0.2415) || 挂载数据: 无 ) 
│       │       ├── SWIG --> ( 难度等级: [0.2413, 0.2414) || 挂载数据: 无 ) 
│       │       └── 手工编写扩展 --> ( 难度等级: [0.2414, 0.2415) || 挂载数据: 无 ) 
│       ├── 程序打包 --> ( 难度等级: [0.2415, 0.242) || 挂载数据: 无 ) 
│       │   ├── Setuptools基础 --> ( 难度等级: [0.2415, 0.2416) || 挂载数据: 无 ) 
│       │   ├── 打包 --> ( 难度等级: [0.2416, 0.2418) || 挂载数据: qa: 2 ) 
│       │   ├── 编译扩展 --> ( 难度等级: [0.2418, 0.2419) || 挂载数据: 无 ) 
│       │   └── 使用py2exe创建可执行程序 --> ( 难度等级: [0.2419, 0.242) || 挂载数据: 无 ) 
│       ├── 趣味编程 --> ( 难度等级: [0.242, 0.2426) || 挂载数据: 无 ) 
│       │   ├── 为何要有趣 --> ( 难度等级: [0.242, 0.2421) || 挂载数据: 无 ) 
│       │   ├── 编程柔术 --> ( 难度等级: [0.2421, 0.2422) || 挂载数据: 无 ) 
│       │   ├── 原型设计 --> ( 难度等级: [0.2422, 0.2423) || 挂载数据: qa: 3 ) 
│       │   ├── 如果你已不胜其烦 --> ( 难度等级: [0.2423, 0.2424) || 挂载数据: 无 ) 
│       │   └── 如果你想深入学习 --> ( 难度等级: [0.2424, 0.2426) || 挂载数据: qa: 10 ) 
│       ├── Python编程基础 --> ( 难度等级: [0.2426, 0.2431) || 挂载数据: qa: 1 ) 
│       │   ├── 控制流 --> ( 难度等级: [0.2426, 0.2428) || 挂载数据: 无 ) 
│       │   │   ├── 布尔值 --> ( 难度等级: [0.2426, 0.2426) || 挂载数据: qa: 1 ) 
│       │   │   ├── 比较操作符 --> ( 难度等级: [0.2426, 0.2426) || 挂载数据: 无 ) 
│       │   │   ├── 布尔操作符 --> ( 难度等级: [0.2426, 0.2427) || 挂载数据: 无 ) 
│       │   │   │   ├── 二元布尔操作符 --> ( 难度等级: [0.2426, 0.2426) || 挂载数据: 无 ) 
│       │   │   │   └── not操作符 --> ( 难度等级: [0.2426, 0.2427) || 挂载数据: qa: 10 ) 
│       │   │   ├── 混合布尔和比较操作符 --> ( 难度等级: [0.2427, 0.2427) || 挂载数据: 无 ) 
│       │   │   ├── 控制流的元素 --> ( 难度等级: [0.2427, 0.2427) || 挂载数据: 无 ) 
│       │   │   │   └── 代码块 --> ( 难度等级: [0.2427, 0.2427) || 挂载数据: 无 ) 
│       │   │   ├── 程序执行 --> ( 难度等级: [0.2427, 0.2428) || 挂载数据: 无 ) 
│       │   │   ├── 控制流语句 --> ( 难度等级: [0.2428, 0.2428) || 挂载数据: 无 ) 
│       │   │   │   ├── else语句 --> ( 难度等级: [0.2428, 0.2428) || 挂载数据: qa: 3 ) 
│       │   │   │   ├── elif语句 --> ( 难度等级: [0.2428, 0.2428) || 挂载数据: qa: 1 ) 
│       │   │   │   ├── 恼人的循环 --> ( 难度等级: [0.2428, 0.2428) || 挂载数据: 无 ) 
│       │   │   │   └── 等价的while循环 --> ( 难度等级: [0.2428, 0.2428) || 挂载数据: qa: 5 ) 
│       │   │   └── 用sys.exit函数提前结束程序 --> ( 难度等级: [0.2428, 0.2428) || 挂载数据: qa: 1 ) 
│       │   └── 字符串操作 --> ( 难度等级: [0.2428, 0.2431) || 挂载数据: 无 ) 
│       │       ├── 将字符串放入其他字符串 --> ( 难度等级: [0.2428, 0.2428) || 挂载数据: qa: 2 ) 
│       │       ├── 有用的字符串方法 --> ( 难度等级: [0.2428, 0.2429) || 挂载数据: 无 ) 
│       │       ├── 使用ord和chr函数的字符的数值 --> ( 难度等级: [0.2429, 0.2429) || 挂载数据: 无 ) 
│       │       ├── 用pyperclip模块复制粘贴字符串 --> ( 难度等级: [0.2429, 0.2429) || 挂载数据: qa: 1 ) 
│       │       ├── 计算字符串的长度 --> ( 难度等级: [0.2429, 0.2429) || 挂载数据: qa: 3 ) 
│       │       ├── 截取字符串 --> ( 难度等级: [0.2429, 0.243) || 挂载数据: qa: 3 ) 
│       │       ├── 分割、合并字符串 --> ( 难度等级: [0.243, 0.243) || 挂载数据: 无 ) 
│       │       ├── 检索字符串 --> ( 难度等级: [0.243, 0.243) || 挂载数据: 无 ) 
│       │       ├── 字母的大小写转换 --> ( 难度等级: [0.243, 0.243) || 挂载数据: qa: 3 ) 
│       │       ├── 去除字符串中的空格和 --> ( 难度等级: [0.243, 0.2431) || 挂载数据: qa: 2 ) 
│       │       └── 格式化字符串 --> ( 难度等级: [0.2431, 0.2431) || 挂载数据: 无 ) 
│       ├── 自动化任务 --> ( 难度等级: [0.2431, 0.2436) || 挂载数据: 无 ) 
│       │   ├── 输入验证 --> ( 难度等级: [0.2431, 0.2431) || 挂载数据: 无 ) 
│       │   │   └── PyInputPlus模块 --> ( 难度等级: [0.2431, 0.2431) || 挂载数据: 无 ) 
│       │   │       ├── 关键字参数min、max、greaterThan和lessThan --> ( 难度等级: [0.2431, 0.2431) || 挂载数据: 无 ) 
│       │   │       ├── 关键字参数blank --> ( 难度等级: [0.2431, 0.2431) || 挂载数据: 无 ) 
│       │   │       ├── 关键字参数limit、timeout和default --> ( 难度等级: [0.2431, 0.2431) || 挂载数据: 无 ) 
│       │   │       ├── 关键字参数allowRegexes和blockRegexes --> ( 难度等级: [0.2431, 0.2431) || 挂载数据: 无 ) 
│       │   │       └── 将自定义验证函数传递给inputCustom --> ( 难度等级: [0.2431, 0.2431) || 挂载数据: 无 ) 
│       │   ├── 组织文件 --> ( 难度等级: [0.2431, 0.2432) || 挂载数据: 无 ) 
│       │   │   ├── shutil模块 --> ( 难度等级: [0.2431, 0.2432) || 挂载数据: 无 ) 
│       │   │   ├── 遍历目录树 --> ( 难度等级: [0.2432, 0.2432) || 挂载数据: 无 ) 
│       │   │   └── 用zipfile模块压缩文件 --> ( 难度等级: [0.2432, 0.2432) || 挂载数据: 无 ) 
│       │   ├── 从Web抓取信息 --> ( 难度等级: [0.2432, 0.2432) || 挂载数据: qa: 1 ) 
│       │   │   ├── 用requests模块从Web下载文件 --> ( 难度等级: [0.2432, 0.2432) || 挂载数据: qa: 1 ) 
│       │   │   ├── 将下载的文件保存到硬盘 --> ( 难度等级: [0.2432, 0.2432) || 挂载数据: 无 ) 
│       │   │   ├── HTML --> ( 难度等级: [0.2432, 0.2432) || 挂载数据: qa: 10 ) 
│       │   │   ├── 用bs4模块解析HTML --> ( 难度等级: [0.2432, 0.2432) || 挂载数据: qa: 1 ) 
│       │   │   └── 用selenium模块控制浏览器 --> ( 难度等级: [0.2432, 0.2432) || 挂载数据: 无 ) 
│       │   ├── 处理Excel电子表格 --> ( 难度等级: [0.2432, 0.2433) || 挂载数据: 无 ) 
│       │   │   ├── Excel文档 --> ( 难度等级: [0.2432, 0.2433) || 挂载数据: qa: 10 ) 
│       │   │   ├── 安装openpyxl模块 --> ( 难度等级: [0.2433, 0.2433) || 挂载数据: 无 ) 
│       │   │   ├── 读取Excel文档 --> ( 难度等级: [0.2433, 0.2433) || 挂载数据: qa: 6 ) 
│       │   │   ├── 写入Excel文档 --> ( 难度等级: [0.2433, 0.2433) || 挂载数据: qa: 6 ) 
│       │   │   ├── 设置单元格的字体风格 --> ( 难度等级: [0.2433, 0.2433) || 挂载数据: 无 ) 
│       │   │   ├── Font对象 --> ( 难度等级: [0.2433, 0.2433) || 挂载数据: 无 ) 
│       │   │   ├── 公式 --> ( 难度等级: [0.2433, 0.2433) || 挂载数据: qa: 1 ) 
│       │   │   └── 调整行和列 --> ( 难度等级: [0.2433, 0.2433) || 挂载数据: 无 ) 
│       │   ├── 处理Google电子表格 --> ( 难度等级: [0.2433, 0.2434) || 挂载数据: 无 ) 
│       │   │   ├── 安装和设置EZSheets --> ( 难度等级: [0.2433, 0.2433) || 挂载数据: 无 ) 
│       │   │   ├── Spreadsheet对象 --> ( 难度等级: [0.2433, 0.2433) || 挂载数据: 无 ) 
│       │   │   ├── 工作表对象 --> ( 难度等级: [0.2433, 0.2433) || 挂载数据: 无 ) 
│       │   │   └── 利用Google Sheets配额 --> ( 难度等级: [0.2433, 0.2434) || 挂载数据: qa: 1 ) 
│       │   ├── 处理PDF和Word文档 --> ( 难度等级: [0.2434, 0.2434) || 挂载数据: 无 ) 
│       │   │   ├── PDF文档 --> ( 难度等级: [0.2434, 0.2434) || 挂载数据: qa: 3 ) 
│       │   │   ├── Word文档 --> ( 难度等级: [0.2434, 0.2434) || 挂载数据: qa: 6 ) 
│       │   │   └── 从Word文档中创建PDF --> ( 难度等级: [0.2434, 0.2434) || 挂载数据: 无 ) 
│       │   ├── 处理CSV文件和JSON数据 --> ( 难度等级: [0.2434, 0.2435) || 挂载数据: 无 ) 
│       │   │   ├── csv模块 --> ( 难度等级: [0.2434, 0.2434) || 挂载数据: qa: 10 ) 
│       │   │   └── json模块 --> ( 难度等级: [0.2434, 0.2435) || 挂载数据: qa: 10 ) 
│       │   ├── 发送电子邮件和短信 --> ( 难度等级: [0.2435, 0.2435) || 挂载数据: 无 ) 
│       │   │   ├── 使用Gmail API发送和接收电子邮件 --> ( 难度等级: [0.2435, 0.2435) || 挂载数据: 无 ) 
│       │   │   ├── SMTP --> ( 难度等级: [0.2435, 0.2435) || 挂载数据: 无 ) 
│       │   │   ├── 发送电子邮件 --> ( 难度等级: [0.2435, 0.2435) || 挂载数据: qa: 1 ) 
│       │   │   ├── IMAP --> ( 难度等级: [0.2435, 0.2435) || 挂载数据: 无 ) 
│       │   │   ├── 用IMAP获取和删除电子邮件 --> ( 难度等级: [0.2435, 0.2435) || 挂载数据: 无 ) 
│       │   │   ├── 使用短信电子邮件网关发送短信 --> ( 难度等级: [0.2435, 0.2435) || 挂载数据: 无 ) 
│       │   │   └── 用Twilio发送短信 --> ( 难度等级: [0.2435, 0.2435) || 挂载数据: 无 ) 
│       │   ├── 操作图像 --> ( 难度等级: [0.2435, 0.2436) || 挂载数据: 无 ) 
│       │   │   ├── 计算机图像基础 --> ( 难度等级: [0.2435, 0.2435) || 挂载数据: 无 ) 
│       │   │   ├── 用pillow操作图像 --> ( 难度等级: [0.2435, 0.2435) || 挂载数据: 无 ) 
│       │   │   └── 在图像上绘画 --> ( 难度等级: [0.2435, 0.2436) || 挂载数据: qa: 3 ) 
│       │   │       ├── 绘制形状 --> ( 难度等级: [0.2435, 0.2436) || 挂载数据: 无 ) 
│       │   │       └── 绘制文本 --> ( 难度等级: [0.2436, 0.2436) || 挂载数据: 无 ) 
│       │   └── 用GUI自动化控制键盘和鼠标 --> ( 难度等级: [0.2436, 0.2436) || 挂载数据: 无 ) 
│       │       ├── 安装pyautogui模块 --> ( 难度等级: [0.2436, 0.2436) || 挂载数据: 无 ) 
│       │       ├── 在macOS上设置无障碍应用程序 --> ( 难度等级: [0.2436, 0.2436) || 挂载数据: 无 ) 
│       │       ├── 走对路 --> ( 难度等级: [0.2436, 0.2436) || 挂载数据: 无 ) 
│       │       ├── 控制鼠标指针移动 --> ( 难度等级: [0.2436, 0.2436) || 挂载数据: 无 ) 
│       │       ├── 控制鼠标交互 --> ( 难度等级: [0.2436, 0.2436) || 挂载数据: qa: 2 ) 
│       │       ├── 规划鼠标运动 --> ( 难度等级: [0.2436, 0.2436) || 挂载数据: 无 ) 
│       │       ├── 处理屏幕 --> ( 难度等级: [0.2436, 0.2436) || 挂载数据: qa: 2 ) 
│       │       ├── 图像识别 --> ( 难度等级: [0.2436, 0.2436) || 挂载数据: qa: 1 ) 
│       │       ├── 获取窗口信息 --> ( 难度等级: [0.2436, 0.2436) || 挂载数据: qa: 4 ) 
│       │       ├── 控制键盘 --> ( 难度等级: [0.2436, 0.2436) || 挂载数据: qa: 4 ) 
│       │       ├── 设置GUI自动化脚本 --> ( 难度等级: [0.2436, 0.2436) || 挂载数据: qa: 2 ) 
│       │       ├── 复习PyAutoGUI的函数 --> ( 难度等级: [0.2436, 0.2436) || 挂载数据: 无 ) 
│       │       └── 显示消息框 --> ( 难度等级: [0.2436, 0.2436) || 挂载数据: qa: 1 ) 
│       ├── 序幕 --> ( 难度等级: [0.2436, 0.2441) || 挂载数据: 无 ) 
│       │   └── Python数据模型 --> ( 难度等级: [0.2436, 0.2441) || 挂载数据: 无 ) 
│       │       ├── 一摞Python风格的纸牌 --> ( 难度等级: [0.2436, 0.2439) || 挂载数据: 无 ) 
│       │       └── 特殊方法一览 --> ( 难度等级: [0.2439, 0.2441) || 挂载数据: 无 ) 
│       ├── 把函数视作对象 --> ( 难度等级: [0.2441, 0.2447) || 挂载数据: 无 ) 
│       │   └── 使用一等函数实现设计模式 --> ( 难度等级: [0.2441, 0.2447) || 挂载数据: 无 ) 
│       │       ├── 案例分析：重构“策略”模式 --> ( 难度等级: [0.2441, 0.2444) || 挂载数据: 无 ) 
│       │       └── “命令”模式 --> ( 难度等级: [0.2444, 0.2447) || 挂载数据: qa: 2 ) 
│       ├── 面向对象惯用法 --> ( 难度等级: [0.2447, 0.2452) || 挂载数据: qa: 1 ) 
│       │   ├── 对象引用、可变性和垃圾回收 --> ( 难度等级: [0.2447, 0.2448) || 挂载数据: 无 ) 
│       │   │   ├── 变量不是盒子 --> ( 难度等级: [0.2447, 0.2447) || 挂载数据: 无 ) 
│       │   │   ├── 标识、相等性和别名 --> ( 难度等级: [0.2447, 0.2447) || 挂载数据: 无 ) 
│       │   │   ├── 默认做浅复制 --> ( 难度等级: [0.2447, 0.2447) || 挂载数据: 无 ) 
│       │   │   ├── 函数的参数作为引用时 --> ( 难度等级: [0.2447, 0.2448) || 挂载数据: qa: 2 ) 
│       │   │   ├── del和垃圾回收 --> ( 难度等级: [0.2448, 0.2448) || 挂载数据: 无 ) 
│       │   │   └── Python对不可变类型施加的把戏 --> ( 难度等级: [0.2448, 0.2448) || 挂载数据: 无 ) 
│       │   ├── 符合Python风格的对象 --> ( 难度等级: [0.2448, 0.2449) || 挂载数据: qa: 1 ) 
│       │   │   ├── 对象表示形式 --> ( 难度等级: [0.2448, 0.2448) || 挂载数据: qa: 1 ) 
│       │   │   ├── 再谈向量类 --> ( 难度等级: [0.2448, 0.2448) || 挂载数据: 无 ) 
│       │   │   ├── 备选构造方法 --> ( 难度等级: [0.2448, 0.2449) || 挂载数据: 无 ) 
│       │   │   ├── classmethod与staticmethod --> ( 难度等级: [0.2449, 0.2449) || 挂载数据: 无 ) 
│       │   │   ├── 格式化显示 --> ( 难度等级: [0.2449, 0.2449) || 挂载数据: 无 ) 
│       │   │   ├── 可散列的Vector2d --> ( 难度等级: [0.2449, 0.2449) || 挂载数据: 无 ) 
│       │   │   ├── Python的私有属性和“受保护的”属性 --> ( 难度等级: [0.2449, 0.2449) || 挂载数据: 无 ) 
│       │   │   ├── 使用__slots__类属性节省空间 --> ( 难度等级: [0.2449, 0.2449) || 挂载数据: 无 ) 
│       │   │   └── 覆盖类属性 --> ( 难度等级: [0.2449, 0.2449) || 挂载数据: 无 ) 
│       │   ├── 继承的优缺点 --> ( 难度等级: [0.2449, 0.2451) || 挂载数据: 无 ) 
│       │   │   ├── 子类化内置类型很麻烦 --> ( 难度等级: [0.2449, 0.245) || 挂载数据: 无 ) 
│       │   │   ├── 多重继承的真实应用 --> ( 难度等级: [0.245, 0.245) || 挂载数据: 无 ) 
│       │   │   └── 一个现代示例：Django通用视图中的混入 --> ( 难度等级: [0.245, 0.2451) || 挂载数据: 无 ) 
│       │   └── 正确重载运算符 --> ( 难度等级: [0.2451, 0.2452) || 挂载数据: 无 ) 
│       │       ├── 运算符重载基础 --> ( 难度等级: [0.2451, 0.2451) || 挂载数据: 无 ) 
│       │       ├── 重载向量加法运算符 + --> ( 难度等级: [0.2451, 0.2451) || 挂载数据: 无 ) 
│       │       ├── 重载标量乘法运算符 * --> ( 难度等级: [0.2451, 0.2452) || 挂载数据: 无 ) 
│       │       ├── 众多比较运算符 --> ( 难度等级: [0.2452, 0.2452) || 挂载数据: 无 ) 
│       │       └── 增量赋值运算符 --> ( 难度等级: [0.2452, 0.2452) || 挂载数据: 无 ) 
│       ├── 控制流程 --> ( 难度等级: [0.2452, 0.2457) || 挂载数据: 无 ) 
│       │   ├── 使用期物处理并发 --> ( 难度等级: [0.2452, 0.2455) || 挂载数据: 无 ) 
│       │   │   ├── 阻塞型I/O和GIL --> ( 难度等级: [0.2452, 0.2453) || 挂载数据: 无 ) 
│       │   │   ├── 使用concurrent.futures模块启动进程 --> ( 难度等级: [0.2453, 0.2453) || 挂载数据: 无 ) 
│       │   │   ├── 实验Executor.map方法 --> ( 难度等级: [0.2453, 0.2454) || 挂载数据: qa: 3 ) 
│       │   │   └── 显示下载进度并处理错误 --> ( 难度等级: [0.2454, 0.2455) || 挂载数据: 无 ) 
│       │   └── 使用asyncio包处理并发 --> ( 难度等级: [0.2455, 0.2457) || 挂载数据: 无 ) 
│       │       ├── 避免阻塞型调用 --> ( 难度等级: [0.2455, 0.2456) || 挂载数据: 无 ) 
│       │       ├── 改进asyncio下载脚本 --> ( 难度等级: [0.2456, 0.2457) || 挂载数据: 无 ) 
│       │       └── 使用asyncio包编写服务器 --> ( 难度等级: [0.2457, 0.2457) || 挂载数据: 无 ) 
│       ├── 元编程 --> ( 难度等级: [0.2457, 0.2463) || 挂载数据: qa: 3 ) 
│       │   ├── 动态属性和特性 --> ( 难度等级: [0.2457, 0.2458) || 挂载数据: 无 ) 
│       │   │   ├── 使用动态属性转换数据 --> ( 难度等级: [0.2457, 0.2457) || 挂载数据: 无 ) 
│       │   │   ├── 使用特性验证属性 --> ( 难度等级: [0.2457, 0.2458) || 挂载数据: 无 ) 
│       │   │   ├── 特性全解析 --> ( 难度等级: [0.2458, 0.2458) || 挂载数据: 无 ) 
│       │   │   ├── 定义一个特性工厂函数 --> ( 难度等级: [0.2458, 0.2458) || 挂载数据: 无 ) 
│       │   │   └── 处理属性删除操作 --> ( 难度等级: [0.2458, 0.2458) || 挂载数据: 无 ) 
│       │   ├── 属性描述符 --> ( 难度等级: [0.2458, 0.2458) || 挂载数据: 无 ) 
│       │   │   ├── 描述符示例：验证属性 --> ( 难度等级: [0.2458, 0.2458) || 挂载数据: 无 ) 
│       │   │   ├── 覆盖型与非覆盖型描述符对比 --> ( 难度等级: [0.2458, 0.2458) || 挂载数据: qa: 1 ) 
│       │   │   ├── 方法是描述符 --> ( 难度等级: [0.2458, 0.2458) || 挂载数据: 无 ) 
│       │   │   ├── 描述符用法建议 --> ( 难度等级: [0.2458, 0.2458) || 挂载数据: 无 ) 
│       │   │   └── 描述符的文档字符串和覆盖删除操作 --> ( 难度等级: [0.2458, 0.2458) || 挂载数据: 无 ) 
│       │   ├── 类元编程 --> ( 难度等级: [0.2458, 0.2458) || 挂载数据: 无 ) 
│       │   │   ├── 类工厂函数 --> ( 难度等级: [0.2458, 0.2458) || 挂载数据: 无 ) 
│       │   │   ├── 定制描述符的类装饰器 --> ( 难度等级: [0.2458, 0.2458) || 挂载数据: 无 ) 
│       │   │   ├── 导入时和运行时比较 --> ( 难度等级: [0.2458, 0.2458) || 挂载数据: 无 ) 
│       │   │   ├── 元类基础知识 --> ( 难度等级: [0.2458, 0.2458) || 挂载数据: 无 ) 
│       │   │   ├── 定制描述符的元类 --> ( 难度等级: [0.2458, 0.2458) || 挂载数据: 无 ) 
│       │   │   └── 元类的特殊方法__prepare__ --> ( 难度等级: [0.2458, 0.2458) || 挂载数据: qa: 1 ) 
│       │   ├── 给函数添加一个包装 --> ( 难度等级: [0.2458, 0.2458) || 挂载数据: 无 ) 
│       │   ├── 编写装饰器时如何保存函数的元数据 --> ( 难度等级: [0.2458, 0.2458) || 挂载数据: 无 ) 
│       │   ├── 对装饰器进行解包装 --> ( 难度等级: [0.2458, 0.2459) || 挂载数据: qa: 6 ) 
│       │   ├── 定义一个可接受参数的装饰器 --> ( 难度等级: [0.2459, 0.2459) || 挂载数据: 无 ) 
│       │   ├── 定义一个属性可由用户修改的装饰器 --> ( 难度等级: [0.2459, 0.2459) || 挂载数据: 无 ) 
│       │   ├── 定义一个能接收可选参数的装饰器 --> ( 难度等级: [0.2459, 0.2459) || 挂载数据: 无 ) 
│       │   ├── 利用装饰器对函数参数强制执行类型检查 --> ( 难度等级: [0.2459, 0.2459) || 挂载数据: 无 ) 
│       │   ├── 在类中定义装饰器 --> ( 难度等级: [0.2459, 0.246) || 挂载数据: 无 ) 
│       │   ├── 把装饰器定义成类 --> ( 难度等级: [0.246, 0.246) || 挂载数据: 无 ) 
│       │   ├── 把装饰器作用到类和静态方法上 --> ( 难度等级: [0.246, 0.246) || 挂载数据: 无 ) 
│       │   ├── 编写装饰器为被包装的函数添加参数 --> ( 难度等级: [0.246, 0.246) || 挂载数据: 无 ) 
│       │   ├── 利用装饰器给类定义打补丁 --> ( 难度等级: [0.246, 0.246) || 挂载数据: 无 ) 
│       │   ├── 获取类属性的定义顺序 --> ( 难度等级: [0.246, 0.2461) || 挂载数据: 无 ) 
│       │   ├── 定义一个能接受可选参数的元类 --> ( 难度等级: [0.2461, 0.2461) || 挂载数据: 无 ) 
│       │   ├── 在*args和**kwargs上强制规定一种参数签名 --> ( 难度等级: [0.2461, 0.2461) || 挂载数据: qa: 1 ) 
│       │   ├── 在类中强制规定编码约定 --> ( 难度等级: [0.2461, 0.2461) || 挂载数据: 无 ) 
│       │   ├── 通过编程的方式来定义类 --> ( 难度等级: [0.2461, 0.2461) || 挂载数据: 无 ) 
│       │   ├── 在定义的时候初始化类成员 --> ( 难度等级: [0.2461, 0.2462) || 挂载数据: 无 ) 
│       │   ├── 通过函数注解来实现方法重载 --> ( 难度等级: [0.2462, 0.2462) || 挂载数据: 无 ) 
│       │   ├── 避免出现重复的属性方法 --> ( 难度等级: [0.2462, 0.2462) || 挂载数据: 无 ) 
│       │   ├── 以简单的方式定义上下文管理器 --> ( 难度等级: [0.2462, 0.2462) || 挂载数据: 无 ) 
│       │   ├── 执行带有局部副作用的代码 --> ( 难度等级: [0.2462, 0.2462) || 挂载数据: 无 ) 
│       │   ├── 解析并分析Python源代码 --> ( 难度等级: [0.2462, 0.2463) || 挂载数据: 无 ) 
│       │   └── 将Python源码分解为字节码 --> ( 难度等级: [0.2463, 0.2463) || 挂载数据: 无 ) 
│       ├── 数据编码与处理 --> ( 难度等级: [0.2463, 0.2468) || 挂载数据: 无 ) 
│       │   ├── 读写CSV数据 --> ( 难度等级: [0.2463, 0.2463) || 挂载数据: 无 ) 
│       │   ├── 读写JSON数据 --> ( 难度等级: [0.2463, 0.2464) || 挂载数据: 无 ) 
│       │   ├── 解析简单的XML文档 --> ( 难度等级: [0.2464, 0.2464) || 挂载数据: 无 ) 
│       │   ├── 以增量方式解析大型XML文件 --> ( 难度等级: [0.2464, 0.2465) || 挂载数据: 无 ) 
│       │   ├── 将字典转换为XML --> ( 难度等级: [0.2465, 0.2465) || 挂载数据: 无 ) 
│       │   ├── 用命名空间来解析XML文档 --> ( 难度等级: [0.2465, 0.2466) || 挂载数据: 无 ) 
│       │   ├── 同关系型数据库进行交互 --> ( 难度等级: [0.2466, 0.2466) || 挂载数据: 无 ) 
│       │   ├── 编码和解码十六进制数字 --> ( 难度等级: [0.2466, 0.2467) || 挂载数据: qa: 1 ) 
│       │   ├── 读写二进制结构的数组 --> ( 难度等级: [0.2467, 0.2467) || 挂载数据: 无 ) 
│       │   ├── 读取嵌套型和大小可变的二进制结构 --> ( 难度等级: [0.2467, 0.2468) || 挂载数据: 无 ) 
│       │   └── 数据汇总和统计 --> ( 难度等级: [0.2468, 0.2468) || 挂载数据: 无 ) 
│       ├── 并发 --> ( 难度等级: [0.2468, 0.2473) || 挂载数据: qa: 1 ) 
│       │   ├── 启动和停止线程 --> ( 难度等级: [0.2468, 0.2468) || 挂载数据: 无 ) 
│       │   ├── 判断线程是否已经启动 --> ( 难度等级: [0.2468, 0.2469) || 挂载数据: 无 ) 
│       │   ├── 线程间通信 --> ( 难度等级: [0.2469, 0.2469) || 挂载数据: 无 ) 
│       │   ├── 对临界区加锁 --> ( 难度等级: [0.2469, 0.247) || 挂载数据: 无 ) 
│       │   ├── 避免死锁 --> ( 难度等级: [0.247, 0.247) || 挂载数据: 无 ) 
│       │   ├── 保存线程专有状态 --> ( 难度等级: [0.247, 0.247) || 挂载数据: 无 ) 
│       │   ├── 创建线程池 --> ( 难度等级: [0.247, 0.2471) || 挂载数据: 无 ) 
│       │   ├── 实现简单的并行编程 --> ( 难度等级: [0.2471, 0.2471) || 挂载数据: 无 ) 
│       │   ├── 如何规避GIL带来的限制 --> ( 难度等级: [0.2471, 0.2472) || 挂载数据: 无 ) 
│       │   ├── 定义一个Actor任务 --> ( 难度等级: [0.2472, 0.2472) || 挂载数据: 无 ) 
│       │   ├── 实现发布者/订阅者消息模式 --> ( 难度等级: [0.2472, 0.2472) || 挂载数据: 无 ) 
│       │   ├── 使用生成器作为线程的替代方案 --> ( 难度等级: [0.2472, 0.2473) || 挂载数据: 无 ) 
│       │   ├── 轮询多个线程队列 --> ( 难度等级: [0.2473, 0.2473) || 挂载数据: 无 ) 
│       │   └── 在UNIX上加载守护进程 --> ( 难度等级: [0.2473, 0.2473) || 挂载数据: 无 ) 
│       ├── 实用脚本和系统管理 --> ( 难度等级: [0.2473, 0.2479) || 挂载数据: qa: 1 ) 
│       │   ├── 通过重定向、管道或输入文件来作为脚本的输入 --> ( 难度等级: [0.2473, 0.2474) || 挂载数据: 无 ) 
│       │   ├── 终止程序并显示错误信息 --> ( 难度等级: [0.2474, 0.2474) || 挂载数据: 无 ) 
│       │   ├── 解析命令行选项 --> ( 难度等级: [0.2474, 0.2475) || 挂载数据: 无 ) 
│       │   ├── 在运行时提供密码输入提示 --> ( 难度等级: [0.2475, 0.2475) || 挂载数据: 无 ) 
│       │   ├── 获取终端大小 --> ( 难度等级: [0.2475, 0.2475) || 挂载数据: qa: 1 ) 
│       │   ├── 执行外部命令并获取输出 --> ( 难度等级: [0.2475, 0.2476) || 挂载数据: 无 ) 
│       │   ├── 创建和解包归档文件 --> ( 难度等级: [0.2476, 0.2476) || 挂载数据: 无 ) 
│       │   ├── 通过名称来查找文件 --> ( 难度等级: [0.2476, 0.2476) || 挂载数据: 无 ) 
│       │   ├── 读取配置文件 --> ( 难度等级: [0.2476, 0.2477) || 挂载数据: 无 ) 
│       │   ├── 给脚本添加日志记录 --> ( 难度等级: [0.2477, 0.2477) || 挂载数据: 无 ) 
│       │   ├── 给库添加日志记录 --> ( 难度等级: [0.2477, 0.2478) || 挂载数据: 无 ) 
│       │   ├── 创建一个秒表计时器 --> ( 难度等级: [0.2478, 0.2478) || 挂载数据: 无 ) 
│       │   ├── 给内存和CPU使用量设定限制 --> ( 难度等级: [0.2478, 0.2478) || 挂载数据: 无 ) 
│       │   └── 加载Web浏览器 --> ( 难度等级: [0.2478, 0.2479) || 挂载数据: 无 ) 
│       ├── C语言扩展 --> ( 难度等级: [0.2479, 0.2484) || 挂载数据: 无 ) 
│       │   ├── 利用ctypes来访问C代码 --> ( 难度等级: [0.2479, 0.2479) || 挂载数据: qa: 2 ) 
│       │   ├── 编写简单的C语言扩展模块 --> ( 难度等级: [0.2479, 0.2479) || 挂载数据: 无 ) 
│       │   ├── 编写一个可操作数组的扩展函数 --> ( 难度等级: [0.2479, 0.2479) || 挂载数据: 无 ) 
│       │   ├── 在C扩展模块中管理不透明指针 --> ( 难度等级: [0.2479, 0.248) || 挂载数据: 无 ) 
│       │   ├── 在扩展模块中定义并导出C API --> ( 难度等级: [0.248, 0.248) || 挂载数据: 无 ) 
│       │   ├── 从C中调用Python --> ( 难度等级: [0.248, 0.248) || 挂载数据: qa: 1 ) 
│       │   ├── 在C扩展模块中释放GIL --> ( 难度等级: [0.248, 0.248) || 挂载数据: 无 ) 
│       │   ├── 混合使用C和Python环境中的线程 --> ( 难度等级: [0.248, 0.2481) || 挂载数据: 无 ) 
│       │   ├── 用Swig来包装C代码 --> ( 难度等级: [0.2481, 0.2481) || 挂载数据: 无 ) 
│       │   ├── 用Cython来包装C代码 --> ( 难度等级: [0.2481, 0.2481) || 挂载数据: 无 ) 
│       │   ├── 用Cython来高效操作数组 --> ( 难度等级: [0.2481, 0.2482) || 挂载数据: 无 ) 
│       │   ├── 把函数指针转换为可调用对象 --> ( 难度等级: [0.2482, 0.2482) || 挂载数据: 无 ) 
│       │   ├── 把以NULL结尾的字符串传给C库 --> ( 难度等级: [0.2482, 0.2482) || 挂载数据: 无 ) 
│       │   ├── 把Unicode字符串传递给C库 --> ( 难度等级: [0.2482, 0.2482) || 挂载数据: 无 ) 
│       │   ├── 把C字符串转换到Python中 --> ( 难度等级: [0.2482, 0.2483) || 挂载数据: 无 ) 
│       │   ├── 同编码方式不确定的C字符串打交道 --> ( 难度等级: [0.2483, 0.2483) || 挂载数据: 无 ) 
│       │   ├── 把文件名传给C扩展模块 --> ( 难度等级: [0.2483, 0.2483) || 挂载数据: 无 ) 
│       │   ├── 把打开的文件传给C扩展模块 --> ( 难度等级: [0.2483, 0.2483) || 挂载数据: 无 ) 
│       │   ├── 在C中读取文件型对象 --> ( 难度等级: [0.2483, 0.2484) || 挂载数据: 无 ) 
│       │   ├── 从C中访问可迭代对象 --> ( 难度等级: [0.2484, 0.2484) || 挂载数据: 无 ) 
│       │   └── 排查段错误 --> ( 难度等级: [0.2484, 0.2484) || 挂载数据: qa: 9 ) 
│       ├── 初识Python --> ( 难度等级: [0.2484, 0.2489) || 挂载数据: 无 ) 
│       │   ├── 搭建Python开发环境 --> ( 难度等级: [0.2484, 0.2487) || 挂载数据: 无 ) 
│       │   │   ├── 开发环境概述 --> ( 难度等级: [0.2484, 0.2485) || 挂载数据: qa: 6 ) 
│       │   │   └── 运行已经编写好的.py文件 --> ( 难度等级: [0.2485, 0.2487) || 挂载数据: qa: 5 ) 
│       │   └── Python开发工具 --> ( 难度等级: [0.2487, 0.2489) || 挂载数据: 无 ) 
│       │       └── 使用自带的IDLE --> ( 难度等级: [0.2487, 0.2489) || 挂载数据: 无 ) 
│       ├── Python语言基础 --> ( 难度等级: [0.2489, 0.2495) || 挂载数据: 无 ) 
│       │   ├── Python语法特点 --> ( 难度等级: [0.2489, 0.2491) || 挂载数据: 无 ) 
│       │   │   └── 注释规则 --> ( 难度等级: [0.2489, 0.2491) || 挂载数据: 无 ) 
│       │   ├── Python中的变量 --> ( 难度等级: [0.2491, 0.2493) || 挂载数据: 无 ) 
│       │   │   ├── 理解Python中的变量 --> ( 难度等级: [0.2491, 0.2492) || 挂载数据: 无 ) 
│       │   │   └── 定义变量 --> ( 难度等级: [0.2492, 0.2493) || 挂载数据: qa: 2 ) 
│       │   └── 基本数据类型 --> ( 难度等级: [0.2493, 0.2495) || 挂载数据: 无 ) 
│       │       ├── 布尔类型 --> ( 难度等级: [0.2493, 0.2494) || 挂载数据: 无 ) 
│       │       └── 数据类型转换 --> ( 难度等级: [0.2494, 0.2495) || 挂载数据: qa: 2 ) 
│       └── 流程控制语句 --> ( 难度等级: [0.2495, 0.25) || 挂载数据: 无 ) 
│           ├── 程序结构 --> ( 难度等级: [0.2495, 0.2496) || 挂载数据: 无 ) 
│           ├── 选择语句 --> ( 难度等级: [0.2496, 0.2498) || 挂载数据: 无 ) 
│           │   ├── if…else语句 --> ( 难度等级: [0.2496, 0.2497) || 挂载数据: qa: 3 ) 
│           │   ├── if…elif…else语句 --> ( 难度等级: [0.2497, 0.2498) || 挂载数据: qa: 1 ) 
│           │   └── if语句的嵌套 --> ( 难度等级: [0.2498, 0.2498) || 挂载数据: qa: 2 ) 
│           └── 循环语句 --> ( 难度等级: [0.2498, 0.25) || 挂载数据: 无 ) 
│               └── 循环嵌套 --> ( 难度等级: [0.2498, 0.25) || 挂载数据: qa: 10 ) 
├── Python中阶 --> ( 难度等级: [0.25, 0.5) || 挂载数据: 无 ) 
│   ├── 基本技能 --> ( 难度等级: [0.25, 0.3) || 挂载数据: 无 ) 
│   │   ├── 时间日期处理 --> ( 难度等级: [0.25, 0.2562) || 挂载数据: 无 ) 
│   │   │   ├── time --> ( 难度等级: [0.25, 0.2531) || 挂载数据: qa: 1 ) 
│   │   │   └── datetime --> ( 难度等级: [0.2531, 0.2562) || 挂载数据: qa: 1 ) 
│   │   ├── 数据文件读写 --> ( 难度等级: [0.2562, 0.2625) || 挂载数据: 无 ) 
│   │   │   └── excel/csv/hdf/netCDF --> ( 难度等级: [0.2562, 0.2625) || 挂载数据: 无 ) 
│   │   ├── 数据库操作 --> ( 难度等级: [0.2625, 0.2687) || 挂载数据: 无 ) 
│   │   │   ├── 数据库概述 --> ( 难度等级: [0.2625, 0.2634) || 挂载数据: 无 ) 
│   │   │   ├── 数据库安装配置 --> ( 难度等级: [0.2634, 0.2643) || 挂载数据: 无 ) 
│   │   │   ├── SQL语句 --> ( 难度等级: [0.2643, 0.2652) || 挂载数据: qa: 4 ) 
│   │   │   ├── SQLite --> ( 难度等级: [0.2652, 0.2661) || 挂载数据: 无 ) 
│   │   │   │   ├── 创建数据库文件 --> ( 难度等级: [0.2652, 0.2656) || 挂载数据: 无 ) 
│   │   │   │   └── 操作SQLite --> ( 难度等级: [0.2656, 0.2661) || 挂载数据: qa: 2 ) 
│   │   │   ├── MySQL --> ( 难度等级: [0.2661, 0.267) || 挂载数据: 无 ) 
│   │   │   │   ├── 下载安装MySQL --> ( 难度等级: [0.2661, 0.2663) || 挂载数据: qa: 10 ) 
│   │   │   │   ├── 连接数据库 --> ( 难度等级: [0.2663, 0.2665) || 挂载数据: qa: 2 ) 
│   │   │   │   ├── 创建数据表 --> ( 难度等级: [0.2665, 0.2667) || 挂载数据: 无 ) 
│   │   │   │   └── 操作MySQL数据表 --> ( 难度等级: [0.2667, 0.267) || 挂载数据: qa: 1 ) 
│   │   │   ├── MongoDB --> ( 难度等级: [0.267, 0.2679) || 挂载数据: qa: 2 ) 
│   │   │   └── 数据库编程接口 --> ( 难度等级: [0.2679, 0.2687) || 挂载数据: 无 ) 
│   │   │       ├── 连接对象 --> ( 难度等级: [0.2679, 0.2683) || 挂载数据: 无 ) 
│   │   │       └── 游标对象 --> ( 难度等级: [0.2683, 0.2687) || 挂载数据: 无 ) 
│   │   ├── 操作系统和环境 --> ( 难度等级: [0.2687, 0.275) || 挂载数据: 无 ) 
│   │   │   └── OS/Sys --> ( 难度等级: [0.2687, 0.275) || 挂载数据: 无 ) 
│   │   ├── 线程进程和协程 --> ( 难度等级: [0.275, 0.2812) || 挂载数据: 无 ) 
│   │   │   ├── 基础概念 --> ( 难度等级: [0.275, 0.276) || 挂载数据: 无 ) 
│   │   │   ├── 加锁和解锁 --> ( 难度等级: [0.276, 0.2771) || 挂载数据: 无 ) 
│   │   │   ├── threading --> ( 难度等级: [0.2771, 0.2781) || 挂载数据: 无 ) 
│   │   │   ├── multiprocessing --> ( 难度等级: [0.2781, 0.2792) || 挂载数据: qa: 1 ) 
│   │   │   ├── queue --> ( 难度等级: [0.2792, 0.2802) || 挂载数据: qa: 1 ) 
│   │   │   └── gevent --> ( 难度等级: [0.2802, 0.2812) || 挂载数据: 无 ) 
│   │   ├── 源码打包 --> ( 难度等级: [0.2812, 0.2875) || 挂载数据: 无 ) 
│   │   │   └── pyinstaller --> ( 难度等级: [0.2812, 0.2875) || 挂载数据: 无 ) 
│   │   ├── 网络编程 --> ( 难度等级: [0.2875, 0.2938) || 挂载数据: 无 ) 
│   │   │   ├── socket --> ( 难度等级: [0.2875, 0.2878) || 挂载数据: qa: 7 ) 
│   │   │   ├── 与HTTP服务交互 --> ( 难度等级: [0.2878, 0.2882) || 挂载数据: 无 ) 
│   │   │   ├── 创建服务器 --> ( 难度等级: [0.2882, 0.2885) || 挂载数据: 无 ) 
│   │   │   │   ├── TCP服务器 --> ( 难度等级: [0.2882, 0.2884) || 挂载数据: qa: 7 ) 
│   │   │   │   └── UDP服务器 --> ( 难度等级: [0.2884, 0.2885) || 挂载数据: 无 ) 
│   │   │   ├── 通过CIDR地址生成对应的IP地址集 --> ( 难度等级: [0.2885, 0.2889) || 挂载数据: 无 ) 
│   │   │   ├── REST接口创建 --> ( 难度等级: [0.2889, 0.2892) || 挂载数据: 无 ) 
│   │   │   ├── 远程调用 --> ( 难度等级: [0.2892, 0.2896) || 挂载数据: 无 ) 
│   │   │   │   ├── 远程方法调用 --> ( 难度等级: [0.2892, 0.2894) || 挂载数据: qa: 10 ) 
│   │   │   │   └── 通过XML-RPC远程调用 --> ( 难度等级: [0.2894, 0.2896) || 挂载数据: 无 ) 
│   │   │   ├── 不同Python解释器之间的交互 --> ( 难度等级: [0.2896, 0.2899) || 挂载数据: 无 ) 
│   │   │   ├── 客户端认证 --> ( 难度等级: [0.2899, 0.2903) || 挂载数据: 无 ) 
│   │   │   ├── Socket文件描述符传递 --> ( 难度等级: [0.2903, 0.2906) || 挂载数据: 无 ) 
│   │   │   ├── 事件驱动的I/O --> ( 难度等级: [0.2906, 0.291) || 挂载数据: 无 ) 
│   │   │   ├── 大型数组发送与接收 --> ( 难度等级: [0.291, 0.2913) || 挂载数据: 无 ) 
│   │   │   ├── 简介 --> ( 难度等级: [0.2913, 0.2917) || 挂载数据: 无 ) 
│   │   │   │   ├── 客户端/服务端架构 --> ( 难度等级: [0.2913, 0.2914) || 挂载数据: 无 ) 
│   │   │   │   ├── 持久化存储 --> ( 难度等级: [0.2914, 0.2915) || 挂载数据: 无 ) 
│   │   │   │   ├── 数据库基本操作和SQL --> ( 难度等级: [0.2915, 0.2915) || 挂载数据: 无 ) 
│   │   │   │   ├── Web应用：客户端/服务器计算 --> ( 难度等级: [0.2915, 0.2916) || 挂载数据: 无 ) 
│   │   │   │   └── 因特网 --> ( 难度等级: [0.2916, 0.2917) || 挂载数据: 无 ) 
│   │   │   ├── 客户端/服务器架构 --> ( 难度等级: [0.2917, 0.292) || 挂载数据: 无 ) 
│   │   │   │   ├── 硬件客户端/服务器架构 --> ( 难度等级: [0.2917, 0.2918) || 挂载数据: 无 ) 
│   │   │   │   ├── 软件客户端/服务器架构 --> ( 难度等级: [0.2918, 0.2918) || 挂载数据: 无 ) 
│   │   │   │   ├── 银行出纳员作为服务器吗 --> ( 难度等级: [0.2918, 0.2919) || 挂载数据: 无 ) 
│   │   │   │   └── 客户端/服务器网络编程 --> ( 难度等级: [0.2919, 0.292) || 挂载数据: 无 ) 
│   │   │   ├── 套接字：通信端点 --> ( 难度等级: [0.292, 0.2924) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 套接字 --> ( 难度等级: [0.292, 0.2921) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 套接字地址：主机-端口对 --> ( 难度等级: [0.2921, 0.2922) || 挂载数据: qa: 1 ) 
│   │   │   │   └── 面向连接的套接字与无连接的套接字 --> ( 难度等级: [0.2922, 0.2924) || 挂载数据: 无 ) 
│   │   │   ├── Python中的网络编程 --> ( 难度等级: [0.2924, 0.2927) || 挂载数据: 无 ) 
│   │   │   │   ├── socket模块函数 --> ( 难度等级: [0.2924, 0.2924) || 挂载数据: 无 ) 
│   │   │   │   ├── 套接字对象（内置）方法 --> ( 难度等级: [0.2924, 0.2924) || 挂载数据: 无 ) 
│   │   │   │   ├── 创建TCP服务器 --> ( 难度等级: [0.2924, 0.2925) || 挂载数据: 无 ) 
│   │   │   │   ├── 创建TCP客户端 --> ( 难度等级: [0.2925, 0.2925) || 挂载数据: 无 ) 
│   │   │   │   ├── 执行TCP服务器和客户端 --> ( 难度等级: [0.2925, 0.2926) || 挂载数据: 无 ) 
│   │   │   │   ├── 创建UDP服务器 --> ( 难度等级: [0.2926, 0.2926) || 挂载数据: 无 ) 
│   │   │   │   ├── 创建UDP客户端 --> ( 难度等级: [0.2926, 0.2926) || 挂载数据: 无 ) 
│   │   │   │   ├── 执行UDP服务器和客户端 --> ( 难度等级: [0.2926, 0.2927) || 挂载数据: 无 ) 
│   │   │   │   └── socket模块属性 --> ( 难度等级: [0.2927, 0.2927) || 挂载数据: 无 ) 
│   │   │   ├── *SocketServer模块 --> ( 难度等级: [0.2927, 0.2931) || 挂载数据: 无 ) 
│   │   │   │   ├── 创建SocketServer TCP服务器 --> ( 难度等级: [0.2927, 0.2929) || 挂载数据: 无 ) 
│   │   │   │   └── 创建SocketServer TCP客户端 --> ( 难度等级: [0.2929, 0.2931) || 挂载数据: 无 ) 
│   │   │   ├── *Twisted框架介绍 --> ( 难度等级: [0.2931, 0.2934) || 挂载数据: 无 ) 
│   │   │   │   ├── 创建Twisted Reactor TCP服务器 --> ( 难度等级: [0.2931, 0.2932) || 挂载数据: 无 ) 
│   │   │   │   └── 创建Twisted Reactor TCP客户端 --> ( 难度等级: [0.2932, 0.2934) || 挂载数据: 无 ) 
│   │   │   └── 相关模块 --> ( 难度等级: [0.2934, 0.2938) || 挂载数据: 无 ) 
│   │   │       └── 其他因特网客户端协议 --> ( 难度等级: [0.2934, 0.2938) || 挂载数据: 无 ) 
│   │   └── 发送邮件 --> ( 难度等级: [0.2938, 0.3) || 挂载数据: qa: 1 ) 
│   │       └── smtplib --> ( 难度等级: [0.2938, 0.3) || 挂载数据: 无 ) 
│   ├── Web应用开发 --> ( 难度等级: [0.3, 0.35) || 挂载数据: 无 ) 
│   │   ├── Web开发基础知识 --> ( 难度等级: [0.3, 0.305) || 挂载数据: 无 ) 
│   │   │   ├── HTML/HTML5/CSS --> ( 难度等级: [0.3, 0.3013) || 挂载数据: 无 ) 
│   │   │   ├── 前端数据库和后台 --> ( 难度等级: [0.3013, 0.3025) || 挂载数据: 无 ) 
│   │   │   ├── MVC架构 --> ( 难度等级: [0.3025, 0.3037) || 挂载数据: 无 ) 
│   │   │   └── REST和Ajax --> ( 难度等级: [0.3037, 0.305) || 挂载数据: 无 ) 
│   │   ├── Django --> ( 难度等级: [0.305, 0.31) || 挂载数据: 无 ) 
│   │   │   ├── Django简介 --> ( 难度等级: [0.305, 0.3052) || 挂载数据: qa: 8 ) 
│   │   │   ├── Django安装配置 --> ( 难度等级: [0.3052, 0.3054) || 挂载数据: 无 ) 
│   │   │   ├── DTL(Django Template Language) --> ( 难度等级: [0.3054, 0.3057) || 挂载数据: 无 ) 
│   │   │   ├── Django路由定义 --> ( 难度等级: [0.3057, 0.3059) || 挂载数据: 无 ) 
│   │   │   ├── Django请求数据解析 --> ( 难度等级: [0.3059, 0.3061) || 挂载数据: qa: 1 ) 
│   │   │   ├── Django数据库操作 --> ( 难度等级: [0.3061, 0.3063) || 挂载数据: qa: 1 ) 
│   │   │   ├── Django提交表单 --> ( 难度等级: [0.3063, 0.3065) || 挂载数据: qa: 1 ) 
│   │   │   ├── Django Rest Framework --> ( 难度等级: [0.3065, 0.3067) || 挂载数据: 无 ) 
│   │   │   ├── 部署日志与安全 --> ( 难度等级: [0.3067, 0.307) || 挂载数据: 无 ) 
│   │   │   ├── Django开发案例 --> ( 难度等级: [0.307, 0.3072) || 挂载数据: qa: 1 ) 
│   │   │   ├── Web框架 --> ( 难度等级: [0.3072, 0.3074) || 挂载数据: 无 ) 
│   │   │   ├── “Hello World”应用（一个博客） --> ( 难度等级: [0.3074, 0.3076) || 挂载数据: qa: 3 ) 
│   │   │   ├── 创建模型来添加数据库服务 --> ( 难度等级: [0.3076, 0.3078) || 挂载数据: 无 ) 
│   │   │   │   └── 设置数据库 --> ( 难度等级: [0.3076, 0.3078) || 挂载数据: 无 ) 
│   │   │   ├── Python应用shell --> ( 难度等级: [0.3078, 0.308) || 挂载数据: 无 ) 
│   │   │   │   ├── 在Django中使用Python shell --> ( 难度等级: [0.3078, 0.3079) || 挂载数据: qa: 9 ) 
│   │   │   │   └── 测试数据模型 --> ( 难度等级: [0.3079, 0.308) || 挂载数据: 无 ) 
│   │   │   ├── Django管理应用 --> ( 难度等级: [0.308, 0.3083) || 挂载数据: 无 ) 
│   │   │   │   ├── 设置admin --> ( 难度等级: [0.308, 0.3082) || 挂载数据: 无 ) 
│   │   │   │   └── 使用admin --> ( 难度等级: [0.3082, 0.3083) || 挂载数据: qa: 1 ) 
│   │   │   ├── 创建博客的用户界面 --> ( 难度等级: [0.3083, 0.3085) || 挂载数据: 无 ) 
│   │   │   │   ├── 创建模板 --> ( 难度等级: [0.3083, 0.3083) || 挂载数据: qa: 6 ) 
│   │   │   │   ├── 创建URL模式 --> ( 难度等级: [0.3083, 0.3084) || 挂载数据: 无 ) 
│   │   │   │   └── 创建视图函数 --> ( 难度等级: [0.3084, 0.3085) || 挂载数据: 无 ) 
│   │   │   ├── 改进输出 --> ( 难度等级: [0.3085, 0.3087) || 挂载数据: 无 ) 
│   │   │   ├── 处理用户输入 --> ( 难度等级: [0.3087, 0.3089) || 挂载数据: 无 ) 
│   │   │   │   ├── 添加URLconf项 --> ( 难度等级: [0.3087, 0.3088) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 视图：处理用户输入 --> ( 难度等级: [0.3088, 0.3088) || 挂载数据: qa: 10 ) 
│   │   │   │   └── 跨站点请求伪造 --> ( 难度等级: [0.3088, 0.3089) || 挂载数据: 无 ) 
│   │   │   ├── 表单和模型表单 --> ( 难度等级: [0.3089, 0.3091) || 挂载数据: 无 ) 
│   │   │   │   ├── Django表单简介 --> ( 难度等级: [0.3089, 0.309) || 挂载数据: 无 ) 
│   │   │   │   ├── 模型表单示例 --> ( 难度等级: [0.309, 0.309) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用ModelForm来生成HTML表单 --> ( 难度等级: [0.309, 0.3091) || 挂载数据: 无 ) 
│   │   │   │   └── 处理ModelForm数据 --> ( 难度等级: [0.3091, 0.3091) || 挂载数据: 无 ) 
│   │   │   ├── 视图进阶 --> ( 难度等级: [0.3091, 0.3093) || 挂载数据: 无 ) 
│   │   │   ├── *改善外观 --> ( 难度等级: [0.3093, 0.3096) || 挂载数据: 无 ) 
│   │   │   ├── *中级Django应用：TweetApprover --> ( 难度等级: [0.3096, 0.3098) || 挂载数据: 无 ) 
│   │   │   │   ├── 安装Twython库 --> ( 难度等级: [0.3096, 0.3096) || 挂载数据: 无 ) 
│   │   │   │   ├── URL结构 --> ( 难度等级: [0.3096, 0.3097) || 挂载数据: qa: 9 ) 
│   │   │   │   ├── 数据模型 --> ( 难度等级: [0.3097, 0.3097) || 挂载数据: 无 ) 
│   │   │   │   ├── 提交新推文以便审核 --> ( 难度等级: [0.3097, 0.3097) || 挂载数据: 无 ) 
│   │   │   │   └── 审核推文 --> ( 难度等级: [0.3097, 0.3098) || 挂载数据: 无 ) 
│   │   │   └── 资源 --> ( 难度等级: [0.3098, 0.31) || 挂载数据: 无 ) 
│   │   ├── Tornado --> ( 难度等级: [0.31, 0.315) || 挂载数据: 无 ) 
│   │   │   ├── Tornado简介 --> ( 难度等级: [0.31, 0.3106) || 挂载数据: 无 ) 
│   │   │   ├── Tornado安装配置 --> ( 难度等级: [0.3106, 0.3111) || 挂载数据: 无 ) 
│   │   │   ├── Tornado提交表单 --> ( 难度等级: [0.3111, 0.3117) || 挂载数据: 无 ) 
│   │   │   ├── Tornado模板 --> ( 难度等级: [0.3117, 0.3122) || 挂载数据: qa: 1 ) 
│   │   │   ├── Tornado数据库操作 --> ( 难度等级: [0.3122, 0.3128) || 挂载数据: 无 ) 
│   │   │   ├── Tornado异步Web服务 --> ( 难度等级: [0.3128, 0.3133) || 挂载数据: 无 ) 
│   │   │   ├── 外部服务认证（auth） --> ( 难度等级: [0.3133, 0.3139) || 挂载数据: 无 ) 
│   │   │   ├── 部署日志与安全 --> ( 难度等级: [0.3139, 0.3144) || 挂载数据: 无 ) 
│   │   │   └── Tornado开发案例 --> ( 难度等级: [0.3144, 0.315) || 挂载数据: 无 ) 
│   │   ├── Flask --> ( 难度等级: [0.315, 0.32) || 挂载数据: 无 ) 
│   │   │   ├── Flask简介 --> ( 难度等级: [0.315, 0.3155) || 挂载数据: 无 ) 
│   │   │   │   ├── 安装 --> ( 难度等级: [0.315, 0.3151) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 创建应用目录 --> ( 难度等级: [0.315, 0.315) || 挂载数据: qa: 8 ) 
│   │   │   │   │   ├── 虚拟环境 --> ( 难度等级: [0.315, 0.315) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 在Python 3中创建虚拟环境 --> ( 难度等级: [0.315, 0.315) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 在Python 2中创建虚拟环境 --> ( 难度等级: [0.315, 0.315) || 挂载数据: qa: 1 ) 
│   │   │   │   │   ├── 使用虚拟环境 --> ( 难度等级: [0.315, 0.3151) || 挂载数据: 无 ) 
│   │   │   │   │   └── 使用pip安装Python包 --> ( 难度等级: [0.3151, 0.3151) || 挂载数据: qa: 10 ) 
│   │   │   │   ├── 应用的基本结构 --> ( 难度等级: [0.3151, 0.3151) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 初始化 --> ( 难度等级: [0.3151, 0.3151) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 路由和视图函数 --> ( 难度等级: [0.3151, 0.3151) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 一个完整的应用 --> ( 难度等级: [0.3151, 0.3151) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Web开发服务器 --> ( 难度等级: [0.3151, 0.3151) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 动态路由 --> ( 难度等级: [0.3151, 0.3151) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 调试模式 --> ( 难度等级: [0.3151, 0.3151) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 命令行选项 --> ( 难度等级: [0.3151, 0.3151) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 请求–响应循环 --> ( 难度等级: [0.3151, 0.3151) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── 应用和请求上下文 --> ( 难度等级: [0.3151, 0.3151) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── 请求分派 --> ( 难度等级: [0.3151, 0.3151) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── 请求对象 --> ( 难度等级: [0.3151, 0.3151) || 挂载数据: 无 ) 
│   │   │   │   │   │   │   ├── 对象显示 --> ( 难度等级: [0.3151, 0.3151) || 挂载数据: qa: 10 ) 
│   │   │   │   │   │   │   ├── 有效创建大量对象 --> ( 难度等级: [0.3151, 0.3151) || 挂载数据: 无 ) 
│   │   │   │   │   │   │   └── 由字符串调用对象 --> ( 难度等级: [0.3151, 0.3151) || 挂载数据: 无 ) 
│   │   │   │   │   │   └── 请求钩子 --> ( 难度等级: [0.3151, 0.3151) || 挂载数据: 无 ) 
│   │   │   │   │   └── Flask扩展 --> ( 难度等级: [0.3151, 0.3151) || 挂载数据: 无 ) 
│   │   │   │   ├── 模板 --> ( 难度等级: [0.3151, 0.3152) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Jinja2模板引擎 --> ( 难度等级: [0.3151, 0.3151) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── 渲染模板 --> ( 难度等级: [0.3151, 0.3151) || 挂载数据: qa: 1 ) 
│   │   │   │   │   │   ├── 变量 --> ( 难度等级: [0.3151, 0.3151) || 挂载数据: 无 ) 
│   │   │   │   │   │   │   ├── 匿名函数捕获变量值 --> ( 难度等级: [0.3151, 0.3151) || 挂载数据: 无 ) 
│   │   │   │   │   │   │   └── 访问闭包中定义的变量 --> ( 难度等级: [0.3151, 0.3151) || 挂载数据: qa: 6 ) 
│   │   │   │   │   │   └── 控制结构 --> ( 难度等级: [0.3151, 0.3151) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 使用Flask-Bootstrap集成Bootstrap --> ( 难度等级: [0.3151, 0.3152) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 自定义错误页面 --> ( 难度等级: [0.3152, 0.3152) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 链接 --> ( 难度等级: [0.3152, 0.3152) || 挂载数据: qa: 2 ) 
│   │   │   │   │   ├── 静态文件 --> ( 难度等级: [0.3152, 0.3152) || 挂载数据: 无 ) 
│   │   │   │   │   └── 使用Flask-Moment本地化日期和时间 --> ( 难度等级: [0.3152, 0.3152) || 挂载数据: 无 ) 
│   │   │   │   ├── Web表单 --> ( 难度等级: [0.3152, 0.3153) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 配置 --> ( 难度等级: [0.3152, 0.3152) || 挂载数据: qa: 1 ) 
│   │   │   │   │   ├── 表单类 --> ( 难度等级: [0.3152, 0.3152) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 把表单渲染成HTML --> ( 难度等级: [0.3152, 0.3152) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 在视图函数中处理表单 --> ( 难度等级: [0.3152, 0.3152) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 重定向和用户会话 --> ( 难度等级: [0.3152, 0.3152) || 挂载数据: qa: 1 ) 
│   │   │   │   │   └── 闪现消息 --> ( 难度等级: [0.3152, 0.3153) || 挂载数据: 无 ) 
│   │   │   │   ├── 数据库 --> ( 难度等级: [0.3153, 0.3153) || 挂载数据: 无 ) 
│   │   │   │   │   ├── SQL数据库 --> ( 难度等级: [0.3153, 0.3153) || 挂载数据: qa: 5 ) 
│   │   │   │   │   ├── NoSQL数据库 --> ( 难度等级: [0.3153, 0.3153) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 使用SQL还是NoSQL --> ( 难度等级: [0.3153, 0.3153) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Python数据库框架 --> ( 难度等级: [0.3153, 0.3153) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 使用Flask-SQLAlchemy管理数据库 --> ( 难度等级: [0.3153, 0.3153) || 挂载数据: qa: 1 ) 
│   │   │   │   │   ├── 定义模型 --> ( 难度等级: [0.3153, 0.3153) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 关系 --> ( 难度等级: [0.3153, 0.3153) || 挂载数据: qa: 2 ) 
│   │   │   │   │   ├── 数据库操作 --> ( 难度等级: [0.3153, 0.3153) || 挂载数据: qa: 1 ) 
│   │   │   │   │   │   ├── 创建表 --> ( 难度等级: [0.3153, 0.3153) || 挂载数据: qa: 1 ) 
│   │   │   │   │   │   ├── 插入行 --> ( 难度等级: [0.3153, 0.3153) || 挂载数据: qa: 1 ) 
│   │   │   │   │   │   ├── 修改行 --> ( 难度等级: [0.3153, 0.3153) || 挂载数据: qa: 7 ) 
│   │   │   │   │   │   ├── 删除行 --> ( 难度等级: [0.3153, 0.3153) || 挂载数据: 无 ) 
│   │   │   │   │   │   └── 查询行 --> ( 难度等级: [0.3153, 0.3153) || 挂载数据: qa: 3 ) 
│   │   │   │   │   ├── 在视图函数中操作数据库 --> ( 难度等级: [0.3153, 0.3153) || 挂载数据: qa: 1 ) 
│   │   │   │   │   ├── 集成Python shell --> ( 难度等级: [0.3153, 0.3153) || 挂载数据: 无 ) 
│   │   │   │   │   └── 使用Flask-Migrate实现数据库迁移 --> ( 难度等级: [0.3153, 0.3153) || 挂载数据: qa: 1 ) 
│   │   │   │   │       ├── 创建迁移仓库 --> ( 难度等级: [0.3153, 0.3153) || 挂载数据: 无 ) 
│   │   │   │   │       ├── 创建迁移脚本 --> ( 难度等级: [0.3153, 0.3153) || 挂载数据: 无 ) 
│   │   │   │   │       ├── 更新数据库 --> ( 难度等级: [0.3153, 0.3153) || 挂载数据: qa: 10 ) 
│   │   │   │   │       └── 添加几个迁移 --> ( 难度等级: [0.3153, 0.3153) || 挂载数据: 无 ) 
│   │   │   │   ├── 电子邮件 --> ( 难度等级: [0.3153, 0.3154) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 电子邮件系统组件和协议 --> ( 难度等级: [0.3153, 0.3153) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 发送电子邮件 --> ( 难度等级: [0.3153, 0.3153) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Python和SMTP --> ( 难度等级: [0.3153, 0.3153) || 挂载数据: 无 ) 
│   │   │   │   │   ├── smtplib.SMTP类方法 --> ( 难度等级: [0.3153, 0.3153) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 交互式SMTP示例 --> ( 难度等级: [0.3153, 0.3153) || 挂载数据: 无 ) 
│   │   │   │   │   ├── SMTP的其他内容 --> ( 难度等级: [0.3153, 0.3154) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 接收电子邮件 --> ( 难度等级: [0.3154, 0.3154) || 挂载数据: 无 ) 
│   │   │   │   │   ├── POP和IMAP --> ( 难度等级: [0.3154, 0.3154) || 挂载数据: qa: 1 ) 
│   │   │   │   │   ├── 交互式POP3示例 --> ( 难度等级: [0.3154, 0.3154) || 挂载数据: 无 ) 
│   │   │   │   │   ├── poplib.POP3类方法 --> ( 难度等级: [0.3154, 0.3154) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 客户端程序SMTP和POP3示例 --> ( 难度等级: [0.3154, 0.3154) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 交互式IMAP4示例 --> ( 难度等级: [0.3154, 0.3154) || 挂载数据: 无 ) 
│   │   │   │   │   └── imaplib.IMAP4类中的常用方法 --> ( 难度等级: [0.3154, 0.3154) || 挂载数据: 无 ) 
│   │   │   │   └── 大型应用的结构 --> ( 难度等级: [0.3154, 0.3155) || 挂载数据: 无 ) 
│   │   │   │       ├── 配置选项 --> ( 难度等级: [0.3154, 0.3154) || 挂载数据: 无 ) 
│   │   │   │       ├── 应用包 --> ( 难度等级: [0.3154, 0.3154) || 挂载数据: 无 ) 
│   │   │   │       │   ├── 使用应用工厂函数 --> ( 难度等级: [0.3154, 0.3154) || 挂载数据: 无 ) 
│   │   │   │       │   └── 在蓝本中实现应用功能 --> ( 难度等级: [0.3154, 0.3154) || 挂载数据: qa: 1 ) 
│   │   │   │       ├── 应用脚本 --> ( 难度等级: [0.3154, 0.3154) || 挂载数据: 无 ) 
│   │   │   │       ├── 需求文件 --> ( 难度等级: [0.3154, 0.3154) || 挂载数据: qa: 1 ) 
│   │   │   │       ├── 单元测试 --> ( 难度等级: [0.3154, 0.3154) || 挂载数据: 无 ) 
│   │   │   │       │   └── blog应用的代码审查 --> ( 难度等级: [0.3154, 0.3154) || 挂载数据: qa: 2 ) 
│   │   │   │       ├── 创建数据库 --> ( 难度等级: [0.3154, 0.3154) || 挂载数据: 无 ) 
│   │   │   │       └── 运行应用 --> ( 难度等级: [0.3154, 0.3155) || 挂载数据: qa: 2 ) 
│   │   │   ├── Flask安装配置 --> ( 难度等级: [0.3155, 0.3159) || 挂载数据: 无 ) 
│   │   │   ├── Flask实现HTTP请求与响应 --> ( 难度等级: [0.3159, 0.3164) || 挂载数据: 无 ) 
│   │   │   ├── Flask cookie与session --> ( 难度等级: [0.3164, 0.3168) || 挂载数据: 无 ) 
│   │   │   ├── Flask模板 --> ( 难度等级: [0.3168, 0.3173) || 挂载数据: 无 ) 
│   │   │   ├── Flask提交表单 --> ( 难度等级: [0.3173, 0.3177) || 挂载数据: 无 ) 
│   │   │   ├── Flask数据库操作 --> ( 难度等级: [0.3177, 0.3182) || 挂载数据: 无 ) 
│   │   │   ├── Bootstrap-Flask --> ( 难度等级: [0.3182, 0.3186) || 挂载数据: 无 ) 
│   │   │   ├── Flask开发REST Web服务 --> ( 难度等级: [0.3186, 0.3191) || 挂载数据: 无 ) 
│   │   │   ├── 部署日志与安全 --> ( 难度等级: [0.3191, 0.3195) || 挂载数据: 无 ) 
│   │   │   └── Flask开发案例 --> ( 难度等级: [0.3195, 0.32) || 挂载数据: 无 ) 
│   │   ├── 网站可视化 --> ( 难度等级: [0.32, 0.325) || 挂载数据: qa: 1 ) 
│   │   │   └── Echarts --> ( 难度等级: [0.32, 0.325) || 挂载数据: 无 ) 
│   │   ├── 网站高并发处理 --> ( 难度等级: [0.325, 0.33) || 挂载数据: 无 ) 
│   │   ├── Web客户端和服务器 --> ( 难度等级: [0.33, 0.335) || 挂载数据: 无 ) 
│   │   │   ├── Python Web客户端工具 --> ( 难度等级: [0.33, 0.3317) || 挂载数据: 无 ) 
│   │   │   │   ├── 统一资源定位符 --> ( 难度等级: [0.33, 0.3303) || 挂载数据: 无 ) 
│   │   │   │   ├── urlparse模块 --> ( 难度等级: [0.3303, 0.3307) || 挂载数据: 无 ) 
│   │   │   │   ├── urllib模块/包 --> ( 难度等级: [0.3307, 0.331) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用urllib2 HTTP验证的示例 --> ( 难度等级: [0.331, 0.3313) || 挂载数据: 无 ) 
│   │   │   │   └── 将HTTP验证示例移植到Python 3中 --> ( 难度等级: [0.3313, 0.3317) || 挂载数据: 无 ) 
│   │   │   ├── Web客户端 --> ( 难度等级: [0.3317, 0.3333) || 挂载数据: 无 ) 
│   │   │   │   ├── 一个简单的Web爬虫/蜘蛛/机器人 --> ( 难度等级: [0.3317, 0.3322) || 挂载数据: 无 ) 
│   │   │   │   ├── 解析Web页面 --> ( 难度等级: [0.3322, 0.3328) || 挂载数据: 无 ) 
│   │   │   │   └── 可编程的Web浏览 --> ( 难度等级: [0.3328, 0.3333) || 挂载数据: qa: 6 ) 
│   │   │   └── Web（HTTP）服务器 --> ( 难度等级: [0.3333, 0.335) || 挂载数据: 无 ) 
│   │   ├── Web编程：CGI和WSGI --> ( 难度等级: [0.335, 0.34) || 挂载数据: 无 ) 
│   │   │   ├── 帮助Web服务器处理客户端数据 --> ( 难度等级: [0.335, 0.3358) || 挂载数据: 无 ) 
│   │   │   │   ├── CGI简介 --> ( 难度等级: [0.335, 0.3352) || 挂载数据: 无 ) 
│   │   │   │   ├── CGI应用程序 --> ( 难度等级: [0.3352, 0.3354) || 挂载数据: 无 ) 
│   │   │   │   ├── cgi模块 --> ( 难度等级: [0.3354, 0.3356) || 挂载数据: 无 ) 
│   │   │   │   └── cgitb模块 --> ( 难度等级: [0.3356, 0.3358) || 挂载数据: 无 ) 
│   │   │   ├── 构建CGI应用程序 --> ( 难度等级: [0.3358, 0.3367) || 挂载数据: 无 ) 
│   │   │   │   ├── 构建Web服务器 --> ( 难度等级: [0.3358, 0.336) || 挂载数据: 无 ) 
│   │   │   │   ├── 建立表单页 --> ( 难度等级: [0.336, 0.3362) || 挂载数据: 无 ) 
│   │   │   │   ├── 生成结果页面 --> ( 难度等级: [0.3362, 0.3363) || 挂载数据: qa: 2 ) 
│   │   │   │   ├── 生成表单和结果页面 --> ( 难度等级: [0.3363, 0.3365) || 挂载数据: 无 ) 
│   │   │   │   └── 全面交互的Web站点 --> ( 难度等级: [0.3365, 0.3367) || 挂载数据: 无 ) 
│   │   │   ├── 在CGI中使用Unicode --> ( 难度等级: [0.3367, 0.3375) || 挂载数据: 无 ) 
│   │   │   ├── 高级CGI --> ( 难度等级: [0.3375, 0.3383) || 挂载数据: 无 ) 
│   │   │   │   ├── mulitipart表单提交和文件上传 --> ( 难度等级: [0.3375, 0.3379) || 挂载数据: 无 ) 
│   │   │   │   └── 多值字段 --> ( 难度等级: [0.3379, 0.3383) || 挂载数据: 无 ) 
│   │   │   ├── WSGI简介 --> ( 难度等级: [0.3383, 0.3392) || 挂载数据: 无 ) 
│   │   │   │   ├── 动机（替代CGI） --> ( 难度等级: [0.3383, 0.3384) || 挂载数据: 无 ) 
│   │   │   │   ├── 服务器集成 --> ( 难度等级: [0.3384, 0.3385) || 挂载数据: 无 ) 
│   │   │   │   ├── 外部进程 --> ( 难度等级: [0.3385, 0.3386) || 挂载数据: 无 ) 
│   │   │   │   ├── WSGI简介 --> ( 难度等级: [0.3386, 0.3387) || 挂载数据: 无 ) 
│   │   │   │   ├── WSGI服务器 --> ( 难度等级: [0.3387, 0.3388) || 挂载数据: 无 ) 
│   │   │   │   ├── 参考服务器 --> ( 难度等级: [0.3388, 0.3389) || 挂载数据: 无 ) 
│   │   │   │   ├── WSGI应用示例 --> ( 难度等级: [0.3389, 0.339) || 挂载数据: 无 ) 
│   │   │   │   ├── 中间件及封装WSGI应用 --> ( 难度等级: [0.339, 0.3391) || 挂载数据: 无 ) 
│   │   │   │   └── 在Python 3中使用WSGI --> ( 难度等级: [0.3391, 0.3392) || 挂载数据: 无 ) 
│   │   │   └── 现实世界中的Web开发 --> ( 难度等级: [0.3392, 0.34) || 挂载数据: 无 ) 
│   │   ├── 云计算：Google App Engine --> ( 难度等级: [0.34, 0.345) || 挂载数据: 无 ) 
│   │   │   ├── 云计算 --> ( 难度等级: [0.34, 0.3403) || 挂载数据: 无 ) 
│   │   │   │   ├── 云计算服务的层次 --> ( 难度等级: [0.34, 0.3402) || 挂载数据: qa: 10 ) 
│   │   │   │   └── App Engine --> ( 难度等级: [0.3402, 0.3403) || 挂载数据: 无 ) 
│   │   │   ├── 沙盒和App Engine SDK --> ( 难度等级: [0.3403, 0.3406) || 挂载数据: 无 ) 
│   │   │   ├── 选择一个App Engine框架 --> ( 难度等级: [0.3406, 0.3409) || 挂载数据: 无 ) 
│   │   │   ├── Python 2.7支持 --> ( 难度等级: [0.3409, 0.3412) || 挂载数据: 无 ) 
│   │   │   │   ├── 一般差异 --> ( 难度等级: [0.3409, 0.3411) || 挂载数据: 无 ) 
│   │   │   │   └── 代码中的差异 --> ( 难度等级: [0.3411, 0.3412) || 挂载数据: 无 ) 
│   │   │   ├── 将“Hello World”改成一个简单的博客 --> ( 难度等级: [0.3412, 0.3416) || 挂载数据: 无 ) 
│   │   │   │   ├── 快速发现改动：30秒内将纯文本转成HTML --> ( 难度等级: [0.3412, 0.3413) || 挂载数据: 无 ) 
│   │   │   │   ├── 添加表单 --> ( 难度等级: [0.3413, 0.3414) || 挂载数据: 无 ) 
│   │   │   │   ├── 添加Datastore服务 --> ( 难度等级: [0.3414, 0.3414) || 挂载数据: 无 ) 
│   │   │   │   ├── 迭代改进 --> ( 难度等级: [0.3414, 0.3415) || 挂载数据: 无 ) 
│   │   │   │   └── 开发/SDK控制台 --> ( 难度等级: [0.3415, 0.3416) || 挂载数据: qa: 2 ) 
│   │   │   ├── 添加Memcache服务 --> ( 难度等级: [0.3416, 0.3419) || 挂载数据: 无 ) 
│   │   │   ├── 添加用户服务 --> ( 难度等级: [0.3419, 0.3422) || 挂载数据: 无 ) 
│   │   │   │   ├── Google账号验证 --> ( 难度等级: [0.3419, 0.342) || 挂载数据: 无 ) 
│   │   │   │   └── 联合验证 --> ( 难度等级: [0.342, 0.3422) || 挂载数据: 无 ) 
│   │   │   ├── 远程API shell --> ( 难度等级: [0.3422, 0.3425) || 挂载数据: 无 ) 
│   │   │   ├── 问与答（Python实现） --> ( 难度等级: [0.3425, 0.3428) || 挂载数据: 无 ) 
│   │   │   ├── 使用XMPP发送即时消息 --> ( 难度等级: [0.3428, 0.3431) || 挂载数据: 无 ) 
│   │   │   ├── 处理图片 --> ( 难度等级: [0.3431, 0.3434) || 挂载数据: qa: 9 ) 
│   │   │   ├── 任务队列（非定期任务） --> ( 难度等级: [0.3434, 0.3438) || 挂载数据: 无 ) 
│   │   │   │   ├── 配置app.yaml --> ( 难度等级: [0.3434, 0.3435) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 其他任务创建选项 --> ( 难度等级: [0.3435, 0.3436) || 挂载数据: 无 ) 
│   │   │   │   ├── 将发送电子邮件作为任务 --> ( 难度等级: [0.3436, 0.3437) || 挂载数据: 无 ) 
│   │   │   │   └── deferred包 --> ( 难度等级: [0.3437, 0.3438) || 挂载数据: 无 ) 
│   │   │   ├── 使用Appstats进行分析 --> ( 难度等级: [0.3438, 0.3441) || 挂载数据: 无 ) 
│   │   │   │   ├── 在app.yaml中添加标准处理程序 --> ( 难度等级: [0.3438, 0.3439) || 挂载数据: 无 ) 
│   │   │   │   ├── 添加自定义Admin Console页面 --> ( 难度等级: [0.3439, 0.344) || 挂载数据: 无 ) 
│   │   │   │   └── 作为内置界面启用界面 --> ( 难度等级: [0.344, 0.3441) || 挂载数据: 无 ) 
│   │   │   ├── URLfetch服务 --> ( 难度等级: [0.3441, 0.3444) || 挂载数据: 无 ) 
│   │   │   ├── 问与答（无Python实现） --> ( 难度等级: [0.3444, 0.3447) || 挂载数据: 无 ) 
│   │   │   │   ├── Cron服务（计划任务作业） --> ( 难度等级: [0.3444, 0.3445) || 挂载数据: 无 ) 
│   │   │   │   ├── 预热请求 --> ( 难度等级: [0.3445, 0.3446) || 挂载数据: 无 ) 
│   │   │   │   └── DoS保护 --> ( 难度等级: [0.3446, 0.3447) || 挂载数据: 无 ) 
│   │   │   └── 厂商锁定 --> ( 难度等级: [0.3447, 0.345) || 挂载数据: 无 ) 
│   │   └── Web服务 --> ( 难度等级: [0.345, 0.35) || 挂载数据: 无 ) 
│   │       ├── Yahoo!金融股票报价服务器 --> ( 难度等级: [0.345, 0.3475) || 挂载数据: 无 ) 
│   │       └── Twitter微博 --> ( 难度等级: [0.3475, 0.35) || 挂载数据: qa: 1 ) 
│   │           ├── 社交网络 --> ( 难度等级: [0.3475, 0.3483) || 挂载数据: 无 ) 
│   │           ├── 稍微长一点的API组合应用示例 --> ( 难度等级: [0.3483, 0.3492) || 挂载数据: qa: 1 ) 
│   │           └── 额外在线资源 --> ( 难度等级: [0.3492, 0.35) || 挂载数据: 无 ) 
│   ├── 网络爬虫 --> ( 难度等级: [0.35, 0.4) || 挂载数据: qa: 1 ) 
│   │   ├── 基础概念 --> ( 难度等级: [0.35, 0.3518) || 挂载数据: 无 ) 
│   │   │   ├── 什么是网络爬虫 --> ( 难度等级: [0.35, 0.3504) || 挂载数据: 无 ) 
│   │   │   ├── HTML与DOM树分析 --> ( 难度等级: [0.3504, 0.3509) || 挂载数据: 无 ) 
│   │   │   ├── 常用网络爬虫工具 --> ( 难度等级: [0.3509, 0.3513) || 挂载数据: 无 ) 
│   │   │   └── 相关法律及注意事项 --> ( 难度等级: [0.3513, 0.3518) || 挂载数据: 无 ) 
│   │   ├── urllib --> ( 难度等级: [0.3518, 0.3536) || 挂载数据: 无 ) 
│   │   │   ├── 处理异常 --> ( 难度等级: [0.3518, 0.3524) || 挂载数据: 无 ) 
│   │   │   ├── 解析链接 --> ( 难度等级: [0.3524, 0.353) || 挂载数据: 无 ) 
│   │   │   └── 分析Robots协议 --> ( 难度等级: [0.353, 0.3536) || 挂载数据: 无 ) 
│   │   ├── 正则表达式 --> ( 难度等级: [0.3536, 0.3554) || 挂载数据: 无 ) 
│   │   │   ├── RE(Regular Expression ) --> ( 难度等级: [0.3536, 0.3538) || 挂载数据: qa: 1 ) 
│   │   │   ├── 基础语法 --> ( 难度等级: [0.3538, 0.3541) || 挂载数据: 无 ) 
│   │   │   ├── 标签匹配常用规则 --> ( 难度等级: [0.3541, 0.3543) || 挂载数据: 无 ) 
│   │   │   ├── 简介／动机 --> ( 难度等级: [0.3543, 0.3546) || 挂载数据: 无 ) 
│   │   │   ├── 特殊符号和字符 --> ( 难度等级: [0.3546, 0.3548) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用择一匹配符号匹配多个正则表达式模式 --> ( 难度等级: [0.3546, 0.3546) || 挂载数据: qa: 7 ) 
│   │   │   │   ├── 匹配任意单个字符 --> ( 难度等级: [0.3546, 0.3546) || 挂载数据: qa: 6 ) 
│   │   │   │   ├── 从字符串起始或者结尾或者单词边界匹配 --> ( 难度等级: [0.3546, 0.3547) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 创建字符集 --> ( 难度等级: [0.3547, 0.3547) || 挂载数据: 无 ) 
│   │   │   │   ├── 限定范围和否定 --> ( 难度等级: [0.3547, 0.3547) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用闭包操作符实现存在性和频数匹配 --> ( 难度等级: [0.3547, 0.3548) || 挂载数据: 无 ) 
│   │   │   │   ├── 表示字符集的特殊字符 --> ( 难度等级: [0.3548, 0.3548) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用圆括号指定分组 --> ( 难度等级: [0.3548, 0.3548) || 挂载数据: 无 ) 
│   │   │   │   └── 扩展表示法 --> ( 难度等级: [0.3548, 0.3548) || 挂载数据: 无 ) 
│   │   │   ├── 一些正则表达式示例 --> ( 难度等级: [0.3548, 0.3551) || 挂载数据: qa: 6 ) 
│   │   │   └── 更长的正则表达式示例 --> ( 难度等级: [0.3551, 0.3554) || 挂载数据: 无 ) 
│   │   ├── Beautiful Soup --> ( 难度等级: [0.3554, 0.3571) || 挂载数据: 无 ) 
│   │   │   ├── Beautiful Soup简介 --> ( 难度等级: [0.3554, 0.3557) || 挂载数据: 无 ) 
│   │   │   ├── 安装配置 --> ( 难度等级: [0.3557, 0.3561) || 挂载数据: 无 ) 
│   │   │   ├── Beautiful Soup对象 --> ( 难度等级: [0.3561, 0.3564) || 挂载数据: qa: 10 ) 
│   │   │   ├── 元素定位 --> ( 难度等级: [0.3564, 0.3568) || 挂载数据: qa: 1 ) 
│   │   │   └── 文档树遍历与搜索 --> ( 难度等级: [0.3568, 0.3571) || 挂载数据: 无 ) 
│   │   ├── lxml --> ( 难度等级: [0.3571, 0.3589) || 挂载数据: 无 ) 
│   │   │   ├── 安装配置 --> ( 难度等级: [0.3571, 0.3574) || 挂载数据: 无 ) 
│   │   │   ├── lxml.etree --> ( 难度等级: [0.3574, 0.3577) || 挂载数据: qa: 1 ) 
│   │   │   ├── XPath选择器 --> ( 难度等级: [0.3577, 0.358) || 挂载数据: 无 ) 
│   │   │   ├── find/findall --> ( 难度等级: [0.358, 0.3583) || 挂载数据: qa: 3 ) 
│   │   │   ├── CSS选择器 --> ( 难度等级: [0.3583, 0.3586) || 挂载数据: 无 ) 
│   │   │   └── 解析HTML --> ( 难度等级: [0.3586, 0.3589) || 挂载数据: 无 ) 
│   │   ├── requests --> ( 难度等级: [0.3589, 0.3607) || 挂载数据: 无 ) 
│   │   │   ├── 安装配置 --> ( 难度等级: [0.3589, 0.3591) || 挂载数据: 无 ) 
│   │   │   ├── 发送请求与HTTP请求类型 --> ( 难度等级: [0.3591, 0.3593) || 挂载数据: 无 ) 
│   │   │   ├── 传递URL参数 --> ( 难度等级: [0.3593, 0.3594) || 挂载数据: qa: 2 ) 
│   │   │   ├── 响应内容 --> ( 难度等级: [0.3594, 0.3596) || 挂载数据: 无 ) 
│   │   │   ├── 定制请求头 --> ( 难度等级: [0.3596, 0.3597) || 挂载数据: 无 ) 
│   │   │   ├── 响应状态码 --> ( 难度等级: [0.3597, 0.3599) || 挂载数据: 无 ) 
│   │   │   ├── Cookie --> ( 难度等级: [0.3599, 0.3601) || 挂载数据: qa: 4 ) 
│   │   │   ├── POST请求 --> ( 难度等级: [0.3601, 0.3602) || 挂载数据: qa: 10 ) 
│   │   │   ├── 身份认证 --> ( 难度等级: [0.3602, 0.3604) || 挂载数据: 无 ) 
│   │   │   ├── 基本用法 --> ( 难度等级: [0.3604, 0.3606) || 挂载数据: 无 ) 
│   │   │   └── 高级用法 --> ( 难度等级: [0.3606, 0.3607) || 挂载数据: 无 ) 
│   │   ├── Selenium --> ( 难度等级: [0.3607, 0.3625) || 挂载数据: qa: 2 ) 
│   │   │   ├── Selenium简介 --> ( 难度等级: [0.3607, 0.3609) || 挂载数据: qa: 10 ) 
│   │   │   ├── 安装配置 --> ( 难度等级: [0.3609, 0.3612) || 挂载数据: 无 ) 
│   │   │   ├── 单元素定位（find_element_id/name/xpath） --> ( 难度等级: [0.3612, 0.3614) || 挂载数据: qa: 1 ) 
│   │   │   ├── 多元素定位（find_elements_id/name/xpath） --> ( 难度等级: [0.3614, 0.3616) || 挂载数据: qa: 5 ) 
│   │   │   ├── 常用方法和属性 --> ( 难度等级: [0.3616, 0.3618) || 挂载数据: 无 ) 
│   │   │   │   ├── 可管理属性创建 --> ( 难度等级: [0.3616, 0.3617) || 挂载数据: qa: 7 ) 
│   │   │   │   ├── 延迟计算属性 --> ( 难度等级: [0.3617, 0.3617) || 挂载数据: 无 ) 
│   │   │   │   ├── 属性的代理访问 --> ( 难度等级: [0.3617, 0.3617) || 挂载数据: qa: 3 ) 
│   │   │   │   ├── 创建用于计算的属性 --> ( 难度等级: [0.3617, 0.3618) || 挂载数据: qa: 1 ) 
│   │   │   │   └── 为属性添加安全保护机制 --> ( 难度等级: [0.3618, 0.3618) || 挂载数据: 无 ) 
│   │   │   ├── 键盘和鼠标操作 --> ( 难度等级: [0.3618, 0.3621) || 挂载数据: 无 ) 
│   │   │   ├── WebDriver API --> ( 难度等级: [0.3621, 0.3623) || 挂载数据: qa: 10 ) 
│   │   │   └── 表单交互 --> ( 难度等级: [0.3623, 0.3625) || 挂载数据: 无 ) 
│   │   ├── Scrapy框架 --> ( 难度等级: [0.3625, 0.3643) || 挂载数据: 无 ) 
│   │   │   ├── Scrapy简介 --> ( 难度等级: [0.3625, 0.3626) || 挂载数据: 无 ) 
│   │   │   ├── 安装配置 --> ( 难度等级: [0.3626, 0.3627) || 挂载数据: 无 ) 
│   │   │   ├── Scrapy框架组成 --> ( 难度等级: [0.3627, 0.3628) || 挂载数据: qa: 5 ) 
│   │   │   ├── Item Pipeline --> ( 难度等级: [0.3628, 0.3629) || 挂载数据: qa: 1 ) 
│   │   │   ├── Downloader --> ( 难度等级: [0.3629, 0.3629) || 挂载数据: 无 ) 
│   │   │   ├── Spiders --> ( 难度等级: [0.3629, 0.363) || 挂载数据: 无 ) 
│   │   │   ├── Scheduler --> ( 难度等级: [0.363, 0.3631) || 挂载数据: 无 ) 
│   │   │   ├── Scrapy框架介绍 --> ( 难度等级: [0.3631, 0.3632) || 挂载数据: 无 ) 
│   │   │   ├── Scrapy入门 --> ( 难度等级: [0.3632, 0.3633) || 挂载数据: qa: 10 ) 
│   │   │   ├── Selector的用法 --> ( 难度等级: [0.3633, 0.3634) || 挂载数据: qa: 1 ) 
│   │   │   ├── Spider的用法 --> ( 难度等级: [0.3634, 0.3635) || 挂载数据: 无 ) 
│   │   │   ├── Downloader Middleware的用法 --> ( 难度等级: [0.3635, 0.3636) || 挂载数据: 无 ) 
│   │   │   ├── Spider Middleware的用法 --> ( 难度等级: [0.3636, 0.3637) || 挂载数据: 无 ) 
│   │   │   ├── Item Pipeline的用法 --> ( 难度等级: [0.3637, 0.3637) || 挂载数据: 无 ) 
│   │   │   ├── Scrapy对接Selenium --> ( 难度等级: [0.3637, 0.3638) || 挂载数据: qa: 2 ) 
│   │   │   ├── Scrapy对接Splash --> ( 难度等级: [0.3638, 0.3639) || 挂载数据: 无 ) 
│   │   │   ├── Scrapy通用爬虫 --> ( 难度等级: [0.3639, 0.364) || 挂载数据: qa: 6 ) 
│   │   │   ├── Scrapyrt的使用 --> ( 难度等级: [0.364, 0.3641) || 挂载数据: 无 ) 
│   │   │   ├── Scrapy对接Docker --> ( 难度等级: [0.3641, 0.3642) || 挂载数据: 无 ) 
│   │   │   └── Scrapy爬取新浪微博 --> ( 难度等级: [0.3642, 0.3643) || 挂载数据: qa: 4 ) 
│   │   ├── 数据存储 --> ( 难度等级: [0.3643, 0.3661) || 挂载数据: 无 ) 
│   │   │   ├── 文件存储 --> ( 难度等级: [0.3643, 0.3647) || 挂载数据: 无 ) 
│   │   │   │   ├── TXT文本存储 --> ( 难度等级: [0.3643, 0.3644) || 挂载数据: qa: 10 ) 
│   │   │   │   ├── JSON文件存储 --> ( 难度等级: [0.3644, 0.3646) || 挂载数据: qa: 2 ) 
│   │   │   │   └── CSV文件存储 --> ( 难度等级: [0.3646, 0.3647) || 挂载数据: qa: 4 ) 
│   │   │   ├── 数据库存储 --> ( 难度等级: [0.3647, 0.3652) || 挂载数据: qa: 1 ) 
│   │   │   ├── 关系型数据库存储 --> ( 难度等级: [0.3652, 0.3656) || 挂载数据: 无 ) 
│   │   │   │   └── MySQL的存储 --> ( 难度等级: [0.3652, 0.3656) || 挂载数据: 无 ) 
│   │   │   └── 非关系型数据库存储 --> ( 难度等级: [0.3656, 0.3661) || 挂载数据: 无 ) 
│   │   │       ├── MongoDB存储 --> ( 难度等级: [0.3656, 0.3658) || 挂载数据: 无 ) 
│   │   │       └── Redis存储 --> ( 难度等级: [0.3658, 0.3661) || 挂载数据: 无 ) 
│   │   ├── 渲染动态网页 --> ( 难度等级: [0.3661, 0.3679) || 挂载数据: 无 ) 
│   │   │   └── WebKit/Selenium/headless/PhantomJS --> ( 难度等级: [0.3661, 0.3679) || 挂载数据: 无 ) 
│   │   ├── 表单交互处理 --> ( 难度等级: [0.3679, 0.3696) || 挂载数据: 无 ) 
│   │   ├── 超时异常处理 --> ( 难度等级: [0.3696, 0.3714) || 挂载数据: 无 ) 
│   │   │   └── timeout --> ( 难度等级: [0.3696, 0.3714) || 挂载数据: 无 ) 
│   │   ├── 验证码处理 --> ( 难度等级: [0.3714, 0.3732) || 挂载数据: 无 ) 
│   │   │   └── 自动输入/OCR字符识别 --> ( 难度等级: [0.3714, 0.3732) || 挂载数据: 无 ) 
│   │   ├── 高并发处理 --> ( 难度等级: [0.3732, 0.375) || 挂载数据: qa: 1 ) 
│   │   ├── 多线程爬虫 --> ( 难度等级: [0.375, 0.3768) || 挂载数据: 无 ) 
│   │   ├── 开发环境配置 --> ( 难度等级: [0.3768, 0.3786) || 挂载数据: 无 ) 
│   │   │   ├── Python 3的安装 --> ( 难度等级: [0.3768, 0.377) || 挂载数据: 无 ) 
│   │   │   │   ├── Windows下的安装 --> ( 难度等级: [0.3768, 0.3769) || 挂载数据: 无 ) 
│   │   │   │   ├── Linux下的安装 --> ( 难度等级: [0.3769, 0.3769) || 挂载数据: qa: 1 ) 
│   │   │   │   └── Mac下的安装 --> ( 难度等级: [0.3769, 0.377) || 挂载数据: qa: 1 ) 
│   │   │   ├── 请求库的安装 --> ( 难度等级: [0.377, 0.3772) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── requests的安装 --> ( 难度等级: [0.377, 0.377) || 挂载数据: qa: 3 ) 
│   │   │   │   ├── Selenium的安装 --> ( 难度等级: [0.377, 0.3771) || 挂载数据: 无 ) 
│   │   │   │   ├── ChromeDriver的安装 --> ( 难度等级: [0.3771, 0.3771) || 挂载数据: qa: 2 ) 
│   │   │   │   ├── GeckoDriver的安装 --> ( 难度等级: [0.3771, 0.3771) || 挂载数据: 无 ) 
│   │   │   │   ├── PhantomJS的安装 --> ( 难度等级: [0.3771, 0.3771) || 挂载数据: qa: 1 ) 
│   │   │   │   └── aiohttp的安装 --> ( 难度等级: [0.3771, 0.3772) || 挂载数据: qa: 1 ) 
│   │   │   ├── 解析库的安装 --> ( 难度等级: [0.3772, 0.3774) || 挂载数据: 无 ) 
│   │   │   │   ├── lxml的安装 --> ( 难度等级: [0.3772, 0.3772) || 挂载数据: 无 ) 
│   │   │   │   ├── Beautiful Soup的安装 --> ( 难度等级: [0.3772, 0.3773) || 挂载数据: 无 ) 
│   │   │   │   ├── pyquery的安装 --> ( 难度等级: [0.3773, 0.3773) || 挂载数据: 无 ) 
│   │   │   │   └── tesserocr的安装 --> ( 难度等级: [0.3773, 0.3774) || 挂载数据: qa: 2 ) 
│   │   │   ├── 数据库的安装 --> ( 难度等级: [0.3774, 0.3776) || 挂载数据: 无 ) 
│   │   │   │   ├── MySQL的安装 --> ( 难度等级: [0.3774, 0.3774) || 挂载数据: 无 ) 
│   │   │   │   ├── MongoDB的安装 --> ( 难度等级: [0.3774, 0.3775) || 挂载数据: 无 ) 
│   │   │   │   └── Redis的安装 --> ( 难度等级: [0.3775, 0.3776) || 挂载数据: 无 ) 
│   │   │   ├── 存储库的安装 --> ( 难度等级: [0.3776, 0.3778) || 挂载数据: 无 ) 
│   │   │   │   ├── PyMySQL的安装 --> ( 难度等级: [0.3776, 0.3776) || 挂载数据: 无 ) 
│   │   │   │   ├── PyMongo的安装 --> ( 难度等级: [0.3776, 0.3777) || 挂载数据: 无 ) 
│   │   │   │   ├── redis-py的安装 --> ( 难度等级: [0.3777, 0.3777) || 挂载数据: qa: 2 ) 
│   │   │   │   └── RedisDump的安装 --> ( 难度等级: [0.3777, 0.3778) || 挂载数据: 无 ) 
│   │   │   ├── Web库的安装 --> ( 难度等级: [0.3778, 0.378) || 挂载数据: 无 ) 
│   │   │   │   ├── Flask的安装 --> ( 难度等级: [0.3778, 0.3779) || 挂载数据: 无 ) 
│   │   │   │   └── Tornado的安装 --> ( 难度等级: [0.3779, 0.378) || 挂载数据: 无 ) 
│   │   │   ├── App爬取相关库的安装 --> ( 难度等级: [0.378, 0.3782) || 挂载数据: 无 ) 
│   │   │   │   ├── Charles的安装 --> ( 难度等级: [0.378, 0.378) || 挂载数据: 无 ) 
│   │   │   │   ├── mitmproxy的安装 --> ( 难度等级: [0.378, 0.3781) || 挂载数据: 无 ) 
│   │   │   │   └── Appium的安装 --> ( 难度等级: [0.3781, 0.3782) || 挂载数据: qa: 1 ) 
│   │   │   ├── 爬虫框架的安装 --> ( 难度等级: [0.3782, 0.3784) || 挂载数据: 无 ) 
│   │   │   │   ├── pyspider的安装 --> ( 难度等级: [0.3782, 0.3782) || 挂载数据: 无 ) 
│   │   │   │   ├── Scrapy的安装 --> ( 难度等级: [0.3782, 0.3783) || 挂载数据: 无 ) 
│   │   │   │   ├── Scrapy-Splash的安装 --> ( 难度等级: [0.3783, 0.3783) || 挂载数据: 无 ) 
│   │   │   │   └── Scrapy-Redis的安装 --> ( 难度等级: [0.3783, 0.3784) || 挂载数据: 无 ) 
│   │   │   └── 部署相关库的安装 --> ( 难度等级: [0.3784, 0.3786) || 挂载数据: 无 ) 
│   │   │       ├── Docker的安装 --> ( 难度等级: [0.3784, 0.3784) || 挂载数据: 无 ) 
│   │   │       ├── Scrapyd的安装 --> ( 难度等级: [0.3784, 0.3784) || 挂载数据: 无 ) 
│   │   │       ├── Scrapyd-Client的安装 --> ( 难度等级: [0.3784, 0.3785) || 挂载数据: 无 ) 
│   │   │       ├── Scrapyd API的安装 --> ( 难度等级: [0.3785, 0.3785) || 挂载数据: 无 ) 
│   │   │       ├── Scrapyrt的安装 --> ( 难度等级: [0.3785, 0.3785) || 挂载数据: 无 ) 
│   │   │       └── Gerapy的安装 --> ( 难度等级: [0.3785, 0.3786) || 挂载数据: 无 ) 
│   │   ├── 爬虫基础 --> ( 难度等级: [0.3786, 0.3804) || 挂载数据: 无 ) 
│   │   │   ├── HTTP基本原理 --> ( 难度等级: [0.3786, 0.3789) || 挂载数据: 无 ) 
│   │   │   │   ├── URI和URL --> ( 难度等级: [0.3786, 0.3786) || 挂载数据: qa: 3 ) 
│   │   │   │   ├── 超文本 --> ( 难度等级: [0.3786, 0.3787) || 挂载数据: 无 ) 
│   │   │   │   ├── HTTP和HTTPS --> ( 难度等级: [0.3787, 0.3787) || 挂载数据: 无 ) 
│   │   │   │   ├── HTTP请求过程 --> ( 难度等级: [0.3787, 0.3788) || 挂载数据: qa: 6 ) 
│   │   │   │   ├── 请求 --> ( 难度等级: [0.3788, 0.3789) || 挂载数据: 无 ) 
│   │   │   │   └── 响应 --> ( 难度等级: [0.3789, 0.3789) || 挂载数据: 无 ) 
│   │   │   ├── 网页基础 --> ( 难度等级: [0.3789, 0.3793) || 挂载数据: 无 ) 
│   │   │   │   ├── 网页的组成 --> ( 难度等级: [0.3789, 0.379) || 挂载数据: qa: 10 ) 
│   │   │   │   ├── 网页的结构 --> ( 难度等级: [0.379, 0.3791) || 挂载数据: 无 ) 
│   │   │   │   ├── 节点树及节点间的关系 --> ( 难度等级: [0.3791, 0.3792) || 挂载数据: 无 ) 
│   │   │   │   └── 选择器 --> ( 难度等级: [0.3792, 0.3793) || 挂载数据: 无 ) 
│   │   │   ├── 爬虫的基本原理 --> ( 难度等级: [0.3793, 0.3796) || 挂载数据: 无 ) 
│   │   │   │   ├── 爬虫概述 --> ( 难度等级: [0.3793, 0.3794) || 挂载数据: qa: 10 ) 
│   │   │   │   ├── 能抓怎样的数据 --> ( 难度等级: [0.3794, 0.3795) || 挂载数据: qa: 4 ) 
│   │   │   │   └── JavaScript渲染页面 --> ( 难度等级: [0.3795, 0.3796) || 挂载数据: qa: 1 ) 
│   │   │   ├── 会话和Cookies --> ( 难度等级: [0.3796, 0.38) || 挂载数据: qa: 2 ) 
│   │   │   │   ├── 静态网页和动态网页 --> ( 难度等级: [0.3796, 0.3798) || 挂载数据: qa: 2 ) 
│   │   │   │   ├── 无状态HTTP --> ( 难度等级: [0.3798, 0.3799) || 挂载数据: 无 ) 
│   │   │   │   └── 常见误区 --> ( 难度等级: [0.3799, 0.38) || 挂载数据: 无 ) 
│   │   │   └── 代理的基本原理 --> ( 难度等级: [0.38, 0.3804) || 挂载数据: 无 ) 
│   │   │       ├── 基本原理 --> ( 难度等级: [0.38, 0.3801) || 挂载数据: 无 ) 
│   │   │       ├── 代理的作用 --> ( 难度等级: [0.3801, 0.3801) || 挂载数据: qa: 2 ) 
│   │   │       ├── 爬虫代理 --> ( 难度等级: [0.3801, 0.3802) || 挂载数据: qa: 1 ) 
│   │   │       ├── 代理分类 --> ( 难度等级: [0.3802, 0.3803) || 挂载数据: 无 ) 
│   │   │       └── 常见代理设置 --> ( 难度等级: [0.3803, 0.3804) || 挂载数据: 无 ) 
│   │   ├── 基本库的使用 --> ( 难度等级: [0.3804, 0.3821) || 挂载数据: 无 ) 
│   │   │   └── 抓取猫眼电影排行 --> ( 难度等级: [0.3804, 0.3821) || 挂载数据: 无 ) 
│   │   ├── 解析库的使用 --> ( 难度等级: [0.3821, 0.3839) || 挂载数据: 无 ) 
│   │   │   ├── 使用XPath --> ( 难度等级: [0.3821, 0.383) || 挂载数据: qa: 10 ) 
│   │   │   └── 使用pyquery --> ( 难度等级: [0.383, 0.3839) || 挂载数据: 无 ) 
│   │   ├── Ajax数据爬取 --> ( 难度等级: [0.3839, 0.3857) || 挂载数据: 无 ) 
│   │   │   ├── 什么是Ajax --> ( 难度等级: [0.3839, 0.3844) || 挂载数据: qa: 2 ) 
│   │   │   ├── Ajax分析方法 --> ( 难度等级: [0.3844, 0.3848) || 挂载数据: 无 ) 
│   │   │   ├── Ajax结果提取 --> ( 难度等级: [0.3848, 0.3853) || 挂载数据: 无 ) 
│   │   │   └── 分析Ajax爬取今日头条街拍美图 --> ( 难度等级: [0.3853, 0.3857) || 挂载数据: 无 ) 
│   │   ├── 动态渲染页面爬取 --> ( 难度等级: [0.3857, 0.3875) || 挂载数据: 无 ) 
│   │   │   ├── Splash的使用 --> ( 难度等级: [0.3857, 0.3863) || 挂载数据: 无 ) 
│   │   │   ├── Splash负载均衡配置 --> ( 难度等级: [0.3863, 0.3869) || 挂载数据: 无 ) 
│   │   │   └── 使用Selenium爬取淘宝商品 --> ( 难度等级: [0.3869, 0.3875) || 挂载数据: qa: 2 ) 
│   │   ├── 验证码的识别 --> ( 难度等级: [0.3875, 0.3893) || 挂载数据: 无 ) 
│   │   │   ├── 图形验证码的识别 --> ( 难度等级: [0.3875, 0.3879) || 挂载数据: 无 ) 
│   │   │   ├── 极验滑动验证码的识别 --> ( 难度等级: [0.3879, 0.3884) || 挂载数据: qa: 1 ) 
│   │   │   ├── 点触验证码的识别 --> ( 难度等级: [0.3884, 0.3888) || 挂载数据: qa: 3 ) 
│   │   │   └── 微博宫格验证码的识别 --> ( 难度等级: [0.3888, 0.3893) || 挂载数据: 无 ) 
│   │   ├── 代理的使用 --> ( 难度等级: [0.3893, 0.3911) || 挂载数据: 无 ) 
│   │   │   ├── 代理的设置 --> ( 难度等级: [0.3893, 0.3896) || 挂载数据: qa: 2 ) 
│   │   │   ├── 代理池的维护 --> ( 难度等级: [0.3896, 0.39) || 挂载数据: 无 ) 
│   │   │   ├── 付费代理的使用 --> ( 难度等级: [0.39, 0.3904) || 挂载数据: 无 ) 
│   │   │   ├── ADSL拨号代理 --> ( 难度等级: [0.3904, 0.3907) || 挂载数据: 无 ) 
│   │   │   └── 使用代理爬取微信公众号文章 --> ( 难度等级: [0.3907, 0.3911) || 挂载数据: 无 ) 
│   │   ├── 模拟登录 --> ( 难度等级: [0.3911, 0.3929) || 挂载数据: 无 ) 
│   │   │   ├── 模拟登录并爬取GitHub --> ( 难度等级: [0.3911, 0.392) || 挂载数据: qa: 7 ) 
│   │   │   └── Cookies池的搭建 --> ( 难度等级: [0.392, 0.3929) || 挂载数据: 无 ) 
│   │   ├── App的爬取 --> ( 难度等级: [0.3929, 0.3946) || 挂载数据: 无 ) 
│   │   │   ├── Charles的使用 --> ( 难度等级: [0.3929, 0.3932) || 挂载数据: 无 ) 
│   │   │   ├── mitmproxy的使用 --> ( 难度等级: [0.3932, 0.3935) || 挂载数据: qa: 1 ) 
│   │   │   ├── mitmdump爬取“得到”App电子书 --> ( 难度等级: [0.3935, 0.3938) || 挂载数据: qa: 4 ) 
│   │   │   ├── Appium的基本使用 --> ( 难度等级: [0.3938, 0.394) || 挂载数据: qa: 1 ) 
│   │   │   ├── Appium爬取微信朋友圈 --> ( 难度等级: [0.394, 0.3943) || 挂载数据: qa: 10 ) 
│   │   │   └── Appium+mitmdump爬取京东商品 --> ( 难度等级: [0.3943, 0.3946) || 挂载数据: qa: 1 ) 
│   │   ├── pyspider框架的使用 --> ( 难度等级: [0.3946, 0.3964) || 挂载数据: 无 ) 
│   │   │   ├── pyspider框架介绍 --> ( 难度等级: [0.3946, 0.3952) || 挂载数据: 无 ) 
│   │   │   ├── pyspider的基本使用 --> ( 难度等级: [0.3952, 0.3958) || 挂载数据: 无 ) 
│   │   │   └── pyspider用法详解 --> ( 难度等级: [0.3958, 0.3964) || 挂载数据: 无 ) 
│   │   ├── 分布式爬虫 --> ( 难度等级: [0.3964, 0.3982) || 挂载数据: 无 ) 
│   │   │   ├── 分布式爬虫原理 --> ( 难度等级: [0.3964, 0.3969) || 挂载数据: 无 ) 
│   │   │   ├── Scrapy-Redis源码解析 --> ( 难度等级: [0.3969, 0.3973) || 挂载数据: 无 ) 
│   │   │   ├── Scrapy分布式实现 --> ( 难度等级: [0.3973, 0.3978) || 挂载数据: 无 ) 
│   │   │   └── Bloom Filter的对接 --> ( 难度等级: [0.3978, 0.3982) || 挂载数据: 无 ) 
│   │   └── 分布式爬虫的部署 --> ( 难度等级: [0.3982, 0.4) || 挂载数据: 无 ) 
│   │       ├── Scrapyd分布式部署 --> ( 难度等级: [0.3982, 0.3986) || 挂载数据: qa: 1 ) 
│   │       ├── Scrapyd-Client的使用 --> ( 难度等级: [0.3986, 0.3989) || 挂载数据: qa: 1 ) 
│   │       ├── Scrapyd对接Docker --> ( 难度等级: [0.3989, 0.3993) || 挂载数据: 无 ) 
│   │       ├── Scrapyd批量部署 --> ( 难度等级: [0.3993, 0.3996) || 挂载数据: qa: 1 ) 
│   │       └── Gerapy分布式管理 --> ( 难度等级: [0.3996, 0.4) || 挂载数据: 无 ) 
│   ├── 桌面应用开发 --> ( 难度等级: [0.4, 0.45) || 挂载数据: 无 ) 
│   │   ├── Tkinter --> ( 难度等级: [0.4, 0.4167) || 挂载数据: qa: 4 ) 
│   │   │   ├── Tkinter简介 --> ( 难度等级: [0.4, 0.4028) || 挂载数据: 无 ) 
│   │   │   ├── 安装配置 --> ( 难度等级: [0.4028, 0.4056) || 挂载数据: 无 ) 
│   │   │   ├── Tkinter模块 --> ( 难度等级: [0.4056, 0.4083) || 挂载数据: qa: 1 ) 
│   │   │   ├── Tkinter控件 --> ( 难度等级: [0.4083, 0.4111) || 挂载数据: 无 ) 
│   │   │   ├── 标准属性 --> ( 难度等级: [0.4111, 0.4139) || 挂载数据: 无 ) 
│   │   │   └── 几何管理 --> ( 难度等级: [0.4139, 0.4167) || 挂载数据: 无 ) 
│   │   ├── PyQT --> ( 难度等级: [0.4167, 0.4333) || 挂载数据: 无 ) 
│   │   │   ├── PyQT简介 --> ( 难度等级: [0.4167, 0.4185) || 挂载数据: 无 ) 
│   │   │   ├── 安装配置 --> ( 难度等级: [0.4185, 0.4204) || 挂载数据: 无 ) 
│   │   │   ├── PyQT模块 --> ( 难度等级: [0.4204, 0.4222) || 挂载数据: 无 ) 
│   │   │   ├── PyQT布局管理 --> ( 难度等级: [0.4222, 0.4241) || 挂载数据: 无 ) 
│   │   │   ├── PyQT菜单和工具栏 --> ( 难度等级: [0.4241, 0.4259) || 挂载数据: 无 ) 
│   │   │   ├── 事件和信号 --> ( 难度等级: [0.4259, 0.4278) || 挂载数据: 无 ) 
│   │   │   ├── PyQT对话框 --> ( 难度等级: [0.4278, 0.4296) || 挂载数据: 无 ) 
│   │   │   ├── PyQT控件 --> ( 难度等级: [0.4296, 0.4315) || 挂载数据: 无 ) 
│   │   │   └── PyQT拖拽与绘图 --> ( 难度等级: [0.4315, 0.4333) || 挂载数据: 无 ) 
│   │   └── WxPython --> ( 难度等级: [0.4333, 0.45) || 挂载数据: qa: 1 ) 
│   │       ├── WxPython简介 --> ( 难度等级: [0.4333, 0.4352) || 挂载数据: 无 ) 
│   │       ├── 安装配置 --> ( 难度等级: [0.4352, 0.437) || 挂载数据: 无 ) 
│   │       ├── WxPython常用类 --> ( 难度等级: [0.437, 0.4389) || 挂载数据: 无 ) 
│   │       ├── WxPython布局管理 --> ( 难度等级: [0.4389, 0.4407) || 挂载数据: 无 ) 
│   │       ├── WxPython事件处理 --> ( 难度等级: [0.4407, 0.4426) || 挂载数据: qa: 10 ) 
│   │       ├── WxPython对话框 --> ( 难度等级: [0.4426, 0.4444) || 挂载数据: 无 ) 
│   │       ├── WxPython组件 --> ( 难度等级: [0.4444, 0.4463) || 挂载数据: qa: 1 ) 
│   │       ├── WxPython拖拽处理 --> ( 难度等级: [0.4463, 0.4481) || 挂载数据: 无 ) 
│   │       └── WxPython绘图API --> ( 难度等级: [0.4481, 0.45) || 挂载数据: 无 ) 
│   └── 其他 --> ( 难度等级: [0.45, 0.5) || 挂载数据: 无 ) 
│       ├── Python总览 --> ( 难度等级: [0.45, 0.4528) || 挂载数据: 无 ) 
│       │   ├── Python总体架构 --> ( 难度等级: [0.45, 0.4509) || 挂载数据: 无 ) 
│       │   ├── Python源码组织 --> ( 难度等级: [0.4509, 0.4519) || 挂载数据: 无 ) 
│       │   └── Python对象初探 --> ( 难度等级: [0.4519, 0.4528) || 挂载数据: 无 ) 
│       │       ├── Python内的对象 --> ( 难度等级: [0.4519, 0.452) || 挂载数据: 无 ) 
│       │       ├── 对象的分类 --> ( 难度等级: [0.452, 0.4521) || 挂载数据: 无 ) 
│       │       ├── 对象机制的基石—PyObject --> ( 难度等级: [0.4521, 0.4522) || 挂载数据: 无 ) 
│       │       ├── 定长对象和变长对象 --> ( 难度等级: [0.4522, 0.4523) || 挂载数据: 无 ) 
│       │       ├── 类型对象 --> ( 难度等级: [0.4523, 0.4524) || 挂载数据: 无 ) 
│       │       ├── 类型的类型 --> ( 难度等级: [0.4524, 0.4525) || 挂载数据: 无 ) 
│       │       ├── 对象的创建 --> ( 难度等级: [0.4525, 0.4526) || 挂载数据: 无 ) 
│       │       ├── 对象的多态性 --> ( 难度等级: [0.4526, 0.4527) || 挂载数据: 无 ) 
│       │       └── 引用计数 --> ( 难度等级: [0.4527, 0.4528) || 挂载数据: 无 ) 
│       ├── 数字对象 --> ( 难度等级: [0.4528, 0.4556) || 挂载数据: 无 ) 
│       │   ├── 整数对象 --> ( 难度等级: [0.4528, 0.4532) || 挂载数据: 无 ) 
│       │   │   ├── PyLongObject对象 --> ( 难度等级: [0.4528, 0.4529) || 挂载数据: 无 ) 
│       │   │   ├── 小整数对象 --> ( 难度等级: [0.4529, 0.453) || 挂载数据: 无 ) 
│       │   │   └── 大整数对象 --> ( 难度等级: [0.453, 0.4532) || 挂载数据: qa: 4 ) 
│       │   ├── 数字格式化输出 --> ( 难度等级: [0.4532, 0.4536) || 挂载数据: qa: 5 ) 
│       │   ├── 进制转换 --> ( 难度等级: [0.4536, 0.454) || 挂载数据: qa: 3 ) 
│       │   ├── 数字运算 --> ( 难度等级: [0.454, 0.4544) || 挂载数据: qa: 10 ) 
│       │   │   ├── 四舍五入运算 --> ( 难度等级: [0.454, 0.454) || 挂载数据: 无 ) 
│       │   │   ├── 浮点数运算 --> ( 难度等级: [0.454, 0.4541) || 挂载数据: 无 ) 
│       │   │   ├── 复数运算 --> ( 难度等级: [0.4541, 0.4542) || 挂载数据: 无 ) 
│       │   │   ├── 分数运算 --> ( 难度等级: [0.4542, 0.4542) || 挂载数据: 无 ) 
│       │   │   ├── 大型数组运算 --> ( 难度等级: [0.4542, 0.4543) || 挂载数据: qa: 1 ) 
│       │   │   └── 矩阵与线性代数运算 --> ( 难度等级: [0.4543, 0.4544) || 挂载数据: 无 ) 
│       │   ├── 字节到大整数的打包与解包 --> ( 难度等级: [0.4544, 0.4548) || 挂载数据: 无 ) 
│       │   ├── 无穷大与NaN --> ( 难度等级: [0.4548, 0.4552) || 挂载数据: qa: 2 ) 
│       │   └── 随机数 --> ( 难度等级: [0.4552, 0.4556) || 挂载数据: 无 ) 
│       ├── 字符串 --> ( 难度等级: [0.4556, 0.4583) || 挂载数据: 无 ) 
│       │   ├── 字符串对象解析 --> ( 难度等级: [0.4556, 0.4559) || 挂载数据: 无 ) 
│       │   │   ├── 字符串对象的intern机制 --> ( 难度等级: [0.4556, 0.4557) || 挂载数据: 无 ) 
│       │   │   └── 字符串操作效率 --> ( 难度等级: [0.4557, 0.4559) || 挂载数据: qa: 1 ) 
│       │   ├── 字符串操作 --> ( 难度等级: [0.4559, 0.4562) || 挂载数据: 无 ) 
│       │   │   ├── 字符串分割 --> ( 难度等级: [0.4559, 0.4559) || 挂载数据: qa: 10 ) 
│       │   │   ├── 删除不需要的字符 --> ( 难度等级: [0.4559, 0.456) || 挂载数据: 无 ) 
│       │   │   ├── 字符串清理 --> ( 难度等级: [0.456, 0.456) || 挂载数据: 无 ) 
│       │   │   ├── 字符串对齐 --> ( 难度等级: [0.456, 0.456) || 挂载数据: 无 ) 
│       │   │   ├── 字符串拼接 --> ( 难度等级: [0.456, 0.4561) || 挂载数据: 无 ) 
│       │   │   ├── 字符串插入 --> ( 难度等级: [0.4561, 0.4561) || 挂载数据: 无 ) 
│       │   │   └── 字符串格式化 --> ( 难度等级: [0.4561, 0.4562) || 挂载数据: qa: 1 ) 
│       │   ├── 字符串匹配 --> ( 难度等级: [0.4562, 0.4565) || 挂载数据: 无 ) 
│       │   │   ├── 字符串开头或结尾匹配 --> ( 难度等级: [0.4562, 0.4562) || 挂载数据: qa: 4 ) 
│       │   │   ├── 用Shell通配符匹配字符串 --> ( 难度等级: [0.4562, 0.4563) || 挂载数据: qa: 1 ) 
│       │   │   ├── 最短匹配 --> ( 难度等级: [0.4563, 0.4564) || 挂载数据: 无 ) 
│       │   │   └── 多行匹配 --> ( 难度等级: [0.4564, 0.4565) || 挂载数据: qa: 10 ) 
│       │   ├── 字符串搜索 --> ( 难度等级: [0.4565, 0.4568) || 挂载数据: 无 ) 
│       │   │   ├── 字符串搜索替换 --> ( 难度等级: [0.4565, 0.4566) || 挂载数据: qa: 4 ) 
│       │   │   └── 字符串忽略大小写的搜索替换 --> ( 难度等级: [0.4566, 0.4568) || 挂载数据: qa: 1 ) 
│       │   ├── 将Unicode文本标准化 --> ( 难度等级: [0.4568, 0.4571) || 挂载数据: 无 ) 
│       │   ├── 在正则表达式中使用Unicode字符 --> ( 难度等级: [0.4571, 0.4574) || 挂载数据: 无 ) 
│       │   ├── 令牌解析 --> ( 难度等级: [0.4574, 0.4577) || 挂载数据: 无 ) 
│       │   ├── 简单的递归下降分析器实现 --> ( 难度等级: [0.4577, 0.458) || 挂载数据: 无 ) 
│       │   └── 字节字符串操作 --> ( 难度等级: [0.458, 0.4583) || 挂载数据: 无 ) 
│       ├── 数据结构 --> ( 难度等级: [0.4583, 0.4611) || 挂载数据: 无 ) 
│       │   ├── 序列 --> ( 难度等级: [0.4583, 0.4587) || 挂载数据: 无 ) 
│       │   │   ├── 序列对象解析 --> ( 难度等级: [0.4583, 0.4584) || 挂载数据: 无 ) 
│       │   │   ├── 序列解压 --> ( 难度等级: [0.4584, 0.4584) || 挂载数据: qa: 4 ) 
│       │   │   ├── 序列去重并保持顺序 --> ( 难度等级: [0.4584, 0.4585) || 挂载数据: qa: 1 ) 
│       │   │   ├── 序列元素统计 --> ( 难度等级: [0.4585, 0.4586) || 挂载数据: qa: 1 ) 
│       │   │   ├── 过滤序列元素 --> ( 难度等级: [0.4586, 0.4586) || 挂载数据: 无 ) 
│       │   │   ├── 序列元素名称映射 --> ( 难度等级: [0.4586, 0.4587) || 挂载数据: 无 ) 
│       │   │   └── 转换并计算数据 --> ( 难度等级: [0.4587, 0.4587) || 挂载数据: qa: 1 ) 
│       │   ├── 字典 --> ( 难度等级: [0.4587, 0.4591) || 挂载数据: 无 ) 
│       │   │   ├── 字典对象解析 --> ( 难度等级: [0.4587, 0.4588) || 挂载数据: 无 ) 
│       │   │   ├── 字典映射 --> ( 难度等级: [0.4588, 0.4588) || 挂载数据: 无 ) 
│       │   │   ├── 字典排序 --> ( 难度等级: [0.4588, 0.4589) || 挂载数据: qa: 3 ) 
│       │   │   ├── 字典运算 --> ( 难度等级: [0.4589, 0.4589) || 挂载数据: 无 ) 
│       │   │   ├── 字典查找 --> ( 难度等级: [0.4589, 0.459) || 挂载数据: 无 ) 
│       │   │   ├── 通过关键字排序字典 --> ( 难度等级: [0.459, 0.459) || 挂载数据: 无 ) 
│       │   │   ├── 字典提取 --> ( 难度等级: [0.459, 0.4591) || 挂载数据: qa: 3 ) 
│       │   │   └── 字典合并 --> ( 难度等级: [0.4591, 0.4591) || 挂载数据: qa: 1 ) 
│       │   ├── 可迭代对象操作 --> ( 难度等级: [0.4591, 0.4595) || 挂载数据: 无 ) 
│       │   │   ├── 可迭代对象解压 --> ( 难度等级: [0.4591, 0.4593) || 挂载数据: 无 ) 
│       │   │   ├── 保留最后N个元素 --> ( 难度等级: [0.4593, 0.4594) || 挂载数据: 无 ) 
│       │   │   └── 记录分组 --> ( 难度等级: [0.4594, 0.4595) || 挂载数据: 无 ) 
│       │   ├── 查找最大或最小的N个元素 --> ( 难度等级: [0.4595, 0.4599) || 挂载数据: qa: 2 ) 
│       │   ├── 实现一个优先级队列 --> ( 难度等级: [0.4599, 0.4603) || 挂载数据: 无 ) 
│       │   ├── 命名切片 --> ( 难度等级: [0.4603, 0.4607) || 挂载数据: 无 ) 
│       │   └── 排序不支持原生比较的对象 --> ( 难度等级: [0.4607, 0.4611) || 挂载数据: qa: 1 ) 
│       ├── 迭代器与生成器 --> ( 难度等级: [0.4611, 0.4639) || 挂载数据: 无 ) 
│       │   ├── 迭代操作 --> ( 难度等级: [0.4611, 0.4617) || 挂载数据: 无 ) 
│       │   │   ├── 手动遍历迭代器 --> ( 难度等级: [0.4611, 0.4612) || 挂载数据: 无 ) 
│       │   │   ├── 代理迭代 --> ( 难度等级: [0.4612, 0.4612) || 挂载数据: qa: 2 ) 
│       │   │   ├── 实现迭代协议 --> ( 难度等级: [0.4612, 0.4613) || 挂载数据: 无 ) 
│       │   │   ├── 反向迭代 --> ( 难度等级: [0.4613, 0.4613) || 挂载数据: qa: 2 ) 
│       │   │   ├── 迭代器切片 --> ( 难度等级: [0.4613, 0.4613) || 挂载数据: 无 ) 
│       │   │   ├── 跳过可迭代对象的开始部分 --> ( 难度等级: [0.4613, 0.4614) || 挂载数据: qa: 1 ) 
│       │   │   ├── 排列组合的迭代 --> ( 难度等级: [0.4614, 0.4614) || 挂载数据: 无 ) 
│       │   │   ├── 序列上索引值迭代 --> ( 难度等级: [0.4614, 0.4615) || 挂载数据: 无 ) 
│       │   │   ├── 多个序列迭代 --> ( 难度等级: [0.4615, 0.4615) || 挂载数据: 无 ) 
│       │   │   ├── 集合元素的迭代 --> ( 难度等级: [0.4615, 0.4616) || 挂载数据: 无 ) 
│       │   │   ├── 顺序迭代合并后的排序迭代对象 --> ( 难度等级: [0.4616, 0.4616) || 挂载数据: qa: 1 ) 
│       │   │   └── 迭代器代替while无限循环 --> ( 难度等级: [0.4616, 0.4617) || 挂载数据: 无 ) 
│       │   ├── 使用生成器创建新的迭代模式 --> ( 难度等级: [0.4617, 0.4622) || 挂载数据: qa: 1 ) 
│       │   ├── 带有外部状态的生成器函数 --> ( 难度等级: [0.4622, 0.4628) || 挂载数据: 无 ) 
│       │   ├── 创建数据处理管道 --> ( 难度等级: [0.4628, 0.4633) || 挂载数据: 无 ) 
│       │   └── 展开嵌套的序列 --> ( 难度等级: [0.4633, 0.4639) || 挂载数据: 无 ) 
│       ├── 文件与I/O --> ( 难度等级: [0.4639, 0.4667) || 挂载数据: 无 ) 
│       │   ├── 读/写操作 --> ( 难度等级: [0.4639, 0.4643) || 挂载数据: 无 ) 
│       │   │   ├── 读/写文本数据 --> ( 难度等级: [0.4639, 0.464) || 挂载数据: qa: 2 ) 
│       │   │   ├── 读/写字节数据 --> ( 难度等级: [0.464, 0.4642) || 挂载数据: 无 ) 
│       │   │   └── 读/写压缩文件 --> ( 难度等级: [0.4642, 0.4643) || 挂载数据: qa: 10 ) 
│       │   ├── 文件操作 --> ( 难度等级: [0.4643, 0.4647) || 挂载数据: 无 ) 
│       │   │   ├── 文件的写入 --> ( 难度等级: [0.4643, 0.4643) || 挂载数据: qa: 1 ) 
│       │   │   ├── 操作文件路径名 --> ( 难度等级: [0.4643, 0.4643) || 挂载数据: qa: 2 ) 
│       │   │   ├── 文件检查 --> ( 难度等级: [0.4643, 0.4644) || 挂载数据: 无 ) 
│       │   │   ├── 文件列表获取 --> ( 难度等级: [0.4644, 0.4644) || 挂载数据: qa: 1 ) 
│       │   │   ├── 忽略文件名编码 --> ( 难度等级: [0.4644, 0.4644) || 挂载数据: 无 ) 
│       │   │   ├── 打印不合法的文件名 --> ( 难度等级: [0.4644, 0.4644) || 挂载数据: 无 ) 
│       │   │   ├── 文件编码变更 --> ( 难度等级: [0.4644, 0.4645) || 挂载数据: qa: 2 ) 
│       │   │   ├── 在文本文件中写入字节 --> ( 难度等级: [0.4645, 0.4645) || 挂载数据: 无 ) 
│       │   │   ├── 文件描述符包装 --> ( 难度等级: [0.4645, 0.4645) || 挂载数据: 无 ) 
│       │   │   ├── 创建临时文件和文件夹 --> ( 难度等级: [0.4645, 0.4646) || 挂载数据: 无 ) 
│       │   │   ├── 文件迭代 --> ( 难度等级: [0.4646, 0.4646) || 挂载数据: 无 ) 
│       │   │   ├── 二进制文件映射 --> ( 难度等级: [0.4646, 0.4646) || 挂载数据: qa: 2 ) 
│       │   │   ├── 创建和解压归档文件 --> ( 难度等级: [0.4646, 0.4646) || 挂载数据: 无 ) 
│       │   │   ├── 文件查找 --> ( 难度等级: [0.4646, 0.4647) || 挂载数据: 无 ) 
│       │   │   └── 配置文件读取 --> ( 难度等级: [0.4647, 0.4647) || 挂载数据: 无 ) 
│       │   ├── 使用分隔符或行终止符打印 --> ( 难度等级: [0.4647, 0.4651) || 挂载数据: 无 ) 
│       │   ├── 字符串的I/O操作 --> ( 难度等级: [0.4651, 0.4655) || 挂载数据: qa: 5 ) 
│       │   ├── 可变缓冲区中二进制数据的读取 --> ( 难度等级: [0.4655, 0.4659) || 挂载数据: 无 ) 
│       │   ├── 串行端口的数据通信 --> ( 难度等级: [0.4659, 0.4663) || 挂载数据: 无 ) 
│       │   └── 对象序列化 --> ( 难度等级: [0.4663, 0.4667) || 挂载数据: 无 ) 
│       ├── 数据编码及处理 --> ( 难度等级: [0.4667, 0.4694) || 挂载数据: 无 ) 
│       │   ├── 数据读/写 --> ( 难度等级: [0.4667, 0.4672) || 挂载数据: 无 ) 
│       │   │   ├── CSV数据读/写 --> ( 难度等级: [0.4667, 0.4668) || 挂载数据: qa: 2 ) 
│       │   │   ├── JSON数据读/写 --> ( 难度等级: [0.4668, 0.4669) || 挂载数据: 无 ) 
│       │   │   ├── 二进制数组数据读/写 --> ( 难度等级: [0.4669, 0.4671) || 挂载数据: qa: 1 ) 
│       │   │   └── 嵌套和可变长二进制数据读取 --> ( 难度等级: [0.4671, 0.4672) || 挂载数据: 无 ) 
│       │   ├── XML数据解析 --> ( 难度等级: [0.4672, 0.4678) || 挂载数据: 无 ) 
│       │   │   ├── 简单XML数据解析 --> ( 难度等级: [0.4672, 0.4674) || 挂载数据: qa: 7 ) 
│       │   │   ├── 解析XML文档 --> ( 难度等级: [0.4674, 0.4676) || 挂载数据: 无 ) 
│       │   │   └── 修改XML --> ( 难度等级: [0.4676, 0.4678) || 挂载数据: qa: 2 ) 
│       │   ├── 字典转换为XML --> ( 难度等级: [0.4678, 0.4683) || 挂载数据: 无 ) 
│       │   ├── 与关系型数据库的交互 --> ( 难度等级: [0.4683, 0.4689) || 挂载数据: 无 ) 
│       │   └── 编码/解码 --> ( 难度等级: [0.4689, 0.4694) || 挂载数据: 无 ) 
│       │       ├── 十六进制数编码和解码 --> ( 难度等级: [0.4689, 0.4692) || 挂载数据: qa: 5 ) 
│       │       └── 编码/解码Base64数据 --> ( 难度等级: [0.4692, 0.4694) || 挂载数据: qa: 4 ) 
│       ├── 函数 --> ( 难度等级: [0.4694, 0.4722) || 挂载数据: 无 ) 
│       │   ├── 函数定义 --> ( 难度等级: [0.4694, 0.4697) || 挂载数据: 无 ) 
│       │   │   ├── 有默认参数的函数定义 --> ( 难度等级: [0.4694, 0.4696) || 挂载数据: qa: 10 ) 
│       │   │   └── 匿名或内联函数定义 --> ( 难度等级: [0.4696, 0.4697) || 挂载数据: 无 ) 
│       │   ├── 函数的参数 --> ( 难度等级: [0.4697, 0.47) || 挂载数据: 无 ) 
│       │   │   ├── 接收任意数量参数 --> ( 难度等级: [0.4697, 0.4698) || 挂载数据: 无 ) 
│       │   │   ├── 接收关键字参数 --> ( 难度等级: [0.4698, 0.4699) || 挂载数据: 无 ) 
│       │   │   ├── 为参数增加元信息 --> ( 难度等级: [0.4699, 0.4699) || 挂载数据: qa: 1 ) 
│       │   │   └── 减少参数个数 --> ( 难度等级: [0.4699, 0.47) || 挂载数据: 无 ) 
│       │   ├── 返回多个值的函数 --> ( 难度等级: [0.47, 0.4703) || 挂载数据: 无 ) 
│       │   ├── 类转换为函数 --> ( 难度等级: [0.4703, 0.4706) || 挂载数据: qa: 1 ) 
│       │   ├── 回调函数 --> ( 难度等级: [0.4706, 0.4708) || 挂载数据: 无 ) 
│       │   │   ├── 有额外状态信息的回调函数 --> ( 难度等级: [0.4706, 0.4707) || 挂载数据: 无 ) 
│       │   │   └── 内联回调函数 --> ( 难度等级: [0.4707, 0.4708) || 挂载数据: 无 ) 
│       │   ├── 函数的创建和调用 --> ( 难度等级: [0.4708, 0.4711) || 挂载数据: 无 ) 
│       │   │   ├── 创建一个函数 --> ( 难度等级: [0.4708, 0.471) || 挂载数据: qa: 9 ) 
│       │   │   └── 调用函数 --> ( 难度等级: [0.471, 0.4711) || 挂载数据: 无 ) 
│       │   ├── 参数传递 --> ( 难度等级: [0.4711, 0.4714) || 挂载数据: 无 ) 
│       │   │   ├── 了解形式参数和实际参数 --> ( 难度等级: [0.4711, 0.4712) || 挂载数据: 无 ) 
│       │   │   ├── 位置参数 --> ( 难度等级: [0.4712, 0.4712) || 挂载数据: 无 ) 
│       │   │   ├── 关键字参数 --> ( 难度等级: [0.4712, 0.4713) || 挂载数据: 无 ) 
│       │   │   ├── 为参数设置默认值 --> ( 难度等级: [0.4713, 0.4713) || 挂载数据: 无 ) 
│       │   │   └── 可变参数 --> ( 难度等级: [0.4713, 0.4714) || 挂载数据: 无 ) 
│       │   ├── 返回值 --> ( 难度等级: [0.4714, 0.4717) || 挂载数据: 无 ) 
│       │   ├── 变量的作用域 --> ( 难度等级: [0.4717, 0.4719) || 挂载数据: qa: 2 ) 
│       │   │   ├── 局部变量 --> ( 难度等级: [0.4717, 0.4718) || 挂载数据: 无 ) 
│       │   │   └── 全局变量 --> ( 难度等级: [0.4718, 0.4719) || 挂载数据: 无 ) 
│       │   └── 匿名函数 --> ( 难度等级: [0.4719, 0.4722) || 挂载数据: 无 ) 
│       ├── 元编程 --> ( 难度等级: [0.4722, 0.475) || 挂载数据: 无 ) 
│       │   ├── 装饰器 --> ( 难度等级: [0.4722, 0.4724) || 挂载数据: 无 ) 
│       │   │   ├── 函数添加装饰器 --> ( 难度等级: [0.4722, 0.4722) || 挂载数据: qa: 1 ) 
│       │   │   ├── 装饰器中保留函数元信息 --> ( 难度等级: [0.4722, 0.4723) || 挂载数据: 无 ) 
│       │   │   ├── 解除装饰器 --> ( 难度等级: [0.4723, 0.4723) || 挂载数据: qa: 3 ) 
│       │   │   ├── 带参数的装饰器 --> ( 难度等级: [0.4723, 0.4723) || 挂载数据: qa: 3 ) 
│       │   │   ├── 装饰器自定义属性 --> ( 难度等级: [0.4723, 0.4723) || 挂载数据: 无 ) 
│       │   │   ├── 带可选参数的装饰器 --> ( 难度等级: [0.4723, 0.4723) || 挂载数据: 无 ) 
│       │   │   ├── 函数的类型检查 --> ( 难度等级: [0.4723, 0.4723) || 挂载数据: 无 ) 
│       │   │   ├── 类中定义装饰器 --> ( 难度等级: [0.4723, 0.4724) || 挂载数据: 无 ) 
│       │   │   ├── 装饰器定义为类 --> ( 难度等级: [0.4724, 0.4724) || 挂载数据: 无 ) 
│       │   │   ├── 类和静态方法的装饰器 --> ( 难度等级: [0.4724, 0.4724) || 挂载数据: 无 ) 
│       │   │   ├── 给函数增加参数 --> ( 难度等级: [0.4724, 0.4724) || 挂载数据: qa: 1 ) 
│       │   │   └── 扩充类的功能 --> ( 难度等级: [0.4724, 0.4724) || 挂载数据: 无 ) 
│       │   ├── 元类 --> ( 难度等级: [0.4724, 0.4726) || 挂载数据: 无 ) 
│       │   │   └── 元类定义可选参数 --> ( 难度等级: [0.4724, 0.4726) || 挂载数据: qa: 1 ) 
│       │   ├── 类的属性定义顺序 --> ( 难度等级: [0.4726, 0.4729) || 挂载数据: 无 ) 
│       │   ├── 强制参数签名 --> ( 难度等级: [0.4729, 0.4731) || 挂载数据: 无 ) 
│       │   ├── 强制使用编程规约 --> ( 难度等级: [0.4731, 0.4733) || 挂载数据: 无 ) 
│       │   ├── 以编程方式定义类 --> ( 难度等级: [0.4733, 0.4735) || 挂载数据: 无 ) 
│       │   ├── 初始化类的成员 --> ( 难度等级: [0.4735, 0.4737) || 挂载数据: 无 ) 
│       │   ├── 利用注解实现方法重载 --> ( 难度等级: [0.4737, 0.4739) || 挂载数据: 无 ) 
│       │   ├── 避免重复的属性方法 --> ( 难度等级: [0.4739, 0.4741) || 挂载数据: 无 ) 
│       │   ├── 定义上下文管理器 --> ( 难度等级: [0.4741, 0.4744) || 挂载数据: 无 ) 
│       │   ├── 局部变量域中执行代码 --> ( 难度等级: [0.4744, 0.4746) || 挂载数据: 无 ) 
│       │   ├── Python源码解析 --> ( 难度等级: [0.4746, 0.4748) || 挂载数据: 无 ) 
│       │   └── Python字节码拆解 --> ( 难度等级: [0.4748, 0.475) || 挂载数据: 无 ) 
│       ├── 并发编程 --> ( 难度等级: [0.475, 0.4778) || 挂载数据: 无 ) 
│       │   ├── 线程处理 --> ( 难度等级: [0.475, 0.4754) || 挂载数据: 无 ) 
│       │   │   ├── 线程的启动与停止 --> ( 难度等级: [0.475, 0.4751) || 挂载数据: qa: 1 ) 
│       │   │   ├── 线程判断 --> ( 难度等级: [0.4751, 0.4751) || 挂载数据: qa: 4 ) 
│       │   │   ├── 线程间通信 --> ( 难度等级: [0.4751, 0.4752) || 挂载数据: 无 ) 
│       │   │   ├── 线程加锁 --> ( 难度等级: [0.4752, 0.4752) || 挂载数据: 无 ) 
│       │   │   ├── 防止死锁 --> ( 难度等级: [0.4752, 0.4753) || 挂载数据: 无 ) 
│       │   │   ├── 线程状态信息保存 --> ( 难度等级: [0.4753, 0.4753) || 挂载数据: 无 ) 
│       │   │   └── 创建线程池 --> ( 难度等级: [0.4753, 0.4754) || 挂载数据: qa: 1 ) 
│       │   ├── 并行编程 --> ( 难度等级: [0.4754, 0.4758) || 挂载数据: 无 ) 
│       │   ├── Actor任务定义 --> ( 难度等级: [0.4758, 0.4762) || 挂载数据: 无 ) 
│       │   ├── 消息发布/订阅模型 --> ( 难度等级: [0.4762, 0.4766) || 挂载数据: 无 ) 
│       │   ├── 生成器代替线程 --> ( 难度等级: [0.4766, 0.477) || 挂载数据: 无 ) 
│       │   ├── 线程队列轮询 --> ( 难度等级: [0.477, 0.4774) || 挂载数据: 无 ) 
│       │   └── 守护进程 --> ( 难度等级: [0.4774, 0.4778) || 挂载数据: 无 ) 
│       ├── 脚本编程与系统管理 --> ( 难度等级: [0.4778, 0.4806) || 挂载数据: 无 ) 
│       │   ├── 脚本接收 --> ( 难度等级: [0.4778, 0.4781) || 挂载数据: qa: 2 ) 
│       │   ├── 终止程序 --> ( 难度等级: [0.4781, 0.4784) || 挂载数据: 无 ) 
│       │   ├── 解析命令行选项 --> ( 难度等级: [0.4784, 0.4787) || 挂载数据: 无 ) 
│       │   ├── 弹出密码输入提示 --> ( 难度等级: [0.4787, 0.479) || 挂载数据: qa: 3 ) 
│       │   ├── 执行外部命令 --> ( 难度等级: [0.479, 0.4793) || 挂载数据: qa: 2 ) 
│       │   ├── 添加日志 --> ( 难度等级: [0.4793, 0.4796) || 挂载数据: 无 ) 
│       │   │   ├── 脚本增加日志功能 --> ( 难度等级: [0.4793, 0.4795) || 挂载数据: 无 ) 
│       │   │   └── 函数库增加日志功能 --> ( 难度等级: [0.4795, 0.4796) || 挂载数据: 无 ) 
│       │   ├── 实现计时器 --> ( 难度等级: [0.4796, 0.4799) || 挂载数据: 无 ) 
│       │   ├── 内存和CPU监测 --> ( 难度等级: [0.4799, 0.4802) || 挂载数据: 无 ) 
│       │   └── 启动Web浏览器 --> ( 难度等级: [0.4802, 0.4806) || 挂载数据: 无 ) 
│       ├── Python的内存管理机制 --> ( 难度等级: [0.4806, 0.4833) || 挂载数据: 无 ) 
│       │   ├── Python内存架构 --> ( 难度等级: [0.4806, 0.4813) || 挂载数据: 无 ) 
│       │   ├── 小块空间的内存池 --> ( 难度等级: [0.4813, 0.4819) || 挂载数据: 无 ) 
│       │   │   ├── block --> ( 难度等级: [0.4813, 0.4814) || 挂载数据: 无 ) 
│       │   │   ├── pool --> ( 难度等级: [0.4814, 0.4816) || 挂载数据: 无 ) 
│       │   │   ├── arena --> ( 难度等级: [0.4816, 0.4818) || 挂载数据: 无 ) 
│       │   │   └── 内存池 --> ( 难度等级: [0.4818, 0.4819) || 挂载数据: qa: 1 ) 
│       │   ├── 循环引用的垃圾收集 --> ( 难度等级: [0.4819, 0.4826) || 挂载数据: 无 ) 
│       │   │   └── 三色标记模型 --> ( 难度等级: [0.4819, 0.4826) || 挂载数据: 无 ) 
│       │   └── Python垃圾收集 --> ( 难度等级: [0.4826, 0.4833) || 挂载数据: 无 ) 
│       │       ├── 可收集对象链表 --> ( 难度等级: [0.4826, 0.4829) || 挂载数据: 无 ) 
│       │       ├── 分代垃圾收集 --> ( 难度等级: [0.4829, 0.4831) || 挂载数据: 无 ) 
│       │       └── Python中的标记—清除方法 --> ( 难度等级: [0.4831, 0.4833) || 挂载数据: 无 ) 
│       ├── 性能优化与实践 --> ( 难度等级: [0.4833, 0.4861) || 挂载数据: 无 ) 
│       │   ├── 优化的规则 --> ( 难度等级: [0.4833, 0.484) || 挂载数据: 无 ) 
│       │   │   ├── 先使程序可以正常工作 --> ( 难度等级: [0.4833, 0.4836) || 挂载数据: 无 ) 
│       │   │   ├── 从用户的角度进行 --> ( 难度等级: [0.4836, 0.4838) || 挂载数据: 无 ) 
│       │   │   └── 保证代码易读 --> ( 难度等级: [0.4838, 0.484) || 挂载数据: 无 ) 
│       │   ├── 优化策略 --> ( 难度等级: [0.484, 0.4847) || 挂载数据: 无 ) 
│       │   │   ├── 寻找其他原因 --> ( 难度等级: [0.484, 0.4843) || 挂载数据: qa: 7 ) 
│       │   │   ├── 度量硬件 --> ( 难度等级: [0.4843, 0.4845) || 挂载数据: 无 ) 
│       │   │   └── 编写速度测试代码 --> ( 难度等级: [0.4845, 0.4847) || 挂载数据: 无 ) 
│       │   ├── 查找瓶颈 --> ( 难度等级: [0.4847, 0.4854) || 挂载数据: 无 ) 
│       │   │   ├── 剖析CPU使用情况 --> ( 难度等级: [0.4847, 0.4851) || 挂载数据: qa: 1 ) 
│       │   │   └── 剖析内存使用情况 --> ( 难度等级: [0.4851, 0.4854) || 挂载数据: 无 ) 
│       │   └── 降低复杂度 --> ( 难度等级: [0.4854, 0.4861) || 挂载数据: 无 ) 
│       │       ├── 测量回路复杂度 --> ( 难度等级: [0.4854, 0.4856) || 挂载数据: 无 ) 
│       │       ├── 测量大O记号 --> ( 难度等级: [0.4856, 0.4859) || 挂载数据: 无 ) 
│       │       └── 简化 --> ( 难度等级: [0.4859, 0.4861) || 挂载数据: qa: 1 ) 
│       ├── 通用应用主题 --> ( 难度等级: [0.4861, 0.4889) || 挂载数据: 无 ) 
│       │   ├── 因特网客户端编程 --> ( 难度等级: [0.4861, 0.4866) || 挂载数据: 无 ) 
│       │   │   ├── 因特网客户端简介 --> ( 难度等级: [0.4861, 0.4863) || 挂载数据: 无 ) 
│       │   │   ├── 文件传输 --> ( 难度等级: [0.4863, 0.4864) || 挂载数据: 无 ) 
│       │   │   │   ├── 文件传输因特网协议 --> ( 难度等级: [0.4863, 0.4863) || 挂载数据: 无 ) 
│       │   │   │   ├── 文件传输协议 --> ( 难度等级: [0.4863, 0.4863) || 挂载数据: 无 ) 
│       │   │   │   ├── ftplib.FTP类的方法 --> ( 难度等级: [0.4863, 0.4863) || 挂载数据: 无 ) 
│       │   │   │   ├── 交互式FTP示例 --> ( 难度等级: [0.4863, 0.4864) || 挂载数据: 无 ) 
│       │   │   │   ├── 客户端FTP程序示例 --> ( 难度等级: [0.4864, 0.4864) || 挂载数据: 无 ) 
│       │   │   │   └── FTP的其他内容 --> ( 难度等级: [0.4864, 0.4864) || 挂载数据: qa: 1 ) 
│       │   │   └── 网络新闻 --> ( 难度等级: [0.4864, 0.4866) || 挂载数据: 无 ) 
│       │   │       ├── Usenet与新闻组 --> ( 难度等级: [0.4864, 0.4864) || 挂载数据: 无 ) 
│       │   │       ├── 网络新闻传输协议 --> ( 难度等级: [0.4864, 0.4865) || 挂载数据: 无 ) 
│       │   │       ├── nntplib.NNTP类方法 --> ( 难度等级: [0.4865, 0.4865) || 挂载数据: 无 ) 
│       │   │       ├── 交互式NNTP示例 --> ( 难度等级: [0.4865, 0.4865) || 挂载数据: 无 ) 
│       │   │       ├── 客户端程序NNTP示例 --> ( 难度等级: [0.4865, 0.4865) || 挂载数据: 无 ) 
│       │   │       └── NNTP的其他内容 --> ( 难度等级: [0.4865, 0.4866) || 挂载数据: 无 ) 
│       │   ├── 多线程编程 --> ( 难度等级: [0.4866, 0.487) || 挂载数据: 无 ) 
│       │   │   ├── thread模块 --> ( 难度等级: [0.4866, 0.4867) || 挂载数据: 无 ) 
│       │   │   ├── threading模块 --> ( 难度等级: [0.4867, 0.4868) || 挂载数据: 无 ) 
│       │   │   │   ├── Thread类 --> ( 难度等级: [0.4867, 0.4867) || 挂载数据: 无 ) 
│       │   │   │   └── threading模块的其他函数 --> ( 难度等级: [0.4867, 0.4868) || 挂载数据: qa: 2 ) 
│       │   │   ├── 单线程和多线程执行对比 --> ( 难度等级: [0.4868, 0.4869) || 挂载数据: qa: 1 ) 
│       │   │   ├── 多线程实践 --> ( 难度等级: [0.4869, 0.4869) || 挂载数据: qa: 5 ) 
│       │   │   │   ├── 图书排名示例 --> ( 难度等级: [0.4869, 0.4869) || 挂载数据: 无 ) 
│       │   │   │   ├── 同步原语 --> ( 难度等级: [0.4869, 0.4869) || 挂载数据: qa: 1 ) 
│       │   │   │   ├── 锁示例 --> ( 难度等级: [0.4869, 0.4869) || 挂载数据: 无 ) 
│       │   │   │   └── 信号量示例 --> ( 难度等级: [0.4869, 0.4869) || 挂载数据: 无 ) 
│       │   │   └── 线程的替代方案 --> ( 难度等级: [0.4869, 0.487) || 挂载数据: qa: 1 ) 
│       │   │       ├── subprocess模块 --> ( 难度等级: [0.4869, 0.487) || 挂载数据: qa: 1 ) 
│       │   │       ├── multiprocessing模块 --> ( 难度等级: [0.487, 0.487) || 挂载数据: 无 ) 
│       │   │       └── concurrent.futures模块 --> ( 难度等级: [0.487, 0.487) || 挂载数据: 无 ) 
│       │   ├── GUI编程 --> ( 难度等级: [0.487, 0.4875) || 挂载数据: 无 ) 
│       │   │   ├── Tkinter示例 --> ( 难度等级: [0.487, 0.4873) || 挂载数据: 无 ) 
│       │   │   │   ├── Label控件 --> ( 难度等级: [0.487, 0.4871) || 挂载数据: qa: 1 ) 
│       │   │   │   ├── Button控件 --> ( 难度等级: [0.4871, 0.4871) || 挂载数据: qa: 3 ) 
│       │   │   │   ├── Label和Button控件 --> ( 难度等级: [0.4871, 0.4872) || 挂载数据: 无 ) 
│       │   │   │   ├── Label、Button和Scale控件 --> ( 难度等级: [0.4872, 0.4872) || 挂载数据: 无 ) 
│       │   │   │   ├── 偏函数应用示例 --> ( 难度等级: [0.4872, 0.4872) || 挂载数据: 无 ) 
│       │   │   │   └── 中级Tkinter示例 --> ( 难度等级: [0.4872, 0.4873) || 挂载数据: qa: 10 ) 
│       │   │   └── 其他GUI简介 --> ( 难度等级: [0.4873, 0.4875) || 挂载数据: 无 ) 
│       │   │       ├── Tk接口扩展（Tix） --> ( 难度等级: [0.4873, 0.4873) || 挂载数据: 无 ) 
│       │   │       ├── Python MegaWidgets（PMW） --> ( 难度等级: [0.4873, 0.4874) || 挂载数据: 无 ) 
│       │   │       ├── GTK+和PyGTK --> ( 难度等级: [0.4874, 0.4874) || 挂载数据: 无 ) 
│       │   │       └── Tile/Ttk --> ( 难度等级: [0.4874, 0.4875) || 挂载数据: 无 ) 
│       │   ├── 数据库编程 --> ( 难度等级: [0.4875, 0.488) || 挂载数据: qa: 1 ) 
│       │   │   ├── Python的DB-API --> ( 难度等级: [0.4875, 0.4876) || 挂载数据: qa: 1 ) 
│       │   │   │   ├── 模块属性 --> ( 难度等级: [0.4875, 0.4875) || 挂载数据: 无 ) 
│       │   │   │   ├── Connection对象 --> ( 难度等级: [0.4875, 0.4875) || 挂载数据: 无 ) 
│       │   │   │   ├── Cursor对象 --> ( 难度等级: [0.4875, 0.4876) || 挂载数据: qa: 3 ) 
│       │   │   │   ├── 关系数据库 --> ( 难度等级: [0.4876, 0.4876) || 挂载数据: 无 ) 
│       │   │   │   ├── 使用数据库适配器的示例 --> ( 难度等级: [0.4876, 0.4876) || 挂载数据: 无 ) 
│       │   │   │   └── 数据库适配器示例应用 --> ( 难度等级: [0.4876, 0.4876) || 挂载数据: 无 ) 
│       │   │   ├── ORM --> ( 难度等级: [0.4876, 0.4877) || 挂载数据: 无 ) 
│       │   │   │   ├── 考虑对象，而不是SQL --> ( 难度等级: [0.4876, 0.4876) || 挂载数据: 无 ) 
│       │   │   │   ├── 员工角色数据库示例 --> ( 难度等级: [0.4876, 0.4877) || 挂载数据: 无 ) 
│       │   │   │   ├── SQLAlchemy --> ( 难度等级: [0.4877, 0.4877) || 挂载数据: qa: 2 ) 
│       │   │   │   └── SQLObject --> ( 难度等级: [0.4877, 0.4877) || 挂载数据: 无 ) 
│       │   │   ├── 非关系数据库 --> ( 难度等级: [0.4877, 0.4878) || 挂载数据: 无 ) 
│       │   │   │   └── NoSQL介绍 --> ( 难度等级: [0.4877, 0.4878) || 挂载数据: 无 ) 
│       │   │   └── 相关文献 --> ( 难度等级: [0.4878, 0.488) || 挂载数据: 无 ) 
│       │   ├── *Microsoft Office编程 --> ( 难度等级: [0.488, 0.4884) || 挂载数据: 无 ) 
│       │   │   ├── 使用Python进行COM客户端编程 --> ( 难度等级: [0.488, 0.4881) || 挂载数据: 无 ) 
│       │   │   │   ├── 客户端COM编程 --> ( 难度等级: [0.488, 0.488) || 挂载数据: qa: 10 ) 
│       │   │   │   └── 入门 --> ( 难度等级: [0.488, 0.4881) || 挂载数据: qa: 6 ) 
│       │   │   ├── 入门示例 --> ( 难度等级: [0.4881, 0.4882) || 挂载数据: 无 ) 
│       │   │   │   ├── Excel --> ( 难度等级: [0.4881, 0.4881) || 挂载数据: 无 ) 
│       │   │   │   ├── Word --> ( 难度等级: [0.4881, 0.4881) || 挂载数据: 无 ) 
│       │   │   │   ├── PowerPoint --> ( 难度等级: [0.4881, 0.4882) || 挂载数据: 无 ) 
│       │   │   │   └── Outlook --> ( 难度等级: [0.4882, 0.4882) || 挂载数据: 无 ) 
│       │   │   ├── 中级示例 --> ( 难度等级: [0.4882, 0.4883) || 挂载数据: 无 ) 
│       │   │   │   ├── Excel --> ( 难度等级: [0.4882, 0.4882) || 挂载数据: 无 ) 
│       │   │   │   ├── Outlook --> ( 难度等级: [0.4882, 0.4883) || 挂载数据: qa: 1 ) 
│       │   │   │   └── PowerPoint --> ( 难度等级: [0.4883, 0.4883) || 挂载数据: 无 ) 
│       │   │   └── 相关模块/包 --> ( 难度等级: [0.4883, 0.4884) || 挂载数据: 无 ) 
│       │   └── 扩展Python --> ( 难度等级: [0.4884, 0.4889) || 挂载数据: 无 ) 
│       │       ├── 编写Python扩展 --> ( 难度等级: [0.4884, 0.4887) || 挂载数据: 无 ) 
│       │       │   ├── 根据样板编写封装代码 --> ( 难度等级: [0.4884, 0.4885) || 挂载数据: qa: 10 ) 
│       │       │   ├── 编译 --> ( 难度等级: [0.4885, 0.4886) || 挂载数据: qa: 2 ) 
│       │       │   └── 导入并测试 --> ( 难度等级: [0.4886, 0.4887) || 挂载数据: 无 ) 
│       │       └── 相关主题 --> ( 难度等级: [0.4887, 0.4889) || 挂载数据: qa: 2 ) 
│       │           ├── SWIG --> ( 难度等级: [0.4887, 0.4887) || 挂载数据: 无 ) 
│       │           ├── Pyrex --> ( 难度等级: [0.4887, 0.4887) || 挂载数据: 无 ) 
│       │           ├── Cython --> ( 难度等级: [0.4887, 0.4888) || 挂载数据: 无 ) 
│       │           ├── Psyco --> ( 难度等级: [0.4888, 0.4888) || 挂载数据: 无 ) 
│       │           ├── PyPy --> ( 难度等级: [0.4888, 0.4889) || 挂载数据: 无 ) 
│       │           └── 嵌入Python --> ( 难度等级: [0.4889, 0.4889) || 挂载数据: 无 ) 
│       ├── Python中使用正则表达式 --> ( 难度等级: [0.4889, 0.4917) || 挂载数据: 无 ) 
│       │   ├── 正则表达式语法 --> ( 难度等级: [0.4889, 0.4903) || 挂载数据: qa: 1 ) 
│       │   │   ├── 行定位符 --> ( 难度等级: [0.4889, 0.489) || 挂载数据: 无 ) 
│       │   │   ├── 元字符 --> ( 难度等级: [0.489, 0.4892) || 挂载数据: 无 ) 
│       │   │   ├── 重复 --> ( 难度等级: [0.4892, 0.4894) || 挂载数据: qa: 1 ) 
│       │   │   ├── 字符类 --> ( 难度等级: [0.4894, 0.4895) || 挂载数据: 无 ) 
│       │   │   ├── 排除字符 --> ( 难度等级: [0.4895, 0.4897) || 挂载数据: qa: 2 ) 
│       │   │   ├── 选择字符 --> ( 难度等级: [0.4897, 0.4898) || 挂载数据: qa: 3 ) 
│       │   │   ├── 转义字符 --> ( 难度等级: [0.4898, 0.49) || 挂载数据: qa: 2 ) 
│       │   │   ├── 分组 --> ( 难度等级: [0.49, 0.4901) || 挂载数据: qa: 2 ) 
│       │   │   └── 在Python中使用正则 --> ( 难度等级: [0.4901, 0.4903) || 挂载数据: qa: 2 ) 
│       │   └── 使用re模块实现正则表达式操作 --> ( 难度等级: [0.4903, 0.4917) || 挂载数据: qa: 1 ) 
│       │       ├── 替换字符串 --> ( 难度等级: [0.4903, 0.491) || 挂载数据: qa: 1 ) 
│       │       └── 使用正则表达式分割字符串 --> ( 难度等级: [0.491, 0.4917) || 挂载数据: qa: 10 ) 
│       ├── 面向对象程序设计 --> ( 难度等级: [0.4917, 0.4944) || 挂载数据: 无 ) 
│       │   ├── 面向对象概述 --> ( 难度等级: [0.4917, 0.4926) || 挂载数据: 无 ) 
│       │   │   └── 面向对象程序设计的特点 --> ( 难度等级: [0.4917, 0.4926) || 挂载数据: qa: 6 ) 
│       │   ├── 类的定义和使用 --> ( 难度等级: [0.4926, 0.4935) || 挂载数据: 无 ) 
│       │   │   ├── 定义类 --> ( 难度等级: [0.4926, 0.4928) || 挂载数据: qa: 10 ) 
│       │   │   ├── 创建__init__方法 --> ( 难度等级: [0.4928, 0.4931) || 挂载数据: qa: 2 ) 
│       │   │   ├── 创建类的成员并访问 --> ( 难度等级: [0.4931, 0.4933) || 挂载数据: qa: 1 ) 
│       │   │   └── 访问限制 --> ( 难度等级: [0.4933, 0.4935) || 挂载数据: qa: 1 ) 
│       │   └── 继承 --> ( 难度等级: [0.4935, 0.4944) || 挂载数据: 无 ) 
│       │       ├── 继承的基本语法 --> ( 难度等级: [0.4935, 0.4938) || 挂载数据: qa: 1 ) 
│       │       ├── 方法重写 --> ( 难度等级: [0.4938, 0.4941) || 挂载数据: 无 ) 
│       │       └── 派生类中调用基类的__init__方法 --> ( 难度等级: [0.4941, 0.4944) || 挂载数据: qa: 1 ) 
│       ├── 模块 --> ( 难度等级: [0.4944, 0.4972) || 挂载数据: 无 ) 
│       │   ├── 模块概述 --> ( 难度等级: [0.4944, 0.4951) || 挂载数据: 无 ) 
│       │   ├── 自定义模块 --> ( 难度等级: [0.4951, 0.4958) || 挂载数据: 无 ) 
│       │   │   ├── 创建模块 --> ( 难度等级: [0.4951, 0.4953) || 挂载数据: qa: 10 ) 
│       │   │   ├── 使用import语句导入模块 --> ( 难度等级: [0.4953, 0.4955) || 挂载数据: qa: 9 ) 
│       │   │   ├── 使用from…import语句 --> ( 难度等级: [0.4955, 0.4957) || 挂载数据: qa: 1 ) 
│       │   │   └── 模块搜索目录 --> ( 难度等级: [0.4957, 0.4958) || 挂载数据: 无 ) 
│       │   ├── Python中的包 --> ( 难度等级: [0.4958, 0.4965) || 挂载数据: 无 ) 
│       │   │   ├── Python程序的包结构 --> ( 难度等级: [0.4958, 0.4962) || 挂载数据: 无 ) 
│       │   │   └── 以主程序的形式执行 --> ( 难度等级: [0.4962, 0.4965) || 挂载数据: 无 ) 
│       │   └── 引用其他模块 --> ( 难度等级: [0.4965, 0.4972) || 挂载数据: 无 ) 
│       └── 异常处理及程序调试 --> ( 难度等级: [0.4972, 0.5) || 挂载数据: 无 ) 
│           ├── 异常概述 --> ( 难度等级: [0.4972, 0.4981) || 挂载数据: 无 ) 
│           ├── 异常处理语句 --> ( 难度等级: [0.4981, 0.4991) || 挂载数据: 无 ) 
│           │   ├── try…except语句 --> ( 难度等级: [0.4981, 0.4984) || 挂载数据: qa: 3 ) 
│           │   ├── try…except…else语句 --> ( 难度等级: [0.4984, 0.4986) || 挂载数据: 无 ) 
│           │   ├── try…except…finally语句 --> ( 难度等级: [0.4986, 0.4988) || 挂载数据: 无 ) 
│           │   └── 使用raise语句抛出异常 --> ( 难度等级: [0.4988, 0.4991) || 挂载数据: qa: 2 ) 
│           └── 程序调试 --> ( 难度等级: [0.4991, 0.5) || 挂载数据: 无 ) 
│               ├── 使用自带的IDLE进行程序调试 --> ( 难度等级: [0.4991, 0.4995) || 挂载数据: 无 ) 
│               └── 使用assert语句调试程序 --> ( 难度等级: [0.4995, 0.5) || 挂载数据: qa: 1 ) 
├── Python高阶 --> ( 难度等级: [0.5, 0.75) || 挂载数据: 无 ) 
│   ├── 科学计算基础软件包NumPy --> ( 难度等级: [0.5, 0.5312) || 挂载数据: 无 ) 
│   │   ├── NumPy概述 --> ( 难度等级: [0.5, 0.5039) || 挂载数据: 无 ) 
│   │   │   ├── NumPy的前世今生 --> ( 难度等级: [0.5, 0.5008) || 挂载数据: 无 ) 
│   │   │   ├── NumPy数组vs Python列表 --> ( 难度等级: [0.5008, 0.5016) || 挂载数据: 无 ) 
│   │   │   ├── NumPy数组类型和属性 --> ( 难度等级: [0.5016, 0.5023) || 挂载数据: 无 ) 
│   │   │   ├── 维、轴、秩 --> ( 难度等级: [0.5023, 0.5031) || 挂载数据: 无 ) 
│   │   │   └── 广播和矢量化 --> ( 难度等级: [0.5031, 0.5039) || 挂载数据: 无 ) 
│   │   ├── 安装配置 --> ( 难度等级: [0.5039, 0.5078) || 挂载数据: 无 ) 
│   │   ├── 创建数组 --> ( 难度等级: [0.5078, 0.5117) || 挂载数据: 无 ) 
│   │   ├── 操作数组 --> ( 难度等级: [0.5117, 0.5156) || 挂载数据: 无 ) 
│   │   │   ├── 索引 --> ( 难度等级: [0.5117, 0.5122) || 挂载数据: 无 ) 
│   │   │   ├── 切片 --> ( 难度等级: [0.5122, 0.5126) || 挂载数据: qa: 2 ) 
│   │   │   ├── 改变数组结构 --> ( 难度等级: [0.5126, 0.513) || 挂载数据: 无 ) 
│   │   │   ├── 合并和拆分 --> ( 难度等级: [0.513, 0.5135) || 挂载数据: 无 ) 
│   │   │   ├── 复制 --> ( 难度等级: [0.5135, 0.5139) || 挂载数据: 无 ) 
│   │   │   ├── 排序 --> ( 难度等级: [0.5139, 0.5143) || 挂载数据: 无 ) 
│   │   │   ├── 查找 --> ( 难度等级: [0.5143, 0.5148) || 挂载数据: qa: 2 ) 
│   │   │   ├── 筛选 --> ( 难度等级: [0.5148, 0.5152) || 挂载数据: qa: 1 ) 
│   │   │   └── 数组I/O --> ( 难度等级: [0.5152, 0.5156) || 挂载数据: qa: 1 ) 
│   │   ├── 常用函数 --> ( 难度等级: [0.5156, 0.5195) || 挂载数据: 无 ) 
│   │   │   ├── np.nan和np.inf --> ( 难度等级: [0.5156, 0.5162) || 挂载数据: qa: 4 ) 
│   │   │   ├── 函数命名空间 --> ( 难度等级: [0.5162, 0.5167) || 挂载数据: 无 ) 
│   │   │   ├── 数学函数 --> ( 难度等级: [0.5167, 0.5173) || 挂载数据: 无 ) 
│   │   │   ├── 统计函数 --> ( 难度等级: [0.5173, 0.5179) || 挂载数据: 无 ) 
│   │   │   ├── 插值函数 --> ( 难度等级: [0.5179, 0.5184) || 挂载数据: 无 ) 
│   │   │   ├── 多项式拟合函数 --> ( 难度等级: [0.5184, 0.519) || 挂载数据: 无 ) 
│   │   │   └── 自定义广播函数 --> ( 难度等级: [0.519, 0.5195) || 挂载数据: 无 ) 
│   │   ├── 掩码数组 --> ( 难度等级: [0.5195, 0.5234) || 挂载数据: 无 ) 
│   │   │   ├── 创建掩码数组 --> ( 难度等级: [0.5195, 0.5215) || 挂载数据: 无 ) 
│   │   │   └── 访问掩码数组 --> ( 难度等级: [0.5215, 0.5234) || 挂载数据: 无 ) 
│   │   ├── 矩阵对象 --> ( 难度等级: [0.5234, 0.5273) || 挂载数据: 无 ) 
│   │   │   ├── 创建矩阵 --> ( 难度等级: [0.5234, 0.5247) || 挂载数据: qa: 3 ) 
│   │   │   ├── 矩阵特有属性 --> ( 难度等级: [0.5247, 0.526) || 挂载数据: 无 ) 
│   │   │   └── 矩阵乘法 --> ( 难度等级: [0.526, 0.5273) || 挂载数据: 无 ) 
│   │   └── 随机抽样子模块 --> ( 难度等级: [0.5273, 0.5312) || 挂载数据: 无 ) 
│   │       ├── 随机数 --> ( 难度等级: [0.5273, 0.5283) || 挂载数据: 无 ) 
│   │       ├── 随机抽样 --> ( 难度等级: [0.5283, 0.5293) || 挂载数据: 无 ) 
│   │       ├── 正态分布 --> ( 难度等级: [0.5293, 0.5303) || 挂载数据: 无 ) 
│   │       └── 伪随机数的深度思考 --> ( 难度等级: [0.5303, 0.5312) || 挂载数据: 无 ) 
│   ├── 结构化数据分析工具Pandas --> ( 难度等级: [0.5312, 0.5625) || 挂载数据: 无 ) 
│   │   ├── Pandas概览 --> ( 难度等级: [0.5312, 0.5391) || 挂载数据: 无 ) 
│   │   │   ├── Panda的特点 --> ( 难度等级: [0.5312, 0.5352) || 挂载数据: 无 ) 
│   │   │   └── 安装和使用 --> ( 难度等级: [0.5352, 0.5391) || 挂载数据: qa: 1 ) 
│   │   ├── 数据结构 --> ( 难度等级: [0.5391, 0.5469) || 挂载数据: 无 ) 
│   │   │   ├── 索引数组Index --> ( 难度等级: [0.5391, 0.5417) || 挂载数据: 无 ) 
│   │   │   ├── 带标签的一维同构数组Series --> ( 难度等级: [0.5417, 0.5443) || 挂载数据: 无 ) 
│   │   │   └── 带标签的二维异构表格DataFrame --> ( 难度等级: [0.5443, 0.5469) || 挂载数据: qa: 2 ) 
│   │   ├── 基本操作 --> ( 难度等级: [0.5469, 0.5547) || 挂载数据: 无 ) 
│   │   │   ├── 数据预览 --> ( 难度等级: [0.5469, 0.5482) || 挂载数据: 无 ) 
│   │   │   ├── 数据选择 --> ( 难度等级: [0.5482, 0.5495) || 挂载数据: 无 ) 
│   │   │   ├── 改变数据结构 --> ( 难度等级: [0.5495, 0.5508) || 挂载数据: 无 ) 
│   │   │   ├── 改变数据类型 --> ( 难度等级: [0.5508, 0.5521) || 挂载数据: 无 ) 
│   │   │   ├── 广播与矢量化运算 --> ( 难度等级: [0.5521, 0.5534) || 挂载数据: 无 ) 
│   │   │   └── 行列级广播函数 --> ( 难度等级: [0.5534, 0.5547) || 挂载数据: qa: 1 ) 
│   │   └── 高级应用 --> ( 难度等级: [0.5547, 0.5625) || 挂载数据: 无 ) 
│   │       ├── 分组 --> ( 难度等级: [0.5547, 0.5557) || 挂载数据: 无 ) 
│   │       ├── 聚合 --> ( 难度等级: [0.5557, 0.5566) || 挂载数据: 无 ) 
│   │       ├── 层次化索引 --> ( 难度等级: [0.5566, 0.5576) || 挂载数据: 无 ) 
│   │       ├── 表级广播函数 --> ( 难度等级: [0.5576, 0.5586) || 挂载数据: 无 ) 
│   │       ├── 日期时间索引对象 --> ( 难度等级: [0.5586, 0.5596) || 挂载数据: 无 ) 
│   │       ├── 透视表 --> ( 难度等级: [0.5596, 0.5605) || 挂载数据: 无 ) 
│   │       ├── 数据可视化 --> ( 难度等级: [0.5605, 0.5615) || 挂载数据: qa: 4 ) 
│   │       └── 数据I/O --> ( 难度等级: [0.5615, 0.5625) || 挂载数据: 无 ) 
│   ├── 绘图库Matplotlib --> ( 难度等级: [0.5625, 0.5938) || 挂载数据: 无 ) 
│   │   ├── 安装配置 --> ( 难度等级: [0.5625, 0.5687) || 挂载数据: 无 ) 
│   │   ├── Matplotlib快速入门 --> ( 难度等级: [0.5687, 0.575) || 挂载数据: 无 ) 
│   │   │   ├── 画布 --> ( 难度等级: [0.5687, 0.57) || 挂载数据: qa: 1 ) 
│   │   │   ├── 子图与子图布局 --> ( 难度等级: [0.57, 0.5712) || 挂载数据: 无 ) 
│   │   │   ├── 坐标轴与刻度的名称 --> ( 难度等级: [0.5712, 0.5725) || 挂载数据: qa: 1 ) 
│   │   │   ├── 图例和文本标注 --> ( 难度等级: [0.5725, 0.5737) || 挂载数据: 无 ) 
│   │   │   └── 显示和保存 --> ( 难度等级: [0.5737, 0.575) || 挂载数据: 无 ) 
│   │   ├── 图形绘制 --> ( 难度等级: [0.575, 0.5813) || 挂载数据: qa: 2 ) 
│   │   │   ├── 曲线图 --> ( 难度等级: [0.575, 0.5759) || 挂载数据: 无 ) 
│   │   │   ├── 散点图 --> ( 难度等级: [0.5759, 0.5768) || 挂载数据: 无 ) 
│   │   │   ├── 直方图 --> ( 难度等级: [0.5768, 0.5777) || 挂载数据: 无 ) 
│   │   │   ├── 饼图 --> ( 难度等级: [0.5777, 0.5786) || 挂载数据: qa: 1 ) 
│   │   │   ├── 箱线图 --> ( 难度等级: [0.5786, 0.5795) || 挂载数据: 无 ) 
│   │   │   ├── 绘制图像 --> ( 难度等级: [0.5795, 0.5804) || 挂载数据: qa: 10 ) 
│   │   │   └── 极坐标绘图 --> ( 难度等级: [0.5804, 0.5813) || 挂载数据: qa: 1 ) 
│   │   ├── 风格和样式 --> ( 难度等级: [0.5813, 0.5875) || 挂载数据: 无 ) 
│   │   │   ├── 画布设置 --> ( 难度等级: [0.5813, 0.5819) || 挂载数据: 无 ) 
│   │   │   ├── 子图布局 --> ( 难度等级: [0.5819, 0.5826) || 挂载数据: 无 ) 
│   │   │   ├── 颜色 --> ( 难度等级: [0.5826, 0.5833) || 挂载数据: 无 ) 
│   │   │   ├── 线条和点的样式 --> ( 难度等级: [0.5833, 0.584) || 挂载数据: 无 ) 
│   │   │   ├── 坐标轴 --> ( 难度等级: [0.584, 0.5847) || 挂载数据: 无 ) 
│   │   │   ├── 刻度 --> ( 难度等级: [0.5847, 0.5854) || 挂载数据: 无 ) 
│   │   │   ├── 文本 --> ( 难度等级: [0.5854, 0.5861) || 挂载数据: 无 ) 
│   │   │   ├── 图例 --> ( 难度等级: [0.5861, 0.5868) || 挂载数据: 无 ) 
│   │   │   └── 网格设置 --> ( 难度等级: [0.5868, 0.5875) || 挂载数据: 无 ) 
│   │   └── Matplotlib扩展 --> ( 难度等级: [0.5875, 0.5938) || 挂载数据: 无 ) 
│   │       ├── 使用BaseMap绘制地图 --> ( 难度等级: [0.5875, 0.5906) || 挂载数据: qa: 1 ) 
│   │       └── 3D绘图工具包 --> ( 难度等级: [0.5906, 0.5938) || 挂载数据: 无 ) 
│   ├── 科学计算工具包SciPy --> ( 难度等级: [0.5938, 0.625) || 挂载数据: 无 ) 
│   │   ├── SciPy概览 --> ( 难度等级: [0.5938, 0.5966) || 挂载数据: qa: 1 ) 
│   │   ├── 安装配置 --> ( 难度等级: [0.5966, 0.5994) || 挂载数据: 无 ) 
│   │   ├── 数据插值 --> ( 难度等级: [0.5994, 0.6023) || 挂载数据: 无 ) 
│   │   │   ├── 一维插值 --> ( 难度等级: [0.5994, 0.6004) || 挂载数据: 无 ) 
│   │   │   ├── 二维插值 --> ( 难度等级: [0.6004, 0.6013) || 挂载数据: 无 ) 
│   │   │   └── 离散数据插值到网格 --> ( 难度等级: [0.6013, 0.6023) || 挂载数据: 无 ) 
│   │   ├── 曲线拟合 --> ( 难度等级: [0.6023, 0.6051) || 挂载数据: 无 ) 
│   │   │   ├── 最小二乘法拟合 --> ( 难度等级: [0.6023, 0.6032) || 挂载数据: 无 ) 
│   │   │   ├── 使用curve_fit函数拟合 --> ( 难度等级: [0.6032, 0.6042) || 挂载数据: qa: 1 ) 
│   │   │   └── 多项式拟合函数 --> ( 难度等级: [0.6042, 0.6051) || 挂载数据: 无 ) 
│   │   ├── 傅里叶变换 --> ( 难度等级: [0.6051, 0.608) || 挂载数据: 无 ) 
│   │   │   ├── 时域到频域的转换 --> ( 难度等级: [0.6051, 0.6061) || 挂载数据: 无 ) 
│   │   │   ├── 一维傅里叶变换的应用 --> ( 难度等级: [0.6061, 0.607) || 挂载数据: 无 ) 
│   │   │   └── 二维傅里叶变换的应用 --> ( 难度等级: [0.607, 0.608) || 挂载数据: 无 ) 
│   │   ├── 图像处理 --> ( 难度等级: [0.608, 0.6108) || 挂载数据: 无 ) 
│   │   │   ├── 图像卷积 --> ( 难度等级: [0.608, 0.6087) || 挂载数据: 无 ) 
│   │   │   ├── 边缘检测 --> ( 难度等级: [0.6087, 0.6094) || 挂载数据: 无 ) 
│   │   │   ├── 侵蚀和膨胀 --> ( 难度等级: [0.6094, 0.6101) || 挂载数据: 无 ) 
│   │   │   └── 图像测量 --> ( 难度等级: [0.6101, 0.6108) || 挂载数据: 无 ) 
│   │   ├── 积分 --> ( 难度等级: [0.6108, 0.6136) || 挂载数据: 无 ) 
│   │   │   ├── 对给定函数的定积分 --> ( 难度等级: [0.6108, 0.6117) || 挂载数据: 无 ) 
│   │   │   ├── 对给定样本的定积分 --> ( 难度等级: [0.6117, 0.6127) || 挂载数据: 无 ) 
│   │   │   └── 二重定积分 --> ( 难度等级: [0.6127, 0.6136) || 挂载数据: qa: 1 ) 
│   │   ├── 非线性方程求解 --> ( 难度等级: [0.6136, 0.6165) || 挂载数据: 无 ) 
│   │   │   ├── 非线性方程 --> ( 难度等级: [0.6136, 0.6151) || 挂载数据: qa: 3 ) 
│   │   │   └── 非线性方程组 --> ( 难度等级: [0.6151, 0.6165) || 挂载数据: 无 ) 
│   │   ├── 线性代数 --> ( 难度等级: [0.6165, 0.6193) || 挂载数据: 无 ) 
│   │   │   ├── 计算矩阵的行列式 --> ( 难度等级: [0.6165, 0.617) || 挂载数据: 无 ) 
│   │   │   ├── 求解逆矩阵 --> ( 难度等级: [0.617, 0.6176) || 挂载数据: 无 ) 
│   │   │   ├── 计算特征向量和特征值 --> ( 难度等级: [0.6176, 0.6182) || 挂载数据: 无 ) 
│   │   │   ├── 矩阵的奇异值分解 --> ( 难度等级: [0.6182, 0.6187) || 挂载数据: 无 ) 
│   │   │   └── 求解线性方程组 --> ( 难度等级: [0.6187, 0.6193) || 挂载数据: 无 ) 
│   │   ├── 聚类 --> ( 难度等级: [0.6193, 0.6222) || 挂载数据: 无 ) 
│   │   │   ├── k-means聚类 --> ( 难度等级: [0.6193, 0.6207) || 挂载数据: 无 ) 
│   │   │   └── 层次聚类 --> ( 难度等级: [0.6207, 0.6222) || 挂载数据: 无 ) 
│   │   └── 空间计算 --> ( 难度等级: [0.6222, 0.625) || 挂载数据: 无 ) 
│   │       ├── 空间旋转的表述 --> ( 难度等级: [0.6222, 0.6236) || 挂载数据: qa: 1 ) 
│   │       └── 三维旋转 --> ( 难度等级: [0.6236, 0.625) || 挂载数据: 无 ) 
│   ├── 数据分析 --> ( 难度等级: [0.625, 0.6562) || 挂载数据: 无 ) 
│   │   ├── Python基础 --> ( 难度等级: [0.625, 0.6264) || 挂载数据: 无 ) 
│   │   │   ├── 创建Python脚本 --> ( 难度等级: [0.625, 0.6252) || 挂载数据: 无 ) 
│   │   │   ├── 运行Python脚本 --> ( 难度等级: [0.6252, 0.6254) || 挂载数据: 无 ) 
│   │   │   ├── 与命令行进行交互的几项技巧 --> ( 难度等级: [0.6254, 0.6255) || 挂载数据: 无 ) 
│   │   │   ├── Python语言基础要素 --> ( 难度等级: [0.6255, 0.6257) || 挂载数据: 无 ) 
│   │   │   │   ├── 数值 --> ( 难度等级: [0.6255, 0.6256) || 挂载数据: qa: 3 ) 
│   │   │   │   ├── 字符串 --> ( 难度等级: [0.6256, 0.6256) || 挂载数据: 无 ) 
│   │   │   │   ├── 正则表达式与模式匹配 --> ( 难度等级: [0.6256, 0.6256) || 挂载数据: 无 ) 
│   │   │   │   ├── 日期 --> ( 难度等级: [0.6256, 0.6256) || 挂载数据: qa: 2 ) 
│   │   │   │   ├── 列表 --> ( 难度等级: [0.6256, 0.6256) || 挂载数据: 无 ) 
│   │   │   │   ├── 元组 --> ( 难度等级: [0.6256, 0.6257) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 字典 --> ( 难度等级: [0.6257, 0.6257) || 挂载数据: 无 ) 
│   │   │   │   └── 控制流 --> ( 难度等级: [0.6257, 0.6257) || 挂载数据: 无 ) 
│   │   │   ├── 读取文本文件 --> ( 难度等级: [0.6257, 0.6259) || 挂载数据: 无 ) 
│   │   │   │   ├── 创建文本文件 --> ( 难度等级: [0.6257, 0.6258) || 挂载数据: 无 ) 
│   │   │   │   ├── 脚本和输入文件在同一位置 --> ( 难度等级: [0.6258, 0.6258) || 挂载数据: 无 ) 
│   │   │   │   └── 读取文件的新型语法 --> ( 难度等级: [0.6258, 0.6259) || 挂载数据: qa: 4 ) 
│   │   │   ├── 使用glob读取多个文本文件 --> ( 难度等级: [0.6259, 0.6261) || 挂载数据: 无 ) 
│   │   │   ├── 写入文本文件 --> ( 难度等级: [0.6261, 0.6262) || 挂载数据: 无 ) 
│   │   │   │   ├── 向first_script.py添加代码 --> ( 难度等级: [0.6261, 0.6262) || 挂载数据: qa: 1 ) 
│   │   │   │   └── 写入CSV文件 --> ( 难度等级: [0.6262, 0.6262) || 挂载数据: qa: 3 ) 
│   │   │   └── print语句 --> ( 难度等级: [0.6262, 0.6264) || 挂载数据: qa: 2 ) 
│   │   ├── CSV文件 --> ( 难度等级: [0.6264, 0.6278) || 挂载数据: 无 ) 
│   │   │   ├── 筛选特定的行 --> ( 难度等级: [0.6264, 0.6266) || 挂载数据: 无 ) 
│   │   │   │   ├── 行中的值满足某个条件 --> ( 难度等级: [0.6264, 0.6265) || 挂载数据: 无 ) 
│   │   │   │   ├── 行中的值属于某个集合 --> ( 难度等级: [0.6265, 0.6266) || 挂载数据: qa: 6 ) 
│   │   │   │   └── 行中的值匹配于某个模式/ 正则表达式 --> ( 难度等级: [0.6266, 0.6266) || 挂载数据: 无 ) 
│   │   │   ├── 选取特定的列 --> ( 难度等级: [0.6266, 0.6268) || 挂载数据: 无 ) 
│   │   │   │   ├── 列索引值 --> ( 难度等级: [0.6266, 0.6267) || 挂载数据: 无 ) 
│   │   │   │   └── 列标题 --> ( 难度等级: [0.6267, 0.6268) || 挂载数据: qa: 4 ) 
│   │   │   ├── 选取连续的行 --> ( 难度等级: [0.6268, 0.627) || 挂载数据: 无 ) 
│   │   │   ├── 添加标题行 --> ( 难度等级: [0.627, 0.6272) || 挂载数据: 无 ) 
│   │   │   ├── 读取多个CSV文件 --> ( 难度等级: [0.6272, 0.6274) || 挂载数据: qa: 10 ) 
│   │   │   ├── 从多个文件中连接数据 --> ( 难度等级: [0.6274, 0.6276) || 挂载数据: qa: 3 ) 
│   │   │   └── 计算每个文件中值的总和与均值 --> ( 难度等级: [0.6276, 0.6278) || 挂载数据: 无 ) 
│   │   ├── Excel文件 --> ( 难度等级: [0.6278, 0.6293) || 挂载数据: 无 ) 
│   │   │   ├── 内省Excel工作簿 --> ( 难度等级: [0.6278, 0.6281) || 挂载数据: 无 ) 
│   │   │   ├── 处理单个工作表 --> ( 难度等级: [0.6281, 0.6284) || 挂载数据: 无 ) 
│   │   │   │   ├── 读写Excel文件 --> ( 难度等级: [0.6281, 0.6282) || 挂载数据: qa: 10 ) 
│   │   │   │   ├── 筛选特定行 --> ( 难度等级: [0.6282, 0.6283) || 挂载数据: 无 ) 
│   │   │   │   └── 选取特定列 --> ( 难度等级: [0.6283, 0.6284) || 挂载数据: 无 ) 
│   │   │   ├── 读取工作簿中的所有工作表 --> ( 难度等级: [0.6284, 0.6287) || 挂载数据: 无 ) 
│   │   │   │   ├── 在所有工作表中筛选特定行 --> ( 难度等级: [0.6284, 0.6286) || 挂载数据: 无 ) 
│   │   │   │   └── 在所有工作表中选取特定列 --> ( 难度等级: [0.6286, 0.6287) || 挂载数据: 无 ) 
│   │   │   ├── 在Excel工作簿中读取一组工作表 --> ( 难度等级: [0.6287, 0.629) || 挂载数据: 无 ) 
│   │   │   └── 处理多个工作簿 --> ( 难度等级: [0.629, 0.6293) || 挂载数据: 无 ) 
│   │   │       ├── 工作表计数以及每个工作表中的行列计数 --> ( 难度等级: [0.629, 0.6291) || 挂载数据: qa: 1 ) 
│   │   │       └── 从多个工作簿中连接数据 --> ( 难度等级: [0.6291, 0.6293) || 挂载数据: 无 ) 
│   │   ├── 数据库 --> ( 难度等级: [0.6293, 0.6307) || 挂载数据: 无 ) 
│   │   │   ├── Python内置的sqlite3 模块 --> ( 难度等级: [0.6293, 0.63) || 挂载数据: 无 ) 
│   │   │   │   ├── 向表中插入新记录 --> ( 难度等级: [0.6293, 0.6296) || 挂载数据: 无 ) 
│   │   │   │   └── 更新表中记录 --> ( 难度等级: [0.6296, 0.63) || 挂载数据: 无 ) 
│   │   │   └── MySQL数据库 --> ( 难度等级: [0.63, 0.6307) || 挂载数据: 无 ) 
│   │   │       ├── 向表中插入新记录 --> ( 难度等级: [0.63, 0.6302) || 挂载数据: 无 ) 
│   │   │       ├── 查询一个表并将输出写入CSV文件 --> ( 难度等级: [0.6302, 0.6304) || 挂载数据: 无 ) 
│   │   │       └── 更新表中记录 --> ( 难度等级: [0.6304, 0.6307) || 挂载数据: 无 ) 
│   │   ├── 应用程序 --> ( 难度等级: [0.6307, 0.6321) || 挂载数据: 无 ) 
│   │   │   ├── 为CSV文件中数据的任意数目分类计算统计量 --> ( 难度等级: [0.6307, 0.6314) || 挂载数据: 无 ) 
│   │   │   └── 为文本文件中数据的任意数目分类计算统计量 --> ( 难度等级: [0.6314, 0.6321) || 挂载数据: 无 ) 
│   │   ├── 图与图表 --> ( 难度等级: [0.6321, 0.6335) || 挂载数据: 无 ) 
│   │   │   ├── matplotlib --> ( 难度等级: [0.6321, 0.6325) || 挂载数据: 无 ) 
│   │   │   │   ├── 条形图 --> ( 难度等级: [0.6321, 0.6322) || 挂载数据: 无 ) 
│   │   │   │   ├── 直方图 --> ( 难度等级: [0.6322, 0.6322) || 挂载数据: 无 ) 
│   │   │   │   ├── 折线图 --> ( 难度等级: [0.6322, 0.6323) || 挂载数据: qa: 4 ) 
│   │   │   │   ├── 散点图 --> ( 难度等级: [0.6323, 0.6324) || 挂载数据: 无 ) 
│   │   │   │   └── 箱线图 --> ( 难度等级: [0.6324, 0.6325) || 挂载数据: 无 ) 
│   │   │   ├── pandas --> ( 难度等级: [0.6325, 0.6328) || 挂载数据: 无 ) 
│   │   │   ├── ggplot --> ( 难度等级: [0.6328, 0.6332) || 挂载数据: 无 ) 
│   │   │   └── seaborn --> ( 难度等级: [0.6332, 0.6335) || 挂载数据: 无 ) 
│   │   ├── 描述性统计与建模 --> ( 难度等级: [0.6335, 0.6349) || 挂载数据: 无 ) 
│   │   │   ├── 数据集 --> ( 难度等级: [0.6335, 0.634) || 挂载数据: 无 ) 
│   │   │   │   ├── 葡萄酒质量 --> ( 难度等级: [0.6335, 0.6338) || 挂载数据: 无 ) 
│   │   │   │   └── 客户流失 --> ( 难度等级: [0.6338, 0.634) || 挂载数据: 无 ) 
│   │   │   ├── 葡萄酒质量 --> ( 难度等级: [0.634, 0.6345) || 挂载数据: 无 ) 
│   │   │   │   ├── 描述性统计 --> ( 难度等级: [0.634, 0.6341) || 挂载数据: qa: 6 ) 
│   │   │   │   ├── 成对变量之间的关系和相关性 --> ( 难度等级: [0.6341, 0.6342) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用最小二乘估计进行线性回归 --> ( 难度等级: [0.6342, 0.6342) || 挂载数据: 无 ) 
│   │   │   │   ├── 系数解释 --> ( 难度等级: [0.6342, 0.6343) || 挂载数据: 无 ) 
│   │   │   │   ├── 自变量标准化 --> ( 难度等级: [0.6343, 0.6344) || 挂载数据: 无 ) 
│   │   │   │   └── 预测 --> ( 难度等级: [0.6344, 0.6345) || 挂载数据: 无 ) 
│   │   │   └── 客户流失 --> ( 难度等级: [0.6345, 0.6349) || 挂载数据: 无 ) 
│   │   │       ├── 逻辑斯蒂回归 --> ( 难度等级: [0.6345, 0.6346) || 挂载数据: 无 ) 
│   │   │       ├── 系数解释 --> ( 难度等级: [0.6346, 0.6348) || 挂载数据: 无 ) 
│   │   │       └── 预测 --> ( 难度等级: [0.6348, 0.6349) || 挂载数据: 无 ) 
│   │   ├── 按计划自动运行脚本 --> ( 难度等级: [0.6349, 0.6364) || 挂载数据: 无 ) 
│   │   │   ├── 任务计划程序（Windows系统） --> ( 难度等级: [0.6349, 0.6357) || 挂载数据: 无 ) 
│   │   │   └── cron工具（macOS系统和Unix系统） --> ( 难度等级: [0.6357, 0.6364) || 挂载数据: 无 ) 
│   │   │       ├── cron表文件：一次性设置 --> ( 难度等级: [0.6357, 0.636) || 挂载数据: 无 ) 
│   │   │       └── 向cron表文件中添加cron任务 --> ( 难度等级: [0.636, 0.6364) || 挂载数据: 无 ) 
│   │   ├── 从这里启航 --> ( 难度等级: [0.6364, 0.6378) || 挂载数据: 无 ) 
│   │   │   ├── 更多的标准库模块和内置函数 --> ( 难度等级: [0.6364, 0.6367) || 挂载数据: 无 ) 
│   │   │   │   ├── Python标准库（PSL）：更多的标准模块 --> ( 难度等级: [0.6364, 0.6365) || 挂载数据: 无 ) 
│   │   │   │   └── 内置函数 --> ( 难度等级: [0.6365, 0.6367) || 挂载数据: qa: 1 ) 
│   │   │   ├── Python包索引（PyPI）：更多的扩展模块 --> ( 难度等级: [0.6367, 0.6371) || 挂载数据: 无 ) 
│   │   │   │   ├── NumPy --> ( 难度等级: [0.6367, 0.6368) || 挂载数据: 无 ) 
│   │   │   │   ├── SciPy --> ( 难度等级: [0.6368, 0.6369) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── Scikit-Learn --> ( 难度等级: [0.6369, 0.637) || 挂载数据: 无 ) 
│   │   │   │   └── 更多的扩展包 --> ( 难度等级: [0.637, 0.6371) || 挂载数据: 无 ) 
│   │   │   ├── 更多的数据结构 --> ( 难度等级: [0.6371, 0.6374) || 挂载数据: 无 ) 
│   │   │   │   ├── 栈 --> ( 难度等级: [0.6371, 0.6372) || 挂载数据: 无 ) 
│   │   │   │   ├── 队列 --> ( 难度等级: [0.6372, 0.6373) || 挂载数据: 无 ) 
│   │   │   │   └── 树 --> ( 难度等级: [0.6373, 0.6374) || 挂载数据: 无 ) 
│   │   │   └── 从这里启航 --> ( 难度等级: [0.6374, 0.6378) || 挂载数据: 无 ) 
│   │   ├── 准备工作 --> ( 难度等级: [0.6378, 0.6392) || 挂载数据: 无 ) 
│   │   │   ├── 本书内容 --> ( 难度等级: [0.6378, 0.638) || 挂载数据: 无 ) 
│   │   │   │   └── 什么类型的数据 --> ( 难度等级: [0.6378, 0.638) || 挂载数据: qa: 1 ) 
│   │   │   ├── 为何利用Python进行数据分析 --> ( 难度等级: [0.638, 0.6383) || 挂载数据: qa: 2 ) 
│   │   │   │   ├── Python作为胶水 --> ( 难度等级: [0.638, 0.6381) || 挂载数据: 无 ) 
│   │   │   │   ├── 解决“双语言”难题 --> ( 难度等级: [0.6381, 0.6382) || 挂载数据: qa: 3 ) 
│   │   │   │   └── 为何不使用Python --> ( 难度等级: [0.6382, 0.6383) || 挂载数据: 无 ) 
│   │   │   ├── 重要的Python库 --> ( 难度等级: [0.6383, 0.6385) || 挂载数据: 无 ) 
│   │   │   │   ├── IPython与Jupyter --> ( 难度等级: [0.6383, 0.6384) || 挂载数据: qa: 1 ) 
│   │   │   │   └── statsmodels --> ( 难度等级: [0.6384, 0.6385) || 挂载数据: 无 ) 
│   │   │   ├── 安装与设置 --> ( 难度等级: [0.6385, 0.6387) || 挂载数据: 无 ) 
│   │   │   │   ├── Windows --> ( 难度等级: [0.6385, 0.6385) || 挂载数据: 无 ) 
│   │   │   │   ├── Apple（OS X和macOS） --> ( 难度等级: [0.6385, 0.6386) || 挂载数据: qa: 2 ) 
│   │   │   │   ├── GNU/Linux --> ( 难度等级: [0.6386, 0.6386) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 安装及更新Python包 --> ( 难度等级: [0.6386, 0.6387) || 挂载数据: 无 ) 
│   │   │   │   ├── Python 2和Python --> ( 难度等级: [0.6387, 0.6387) || 挂载数据: 无 ) 
│   │   │   │   └── 集成开发环境和文本编辑器 --> ( 难度等级: [0.6387, 0.6387) || 挂载数据: 无 ) 
│   │   │   ├── 社区和会议 --> ( 难度等级: [0.6387, 0.639) || 挂载数据: 无 ) 
│   │   │   └── 快速浏览本书 --> ( 难度等级: [0.639, 0.6392) || 挂载数据: qa: 1 ) 
│   │   │       ├── 代码示例 --> ( 难度等级: [0.639, 0.639) || 挂载数据: 无 ) 
│   │   │       ├── 示例数据 --> ( 难度等级: [0.639, 0.6391) || 挂载数据: 无 ) 
│   │   │       ├── 导入约定 --> ( 难度等级: [0.6391, 0.6391) || 挂载数据: 无 ) 
│   │   │       └── 术语 --> ( 难度等级: [0.6391, 0.6392) || 挂载数据: 无 ) 
│   │   ├── 内建数据结构、函数及文件 --> ( 难度等级: [0.6392, 0.6406) || 挂载数据: 无 ) 
│   │   │   ├── 数据结构和序列 --> ( 难度等级: [0.6392, 0.6397) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 内建序列函数 --> ( 难度等级: [0.6392, 0.6394) || 挂载数据: 无 ) 
│   │   │   │   └── 集合 --> ( 难度等级: [0.6394, 0.6397) || 挂载数据: 无 ) 
│   │   │   ├── 函数 --> ( 难度等级: [0.6397, 0.6402) || 挂载数据: 无 ) 
│   │   │   │   ├── 命名空间、作用域和本地函数 --> ( 难度等级: [0.6397, 0.6397) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 返回多个值 --> ( 难度等级: [0.6397, 0.6398) || 挂载数据: 无 ) 
│   │   │   │   ├── 函数是对象 --> ( 难度等级: [0.6398, 0.6399) || 挂载数据: qa: 10 ) 
│   │   │   │   ├── 匿名（Lambda）函数 --> ( 难度等级: [0.6399, 0.6399) || 挂载数据: qa: 4 ) 
│   │   │   │   ├── 柯里化：部分参数应用 --> ( 难度等级: [0.6399, 0.64) || 挂载数据: 无 ) 
│   │   │   │   ├── 生成器 --> ( 难度等级: [0.64, 0.6401) || 挂载数据: 无 ) 
│   │   │   │   └── 错误和异常处理 --> ( 难度等级: [0.6401, 0.6402) || 挂载数据: 无 ) 
│   │   │   └── 文件与操作系统 --> ( 难度等级: [0.6402, 0.6406) || 挂载数据: 无 ) 
│   │   │       └── 字节与Unicode文件 --> ( 难度等级: [0.6402, 0.6406) || 挂载数据: 无 ) 
│   │   ├── NumPy基础：数组与向量化计算 --> ( 难度等级: [0.6406, 0.642) || 挂载数据: 无 ) 
│   │   │   ├── NumPy ndarray：多维数组对象 --> ( 难度等级: [0.6406, 0.6408) || 挂载数据: 无 ) 
│   │   │   │   ├── 生成ndarray --> ( 难度等级: [0.6406, 0.6407) || 挂载数据: qa: 3 ) 
│   │   │   │   ├── ndarray的数据类型 --> ( 难度等级: [0.6407, 0.6407) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── NumPy数组算术 --> ( 难度等级: [0.6407, 0.6407) || 挂载数据: qa: 10 ) 
│   │   │   │   ├── 基础索引与切片 --> ( 难度等级: [0.6407, 0.6407) || 挂载数据: 无 ) 
│   │   │   │   ├── 布尔索引 --> ( 难度等级: [0.6407, 0.6408) || 挂载数据: 无 ) 
│   │   │   │   ├── 神奇索引 --> ( 难度等级: [0.6408, 0.6408) || 挂载数据: 无 ) 
│   │   │   │   └── 数组转置和换轴 --> ( 难度等级: [0.6408, 0.6408) || 挂载数据: qa: 10 ) 
│   │   │   ├── 通用函数：快速的逐元素数组函数 --> ( 难度等级: [0.6408, 0.641) || 挂载数据: 无 ) 
│   │   │   ├── 使用数组进行面向数组编程 --> ( 难度等级: [0.641, 0.6412) || 挂载数据: 无 ) 
│   │   │   │   ├── 将条件逻辑作为数组操作 --> ( 难度等级: [0.641, 0.6411) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 数学和统计方法 --> ( 难度等级: [0.6411, 0.6411) || 挂载数据: 无 ) 
│   │   │   │   ├── 布尔值数组的方法 --> ( 难度等级: [0.6411, 0.6412) || 挂载数据: 无 ) 
│   │   │   │   ├── 排序 --> ( 难度等级: [0.6412, 0.6412) || 挂载数据: qa: 5 ) 
│   │   │   │   └── 唯一值与其他集合逻辑 --> ( 难度等级: [0.6412, 0.6412) || 挂载数据: 无 ) 
│   │   │   ├── 使用数组进行文件输入和输出 --> ( 难度等级: [0.6412, 0.6414) || 挂载数据: qa: 2 ) 
│   │   │   ├── 线性代数 --> ( 难度等级: [0.6414, 0.6416) || 挂载数据: 无 ) 
│   │   │   ├── 伪随机数生成 --> ( 难度等级: [0.6416, 0.6418) || 挂载数据: qa: 1 ) 
│   │   │   └── 示例：随机漫步 --> ( 难度等级: [0.6418, 0.642) || 挂载数据: 无 ) 
│   │   │       └── 一次性模拟多次随机漫步 --> ( 难度等级: [0.6418, 0.642) || 挂载数据: qa: 10 ) 
│   │   ├── pandas入门 --> ( 难度等级: [0.642, 0.6435) || 挂载数据: 无 ) 
│   │   │   ├── pandas数据结构介绍 --> ( 难度等级: [0.642, 0.6425) || 挂载数据: qa: 10 ) 
│   │   │   │   ├── Series --> ( 难度等级: [0.642, 0.6422) || 挂载数据: qa: 2 ) 
│   │   │   │   ├── DataFrame --> ( 难度等级: [0.6422, 0.6424) || 挂载数据: qa: 10 ) 
│   │   │   │   └── 索引对象 --> ( 难度等级: [0.6424, 0.6425) || 挂载数据: qa: 1 ) 
│   │   │   ├── 基本功能 --> ( 难度等级: [0.6425, 0.643) || 挂载数据: 无 ) 
│   │   │   │   ├── 重建索引 --> ( 难度等级: [0.6425, 0.6426) || 挂载数据: 无 ) 
│   │   │   │   ├── 轴向上删除条目 --> ( 难度等级: [0.6426, 0.6427) || 挂载数据: 无 ) 
│   │   │   │   ├── 索引、选择与过滤 --> ( 难度等级: [0.6427, 0.6428) || 挂载数据: 无 ) 
│   │   │   │   ├── 整数索引 --> ( 难度等级: [0.6428, 0.6428) || 挂载数据: 无 ) 
│   │   │   │   ├── 算术和数据对齐 --> ( 难度等级: [0.6428, 0.6429) || 挂载数据: 无 ) 
│   │   │   │   └── 含有重复标签的轴索引 --> ( 难度等级: [0.6429, 0.643) || 挂载数据: 无 ) 
│   │   │   └── 描述性统计的概述与计算 --> ( 难度等级: [0.643, 0.6435) || 挂载数据: 无 ) 
│   │   ├── 数据载入、存储及文件格式 --> ( 难度等级: [0.6435, 0.6449) || 挂载数据: 无 ) 
│   │   │   ├── 文本格式数据的读写 --> ( 难度等级: [0.6435, 0.6438) || 挂载数据: 无 ) 
│   │   │   │   ├── 分块读入文本文件 --> ( 难度等级: [0.6435, 0.6435) || 挂载数据: 无 ) 
│   │   │   │   ├── 将数据写入文本格式 --> ( 难度等级: [0.6435, 0.6436) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 使用分隔格式 --> ( 难度等级: [0.6436, 0.6437) || 挂载数据: 无 ) 
│   │   │   │   ├── JSON数据 --> ( 难度等级: [0.6437, 0.6437) || 挂载数据: 无 ) 
│   │   │   │   └── XML和HTML：网络抓取 --> ( 难度等级: [0.6437, 0.6438) || 挂载数据: qa: 3 ) 
│   │   │   ├── 二进制格式 --> ( 难度等级: [0.6438, 0.6442) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用HDF5格式 --> ( 难度等级: [0.6438, 0.644) || 挂载数据: qa: 7 ) 
│   │   │   │   └── 读取Microsoft Excel文件 --> ( 难度等级: [0.644, 0.6442) || 挂载数据: 无 ) 
│   │   │   ├── 与Web API交互 --> ( 难度等级: [0.6442, 0.6445) || 挂载数据: qa: 1 ) 
│   │   │   └── 与数据库交互 --> ( 难度等级: [0.6445, 0.6449) || 挂载数据: 无 ) 
│   │   ├── 数据清洗与准备 --> ( 难度等级: [0.6449, 0.6463) || 挂载数据: 无 ) 
│   │   │   ├── 处理缺失值 --> ( 难度等级: [0.6449, 0.6454) || 挂载数据: 无 ) 
│   │   │   │   ├── 过滤缺失值 --> ( 难度等级: [0.6449, 0.6451) || 挂载数据: 无 ) 
│   │   │   │   └── 补全缺失值 --> ( 难度等级: [0.6451, 0.6454) || 挂载数据: qa: 8 ) 
│   │   │   ├── 数据转换 --> ( 难度等级: [0.6454, 0.6458) || 挂载数据: 无 ) 
│   │   │   │   ├── 删除重复值 --> ( 难度等级: [0.6454, 0.6454) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 使用函数或映射进行数据转换 --> ( 难度等级: [0.6454, 0.6455) || 挂载数据: qa: 10 ) 
│   │   │   │   ├── 替代值 --> ( 难度等级: [0.6455, 0.6455) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 重命名轴索引 --> ( 难度等级: [0.6455, 0.6456) || 挂载数据: 无 ) 
│   │   │   │   ├── 离散化和分箱 --> ( 难度等级: [0.6456, 0.6457) || 挂载数据: 无 ) 
│   │   │   │   ├── 检测和过滤异常值 --> ( 难度等级: [0.6457, 0.6457) || 挂载数据: 无 ) 
│   │   │   │   ├── 置换和随机抽样 --> ( 难度等级: [0.6457, 0.6458) || 挂载数据: 无 ) 
│   │   │   │   └── 计算指标/虚拟变量 --> ( 难度等级: [0.6458, 0.6458) || 挂载数据: 无 ) 
│   │   │   └── 字符串操作 --> ( 难度等级: [0.6458, 0.6463) || 挂载数据: 无 ) 
│   │   │       ├── 字符串对象方法 --> ( 难度等级: [0.6458, 0.6461) || 挂载数据: 无 ) 
│   │   │       └── pandas中的向量化字符串函数 --> ( 难度等级: [0.6461, 0.6463) || 挂载数据: 无 ) 
│   │   ├── 数据规整：连接、联合与重塑 --> ( 难度等级: [0.6463, 0.6477) || 挂载数据: 无 ) 
│   │   │   ├── 分层索引 --> ( 难度等级: [0.6463, 0.6468) || 挂载数据: 无 ) 
│   │   │   │   ├── 重排序和层级排序 --> ( 难度等级: [0.6463, 0.6465) || 挂载数据: 无 ) 
│   │   │   │   ├── 按层级进行汇总统计 --> ( 难度等级: [0.6465, 0.6466) || 挂载数据: 无 ) 
│   │   │   │   └── 使用DataFrame的列进行索引 --> ( 难度等级: [0.6466, 0.6468) || 挂载数据: qa: 10 ) 
│   │   │   ├── 联合与合并数据集 --> ( 难度等级: [0.6468, 0.6473) || 挂载数据: 无 ) 
│   │   │   │   ├── 数据库风格的DataFrame连接 --> ( 难度等级: [0.6468, 0.6469) || 挂载数据: 无 ) 
│   │   │   │   ├── 根据索引合并 --> ( 难度等级: [0.6469, 0.647) || 挂载数据: qa: 3 ) 
│   │   │   │   ├── 沿轴向连接 --> ( 难度等级: [0.647, 0.6471) || 挂载数据: qa: 1 ) 
│   │   │   │   └── 联合重叠数据 --> ( 难度等级: [0.6471, 0.6473) || 挂载数据: 无 ) 
│   │   │   └── 重塑和透视 --> ( 难度等级: [0.6473, 0.6477) || 挂载数据: 无 ) 
│   │   │       ├── 使用多层索引进行重塑 --> ( 难度等级: [0.6473, 0.6474) || 挂载数据: 无 ) 
│   │   │       ├── 将“长”透视为“宽” --> ( 难度等级: [0.6474, 0.6476) || 挂载数据: 无 ) 
│   │   │       └── 将“宽”透视为“长” --> ( 难度等级: [0.6476, 0.6477) || 挂载数据: 无 ) 
│   │   ├── 绘图与可视化 --> ( 难度等级: [0.6477, 0.6491) || 挂载数据: 无 ) 
│   │   │   ├── 简明matplotlib API入门 --> ( 难度等级: [0.6477, 0.6484) || 挂载数据: 无 ) 
│   │   │   │   ├── 图片与子图 --> ( 难度等级: [0.6477, 0.6478) || 挂载数据: 无 ) 
│   │   │   │   ├── 颜色、标记和线类型 --> ( 难度等级: [0.6478, 0.648) || 挂载数据: 无 ) 
│   │   │   │   ├── 刻度、标签和图例 --> ( 难度等级: [0.648, 0.6481) || 挂载数据: 无 ) 
│   │   │   │   ├── 注释与子图加工 --> ( 难度等级: [0.6481, 0.6482) || 挂载数据: 无 ) 
│   │   │   │   ├── 将图片保存到文件 --> ( 难度等级: [0.6482, 0.6483) || 挂载数据: qa: 5 ) 
│   │   │   │   └── matplotlib设置 --> ( 难度等级: [0.6483, 0.6484) || 挂载数据: qa: 10 ) 
│   │   │   └── 其他Python可视化工具 --> ( 难度等级: [0.6484, 0.6491) || 挂载数据: 无 ) 
│   │   ├── 数据聚合与分组操作 --> ( 难度等级: [0.6491, 0.6506) || 挂载数据: 无 ) 
│   │   │   ├── GroupBy机制 --> ( 难度等级: [0.6491, 0.6495) || 挂载数据: 无 ) 
│   │   │   │   ├── 遍历各分组 --> ( 难度等级: [0.6491, 0.6492) || 挂载数据: 无 ) 
│   │   │   │   ├── 选择一列或所有列的子集 --> ( 难度等级: [0.6492, 0.6493) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用函数分组 --> ( 难度等级: [0.6493, 0.6494) || 挂载数据: qa: 1 ) 
│   │   │   │   └── 根据索引层级分组 --> ( 难度等级: [0.6494, 0.6495) || 挂载数据: 无 ) 
│   │   │   ├── 数据聚合 --> ( 难度等级: [0.6495, 0.6499) || 挂载数据: 无 ) 
│   │   │   │   └── 返回不含行索引的聚合数据 --> ( 难度等级: [0.6495, 0.6499) || 挂载数据: qa: 2 ) 
│   │   │   ├── 应用：通用拆分-应用-联合 --> ( 难度等级: [0.6499, 0.6502) || 挂载数据: 无 ) 
│   │   │   │   ├── 压缩分组键 --> ( 难度等级: [0.6499, 0.65) || 挂载数据: 无 ) 
│   │   │   │   └── 分位数与桶分析 --> ( 难度等级: [0.65, 0.6502) || 挂载数据: 无 ) 
│   │   │   └── 数据透视表与交叉表 --> ( 难度等级: [0.6502, 0.6506) || 挂载数据: 无 ) 
│   │   │       └── 交叉表：crosstab --> ( 难度等级: [0.6502, 0.6506) || 挂载数据: 无 ) 
│   │   ├── 时间序列 --> ( 难度等级: [0.6506, 0.652) || 挂载数据: 无 ) 
│   │   │   ├── 时间序列基础 --> ( 难度等级: [0.6506, 0.6509) || 挂载数据: 无 ) 
│   │   │   │   └── 含有重复索引的时间序列 --> ( 难度等级: [0.6506, 0.6509) || 挂载数据: qa: 2 ) 
│   │   │   ├── 时区处理 --> ( 难度等级: [0.6509, 0.6511) || 挂载数据: 无 ) 
│   │   │   │   ├── 时区的本地化和转换 --> ( 难度等级: [0.6509, 0.6509) || 挂载数据: 无 ) 
│   │   │   │   ├── 时区感知时间戳对象的操作 --> ( 难度等级: [0.6509, 0.651) || 挂载数据: qa: 1 ) 
│   │   │   │   └── 不同时区间的操作 --> ( 难度等级: [0.651, 0.6511) || 挂载数据: 无 ) 
│   │   │   ├── 时间区间和区间算术 --> ( 难度等级: [0.6511, 0.6514) || 挂载数据: 无 ) 
│   │   │   │   ├── 区间频率转换 --> ( 难度等级: [0.6511, 0.6512) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 季度区间频率 --> ( 难度等级: [0.6512, 0.6513) || 挂载数据: 无 ) 
│   │   │   │   ├── 将时间戳转换为区间（以及逆转换） --> ( 难度等级: [0.6513, 0.6513) || 挂载数据: qa: 10 ) 
│   │   │   │   └── 从数组生成PeriodIndex --> ( 难度等级: [0.6513, 0.6514) || 挂载数据: qa: 1 ) 
│   │   │   ├── 重新采样与频率转换 --> ( 难度等级: [0.6514, 0.6517) || 挂载数据: 无 ) 
│   │   │   │   ├── 向下采样 --> ( 难度等级: [0.6514, 0.6515) || 挂载数据: 无 ) 
│   │   │   │   ├── 向上采样与插值 --> ( 难度等级: [0.6515, 0.6516) || 挂载数据: 无 ) 
│   │   │   │   └── 使用区间进行重新采样 --> ( 难度等级: [0.6516, 0.6517) || 挂载数据: 无 ) 
│   │   │   └── 移动窗口函数 --> ( 难度等级: [0.6517, 0.652) || 挂载数据: 无 ) 
│   │   │       ├── 指数加权函数 --> ( 难度等级: [0.6517, 0.6518) || 挂载数据: 无 ) 
│   │   │       ├── 二元移动窗口函数 --> ( 难度等级: [0.6518, 0.6519) || 挂载数据: qa: 4 ) 
│   │   │       └── 用户自定义的移动窗口函数 --> ( 难度等级: [0.6519, 0.652) || 挂载数据: 无 ) 
│   │   ├── 高阶pandas --> ( 难度等级: [0.652, 0.6534) || 挂载数据: 无 ) 
│   │   │   ├── 分类数据 --> ( 难度等级: [0.652, 0.6525) || 挂载数据: 无 ) 
│   │   │   │   ├── 背景和目标 --> ( 难度等级: [0.652, 0.6521) || 挂载数据: 无 ) 
│   │   │   │   ├── pandas中的Categorical类型 --> ( 难度等级: [0.6521, 0.6522) || 挂载数据: qa: 10 ) 
│   │   │   │   ├── 使用Categorical对象进行计算 --> ( 难度等级: [0.6522, 0.6523) || 挂载数据: 无 ) 
│   │   │   │   └── 分类方法 --> ( 难度等级: [0.6523, 0.6525) || 挂载数据: qa: 2 ) 
│   │   │   ├── 高阶GroupBy应用 --> ( 难度等级: [0.6525, 0.6529) || 挂载数据: 无 ) 
│   │   │   │   ├── 分组转换和“展开”GroupBy --> ( 难度等级: [0.6525, 0.6527) || 挂载数据: qa: 3 ) 
│   │   │   │   └── 分组的时间重新采样 --> ( 难度等级: [0.6527, 0.6529) || 挂载数据: 无 ) 
│   │   │   └── 方法链技术 --> ( 难度等级: [0.6529, 0.6534) || 挂载数据: 无 ) 
│   │   │       └── pipe方法 --> ( 难度等级: [0.6529, 0.6534) || 挂载数据: qa: 1 ) 
│   │   ├── Python建模库介绍 --> ( 难度等级: [0.6534, 0.6548) || 挂载数据: 无 ) 
│   │   │   ├── 使用Patsy创建模型描述 --> ( 难度等级: [0.6534, 0.6538) || 挂载数据: 无 ) 
│   │   │   │   └── Patsy公式中的数据转换 --> ( 难度等级: [0.6534, 0.6538) || 挂载数据: 无 ) 
│   │   │   ├── statsmodels介绍 --> ( 难度等级: [0.6538, 0.6541) || 挂载数据: 无 ) 
│   │   │   │   ├── 评估线性模型 --> ( 难度等级: [0.6538, 0.6539) || 挂载数据: qa: 1 ) 
│   │   │   │   └── 评估时间序列处理 --> ( 难度等级: [0.6539, 0.6541) || 挂载数据: 无 ) 
│   │   │   ├── scikit-learn介绍 --> ( 难度等级: [0.6541, 0.6545) || 挂载数据: 无 ) 
│   │   │   └── 继续你的教育 --> ( 难度等级: [0.6545, 0.6548) || 挂载数据: 无 ) 
│   │   └── 数据分析示例 --> ( 难度等级: [0.6548, 0.6562) || 挂载数据: qa: 2 ) 
│   │       ├── 从Bitly获取1.USA.gov数据 --> ( 难度等级: [0.6548, 0.6551) || 挂载数据: 无 ) 
│   │       │   ├── 纯Python时区计数 --> ( 难度等级: [0.6548, 0.655) || 挂载数据: qa: 1 ) 
│   │       │   └── 使用pandas进行时区计数 --> ( 难度等级: [0.655, 0.6551) || 挂载数据: 无 ) 
│   │       ├── MovieLens 1M数据集 --> ( 难度等级: [0.6551, 0.6554) || 挂载数据: 无 ) 
│   │       │   └── 测量评价分歧 --> ( 难度等级: [0.6551, 0.6554) || 挂载数据: 无 ) 
│   │       ├── 美国1880～2010年的婴儿名字 --> ( 难度等级: [0.6554, 0.6557) || 挂载数据: 无 ) 
│   │       │   └── 分析名字趋势 --> ( 难度等级: [0.6554, 0.6557) || 挂载数据: 无 ) 
│   │       ├── 美国农业部食品数据库 --> ( 难度等级: [0.6557, 0.656) || 挂载数据: 无 ) 
│   │       └── 2012年联邦选举委员会数据库 --> ( 难度等级: [0.656, 0.6562) || 挂载数据: 无 ) 
│   │           ├── 按职业和雇主的捐献统计 --> ( 难度等级: [0.656, 0.6561) || 挂载数据: 无 ) 
│   │           ├── 捐赠金额分桶 --> ( 难度等级: [0.6561, 0.6562) || 挂载数据: 无 ) 
│   │           └── 按州进行捐赠统计 --> ( 难度等级: [0.6562, 0.6562) || 挂载数据: 无 ) 
│   ├── 人工智能 --> ( 难度等级: [0.6562, 0.6875) || 挂载数据: 无 ) 
│   │   ├── 机器学习工具包Scikit-learn --> ( 难度等级: [0.6562, 0.6594) || 挂载数据: 无 ) 
│   │   │   ├── Scikit-learn概览 --> ( 难度等级: [0.6562, 0.6566) || 挂载数据: qa: 2 ) 
│   │   │   ├── 安装配置 --> ( 难度等级: [0.6566, 0.6569) || 挂载数据: 无 ) 
│   │   │   ├── 数据集 --> ( 难度等级: [0.6569, 0.6573) || 挂载数据: 无 ) 
│   │   │   │   ├── Scikit-learn自带的数据集 --> ( 难度等级: [0.6569, 0.6571) || 挂载数据: 无 ) 
│   │   │   │   ├── 样本生成器 --> ( 难度等级: [0.6571, 0.6572) || 挂载数据: 无 ) 
│   │   │   │   └── 加载其他数据集 --> ( 难度等级: [0.6572, 0.6573) || 挂载数据: qa: 5 ) 
│   │   │   ├── 数据预处理Preprocessing --> ( 难度等级: [0.6573, 0.6576) || 挂载数据: 无 ) 
│   │   │   │   ├── 标准化 --> ( 难度等级: [0.6573, 0.6573) || 挂载数据: 无 ) 
│   │   │   │   ├── 归一化 --> ( 难度等级: [0.6573, 0.6574) || 挂载数据: 无 ) 
│   │   │   │   ├── 正则化 --> ( 难度等级: [0.6574, 0.6575) || 挂载数据: 无 ) 
│   │   │   │   ├── 离散化 --> ( 难度等级: [0.6575, 0.6575) || 挂载数据: 无 ) 
│   │   │   │   ├── 特征编码 --> ( 难度等级: [0.6575, 0.6576) || 挂载数据: 无 ) 
│   │   │   │   └── 缺失值补全 --> ( 难度等级: [0.6576, 0.6576) || 挂载数据: qa: 1 ) 
│   │   │   ├── 分类Classification --> ( 难度等级: [0.6576, 0.658) || 挂载数据: 无 ) 
│   │   │   │   ├── K-近邻分类 --> ( 难度等级: [0.6576, 0.6577) || 挂载数据: 无 ) 
│   │   │   │   ├── 贝叶斯分类 --> ( 难度等级: [0.6577, 0.6577) || 挂载数据: 无 ) 
│   │   │   │   ├── 决策树分类 --> ( 难度等级: [0.6577, 0.6578) || 挂载数据: 无 ) 
│   │   │   │   ├── 支持向量机分类 --> ( 难度等级: [0.6578, 0.6578) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 随机森林分类 --> ( 难度等级: [0.6578, 0.6579) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 集成学习Bagging/Boosting --> ( 难度等级: [0.6579, 0.6579) || 挂载数据: 无 ) 
│   │   │   │   └── 神经网络模型 --> ( 难度等级: [0.6579, 0.658) || 挂载数据: 无 ) 
│   │   │   ├── 回归Regression --> ( 难度等级: [0.658, 0.6583) || 挂载数据: 无 ) 
│   │   │   │   ├── 线性回归 --> ( 难度等级: [0.658, 0.658) || 挂载数据: qa: 2 ) 
│   │   │   │   ├── Lasso回归 --> ( 难度等级: [0.658, 0.6581) || 挂载数据: 无 ) 
│   │   │   │   ├── 支持向量机回归 --> ( 难度等级: [0.6581, 0.6581) || 挂载数据: 无 ) 
│   │   │   │   ├── K-近邻回归 --> ( 难度等级: [0.6581, 0.6582) || 挂载数据: 无 ) 
│   │   │   │   ├── 决策树回归 --> ( 难度等级: [0.6582, 0.6582) || 挂载数据: 无 ) 
│   │   │   │   ├── 随机森林回归 --> ( 难度等级: [0.6582, 0.6583) || 挂载数据: 无 ) 
│   │   │   │   └── 逻辑回归 --> ( 难度等级: [0.6583, 0.6583) || 挂载数据: qa: 3 ) 
│   │   │   ├── 聚类Clustering --> ( 难度等级: [0.6583, 0.6587) || 挂载数据: 无 ) 
│   │   │   │   ├── K-Means聚类 --> ( 难度等级: [0.6583, 0.6584) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 均值漂移聚类 --> ( 难度等级: [0.6584, 0.6585) || 挂载数据: 无 ) 
│   │   │   │   ├── 基于密度的空间聚类 --> ( 难度等级: [0.6585, 0.6585) || 挂载数据: 无 ) 
│   │   │   │   ├── 谱聚类 --> ( 难度等级: [0.6585, 0.6586) || 挂载数据: 无 ) 
│   │   │   │   └── 层次聚类 --> ( 难度等级: [0.6586, 0.6587) || 挂载数据: 无 ) 
│   │   │   │       ├── 自下而上的方法 --> ( 难度等级: [0.6586, 0.6586) || 挂载数据: 无 ) 
│   │   │   │       ├── 聚类之间的距离 --> ( 难度等级: [0.6586, 0.6586) || 挂载数据: qa: 2 ) 
│   │   │   │       ├── 自上而下的方法 --> ( 难度等级: [0.6586, 0.6587) || 挂载数据: 无 ) 
│   │   │   │       └── 图论方法 --> ( 难度等级: [0.6587, 0.6587) || 挂载数据: 无 ) 
│   │   │   ├── 成分分解与降维 --> ( 难度等级: [0.6587, 0.659) || 挂载数据: 无 ) 
│   │   │   │   ├── 主成分分析 --> ( 难度等级: [0.6587, 0.6588) || 挂载数据: 无 ) 
│   │   │   │   ├── 因子分析 --> ( 难度等级: [0.6588, 0.6589) || 挂载数据: 无 ) 
│   │   │   │   ├── 截断奇异值分解 --> ( 难度等级: [0.6589, 0.6589) || 挂载数据: 无 ) 
│   │   │   │   └── 独立成分分析ICA（Independent Component Analysis） --> ( 难度等级: [0.6589, 0.659) || 挂载数据: 无 ) 
│   │   │   └── 模型评估与参数调优 --> ( 难度等级: [0.659, 0.6594) || 挂载数据: 无 ) 
│   │   │       ├── 估计器得分 --> ( 难度等级: [0.659, 0.6591) || 挂载数据: 无 ) 
│   │   │       ├── 交叉验证 --> ( 难度等级: [0.6591, 0.6592) || 挂载数据: 无 ) 
│   │   │       ├── 评价指标 --> ( 难度等级: [0.6592, 0.6592) || 挂载数据: 无 ) 
│   │   │       ├── 参数调优 --> ( 难度等级: [0.6592, 0.6593) || 挂载数据: 无 ) 
│   │   │       └── 模型持久化 --> ( 难度等级: [0.6593, 0.6594) || 挂载数据: 无 ) 
│   │   ├── 深度学习 --> ( 难度等级: [0.6594, 0.6625) || 挂载数据: 无 ) 
│   │   │   ├── 神经网络基础知识 --> ( 难度等级: [0.6594, 0.6598) || 挂载数据: 无 ) 
│   │   │   │   ├── 人工智能发展历史 --> ( 难度等级: [0.6594, 0.6594) || 挂载数据: 无 ) 
│   │   │   │   ├── 神经元 --> ( 难度等级: [0.6594, 0.6595) || 挂载数据: 无 ) 
│   │   │   │   ├── BP神经网络 --> ( 难度等级: [0.6595, 0.6595) || 挂载数据: qa: 2 ) 
│   │   │   │   ├── 梯度下降 --> ( 难度等级: [0.6595, 0.6596) || 挂载数据: 无 ) 
│   │   │   │   ├── 激励函数 --> ( 难度等级: [0.6596, 0.6597) || 挂载数据: 无 ) 
│   │   │   │   ├── 过拟合、欠拟合 --> ( 难度等级: [0.6597, 0.6597) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 优化器Optimizer --> ( 难度等级: [0.6597, 0.6598) || 挂载数据: 无 ) 
│   │   │   │   └── 常用开发工具 --> ( 难度等级: [0.6598, 0.6598) || 挂载数据: qa: 1 ) 
│   │   │   ├── 环境配置 --> ( 难度等级: [0.6598, 0.6603) || 挂载数据: 无 ) 
│   │   │   │   ├── Windows搭建深度学习环境 --> ( 难度等级: [0.6598, 0.6599) || 挂载数据: 无 ) 
│   │   │   │   ├── Linux搭建深度学习环境 --> ( 难度等级: [0.6599, 0.66) || 挂载数据: 无 ) 
│   │   │   │   ├── MacOS搭建深度学习环境 --> ( 难度等级: [0.66, 0.6602) || 挂载数据: 无 ) 
│   │   │   │   └── CPU/GPU环境搭建 --> ( 难度等级: [0.6602, 0.6603) || 挂载数据: qa: 2 ) 
│   │   │   ├── Theano --> ( 难度等级: [0.6603, 0.6607) || 挂载数据: 无 ) 
│   │   │   │   ├── Theano基础知识 --> ( 难度等级: [0.6603, 0.6603) || 挂载数据: qa: 2 ) 
│   │   │   │   ├── 定义Layer --> ( 难度等级: [0.6603, 0.6604) || 挂载数据: 无 ) 
│   │   │   │   ├── CNN --> ( 难度等级: [0.6604, 0.6605) || 挂载数据: 无 ) 
│   │   │   │   ├── RNN(GRU/LSTM) --> ( 难度等级: [0.6605, 0.6605) || 挂载数据: 无 ) 
│   │   │   │   ├── Autoencoder --> ( 难度等级: [0.6605, 0.6606) || 挂载数据: 无 ) 
│   │   │   │   ├── 神经网络参数保存 --> ( 难度等级: [0.6606, 0.6607) || 挂载数据: 无 ) 
│   │   │   │   └── 神经网络性能评价 --> ( 难度等级: [0.6607, 0.6607) || 挂载数据: 无 ) 
│   │   │   ├── TensorFlow --> ( 难度等级: [0.6607, 0.6612) || 挂载数据: 无 ) 
│   │   │   │   ├── TensorFlow基础知识 --> ( 难度等级: [0.6607, 0.6607) || 挂载数据: qa: 5 ) 
│   │   │   │   ├── Tensor --> ( 难度等级: [0.6607, 0.6608) || 挂载数据: 无 ) 
│   │   │   │   ├── Session --> ( 难度等级: [0.6608, 0.6608) || 挂载数据: 无 ) 
│   │   │   │   ├── Variable --> ( 难度等级: [0.6608, 0.6609) || 挂载数据: 无 ) 
│   │   │   │   ├── Placeholder --> ( 难度等级: [0.6609, 0.6609) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── Dropout --> ( 难度等级: [0.6609, 0.6609) || 挂载数据: 无 ) 
│   │   │   │   ├── Tensorboard --> ( 难度等级: [0.6609, 0.661) || 挂载数据: 无 ) 
│   │   │   │   ├── CNN --> ( 难度等级: [0.661, 0.661) || 挂载数据: 无 ) 
│   │   │   │   ├── RNN(GRU/LSTM) --> ( 难度等级: [0.661, 0.661) || 挂载数据: 无 ) 
│   │   │   │   ├── Autoencoder --> ( 难度等级: [0.661, 0.6611) || 挂载数据: 无 ) 
│   │   │   │   ├── GNN --> ( 难度等级: [0.6611, 0.6611) || 挂载数据: 无 ) 
│   │   │   │   ├── 神经网络参数保存 --> ( 难度等级: [0.6611, 0.6611) || 挂载数据: 无 ) 
│   │   │   │   └── 神经网络性能评价 --> ( 难度等级: [0.6611, 0.6612) || 挂载数据: 无 ) 
│   │   │   ├── Keras --> ( 难度等级: [0.6612, 0.6616) || 挂载数据: 无 ) 
│   │   │   │   ├── Keras基础语法 --> ( 难度等级: [0.6612, 0.6612) || 挂载数据: qa: 4 ) 
│   │   │   │   ├── 兼容Backend --> ( 难度等级: [0.6612, 0.6612) || 挂载数据: 无 ) 
│   │   │   │   ├── 函数模型和序列模型 --> ( 难度等级: [0.6612, 0.6613) || 挂载数据: 无 ) 
│   │   │   │   ├── 定义Layer --> ( 难度等级: [0.6613, 0.6613) || 挂载数据: 无 ) 
│   │   │   │   ├── CNN --> ( 难度等级: [0.6613, 0.6613) || 挂载数据: 无 ) 
│   │   │   │   ├── RNN(GRU/LSTM) --> ( 难度等级: [0.6613, 0.6614) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── Autoencoder --> ( 难度等级: [0.6614, 0.6614) || 挂载数据: 无 ) 
│   │   │   │   ├── GNN --> ( 难度等级: [0.6614, 0.6614) || 挂载数据: 无 ) 
│   │   │   │   ├── 迁移学习 --> ( 难度等级: [0.6614, 0.6615) || 挂载数据: 无 ) 
│   │   │   │   ├── BiLSTM-Attention --> ( 难度等级: [0.6615, 0.6615) || 挂载数据: 无 ) 
│   │   │   │   ├── 生成对抗网络GAN --> ( 难度等级: [0.6615, 0.6615) || 挂载数据: 无 ) 
│   │   │   │   ├── 神经网络参数保存 --> ( 难度等级: [0.6615, 0.6616) || 挂载数据: 无 ) 
│   │   │   │   └── 神经网络性能评价 --> ( 难度等级: [0.6616, 0.6616) || 挂载数据: 无 ) 
│   │   │   ├── PyTorch --> ( 难度等级: [0.6616, 0.6621) || 挂载数据: 无 ) 
│   │   │   │   ├── PyTorch基础知识 --> ( 难度等级: [0.6616, 0.6616) || 挂载数据: 无 ) 
│   │   │   │   ├── Tensor --> ( 难度等级: [0.6616, 0.6617) || 挂载数据: 无 ) 
│   │   │   │   ├── Variable --> ( 难度等级: [0.6617, 0.6617) || 挂载数据: 无 ) 
│   │   │   │   ├── 定义Layer --> ( 难度等级: [0.6617, 0.6617) || 挂载数据: 无 ) 
│   │   │   │   ├── 可视化 --> ( 难度等级: [0.6617, 0.6618) || 挂载数据: 无 ) 
│   │   │   │   ├── CNN(TextCNN) --> ( 难度等级: [0.6618, 0.6618) || 挂载数据: 无 ) 
│   │   │   │   ├── RNN(GRU/LSTM) --> ( 难度等级: [0.6618, 0.6618) || 挂载数据: 无 ) 
│   │   │   │   ├── Autoencoder --> ( 难度等级: [0.6618, 0.6619) || 挂载数据: 无 ) 
│   │   │   │   ├── GNN/GCN --> ( 难度等级: [0.6619, 0.6619) || 挂载数据: 无 ) 
│   │   │   │   ├── 迁移学习 --> ( 难度等级: [0.6619, 0.662) || 挂载数据: 无 ) 
│   │   │   │   ├── 生成对抗网络GAN --> ( 难度等级: [0.662, 0.662) || 挂载数据: 无 ) 
│   │   │   │   ├── 神经网络参数保存 --> ( 难度等级: [0.662, 0.662) || 挂载数据: 无 ) 
│   │   │   │   └── 神经网络性能评价 --> ( 难度等级: [0.662, 0.6621) || 挂载数据: 无 ) 
│   │   │   └── 强化学习 --> ( 难度等级: [0.6621, 0.6625) || 挂载数据: qa: 1 ) 
│   │   │       ├── 强化学习概念 --> ( 难度等级: [0.6621, 0.6621) || 挂载数据: qa: 10 ) 
│   │   │       ├── Q-Learning --> ( 难度等级: [0.6621, 0.6622) || 挂载数据: qa: 1 ) 
│   │   │       ├── Sarsa --> ( 难度等级: [0.6622, 0.6623) || 挂载数据: 无 ) 
│   │   │       ├── DQN(Deep Q Network) --> ( 难度等级: [0.6623, 0.6624) || 挂载数据: qa: 1 ) 
│   │   │       ├── Policy Gradients --> ( 难度等级: [0.6624, 0.6624) || 挂载数据: 无 ) 
│   │   │       └── Actor Critic --> ( 难度等级: [0.6624, 0.6625) || 挂载数据: 无 ) 
│   │   ├── 计算机视觉 --> ( 难度等级: [0.6625, 0.6656) || 挂载数据: 无 ) 
│   │   │   ├── 数字图像处理基础 --> ( 难度等级: [0.6625, 0.6626) || 挂载数据: 无 ) 
│   │   │   │   ├── 数字图像处理 --> ( 难度等级: [0.6625, 0.6625) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 图像三要素 --> ( 难度等级: [0.6625, 0.6626) || 挂载数据: 无 ) 
│   │   │   │   ├── 像素及图像类型 --> ( 难度等级: [0.6626, 0.6626) || 挂载数据: 无 ) 
│   │   │   │   └── 图像信号数字转换 --> ( 难度等级: [0.6626, 0.6626) || 挂载数据: 无 ) 
│   │   │   ├── OpenCV基础 --> ( 难度等级: [0.6626, 0.6627) || 挂载数据: 无 ) 
│   │   │   │   ├── 安装配置 --> ( 难度等级: [0.6626, 0.6627) || 挂载数据: 无 ) 
│   │   │   │   ├── OpenCV基础语法 --> ( 难度等级: [0.6627, 0.6627) || 挂载数据: qa: 10 ) 
│   │   │   │   └── 几何图形绘制 --> ( 难度等级: [0.6627, 0.6627) || 挂载数据: 无 ) 
│   │   │   ├── 图像处理入门 --> ( 难度等级: [0.6627, 0.6629) || 挂载数据: 无 ) 
│   │   │   │   ├── 读取显示图像 --> ( 难度等级: [0.6627, 0.6628) || 挂载数据: 无 ) 
│   │   │   │   ├── 读取修改像素 --> ( 难度等级: [0.6628, 0.6628) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 创建复制保存图像 --> ( 难度等级: [0.6628, 0.6628) || 挂载数据: 无 ) 
│   │   │   │   └── 获取图像属性及通道 --> ( 难度等级: [0.6628, 0.6629) || 挂载数据: 无 ) 
│   │   │   ├── 图像算数与逻辑运算 --> ( 难度等级: [0.6629, 0.663) || 挂载数据: 无 ) 
│   │   │   │   ├── 图像加法运算 --> ( 难度等级: [0.6629, 0.6629) || 挂载数据: 无 ) 
│   │   │   │   ├── 图像减法运算 --> ( 难度等级: [0.6629, 0.6629) || 挂载数据: 无 ) 
│   │   │   │   ├── 图像与运算 --> ( 难度等级: [0.6629, 0.6629) || 挂载数据: 无 ) 
│   │   │   │   ├── 图像或运算 --> ( 难度等级: [0.6629, 0.6629) || 挂载数据: 无 ) 
│   │   │   │   ├── 图像异或运算 --> ( 难度等级: [0.6629, 0.663) || 挂载数据: 无 ) 
│   │   │   │   └── 图像非运算 --> ( 难度等级: [0.663, 0.663) || 挂载数据: 无 ) 
│   │   │   ├── 图像几何变换 --> ( 难度等级: [0.663, 0.6631) || 挂载数据: 无 ) 
│   │   │   │   ├── 平移变换 --> ( 难度等级: [0.663, 0.663) || 挂载数据: 无 ) 
│   │   │   │   ├── 缩放变换 --> ( 难度等级: [0.663, 0.663) || 挂载数据: 无 ) 
│   │   │   │   ├── 旋转变换 --> ( 难度等级: [0.663, 0.663) || 挂载数据: 无 ) 
│   │   │   │   ├── 镜像变换 --> ( 难度等级: [0.663, 0.6631) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 仿射变换 --> ( 难度等级: [0.6631, 0.6631) || 挂载数据: qa: 1 ) 
│   │   │   │   └── 透视变换 --> ( 难度等级: [0.6631, 0.6631) || 挂载数据: qa: 1 ) 
│   │   │   ├── 图像量化与采样 --> ( 难度等级: [0.6631, 0.6632) || 挂载数据: 无 ) 
│   │   │   │   ├── 图像量化处理 --> ( 难度等级: [0.6631, 0.6631) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 图像采样处理 --> ( 难度等级: [0.6631, 0.6632) || 挂载数据: 无 ) 
│   │   │   │   ├── 图像金字塔 --> ( 难度等级: [0.6632, 0.6632) || 挂载数据: qa: 1 ) 
│   │   │   │   └── 局部马赛克处理 --> ( 难度等级: [0.6632, 0.6632) || 挂载数据: 无 ) 
│   │   │   ├── 直方图统计 --> ( 难度等级: [0.6632, 0.6633) || 挂载数据: 无 ) 
│   │   │   │   ├── 直方图概述 --> ( 难度等级: [0.6632, 0.6632) || 挂载数据: 无 ) 
│   │   │   │   ├── 直方图绘制 --> ( 难度等级: [0.6632, 0.6633) || 挂载数据: 无 ) 
│   │   │   │   ├── 掩膜直方图 --> ( 难度等级: [0.6633, 0.6633) || 挂载数据: 无 ) 
│   │   │   │   ├── H-S直方图 --> ( 难度等级: [0.6633, 0.6633) || 挂载数据: qa: 1 ) 
│   │   │   │   └── 直方图对比 --> ( 难度等级: [0.6633, 0.6633) || 挂载数据: 无 ) 
│   │   │   ├── 图像增强 --> ( 难度等级: [0.6633, 0.6635) || 挂载数据: 无 ) 
│   │   │   │   ├── 图像增强 --> ( 难度等级: [0.6633, 0.6634) || 挂载数据: 无 ) 
│   │   │   │   ├── 直方图均衡化 --> ( 难度等级: [0.6634, 0.6634) || 挂载数据: 无 ) 
│   │   │   │   ├── 局部直方图均衡化 --> ( 难度等级: [0.6634, 0.6634) || 挂载数据: 无 ) 
│   │   │   │   ├── 自动色彩均衡化 --> ( 难度等级: [0.6634, 0.6634) || 挂载数据: 无 ) 
│   │   │   │   └── 图像去雾 --> ( 难度等级: [0.6634, 0.6635) || 挂载数据: 无 ) 
│   │   │   ├── 图像平滑 --> ( 难度等级: [0.6635, 0.6636) || 挂载数据: 无 ) 
│   │   │   │   ├── 图像平滑概述 --> ( 难度等级: [0.6635, 0.6635) || 挂载数据: 无 ) 
│   │   │   │   ├── 均值滤波 --> ( 难度等级: [0.6635, 0.6635) || 挂载数据: 无 ) 
│   │   │   │   ├── 方框滤波 --> ( 难度等级: [0.6635, 0.6635) || 挂载数据: 无 ) 
│   │   │   │   ├── 高斯滤波 --> ( 难度等级: [0.6635, 0.6635) || 挂载数据: 无 ) 
│   │   │   │   ├── 中值滤波 --> ( 难度等级: [0.6635, 0.6636) || 挂载数据: 无 ) 
│   │   │   │   └── 双边滤波 --> ( 难度等级: [0.6636, 0.6636) || 挂载数据: 无 ) 
│   │   │   ├── 图像锐化及边缘检测 --> ( 难度等级: [0.6636, 0.6637) || 挂载数据: 无 ) 
│   │   │   │   ├── 一阶微分算法、二阶微分算子 --> ( 难度等级: [0.6636, 0.6636) || 挂载数据: 无 ) 
│   │   │   │   ├── Roberts算子 --> ( 难度等级: [0.6636, 0.6636) || 挂载数据: 无 ) 
│   │   │   │   ├── Prewitt算子 --> ( 难度等级: [0.6636, 0.6636) || 挂载数据: 无 ) 
│   │   │   │   ├── Sobel算子 --> ( 难度等级: [0.6636, 0.6636) || 挂载数据: 无 ) 
│   │   │   │   ├── Laplacian算子 --> ( 难度等级: [0.6636, 0.6637) || 挂载数据: 无 ) 
│   │   │   │   ├── Scharr算子 --> ( 难度等级: [0.6637, 0.6637) || 挂载数据: 无 ) 
│   │   │   │   ├── Canny算子 --> ( 难度等级: [0.6637, 0.6637) || 挂载数据: 无 ) 
│   │   │   │   └── LOG算子 --> ( 难度等级: [0.6637, 0.6637) || 挂载数据: qa: 3 ) 
│   │   │   ├── 图像形态学处理 --> ( 难度等级: [0.6637, 0.6638) || 挂载数据: 无 ) 
│   │   │   │   ├── 图像腐蚀 --> ( 难度等级: [0.6637, 0.6637) || 挂载数据: 无 ) 
│   │   │   │   ├── 图像膨胀 --> ( 难度等级: [0.6637, 0.6637) || 挂载数据: 无 ) 
│   │   │   │   ├── 图像开运算 --> ( 难度等级: [0.6637, 0.6638) || 挂载数据: 无 ) 
│   │   │   │   ├── 图像闭运算 --> ( 难度等级: [0.6638, 0.6638) || 挂载数据: 无 ) 
│   │   │   │   ├── 图像梯度运算 --> ( 难度等级: [0.6638, 0.6638) || 挂载数据: 无 ) 
│   │   │   │   ├── 图像顶帽运算 --> ( 难度等级: [0.6638, 0.6638) || 挂载数据: 无 ) 
│   │   │   │   └── 图像底帽运算 --> ( 难度等级: [0.6638, 0.6638) || 挂载数据: 无 ) 
│   │   │   ├── 图像分割 --> ( 难度等级: [0.6638, 0.6639) || 挂载数据: 无 ) 
│   │   │   │   ├── 基于阈值的图像分割 --> ( 难度等级: [0.6638, 0.6638) || 挂载数据: qa: 4 ) 
│   │   │   │   ├── 基于边缘检测的图像分割 --> ( 难度等级: [0.6638, 0.6639) || 挂载数据: 无 ) 
│   │   │   │   ├── 基于纹理背景的图像分割 --> ( 难度等级: [0.6639, 0.6639) || 挂载数据: 无 ) 
│   │   │   │   ├── 基于K-Means聚类的区域分割 --> ( 难度等级: [0.6639, 0.6639) || 挂载数据: 无 ) 
│   │   │   │   ├── 基于均值漂移算法的图像分割 --> ( 难度等级: [0.6639, 0.6639) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 基于分水岭算法的图像分割 --> ( 难度等级: [0.6639, 0.6639) || 挂载数据: 无 ) 
│   │   │   │   ├── 图像漫水填充分割 --> ( 难度等级: [0.6639, 0.6639) || 挂载数据: 无 ) 
│   │   │   │   └── 文字区域分割及定位 --> ( 难度等级: [0.6639, 0.6639) || 挂载数据: 无 ) 
│   │   │   ├── 傅里叶变换 --> ( 难度等级: [0.6639, 0.6641) || 挂载数据: 无 ) 
│   │   │   │   ├── 傅里叶变换 --> ( 难度等级: [0.6639, 0.664) || 挂载数据: qa: 2 ) 
│   │   │   │   ├── 傅里叶逆变换 --> ( 难度等级: [0.664, 0.664) || 挂载数据: 无 ) 
│   │   │   │   ├── 高通滤波器 --> ( 难度等级: [0.664, 0.664) || 挂载数据: 无 ) 
│   │   │   │   └── 低通滤波器 --> ( 难度等级: [0.664, 0.6641) || 挂载数据: 无 ) 
│   │   │   ├── 霍夫变换 --> ( 难度等级: [0.6641, 0.6642) || 挂载数据: 无 ) 
│   │   │   │   ├── 霍夫变换 --> ( 难度等级: [0.6641, 0.6641) || 挂载数据: 无 ) 
│   │   │   │   ├── 霍夫线变换 --> ( 难度等级: [0.6641, 0.6641) || 挂载数据: 无 ) 
│   │   │   │   └── 霍夫圆变换 --> ( 难度等级: [0.6641, 0.6642) || 挂载数据: 无 ) 
│   │   │   ├── 图像特效处理 --> ( 难度等级: [0.6642, 0.6643) || 挂载数据: 无 ) 
│   │   │   │   ├── 图像毛玻璃特效 --> ( 难度等级: [0.6642, 0.6642) || 挂载数据: 无 ) 
│   │   │   │   ├── 图像浮雕特效 --> ( 难度等级: [0.6642, 0.6642) || 挂载数据: 无 ) 
│   │   │   │   ├── 图像素描特效 --> ( 难度等级: [0.6642, 0.6642) || 挂载数据: 无 ) 
│   │   │   │   ├── 图像怀旧特效 --> ( 难度等级: [0.6642, 0.6642) || 挂载数据: 无 ) 
│   │   │   │   ├── 图像流年特效 --> ( 难度等级: [0.6642, 0.6643) || 挂载数据: 无 ) 
│   │   │   │   ├── 图像滤镜特效 --> ( 难度等级: [0.6643, 0.6643) || 挂载数据: 无 ) 
│   │   │   │   ├── 图像水波特效 --> ( 难度等级: [0.6643, 0.6643) || 挂载数据: 无 ) 
│   │   │   │   └── 图像卡通特效 --> ( 难度等级: [0.6643, 0.6643) || 挂载数据: 无 ) 
│   │   │   ├── 图像分类 --> ( 难度等级: [0.6643, 0.6644) || 挂载数据: 无 ) 
│   │   │   │   ├── 图像分类概述 --> ( 难度等级: [0.6643, 0.6643) || 挂载数据: 无 ) 
│   │   │   │   ├── 基于机器学习的图像分类 --> ( 难度等级: [0.6643, 0.6643) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 基于深度学习的图像分类 --> ( 难度等级: [0.6643, 0.6644) || 挂载数据: qa: 2 ) 
│   │   │   │   ├── LeNet --> ( 难度等级: [0.6644, 0.6644) || 挂载数据: 无 ) 
│   │   │   │   ├── VGG --> ( 难度等级: [0.6644, 0.6644) || 挂载数据: 无 ) 
│   │   │   │   ├── AlexNet --> ( 难度等级: [0.6644, 0.6644) || 挂载数据: 无 ) 
│   │   │   │   └── ResNet --> ( 难度等级: [0.6644, 0.6644) || 挂载数据: qa: 1 ) 
│   │   │   ├── 人脸识别 --> ( 难度等级: [0.6644, 0.6645) || 挂载数据: 无 ) 
│   │   │   ├── 目标检测 --> ( 难度等级: [0.6645, 0.6647) || 挂载数据: 无 ) 
│   │   │   │   ├── 目标检测概述 --> ( 难度等级: [0.6645, 0.6646) || 挂载数据: qa: 3 ) 
│   │   │   │   ├── RCNN --> ( 难度等级: [0.6646, 0.6646) || 挂载数据: 无 ) 
│   │   │   │   ├── Fast-RCNN --> ( 难度等级: [0.6646, 0.6646) || 挂载数据: 无 ) 
│   │   │   │   ├── SPPNet --> ( 难度等级: [0.6646, 0.6646) || 挂载数据: 无 ) 
│   │   │   │   ├── Mask-RCNN --> ( 难度等级: [0.6646, 0.6646) || 挂载数据: qa: 2 ) 
│   │   │   │   ├── SSD --> ( 难度等级: [0.6646, 0.6646) || 挂载数据: 无 ) 
│   │   │   │   └── YOLO系列算法 --> ( 难度等级: [0.6646, 0.6647) || 挂载数据: qa: 1 ) 
│   │   │   ├── 深度神经网络概述 --> ( 难度等级: [0.6647, 0.6648) || 挂载数据: 无 ) 
│   │   │   │   ├── 创建神经网络块 --> ( 难度等级: [0.6647, 0.6647) || 挂载数据: 无 ) 
│   │   │   │   ├── TensorFlow介绍 --> ( 难度等级: [0.6647, 0.6647) || 挂载数据: 无 ) 
│   │   │   │   ├── MNIST数据集介绍 --> ( 难度等级: [0.6647, 0.6647) || 挂载数据: 无 ) 
│   │   │   │   ├── Keras深度学习库概述 --> ( 难度等级: [0.6647, 0.6647) || 挂载数据: 无 ) 
│   │   │   │   ├── 基于Keras和MNIST的手写数字识别 --> ( 难度等级: [0.6647, 0.6648) || 挂载数据: qa: 1 ) 
│   │   │   │   │   ├── 训练和测试数据的检索 --> ( 难度等级: [0.6647, 0.6647) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 训练数据的可视化 --> ( 难度等级: [0.6647, 0.6648) || 挂载数据: qa: 1 ) 
│   │   │   │   │   ├── 创建神经网络 --> ( 难度等级: [0.6648, 0.6648) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 训练神经网络 --> ( 难度等级: [0.6648, 0.6648) || 挂载数据: qa: 2 ) 
│   │   │   │   │   └── 测试 --> ( 难度等级: [0.6648, 0.6648) || 挂载数据: 无 ) 
│   │   │   │   └── 理解反向传播 --> ( 难度等级: [0.6648, 0.6648) || 挂载数据: 无 ) 
│   │   │   ├── 卷积神经网络介绍 --> ( 难度等级: [0.6648, 0.6649) || 挂载数据: 无 ) 
│   │   │   │   ├── CNN历史 --> ( 难度等级: [0.6648, 0.6648) || 挂载数据: 无 ) 
│   │   │   │   └── 卷积神经网络 --> ( 难度等级: [0.6648, 0.6649) || 挂载数据: 无 ) 
│   │   │   │       ├── 计算机如何解释图像 --> ( 难度等级: [0.6648, 0.6649) || 挂载数据: qa: 1 ) 
│   │   │   │       ├── 编码实现图像可视化 --> ( 难度等级: [0.6649, 0.6649) || 挂载数据: 无 ) 
│   │   │   │       ├── dropout --> ( 难度等级: [0.6649, 0.6649) || 挂载数据: 无 ) 
│   │   │   │       ├── 输入层 --> ( 难度等级: [0.6649, 0.6649) || 挂载数据: 无 ) 
│   │   │   │       ├── 卷积层 --> ( 难度等级: [0.6649, 0.6649) || 挂载数据: 无 ) 
│   │   │   │       └── 池化层 --> ( 难度等级: [0.6649, 0.6649) || 挂载数据: 无 ) 
│   │   │   ├── 构建CNN并进行性能优化 --> ( 难度等级: [0.6649, 0.665) || 挂载数据: 无 ) 
│   │   │   │   ├── CNN架构和DNN的缺点 --> ( 难度等级: [0.6649, 0.6649) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 卷积操作 --> ( 难度等级: [0.6649, 0.6649) || 挂载数据: 无 ) 
│   │   │   │   │   └── 池化、步长和填充操作 --> ( 难度等级: [0.6649, 0.6649) || 挂载数据: 无 ) 
│   │   │   │   ├── TensorFlow中的卷积和池化操作 --> ( 难度等级: [0.6649, 0.665) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 在TensorFlow中应用池化操作 --> ( 难度等级: [0.6649, 0.6649) || 挂载数据: 无 ) 
│   │   │   │   │   └── TensorFlow中的卷积操作 --> ( 难度等级: [0.6649, 0.665) || 挂载数据: 无 ) 
│   │   │   │   ├── 训练CNN --> ( 难度等级: [0.665, 0.665) || 挂载数据: qa: 1 ) 
│   │   │   │   │   ├── 初始化权重和偏置 --> ( 难度等级: [0.665, 0.665) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 正则化 --> ( 难度等级: [0.665, 0.665) || 挂载数据: 无 ) 
│   │   │   │   │   └── 激活函数 --> ( 难度等级: [0.665, 0.665) || 挂载数据: 无 ) 
│   │   │   │   └── 模型性能优化 --> ( 难度等级: [0.665, 0.665) || 挂载数据: 无 ) 
│   │   │   │       ├── 隐含层数量 --> ( 难度等级: [0.665, 0.665) || 挂载数据: 无 ) 
│   │   │   │       ├── 每个隐含层的神经元个数 --> ( 难度等级: [0.665, 0.665) || 挂载数据: 无 ) 
│   │   │   │       ├── 批标准化 --> ( 难度等级: [0.665, 0.665) || 挂载数据: 无 ) 
│   │   │   │       ├── 高级正则化及过拟合的避免 --> ( 难度等级: [0.665, 0.665) || 挂载数据: 无 ) 
│   │   │   │       ├── 运用哪个优化器 --> ( 难度等级: [0.665, 0.665) || 挂载数据: qa: 5 ) 
│   │   │   │       ├── 内存调优 --> ( 难度等级: [0.665, 0.665) || 挂载数据: 无 ) 
│   │   │   │       ├── 层的位置调优 --> ( 难度等级: [0.665, 0.665) || 挂载数据: 无 ) 
│   │   │   │       ├── 综合所有操作创建第二个CNN --> ( 难度等级: [0.665, 0.665) || 挂载数据: 无 ) 
│   │   │   │       ├── 数据集描述和预处理 --> ( 难度等级: [0.665, 0.665) || 挂载数据: 无 ) 
│   │   │   │       └── 创建CNN模型 --> ( 难度等级: [0.665, 0.665) || 挂载数据: qa: 2 ) 
│   │   │   ├── 经典的CNN模型架构 --> ( 难度等级: [0.665, 0.6651) || 挂载数据: 无 ) 
│   │   │   │   ├── ImageNet介绍 --> ( 难度等级: [0.665, 0.665) || 挂载数据: 无 ) 
│   │   │   │   ├── AlexNet架构 --> ( 难度等级: [0.665, 0.6651) || 挂载数据: 无 ) 
│   │   │   │   ├── VGGNet架构 --> ( 难度等级: [0.6651, 0.6651) || 挂载数据: 无 ) 
│   │   │   │   ├── GoogLeNet架构 --> ( 难度等级: [0.6651, 0.6651) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 架构洞察 --> ( 难度等级: [0.6651, 0.6651) || 挂载数据: 无 ) 
│   │   │   │   │   └── inception模块 --> ( 难度等级: [0.6651, 0.6651) || 挂载数据: 无 ) 
│   │   │   │   └── ResNet架构 --> ( 难度等级: [0.6651, 0.6651) || 挂载数据: 无 ) 
│   │   │   ├── 转移学习 --> ( 难度等级: [0.6651, 0.6653) || 挂载数据: 无 ) 
│   │   │   │   ├── 特征提取方法 --> ( 难度等级: [0.6651, 0.6652) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 目标数据集较小且与原始训练集相似 --> ( 难度等级: [0.6651, 0.6652) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 目标数据集较小且与原始训练集不同 --> ( 难度等级: [0.6652, 0.6652) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 目标数据集很大且与原始训练集相似 --> ( 难度等级: [0.6652, 0.6652) || 挂载数据: 无 ) 
│   │   │   │   │   └── 目标数据集很大且与原始训练集不同 --> ( 难度等级: [0.6652, 0.6652) || 挂载数据: 无 ) 
│   │   │   │   ├── 转移学习示例 --> ( 难度等级: [0.6652, 0.6652) || 挂载数据: 无 ) 
│   │   │   │   └── 多任务学习 --> ( 难度等级: [0.6652, 0.6653) || 挂载数据: 无 ) 
│   │   │   ├── CNN自编码器 --> ( 难度等级: [0.6653, 0.6654) || 挂载数据: 无 ) 
│   │   │   │   ├── 自编码器介绍 --> ( 难度等级: [0.6653, 0.6653) || 挂载数据: 无 ) 
│   │   │   │   ├── 卷积自编码器 --> ( 难度等级: [0.6653, 0.6653) || 挂载数据: 无 ) 
│   │   │   │   └── 应用 --> ( 难度等级: [0.6653, 0.6654) || 挂载数据: 无 ) 
│   │   │   ├── GAN：使用CNN生成新图像 --> ( 难度等级: [0.6654, 0.6655) || 挂载数据: 无 ) 
│   │   │   │   ├── Pix2pix：基于GAN的图像翻译 --> ( 难度等级: [0.6654, 0.6654) || 挂载数据: 无 ) 
│   │   │   │   │   ├── CycleGAN --> ( 难度等级: [0.6654, 0.6654) || 挂载数据: 无 ) 
│   │   │   │   │   └── 训练GAN模型 --> ( 难度等级: [0.6654, 0.6654) || 挂载数据: qa: 2 ) 
│   │   │   │   ├── GAN的代码示例 --> ( 难度等级: [0.6654, 0.6655) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 计算损失 --> ( 难度等级: [0.6654, 0.6654) || 挂载数据: 无 ) 
│   │   │   │   │   └── 半监督学习和GAN --> ( 难度等级: [0.6654, 0.6655) || 挂载数据: 无 ) 
│   │   │   │   └── 特征匹配 --> ( 难度等级: [0.6655, 0.6655) || 挂载数据: 无 ) 
│   │   │   │       ├── 基于半监督分类的GAN示例 --> ( 难度等级: [0.6655, 0.6655) || 挂载数据: 无 ) 
│   │   │   │       └── 深度卷积GAN --> ( 难度等级: [0.6655, 0.6655) || 挂载数据: 无 ) 
│   │   │   └── CNN和视觉模型的注意力机制 --> ( 难度等级: [0.6655, 0.6656) || 挂载数据: 无 ) 
│   │   │       ├── 图像描述中的注意力机制 --> ( 难度等级: [0.6655, 0.6655) || 挂载数据: 无 ) 
│   │   │       ├── 注意力类型 --> ( 难度等级: [0.6655, 0.6656) || 挂载数据: 无 ) 
│   │   │       │   ├── 硬注意力 --> ( 难度等级: [0.6655, 0.6655) || 挂载数据: 无 ) 
│   │   │       │   └── 软注意力 --> ( 难度等级: [0.6655, 0.6656) || 挂载数据: 无 ) 
│   │   │       ├── 运用注意力改善视觉模型 --> ( 难度等级: [0.6656, 0.6656) || 挂载数据: 无 ) 
│   │   │       │   ├── 视觉CNN模型次优性能的原因 --> ( 难度等级: [0.6656, 0.6656) || 挂载数据: 无 ) 
│   │   │       │   └── 循环视觉注意力模型 --> ( 难度等级: [0.6656, 0.6656) || 挂载数据: qa: 2 ) 
│   │   │       └── 参考文献 --> ( 难度等级: [0.6656, 0.6656) || 挂载数据: 无 ) 
│   │   ├── 自然语言处理 --> ( 难度等级: [0.6656, 0.6687) || 挂载数据: 无 ) 
│   │   │   ├── 自然语言处理概览 --> ( 难度等级: [0.6656, 0.6658) || 挂载数据: 无 ) 
│   │   │   │   ├── 自然语言处理的基本概念 --> ( 难度等级: [0.6656, 0.6657) || 挂载数据: 无 ) 
│   │   │   │   ├── 自然语言处理的面临困难 --> ( 难度等级: [0.6657, 0.6657) || 挂载数据: 无 ) 
│   │   │   │   └── 自然语言处理的研究现状 --> ( 难度等级: [0.6657, 0.6658) || 挂载数据: qa: 1 ) 
│   │   │   ├── 预备知识 --> ( 难度等级: [0.6658, 0.666) || 挂载数据: 无 ) 
│   │   │   │   ├── 概率论基础知识 --> ( 难度等级: [0.6658, 0.6658) || 挂载数据: 无 ) 
│   │   │   │   ├── 最大似然估计 --> ( 难度等级: [0.6658, 0.6658) || 挂载数据: 无 ) 
│   │   │   │   ├── 隐马尔可夫模型 --> ( 难度等级: [0.6658, 0.6658) || 挂载数据: 无 ) 
│   │   │   │   ├── 贝叶斯网络 --> ( 难度等级: [0.6658, 0.6658) || 挂载数据: 无 ) 
│   │   │   │   ├── 条件概率分布 --> ( 难度等级: [0.6658, 0.6659) || 挂载数据: 无 ) 
│   │   │   │   ├── 信息论基础知识 --> ( 难度等级: [0.6659, 0.6659) || 挂载数据: 无 ) 
│   │   │   │   ├── 熵 --> ( 难度等级: [0.6659, 0.6659) || 挂载数据: 无 ) 
│   │   │   │   ├── 困惑度 --> ( 难度等级: [0.6659, 0.6659) || 挂载数据: 无 ) 
│   │   │   │   ├── 互信息 --> ( 难度等级: [0.6659, 0.6659) || 挂载数据: 无 ) 
│   │   │   │   ├── 神经网络基础知识 --> ( 难度等级: [0.6659, 0.6659) || 挂载数据: 无 ) 
│   │   │   │   ├── CRF --> ( 难度等级: [0.6659, 0.6659) || 挂载数据: 无 ) 
│   │   │   │   ├── BiLSTM+Attention --> ( 难度等级: [0.6659, 0.6659) || 挂载数据: 无 ) 
│   │   │   │   ├── 迁移学习 --> ( 难度等级: [0.6659, 0.666) || 挂载数据: 无 ) 
│   │   │   │   └── 常用语料库和知识库 --> ( 难度等级: [0.666, 0.666) || 挂载数据: 无 ) 
│   │   │   ├── jieba --> ( 难度等级: [0.666, 0.6661) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── jieba概述 --> ( 难度等级: [0.666, 0.666) || 挂载数据: 无 ) 
│   │   │   │   ├── jieba分词 --> ( 难度等级: [0.666, 0.666) || 挂载数据: qa: 2 ) 
│   │   │   │   ├── jieba添加自定义词典 --> ( 难度等级: [0.666, 0.6661) || 挂载数据: 无 ) 
│   │   │   │   ├── jieba词性标注 --> ( 难度等级: [0.6661, 0.6661) || 挂载数据: 无 ) 
│   │   │   │   └── jieba关键词抽取 --> ( 难度等级: [0.6661, 0.6661) || 挂载数据: 无 ) 
│   │   │   ├── nltk --> ( 难度等级: [0.6661, 0.6663) || 挂载数据: 无 ) 
│   │   │   │   ├── nltk概述 --> ( 难度等级: [0.6661, 0.6662) || 挂载数据: 无 ) 
│   │   │   │   ├── nltk字符串处理 --> ( 难度等级: [0.6662, 0.6662) || 挂载数据: 无 ) 
│   │   │   │   ├── nltk词性标注 --> ( 难度等级: [0.6662, 0.6662) || 挂载数据: 无 ) 
│   │   │   │   ├── nltk词干提取 --> ( 难度等级: [0.6662, 0.6662) || 挂载数据: 无 ) 
│   │   │   │   ├── nltk命名实体识别 --> ( 难度等级: [0.6662, 0.6663) || 挂载数据: 无 ) 
│   │   │   │   ├── nltk分块处理 --> ( 难度等级: [0.6663, 0.6663) || 挂载数据: 无 ) 
│   │   │   │   ├── nltk文本分类 --> ( 难度等级: [0.6663, 0.6663) || 挂载数据: 无 ) 
│   │   │   │   └── nltk情感分析 --> ( 难度等级: [0.6663, 0.6663) || 挂载数据: 无 ) 
│   │   │   ├── Genism --> ( 难度等级: [0.6663, 0.6665) || 挂载数据: 无 ) 
│   │   │   │   ├── TF-IDF --> ( 难度等级: [0.6663, 0.6664) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── similarities --> ( 难度等级: [0.6664, 0.6664) || 挂载数据: 无 ) 
│   │   │   │   ├── LSA --> ( 难度等级: [0.6664, 0.6664) || 挂载数据: 无 ) 
│   │   │   │   ├── LDA --> ( 难度等级: [0.6664, 0.6665) || 挂载数据: 无 ) 
│   │   │   │   └── Word2vec --> ( 难度等级: [0.6665, 0.6665) || 挂载数据: 无 ) 
│   │   │   ├── 词法分析 --> ( 难度等级: [0.6665, 0.6667) || 挂载数据: 无 ) 
│   │   │   │   ├── 分词(英文分词/中文分词) --> ( 难度等级: [0.6665, 0.6665) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 词干提取 --> ( 难度等级: [0.6665, 0.6666) || 挂载数据: 无 ) 
│   │   │   │   ├── 词形还原 --> ( 难度等级: [0.6666, 0.6666) || 挂载数据: 无 ) 
│   │   │   │   ├── 词性标注 --> ( 难度等级: [0.6666, 0.6666) || 挂载数据: 无 ) 
│   │   │   │   └── 命名实体识别 --> ( 难度等级: [0.6666, 0.6667) || 挂载数据: qa: 1 ) 
│   │   │   ├── 句法分析 --> ( 难度等级: [0.6667, 0.6668) || 挂载数据: 无 ) 
│   │   │   │   ├── 短语结构分析 --> ( 难度等级: [0.6667, 0.6668) || 挂载数据: 无 ) 
│   │   │   │   └── 依存句法分析 --> ( 难度等级: [0.6668, 0.6668) || 挂载数据: 无 ) 
│   │   │   ├── 语义分析 --> ( 难度等级: [0.6668, 0.667) || 挂载数据: 无 ) 
│   │   │   │   ├── 命名实体消歧 --> ( 难度等级: [0.6668, 0.6669) || 挂载数据: 无 ) 
│   │   │   │   ├── 指代消解 --> ( 难度等级: [0.6669, 0.6669) || 挂载数据: 无 ) 
│   │   │   │   ├── 语义角色标注 --> ( 难度等级: [0.6669, 0.6669) || 挂载数据: 无 ) 
│   │   │   │   ├── 语义关系抽取 --> ( 难度等级: [0.6669, 0.667) || 挂载数据: 无 ) 
│   │   │   │   ├── 语义依存分析 --> ( 难度等级: [0.667, 0.667) || 挂载数据: qa: 4 ) 
│   │   │   │   └── 抽象语义表示 --> ( 难度等级: [0.667, 0.667) || 挂载数据: 无 ) 
│   │   │   ├── 词嵌入 --> ( 难度等级: [0.667, 0.6672) || 挂载数据: qa: 2 ) 
│   │   │   │   ├── Word2Vec --> ( 难度等级: [0.667, 0.667) || 挂载数据: 无 ) 
│   │   │   │   ├── GloVe --> ( 难度等级: [0.667, 0.6671) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── fastText --> ( 难度等级: [0.6671, 0.6671) || 挂载数据: 无 ) 
│   │   │   │   ├── ELMo --> ( 难度等级: [0.6671, 0.6671) || 挂载数据: 无 ) 
│   │   │   │   ├── BERT --> ( 难度等级: [0.6671, 0.6672) || 挂载数据: 无 ) 
│   │   │   │   └── XLNet --> ( 难度等级: [0.6672, 0.6672) || 挂载数据: 无 ) 
│   │   │   ├── 文本挖掘 --> ( 难度等级: [0.6672, 0.6674) || 挂载数据: 无 ) 
│   │   │   │   ├── 文本相似度计算 --> ( 难度等级: [0.6672, 0.6672) || 挂载数据: 无 ) 
│   │   │   │   ├── 文本聚类 --> ( 难度等级: [0.6672, 0.6673) || 挂载数据: 无 ) 
│   │   │   │   ├── 文本分类 --> ( 难度等级: [0.6673, 0.6673) || 挂载数据: 无 ) 
│   │   │   │   └── 文本摘要 --> ( 难度等级: [0.6673, 0.6674) || 挂载数据: qa: 10 ) 
│   │   │   ├── 情感分析 --> ( 难度等级: [0.6674, 0.6675) || 挂载数据: 无 ) 
│   │   │   │   ├── 基于情感词典的情感分析 --> ( 难度等级: [0.6674, 0.6674) || 挂载数据: 无 ) 
│   │   │   │   └── 基于深度学习的情感分析 --> ( 难度等级: [0.6674, 0.6675) || 挂载数据: 无 ) 
│   │   │   ├── 主题模型 --> ( 难度等级: [0.6675, 0.6677) || 挂载数据: 无 ) 
│   │   │   │   ├── LSA --> ( 难度等级: [0.6675, 0.6676) || 挂载数据: 无 ) 
│   │   │   │   └── LDA --> ( 难度等级: [0.6676, 0.6677) || 挂载数据: qa: 2 ) 
│   │   │   ├── 机器翻译 --> ( 难度等级: [0.6677, 0.6679) || 挂载数据: 无 ) 
│   │   │   │   ├── IBM统计翻译模型 --> ( 难度等级: [0.6677, 0.6677) || 挂载数据: 无 ) 
│   │   │   │   ├── 短语抽取 --> ( 难度等级: [0.6677, 0.6678) || 挂载数据: 无 ) 
│   │   │   │   ├── 语言模型 --> ( 难度等级: [0.6678, 0.6678) || 挂载数据: qa: 10 ) 
│   │   │   │   ├── GNMT --> ( 难度等级: [0.6678, 0.6678) || 挂载数据: 无 ) 
│   │   │   │   ├── Seq2Seq --> ( 难度等级: [0.6678, 0.6679) || 挂载数据: 无 ) 
│   │   │   │   └── Transformer --> ( 难度等级: [0.6679, 0.6679) || 挂载数据: 无 ) 
│   │   │   ├── 语言模型 --> ( 难度等级: [0.6679, 0.6681) || 挂载数据: 无 ) 
│   │   │   │   ├── n-gram --> ( 难度等级: [0.6679, 0.6679) || 挂载数据: qa: 7 ) 
│   │   │   │   ├── Pitman-Yor过程模型 --> ( 难度等级: [0.6679, 0.668) || 挂载数据: 无 ) 
│   │   │   │   ├── AWD-LSTM --> ( 难度等级: [0.668, 0.668) || 挂载数据: 无 ) 
│   │   │   │   ├── Transformer-XL --> ( 难度等级: [0.668, 0.668) || 挂载数据: 无 ) 
│   │   │   │   └── Gated CNN --> ( 难度等级: [0.668, 0.6681) || 挂载数据: 无 ) 
│   │   │   ├── 智能问答 --> ( 难度等级: [0.6681, 0.6682) || 挂载数据: 无 ) 
│   │   │   │   ├── 基于知识的问答 --> ( 难度等级: [0.6681, 0.6681) || 挂载数据: 无 ) 
│   │   │   │   ├── 基于检索的问答 --> ( 难度等级: [0.6681, 0.6681) || 挂载数据: 无 ) 
│   │   │   │   ├── 阅读理解 --> ( 难度等级: [0.6681, 0.6682) || 挂载数据: qa: 4 ) 
│   │   │   │   └── 完形填空 --> ( 难度等级: [0.6682, 0.6682) || 挂载数据: 无 ) 
│   │   │   ├── 智能对话 --> ( 难度等级: [0.6682, 0.6684) || 挂载数据: 无 ) 
│   │   │   │   ├── 对话行为分类 --> ( 难度等级: [0.6682, 0.6683) || 挂载数据: 无 ) 
│   │   │   │   ├── 对话状态跟踪 --> ( 难度等级: [0.6683, 0.6683) || 挂载数据: 无 ) 
│   │   │   │   ├── 检索式聊天机器人 --> ( 难度等级: [0.6683, 0.6683) || 挂载数据: 无 ) 
│   │   │   │   ├── 生成式聊天机器人 --> ( 难度等级: [0.6683, 0.6683) || 挂载数据: 无 ) 
│   │   │   │   ├── 意图识别 --> ( 难度等级: [0.6683, 0.6684) || 挂载数据: 无 ) 
│   │   │   │   └── 槽填充(Slot Filling) --> ( 难度等级: [0.6684, 0.6684) || 挂载数据: 无 ) 
│   │   │   ├── 语音识别 --> ( 难度等级: [0.6684, 0.6686) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 傅里叶变换 --> ( 难度等级: [0.6684, 0.6684) || 挂载数据: 无 ) 
│   │   │   │   ├── 声学模型 --> ( 难度等级: [0.6684, 0.6685) || 挂载数据: 无 ) 
│   │   │   │   ├── 隐马尔可夫模型 --> ( 难度等级: [0.6685, 0.6685) || 挂载数据: 无 ) 
│   │   │   │   ├── CNN --> ( 难度等级: [0.6685, 0.6685) || 挂载数据: 无 ) 
│   │   │   │   ├── LSTM-HMM --> ( 难度等级: [0.6685, 0.6685) || 挂载数据: 无 ) 
│   │   │   │   ├── 神经网络语言模型 --> ( 难度等级: [0.6685, 0.6686) || 挂载数据: 无 ) 
│   │   │   │   └── MFCC --> ( 难度等级: [0.6686, 0.6686) || 挂载数据: 无 ) 
│   │   │   └── 知识图谱 --> ( 难度等级: [0.6686, 0.6687) || 挂载数据: 无 ) 
│   │   │       ├── 知识图谱构建 --> ( 难度等级: [0.6686, 0.6686) || 挂载数据: 无 ) 
│   │   │       ├── 知识计算 --> ( 难度等级: [0.6686, 0.6687) || 挂载数据: 无 ) 
│   │   │       ├── 知识存储 --> ( 难度等级: [0.6687, 0.6687) || 挂载数据: qa: 2 ) 
│   │   │       └── 知识服务与应用 --> ( 难度等级: [0.6687, 0.6687) || 挂载数据: 无 ) 
│   │   ├── 简介 --> ( 难度等级: [0.6687, 0.6719) || 挂载数据: 无 ) 
│   │   │   ├── 为何选择Python --> ( 难度等级: [0.6687, 0.6693) || 挂载数据: 无 ) 
│   │   │   ├── 何时避免使用Python --> ( 难度等级: [0.6693, 0.6698) || 挂载数据: 无 ) 
│   │   │   ├── Python中的面向对象编程 --> ( 难度等级: [0.6698, 0.6703) || 挂载数据: 无 ) 
│   │   │   ├── 在Python中调用其他语言 --> ( 难度等级: [0.6703, 0.6708) || 挂载数据: 无 ) 
│   │   │   ├── 将Python模型作为微服务 --> ( 难度等级: [0.6708, 0.6714) || 挂载数据: 无 ) 
│   │   │   └── 高性能API和并发编程 --> ( 难度等级: [0.6714, 0.6719) || 挂载数据: 无 ) 
│   │   ├── Python结构化数据提取、转换和加载 --> ( 难度等级: [0.6719, 0.675) || 挂载数据: 无 ) 
│   │   │   ├── MySQL --> ( 难度等级: [0.6719, 0.6722) || 挂载数据: 无 ) 
│   │   │   │   ├── 如何安装MySQLdb --> ( 难度等级: [0.6719, 0.6719) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 数据库连接 --> ( 难度等级: [0.6719, 0.6719) || 挂载数据: 无 ) 
│   │   │   │   ├── INSERT操作 --> ( 难度等级: [0.6719, 0.672) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── READ操作 --> ( 难度等级: [0.672, 0.672) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── DELETE操作 --> ( 难度等级: [0.672, 0.6721) || 挂载数据: 无 ) 
│   │   │   │   ├── UPDATE操作 --> ( 难度等级: [0.6721, 0.6721) || 挂载数据: qa: 2 ) 
│   │   │   │   ├── COMMIT操作 --> ( 难度等级: [0.6721, 0.6721) || 挂载数据: 无 ) 
│   │   │   │   └── ROLL-BACK操作 --> ( 难度等级: [0.6721, 0.6722) || 挂载数据: 无 ) 
│   │   │   ├── Elasticsearch --> ( 难度等级: [0.6722, 0.6724) || 挂载数据: 无 ) 
│   │   │   ├── Neo4j Python驱动 --> ( 难度等级: [0.6724, 0.6727) || 挂载数据: 无 ) 
│   │   │   ├── neo4j-rest-client --> ( 难度等级: [0.6727, 0.673) || 挂载数据: 无 ) 
│   │   │   ├── 内存数据库 --> ( 难度等级: [0.673, 0.6733) || 挂载数据: 无 ) 
│   │   │   ├── Python版本MongoDB --> ( 难度等级: [0.6733, 0.6736) || 挂载数据: 无 ) 
│   │   │   │   ├── 将数据导入集合 --> ( 难度等级: [0.6733, 0.6733) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用pymongo创建连接 --> ( 难度等级: [0.6733, 0.6734) || 挂载数据: 无 ) 
│   │   │   │   ├── 访问数据库对象 --> ( 难度等级: [0.6734, 0.6734) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 插入数据 --> ( 难度等级: [0.6734, 0.6735) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 更新数据 --> ( 难度等级: [0.6735, 0.6735) || 挂载数据: 无 ) 
│   │   │   │   └── 删除数据 --> ( 难度等级: [0.6735, 0.6736) || 挂载数据: qa: 2 ) 
│   │   │   ├── Pandas --> ( 难度等级: [0.6736, 0.6739) || 挂载数据: 无 ) 
│   │   │   ├── Python非结构化数据提取、转换和加载 --> ( 难度等级: [0.6739, 0.6741) || 挂载数据: 无 ) 
│   │   │   │   ├── 电子邮件解析 --> ( 难度等级: [0.6739, 0.674) || 挂载数据: 无 ) 
│   │   │   │   └── 主题爬取 --> ( 难度等级: [0.674, 0.6741) || 挂载数据: 无 ) 
│   │   │   ├── 稳定方差 --> ( 难度等级: [0.6741, 0.6744) || 挂载数据: 无 ) 
│   │   │   ├── 使周期效应累加 --> ( 难度等级: [0.6744, 0.6747) || 挂载数据: 无 ) 
│   │   │   └── 使数据呈正态分布 --> ( 难度等级: [0.6747, 0.675) || 挂载数据: 无 ) 
│   │   ├── 基于Python的监督学习 --> ( 难度等级: [0.675, 0.6781) || 挂载数据: 无 ) 
│   │   │   ├── 使用Python实现降维 --> ( 难度等级: [0.675, 0.6753) || 挂载数据: 无 ) 
│   │   │   │   └── 相关性分析 --> ( 难度等级: [0.675, 0.6753) || 挂载数据: 无 ) 
│   │   │   ├── 使用Python进行分类 --> ( 难度等级: [0.6753, 0.6755) || 挂载数据: 无 ) 
│   │   │   ├── 决策树 --> ( 难度等级: [0.6755, 0.6758) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 哪个属性优先 --> ( 难度等级: [0.6755, 0.6757) || 挂载数据: 无 ) 
│   │   │   │   └── 随机森林分类器 --> ( 难度等级: [0.6757, 0.6758) || 挂载数据: 无 ) 
│   │   │   ├── 朴素贝叶斯分类器 --> ( 难度等级: [0.6758, 0.676) || 挂载数据: qa: 1 ) 
│   │   │   ├── 支持向量机 --> ( 难度等级: [0.676, 0.6763) || 挂载数据: qa: 1 ) 
│   │   │   ├── 最近邻分类器 --> ( 难度等级: [0.6763, 0.6766) || 挂载数据: 无 ) 
│   │   │   ├── 情绪分析 --> ( 难度等级: [0.6766, 0.6768) || 挂载数据: 无 ) 
│   │   │   ├── 图像识别 --> ( 难度等级: [0.6768, 0.6771) || 挂载数据: 无 ) 
│   │   │   ├── 使用Python进行回归 --> ( 难度等级: [0.6771, 0.6773) || 挂载数据: 无 ) 
│   │   │   │   └── 最小二乘估计 --> ( 难度等级: [0.6771, 0.6773) || 挂载数据: qa: 1 ) 
│   │   │   ├── 分类和回归 --> ( 难度等级: [0.6773, 0.6776) || 挂载数据: 无 ) 
│   │   │   ├── 使模型高估或低估 --> ( 难度等级: [0.6776, 0.6779) || 挂载数据: 无 ) 
│   │   │   └── 处理分类型数据 --> ( 难度等级: [0.6779, 0.6781) || 挂载数据: 无 ) 
│   │   ├── 无监督学习—聚类 --> ( 难度等级: [0.6781, 0.6813) || 挂载数据: 无 ) 
│   │   │   ├── K均值聚类 --> ( 难度等级: [0.6781, 0.6787) || 挂载数据: 无 ) 
│   │   │   ├── 选择K—肘部法则 --> ( 难度等级: [0.6787, 0.6794) || 挂载数据: 无 ) 
│   │   │   ├── 距离或相似性度量 --> ( 难度等级: [0.6794, 0.68) || 挂载数据: 无 ) 
│   │   │   │   ├── 属性 --> ( 难度等级: [0.6794, 0.6795) || 挂载数据: 无 ) 
│   │   │   │   ├── 一般及欧氏距离 --> ( 难度等级: [0.6795, 0.6797) || 挂载数据: 无 ) 
│   │   │   │   ├── 平方欧氏距离 --> ( 难度等级: [0.6797, 0.6798) || 挂载数据: qa: 1 ) 
│   │   │   │   └── 字符串之间的编辑距离 --> ( 难度等级: [0.6798, 0.68) || 挂载数据: 无 ) 
│   │   │   ├── 文档上下文的相似性 --> ( 难度等级: [0.68, 0.6806) || 挂载数据: 无 ) 
│   │   │   └── 如何判断聚类结果是否良好 --> ( 难度等级: [0.6806, 0.6813) || 挂载数据: 无 ) 
│   │   ├── 时间序列 --> ( 难度等级: [0.6813, 0.6844) || 挂载数据: 无 ) 
│   │   │   ├── 变化的分类 --> ( 难度等级: [0.6813, 0.6816) || 挂载数据: 无 ) 
│   │   │   ├── 包含趋势的序列分析 --> ( 难度等级: [0.6816, 0.6819) || 挂载数据: 无 ) 
│   │   │   │   ├── 曲线拟合 --> ( 难度等级: [0.6816, 0.6817) || 挂载数据: 无 ) 
│   │   │   │   └── 从时间序列中去除趋势 --> ( 难度等级: [0.6817, 0.6819) || 挂载数据: qa: 1 ) 
│   │   │   ├── 包含周期性的序列数据分析 --> ( 难度等级: [0.6819, 0.6822) || 挂载数据: 无 ) 
│   │   │   ├── 从时间序列中去除周期性 --> ( 难度等级: [0.6822, 0.6825) || 挂载数据: 无 ) 
│   │   │   │   ├── 滤波 --> ( 难度等级: [0.6822, 0.6823) || 挂载数据: 无 ) 
│   │   │   │   └── 差分 --> ( 难度等级: [0.6823, 0.6825) || 挂载数据: 无 ) 
│   │   │   ├── 平稳时间序列 --> ( 难度等级: [0.6825, 0.6828) || 挂载数据: 无 ) 
│   │   │   │   ├── 平稳过程 --> ( 难度等级: [0.6825, 0.6826) || 挂载数据: 无 ) 
│   │   │   │   ├── 自相关和相关图 --> ( 难度等级: [0.6826, 0.6827) || 挂载数据: qa: 7 ) 
│   │   │   │   └── 自协方差和自相关函数的估计 --> ( 难度等级: [0.6827, 0.6828) || 挂载数据: 无 ) 
│   │   │   ├── 使用Python进行时间序列分析 --> ( 难度等级: [0.6828, 0.6831) || 挂载数据: 无 ) 
│   │   │   │   ├── 有用的方法 --> ( 难度等级: [0.6828, 0.6829) || 挂载数据: 无 ) 
│   │   │   │   ├── 自回归过程 --> ( 难度等级: [0.6829, 0.683) || 挂载数据: 无 ) 
│   │   │   │   └── 估计AR过程的参数 --> ( 难度等级: [0.683, 0.6831) || 挂载数据: 无 ) 
│   │   │   ├── 混合ARMA模型 --> ( 难度等级: [0.6831, 0.6834) || 挂载数据: 无 ) 
│   │   │   ├── 集成ARMA模型 --> ( 难度等级: [0.6834, 0.6837) || 挂载数据: 无 ) 
│   │   │   ├── 一个特殊的场景 --> ( 难度等级: [0.6837, 0.6841) || 挂载数据: 无 ) 
│   │   │   └── 数据缺失 --> ( 难度等级: [0.6841, 0.6844) || 挂载数据: 无 ) 
│   │   └── 大数据分析 --> ( 难度等级: [0.6844, 0.6875) || 挂载数据: qa: 1 ) 
│   │       ├── Hadoop --> ( 难度等级: [0.6844, 0.6852) || 挂载数据: 无 ) 
│   │       │   ├── MapReduce编程 --> ( 难度等级: [0.6844, 0.6845) || 挂载数据: qa: 1 ) 
│   │       │   ├── partitioning函数 --> ( 难度等级: [0.6845, 0.6847) || 挂载数据: 无 ) 
│   │       │   ├── combiner函数 --> ( 难度等级: [0.6847, 0.6848) || 挂载数据: 无 ) 
│   │       │   ├── HDFS文件系统 --> ( 难度等级: [0.6848, 0.685) || 挂载数据: 无 ) 
│   │       │   └── MapReduce设计模式 --> ( 难度等级: [0.685, 0.6852) || 挂载数据: 无 ) 
│   │       ├── Spark --> ( 难度等级: [0.6852, 0.6859) || 挂载数据: 无 ) 
│   │       ├── 云分析 --> ( 难度等级: [0.6859, 0.6867) || 挂载数据: 无 ) 
│   │       └── 物联网 --> ( 难度等级: [0.6867, 0.6875) || 挂载数据: 无 ) 
│   ├── 高级教程 --> ( 难度等级: [0.6875, 0.7188) || 挂载数据: 无 ) 
│   │   ├── 原理与哲学 --> ( 难度等级: [0.6875, 0.6906) || 挂载数据: qa: 1 ) 
│   │   │   ├── Python之禅 --> ( 难度等级: [0.6875, 0.6879) || 挂载数据: 无 ) 
│   │   │   │   ├── 优美胜于丑陋 --> ( 难度等级: [0.6875, 0.6875) || 挂载数据: 无 ) 
│   │   │   │   ├── 明了胜于晦涩 --> ( 难度等级: [0.6875, 0.6875) || 挂载数据: 无 ) 
│   │   │   │   ├── 简洁胜于复杂 --> ( 难度等级: [0.6875, 0.6876) || 挂载数据: 无 ) 
│   │   │   │   ├── 复杂胜于难以理解 --> ( 难度等级: [0.6876, 0.6876) || 挂载数据: 无 ) 
│   │   │   │   ├── 扁平胜于嵌套 --> ( 难度等级: [0.6876, 0.6876) || 挂载数据: 无 ) 
│   │   │   │   ├── 宽松胜于紧凑 --> ( 难度等级: [0.6876, 0.6876) || 挂载数据: 无 ) 
│   │   │   │   ├── 可读性很重要 --> ( 难度等级: [0.6876, 0.6877) || 挂载数据: 无 ) 
│   │   │   │   ├── 即便是特例，也不可违背这些规则 --> ( 难度等级: [0.6877, 0.6877) || 挂载数据: 无 ) 
│   │   │   │   ├── 实用性胜于纯粹性 --> ( 难度等级: [0.6877, 0.6877) || 挂载数据: 无 ) 
│   │   │   │   ├── 错误永远不应该悄无声息地过去 --> ( 难度等级: [0.6877, 0.6877) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 除非明确地沉默 --> ( 难度等级: [0.6877, 0.6878) || 挂载数据: 无 ) 
│   │   │   │   ├── 面对模棱两可的情况，拒绝猜测的诱惑 --> ( 难度等级: [0.6878, 0.6878) || 挂载数据: 无 ) 
│   │   │   │   ├── 应该有一种(最好只有一种)显而易见的方法 --> ( 难度等级: [0.6878, 0.6878) || 挂载数据: 无 ) 
│   │   │   │   ├── 尽管这种方式起初可能并不明显，除非你是荷兰人 --> ( 难度等级: [0.6878, 0.6878) || 挂载数据: 无 ) 
│   │   │   │   ├── 做比不做要好 --> ( 难度等级: [0.6878, 0.6879) || 挂载数据: qa: 10 ) 
│   │   │   │   ├── 不假思索就动手还不如不做 --> ( 难度等级: [0.6879, 0.6879) || 挂载数据: 无 ) 
│   │   │   │   ├── 如果实现难以解释，那就是一个糟糕的想法 --> ( 难度等级: [0.6879, 0.6879) || 挂载数据: 无 ) 
│   │   │   │   ├── 如果实现容易解释，则可能是一个好主意 --> ( 难度等级: [0.6879, 0.6879) || 挂载数据: 无 ) 
│   │   │   │   └── 命名空间是一个很棒的想法，让我们做更多这样的事情吧 --> ( 难度等级: [0.6879, 0.6879) || 挂载数据: 无 ) 
│   │   │   ├── 不要重复自己 --> ( 难度等级: [0.6879, 0.6884) || 挂载数据: 无 ) 
│   │   │   ├── 松耦合 --> ( 难度等级: [0.6884, 0.6888) || 挂载数据: 无 ) 
│   │   │   ├── 武士原则 --> ( 难度等级: [0.6888, 0.6893) || 挂载数据: 无 ) 
│   │   │   ├── 帕累托原则 --> ( 难度等级: [0.6893, 0.6897) || 挂载数据: 无 ) 
│   │   │   ├── 稳健性原则 --> ( 难度等级: [0.6897, 0.6902) || 挂载数据: 无 ) 
│   │   │   └── 向后兼容性 --> ( 难度等级: [0.6902, 0.6906) || 挂载数据: 无 ) 
│   │   ├── 基础知识 --> ( 难度等级: [0.6906, 0.6937) || 挂载数据: 无 ) 
│   │   │   ├── 总体概念 --> ( 难度等级: [0.6906, 0.6911) || 挂载数据: 无 ) 
│   │   │   │   ├── 迭代 --> ( 难度等级: [0.6906, 0.6908) || 挂载数据: 无 ) 
│   │   │   │   ├── 缓存 --> ( 难度等级: [0.6908, 0.691) || 挂载数据: qa: 1 ) 
│   │   │   │   └── 透明度 --> ( 难度等级: [0.691, 0.6911) || 挂载数据: 无 ) 
│   │   │   ├── 流程控制 --> ( 难度等级: [0.6911, 0.6917) || 挂载数据: 无 ) 
│   │   │   │   ├── 捕获异常 --> ( 难度等级: [0.6911, 0.6912) || 挂载数据: 无 ) 
│   │   │   │   ├── 异常链 --> ( 难度等级: [0.6912, 0.6913) || 挂载数据: 无 ) 
│   │   │   │   ├── 当一切顺利的时候 --> ( 难度等级: [0.6913, 0.6914) || 挂载数据: 无 ) 
│   │   │   │   ├── 继续执行，无论异常如何 --> ( 难度等级: [0.6914, 0.6914) || 挂载数据: 无 ) 
│   │   │   │   ├── 优化循环 --> ( 难度等级: [0.6914, 0.6915) || 挂载数据: 无 ) 
│   │   │   │   ├── with语句 --> ( 难度等级: [0.6915, 0.6916) || 挂载数据: qa: 2 ) 
│   │   │   │   └── 条件表达式 --> ( 难度等级: [0.6916, 0.6917) || 挂载数据: 无 ) 
│   │   │   ├── 迭代 --> ( 难度等级: [0.6917, 0.6922) || 挂载数据: 无 ) 
│   │   │   │   ├── 序列解包 --> ( 难度等级: [0.6917, 0.6917) || 挂载数据: 无 ) 
│   │   │   │   ├── 列表解析式 --> ( 难度等级: [0.6917, 0.6918) || 挂载数据: 无 ) 
│   │   │   │   ├── 生成器表达式 --> ( 难度等级: [0.6918, 0.6919) || 挂载数据: 无 ) 
│   │   │   │   ├── 集合解析式 --> ( 难度等级: [0.6919, 0.692) || 挂载数据: 无 ) 
│   │   │   │   ├── 字典解析式 --> ( 难度等级: [0.692, 0.692) || 挂载数据: 无 ) 
│   │   │   │   ├── 将迭代器链接在一起 --> ( 难度等级: [0.692, 0.6921) || 挂载数据: 无 ) 
│   │   │   │   └── 将迭代器压缩在一起 --> ( 难度等级: [0.6921, 0.6922) || 挂载数据: 无 ) 
│   │   │   ├── 容器数据类型 --> ( 难度等级: [0.6922, 0.6927) || 挂载数据: 无 ) 
│   │   │   │   ├── 集合 --> ( 难度等级: [0.6922, 0.6923) || 挂载数据: 无 ) 
│   │   │   │   ├── 命名元组 --> ( 难度等级: [0.6923, 0.6924) || 挂载数据: 无 ) 
│   │   │   │   ├── 有序字典 --> ( 难度等级: [0.6924, 0.6926) || 挂载数据: 无 ) 
│   │   │   │   └── 带有默认值的字典 --> ( 难度等级: [0.6926, 0.6927) || 挂载数据: qa: 1 ) 
│   │   │   ├── 导入代码 --> ( 难度等级: [0.6927, 0.6932) || 挂载数据: 无 ) 
│   │   │   │   ├── 回退(备用)导入 --> ( 难度等级: [0.6927, 0.6928) || 挂载数据: 无 ) 
│   │   │   │   ├── 从即将发布的版本中导入 --> ( 难度等级: [0.6928, 0.6929) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用__all__进行自定义导入 --> ( 难度等级: [0.6929, 0.693) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 相对导入 --> ( 难度等级: [0.693, 0.6931) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── __import__函数 --> ( 难度等级: [0.6931, 0.6931) || 挂载数据: 无 ) 
│   │   │   │   └── importlib模块 --> ( 难度等级: [0.6931, 0.6932) || 挂载数据: 无 ) 
│   │   │   └── 令人兴奋的Python扩展：NIST的随机数信标 --> ( 难度等级: [0.6932, 0.6937) || 挂载数据: 无 ) 
│   │   │       ├── 如何安装NIST信标库 --> ( 难度等级: [0.6932, 0.6932) || 挂载数据: 无 ) 
│   │   │       ├── 示例：获取值 --> ( 难度等级: [0.6932, 0.6933) || 挂载数据: 无 ) 
│   │   │       ├── 示例：模拟抛硬币并记录每次正反面的结果 --> ( 难度等级: [0.6933, 0.6933) || 挂载数据: 无 ) 
│   │   │       ├── 安装Pandas和matplotlib --> ( 难度等级: [0.6933, 0.6933) || 挂载数据: 无 ) 
│   │   │       ├── 创建文本文件 --> ( 难度等级: [0.6933, 0.6933) || 挂载数据: 无 ) 
│   │   │       ├── 使用Pandas显示数据 --> ( 难度等级: [0.6933, 0.6933) || 挂载数据: 无 ) 
│   │   │       ├── 进行一些数据分析 --> ( 难度等级: [0.6933, 0.6934) || 挂载数据: 无 ) 
│   │   │       ├── 使用matplotlib进行绘图 --> ( 难度等级: [0.6934, 0.6934) || 挂载数据: 无 ) 
│   │   │       ├── 图表的类型 --> ( 难度等级: [0.6934, 0.6934) || 挂载数据: 无 ) 
│   │   │       ├── 安装Scrapy --> ( 难度等级: [0.6934, 0.6934) || 挂载数据: 无 ) 
│   │   │       ├── 运行Scrapy --> ( 难度等级: [0.6934, 0.6934) || 挂载数据: 无 ) 
│   │   │       ├── 使用Scrapy获取Web数据 --> ( 难度等级: [0.6934, 0.6935) || 挂载数据: 无 ) 
│   │   │       ├── 通过Scrapy浏览网页 --> ( 难度等级: [0.6935, 0.6935) || 挂载数据: 无 ) 
│   │   │       ├── shell选项 --> ( 难度等级: [0.6935, 0.6935) || 挂载数据: 无 ) 
│   │   │       ├── 安装Beautiful Soup --> ( 难度等级: [0.6935, 0.6935) || 挂载数据: 无 ) 
│   │   │       ├── 使用Beautiful Soup --> ( 难度等级: [0.6935, 0.6935) || 挂载数据: 无 ) 
│   │   │       ├── 如何安装feedparser库 --> ( 难度等级: [0.6935, 0.6936) || 挂载数据: 无 ) 
│   │   │       ├── 如何使用feedparser库 --> ( 难度等级: [0.6936, 0.6936) || 挂载数据: 无 ) 
│   │   │       ├── 安装NumPy --> ( 难度等级: [0.6936, 0.6936) || 挂载数据: 无 ) 
│   │   │       ├── 使用NumPy --> ( 难度等级: [0.6936, 0.6936) || 挂载数据: 无 ) 
│   │   │       ├── 使用NumPy数组 --> ( 难度等级: [0.6936, 0.6936) || 挂载数据: 无 ) 
│   │   │       ├── 统计度量 --> ( 难度等级: [0.6936, 0.6937) || 挂载数据: 无 ) 
│   │   │       ├── 如何安装Pillow库 --> ( 难度等级: [0.6937, 0.6937) || 挂载数据: 无 ) 
│   │   │       ├── 图像显示：确定文件的大小和类型并显示 --> ( 难度等级: [0.6937, 0.6937) || 挂载数据: 无 ) 
│   │   │       ├── 图像处理：裁剪图像的一部分 --> ( 难度等级: [0.6937, 0.6937) || 挂载数据: 无 ) 
│   │   │       ├── 随机数 --> ( 难度等级: [0.6937, 0.6937) || 挂载数据: qa: 2 ) 
│   │   │       └── 密码生成器 --> ( 难度等级: [0.6937, 0.6937) || 挂载数据: 无 ) 
│   │   ├── 函数 --> ( 难度等级: [0.6937, 0.6969) || 挂载数据: 无 ) 
│   │   │   ├── 参数 --> ( 难度等级: [0.6937, 0.6943) || 挂载数据: 无 ) 
│   │   │   │   ├── 规划时的灵活性 --> ( 难度等级: [0.6937, 0.6938) || 挂载数据: 无 ) 
│   │   │   │   ├── 可变位置参数 --> ( 难度等级: [0.6938, 0.6939) || 挂载数据: qa: 3 ) 
│   │   │   │   ├── 可变关键字参数 --> ( 难度等级: [0.6939, 0.694) || 挂载数据: 无 ) 
│   │   │   │   ├── 组合不同类型的参数 --> ( 难度等级: [0.694, 0.694) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 调用具有可变参数的函数 --> ( 难度等级: [0.694, 0.6941) || 挂载数据: qa: 2 ) 
│   │   │   │   ├── 传递参数 --> ( 难度等级: [0.6941, 0.6942) || 挂载数据: qa: 10 ) 
│   │   │   │   └── 自省 --> ( 难度等级: [0.6942, 0.6943) || 挂载数据: 无 ) 
│   │   │   ├── 装饰器 --> ( 难度等级: [0.6943, 0.6948) || 挂载数据: 无 ) 
│   │   │   │   ├── 闭包 --> ( 难度等级: [0.6943, 0.6944) || 挂载数据: 无 ) 
│   │   │   │   ├── 包装器 --> ( 难度等级: [0.6944, 0.6945) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 带参数的装饰器 --> ( 难度等级: [0.6945, 0.6947) || 挂载数据: qa: 1 ) 
│   │   │   │   └── 带参数或不带参数的装饰器 --> ( 难度等级: [0.6947, 0.6948) || 挂载数据: 无 ) 
│   │   │   ├── 函数注解 --> ( 难度等级: [0.6948, 0.6953) || 挂载数据: 无 ) 
│   │   │   │   ├── 提取样板 --> ( 难度等级: [0.6948, 0.6951) || 挂载数据: 无 ) 
│   │   │   │   └── 用装饰器进行注解 --> ( 难度等级: [0.6951, 0.6953) || 挂载数据: 无 ) 
│   │   │   ├── 生成器 --> ( 难度等级: [0.6953, 0.6958) || 挂载数据: 无 ) 
│   │   │   ├── lambda --> ( 难度等级: [0.6958, 0.6964) || 挂载数据: qa: 1 ) 
│   │   │   └── 自省 --> ( 难度等级: [0.6964, 0.6969) || 挂载数据: 无 ) 
│   │   │       ├── 标识对象类型 --> ( 难度等级: [0.6964, 0.6965) || 挂载数据: 无 ) 
│   │   │       ├── 模块和软件包 --> ( 难度等级: [0.6965, 0.6967) || 挂载数据: 无 ) 
│   │   │       └── 文档字符串 --> ( 难度等级: [0.6967, 0.6969) || 挂载数据: 无 ) 
│   │   │           ├── 描述函数的作用 --> ( 难度等级: [0.6967, 0.6968) || 挂载数据: 无 ) 
│   │   │           ├── 返回值 --> ( 难度等级: [0.6968, 0.6968) || 挂载数据: 无 ) 
│   │   │           └── 包含预期的异常 --> ( 难度等级: [0.6968, 0.6969) || 挂载数据: qa: 1 ) 
│   │   ├── 类 --> ( 难度等级: [0.6969, 0.7) || 挂载数据: 无 ) 
│   │   │   ├── 继承 --> ( 难度等级: [0.6969, 0.6975) || 挂载数据: 无 ) 
│   │   │   │   ├── 多重继承 --> ( 难度等级: [0.6969, 0.697) || 挂载数据: qa: 3 ) 
│   │   │   │   ├── 方法解析顺序 --> ( 难度等级: [0.697, 0.6972) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用super函数将控制权传递给其他类 --> ( 难度等级: [0.6972, 0.6973) || 挂载数据: qa: 1 ) 
│   │   │   │   └── 自省 --> ( 难度等级: [0.6973, 0.6975) || 挂载数据: 无 ) 
│   │   │   ├── 如何创建类 --> ( 难度等级: [0.6975, 0.6981) || 挂载数据: 无 ) 
│   │   │   │   ├── 在运行时创建类 --> ( 难度等级: [0.6975, 0.6977) || 挂载数据: qa: 7 ) 
│   │   │   │   ├── 元类 --> ( 难度等级: [0.6977, 0.6979) || 挂载数据: qa: 10 ) 
│   │   │   │   └── 控制命名空间 --> ( 难度等级: [0.6979, 0.6981) || 挂载数据: 无 ) 
│   │   │   ├── 成员变量 --> ( 难度等级: [0.6981, 0.6987) || 挂载数据: 无 ) 
│   │   │   │   ├── 属性 --> ( 难度等级: [0.6981, 0.6984) || 挂载数据: 无 ) 
│   │   │   │   └── 描述器 --> ( 难度等级: [0.6984, 0.6987) || 挂载数据: qa: 1 ) 
│   │   │   ├── 方法 --> ( 难度等级: [0.6987, 0.6994) || 挂载数据: 无 ) 
│   │   │   │   ├── 非绑定方法 --> ( 难度等级: [0.6987, 0.6991) || 挂载数据: 无 ) 
│   │   │   │   └── 绑定方法 --> ( 难度等级: [0.6991, 0.6994) || 挂载数据: qa: 10 ) 
│   │   │   └── 魔术方法 --> ( 难度等级: [0.6994, 0.7) || 挂载数据: qa: 1 ) 
│   │   │       ├── 处理成员变量 --> ( 难度等级: [0.6994, 0.6997) || 挂载数据: 无 ) 
│   │   │       └── 字符串表示 --> ( 难度等级: [0.6997, 0.7) || 挂载数据: 无 ) 
│   │   │           ├── 字节字符串 --> ( 难度等级: [0.6997, 0.6998) || 挂载数据: qa: 1 ) 
│   │   │           │   ├── 借助chr和ord进行简单的转换 --> ( 难度等级: [0.6997, 0.6997) || 挂载数据: 无 ) 
│   │   │           │   └── 借助struct模块进行复杂的转换 --> ( 难度等级: [0.6997, 0.6998) || 挂载数据: 无 ) 
│   │   │           ├── 文本 --> ( 难度等级: [0.6998, 0.6998) || 挂载数据: 无 ) 
│   │   │           │   ├── Unicode --> ( 难度等级: [0.6998, 0.6998) || 挂载数据: qa: 4 ) 
│   │   │           │   └── 编码 --> ( 难度等级: [0.6998, 0.6998) || 挂载数据: qa: 1 ) 
│   │   │           ├── 简单的替换 --> ( 难度等级: [0.6998, 0.6999) || 挂载数据: qa: 3 ) 
│   │   │           └── 格式化 --> ( 难度等级: [0.6999, 0.7) || 挂载数据: 无 ) 
│   │   │               ├── 在对象中查找值 --> ( 难度等级: [0.6999, 0.6999) || 挂载数据: 无 ) 
│   │   │               ├── 区分字符串类型 --> ( 难度等级: [0.6999, 0.7) || 挂载数据: 无 ) 
│   │   │               ├── 标准格式规范 --> ( 难度等级: [0.7, 0.7) || 挂载数据: 无 ) 
│   │   │               ├── 为文本文档制作目录 --> ( 难度等级: [0.7, 0.7) || 挂载数据: qa: 2 ) 
│   │   │               └── 自定义格式规范 --> ( 难度等级: [0.7, 0.7) || 挂载数据: 无 ) 
│   │   ├── 通用协议 --> ( 难度等级: [0.7, 0.7031) || 挂载数据: 无 ) 
│   │   │   ├── 基本运算 --> ( 难度等级: [0.7, 0.7004) || 挂载数据: 无 ) 
│   │   │   │   ├── 数学运算 --> ( 难度等级: [0.7, 0.7001) || 挂载数据: 无 ) 
│   │   │   │   ├── 按位运算 --> ( 难度等级: [0.7001, 0.7003) || 挂载数据: qa: 4 ) 
│   │   │   │   └── 运算符的变体 --> ( 难度等级: [0.7003, 0.7004) || 挂载数据: 无 ) 
│   │   │   ├── 数字 --> ( 难度等级: [0.7004, 0.7009) || 挂载数据: 无 ) 
│   │   │   │   ├── 符号运算 --> ( 难度等级: [0.7004, 0.7007) || 挂载数据: qa: 2 ) 
│   │   │   │   └── 比较运算 --> ( 难度等级: [0.7007, 0.7009) || 挂载数据: 无 ) 
│   │   │   ├── 可迭代对象 --> ( 难度等级: [0.7009, 0.7013) || 挂载数据: 无 ) 
│   │   │   ├── 序列 --> ( 难度等级: [0.7013, 0.7018) || 挂载数据: 无 ) 
│   │   │   ├── 映射 --> ( 难度等级: [0.7018, 0.7022) || 挂载数据: 无 ) 
│   │   │   ├── _call_方法 --> ( 难度等级: [0.7022, 0.7027) || 挂载数据: 无 ) 
│   │   │   └── 上下文管理器 --> ( 难度等级: [0.7027, 0.7031) || 挂载数据: 无 ) 
│   │   ├── 对象管理 --> ( 难度等级: [0.7031, 0.7063) || 挂载数据: 无 ) 
│   │   │   ├── 命名空间字典 --> ( 难度等级: [0.7031, 0.7039) || 挂载数据: 无 ) 
│   │   │   ├── 垃圾回收 --> ( 难度等级: [0.7039, 0.7047) || 挂载数据: 无 ) 
│   │   │   │   ├── 引用计数 --> ( 难度等级: [0.7039, 0.7042) || 挂载数据: 无 ) 
│   │   │   │   ├── 循环引用 --> ( 难度等级: [0.7042, 0.7044) || 挂载数据: qa: 1 ) 
│   │   │   │   └── 弱引用 --> ( 难度等级: [0.7044, 0.7047) || 挂载数据: 无 ) 
│   │   │   ├── Python对象的序列化 --> ( 难度等级: [0.7047, 0.7055) || 挂载数据: 无 ) 
│   │   │   └── 复制 --> ( 难度等级: [0.7055, 0.7063) || 挂载数据: 无 ) 
│   │   │       ├── 浅层复制 --> ( 难度等级: [0.7055, 0.7059) || 挂载数据: qa: 1 ) 
│   │   │       └── 深层复制 --> ( 难度等级: [0.7059, 0.7063) || 挂载数据: qa: 1 ) 
│   │   ├── 文档的编写 --> ( 难度等级: [0.7063, 0.7094) || 挂载数据: 无 ) 
│   │   │   ├── 恰当地命名 --> ( 难度等级: [0.7063, 0.707) || 挂载数据: 无 ) 
│   │   │   ├── 注释 --> ( 难度等级: [0.707, 0.7078) || 挂载数据: 无 ) 
│   │   │   ├── 代码之外的文档 --> ( 难度等级: [0.7078, 0.7086) || 挂载数据: 无 ) 
│   │   │   │   ├── 安装与配置 --> ( 难度等级: [0.7078, 0.7081) || 挂载数据: 无 ) 
│   │   │   │   ├── 教程 --> ( 难度等级: [0.7081, 0.7083) || 挂载数据: qa: 2 ) 
│   │   │   │   └── 参考文档 --> ( 难度等级: [0.7083, 0.7086) || 挂载数据: qa: 4 ) 
│   │   │   └── 用于编写文档的实用工具 --> ( 难度等级: [0.7086, 0.7094) || 挂载数据: 无 ) 
│   │   │       ├── 链接 --> ( 难度等级: [0.7086, 0.709) || 挂载数据: 无 ) 
│   │   │       └── Sphinx --> ( 难度等级: [0.709, 0.7094) || 挂载数据: 无 ) 
│   │   ├── 测试 --> ( 难度等级: [0.7094, 0.7125) || 挂载数据: 无 ) 
│   │   │   ├── 测试驱动开发 --> ( 难度等级: [0.7094, 0.7102) || 挂载数据: qa: 1 ) 
│   │   │   ├── doctest --> ( 难度等级: [0.7102, 0.7109) || 挂载数据: 无 ) 
│   │   │   │   ├── 格式化代码 --> ( 难度等级: [0.7102, 0.7104) || 挂载数据: 无 ) 
│   │   │   │   ├── 呈现输出 --> ( 难度等级: [0.7104, 0.7105) || 挂载数据: 无 ) 
│   │   │   │   ├── 与文档集成 --> ( 难度等级: [0.7105, 0.7107) || 挂载数据: 无 ) 
│   │   │   │   └── 运行测试 --> ( 难度等级: [0.7107, 0.7109) || 挂载数据: 无 ) 
│   │   │   ├── unittest模块 --> ( 难度等级: [0.7109, 0.7117) || 挂载数据: 无 ) 
│   │   │   │   ├── 初始化配置 --> ( 难度等级: [0.7109, 0.7111) || 挂载数据: 无 ) 
│   │   │   │   ├── 编写测试 --> ( 难度等级: [0.7111, 0.7112) || 挂载数据: qa: 10 ) 
│   │   │   │   ├── 其他比较 --> ( 难度等级: [0.7112, 0.7113) || 挂载数据: 无 ) 
│   │   │   │   ├── 测试异常 --> ( 难度等级: [0.7113, 0.7115) || 挂载数据: 无 ) 
│   │   │   │   ├── 测试对象标识 --> ( 难度等级: [0.7115, 0.7116) || 挂载数据: 无 ) 
│   │   │   │   └── 释放资源 --> ( 难度等级: [0.7116, 0.7117) || 挂载数据: 无 ) 
│   │   │   └── 提供自定义的测试类 --> ( 难度等级: [0.7117, 0.7125) || 挂载数据: 无 ) 
│   │   ├── 发布 --> ( 难度等级: [0.7125, 0.7156) || 挂载数据: 无 ) 
│   │   │   ├── 许可证 --> ( 难度等级: [0.7125, 0.7135) || 挂载数据: 无 ) 
│   │   │   │   ├── GNU通用公共许可证 --> ( 难度等级: [0.7125, 0.7127) || 挂载数据: 无 ) 
│   │   │   │   ├── Affero通用公共许可证 --> ( 难度等级: [0.7127, 0.7129) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── GNU宽通用公共许可证 --> ( 难度等级: [0.7129, 0.7131) || 挂载数据: 无 ) 
│   │   │   │   ├── 伯克利软件发行许可证 --> ( 难度等级: [0.7131, 0.7133) || 挂载数据: 无 ) 
│   │   │   │   └── 其他许可证 --> ( 难度等级: [0.7133, 0.7135) || 挂载数据: 无 ) 
│   │   │   ├── 打包 --> ( 难度等级: [0.7135, 0.7146) || 挂载数据: 无 ) 
│   │   │   │   ├── setup.py --> ( 难度等级: [0.7135, 0.7139) || 挂载数据: qa: 10 ) 
│   │   │   │   ├── MANIFEST.in --> ( 难度等级: [0.7139, 0.7142) || 挂载数据: qa: 5 ) 
│   │   │   │   └── sdist命令 --> ( 难度等级: [0.7142, 0.7146) || 挂载数据: 无 ) 
│   │   │   └── 发布 --> ( 难度等级: [0.7146, 0.7156) || 挂载数据: 无 ) 
│   │   └── 构建CSV框架sheets --> ( 难度等级: [0.7156, 0.7188) || 挂载数据: 无 ) 
│   │       ├── 构建声明性框架 --> ( 难度等级: [0.7156, 0.7162) || 挂载数据: 无 ) 
│   │       │   ├── 声明性编程简介 --> ( 难度等级: [0.7156, 0.7159) || 挂载数据: 无 ) 
│   │       │   └── 是否构建声明性框架 --> ( 难度等级: [0.7159, 0.7162) || 挂载数据: 无 ) 
│   │       ├── 构建框架 --> ( 难度等级: [0.7162, 0.7169) || 挂载数据: 无 ) 
│   │       │   ├── 管理选项 --> ( 难度等级: [0.7162, 0.7164) || 挂载数据: 无 ) 
│   │       │   ├── 定义字段 --> ( 难度等级: [0.7164, 0.7165) || 挂载数据: 无 ) 
│   │       │   ├── 将字段附加到类 --> ( 难度等级: [0.7165, 0.7166) || 挂载数据: 无 ) 
│   │       │   ├── 添加元类 --> ( 难度等级: [0.7166, 0.7167) || 挂载数据: 无 ) 
│   │       │   └── 整合 --> ( 难度等级: [0.7167, 0.7169) || 挂载数据: 无 ) 
│   │       ├── 字段排序 --> ( 难度等级: [0.7169, 0.7175) || 挂载数据: 无 ) 
│   │       │   ├── DeclarativeMeta.__prepare__ --> ( 难度等级: [0.7169, 0.717) || 挂载数据: 无 ) 
│   │       │   ├── Column.__init__ --> ( 难度等级: [0.717, 0.7171) || 挂载数据: qa: 3 ) 
│   │       │   ├── Column.__new__ --> ( 难度等级: [0.7171, 0.7172) || 挂载数据: 无 ) 
│   │       │   ├── CounterMeta.__call__ --> ( 难度等级: [0.7172, 0.7174) || 挂载数据: 无 ) 
│   │       │   └── 挑选选项 --> ( 难度等级: [0.7174, 0.7175) || 挂载数据: 无 ) 
│   │       ├── 构建字段库 --> ( 难度等级: [0.7175, 0.7181) || 挂载数据: 无 ) 
│   │       │   ├── StringField(字符串字段) --> ( 难度等级: [0.7175, 0.7176) || 挂载数据: qa: 4 ) 
│   │       │   ├── IntegerColumn(整数列) --> ( 难度等级: [0.7176, 0.7177) || 挂载数据: 无 ) 
│   │       │   ├── FloatColumn(浮点数列) --> ( 难度等级: [0.7177, 0.7179) || 挂载数据: 无 ) 
│   │       │   ├── DecimalColumn(小数列) --> ( 难度等级: [0.7179, 0.718) || 挂载数据: 无 ) 
│   │       │   └── DateColumn(日期列) --> ( 难度等级: [0.718, 0.7181) || 挂载数据: 无 ) 
│   │       └── 回到CSV --> ( 难度等级: [0.7181, 0.7188) || 挂载数据: 无 ) 
│   │           ├── 检查参数 --> ( 难度等级: [0.7181, 0.7183) || 挂载数据: 无 ) 
│   │           ├── 填充值 --> ( 难度等级: [0.7183, 0.7184) || 挂载数据: 无 ) 
│   │           ├── 读取器 --> ( 难度等级: [0.7184, 0.7186) || 挂载数据: 无 ) 
│   │           └── 写入器 --> ( 难度等级: [0.7186, 0.7188) || 挂载数据: 无 ) 
│   └── 其他 --> ( 难度等级: [0.7188, 0.75) || 挂载数据: 无 ) 
│       ├── GUI界面编程 --> ( 难度等级: [0.7188, 0.7232) || 挂载数据: 无 ) 
│       │   ├── 初识GUI --> ( 难度等级: [0.7188, 0.7196) || 挂载数据: 无 ) 
│       │   │   ├── 什么是GUI --> ( 难度等级: [0.7188, 0.719) || 挂载数据: qa: 8 ) 
│       │   │   ├── 常用的GUI框架 --> ( 难度等级: [0.719, 0.7193) || 挂载数据: 无 ) 
│       │   │   └── 安装wxPython --> ( 难度等级: [0.7193, 0.7196) || 挂载数据: 无 ) 
│       │   ├── 创建应用程序 --> ( 难度等级: [0.7196, 0.7205) || 挂载数据: 无 ) 
│       │   │   ├── 创建一个wx.App的子类 --> ( 难度等级: [0.7196, 0.7199) || 挂载数据: 无 ) 
│       │   │   ├── 直接使用wx.App --> ( 难度等级: [0.7199, 0.7202) || 挂载数据: 无 ) 
│       │   │   └── 使用wx.Frame框架 --> ( 难度等级: [0.7202, 0.7205) || 挂载数据: 无 ) 
│       │   ├── 常用控件 --> ( 难度等级: [0.7205, 0.7214) || 挂载数据: qa: 1 ) 
│       │   │   ├── StaticText文本类 --> ( 难度等级: [0.7205, 0.7208) || 挂载数据: 无 ) 
│       │   │   ├── TextCtrl输入文本类 --> ( 难度等级: [0.7208, 0.7211) || 挂载数据: 无 ) 
│       │   │   └── Button按钮类 --> ( 难度等级: [0.7211, 0.7214) || 挂载数据: 无 ) 
│       │   ├── BoxSizer布局 --> ( 难度等级: [0.7214, 0.7223) || 挂载数据: 无 ) 
│       │   │   ├── 什么是BoxSizer --> ( 难度等级: [0.7214, 0.7219) || 挂载数据: 无 ) 
│       │   │   └── 使用BoxSizer布局 --> ( 难度等级: [0.7219, 0.7223) || 挂载数据: qa: 1 ) 
│       │   └── 事件处理 --> ( 难度等级: [0.7223, 0.7232) || 挂载数据: 无 ) 
│       │       ├── 什么是事件 --> ( 难度等级: [0.7223, 0.7228) || 挂载数据: 无 ) 
│       │       └── 绑定事件 --> ( 难度等级: [0.7228, 0.7232) || 挂载数据: qa: 1 ) 
│       ├── Pygame游戏编程 --> ( 难度等级: [0.7232, 0.7277) || 挂载数据: 无 ) 
│       │   ├── 初识Pygame --> ( 难度等级: [0.7232, 0.7247) || 挂载数据: 无 ) 
│       │   │   ├── 安装Pygame --> ( 难度等级: [0.7232, 0.724) || 挂载数据: 无 ) 
│       │   │   └── Pygame常用模块 --> ( 难度等级: [0.724, 0.7247) || 挂载数据: 无 ) 
│       │   ├── Pygame基本使用 --> ( 难度等级: [0.7247, 0.7262) || 挂载数据: 无 ) 
│       │   └── 开发Flappy Bird游戏 --> ( 难度等级: [0.7262, 0.7277) || 挂载数据: 无 ) 
│       │       ├── 游戏简介 --> ( 难度等级: [0.7262, 0.7264) || 挂载数据: 无 ) 
│       │       ├── 游戏分析 --> ( 难度等级: [0.7264, 0.7266) || 挂载数据: qa: 7 ) 
│       │       ├── 搭建主框架 --> ( 难度等级: [0.7266, 0.7268) || 挂载数据: qa: 1 ) 
│       │       ├── 创建小鸟类 --> ( 难度等级: [0.7268, 0.727) || 挂载数据: 无 ) 
│       │       ├── 创建管道类 --> ( 难度等级: [0.727, 0.7273) || 挂载数据: 无 ) 
│       │       ├── 计算得分 --> ( 难度等级: [0.7273, 0.7275) || 挂载数据: qa: 1 ) 
│       │       └── 碰撞检测 --> ( 难度等级: [0.7275, 0.7277) || 挂载数据: 无 ) 
│       ├── 网络爬虫开发 --> ( 难度等级: [0.7277, 0.7321) || 挂载数据: 无 ) 
│       │   ├── 初识网络爬虫 --> ( 难度等级: [0.7277, 0.7292) || 挂载数据: 无 ) 
│       │   │   ├── 网络爬虫概述 --> ( 难度等级: [0.7277, 0.7282) || 挂载数据: qa: 3 ) 
│       │   │   ├── 网络爬虫的分类 --> ( 难度等级: [0.7282, 0.7287) || 挂载数据: 无 ) 
│       │   │   └── 网络爬虫的基本原理 --> ( 难度等级: [0.7287, 0.7292) || 挂载数据: 无 ) 
│       │   ├── 网络爬虫的常用技术 --> ( 难度等级: [0.7292, 0.7307) || 挂载数据: qa: 1 ) 
│       │   │   ├── Python的网络请求 --> ( 难度等级: [0.7292, 0.7295) || 挂载数据: qa: 4 ) 
│       │   │   ├── 请求headers处理 --> ( 难度等级: [0.7295, 0.7298) || 挂载数据: qa: 1 ) 
│       │   │   ├── 网络超时 --> ( 难度等级: [0.7298, 0.7301) || 挂载数据: qa: 1 ) 
│       │   │   ├── 代理服务 --> ( 难度等级: [0.7301, 0.7304) || 挂载数据: 无 ) 
│       │   │   └── HTML解析之BeautifulSoup --> ( 难度等级: [0.7304, 0.7307) || 挂载数据: qa: 2 ) 
│       │   └── 网络爬虫开发常用框架 --> ( 难度等级: [0.7307, 0.7321) || 挂载数据: 无 ) 
│       │       ├── Scrapy爬虫框架 --> ( 难度等级: [0.7307, 0.7312) || 挂载数据: qa: 1 ) 
│       │       ├── Crawley爬虫框架 --> ( 难度等级: [0.7312, 0.7316) || 挂载数据: qa: 1 ) 
│       │       └── PySpider爬虫框架 --> ( 难度等级: [0.7316, 0.7321) || 挂载数据: 无 ) 
│       ├── 使用进程和线程 --> ( 难度等级: [0.7321, 0.7366) || 挂载数据: 无 ) 
│       │   ├── 什么是进程 --> ( 难度等级: [0.7321, 0.7329) || 挂载数据: 无 ) 
│       │   ├── 创建进程的常用方式 --> ( 难度等级: [0.7329, 0.7336) || 挂载数据: 无 ) 
│       │   │   ├── 使用multiprocessing模块创建进程 --> ( 难度等级: [0.7329, 0.7331) || 挂载数据: qa: 1 ) 
│       │   │   ├── 使用Process子类创建进程 --> ( 难度等级: [0.7331, 0.7334) || 挂载数据: qa: 1 ) 
│       │   │   └── 使用进程池Pool创建进程 --> ( 难度等级: [0.7334, 0.7336) || 挂载数据: qa: 2 ) 
│       │   ├── 进程间通信 --> ( 难度等级: [0.7336, 0.7344) || 挂载数据: 无 ) 
│       │   │   ├── 队列简介 --> ( 难度等级: [0.7336, 0.7339) || 挂载数据: 无 ) 
│       │   │   ├── 多进程队列的使用 --> ( 难度等级: [0.7339, 0.7341) || 挂载数据: qa: 5 ) 
│       │   │   └── 使用队列在进程间通信 --> ( 难度等级: [0.7341, 0.7344) || 挂载数据: 无 ) 
│       │   ├── 什么是线程 --> ( 难度等级: [0.7344, 0.7351) || 挂载数据: 无 ) 
│       │   ├── 创建线程 --> ( 难度等级: [0.7351, 0.7359) || 挂载数据: 无 ) 
│       │   │   ├── 使用threading模块创建线程 --> ( 难度等级: [0.7351, 0.7355) || 挂载数据: 无 ) 
│       │   │   └── 使用Thread子类创建线程 --> ( 难度等级: [0.7355, 0.7359) || 挂载数据: qa: 1 ) 
│       │   └── 线程间通信 --> ( 难度等级: [0.7359, 0.7366) || 挂载数据: 无 ) 
│       │       ├── 什么是互斥锁 --> ( 难度等级: [0.7359, 0.7361) || 挂载数据: qa: 1 ) 
│       │       ├── 使用互斥锁 --> ( 难度等级: [0.7361, 0.7364) || 挂载数据: 无 ) 
│       │       └── 使用队列在线程间通信 --> ( 难度等级: [0.7364, 0.7366) || 挂载数据: 无 ) 
│       ├── 网络编程 --> ( 难度等级: [0.7366, 0.7411) || 挂载数据: 无 ) 
│       │   ├── 网络基础 --> ( 难度等级: [0.7366, 0.7381) || 挂载数据: 无 ) 
│       │   │   ├── TCP/IP简介 --> ( 难度等级: [0.7366, 0.7371) || 挂载数据: qa: 8 ) 
│       │   │   ├── UDP简介 --> ( 难度等级: [0.7371, 0.7376) || 挂载数据: 无 ) 
│       │   │   └── Socket简介 --> ( 难度等级: [0.7376, 0.7381) || 挂载数据: 无 ) 
│       │   ├── TCP编程 --> ( 难度等级: [0.7381, 0.7396) || 挂载数据: 无 ) 
│       │   │   ├── 创建TCP服务器 --> ( 难度等级: [0.7381, 0.7386) || 挂载数据: 无 ) 
│       │   │   ├── 创建TCP客户端 --> ( 难度等级: [0.7386, 0.7391) || 挂载数据: qa: 1 ) 
│       │   │   └── 执行TCP服务器和客户端 --> ( 难度等级: [0.7391, 0.7396) || 挂载数据: 无 ) 
│       │   └── UDP编程 --> ( 难度等级: [0.7396, 0.7411) || 挂载数据: 无 ) 
│       │       ├── 创建UDP服务器 --> ( 难度等级: [0.7396, 0.7401) || 挂载数据: 无 ) 
│       │       ├── 创建UDP客户端 --> ( 难度等级: [0.7401, 0.7406) || 挂载数据: qa: 3 ) 
│       │       └── 执行UDP服务器和客户端 --> ( 难度等级: [0.7406, 0.7411) || 挂载数据: 无 ) 
│       ├── Web编程 --> ( 难度等级: [0.7411, 0.7455) || 挂载数据: 无 ) 
│       │   ├── Web基础 --> ( 难度等级: [0.7411, 0.7426) || 挂载数据: 无 ) 
│       │   │   ├── HTTP协议 --> ( 难度等级: [0.7411, 0.7414) || 挂载数据: 无 ) 
│       │   │   ├── Web服务器 --> ( 难度等级: [0.7414, 0.7418) || 挂载数据: 无 ) 
│       │   │   ├── 前端基础 --> ( 难度等级: [0.7418, 0.7422) || 挂载数据: qa: 10 ) 
│       │   │   └── 静态服务器 --> ( 难度等级: [0.7422, 0.7426) || 挂载数据: 无 ) 
│       │   ├── WSGI接口 --> ( 难度等级: [0.7426, 0.744) || 挂载数据: 无 ) 
│       │   │   ├── CGI简介 --> ( 难度等级: [0.7426, 0.7429) || 挂载数据: 无 ) 
│       │   │   ├── WSGI简介 --> ( 难度等级: [0.7429, 0.7433) || 挂载数据: 无 ) 
│       │   │   ├── 定义WSGI接口 --> ( 难度等级: [0.7433, 0.7437) || 挂载数据: qa: 3 ) 
│       │   │   └── 运行WSGI服务 --> ( 难度等级: [0.7437, 0.744) || 挂载数据: 无 ) 
│       │   └── Web框架 --> ( 难度等级: [0.744, 0.7455) || 挂载数据: 无 ) 
│       │       ├── 什么是Web框架 --> ( 难度等级: [0.744, 0.7448) || 挂载数据: qa: 3 ) 
│       │       └── Python中常用的Web框架 --> ( 难度等级: [0.7448, 0.7455) || 挂载数据: 无 ) 
│       └── Flask框架 --> ( 难度等级: [0.7455, 0.75) || 挂载数据: qa: 1 ) 
│           ├── Flask简介 --> ( 难度等级: [0.7455, 0.7467) || 挂载数据: 无 ) 
│           │   ├── 安装虚拟环境 --> ( 难度等级: [0.7455, 0.7459) || 挂载数据: 无 ) 
│           │   ├── 安装Flask --> ( 难度等级: [0.7459, 0.7463) || 挂载数据: qa: 6 ) 
│           │   └── 第一个Flask程序 --> ( 难度等级: [0.7463, 0.7467) || 挂载数据: 无 ) 
│           ├── Flask基础 --> ( 难度等级: [0.7467, 0.7478) || 挂载数据: 无 ) 
│           │   ├── 开启调试模式 --> ( 难度等级: [0.7467, 0.7469) || 挂载数据: 无 ) 
│           │   ├── 路由 --> ( 难度等级: [0.7469, 0.7472) || 挂载数据: 无 ) 
│           │   ├── 静态文件 --> ( 难度等级: [0.7472, 0.7475) || 挂载数据: 无 ) 
│           │   └── 蓝图 --> ( 难度等级: [0.7475, 0.7478) || 挂载数据: 无 ) 
│           ├── 模板 --> ( 难度等级: [0.7478, 0.7489) || 挂载数据: 无 ) 
│           │   ├── 渲染模板 --> ( 难度等级: [0.7478, 0.7481) || 挂载数据: 无 ) 
│           │   ├── 变量 --> ( 难度等级: [0.7481, 0.7485) || 挂载数据: 无 ) 
│           │   └── 控制结构 --> ( 难度等级: [0.7485, 0.7489) || 挂载数据: 无 ) 
│           └── Web表单 --> ( 难度等级: [0.7489, 0.75) || 挂载数据: 无 ) 
│               ├── CSRF保护和验证 --> ( 难度等级: [0.7489, 0.7493) || 挂载数据: 无 ) 
│               ├── 表单类 --> ( 难度等级: [0.7493, 0.7496) || 挂载数据: 无 ) 
│               └── 把表单渲染成HTML --> ( 难度等级: [0.7496, 0.75) || 挂载数据: 无 ) 
└── 其他 --> ( 难度等级: [0.75, 1.0) || 挂载数据: 无 ) 
    ├── 其他类别标签问题 --> ( 难度等级: [0.75, 0.8333) || 挂载数据: qa: 10 ) 
    ├── 应用类问题 --> ( 难度等级: [0.8333, 0.9167) || 挂载数据: qa: 10 ) 
    └── 第三方包问题 --> ( 难度等级: [0.9167, 1.0) || 挂载数据: qa: 10 )