python_tree.txt

python --> ( 难度等级: [0, 1) || 挂载数据: 无 ) 
├── Python初阶 --> ( 难度等级: [0.0, 0.3333) || 挂载数据: 无 ) 
│   ├── 预备知识 --> ( 难度等级: [0.0, 0.0667) || 挂载数据: 无 ) 
│   │   ├── Python简介 --> ( 难度等级: [0.0, 0.0095) || 挂载数据: 无 ) 
│   │   │   └── Python都能做什么 --> ( 难度等级: [0.0, 0.0095) || 挂载数据: 无 ) 
│   │   ├── 程序设计思想 --> ( 难度等级: [0.0095, 0.019) || 挂载数据: 无 ) 
│   │   ├── 安装Python --> ( 难度等级: [0.019, 0.0286) || 挂载数据: 无 ) 
│   │   │   ├── Windows安装Python --> ( 难度等级: [0.019, 0.0222) || 挂载数据: 无 ) 
│   │   │   ├── Linux安装Python --> ( 难度等级: [0.0222, 0.0254) || 挂载数据: 无 ) 
│   │   │   └── MacOS安装Python --> ( 难度等级: [0.0254, 0.0286) || 挂载数据: 无 ) 
│   │   ├── 运行方式 --> ( 难度等级: [0.0286, 0.0381) || 挂载数据: 无 ) 
│   │   │   ├── 以交互方式运行 --> ( 难度等级: [0.0286, 0.0333) || 挂载数据: qa: 32; blog: 1 ) 
│   │   │   └── 以脚本方式运行 --> ( 难度等级: [0.0333, 0.0381) || 挂载数据: qa: 5; blog: 1 ) 
│   │   ├── 常用开发工具 --> ( 难度等级: [0.0381, 0.0476) || 挂载数据: 无 ) 
│   │   │   ├── typing --- 类型提示支持 --> ( 难度等级: [0.0381, 0.0387) || 挂载数据: 无 ) 
│   │   │   ├── pydoc --- 文档生成器和在线帮助系统 --> ( 难度等级: [0.0387, 0.0393) || 挂载数据: 无 ) 
│   │   │   ├── Python Development Mode --> ( 难度等级: [0.0393, 0.0399) || 挂载数据: 无 ) 
│   │   │   ├── Effects of the Python Development Mode --> ( 难度等级: [0.0399, 0.0405) || 挂载数据: qa: 1 ) 
│   │   │   ├── ResourceWarning Example --> ( 难度等级: [0.0405, 0.0411) || 挂载数据: blog: 1 ) 
│   │   │   ├── Bad file descriptor error example --> ( 难度等级: [0.0411, 0.0417) || 挂载数据: qa: 10; blog: 69 ) 
│   │   │   ├── doctest --- 测试交互性的Python示例 --> ( 难度等级: [0.0417, 0.0423) || 挂载数据: 无 ) 
│   │   │   ├── unittest --- 单元测试框架 --> ( 难度等级: [0.0423, 0.0429) || 挂载数据: blog: 18 ) 
│   │   │   ├── unittest.mock --- mock对象库 --> ( 难度等级: [0.0429, 0.0435) || 挂载数据: blog: 6 ) 
│   │   │   ├── unittest.mock上手指南 --> ( 难度等级: [0.0435, 0.044) || 挂载数据: 无 ) 
│   │   │   ├── 2to3 - 自动将Python 2 代码转为Python 3 代码 --> ( 难度等级: [0.044, 0.0446) || 挂载数据: 无 ) 
│   │   │   ├── test ---  Python回归测试包 --> ( 难度等级: [0.0446, 0.0452) || 挂载数据: 无 ) 
│   │   │   ├── test.support --- Utilities for the Python test suite --> ( 难度等级: [0.0452, 0.0458) || 挂载数据: blog: 2 ) 
│   │   │   ├── test.support.socket_helper --- Utilities for socket tests --> ( 难度等级: [0.0458, 0.0464) || 挂载数据: 无 ) 
│   │   │   ├── test.support.script_helper --- Utilities for the Python execution tests --> ( 难度等级: [0.0464, 0.047) || 挂载数据: 无 ) 
│   │   │   └── test.support.bytecode_helper --- Support tools for testing correct bytecode generation --> ( 难度等级: [0.047, 0.0476) || 挂载数据: 无 ) 
│   │   ├── 编码规范 --> ( 难度等级: [0.0476, 0.0571) || 挂载数据: 无 ) 
│   │   └── 模块管理 --> ( 难度等级: [0.0571, 0.0667) || 挂载数据: 无 ) 
│   │       └── pip --> ( 难度等级: [0.0571, 0.0667) || 挂载数据: qa: 12; blog: 62 ) 
│   ├── 基础语法 --> ( 难度等级: [0.0667, 0.1333) || 挂载数据: 无 ) 
│   │   ├── 缩进规则 --> ( 难度等级: [0.0667, 0.0733) || 挂载数据: 无 ) 
│   │   │   └── 建议使用4个空格 --> ( 难度等级: [0.0667, 0.0733) || 挂载数据: qa: 1 ) 
│   │   ├── 基础知识 --> ( 难度等级: [0.0733, 0.08) || 挂载数据: 无 ) 
│   │   │   ├── 注释 --> ( 难度等级: [0.0733, 0.0738) || 挂载数据: 无 ) 
│   │   │   │   └── 如何编写注释 --> ( 难度等级: [0.0733, 0.0738) || 挂载数据: qa: 9 ) 
│   │   │   ├── 变量 --> ( 难度等级: [0.0738, 0.0743) || 挂载数据: qa: 2 ) 
│   │   │   │   ├── 变量的命名和使用 --> ( 难度等级: [0.0738, 0.074) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用变量时避免命名错误 --> ( 难度等级: [0.074, 0.0741) || 挂载数据: 无 ) 
│   │   │   │   └── 变量是标签 --> ( 难度等级: [0.0741, 0.0743) || 挂载数据: qa: 10 ) 
│   │   │   ├── 语句 --> ( 难度等级: [0.0743, 0.0748) || 挂载数据: qa: 2 ) 
│   │   │   │   ├── 表达式语句 --> ( 难度等级: [0.0743, 0.0743) || 挂载数据: 无 ) 
│   │   │   │   ├── 赋值语句 --> ( 难度等级: [0.0743, 0.0744) || 挂载数据: 无 ) 
│   │   │   │   ├── assert语句 --> ( 难度等级: [0.0744, 0.0744) || 挂载数据: qa: 6 ) 
│   │   │   │   ├── return语句 --> ( 难度等级: [0.0744, 0.0745) || 挂载数据: qa: 3 ) 
│   │   │   │   ├── yield语句 --> ( 难度等级: [0.0745, 0.0745) || 挂载数据: 无 ) 
│   │   │   │   ├── raise语句 --> ( 难度等级: [0.0745, 0.0745) || 挂载数据: 无 ) 
│   │   │   │   ├── break语句 --> ( 难度等级: [0.0745, 0.0746) || 挂载数据: 无 ) 
│   │   │   │   ├── continue语句 --> ( 难度等级: [0.0746, 0.0746) || 挂载数据: 无 ) 
│   │   │   │   ├── import语句 --> ( 难度等级: [0.0746, 0.0747) || 挂载数据: qa: 8; blog: 19 ) 
│   │   │   │   ├── global语句 --> ( 难度等级: [0.0747, 0.0747) || 挂载数据: qa: 5 ) 
│   │   │   │   └── nonlocal语句 --> ( 难度等级: [0.0747, 0.0748) || 挂载数据: 无 ) 
│   │   │   ├── 标识符 --> ( 难度等级: [0.0748, 0.0752) || 挂载数据: 无 ) 
│   │   │   ├── 命名规则 --> ( 难度等级: [0.0752, 0.0757) || 挂载数据: 无 ) 
│   │   │   ├── 运算与表达式 --> ( 难度等级: [0.0757, 0.0762) || 挂载数据: 无 ) 
│   │   │   ├── 代码风格 --> ( 难度等级: [0.0762, 0.0767) || 挂载数据: 无 ) 
│   │   │   ├── 交互式解释器 --> ( 难度等级: [0.0767, 0.0771) || 挂载数据: 无 ) 
│   │   │   ├── 算法是什么 --> ( 难度等级: [0.0771, 0.0776) || 挂载数据: qa: 4 ) 
│   │   │   ├── 获取用户输入 --> ( 难度等级: [0.0776, 0.0781) || 挂载数据: 无 ) 
│   │   │   ├── 保存并执行程序 --> ( 难度等级: [0.0781, 0.0786) || 挂载数据: 无 ) 
│   │   │   │   ├── 从命令提示符运行Python脚本 --> ( 难度等级: [0.0781, 0.0783) || 挂载数据: 无 ) 
│   │   │   │   └── 让脚本像普通程序一样 --> ( 难度等级: [0.0783, 0.0786) || 挂载数据: 无 ) 
│   │   │   ├── 起步 --> ( 难度等级: [0.0786, 0.079) || 挂载数据: 无 ) 
│   │   │   │   ├── 搭建编程环境 --> ( 难度等级: [0.0786, 0.0787) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Python版本 --> ( 难度等级: [0.0786, 0.0786) || 挂载数据: qa: 4 ) 
│   │   │   │   │   ├── 运行Python代码片段 --> ( 难度等级: [0.0786, 0.0787) || 挂载数据: 无 ) 
│   │   │   │   │   └── SublimeText简介 --> ( 难度等级: [0.0787, 0.0787) || 挂载数据: 无 ) 
│   │   │   │   ├── 在不同操作系统中搭建Python编程环境 --> ( 难度等级: [0.0787, 0.0788) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 在Windows系统中搭建Python编程环境 --> ( 难度等级: [0.0787, 0.0787) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 在macOS系统中搭建Python编程环境 --> ( 难度等级: [0.0787, 0.0788) || 挂载数据: 无 ) 
│   │   │   │   │   └── 在Linux系统中搭建Python编程环境 --> ( 难度等级: [0.0788, 0.0788) || 挂载数据: qa: 1; blog: 4 ) 
│   │   │   │   ├── 运行HelloWorld程序 --> ( 难度等级: [0.0788, 0.0789) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 配置SublimeText以使用正确的Python版本 --> ( 难度等级: [0.0788, 0.0789) || 挂载数据: qa: 1 ) 
│   │   │   │   │   └── 运行程序hello_world.py --> ( 难度等级: [0.0789, 0.0789) || 挂载数据: qa: 50; blog: 11 ) 
│   │   │   │   └── 从终端运行Python程序 --> ( 难度等级: [0.0789, 0.079) || 挂载数据: 无 ) 
│   │   │   │       └── 在Windows系统中从终端运行Python程序 --> ( 难度等级: [0.0789, 0.079) || 挂载数据: qa: 1; blog: 1 ) 
│   │   │   ├── 列表简介 --> ( 难度等级: [0.079, 0.0795) || 挂载数据: 无 ) 
│   │   │   │   ├── 修改、添加和删除元素 --> ( 难度等级: [0.079, 0.0792) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 修改列表元素 --> ( 难度等级: [0.079, 0.0791) || 挂载数据: qa: 7; blog: 1 ) 
│   │   │   │   │   ├── 在列表中添加元素 --> ( 难度等级: [0.0791, 0.0792) || 挂载数据: qa: 3; blog: 1 ) 
│   │   │   │   │   └── 从列表中删除元素 --> ( 难度等级: [0.0792, 0.0792) || 挂载数据: qa: 30 ) 
│   │   │   │   ├── 组织列表 --> ( 难度等级: [0.0792, 0.0794) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 使用方法sort对列表永久排序 --> ( 难度等级: [0.0792, 0.0792) || 挂载数据: qa: 6 ) 
│   │   │   │   │   ├── 使用函数sorted对列表临时排序 --> ( 难度等级: [0.0792, 0.0793) || 挂载数据: qa: 1 ) 
│   │   │   │   │   ├── 倒着打印列表 --> ( 难度等级: [0.0793, 0.0793) || 挂载数据: qa: 1 ) 
│   │   │   │   │   └── 确定列表的长度 --> ( 难度等级: [0.0793, 0.0794) || 挂载数据: 无 ) 
│   │   │   │   └── 使用列表时避免索引错误 --> ( 难度等级: [0.0794, 0.0795) || 挂载数据: 无 ) 
│   │   │   └── 测试代码 --> ( 难度等级: [0.0795, 0.08) || 挂载数据: 无 ) 
│   │   │       └── 测试函数 --> ( 难度等级: [0.0795, 0.08) || 挂载数据: 无 ) 
│   │   ├── 函数 --> ( 难度等级: [0.08, 0.0867) || 挂载数据: 无 ) 
│   │   │   ├── 函数定义def --> ( 难度等级: [0.08, 0.0802) || 挂载数据: qa: 4 ) 
│   │   │   ├── 参数var --> ( 难度等级: [0.0802, 0.0804) || 挂载数据: 无 ) 
│   │   │   ├── 返回值return --> ( 难度等级: [0.0804, 0.0805) || 挂载数据: 无 ) 
│   │   │   ├── 参数传递 --> ( 难度等级: [0.0805, 0.0807) || 挂载数据: 无 ) 
│   │   │   ├── 函数调用 --> ( 难度等级: [0.0807, 0.0809) || 挂载数据: qa: 1 ) 
│   │   │   ├── 函数递归 --> ( 难度等级: [0.0809, 0.0811) || 挂载数据: 无 ) 
│   │   │   ├── 函数编写风格 --> ( 难度等级: [0.0811, 0.0812) || 挂载数据: 无 ) 
│   │   │   ├── 调用函数 --> ( 难度等级: [0.0812, 0.0814) || 挂载数据: 无 ) 
│   │   │   ├── 函数的参数 --> ( 难度等级: [0.0814, 0.0816) || 挂载数据: 无 ) 
│   │   │   ├── 递归函数 --> ( 难度等级: [0.0816, 0.0818) || 挂载数据: qa: 1 ) 
│   │   │   ├── None值 --> ( 难度等级: [0.0818, 0.0819) || 挂载数据: qa: 3 ) 
│   │   │   ├── 调用栈 --> ( 难度等级: [0.0819, 0.0821) || 挂载数据: 无 ) 
│   │   │   ├── 局部和全局作用域 --> ( 难度等级: [0.0821, 0.0823) || 挂载数据: 无 ) 
│   │   │   │   ├── 局部变量不能在全局作用域内使用 --> ( 难度等级: [0.0821, 0.0822) || 挂载数据: 无 ) 
│   │   │   │   ├── 局部作用域不能使用其他局部作用域内的变量 --> ( 难度等级: [0.0822, 0.0822) || 挂载数据: 无 ) 
│   │   │   │   └── 全局变量可以在局部作用域中读取 --> ( 难度等级: [0.0822, 0.0823) || 挂载数据: 无 ) 
│   │   │   ├── 异常处理 --> ( 难度等级: [0.0823, 0.0825) || 挂载数据: 无 ) 
│   │   │   ├── 把函数视作对象 --> ( 难度等级: [0.0825, 0.0826) || 挂载数据: 无 ) 
│   │   │   ├── 可调用对象 --> ( 难度等级: [0.0826, 0.0828) || 挂载数据: 无 ) 
│   │   │   ├── 用户定义的可调用类型 --> ( 难度等级: [0.0828, 0.083) || 挂载数据: 无 ) 
│   │   │   ├── 函数内省 --> ( 难度等级: [0.083, 0.0832) || 挂载数据: 无 ) 
│   │   │   ├── 从定位参数到仅限关键字参数 --> ( 难度等级: [0.0832, 0.0833) || 挂载数据: 无 ) 
│   │   │   ├── 获取关于参数的信息 --> ( 难度等级: [0.0833, 0.0835) || 挂载数据: 无 ) 
│   │   │   ├── 支持函数式编程的包 --> ( 难度等级: [0.0835, 0.0837) || 挂载数据: blog: 1 ) 
│   │   │   ├── 传递实参 --> ( 难度等级: [0.0837, 0.0839) || 挂载数据: 无 ) 
│   │   │   │   ├── 位置实参 --> ( 难度等级: [0.0837, 0.0837) || 挂载数据: qa: 2 ) 
│   │   │   │   ├── 关键字实参 --> ( 难度等级: [0.0837, 0.0838) || 挂载数据: 无 ) 
│   │   │   │   ├── 默认值 --> ( 难度等级: [0.0838, 0.0838) || 挂载数据: 无 ) 
│   │   │   │   ├── 等效的函数调用 --> ( 难度等级: [0.0838, 0.0838) || 挂载数据: 无 ) 
│   │   │   │   └── 避免实参错误 --> ( 难度等级: [0.0838, 0.0839) || 挂载数据: 无 ) 
│   │   │   ├── 返回值 --> ( 难度等级: [0.0839, 0.084) || 挂载数据: 无 ) 
│   │   │   │   ├── 返回简单值 --> ( 难度等级: [0.0839, 0.0839) || 挂载数据: 无 ) 
│   │   │   │   ├── 让实参变成可选的 --> ( 难度等级: [0.0839, 0.084) || 挂载数据: 无 ) 
│   │   │   │   └── 返回字典 --> ( 难度等级: [0.084, 0.084) || 挂载数据: qa: 4 ) 
│   │   │   ├── 传递列表 --> ( 难度等级: [0.084, 0.0842) || 挂载数据: 无 ) 
│   │   │   │   ├── 在函数中修改列表 --> ( 难度等级: [0.084, 0.0841) || 挂载数据: qa: 3; blog: 1 ) 
│   │   │   │   └── 禁止函数修改列表 --> ( 难度等级: [0.0841, 0.0842) || 挂载数据: 无 ) 
│   │   │   ├── 传递任意数量的实参 --> ( 难度等级: [0.0842, 0.0844) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用任意数量的关键字实参 --> ( 难度等级: [0.0842, 0.0842) || 挂载数据: qa: 2 ) 
│   │   │   │   ├── 导入特定的函数 --> ( 难度等级: [0.0842, 0.0843) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用as给函数指定别名 --> ( 难度等级: [0.0843, 0.0843) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 使用as给模块指定别名 --> ( 难度等级: [0.0843, 0.0844) || 挂载数据: 无 ) 
│   │   │   │   └── 导入模块中的所有函数 --> ( 难度等级: [0.0844, 0.0844) || 挂载数据: 无 ) 
│   │   │   ├── 函数编写指南 --> ( 难度等级: [0.0844, 0.0846) || 挂载数据: qa: 1 ) 
│   │   │   ├── 编写可接受任意数量参数的函数 --> ( 难度等级: [0.0846, 0.0847) || 挂载数据: 无 ) 
│   │   │   ├── 编写只接受关键字参数的函数 --> ( 难度等级: [0.0847, 0.0849) || 挂载数据: 无 ) 
│   │   │   ├── 将元数据信息附加到函数参数上 --> ( 难度等级: [0.0849, 0.0851) || 挂载数据: 无 ) 
│   │   │   ├── 从函数中返回多个值 --> ( 难度等级: [0.0851, 0.0853) || 挂载数据: 无 ) 
│   │   │   ├── 定义带有默认参数的函数 --> ( 难度等级: [0.0853, 0.0854) || 挂载数据: 无 ) 
│   │   │   ├── 定义匿名或内联函数 --> ( 难度等级: [0.0854, 0.0856) || 挂载数据: 无 ) 
│   │   │   ├── 在匿名函数中绑定变量的值 --> ( 难度等级: [0.0856, 0.0858) || 挂载数据: qa: 1 ) 
│   │   │   ├── 让带有N个参数的可调用对象以较少的参数形式调用 --> ( 难度等级: [0.0858, 0.086) || 挂载数据: 无 ) 
│   │   │   ├── 用函数替代只有单个方法的类 --> ( 难度等级: [0.086, 0.0861) || 挂载数据: qa: 1 ) 
│   │   │   ├── 在回调函数中携带额外的状态 --> ( 难度等级: [0.0861, 0.0863) || 挂载数据: 无 ) 
│   │   │   ├── 内联回调函数 --> ( 难度等级: [0.0863, 0.0865) || 挂载数据: 无 ) 
│   │   │   └── 访问定义在闭包内的变量 --> ( 难度等级: [0.0865, 0.0867) || 挂载数据: 无 ) 
│   │   ├── 类 --> ( 难度等级: [0.0867, 0.0933) || 挂载数据: qa: 3 ) 
│   │   │   ├── 类定义class --> ( 难度等级: [0.0867, 0.087) || 挂载数据: qa: 5; blog: 7 ) 
│   │   │   ├── 作用域和命名空间 --> ( 难度等级: [0.087, 0.0873) || 挂载数据: 无 ) 
│   │   │   ├── 对象 --> ( 难度等级: [0.0873, 0.0877) || 挂载数据: 无 ) 
│   │   │   ├── 属性和方法 --> ( 难度等级: [0.0877, 0.088) || 挂载数据: 无 ) 
│   │   │   │   ├── 模拟数值类型 --> ( 难度等级: [0.0877, 0.0878) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 字符串表示形式 --> ( 难度等级: [0.0878, 0.0879) || 挂载数据: 无 ) 
│   │   │   │   └── 自定义的布尔值 --> ( 难度等级: [0.0879, 0.088) || 挂载数据: 无 ) 
│   │   │   ├── 类编码风格 --> ( 难度等级: [0.088, 0.0883) || 挂载数据: 无 ) 
│   │   │   ├── 初探类 --> ( 难度等级: [0.0883, 0.0887) || 挂载数据: 无 ) 
│   │   │   │   ├── 类定义语法 --> ( 难度等级: [0.0883, 0.0884) || 挂载数据: qa: 1; blog: 1 ) 
│   │   │   │   ├── 类对象 --> ( 难度等级: [0.0884, 0.0886) || 挂载数据: qa: 1 ) 
│   │   │   │   └── 方法对象 --> ( 难度等级: [0.0886, 0.0887) || 挂载数据: 无 ) 
│   │   │   ├── 补充说明 --> ( 难度等级: [0.0887, 0.089) || 挂载数据: 无 ) 
│   │   │   ├── 私有变量 --> ( 难度等级: [0.089, 0.0893) || 挂载数据: 无 ) 
│   │   │   ├── 生成器表达式 --> ( 难度等级: [0.0893, 0.0897) || 挂载数据: 无 ) 
│   │   │   ├── 类到底是什么 --> ( 难度等级: [0.0897, 0.09) || 挂载数据: qa: 1 ) 
│   │   │   ├── 创建自定义类 --> ( 难度等级: [0.09, 0.0903) || 挂载数据: qa: 1 ) 
│   │   │   ├── 再谈隐藏 --> ( 难度等级: [0.0903, 0.0907) || 挂载数据: 无 ) 
│   │   │   ├── 类的命名空间 --> ( 难度等级: [0.0907, 0.091) || 挂载数据: 无 ) 
│   │   │   ├── 指定超类 --> ( 难度等级: [0.091, 0.0913) || 挂载数据: 无 ) 
│   │   │   ├── 深入探讨继承 --> ( 难度等级: [0.0913, 0.0917) || 挂载数据: 无 ) 
│   │   │   ├── 多个超类 --> ( 难度等级: [0.0917, 0.092) || 挂载数据: 无 ) 
│   │   │   ├── 接口和内省 --> ( 难度等级: [0.092, 0.0923) || 挂载数据: 无 ) 
│   │   │   │   ├── Python文化中的接口和协议 --> ( 难度等级: [0.092, 0.092) || 挂载数据: 无 ) 
│   │   │   │   ├── Python喜欢序列 --> ( 难度等级: [0.092, 0.0921) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用猴子补丁在运行时实现协议 --> ( 难度等级: [0.0921, 0.0921) || 挂载数据: 无 ) 
│   │   │   │   ├── Alex Martelli的水禽 --> ( 难度等级: [0.0921, 0.0921) || 挂载数据: 无 ) 
│   │   │   │   ├── 定义抽象基类的子类 --> ( 难度等级: [0.0921, 0.0922) || 挂载数据: 无 ) 
│   │   │   │   ├── 标准库中的抽象基类 --> ( 难度等级: [0.0922, 0.0922) || 挂载数据: 无 ) 
│   │   │   │   ├── 定义并使用一个抽象基类 --> ( 难度等级: [0.0922, 0.0922) || 挂载数据: 无 ) 
│   │   │   │   ├── Tombola子类的测试方法 --> ( 难度等级: [0.0922, 0.0923) || 挂载数据: 无 ) 
│   │   │   │   ├── Python使用register的方式 --> ( 难度等级: [0.0923, 0.0923) || 挂载数据: 无 ) 
│   │   │   │   └── 鹅的行为有可能像鸭子 --> ( 难度等级: [0.0923, 0.0923) || 挂载数据: 无 ) 
│   │   │   ├── 抽象基类 --> ( 难度等级: [0.0923, 0.0927) || 挂载数据: 无 ) 
│   │   │   ├── 导入类 --> ( 难度等级: [0.0927, 0.093) || 挂载数据: 无 ) 
│   │   │   │   ├── 导入单个类 --> ( 难度等级: [0.0927, 0.0927) || 挂载数据: 无 ) 
│   │   │   │   ├── 在一个模块中存储多个类 --> ( 难度等级: [0.0927, 0.0928) || 挂载数据: 无 ) 
│   │   │   │   ├── 从一个模块中导入多个类 --> ( 难度等级: [0.0928, 0.0929) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 导入模块中的所有类 --> ( 难度等级: [0.0929, 0.0929) || 挂载数据: 无 ) 
│   │   │   │   └── 自定义工作流程 --> ( 难度等级: [0.0929, 0.093) || 挂载数据: 无 ) 
│   │   │   └── Python标准库 --> ( 难度等级: [0.093, 0.0933) || 挂载数据: 无 ) 
│   │   ├── 顺序语句结构 --> ( 难度等级: [0.0933, 0.1) || 挂载数据: 无 ) 
│   │   ├── 条件和分支 --> ( 难度等级: [0.1, 0.1067) || 挂载数据: 无 ) 
│   │   │   ├── if --> ( 难度等级: [0.1, 0.1005) || 挂载数据: 无 ) 
│   │   │   │   ├── if-else语句 --> ( 难度等级: [0.1, 0.1001) || 挂载数据: qa: 23; blog: 23 ) 
│   │   │   │   ├── if-elif-else结构 --> ( 难度等级: [0.1001, 0.1002) || 挂载数据: qa: 1; blog: 1 ) 
│   │   │   │   ├── 省略else代码块 --> ( 难度等级: [0.1002, 0.1003) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用if语句处理列表 --> ( 难度等级: [0.1003, 0.1004) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 检查特殊元素 --> ( 难度等级: [0.1003, 0.1004) || 挂载数据: 无 ) 
│   │   │   │   │   └── 确定列表不是空的 --> ( 难度等级: [0.1004, 0.1004) || 挂载数据: qa: 6 ) 
│   │   │   │   └── 设置if语句的格式 --> ( 难度等级: [0.1004, 0.1005) || 挂载数据: 无 ) 
│   │   │   ├── elif --> ( 难度等级: [0.1005, 0.101) || 挂载数据: 无 ) 
│   │   │   ├── else --> ( 难度等级: [0.101, 0.1015) || 挂载数据: 无 ) 
│   │   │   ├── 条件判断 --> ( 难度等级: [0.1015, 0.1021) || 挂载数据: qa: 3 ) 
│   │   │   ├── 这正是布尔值的用武之地 --> ( 难度等级: [0.1021, 0.1026) || 挂载数据: 无 ) 
│   │   │   ├── 代码块嵌套 --> ( 难度等级: [0.1026, 0.1031) || 挂载数据: 无 ) 
│   │   │   │   ├── 字典列表 --> ( 难度等级: [0.1026, 0.1027) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 在字典中存储列表 --> ( 难度等级: [0.1027, 0.1029) || 挂载数据: 无 ) 
│   │   │   │   └── 在字典中存储字典 --> ( 难度等级: [0.1029, 0.1031) || 挂载数据: 无 ) 
│   │   │   ├── 检查是否相等 --> ( 难度等级: [0.1031, 0.1036) || 挂载数据: qa: 1 ) 
│   │   │   ├── 检查是否相等时忽略大小写 --> ( 难度等级: [0.1036, 0.1041) || 挂载数据: 无 ) 
│   │   │   ├── 检查是否不相等 --> ( 难度等级: [0.1041, 0.1046) || 挂载数据: 无 ) 
│   │   │   ├── 数值比较 --> ( 难度等级: [0.1046, 0.1051) || 挂载数据: 无 ) 
│   │   │   ├── 检查多个条件 --> ( 难度等级: [0.1051, 0.1056) || 挂载数据: 无 ) 
│   │   │   ├── 检查特定值是否包含在列表中 --> ( 难度等级: [0.1056, 0.1062) || 挂载数据: 无 ) 
│   │   │   └── 布尔表达式 --> ( 难度等级: [0.1062, 0.1067) || 挂载数据: 无 ) 
│   │   ├── 循环 --> ( 难度等级: [0.1067, 0.1133) || 挂载数据: 无 ) 
│   │   │   ├── for --> ( 难度等级: [0.1067, 0.1074) || 挂载数据: qa: 7; blog: 8 ) 
│   │   │   ├── while --> ( 难度等级: [0.1074, 0.1081) || 挂载数据: qa: 3 ) 
│   │   │   ├── break --> ( 难度等级: [0.1081, 0.1089) || 挂载数据: qa: 2 ) 
│   │   │   ├── continue --> ( 难度等级: [0.1089, 0.1096) || 挂载数据: qa: 1 ) 
│   │   │   ├── 循环判断 --> ( 难度等级: [0.1096, 0.1104) || 挂载数据: 无 ) 
│   │   │   ├── 迭代字典 --> ( 难度等级: [0.1104, 0.1111) || 挂载数据: 无 ) 
│   │   │   ├── 一些迭代工具 --> ( 难度等级: [0.1111, 0.1119) || 挂载数据: 无 ) 
│   │   │   ├── 跳出循环 --> ( 难度等级: [0.1119, 0.1126) || 挂载数据: 无 ) 
│   │   │   └── 循环中的else子句 --> ( 难度等级: [0.1126, 0.1133) || 挂载数据: qa: 3 ) 
│   │   ├── 数据类型 --> ( 难度等级: [0.1133, 0.12) || 挂载数据: 无 ) 
│   │   │   ├── 整型 --> ( 难度等级: [0.1133, 0.1137) || 挂载数据: 无 ) 
│   │   │   ├── 浮点型 --> ( 难度等级: [0.1137, 0.114) || 挂载数据: 无 ) 
│   │   │   ├── 布尔型 --> ( 难度等级: [0.114, 0.1144) || 挂载数据: 无 ) 
│   │   │   ├── 字符串 --> ( 难度等级: [0.1144, 0.1147) || 挂载数据: qa: 2 ) 
│   │   │   │   ├── 单引号字符串以及对引号转义 --> ( 难度等级: [0.1144, 0.1144) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 拼接字符串 --> ( 难度等级: [0.1144, 0.1144) || 挂载数据: 无 ) 
│   │   │   │   ├── 字符串表示str和repr --> ( 难度等级: [0.1144, 0.1145) || 挂载数据: qa: 3; blog: 1 ) 
│   │   │   │   ├── 长字符串、原始字符串和字节 --> ( 难度等级: [0.1145, 0.1145) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 字符串基本操作 --> ( 难度等级: [0.1145, 0.1145) || 挂载数据: 无 ) 
│   │   │   │   ├── 设置字符串的格式：精简版 --> ( 难度等级: [0.1145, 0.1146) || 挂载数据: qa: 2 ) 
│   │   │   │   │   └── 替换字段名 --> ( 难度等级: [0.1145, 0.1146) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用方法修改字符串的大小写 --> ( 难度等级: [0.1146, 0.1146) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用制表符或换行符来添加空白 --> ( 难度等级: [0.1146, 0.1146) || 挂载数据: 无 ) 
│   │   │   │   ├── 删除空白 --> ( 难度等级: [0.1146, 0.1147) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用字符串时避免语法错误 --> ( 难度等级: [0.1147, 0.1147) || 挂载数据: qa: 3 ) 
│   │   │   │   └── 字符串编码转换 --> ( 难度等级: [0.1147, 0.1147) || 挂载数据: qa: 2 ) 
│   │   │   │       ├── 使用encode方法编码 --> ( 难度等级: [0.1147, 0.1147) || 挂载数据: qa: 2 ) 
│   │   │   │       └── 使用decode方法解码 --> ( 难度等级: [0.1147, 0.1147) || 挂载数据: 无 ) 
│   │   │   ├── datetime --- 基本的日期和时间类型 --> ( 难度等级: [0.1147, 0.1151) || 挂载数据: 无 ) 
│   │   │   ├── zoneinfo --- IANA时区支持 --> ( 难度等级: [0.1151, 0.1154) || 挂载数据: 无 ) 
│   │   │   ├── calendar --- 日历相关函数 --> ( 难度等级: [0.1154, 0.1158) || 挂载数据: 无 ) 
│   │   │   ├── collections --- 容器数据类型 --> ( 难度等级: [0.1158, 0.1161) || 挂载数据: qa: 1 ) 
│   │   │   ├── collections.abc --- 容器的抽象基类 --> ( 难度等级: [0.1161, 0.1165) || 挂载数据: 无 ) 
│   │   │   ├── heapq --- 堆队列算法 --> ( 难度等级: [0.1165, 0.1168) || 挂载数据: 无 ) 
│   │   │   ├── bisect --- 数组二分查找算法 --> ( 难度等级: [0.1168, 0.1172) || 挂载数据: 无 ) 
│   │   │   ├── array --- 高效的数值数组 --> ( 难度等级: [0.1172, 0.1175) || 挂载数据: qa: 1 ) 
│   │   │   ├── weakref --- 弱引用 --> ( 难度等级: [0.1175, 0.1179) || 挂载数据: 无 ) 
│   │   │   ├── types --- 动态类型创建和内置类型名称 --> ( 难度等级: [0.1179, 0.1182) || 挂载数据: 无 ) 
│   │   │   ├── copy --- 浅层 (shallow) 和深层 (deep) 复制操作 --> ( 难度等级: [0.1182, 0.1186) || 挂载数据: qa: 1 ) 
│   │   │   ├── pprint --- 数据美化输出 --> ( 难度等级: [0.1186, 0.1189) || 挂载数据: 无 ) 
│   │   │   ├── reprlib --- 另一种repr 实现 --> ( 难度等级: [0.1189, 0.1193) || 挂载数据: 无 ) 
│   │   │   ├── enum --- 对枚举的支持 --> ( 难度等级: [0.1193, 0.1196) || 挂载数据: 无 ) 
│   │   │   └── graphlib --- Functionality to operate with graph-like structures --> ( 难度等级: [0.1196, 0.12) || 挂载数据: 无 ) 
│   │   ├── 内置类 --> ( 难度等级: [0.12, 0.1267) || 挂载数据: 无 ) 
│   │   │   ├── 列表：list --> ( 难度等级: [0.12, 0.1211) || 挂载数据: 无 ) 
│   │   │   │   ├── 函数list --> ( 难度等级: [0.12, 0.1201) || 挂载数据: qa: 43; blog: 183 ) 
│   │   │   │   ├── 基本的列表操作 --> ( 难度等级: [0.1201, 0.1201) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 遍历整个列表 --> ( 难度等级: [0.1201, 0.1201) || 挂载数据: qa: 1 ) 
│   │   │   │   │   │   ├── 深入研究循环 --> ( 难度等级: [0.1201, 0.1201) || 挂载数据: qa: 6 ) 
│   │   │   │   │   │   ├── 在for循环中执行更多操作 --> ( 难度等级: [0.1201, 0.1201) || 挂载数据: qa: 11 ) 
│   │   │   │   │   │   └── 在for循环结束后执行一些操作 --> ( 难度等级: [0.1201, 0.1201) || 挂载数据: qa: 1 ) 
│   │   │   │   │   ├── 避免缩进错误 --> ( 难度等级: [0.1201, 0.1201) || 挂载数据: qa: 2 ) 
│   │   │   │   │   │   ├── 忘记缩进 --> ( 难度等级: [0.1201, 0.1201) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── 忘记缩进额外的代码行 --> ( 难度等级: [0.1201, 0.1201) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── 不必要的缩进 --> ( 难度等级: [0.1201, 0.1201) || 挂载数据: qa: 2 ) 
│   │   │   │   │   │   ├── 循环后不必要的缩进 --> ( 难度等级: [0.1201, 0.1201) || 挂载数据: 无 ) 
│   │   │   │   │   │   └── 遗漏了冒号 --> ( 难度等级: [0.1201, 0.1201) || 挂载数据: qa: 1 ) 
│   │   │   │   │   ├── 创建数值列表 --> ( 难度等级: [0.1201, 0.1201) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── 使用range创建数字列表 --> ( 难度等级: [0.1201, 0.1201) || 挂载数据: qa: 6 ) 
│   │   │   │   │   │   ├── 对数字列表执行简单的统计计算 --> ( 难度等级: [0.1201, 0.1201) || 挂载数据: qa: 3 ) 
│   │   │   │   │   │   └── 列表解析 --> ( 难度等级: [0.1201, 0.1201) || 挂载数据: qa: 58; blog: 2 ) 
│   │   │   │   │   └── 设置代码格式 --> ( 难度等级: [0.1201, 0.1201) || 挂载数据: 无 ) 
│   │   │   │   │       ├── 格式设置指南 --> ( 难度等级: [0.1201, 0.1201) || 挂载数据: 无 ) 
│   │   │   │   │       ├── 行长 --> ( 难度等级: [0.1201, 0.1201) || 挂载数据: 无 ) 
│   │   │   │   │       ├── 空行 --> ( 难度等级: [0.1201, 0.1201) || 挂载数据: 无 ) 
│   │   │   │   │       └── 其他格式设置指南 --> ( 难度等级: [0.1201, 0.1201) || 挂载数据: qa: 15; blog: 1 ) 
│   │   │   │   ├── 列表方法 --> ( 难度等级: [0.1201, 0.1202) || 挂载数据: 无 ) 
│   │   │   │   ├── 列表数据类型 --> ( 难度等级: [0.1202, 0.1203) || 挂载数据: 无 ) 
│   │   │   │   ├── 增强的赋值操作 --> ( 难度等级: [0.1203, 0.1204) || 挂载数据: 无 ) 
│   │   │   │   ├── 序列数据类型 --> ( 难度等级: [0.1204, 0.1204) || 挂载数据: 无 ) 
│   │   │   │   ├── 引用 --> ( 难度等级: [0.1204, 0.1205) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 访问列表元素 --> ( 难度等级: [0.1205, 0.1206) || 挂载数据: 无 ) 
│   │   │   │   ├── 索引从0而不是1开始 --> ( 难度等级: [0.1206, 0.1207) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用列表中的各个值 --> ( 难度等级: [0.1207, 0.1207) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 遍历切片 --> ( 难度等级: [0.1207, 0.1208) || 挂载数据: 无 ) 
│   │   │   │   ├── 复制列表 --> ( 难度等级: [0.1208, 0.1209) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 列表的创建和删除 --> ( 难度等级: [0.1209, 0.121) || 挂载数据: 无 ) 
│   │   │   │   ├── 对列表进行统计计算 --> ( 难度等级: [0.121, 0.121) || 挂载数据: 无 ) 
│   │   │   │   └── 对列表进行排序 --> ( 难度等级: [0.121, 0.1211) || 挂载数据: 无 ) 
│   │   │   ├── 字典：dict --> ( 难度等级: [0.1211, 0.1222) || 挂载数据: qa: 3 ) 
│   │   │   │   ├── 访问字典中的值 --> ( 难度等级: [0.1211, 0.1212) || 挂载数据: 无 ) 
│   │   │   │   ├── 添加键值对 --> ( 难度等级: [0.1212, 0.1213) || 挂载数据: 无 ) 
│   │   │   │   ├── 先创建一个空字典 --> ( 难度等级: [0.1213, 0.1214) || 挂载数据: 无 ) 
│   │   │   │   ├── 修改字典中的值 --> ( 难度等级: [0.1214, 0.1216) || 挂载数据: qa: 2 ) 
│   │   │   │   ├── 删除键值对 --> ( 难度等级: [0.1216, 0.1217) || 挂载数据: 无 ) 
│   │   │   │   ├── 由类似对象组成的字典 --> ( 难度等级: [0.1217, 0.1218) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用get来访问值 --> ( 难度等级: [0.1218, 0.1219) || 挂载数据: qa: 3; blog: 3 ) 
│   │   │   │   ├── 遍历字典 --> ( 难度等级: [0.1219, 0.122) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 遍历所有键值对 --> ( 难度等级: [0.1219, 0.1219) || 挂载数据: qa: 10 ) 
│   │   │   │   │   ├── 遍历字典中的所有键 --> ( 难度等级: [0.1219, 0.1219) || 挂载数据: qa: 2 ) 
│   │   │   │   │   ├── 按特定顺序遍历字典中的所有键 --> ( 难度等级: [0.1219, 0.122) || 挂载数据: 无 ) 
│   │   │   │   │   └── 遍历字典中的所有值 --> ( 难度等级: [0.122, 0.122) || 挂载数据: qa: 28 ) 
│   │   │   │   ├── 访问字典 --> ( 难度等级: [0.122, 0.1221) || 挂载数据: 无 ) 
│   │   │   │   └── 字典推导式 --> ( 难度等级: [0.1221, 0.1222) || 挂载数据: qa: 1 ) 
│   │   │   ├── 元组：tuple --> ( 难度等级: [0.1222, 0.1233) || 挂载数据: 无 ) 
│   │   │   │   ├── 定义元组 --> ( 难度等级: [0.1222, 0.1224) || 挂载数据: 无 ) 
│   │   │   │   ├── 遍历元组中的所有值 --> ( 难度等级: [0.1224, 0.1226) || 挂载数据: 无 ) 
│   │   │   │   ├── 修改元组变量 --> ( 难度等级: [0.1226, 0.1228) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 访问元组元素 --> ( 难度等级: [0.1228, 0.123) || 挂载数据: 无 ) 
│   │   │   │   ├── 修改元组 --> ( 难度等级: [0.123, 0.1231) || 挂载数据: qa: 3 ) 
│   │   │   │   └── 元组推导式 --> ( 难度等级: [0.1231, 0.1233) || 挂载数据: 无 ) 
│   │   │   ├── 集合：set --> ( 难度等级: [0.1233, 0.1244) || 挂载数据: qa: 1; blog: 1 ) 
│   │   │   │   ├── 创建集合 --> ( 难度等级: [0.1233, 0.1239) || 挂载数据: qa: 3; blog: 5 ) 
│   │   │   │   └── 集合的交集、并集和差集运算 --> ( 难度等级: [0.1239, 0.1244) || 挂载数据: 无 ) 
│   │   │   ├── 整型：int --> ( 难度等级: [0.1244, 0.1256) || 挂载数据: qa: 3; blog: 1 ) 
│   │   │   └── 字符串：str --> ( 难度等级: [0.1256, 0.1267) || 挂载数据: qa: 6 ) 
│   │   └── 常用内置函数 --> ( 难度等级: [0.1267, 0.1333) || 挂载数据: 无 ) 
│   │       ├── help --> ( 难度等级: [0.1267, 0.1272) || 挂载数据: 无 ) 
│   │       ├── input --> ( 难度等级: [0.1272, 0.1277) || 挂载数据: qa: 2 ) 
│   │       ├── print --> ( 难度等级: [0.1277, 0.1282) || 挂载数据: qa: 13; blog: 1 ) 
│   │       ├── range --> ( 难度等级: [0.1282, 0.1287) || 挂载数据: qa: 5 ) 
│   │       ├── format --> ( 难度等级: [0.1287, 0.1292) || 挂载数据: qa: 6; blog: 3 ) 
│   │       ├── len --> ( 难度等级: [0.1292, 0.1297) || 挂载数据: qa: 1 ) 
│   │       ├── sorted --> ( 难度等级: [0.1297, 0.1303) || 挂载数据: qa: 5 ) 
│   │       ├── open --> ( 难度等级: [0.1303, 0.1308) || 挂载数据: qa: 1 ) 
│   │       ├── dir --> ( 难度等级: [0.1308, 0.1313) || 挂载数据: 无 ) 
│   │       ├── enumerate/zip --> ( 难度等级: [0.1313, 0.1318) || 挂载数据: qa: 3; blog: 1 ) 
│   │       ├── type/isinstance --> ( 难度等级: [0.1318, 0.1323) || 挂载数据: 无 ) 
│   │       ├── min/max/sum --> ( 难度等级: [0.1323, 0.1328) || 挂载数据: qa: 3 ) 
│   │       └── abs/round/pow/divmod --> ( 难度等级: [0.1328, 0.1333) || 挂载数据: 无 ) 
│   ├── 进阶语法 --> ( 难度等级: [0.1333, 0.2) || 挂载数据: 无 ) 
│   │   ├── 列表推导式 --> ( 难度等级: [0.1333, 0.14) || 挂载数据: 无 ) 
│   │   ├── 三元表达式 --> ( 难度等级: [0.14, 0.1467) || 挂载数据: qa: 1 ) 
│   │   │   ├── 算术转换 --> ( 难度等级: [0.14, 0.1404) || 挂载数据: 无 ) 
│   │   │   ├── 原子 --> ( 难度等级: [0.1404, 0.1409) || 挂载数据: 无 ) 
│   │   │   ├── 原型 --> ( 难度等级: [0.1409, 0.1413) || 挂载数据: 无 ) 
│   │   │   ├── await表达式 --> ( 难度等级: [0.1413, 0.1418) || 挂载数据: qa: 3 ) 
│   │   │   ├── 幂运算符 --> ( 难度等级: [0.1418, 0.1422) || 挂载数据: 无 ) 
│   │   │   ├── 一元算术和位运算 --> ( 难度等级: [0.1422, 0.1427) || 挂载数据: 无 ) 
│   │   │   ├── 二元算术运算符 --> ( 难度等级: [0.1427, 0.1431) || 挂载数据: 无 ) 
│   │   │   ├── 移位运算 --> ( 难度等级: [0.1431, 0.1436) || 挂载数据: qa: 1; blog: 1 ) 
│   │   │   ├── 比较运算 --> ( 难度等级: [0.1436, 0.144) || 挂载数据: 无 ) 
│   │   │   ├── 布尔运算 --> ( 难度等级: [0.144, 0.1444) || 挂载数据: 无 ) 
│   │   │   ├── 赋值表达式 --> ( 难度等级: [0.1444, 0.1449) || 挂载数据: qa: 1 ) 
│   │   │   ├── 条件表达式 --> ( 难度等级: [0.1449, 0.1453) || 挂载数据: 无 ) 
│   │   │   ├── 表达式列表 --> ( 难度等级: [0.1453, 0.1458) || 挂载数据: 无 ) 
│   │   │   ├── 求值顺序 --> ( 难度等级: [0.1458, 0.1462) || 挂载数据: 无 ) 
│   │   │   └── 运算符优先级 --> ( 难度等级: [0.1462, 0.1467) || 挂载数据: 无 ) 
│   │   ├── 断言 --> ( 难度等级: [0.1467, 0.1533) || 挂载数据: 无 ) 
│   │   ├── with-as --> ( 难度等级: [0.1533, 0.16) || 挂载数据: 无 ) 
│   │   ├── 异常捕获预处理 --> ( 难度等级: [0.16, 0.1667) || 挂载数据: 无 ) 
│   │   │   ├── try-catch-finally --> ( 难度等级: [0.16, 0.1633) || 挂载数据: 无 ) 
│   │   │   └── 异常捕获 --> ( 难度等级: [0.1633, 0.1667) || 挂载数据: 无 ) 
│   │   ├── 字符串方法 --> ( 难度等级: [0.1667, 0.1733) || 挂载数据: 无 ) 
│   │   │   ├── find --> ( 难度等级: [0.1667, 0.1673) || 挂载数据: qa: 5; blog: 1 ) 
│   │   │   ├── index --> ( 难度等级: [0.1673, 0.1679) || 挂载数据: qa: 4; blog: 1 ) 
│   │   │   ├── join --> ( 难度等级: [0.1679, 0.1685) || 挂载数据: qa: 2 ) 
│   │   │   ├── lower --> ( 难度等级: [0.1685, 0.1691) || 挂载数据: qa: 2 ) 
│   │   │   ├── replace --> ( 难度等级: [0.1691, 0.1697) || 挂载数据: qa: 2 ) 
│   │   │   ├── split --> ( 难度等级: [0.1697, 0.1703) || 挂载数据: qa: 3 ) 
│   │   │   ├── strip --> ( 难度等级: [0.1703, 0.1709) || 挂载数据: 无 ) 
│   │   │   ├── translate --> ( 难度等级: [0.1709, 0.1715) || 挂载数据: 无 ) 
│   │   │   ├── upper --> ( 难度等级: [0.1715, 0.1721) || 挂载数据: 无 ) 
│   │   │   ├── center --> ( 难度等级: [0.1721, 0.1727) || 挂载数据: 无 ) 
│   │   │   └── 判断字符串是否满足特定的条件 --> ( 难度等级: [0.1727, 0.1733) || 挂载数据: qa: 1 ) 
│   │   ├── lambda函数 --> ( 难度等级: [0.1733, 0.18) || 挂载数据: qa: 1 ) 
│   │   │   ├── 迭代器 --> ( 难度等级: [0.1733, 0.175) || 挂载数据: 无 ) 
│   │   │   │   ├── 迭代器协议 --> ( 难度等级: [0.1733, 0.1742) || 挂载数据: 无 ) 
│   │   │   │   └── 从迭代器创建序列 --> ( 难度等级: [0.1742, 0.175) || 挂载数据: 无 ) 
│   │   │   ├── 生成器 --> ( 难度等级: [0.175, 0.1767) || 挂载数据: 无 ) 
│   │   │   │   ├── 创建生成器 --> ( 难度等级: [0.175, 0.1753) || 挂载数据: qa: 6 ) 
│   │   │   │   ├── 递归式生成器 --> ( 难度等级: [0.1753, 0.1757) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 通用生成器 --> ( 难度等级: [0.1757, 0.176) || 挂载数据: 无 ) 
│   │   │   │   ├── 生成器的方法 --> ( 难度等级: [0.176, 0.1763) || 挂载数据: 无 ) 
│   │   │   │   └── 模拟生成器 --> ( 难度等级: [0.1763, 0.1767) || 挂载数据: 无 ) 
│   │   │   ├── 装饰器 --> ( 难度等级: [0.1767, 0.1783) || 挂载数据: qa: 1 ) 
│   │   │   └── 闭包 --> ( 难度等级: [0.1783, 0.18) || 挂载数据: 无 ) 
│   │   ├── 文件 --> ( 难度等级: [0.18, 0.1867) || 挂载数据: 无 ) 
│   │   │   ├── 打开文件 --> ( 难度等级: [0.18, 0.1817) || 挂载数据: qa: 12 ) 
│   │   │   ├── 文件基本方法 --> ( 难度等级: [0.1817, 0.1833) || 挂载数据: 无 ) 
│   │   │   ├── 文件内容迭代 --> ( 难度等级: [0.1833, 0.185) || 挂载数据: 无 ) 
│   │   │   │   ├── 每次一个字符（或字节） --> ( 难度等级: [0.1833, 0.1837) || 挂载数据: 无 ) 
│   │   │   │   ├── 每次一行 --> ( 难度等级: [0.1837, 0.184) || 挂载数据: 无 ) 
│   │   │   │   ├── 读取所有内容 --> ( 难度等级: [0.184, 0.1843) || 挂载数据: qa: 9 ) 
│   │   │   │   ├── 使用fileinput实现延迟行迭代 --> ( 难度等级: [0.1843, 0.1847) || 挂载数据: 无 ) 
│   │   │   │   └── 文件迭代器 --> ( 难度等级: [0.1847, 0.185) || 挂载数据: 无 ) 
│   │   │   └── 文件的基本方法 --> ( 难度等级: [0.185, 0.1867) || 挂载数据: 无 ) 
│   │   │       ├── 读取和写入 --> ( 难度等级: [0.185, 0.1853) || 挂载数据: 无 ) 
│   │   │       ├── 使用管道重定向输出 --> ( 难度等级: [0.1853, 0.1857) || 挂载数据: 无 ) 
│   │   │       ├── 读取和写入行 --> ( 难度等级: [0.1857, 0.186) || 挂载数据: 无 ) 
│   │   │       ├── 关闭文件 --> ( 难度等级: [0.186, 0.1863) || 挂载数据: qa: 45; blog: 1 ) 
│   │   │       └── 使用文件的基本方法 --> ( 难度等级: [0.1863, 0.1867) || 挂载数据: qa: 1 ) 
│   │   ├── 常用标准库 --> ( 难度等级: [0.1867, 0.1933) || 挂载数据: 无 ) 
│   │   │   ├── datetime --> ( 难度等级: [0.1867, 0.1873) || 挂载数据: qa: 1 ) 
│   │   │   ├── json --> ( 难度等级: [0.1873, 0.1879) || 挂载数据: 无 ) 
│   │   │   ├── math --> ( 难度等级: [0.1879, 0.1885) || 挂载数据: blog: 1 ) 
│   │   │   ├── os --> ( 难度等级: [0.1885, 0.1891) || 挂载数据: qa: 5; blog: 1 ) 
│   │   │   ├── random --> ( 难度等级: [0.1891, 0.1897) || 挂载数据: qa: 7; blog: 2 ) 
│   │   │   ├── re --> ( 难度等级: [0.1897, 0.1903) || 挂载数据: qa: 9 ) 
│   │   │   ├── sys --> ( 难度等级: [0.1903, 0.1909) || 挂载数据: qa: 5; blog: 1 ) 
│   │   │   ├── time --> ( 难度等级: [0.1909, 0.1915) || 挂载数据: blog: 1 ) 
│   │   │   ├── urllib --> ( 难度等级: [0.1915, 0.1921) || 挂载数据: qa: 3 ) 
│   │   │   ├── fileinput --> ( 难度等级: [0.1921, 0.1927) || 挂载数据: 无 ) 
│   │   │   └── 其他有趣的标准模块 --> ( 难度等级: [0.1927, 0.1933) || 挂载数据: 无 ) 
│   │   └── 字符编码与解码 --> ( 难度等级: [0.1933, 0.2) || 挂载数据: 无 ) 
│   │       └── 理解内码和字节码的概念 --> ( 难度等级: [0.1933, 0.2) || 挂载数据: 无 ) 
│   ├── 面向对象编程 --> ( 难度等级: [0.2, 0.2667) || 挂载数据: 无 ) 
│   │   ├── 类和对象的概念 --> ( 难度等级: [0.2, 0.2095) || 挂载数据: 无 ) 
│   │   ├── 类成员 --> ( 难度等级: [0.2095, 0.219) || 挂载数据: 无 ) 
│   │   ├── 面向对象三要素 --> ( 难度等级: [0.219, 0.2286) || 挂载数据: 无 ) 
│   │   │   ├── 封装 --> ( 难度等级: [0.219, 0.2222) || 挂载数据: 无 ) 
│   │   │   ├── 继承 --> ( 难度等级: [0.2222, 0.2254) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 子类的方法__init__ --> ( 难度等级: [0.2222, 0.2233) || 挂载数据: qa: 2 ) 
│   │   │   │   ├── 重写父类的方法 --> ( 难度等级: [0.2233, 0.2243) || 挂载数据: 无 ) 
│   │   │   │   └── 模拟实物 --> ( 难度等级: [0.2243, 0.2254) || 挂载数据: 无 ) 
│   │   │   └── 多态 --> ( 难度等级: [0.2254, 0.2286) || 挂载数据: 无 ) 
│   │   ├── 创建类 --> ( 难度等级: [0.2286, 0.2381) || 挂载数据: 无 ) 
│   │   ├── 抽象类 --> ( 难度等级: [0.2381, 0.2476) || 挂载数据: 无 ) 
│   │   ├── 访问限制 --> ( 难度等级: [0.2476, 0.2571) || 挂载数据: 无 ) 
│   │   └── 获取对象信息 --> ( 难度等级: [0.2571, 0.2667) || 挂载数据: 无 ) 
│   └── 其他 --> ( 难度等级: [0.2667, 0.3333) || 挂载数据: 无 ) 
│       ├── 命令行与环境 --> ( 难度等级: [0.2667, 0.2674) || 挂载数据: 无 ) 
│       │   ├── 命令行 --> ( 难度等级: [0.2667, 0.267) || 挂载数据: 无 ) 
│       │   │   ├── 接口选项 --> ( 难度等级: [0.2667, 0.2668) || 挂载数据: 无 ) 
│       │   │   ├── 通用选项 --> ( 难度等级: [0.2668, 0.2668) || 挂载数据: qa: 1 ) 
│       │   │   ├── 其他选项 --> ( 难度等级: [0.2668, 0.2669) || 挂载数据: qa: 2 ) 
│       │   │   └── 不应当使用的选项 --> ( 难度等级: [0.2669, 0.267) || 挂载数据: 无 ) 
│       │   └── 环境变量 --> ( 难度等级: [0.267, 0.2674) || 挂载数据: 无 ) 
│       │       └── 调试模式变量 --> ( 难度等级: [0.267, 0.2674) || 挂载数据: 无 ) 
│       ├── 在Unix平台中使用Python --> ( 难度等级: [0.2674, 0.2681) || 挂载数据: 无 ) 
│       │   ├── 获取最新版本的Python --> ( 难度等级: [0.2674, 0.2676) || 挂载数据: 无 ) 
│       │   │   ├── 在Linux中 --> ( 难度等级: [0.2674, 0.2675) || 挂载数据: qa: 10; blog: 33 ) 
│       │   │   ├── 在FreeBSD和OpenBSD上 --> ( 难度等级: [0.2675, 0.2675) || 挂载数据: 无 ) 
│       │   │   └── 在OpenSolaris系统上 --> ( 难度等级: [0.2675, 0.2676) || 挂载数据: 无 ) 
│       │   ├── 构建Python --> ( 难度等级: [0.2676, 0.2678) || 挂载数据: 无 ) 
│       │   └── 杂项 --> ( 难度等级: [0.2678, 0.2681) || 挂载数据: 无 ) 
│       ├── 在Windows上使用Python --> ( 难度等级: [0.2681, 0.2688) || 挂载数据: 无 ) 
│       │   ├── 完整安装程序 --> ( 难度等级: [0.2681, 0.2681) || 挂载数据: 无 ) 
│       │   │   ├── 安装步骤 --> ( 难度等级: [0.2681, 0.2681) || 挂载数据: qa: 2 ) 
│       │   │   ├── 删除MAX_PATH限制 --> ( 难度等级: [0.2681, 0.2681) || 挂载数据: qa: 1; blog: 1 ) 
│       │   │   ├── 无UI安装 --> ( 难度等级: [0.2681, 0.2681) || 挂载数据: qa: 1; blog: 7 ) 
│       │   │   ├── 免下载安装 --> ( 难度等级: [0.2681, 0.2681) || 挂载数据: 无 ) 
│       │   │   └── 修改安装 --> ( 难度等级: [0.2681, 0.2681) || 挂载数据: 无 ) 
│       │   ├── Microsoft Store包 --> ( 难度等级: [0.2681, 0.2682) || 挂载数据: qa: 1; blog: 2 ) 
│       │   ├── nuget.org安装包 --> ( 难度等级: [0.2682, 0.2683) || 挂载数据: blog: 3 ) 
│       │   ├── 可嵌入的包 --> ( 难度等级: [0.2683, 0.2683) || 挂载数据: 无 ) 
│       │   │   ├── Python应用程序 --> ( 难度等级: [0.2683, 0.2683) || 挂载数据: qa: 1 ) 
│       │   │   └── 嵌入Python --> ( 难度等级: [0.2683, 0.2683) || 挂载数据: qa: 2; blog: 1 ) 
│       │   ├── 替代捆绑包 --> ( 难度等级: [0.2683, 0.2684) || 挂载数据: 无 ) 
│       │   ├── 配置Python --> ( 难度等级: [0.2684, 0.2684) || 挂载数据: 无 ) 
│       │   │   └── 查找Python可执行文件 --> ( 难度等级: [0.2684, 0.2684) || 挂载数据: 无 ) 
│       │   ├── UTF-8 模式 --> ( 难度等级: [0.2684, 0.2685) || 挂载数据: qa: 4; blog: 1 ) 
│       │   ├── 适用于Windows的Python启动器 --> ( 难度等级: [0.2685, 0.2686) || 挂载数据: 无 ) 
│       │   │   ├── 入门 --> ( 难度等级: [0.2685, 0.2685) || 挂载数据: 无 ) 
│       │   │   │   ├── 从虚拟环境 --> ( 难度等级: [0.2685, 0.2685) || 挂载数据: blog: 1 ) 
│       │   │   │   ├── 从脚本 --> ( 难度等级: [0.2685, 0.2685) || 挂载数据: qa: 1 ) 
│       │   │   │   └── 从文件关联 --> ( 难度等级: [0.2685, 0.2685) || 挂载数据: 无 ) 
│       │   │   ├── Shebang Lines --> ( 难度等级: [0.2685, 0.2685) || 挂载数据: 无 ) 
│       │   │   ├── shebang lines的参数 --> ( 难度等级: [0.2685, 0.2685) || 挂载数据: 无 ) 
│       │   │   ├── 自定义 --> ( 难度等级: [0.2685, 0.2685) || 挂载数据: 无 ) 
│       │   │   │   ├── 通过INI文件自定义 --> ( 难度等级: [0.2685, 0.2685) || 挂载数据: blog: 1 ) 
│       │   │   │   └── 自定义默认的Python版本 --> ( 难度等级: [0.2685, 0.2685) || 挂载数据: qa: 1 ) 
│       │   │   └── 诊断 --> ( 难度等级: [0.2685, 0.2686) || 挂载数据: 无 ) 
│       │   ├── 查找模块 --> ( 难度等级: [0.2686, 0.2686) || 挂载数据: 无 ) 
│       │   ├── 附加模块 --> ( 难度等级: [0.2686, 0.2687) || 挂载数据: 无 ) 
│       │   │   ├── PyWin32 --> ( 难度等级: [0.2686, 0.2686) || 挂载数据: 无 ) 
│       │   │   ├── cx_Freeze --> ( 难度等级: [0.2686, 0.2687) || 挂载数据: 无 ) 
│       │   │   └── WConio --> ( 难度等级: [0.2687, 0.2687) || 挂载数据: 无 ) 
│       │   ├── 在Windows上编译Python --> ( 难度等级: [0.2687, 0.2687) || 挂载数据: qa: 7; blog: 44 ) 
│       │   └── 其他平台 --> ( 难度等级: [0.2687, 0.2688) || 挂载数据: qa: 1 ) 
│       ├── 在苹果系统上使用Python --> ( 难度等级: [0.2688, 0.2695) || 挂载数据: 无 ) 
│       │   ├── 获取和安装MacPython --> ( 难度等级: [0.2688, 0.2689) || 挂载数据: 无 ) 
│       │   │   ├── 如何运行Python脚本 --> ( 难度等级: [0.2688, 0.2688) || 挂载数据: 无 ) 
│       │   │   ├── 运行有图形界面的脚本 --> ( 难度等级: [0.2688, 0.2689) || 挂载数据: 无 ) 
│       │   │   └── 配置 --> ( 难度等级: [0.2689, 0.2689) || 挂载数据: qa: 1 ) 
│       │   │       ├── 提取常量 --> ( 难度等级: [0.2689, 0.2689) || 挂载数据: qa: 7 ) 
│       │   │       └── 配置文件 --> ( 难度等级: [0.2689, 0.2689) || 挂载数据: 无 ) 
│       │   ├── IDE --> ( 难度等级: [0.2689, 0.269) || 挂载数据: qa: 3; blog: 4 ) 
│       │   ├── 安装额外的Python包 --> ( 难度等级: [0.269, 0.2691) || 挂载数据: 无 ) 
│       │   ├── Mac上的图形界面编程 --> ( 难度等级: [0.2691, 0.2693) || 挂载数据: 无 ) 
│       │   ├── 在Mac上分发Python应用程序 --> ( 难度等级: [0.2693, 0.2694) || 挂载数据: 无 ) 
│       │   └── 其他资源 --> ( 难度等级: [0.2694, 0.2695) || 挂载数据: 无 ) 
│       ├── 编辑器和集成开发环境 --> ( 难度等级: [0.2695, 0.2702) || 挂载数据: qa: 1 ) 
│       ├── Python解释器 --> ( 难度等级: [0.2702, 0.2709) || 挂载数据: 无 ) 
│       │   ├── 调用解释器 --> ( 难度等级: [0.2702, 0.2706) || 挂载数据: qa: 1 ) 
│       │   │   ├── 传入参数 --> ( 难度等级: [0.2702, 0.2704) || 挂载数据: 无 ) 
│       │   │   └── 交互模式 --> ( 难度等级: [0.2704, 0.2706) || 挂载数据: qa: 2; blog: 1 ) 
│       │   └── 解释器的运行环境 --> ( 难度等级: [0.2706, 0.2709) || 挂载数据: qa: 1 ) 
│       │       └── 源文件的字符编码 --> ( 难度等级: [0.2706, 0.2709) || 挂载数据: 无 ) 
│       ├── Python速览 --> ( 难度等级: [0.2709, 0.2716) || 挂载数据: 无 ) 
│       │   ├── Python用作计算器 --> ( 难度等级: [0.2709, 0.2713) || 挂载数据: qa: 1 ) 
│       │   │   └── 数字 --> ( 难度等级: [0.2709, 0.2713) || 挂载数据: qa: 1 ) 
│       │   └── 走向编程的第一步 --> ( 难度等级: [0.2713, 0.2716) || 挂载数据: 无 ) 
│       ├── 其他流程控制工具 --> ( 难度等级: [0.2716, 0.2723) || 挂载数据: 无 ) 
│       │   ├── range 函数 --> ( 难度等级: [0.2716, 0.2718) || 挂载数据: qa: 1 ) 
│       │   ├── pass语句 --> ( 难度等级: [0.2718, 0.2719) || 挂载数据: qa: 1 ) 
│       │   ├── 定义函数 --> ( 难度等级: [0.2719, 0.2721) || 挂载数据: qa: 3 ) 
│       │   │   ├── 向函数传递信息 --> ( 难度等级: [0.2719, 0.272) || 挂载数据: 无 ) 
│       │   │   └── 实参和形参 --> ( 难度等级: [0.272, 0.2721) || 挂载数据: 无 ) 
│       │   ├── 函数定义详解 --> ( 难度等级: [0.2721, 0.2722) || 挂载数据: 无 ) 
│       │   │   ├── 默认值参数 --> ( 难度等级: [0.2721, 0.2721) || 挂载数据: 无 ) 
│       │   │   ├── 关键字参数 --> ( 难度等级: [0.2721, 0.2721) || 挂载数据: 无 ) 
│       │   │   ├── 特殊参数 --> ( 难度等级: [0.2721, 0.2721) || 挂载数据: 无 ) 
│       │   │   │   ├── 位置或关键字参数 --> ( 难度等级: [0.2721, 0.2721) || 挂载数据: 无 ) 
│       │   │   │   ├── 仅位置参数 --> ( 难度等级: [0.2721, 0.2721) || 挂载数据: blog: 1 ) 
│       │   │   │   ├── 仅限关键字参数 --> ( 难度等级: [0.2721, 0.2721) || 挂载数据: 无 ) 
│       │   │   │   └── 函数示例 --> ( 难度等级: [0.2721, 0.2721) || 挂载数据: 无 ) 
│       │   │   ├── 任意实参列表 --> ( 难度等级: [0.2721, 0.2721) || 挂载数据: 无 ) 
│       │   │   ├── 解包实参列表 --> ( 难度等级: [0.2721, 0.2721) || 挂载数据: 无 ) 
│       │   │   ├── Lambda表达式 --> ( 难度等级: [0.2721, 0.2722) || 挂载数据: qa: 2; blog: 1 ) 
│       │   │   ├── 文档字符串 --> ( 难度等级: [0.2722, 0.2722) || 挂载数据: 无 ) 
│       │   │   └── 函数注解 --> ( 难度等级: [0.2722, 0.2722) || 挂载数据: 无 ) 
│       │   └── 小插曲：编码风格 --> ( 难度等级: [0.2722, 0.2723) || 挂载数据: 无 ) 
│       ├── 数据结构 --> ( 难度等级: [0.2723, 0.273) || 挂载数据: 无 ) 
│       │   ├── 列表详解 --> ( 难度等级: [0.2723, 0.2724) || 挂载数据: qa: 2 ) 
│       │   │   ├── 用列表实现堆栈 --> ( 难度等级: [0.2723, 0.2724) || 挂载数据: 无 ) 
│       │   │   ├── 用列表实现队列 --> ( 难度等级: [0.2724, 0.2724) || 挂载数据: 无 ) 
│       │   │   └── 嵌套的列表推导式 --> ( 难度等级: [0.2724, 0.2724) || 挂载数据: 无 ) 
│       │   ├── del语句 --> ( 难度等级: [0.2724, 0.2725) || 挂载数据: 无 ) 
│       │   ├── 循环的技巧 --> ( 难度等级: [0.2725, 0.2726) || 挂载数据: blog: 1 ) 
│       │   ├── 深入条件控制 --> ( 难度等级: [0.2726, 0.2727) || 挂载数据: 无 ) 
│       │   ├── 序列和其他类型的比较 --> ( 难度等级: [0.2727, 0.2728) || 挂载数据: 无 ) 
│       │   ├── 序列构成的数组 --> ( 难度等级: [0.2728, 0.2729) || 挂载数据: 无 ) 
│       │   │   ├── 内置序列类型概览 --> ( 难度等级: [0.2728, 0.2729) || 挂载数据: 无 ) 
│       │   │   ├── 元组不仅仅是不可变的列表 --> ( 难度等级: [0.2729, 0.2729) || 挂载数据: 无 ) 
│       │   │   ├── 序列的增量赋值 --> ( 难度等级: [0.2729, 0.2729) || 挂载数据: 无 ) 
│       │   │   ├── list.sort方法和内置函数sorted --> ( 难度等级: [0.2729, 0.2729) || 挂载数据: blog: 1 ) 
│       │   │   ├── 用bisect来管理已排序的序列 --> ( 难度等级: [0.2729, 0.2729) || 挂载数据: qa: 1 ) 
│       │   │   └── 当列表不是首选时 --> ( 难度等级: [0.2729, 0.2729) || 挂载数据: 无 ) 
│       │   └── 文本和字节序列 --> ( 难度等级: [0.2729, 0.273) || 挂载数据: 无 ) 
│       │       ├── 字节概要 --> ( 难度等级: [0.2729, 0.273) || 挂载数据: 无 ) 
│       │       ├── 基本的编解码器 --> ( 难度等级: [0.273, 0.273) || 挂载数据: 无 ) 
│       │       ├── 处理文本文件 --> ( 难度等级: [0.273, 0.273) || 挂载数据: 无 ) 
│       │       ├── 为了正确比较而规范化Unicode字符串 --> ( 难度等级: [0.273, 0.273) || 挂载数据: 无 ) 
│       │       ├── Unicode文本排序 --> ( 难度等级: [0.273, 0.273) || 挂载数据: 无 ) 
│       │       ├── Unicode数据库 --> ( 难度等级: [0.273, 0.273) || 挂载数据: 无 ) 
│       │       └── 支持字符串和字节序列的双模式API --> ( 难度等级: [0.273, 0.273) || 挂载数据: qa: 1 ) 
│       ├── 模块 --> ( 难度等级: [0.273, 0.2738) || 挂载数据: 无 ) 
│       │   ├── 模块详解 --> ( 难度等级: [0.273, 0.2731) || 挂载数据: 无 ) 
│       │   │   ├── 以脚本方式执行模块 --> ( 难度等级: [0.273, 0.2731) || 挂载数据: 无 ) 
│       │   │   ├── 模块搜索路径 --> ( 难度等级: [0.2731, 0.2731) || 挂载数据: qa: 1 ) 
│       │   │   └── “已编译的” Python文件 --> ( 难度等级: [0.2731, 0.2731) || 挂载数据: 无 ) 
│       │   ├── 标准模块 --> ( 难度等级: [0.2731, 0.2732) || 挂载数据: 无 ) 
│       │   ├── dir 函数 --> ( 难度等级: [0.2732, 0.2732) || 挂载数据: 无 ) 
│       │   ├── 包 --> ( 难度等级: [0.2732, 0.2733) || 挂载数据: 无 ) 
│       │   │   ├── 从包中导入 * --> ( 难度等级: [0.2732, 0.2732) || 挂载数据: qa: 1 ) 
│       │   │   ├── 子包参考 --> ( 难度等级: [0.2732, 0.2732) || 挂载数据: 无 ) 
│       │   │   └── 多目录中的包 --> ( 难度等级: [0.2732, 0.2733) || 挂载数据: qa: 4; blog: 1 ) 
│       │   ├── 安装第三方模块 --> ( 难度等级: [0.2733, 0.2733) || 挂载数据: qa: 4; blog: 1 ) 
│       │   ├── Pillow --> ( 难度等级: [0.2733, 0.2734) || 挂载数据: blog: 2 ) 
│       │   ├── requests --> ( 难度等级: [0.2734, 0.2734) || 挂载数据: qa: 13; blog: 1 ) 
│       │   ├── chardet --> ( 难度等级: [0.2734, 0.2735) || 挂载数据: 无 ) 
│       │   ├── psutil --> ( 难度等级: [0.2735, 0.2735) || 挂载数据: 无 ) 
│       │   ├── cmath和复数 --> ( 难度等级: [0.2735, 0.2736) || 挂载数据: 无 ) 
│       │   ├── 回到未来 --> ( 难度等级: [0.2736, 0.2736) || 挂载数据: 无 ) 
│       │   ├── 模块就是程序 --> ( 难度等级: [0.2736, 0.2737) || 挂载数据: 无 ) 
│       │   ├── 模块是用来下定义的 --> ( 难度等级: [0.2737, 0.2737) || 挂载数据: 无 ) 
│       │   └── 让模块可用 --> ( 难度等级: [0.2737, 0.2738) || 挂载数据: 无 ) 
│       ├── 输入与输出 --> ( 难度等级: [0.2738, 0.2745) || 挂载数据: 无 ) 
│       │   ├── 更复杂的输出格式 --> ( 难度等级: [0.2738, 0.2739) || 挂载数据: qa: 61 ) 
│       │   │   ├── 格式化字符串字面值 --> ( 难度等级: [0.2738, 0.2738) || 挂载数据: 无 ) 
│       │   │   ├── 字符串format 方法 --> ( 难度等级: [0.2738, 0.2738) || 挂载数据: qa: 3 ) 
│       │   │   ├── 手动格式化字符串 --> ( 难度等级: [0.2738, 0.2739) || 挂载数据: 无 ) 
│       │   │   └── 旧式字符串格式化方法 --> ( 难度等级: [0.2739, 0.2739) || 挂载数据: 无 ) 
│       │   ├── 读写文件 --> ( 难度等级: [0.2739, 0.2741) || 挂载数据: qa: 3 ) 
│       │   │   ├── 文件对象的方法 --> ( 难度等级: [0.2739, 0.274) || 挂载数据: 无 ) 
│       │   │   ├── 使用json保存结构化数据 --> ( 难度等级: [0.274, 0.274) || 挂载数据: 无 ) 
│       │   │   ├── 文件读写过程 --> ( 难度等级: [0.274, 0.274) || 挂载数据: qa: 5 ) 
│       │   │   ├── 用shelve模块保存变量 --> ( 难度等级: [0.274, 0.2741) || 挂载数据: 无 ) 
│       │   │   └── 用pprint.pformat函数保存变量 --> ( 难度等级: [0.2741, 0.2741) || 挂载数据: 无 ) 
│       │   ├── 使用input函数输入 --> ( 难度等级: [0.2741, 0.2743) || 挂载数据: qa: 4 ) 
│       │   └── 使用print函数输出 --> ( 难度等级: [0.2743, 0.2745) || 挂载数据: qa: 8 ) 
│       ├── 错误和异常 --> ( 难度等级: [0.2745, 0.2752) || 挂载数据: 无 ) 
│       │   ├── 句法错误 --> ( 难度等级: [0.2745, 0.2745) || 挂载数据: 无 ) 
│       │   ├── 异常 --> ( 难度等级: [0.2745, 0.2746) || 挂载数据: 无 ) 
│       │   ├── 处理异常 --> ( 难度等级: [0.2746, 0.2746) || 挂载数据: qa: 1 ) 
│       │   ├── 触发异常 --> ( 难度等级: [0.2746, 0.2747) || 挂载数据: 无 ) 
│       │   ├── 异常链 --> ( 难度等级: [0.2747, 0.2747) || 挂载数据: 无 ) 
│       │   ├── 用户自定义异常 --> ( 难度等级: [0.2747, 0.2748) || 挂载数据: qa: 1 ) 
│       │   ├── 定义清理操作 --> ( 难度等级: [0.2748, 0.2748) || 挂载数据: 无 ) 
│       │   ├── 预定义的清理操作 --> ( 难度等级: [0.2748, 0.2749) || 挂载数据: 无 ) 
│       │   ├── 异常是什么 --> ( 难度等级: [0.2749, 0.275) || 挂载数据: 无 ) 
│       │   ├── 让事情沿你指定的轨道出错 --> ( 难度等级: [0.275, 0.275) || 挂载数据: qa: 8 ) 
│       │   │   └── 自定义的异常类 --> ( 难度等级: [0.275, 0.275) || 挂载数据: 无 ) 
│       │   ├── 捕获异常 --> ( 难度等级: [0.275, 0.2751) || 挂载数据: 无 ) 
│       │   │   ├── 不用提供参数 --> ( 难度等级: [0.275, 0.275) || 挂载数据: 无 ) 
│       │   │   ├── 多个except子句 --> ( 难度等级: [0.275, 0.275) || 挂载数据: qa: 1 ) 
│       │   │   ├── 一箭双雕 --> ( 难度等级: [0.275, 0.275) || 挂载数据: 无 ) 
│       │   │   ├── 捕获对象 --> ( 难度等级: [0.275, 0.275) || 挂载数据: 无 ) 
│       │   │   ├── 一网打尽 --> ( 难度等级: [0.275, 0.2751) || 挂载数据: 无 ) 
│       │   │   ├── 万事大吉时 --> ( 难度等级: [0.2751, 0.2751) || 挂载数据: 无 ) 
│       │   │   └── 最后 --> ( 难度等级: [0.2751, 0.2751) || 挂载数据: 无 ) 
│       │   ├── 异常之禅 --> ( 难度等级: [0.2751, 0.2751) || 挂载数据: 无 ) 
│       │   └── 不那么异常的情况 --> ( 难度等级: [0.2751, 0.2752) || 挂载数据: qa: 5 ) 
│       ├── 标准库简介 --> ( 难度等级: [0.2752, 0.2759) || 挂载数据: 无 ) 
│       │   ├── 操作系统接口 --> ( 难度等级: [0.2752, 0.2752) || 挂载数据: 无 ) 
│       │   ├── 文件通配符 --> ( 难度等级: [0.2752, 0.2752) || 挂载数据: 无 ) 
│       │   ├── 命令行参数 --> ( 难度等级: [0.2752, 0.2753) || 挂载数据: 无 ) 
│       │   ├── 错误输出重定向和程序终止 --> ( 难度等级: [0.2753, 0.2753) || 挂载数据: 无 ) 
│       │   ├── 字符串模式匹配 --> ( 难度等级: [0.2753, 0.2754) || 挂载数据: 无 ) 
│       │   ├── 数学 --> ( 难度等级: [0.2754, 0.2754) || 挂载数据: 无 ) 
│       │   ├── 互联网访问 --> ( 难度等级: [0.2754, 0.2754) || 挂载数据: 无 ) 
│       │   ├── 日期和时间 --> ( 难度等级: [0.2754, 0.2755) || 挂载数据: qa: 1 ) 
│       │   ├── 数据压缩 --> ( 难度等级: [0.2755, 0.2755) || 挂载数据: 无 ) 
│       │   ├── 性能测量 --> ( 难度等级: [0.2755, 0.2755) || 挂载数据: 无 ) 
│       │   ├── 质量控制 --> ( 难度等级: [0.2755, 0.2756) || 挂载数据: 无 ) 
│       │   ├── 自带电池 --> ( 难度等级: [0.2756, 0.2756) || 挂载数据: 无 ) 
│       │   ├── 格式化输出 --> ( 难度等级: [0.2756, 0.2756) || 挂载数据: qa: 1 ) 
│       │   ├── 模板 --> ( 难度等级: [0.2756, 0.2757) || 挂载数据: 无 ) 
│       │   ├── 使用二进制数据记录格式 --> ( 难度等级: [0.2757, 0.2757) || 挂载数据: 无 ) 
│       │   ├── 多线程 --> ( 难度等级: [0.2757, 0.2757) || 挂载数据: 无 ) 
│       │   ├── 日志 --> ( 难度等级: [0.2757, 0.2758) || 挂载数据: 无 ) 
│       │   ├── 弱引用 --> ( 难度等级: [0.2758, 0.2758) || 挂载数据: 无 ) 
│       │   ├── 用于操作列表的工具 --> ( 难度等级: [0.2758, 0.2759) || 挂载数据: 无 ) 
│       │   └── 十进制浮点运算 --> ( 难度等级: [0.2759, 0.2759) || 挂载数据: 无 ) 
│       ├── 交互式编辑和编辑历史 --> ( 难度等级: [0.2759, 0.2766) || 挂载数据: 无 ) 
│       │   ├── Tab补全和编辑历史 --> ( 难度等级: [0.2759, 0.2762) || 挂载数据: 无 ) 
│       │   └── 默认交互式解释器的替代品 --> ( 难度等级: [0.2762, 0.2766) || 挂载数据: 无 ) 
│       ├── 浮点算术：争议和限制 --> ( 难度等级: [0.2766, 0.2773) || 挂载数据: 无 ) 
│       │   └── 表示性错误 --> ( 难度等级: [0.2766, 0.2773) || 挂载数据: 无 ) 
│       ├── 概述 --> ( 难度等级: [0.2773, 0.278) || 挂载数据: 无 ) 
│       │   ├── 其他实现 --> ( 难度等级: [0.2773, 0.2775) || 挂载数据: 无 ) 
│       │   ├── 标注 --> ( 难度等级: [0.2775, 0.2778) || 挂载数据: 无 ) 
│       │   └── 可用性注释 --> ( 难度等级: [0.2778, 0.278) || 挂载数据: 无 ) 
│       ├── 词法分析 --> ( 难度等级: [0.278, 0.2787) || 挂载数据: 无 ) 
│       │   ├── 行结构 --> ( 难度等级: [0.278, 0.2782) || 挂载数据: qa: 1 ) 
│       │   ├── 其他形符 --> ( 难度等级: [0.2782, 0.2783) || 挂载数据: 无 ) 
│       │   ├── 字面值 --> ( 难度等级: [0.2783, 0.2784) || 挂载数据: 无 ) 
│       │   ├── 运算符 --> ( 难度等级: [0.2784, 0.2786) || 挂载数据: 无 ) 
│       │   │   ├── 赋值运算符 --> ( 难度等级: [0.2784, 0.2785) || 挂载数据: qa: 2 ) 
│       │   │   ├── 比较（关系）运算符 --> ( 难度等级: [0.2785, 0.2785) || 挂载数据: 无 ) 
│       │   │   ├── 逻辑运算符 --> ( 难度等级: [0.2785, 0.2785) || 挂载数据: 无 ) 
│       │   │   └── 位运算符 --> ( 难度等级: [0.2785, 0.2786) || 挂载数据: qa: 2 ) 
│       │   └── 分隔符 --> ( 难度等级: [0.2786, 0.2787) || 挂载数据: 无 ) 
│       ├── 数据模型 --> ( 难度等级: [0.2787, 0.2794) || 挂载数据: 无 ) 
│       │   ├── 标准类型层级结构 --> ( 难度等级: [0.2787, 0.279) || 挂载数据: 无 ) 
│       │   ├── 特殊方法名称 --> ( 难度等级: [0.279, 0.2792) || 挂载数据: 无 ) 
│       │   └── 协程 --> ( 难度等级: [0.2792, 0.2794) || 挂载数据: 无 ) 
│       │       ├── 生成器如何进化成协程 --> ( 难度等级: [0.2792, 0.2792) || 挂载数据: 无 ) 
│       │       ├── 用作协程的生成器的基本行为 --> ( 难度等级: [0.2792, 0.2793) || 挂载数据: 无 ) 
│       │       ├── 预激协程的装饰器 --> ( 难度等级: [0.2793, 0.2793) || 挂载数据: 无 ) 
│       │       ├── 让协程返回值 --> ( 难度等级: [0.2793, 0.2793) || 挂载数据: qa: 1 ) 
│       │       ├── 使用yield from --> ( 难度等级: [0.2793, 0.2794) || 挂载数据: 无 ) 
│       │       ├── yield from的意义 --> ( 难度等级: [0.2794, 0.2794) || 挂载数据: qa: 1 ) 
│       │       └── 使用案例：使用协程做离散事件仿真 --> ( 难度等级: [0.2794, 0.2794) || 挂载数据: 无 ) 
│       ├── 执行模型 --> ( 难度等级: [0.2794, 0.2801) || 挂载数据: 无 ) 
│       │   ├── 程序的结构 --> ( 难度等级: [0.2794, 0.2798) || 挂载数据: qa: 4 ) 
│       │   └── 命名与绑定 --> ( 难度等级: [0.2798, 0.2801) || 挂载数据: 无 ) 
│       ├── 导入系统 --> ( 难度等级: [0.2801, 0.2809) || 挂载数据: 无 ) 
│       │   ├── importlib --> ( 难度等级: [0.2801, 0.2802) || 挂载数据: 无 ) 
│       │   ├── 搜索 --> ( 难度等级: [0.2802, 0.2803) || 挂载数据: 无 ) 
│       │   ├── 加载 --> ( 难度等级: [0.2803, 0.2804) || 挂载数据: qa: 1 ) 
│       │   ├── 基于路径的查找器 --> ( 难度等级: [0.2804, 0.2805) || 挂载数据: 无 ) 
│       │   ├── 替换标准导入系统 --> ( 难度等级: [0.2805, 0.2806) || 挂载数据: qa: 5; blog: 2 ) 
│       │   ├── 包相对导入 --> ( 难度等级: [0.2806, 0.2807) || 挂载数据: 无 ) 
│       │   ├── 有关__main__的特殊事项 --> ( 难度等级: [0.2807, 0.2808) || 挂载数据: qa: 3 ) 
│       │   └── 参考文献 --> ( 难度等级: [0.2808, 0.2809) || 挂载数据: 无 ) 
│       ├── 复合语句 --> ( 难度等级: [0.2809, 0.2816) || 挂载数据: 无 ) 
│       │   ├── while语句 --> ( 难度等级: [0.2809, 0.281) || 挂载数据: 无 ) 
│       │   ├── try语句 --> ( 难度等级: [0.281, 0.2811) || 挂载数据: 无 ) 
│       │   ├── with语句 --> ( 难度等级: [0.2811, 0.2813) || 挂载数据: qa: 1 ) 
│       │   ├── 函数定义 --> ( 难度等级: [0.2813, 0.2814) || 挂载数据: qa: 2 ) 
│       │   └── 类定义 --> ( 难度等级: [0.2814, 0.2816) || 挂载数据: 无 ) 
│       ├── 顶级组件 --> ( 难度等级: [0.2816, 0.2823) || 挂载数据: 无 ) 
│       │   ├── 完整的Python程序 --> ( 难度等级: [0.2816, 0.2817) || 挂载数据: 无 ) 
│       │   │   ├── 使用文本编辑器 --> ( 难度等级: [0.2816, 0.2816) || 挂载数据: 无 ) 
│       │   │   └── Python代码运行助手 --> ( 难度等级: [0.2816, 0.2817) || 挂载数据: blog: 1 ) 
│       │   ├── 文件输入 --> ( 难度等级: [0.2817, 0.2819) || 挂载数据: qa: 1 ) 
│       │   ├── 交互式输入 --> ( 难度等级: [0.2819, 0.2821) || 挂载数据: 无 ) 
│       │   └── 表达式输入 --> ( 难度等级: [0.2821, 0.2823) || 挂载数据: 无 ) 
│       ├── 完整的语法规范 --> ( 难度等级: [0.2823, 0.283) || 挂载数据: 无 ) 
│       ├── 内置常量 --> ( 难度等级: [0.283, 0.2837) || 挂载数据: 无 ) 
│       │   └── 由site模块添加的常量 --> ( 难度等级: [0.283, 0.2837) || 挂载数据: 无 ) 
│       ├── 内置类型 --> ( 难度等级: [0.2837, 0.2844) || 挂载数据: 无 ) 
│       │   ├── 逻辑值检测 --> ( 难度等级: [0.2837, 0.2837) || 挂载数据: 无 ) 
│       │   ├── 布尔运算 --- and, or, not --> ( 难度等级: [0.2837, 0.2838) || 挂载数据: qa: 6; blog: 2 ) 
│       │   ├── 比较 --> ( 难度等级: [0.2838, 0.2839) || 挂载数据: 无 ) 
│       │   ├── 数字类型 --- int, float, complex --> ( 难度等级: [0.2839, 0.2839) || 挂载数据: qa: 4 ) 
│       │   ├── 迭代器类型 --> ( 难度等级: [0.2839, 0.284) || 挂载数据: 无 ) 
│       │   ├── 序列类型 --- list, tuple, range --> ( 难度等级: [0.284, 0.284) || 挂载数据: qa: 2 ) 
│       │   ├── 文本序列类型 --- str --> ( 难度等级: [0.284, 0.2841) || 挂载数据: qa: 1 ) 
│       │   ├── 二进制序列类型 --- bytes, bytearray, memoryview --> ( 难度等级: [0.2841, 0.2841) || 挂载数据: 无 ) 
│       │   ├── 集合类型 --- set, frozenset --> ( 难度等级: [0.2841, 0.2842) || 挂载数据: 无 ) 
│       │   ├── 映射类型 --- dict --> ( 难度等级: [0.2842, 0.2842) || 挂载数据: 无 ) 
│       │   ├── 上下文管理器类型 --> ( 难度等级: [0.2842, 0.2843) || 挂载数据: 无 ) 
│       │   ├── Generic Alias Type --> ( 难度等级: [0.2843, 0.2843) || 挂载数据: 无 ) 
│       │   └── 其他内置类型 --> ( 难度等级: [0.2843, 0.2844) || 挂载数据: qa: 2 ) 
│       ├── 内置异常 --> ( 难度等级: [0.2844, 0.2851) || 挂载数据: 无 ) 
│       │   ├── 基类 --> ( 难度等级: [0.2844, 0.2846) || 挂载数据: 无 ) 
│       │   ├── 警告 --> ( 难度等级: [0.2846, 0.2849) || 挂载数据: qa: 1; blog: 1 ) 
│       │   └── 异常层次结构 --> ( 难度等级: [0.2849, 0.2851) || 挂载数据: 无 ) 
│       ├── 文本处理服务 --> ( 难度等级: [0.2851, 0.2858) || 挂载数据: 无 ) 
│       │   ├── string --- 常见的字符串操作 --> ( 难度等级: [0.2851, 0.2852) || 挂载数据: qa: 5; blog: 11 ) 
│       │   ├── re --- 正则表达式操作 --> ( 难度等级: [0.2852, 0.2853) || 挂载数据: 无 ) 
│       │   ├── difflib --- 计算差异的辅助工具 --> ( 难度等级: [0.2853, 0.2854) || 挂载数据: 无 ) 
│       │   ├── textwrap --- 文本自动换行与填充 --> ( 难度等级: [0.2854, 0.2855) || 挂载数据: 无 ) 
│       │   ├── unicodedata --- Unicode数据库 --> ( 难度等级: [0.2855, 0.2855) || 挂载数据: 无 ) 
│       │   ├── stringprep --- 因特网字符串预备 --> ( 难度等级: [0.2855, 0.2856) || 挂载数据: 无 ) 
│       │   ├── readline --- GNU readline接口 --> ( 难度等级: [0.2856, 0.2857) || 挂载数据: qa: 3 ) 
│       │   └── rlcompleter --- GNU readline的补全函数 --> ( 难度等级: [0.2857, 0.2858) || 挂载数据: 无 ) 
│       ├── 二进制数据服务 --> ( 难度等级: [0.2858, 0.2865) || 挂载数据: 无 ) 
│       │   ├── struct --- 将字节串解读为打包的二进制数据 --> ( 难度等级: [0.2858, 0.2862) || 挂载数据: qa: 1 ) 
│       │   └── codecs --- 编解码器注册和相关基类 --> ( 难度等级: [0.2862, 0.2865) || 挂载数据: 无 ) 
│       ├── 函数式编程模块 --> ( 难度等级: [0.2865, 0.2872) || 挂载数据: 无 ) 
│       │   ├── itertools --- 为高效循环而创建迭代器的函数 --> ( 难度等级: [0.2865, 0.2868) || 挂载数据: 无 ) 
│       │   ├── functools --- 高阶函数和可调用对象上的操作 --> ( 难度等级: [0.2868, 0.287) || 挂载数据: 无 ) 
│       │   └── operator --- 标准运算符替代函数 --> ( 难度等级: [0.287, 0.2872) || 挂载数据: 无 ) 
│       ├── 数据持久化 --> ( 难度等级: [0.2872, 0.2879) || 挂载数据: 无 ) 
│       │   ├── pickle --- Python对象序列化 --> ( 难度等级: [0.2872, 0.2874) || 挂载数据: 无 ) 
│       │   ├── copyreg --- 注册配合pickle模块使用的函数 --> ( 难度等级: [0.2874, 0.2875) || 挂载数据: qa: 1 ) 
│       │   ├── shelve --- Python对象持久化 --> ( 难度等级: [0.2875, 0.2876) || 挂载数据: 无 ) 
│       │   ├── marshal --- 内部Python对象序列化 --> ( 难度等级: [0.2876, 0.2877) || 挂载数据: 无 ) 
│       │   ├── dbm --- Unix "数据库" 接口 --> ( 难度等级: [0.2877, 0.2878) || 挂载数据: 无 ) 
│       │   └── sqlite3 --- SQLite数据库DB-API 2.0 接口模块 --> ( 难度等级: [0.2878, 0.2879) || 挂载数据: 无 ) 
│       ├── 文件格式 --> ( 难度等级: [0.2879, 0.2887) || 挂载数据: 无 ) 
│       │   ├── csv --- CSV文件读写 --> ( 难度等级: [0.2879, 0.2881) || 挂载数据: qa: 1 ) 
│       │   ├── configparser --- 配置文件解析器 --> ( 难度等级: [0.2881, 0.2882) || 挂载数据: blog: 1 ) 
│       │   ├── netrc --- netrc文件处理 --> ( 难度等级: [0.2882, 0.2884) || 挂载数据: 无 ) 
│       │   ├── xdrlib --- 编码与解码XDR数据 --> ( 难度等级: [0.2884, 0.2885) || 挂载数据: 无 ) 
│       │   └── plistlib --- 生成与解析Apple .plist文件 --> ( 难度等级: [0.2885, 0.2887) || 挂载数据: blog: 1 ) 
│       ├── 加密服务 --> ( 难度等级: [0.2887, 0.2894) || 挂载数据: 无 ) 
│       │   ├── hashlib --- 安全哈希与消息摘要 --> ( 难度等级: [0.2887, 0.2889) || 挂载数据: 无 ) 
│       │   ├── hmac --- 基于密钥的消息验证 --> ( 难度等级: [0.2889, 0.2891) || 挂载数据: 无 ) 
│       │   └── secrets --- 生成管理密码的安全随机数 --> ( 难度等级: [0.2891, 0.2894) || 挂载数据: 无 ) 
│       ├── 通用操作系统服务 --> ( 难度等级: [0.2894, 0.2901) || 挂载数据: 无 ) 
│       │   ├── os --- 多种操作系统接口 --> ( 难度等级: [0.2894, 0.2894) || 挂载数据: blog: 1 ) 
│       │   ├── io --- 处理流的核心工具 --> ( 难度等级: [0.2894, 0.2895) || 挂载数据: blog: 1 ) 
│       │   ├── time --- 时间的访问和转换 --> ( 难度等级: [0.2895, 0.2895) || 挂载数据: 无 ) 
│       │   ├── argparse --- 命令行选项、参数和子命令解析器 --> ( 难度等级: [0.2895, 0.2895) || 挂载数据: 无 ) 
│       │   ├── getopt --- C风格的命令行选项解析器 --> ( 难度等级: [0.2895, 0.2896) || 挂载数据: 无 ) 
│       │   ├── logging --- Python的日志记录工具 --> ( 难度等级: [0.2896, 0.2896) || 挂载数据: 无 ) 
│       │   ├── logging.config --- 日志记录配置 --> ( 难度等级: [0.2896, 0.2897) || 挂载数据: 无 ) 
│       │   ├── logging.handlers --- 日志处理程序 --> ( 难度等级: [0.2897, 0.2897) || 挂载数据: 无 ) 
│       │   ├── getpass --- 便携式密码输入工具 --> ( 难度等级: [0.2897, 0.2898) || 挂载数据: 无 ) 
│       │   ├── curses --- 终端字符单元显示的处理 --> ( 难度等级: [0.2898, 0.2898) || 挂载数据: 无 ) 
│       │   ├── curses.textpad --- 用于curses程序的文本输入控件 --> ( 难度等级: [0.2898, 0.2898) || 挂载数据: 无 ) 
│       │   ├── curses.ascii --- 用于ASCII字符的工具 --> ( 难度等级: [0.2898, 0.2899) || 挂载数据: 无 ) 
│       │   ├── curses.panel --- curses的面板栈扩展 --> ( 难度等级: [0.2899, 0.2899) || 挂载数据: 无 ) 
│       │   ├── platform ---  获取底层平台的标识数据 --> ( 难度等级: [0.2899, 0.29) || 挂载数据: blog: 1 ) 
│       │   ├── errno --- 标准errno系统符号 --> ( 难度等级: [0.29, 0.29) || 挂载数据: qa: 2 ) 
│       │   └── ctypes --- Python的外部函数库 --> ( 难度等级: [0.29, 0.2901) || 挂载数据: 无 ) 
│       ├── 并发执行 --> ( 难度等级: [0.2901, 0.2908) || 挂载数据: 无 ) 
│       │   ├── threading --- 基于线程的并行 --> ( 难度等级: [0.2901, 0.2901) || 挂载数据: 无 ) 
│       │   ├── multiprocessing --- 基于进程的并行 --> ( 难度等级: [0.2901, 0.2902) || 挂载数据: 无 ) 
│       │   ├── multiprocessing.shared_memory --- 可从进程直接访问的共享内存 --> ( 难度等级: [0.2902, 0.2903) || 挂载数据: 无 ) 
│       │   ├── concurrent包 --> ( 难度等级: [0.2903, 0.2904) || 挂载数据: 无 ) 
│       │   ├── concurrent.futures --- 启动并行任务 --> ( 难度等级: [0.2904, 0.2904) || 挂载数据: 无 ) 
│       │   ├── subprocess --- 子进程管理 --> ( 难度等级: [0.2904, 0.2905) || 挂载数据: qa: 3 ) 
│       │   ├── sched --- 事件调度器 --> ( 难度等级: [0.2905, 0.2906) || 挂载数据: 无 ) 
│       │   ├── queue --- 一个同步的队列类 --> ( 难度等级: [0.2906, 0.2906) || 挂载数据: 无 ) 
│       │   ├── contextvars --- 上下文变量 --> ( 难度等级: [0.2906, 0.2907) || 挂载数据: 无 ) 
│       │   └── _thread --- 底层多线程API --> ( 难度等级: [0.2907, 0.2908) || 挂载数据: qa: 1 ) 
│       ├── 网络和进程间通信 --> ( 难度等级: [0.2908, 0.2915) || 挂载数据: 无 ) 
│       │   ├── asyncio --- 异步I/O --> ( 难度等级: [0.2908, 0.2909) || 挂载数据: 无 ) 
│       │   ├── socket --- 底层网络接口 --> ( 难度等级: [0.2909, 0.2909) || 挂载数据: 无 ) 
│       │   ├── ssl --- 套接字对象的TLS/SSL包装器 --> ( 难度等级: [0.2909, 0.291) || 挂载数据: blog: 1 ) 
│       │   ├── select --- 等待I/O完成 --> ( 难度等级: [0.291, 0.2911) || 挂载数据: 无 ) 
│       │   ├── selectors --- 高级I/O复用库 --> ( 难度等级: [0.2911, 0.2912) || 挂载数据: qa: 1 ) 
│       │   ├── asyncore --- 异步套接字处理器 --> ( 难度等级: [0.2912, 0.2913) || 挂载数据: 无 ) 
│       │   ├── asynchat --- 异步套接字指令/响应处理程序 --> ( 难度等级: [0.2913, 0.2913) || 挂载数据: 无 ) 
│       │   ├── signal --- 设置异步事件处理程序 --> ( 难度等级: [0.2913, 0.2914) || 挂载数据: 无 ) 
│       │   └── mmap --- 内存映射文件支持 --> ( 难度等级: [0.2914, 0.2915) || 挂载数据: 无 ) 
│       ├── 互联网数据处理 --> ( 难度等级: [0.2915, 0.2922) || 挂载数据: qa: 1 ) 
│       │   ├── email --- 电子邮件与MIME处理包 --> ( 难度等级: [0.2915, 0.2916) || 挂载数据: blog: 1 ) 
│       │   ├── json --- JSON编码和解码器 --> ( 难度等级: [0.2916, 0.2917) || 挂载数据: 无 ) 
│       │   ├── mailcap --- Mailcap文件处理 --> ( 难度等级: [0.2917, 0.2918) || 挂载数据: 无 ) 
│       │   ├── mailbox --- 操作多种格式的邮箱 --> ( 难度等级: [0.2918, 0.2918) || 挂载数据: 无 ) 
│       │   ├── mimetypes --- 映射文件名到MIME类型 --> ( 难度等级: [0.2918, 0.2919) || 挂载数据: 无 ) 
│       │   ├── base64 --- Base16, Base32, Base64, Base85 数据编码 --> ( 难度等级: [0.2919, 0.292) || 挂载数据: 无 ) 
│       │   ├── binascii --- 二进制和ASCII码互转 --> ( 难度等级: [0.292, 0.2921) || 挂载数据: qa: 2 ) 
│       │   └── quopri --- 编码与解码经过MIME转码的可打印数据 --> ( 难度等级: [0.2921, 0.2922) || 挂载数据: 无 ) 
│       ├── 结构化标记处理工具 --> ( 难度等级: [0.2922, 0.2929) || 挂载数据: 无 ) 
│       │   ├── html --- 超文本标记语言支持 --> ( 难度等级: [0.2922, 0.2923) || 挂载数据: 无 ) 
│       │   ├── html.parser --- 简单的HTML和XHTML解析器 --> ( 难度等级: [0.2923, 0.2923) || 挂载数据: 无 ) 
│       │   ├── html.entities --- HTML一般实体的定义 --> ( 难度等级: [0.2923, 0.2924) || 挂载数据: 无 ) 
│       │   ├── XML处理模块 --> ( 难度等级: [0.2924, 0.2924) || 挂载数据: 无 ) 
│       │   ├── xml.etree.ElementTree ---  ElementTree XML API --> ( 难度等级: [0.2924, 0.2925) || 挂载数据: 无 ) 
│       │   ├── xml.dom --- 文档对象模型API --> ( 难度等级: [0.2925, 0.2925) || 挂载数据: 无 ) 
│       │   ├── xml.dom.minidom --- Minimal DOM implementation --> ( 难度等级: [0.2925, 0.2926) || 挂载数据: 无 ) 
│       │   ├── xml.dom.pulldom --- 支持构建部分DOM树 --> ( 难度等级: [0.2926, 0.2926) || 挂载数据: 无 ) 
│       │   ├── xml.sax --- 支持SAX2 解析器 --> ( 难度等级: [0.2926, 0.2927) || 挂载数据: 无 ) 
│       │   ├── xml.sax.handler --- SAX处理程序的基类 --> ( 难度等级: [0.2927, 0.2927) || 挂载数据: 无 ) 
│       │   ├── xml.sax.saxutils --- SAX工具集 --> ( 难度等级: [0.2927, 0.2928) || 挂载数据: 无 ) 
│       │   ├── xml.sax.xmlreader --- 用于XML解析器的接口 --> ( 难度等级: [0.2928, 0.2929) || 挂载数据: 无 ) 
│       │   └── xml.parsers.expat --- Fast XML parsing using Expat --> ( 难度等级: [0.2929, 0.2929) || 挂载数据: 无 ) 
│       ├── 互联网协议和支持 --> ( 难度等级: [0.2929, 0.2936) || 挂载数据: 无 ) 
│       │   ├── webbrowser --- 方便的Web浏览器控制器 --> ( 难度等级: [0.2929, 0.2929) || 挂载数据: 无 ) 
│       │   ├── cgi --- Common Gateway Interface support --> ( 难度等级: [0.2929, 0.293) || 挂载数据: blog: 5 ) 
│       │   ├── cgitb --- 用于CGI脚本的回溯管理器 --> ( 难度等级: [0.293, 0.293) || 挂载数据: 无 ) 
│       │   ├── wsgiref --- WSGI Utilities and Reference Implementation --> ( 难度等级: [0.293, 0.293) || 挂载数据: 无 ) 
│       │   ├── urllib --- URL处理模块 --> ( 难度等级: [0.293, 0.293) || 挂载数据: 无 ) 
│       │   ├── urllib.request --- 用于打开URL的可扩展库 --> ( 难度等级: [0.293, 0.2931) || 挂载数据: 无 ) 
│       │   ├── urllib.response --- urllib使用的Response类 --> ( 难度等级: [0.2931, 0.2931) || 挂载数据: qa: 1 ) 
│       │   ├── urllib.parse用于解析URL --> ( 难度等级: [0.2931, 0.2931) || 挂载数据: qa: 1 ) 
│       │   ├── urllib.error --- urllib.request引发的异常类 --> ( 难度等级: [0.2931, 0.2931) || 挂载数据: qa: 3 ) 
│       │   ├── urllib.robotparser --- robots.txt语法分析程序 --> ( 难度等级: [0.2931, 0.2932) || 挂载数据: 无 ) 
│       │   ├── http --- HTTP模块 --> ( 难度等级: [0.2932, 0.2932) || 挂载数据: 无 ) 
│       │   ├── http.client --- HTTP协议客户端 --> ( 难度等级: [0.2932, 0.2932) || 挂载数据: 无 ) 
│       │   ├── ftplib --- FTP协议客户端 --> ( 难度等级: [0.2932, 0.2932) || 挂载数据: 无 ) 
│       │   ├── poplib --- POP3 协议客户端 --> ( 难度等级: [0.2932, 0.2933) || 挂载数据: 无 ) 
│       │   ├── imaplib --- IMAP4 协议客户端 --> ( 难度等级: [0.2933, 0.2933) || 挂载数据: 无 ) 
│       │   ├── nntplib --- NNTP protocol client --> ( 难度等级: [0.2933, 0.2933) || 挂载数据: 无 ) 
│       │   ├── smtplib ---SMTP协议客户端 --> ( 难度等级: [0.2933, 0.2933) || 挂载数据: 无 ) 
│       │   ├── smtpd --- SMTP服务器 --> ( 难度等级: [0.2933, 0.2934) || 挂载数据: 无 ) 
│       │   ├── telnetlib -- Telnet客户端 --> ( 难度等级: [0.2934, 0.2934) || 挂载数据: 无 ) 
│       │   ├── uuid --- UUID objects according to <strong>RFC 4122</strong> --> ( 难度等级: [0.2934, 0.2934) || 挂载数据: 无 ) 
│       │   ├── socketserver --- A framework for network servers --> ( 难度等级: [0.2934, 0.2934) || 挂载数据: qa: 5 ) 
│       │   ├── http.server --- HTTP服务器 --> ( 难度等级: [0.2934, 0.2935) || 挂载数据: blog: 11 ) 
│       │   ├── http.cookies --- HTTP状态管理 --> ( 难度等级: [0.2935, 0.2935) || 挂载数据: qa: 1 ) 
│       │   ├── http.cookiejar —— HTTP客户端的Cookie处理 --> ( 难度等级: [0.2935, 0.2935) || 挂载数据: 无 ) 
│       │   ├── xmlrpc --- XMLRPC服务端与客户端模块 --> ( 难度等级: [0.2935, 0.2935) || 挂载数据: 无 ) 
│       │   ├── xmlrpc.client --- XML-RPC客户端访问 --> ( 难度等级: [0.2935, 0.2936) || 挂载数据: 无 ) 
│       │   ├── xmlrpc.server --- 基本XML-RPC服务器 --> ( 难度等级: [0.2936, 0.2936) || 挂载数据: 无 ) 
│       │   └── ipaddress --- IPv4/IPv6 操作库 --> ( 难度等级: [0.2936, 0.2936) || 挂载数据: 无 ) 
│       ├── 多媒体服务 --> ( 难度等级: [0.2936, 0.2943) || 挂载数据: 无 ) 
│       │   ├── audioop --- 处理原始音频数据 --> ( 难度等级: [0.2936, 0.2937) || 挂载数据: 无 ) 
│       │   ├── aifc --- 读写AIFF和AIFC文件 --> ( 难度等级: [0.2937, 0.2938) || 挂载数据: 无 ) 
│       │   ├── sunau --- 读写Sun AU文件 --> ( 难度等级: [0.2938, 0.2939) || 挂载数据: 无 ) 
│       │   ├── wave --- 读写WAV格式文件 --> ( 难度等级: [0.2939, 0.2939) || 挂载数据: 无 ) 
│       │   ├── chunk --- 读取IFF分块数据 --> ( 难度等级: [0.2939, 0.294) || 挂载数据: 无 ) 
│       │   ├── colorsys --- 颜色系统间的转换 --> ( 难度等级: [0.294, 0.2941) || 挂载数据: 无 ) 
│       │   ├── imghdr --- 推测图像类型 --> ( 难度等级: [0.2941, 0.2942) || 挂载数据: 无 ) 
│       │   ├── sndhdr --- 推测声音文件的类型 --> ( 难度等级: [0.2942, 0.2942) || 挂载数据: 无 ) 
│       │   └── ossaudiodev --- Access to OSS-compatible audio devices --> ( 难度等级: [0.2942, 0.2943) || 挂载数据: qa: 1 ) 
│       ├── 国际化 --> ( 难度等级: [0.2943, 0.295) || 挂载数据: 无 ) 
│       │   ├── gettext --- 多语种国际化服务 --> ( 难度等级: [0.2943, 0.2947) || 挂载数据: 无 ) 
│       │   └── locale --- 国际化服务 --> ( 难度等级: [0.2947, 0.295) || 挂载数据: 无 ) 
│       ├── 程序框架 --> ( 难度等级: [0.295, 0.2957) || 挂载数据: 无 ) 
│       │   ├── turtle --- 海龟绘图 --> ( 难度等级: [0.295, 0.2953) || 挂载数据: qa: 6; blog: 3 ) 
│       │   ├── cmd --- 支持面向行的命令解释器 --> ( 难度等级: [0.2953, 0.2955) || 挂载数据: qa: 3 ) 
│       │   └── shlex --- Simple lexical analysis --> ( 难度等级: [0.2955, 0.2957) || 挂载数据: 无 ) 
│       ├── Tk图形用户界面(GUI) --> ( 难度等级: [0.2957, 0.2965) || 挂载数据: 无 ) 
│       │   ├── tkinter --- Tcl/Tk的Python接口 --> ( 难度等级: [0.2957, 0.2958) || 挂载数据: qa: 2 ) 
│       │   ├── tkinter.colorchooser --- 颜色选择对话框 --> ( 难度等级: [0.2958, 0.2959) || 挂载数据: 无 ) 
│       │   ├── tkinter.font --- Tkinter字体封装 --> ( 难度等级: [0.2959, 0.2959) || 挂载数据: 无 ) 
│       │   ├── Tkinter对话框 --> ( 难度等级: [0.2959, 0.296) || 挂载数据: blog: 1 ) 
│       │   ├── tkinter.messagebox --- Tkinter消息提示 --> ( 难度等级: [0.296, 0.2961) || 挂载数据: qa: 2 ) 
│       │   ├── tkinter.scrolledtext --- 滚动文字控件 --> ( 难度等级: [0.2961, 0.2961) || 挂载数据: 无 ) 
│       │   ├── tkinter.dnd --- 拖放操作支持 --> ( 难度等级: [0.2961, 0.2962) || 挂载数据: 无 ) 
│       │   ├── tkinter.ttk --- Tk主题部件 --> ( 难度等级: [0.2962, 0.2963) || 挂载数据: blog: 1 ) 
│       │   ├── tkinter.tix --- Extension widgets for Tk --> ( 难度等级: [0.2963, 0.2963) || 挂载数据: qa: 1 ) 
│       │   ├── IDLE --> ( 难度等级: [0.2963, 0.2964) || 挂载数据: qa: 7 ) 
│       │   └── 其他图形用户界面（GUI）包 --> ( 难度等级: [0.2964, 0.2965) || 挂载数据: 无 ) 
│       ├── 调试和分析 --> ( 难度等级: [0.2965, 0.2972) || 挂载数据: 无 ) 
│       │   ├── 审计事件表 --> ( 难度等级: [0.2965, 0.2965) || 挂载数据: 无 ) 
│       │   ├── bdb --- Debugger framework --> ( 难度等级: [0.2965, 0.2966) || 挂载数据: blog: 1 ) 
│       │   ├── faulthandler --- Dump the Python traceback --> ( 难度等级: [0.2966, 0.2966) || 挂载数据: 无 ) 
│       │   ├── pdb --- Python的调试器 --> ( 难度等级: [0.2966, 0.2967) || 挂载数据: 无 ) 
│       │   ├── Python Profilers分析器 --> ( 难度等级: [0.2967, 0.2968) || 挂载数据: 无 ) 
│       │   ├── timeit --- 测量小代码片段的执行时间 --> ( 难度等级: [0.2968, 0.2968) || 挂载数据: qa: 4 ) 
│       │   ├── trace --- 跟踪Python语句执行 --> ( 难度等级: [0.2968, 0.2969) || 挂载数据: 无 ) 
│       │   ├── tracemalloc --- 跟踪内存分配 --> ( 难度等级: [0.2969, 0.297) || 挂载数据: 无 ) 
│       │   ├── 抛出异常 --> ( 难度等级: [0.297, 0.297) || 挂载数据: 无 ) 
│       │   ├── 取得回溯字符串 --> ( 难度等级: [0.297, 0.2971) || 挂载数据: qa: 1 ) 
│       │   └── Mu的调试器 --> ( 难度等级: [0.2971, 0.2972) || 挂载数据: 无 ) 
│       ├── 软件打包和分发 --> ( 难度等级: [0.2972, 0.2979) || 挂载数据: 无 ) 
│       │   ├── distutils --- 构建和安装Python模块 --> ( 难度等级: [0.2972, 0.2973) || 挂载数据: 无 ) 
│       │   ├── ensurepip --- Bootstrapping the pip installer --> ( 难度等级: [0.2973, 0.2975) || 挂载数据: blog: 2 ) 
│       │   ├── venv --- 创建虚拟环境 --> ( 难度等级: [0.2975, 0.2977) || 挂载数据: blog: 5 ) 
│       │   └── zipapp --- Manage executable Python zip archives --> ( 难度等级: [0.2977, 0.2979) || 挂载数据: 无 ) 
│       ├── Python运行时服务 --> ( 难度等级: [0.2979, 0.2986) || 挂载数据: 无 ) 
│       │   ├── sysconfig --- Provide access to Python's configuration information --> ( 难度等级: [0.2979, 0.2979) || 挂载数据: blog: 3 ) 
│       │   ├── builtins --- 内建对象 --> ( 难度等级: [0.2979, 0.298) || 挂载数据: 无 ) 
│       │   ├── __main__ --- 顶层脚本环境 --> ( 难度等级: [0.298, 0.298) || 挂载数据: 无 ) 
│       │   ├── warnings --- Warning control --> ( 难度等级: [0.298, 0.2981) || 挂载数据: qa: 1 ) 
│       │   ├── dataclasses --- 数据类 --> ( 难度等级: [0.2981, 0.2981) || 挂载数据: 无 ) 
│       │   ├── contextlib --- 为with语句上下文提供的工具 --> ( 难度等级: [0.2981, 0.2982) || 挂载数据: 无 ) 
│       │   ├── abc --- 抽象基类 --> ( 难度等级: [0.2982, 0.2983) || 挂载数据: 无 ) 
│       │   ├── atexit --- 退出处理器 --> ( 难度等级: [0.2983, 0.2983) || 挂载数据: 无 ) 
│       │   ├── traceback --- 打印或检索堆栈回溯 --> ( 难度等级: [0.2983, 0.2984) || 挂载数据: qa: 3 ) 
│       │   ├── __future__ --- Future语句定义 --> ( 难度等级: [0.2984, 0.2984) || 挂载数据: 无 ) 
│       │   ├── gc --- 垃圾回收器接口 --> ( 难度等级: [0.2984, 0.2985) || 挂载数据: 无 ) 
│       │   ├── inspect --- 检查对象 --> ( 难度等级: [0.2985, 0.2985) || 挂载数据: 无 ) 
│       │   └── site —— 指定域的配置钩子 --> ( 难度等级: [0.2985, 0.2986) || 挂载数据: 无 ) 
│       ├── 自定义Python解释器 --> ( 难度等级: [0.2986, 0.2993) || 挂载数据: 无 ) 
│       │   ├── code --- 解释器基类 --> ( 难度等级: [0.2986, 0.2989) || 挂载数据: qa: 2 ) 
│       │   └── codeop --- 编译Python代码 --> ( 难度等级: [0.2989, 0.2993) || 挂载数据: 无 ) 
│       ├── 导入模块 --> ( 难度等级: [0.2993, 0.3) || 挂载数据: 无 ) 
│       │   ├── zipimport --- 从Zip存档中导入模块 --> ( 难度等级: [0.2993, 0.2994) || 挂载数据: 无 ) 
│       │   ├── pkgutil --- 包扩展工具 --> ( 难度等级: [0.2994, 0.2995) || 挂载数据: 无 ) 
│       │   ├── modulefinder --- 查找脚本使用的模块 --> ( 难度等级: [0.2995, 0.2996) || 挂载数据: 无 ) 
│       │   ├── runpy --- Locating and executing Python modules --> ( 难度等级: [0.2996, 0.2998) || 挂载数据: 无 ) 
│       │   ├── importlib --- import的实现 --> ( 难度等级: [0.2998, 0.2999) || 挂载数据: 无 ) 
│       │   └── Using importlib.metadata --> ( 难度等级: [0.2999, 0.3) || 挂载数据: qa: 1 ) 
│       ├── Python语言服务 --> ( 难度等级: [0.3, 0.3007) || 挂载数据: 无 ) 
│       │   ├── parser --- 访问Python解析树 --> ( 难度等级: [0.3, 0.3001) || 挂载数据: 无 ) 
│       │   ├── ast --- 抽象语法树 --> ( 难度等级: [0.3001, 0.3001) || 挂载数据: 无 ) 
│       │   ├── symtable --- Access to the compiler's symbol tables --> ( 难度等级: [0.3001, 0.3002) || 挂载数据: 无 ) 
│       │   ├── symbol --- 与Python解析树一起使用的常量 --> ( 难度等级: [0.3002, 0.3002) || 挂载数据: 无 ) 
│       │   ├── token --- 与Python解析树一起使用的常量 --> ( 难度等级: [0.3002, 0.3003) || 挂载数据: qa: 1 ) 
│       │   ├── keyword --- 检验Python关键字 --> ( 难度等级: [0.3003, 0.3003) || 挂载数据: qa: 1 ) 
│       │   ├── tokenize --- 对Python代码使用的标记解析器 --> ( 难度等级: [0.3003, 0.3004) || 挂载数据: qa: 1 ) 
│       │   ├── tabnanny --- 模糊缩进检测 --> ( 难度等级: [0.3004, 0.3004) || 挂载数据: 无 ) 
│       │   ├── pyclbr --- Python模块浏览器支持 --> ( 难度等级: [0.3004, 0.3005) || 挂载数据: 无 ) 
│       │   ├── py_compile --- 编译Python源文件 --> ( 难度等级: [0.3005, 0.3005) || 挂载数据: 无 ) 
│       │   ├── compileall --- Byte-compile Python libraries --> ( 难度等级: [0.3005, 0.3006) || 挂载数据: qa: 1; blog: 3 ) 
│       │   ├── dis --- Python字节码反汇编器 --> ( 难度等级: [0.3006, 0.3007) || 挂载数据: 无 ) 
│       │   └── pickletools --- pickle开发者工具集 --> ( 难度等级: [0.3007, 0.3007) || 挂载数据: 无 ) 
│       ├── 杂项服务 --> ( 难度等级: [0.3007, 0.3014) || 挂载数据: 无 ) 
│       │   └── formatter --- 通用格式化输出 --> ( 难度等级: [0.3007, 0.3014) || 挂载数据: 无 ) 
│       ├── Windows系统相关模块 --> ( 难度等级: [0.3014, 0.3021) || 挂载数据: 无 ) 
│       │   ├── msilib --- Read and write Microsoft Installer files --> ( 难度等级: [0.3014, 0.3016) || 挂载数据: qa: 4; blog: 1 ) 
│       │   ├── msvcrt --- 来自MS VC++ 运行时的有用例程 --> ( 难度等级: [0.3016, 0.3018) || 挂载数据: 无 ) 
│       │   ├── winreg --- Windows注册表访问 --> ( 难度等级: [0.3018, 0.302) || 挂载数据: qa: 1; blog: 4 ) 
│       │   └── winsound --- Sound-playing interface for Windows --> ( 难度等级: [0.302, 0.3021) || 挂载数据: blog: 5 ) 
│       ├── Unix专有服务 --> ( 难度等级: [0.3021, 0.3028) || 挂载数据: 无 ) 
│       │   ├── posix --- 最常见的POSIX系统调用 --> ( 难度等级: [0.3021, 0.3022) || 挂载数据: 无 ) 
│       │   ├── pwd --- 用户密码数据库 --> ( 难度等级: [0.3022, 0.3022) || 挂载数据: 无 ) 
│       │   ├── spwd --- The shadow password database --> ( 难度等级: [0.3022, 0.3023) || 挂载数据: qa: 1; blog: 1 ) 
│       │   ├── grp --- 组数据库 --> ( 难度等级: [0.3023, 0.3023) || 挂载数据: 无 ) 
│       │   ├── crypt --- Function to check Unix passwords --> ( 难度等级: [0.3023, 0.3024) || 挂载数据: qa: 5; blog: 1 ) 
│       │   ├── termios --- POSIX风格的tty控制 --> ( 难度等级: [0.3024, 0.3025) || 挂载数据: 无 ) 
│       │   ├── tty --- 终端控制功能 --> ( 难度等级: [0.3025, 0.3025) || 挂载数据: 无 ) 
│       │   ├── pty --- 伪终端工具 --> ( 难度等级: [0.3025, 0.3026) || 挂载数据: 无 ) 
│       │   ├── fcntl --- The fcntl and ioctl system calls --> ( 难度等级: [0.3026, 0.3026) || 挂载数据: qa: 1 ) 
│       │   ├── pipes --- 终端管道接口 --> ( 难度等级: [0.3026, 0.3027) || 挂载数据: 无 ) 
│       │   ├── resource --- Resource usage information --> ( 难度等级: [0.3027, 0.3027) || 挂载数据: qa: 5 ) 
│       │   ├── nis --- Sun的NIS (黄页) 接口 --> ( 难度等级: [0.3027, 0.3028) || 挂载数据: blog: 3 ) 
│       │   └── Unix syslog库例程 --> ( 难度等级: [0.3028, 0.3028) || 挂载数据: blog: 2 ) 
│       ├── 被取代的模块 --> ( 难度等级: [0.3028, 0.3035) || 挂载数据: 无 ) 
│       │   ├── optparse --- 解析器的命令行选项 --> ( 难度等级: [0.3028, 0.3032) || 挂载数据: 无 ) 
│       │   └── imp --- Access the import internals --> ( 难度等级: [0.3032, 0.3035) || 挂载数据: blog: 1 ) 
│       ├── 未创建文档的模块 --> ( 难度等级: [0.3035, 0.3043) || 挂载数据: 无 ) 
│       │   └── 平台特定模块 --> ( 难度等级: [0.3035, 0.3043) || 挂载数据: 无 ) 
│       ├── Python基础 --> ( 难度等级: [0.3043, 0.305) || 挂载数据: 无 ) 
│       │   ├── 在交互式环境中输入表达式 --> ( 难度等级: [0.3043, 0.3044) || 挂载数据: 无 ) 
│       │   ├── 字符串连接和复制 --> ( 难度等级: [0.3044, 0.3045) || 挂载数据: 无 ) 
│       │   ├── 在变量中保存值 --> ( 难度等级: [0.3045, 0.3047) || 挂载数据: qa: 1 ) 
│       │   │   └── 变量名 --> ( 难度等级: [0.3045, 0.3047) || 挂载数据: qa: 2 ) 
│       │   ├── 第一个程序 --> ( 难度等级: [0.3047, 0.3048) || 挂载数据: qa: 8 ) 
│       │   └── 程序剖析 --> ( 难度等级: [0.3048, 0.305) || 挂载数据: 无 ) 
│       │       ├── print函数 --> ( 难度等级: [0.3048, 0.3049) || 挂载数据: qa: 3 ) 
│       │       ├── input函数 --> ( 难度等级: [0.3049, 0.3049) || 挂载数据: qa: 1; blog: 1 ) 
│       │       ├── 输出用户的名字 --> ( 难度等级: [0.3049, 0.3049) || 挂载数据: qa: 1 ) 
│       │       └── len函数 --> ( 难度等级: [0.3049, 0.305) || 挂载数据: qa: 1 ) 
│       ├── 高级特性 --> ( 难度等级: [0.305, 0.3057) || 挂载数据: 无 ) 
│       │   ├── 切片 --> ( 难度等级: [0.305, 0.3052) || 挂载数据: 无 ) 
│       │   ├── 迭代 --> ( 难度等级: [0.3052, 0.3054) || 挂载数据: 无 ) 
│       │   └── 列表生成式 --> ( 难度等级: [0.3054, 0.3057) || 挂载数据: 无 ) 
│       ├── 函数式编程 --> ( 难度等级: [0.3057, 0.3064) || 挂载数据: 无 ) 
│       │   ├── 高阶函数 --> ( 难度等级: [0.3057, 0.3059) || 挂载数据: 无 ) 
│       │   │   ├── map/reduce --> ( 难度等级: [0.3057, 0.3058) || 挂载数据: qa: 6 ) 
│       │   │   └── filter --> ( 难度等级: [0.3058, 0.3059) || 挂载数据: blog: 2 ) 
│       │   ├── 返回函数 --> ( 难度等级: [0.3059, 0.306) || 挂载数据: qa: 1 ) 
│       │   ├── 匿名函数 --> ( 难度等级: [0.306, 0.3062) || 挂载数据: 无 ) 
│       │   └── 偏函数 --> ( 难度等级: [0.3062, 0.3064) || 挂载数据: 无 ) 
│       ├── 面向对象高级编程 --> ( 难度等级: [0.3064, 0.3071) || 挂载数据: 无 ) 
│       │   ├── 使用__slots__ --> ( 难度等级: [0.3064, 0.3066) || 挂载数据: blog: 1 ) 
│       │   ├── 使用@property --> ( 难度等级: [0.3066, 0.3067) || 挂载数据: qa: 2 ) 
│       │   ├── 定制类 --> ( 难度等级: [0.3067, 0.3069) || 挂载数据: 无 ) 
│       │   └── 使用枚举类 --> ( 难度等级: [0.3069, 0.3071) || 挂载数据: 无 ) 
│       ├── IO编程 --> ( 难度等级: [0.3071, 0.3078) || 挂载数据: 无 ) 
│       │   ├── StringIO和BytesIO --> ( 难度等级: [0.3071, 0.3073) || 挂载数据: 无 ) 
│       │   ├── 操作文件和目录 --> ( 难度等级: [0.3073, 0.3076) || 挂载数据: 无 ) 
│       │   └── 序列化 --> ( 难度等级: [0.3076, 0.3078) || 挂载数据: 无 ) 
│       ├── 进程和线程 --> ( 难度等级: [0.3078, 0.3085) || 挂载数据: 无 ) 
│       │   ├── 多进程 --> ( 难度等级: [0.3078, 0.308) || 挂载数据: 无 ) 
│       │   ├── ThreadLocal --> ( 难度等级: [0.308, 0.3082) || 挂载数据: 无 ) 
│       │   ├── 进程vs. 线程 --> ( 难度等级: [0.3082, 0.3083) || 挂载数据: qa: 5; blog: 1 ) 
│       │   └── 分布式进程 --> ( 难度等级: [0.3083, 0.3085) || 挂载数据: 无 ) 
│       ├── 正则表达式 --> ( 难度等级: [0.3085, 0.3092) || 挂载数据: qa: 6 ) 
│       ├── 常用内建模块 --> ( 难度等级: [0.3092, 0.3099) || 挂载数据: 无 ) 
│       │   ├── collections --> ( 难度等级: [0.3092, 0.3093) || 挂载数据: 无 ) 
│       │   ├── base64 --> ( 难度等级: [0.3093, 0.3094) || 挂载数据: 无 ) 
│       │   ├── struct --> ( 难度等级: [0.3094, 0.3095) || 挂载数据: blog: 14 ) 
│       │   ├── hashlib --> ( 难度等级: [0.3095, 0.3095) || 挂载数据: 无 ) 
│       │   ├── hmac --> ( 难度等级: [0.3095, 0.3096) || 挂载数据: 无 ) 
│       │   ├── itertools --> ( 难度等级: [0.3096, 0.3097) || 挂载数据: 无 ) 
│       │   ├── contextlib --> ( 难度等级: [0.3097, 0.3098) || 挂载数据: 无 ) 
│       │   ├── XML --> ( 难度等级: [0.3098, 0.3099) || 挂载数据: 无 ) 
│       │   └── HTMLParser --> ( 难度等级: [0.3099, 0.3099) || 挂载数据: 无 ) 
│       ├── virtualenv --> ( 难度等级: [0.3099, 0.3106) || 挂载数据: blog: 104 ) 
│       ├── 图形界面 --> ( 难度等级: [0.3106, 0.3113) || 挂载数据: 无 ) 
│       │   └── 海龟绘图 --> ( 难度等级: [0.3106, 0.3113) || 挂载数据: 无 ) 
│       ├── 网络编程 --> ( 难度等级: [0.3113, 0.3121) || 挂载数据: 无 ) 
│       │   ├── TCP/IP简介 --> ( 难度等级: [0.3113, 0.3115) || 挂载数据: 无 ) 
│       │   ├── TCP编程 --> ( 难度等级: [0.3115, 0.3116) || 挂载数据: 无 ) 
│       │   ├── UDP编程 --> ( 难度等级: [0.3116, 0.3117) || 挂载数据: 无 ) 
│       │   ├── 几个网络模块 --> ( 难度等级: [0.3117, 0.3118) || 挂载数据: 无 ) 
│       │   │   ├── 模块socket --> ( 难度等级: [0.3117, 0.3118) || 挂载数据: qa: 1; blog: 5 ) 
│       │   │   └── 模块urllib和urllib2 --> ( 难度等级: [0.3118, 0.3118) || 挂载数据: qa: 1 ) 
│       │   ├── SocketServer及相关的类 --> ( 难度等级: [0.3118, 0.3119) || 挂载数据: 无 ) 
│       │   └── Twisted --> ( 难度等级: [0.3119, 0.3121) || 挂载数据: 无 ) 
│       │       ├── 下载并安装Twisted --> ( 难度等级: [0.3119, 0.312) || 挂载数据: qa: 3; blog: 2 ) 
│       │       └── 编写Twisted服务器 --> ( 难度等级: [0.312, 0.3121) || 挂载数据: 无 ) 
│       ├── 电子邮件 --> ( 难度等级: [0.3121, 0.3128) || 挂载数据: 无 ) 
│       │   ├── SMTP发送邮件 --> ( 难度等级: [0.3121, 0.3124) || 挂载数据: qa: 2; blog: 1 ) 
│       │   └── POP3收取邮件 --> ( 难度等级: [0.3124, 0.3128) || 挂载数据: 无 ) 
│       ├── 访问数据库 --> ( 难度等级: [0.3128, 0.3135) || 挂载数据: 无 ) 
│       │   ├── 使用SQLite --> ( 难度等级: [0.3128, 0.313) || 挂载数据: 无 ) 
│       │   ├── 使用MySQL --> ( 难度等级: [0.313, 0.3132) || 挂载数据: 无 ) 
│       │   └── 使用SQLAlchemy --> ( 难度等级: [0.3132, 0.3135) || 挂载数据: qa: 1 ) 
│       ├── Web开发 --> ( 难度等级: [0.3135, 0.3142) || 挂载数据: 无 ) 
│       │   ├── HTTP协议简介 --> ( 难度等级: [0.3135, 0.3137) || 挂载数据: 无 ) 
│       │   ├── HTML简介 --> ( 难度等级: [0.3137, 0.3138) || 挂载数据: 无 ) 
│       │   ├── WSGI接口 --> ( 难度等级: [0.3138, 0.314) || 挂载数据: 无 ) 
│       │   └── 使用Web框架 --> ( 难度等级: [0.314, 0.3142) || 挂载数据: 无 ) 
│       ├── 异步IO --> ( 难度等级: [0.3142, 0.3149) || 挂载数据: 无 ) 
│       │   ├── asyncio --> ( 难度等级: [0.3142, 0.3144) || 挂载数据: 无 ) 
│       │   ├── async/await --> ( 难度等级: [0.3144, 0.3147) || 挂载数据: 无 ) 
│       │   └── aiohttp --> ( 难度等级: [0.3147, 0.3149) || 挂载数据: 无 ) 
│       ├── 使用MicroPython --> ( 难度等级: [0.3149, 0.3156) || 挂载数据: 无 ) 
│       │   ├── 搭建开发环境 --> ( 难度等级: [0.3149, 0.3151) || 挂载数据: 无 ) 
│       │   ├── 控制小车 --> ( 难度等级: [0.3151, 0.3152) || 挂载数据: 无 ) 
│       │   ├── 遥控小车 --> ( 难度等级: [0.3152, 0.3154) || 挂载数据: 无 ) 
│       │   └── 遥控转向 --> ( 难度等级: [0.3154, 0.3156) || 挂载数据: blog: 1 ) 
│       ├── 当索引行不通时 --> ( 难度等级: [0.3156, 0.3163) || 挂载数据: 无 ) 
│       │   └── 字典的用途 --> ( 难度等级: [0.3156, 0.3163) || 挂载数据: 无 ) 
│       ├── 抽象 --> ( 难度等级: [0.3163, 0.317) || 挂载数据: 无 ) 
│       │   ├── 懒惰是一种美德 --> ( 难度等级: [0.3163, 0.3165) || 挂载数据: 无 ) 
│       │   ├── 自定义函数 --> ( 难度等级: [0.3165, 0.3167) || 挂载数据: qa: 1 ) 
│       │   │   └── 给函数编写文档 --> ( 难度等级: [0.3165, 0.3167) || 挂载数据: qa: 8 ) 
│       │   ├── 参数魔法 --> ( 难度等级: [0.3167, 0.3168) || 挂载数据: 无 ) 
│       │   │   ├── 值从哪里来 --> ( 难度等级: [0.3167, 0.3167) || 挂载数据: qa: 1 ) 
│       │   │   ├── 我能修改参数吗 --> ( 难度等级: [0.3167, 0.3168) || 挂载数据: qa: 1 ) 
│       │   │   ├── 收集参数 --> ( 难度等级: [0.3168, 0.3168) || 挂载数据: 无 ) 
│       │   │   └── 分配参数 --> ( 难度等级: [0.3168, 0.3168) || 挂载数据: qa: 1 ) 
│       │   └── 递归 --> ( 难度等级: [0.3168, 0.317) || 挂载数据: qa: 3 ) 
│       │       ├── 两个经典案例：阶乘和幂 --> ( 难度等级: [0.3168, 0.3169) || 挂载数据: qa: 1 ) 
│       │       └── 另一个经典案例：二分查找 --> ( 难度等级: [0.3169, 0.317) || 挂载数据: qa: 1 ) 
│       ├── 再谈抽象 --> ( 难度等级: [0.317, 0.3177) || 挂载数据: 无 ) 
│       │   ├── 对象魔法 --> ( 难度等级: [0.317, 0.3174) || 挂载数据: 无 ) 
│       │   └── 关于面向对象设计的一些思考 --> ( 难度等级: [0.3174, 0.3177) || 挂载数据: 无 ) 
│       ├── 开箱即用 --> ( 难度等级: [0.3177, 0.3184) || 挂载数据: 无 ) 
│       │   └── 探索模块 --> ( 难度等级: [0.3177, 0.3184) || 挂载数据: 无 ) 
│       │       ├── 模块包含什么 --> ( 难度等级: [0.3177, 0.3179) || 挂载数据: 无 ) 
│       │       ├── 使用help获取帮助 --> ( 难度等级: [0.3179, 0.3181) || 挂载数据: qa: 2 ) 
│       │       ├── 文档 --> ( 难度等级: [0.3181, 0.3183) || 挂载数据: 无 ) 
│       │       └── 使用源代码 --> ( 难度等级: [0.3183, 0.3184) || 挂载数据: 无 ) 
│       ├── 图形用户界面 --> ( 难度等级: [0.3184, 0.3191) || 挂载数据: 无 ) 
│       │   ├── 创建GUI示例应用程序 --> ( 难度等级: [0.3184, 0.3188) || 挂载数据: 无 ) 
│       │   │   ├── 初探 --> ( 难度等级: [0.3184, 0.3185) || 挂载数据: 无 ) 
│       │   │   ├── 布局 --> ( 难度等级: [0.3185, 0.3186) || 挂载数据: 无 ) 
│       │   │   ├── 事件处理 --> ( 难度等级: [0.3186, 0.3187) || 挂载数据: 无 ) 
│       │   │   └── 最终的程序 --> ( 难度等级: [0.3187, 0.3188) || 挂载数据: qa: 1 ) 
│       │   └── 使用其他GUI工具包 --> ( 难度等级: [0.3188, 0.3191) || 挂载数据: 无 ) 
│       ├── 数据库支持 --> ( 难度等级: [0.3191, 0.3199) || 挂载数据: 无 ) 
│       │   └── Python数据库API --> ( 难度等级: [0.3191, 0.3199) || 挂载数据: 无 ) 
│       │       ├── 全局变量 --> ( 难度等级: [0.3191, 0.3195) || 挂载数据: qa: 2 ) 
│       │       └── 连接和游标 --> ( 难度等级: [0.3195, 0.3199) || 挂载数据: 无 ) 
│       │           ├── 使用SocketServer实现分叉和线程化 --> ( 难度等级: [0.3195, 0.3197) || 挂载数据: 无 ) 
│       │           └── 使用select和poll实现异步I/O --> ( 难度等级: [0.3197, 0.3199) || 挂载数据: qa: 1 ) 
│       ├── Python和Web --> ( 难度等级: [0.3199, 0.3206) || 挂载数据: 无 ) 
│       │   ├── 屏幕抓取 --> ( 难度等级: [0.3199, 0.3201) || 挂载数据: qa: 1 ) 
│       │   │   ├── Tidy和XHTML解析 --> ( 难度等级: [0.3199, 0.32) || 挂载数据: qa: 1; blog: 1 ) 
│       │   │   └── Beautiful Soup --> ( 难度等级: [0.32, 0.3201) || 挂载数据: 无 ) 
│       │   ├── 使用CGI创建动态网页 --> ( 难度等级: [0.3201, 0.3203) || 挂载数据: 无 ) 
│       │   │   ├── 第一步：准备Web服务器 --> ( 难度等级: [0.3201, 0.3201) || 挂载数据: 无 ) 
│       │   │   ├── 第二步：添加!#行 --> ( 难度等级: [0.3201, 0.3202) || 挂载数据: qa: 1 ) 
│       │   │   ├── 第三步：设置文件权限 --> ( 难度等级: [0.3202, 0.3202) || 挂载数据: 无 ) 
│       │   │   ├── CGI安全风险 --> ( 难度等级: [0.3202, 0.3202) || 挂载数据: 无 ) 
│       │   │   ├── 简单的CGI脚本 --> ( 难度等级: [0.3202, 0.3202) || 挂载数据: 无 ) 
│       │   │   ├── 使用cgitb进行调试 --> ( 难度等级: [0.3202, 0.3203) || 挂载数据: qa: 1 ) 
│       │   │   ├── 使用模块cgi --> ( 难度等级: [0.3203, 0.3203) || 挂载数据: 无 ) 
│       │   │   └── 简单的表单 --> ( 难度等级: [0.3203, 0.3203) || 挂载数据: 无 ) 
│       │   └── Web服务：更高级的抓取 --> ( 难度等级: [0.3203, 0.3206) || 挂载数据: 无 ) 
│       │       ├── RSS和相关内容 --> ( 难度等级: [0.3203, 0.3204) || 挂载数据: 无 ) 
│       │       ├── 使用XML-RPC进行远程过程调用 --> ( 难度等级: [0.3204, 0.3205) || 挂载数据: 无 ) 
│       │       └── SOAP --> ( 难度等级: [0.3205, 0.3206) || 挂载数据: blog: 1 ) 
│       ├── 测试基础 --> ( 难度等级: [0.3206, 0.3213) || 挂载数据: qa: 2 ) 
│       │   ├── 先测试再编码 --> ( 难度等级: [0.3206, 0.3208) || 挂载数据: 无 ) 
│       │   │   ├── 准确的需求说明 --> ( 难度等级: [0.3206, 0.3206) || 挂载数据: 无 ) 
│       │   │   ├── 做好应对变化的准备 --> ( 难度等级: [0.3206, 0.3207) || 挂载数据: qa: 1 ) 
│       │   │   └── 测试四步曲 --> ( 难度等级: [0.3207, 0.3208) || 挂载数据: 无 ) 
│       │   ├── 测试工具 --> ( 难度等级: [0.3208, 0.321) || 挂载数据: 无 ) 
│       │   │   ├── doctest --> ( 难度等级: [0.3208, 0.3209) || 挂载数据: blog: 2 ) 
│       │   │   └── unittest --> ( 难度等级: [0.3209, 0.321) || 挂载数据: qa: 2; blog: 147 ) 
│       │   └── 超越单元测试 --> ( 难度等级: [0.321, 0.3213) || 挂载数据: 无 ) 
│       │       ├── 使用PyChecker和PyLint检查源代码 --> ( 难度等级: [0.321, 0.3212) || 挂载数据: 无 ) 
│       │       └── 性能分析 --> ( 难度等级: [0.3212, 0.3213) || 挂载数据: 无 ) 
│       ├── 扩展Python --> ( 难度等级: [0.3213, 0.322) || 挂载数据: 无 ) 
│       │   ├── 鱼和熊掌兼得 --> ( 难度等级: [0.3213, 0.3215) || 挂载数据: 无 ) 
│       │   ├── 简单易行的方式：Jython和IronPython --> ( 难度等级: [0.3215, 0.3217) || 挂载数据: qa: 1; blog: 110 ) 
│       │   └── 编写C语言扩展 --> ( 难度等级: [0.3217, 0.322) || 挂载数据: 无 ) 
│       │       ├── SWIG --> ( 难度等级: [0.3217, 0.3219) || 挂载数据: 无 ) 
│       │       └── 手工编写扩展 --> ( 难度等级: [0.3219, 0.322) || 挂载数据: 无 ) 
│       ├── 程序打包 --> ( 难度等级: [0.322, 0.3227) || 挂载数据: 无 ) 
│       │   ├── Setuptools基础 --> ( 难度等级: [0.322, 0.3222) || 挂载数据: blog: 1 ) 
│       │   ├── 打包 --> ( 难度等级: [0.3222, 0.3223) || 挂载数据: qa: 2 ) 
│       │   ├── 编译扩展 --> ( 难度等级: [0.3223, 0.3225) || 挂载数据: 无 ) 
│       │   └── 使用py2exe创建可执行程序 --> ( 难度等级: [0.3225, 0.3227) || 挂载数据: 无 ) 
│       ├── 趣味编程 --> ( 难度等级: [0.3227, 0.3234) || 挂载数据: 无 ) 
│       │   ├── 为何要有趣 --> ( 难度等级: [0.3227, 0.3228) || 挂载数据: 无 ) 
│       │   ├── 编程柔术 --> ( 难度等级: [0.3228, 0.323) || 挂载数据: 无 ) 
│       │   ├── 原型设计 --> ( 难度等级: [0.323, 0.3231) || 挂载数据: qa: 3 ) 
│       │   ├── 如果你已不胜其烦 --> ( 难度等级: [0.3231, 0.3233) || 挂载数据: 无 ) 
│       │   └── 如果你想深入学习 --> ( 难度等级: [0.3233, 0.3234) || 挂载数据: qa: 23 ) 
│       ├── Python编程基础 --> ( 难度等级: [0.3234, 0.3241) || 挂载数据: qa: 1 ) 
│       │   ├── 控制流 --> ( 难度等级: [0.3234, 0.3238) || 挂载数据: 无 ) 
│       │   │   ├── 布尔值 --> ( 难度等级: [0.3234, 0.3234) || 挂载数据: qa: 1 ) 
│       │   │   ├── 比较操作符 --> ( 难度等级: [0.3234, 0.3235) || 挂载数据: 无 ) 
│       │   │   ├── 布尔操作符 --> ( 难度等级: [0.3235, 0.3235) || 挂载数据: 无 ) 
│       │   │   │   ├── 二元布尔操作符 --> ( 难度等级: [0.3235, 0.3235) || 挂载数据: 无 ) 
│       │   │   │   └── not操作符 --> ( 难度等级: [0.3235, 0.3235) || 挂载数据: qa: 26; blog: 6 ) 
│       │   │   ├── 混合布尔和比较操作符 --> ( 难度等级: [0.3235, 0.3236) || 挂载数据: 无 ) 
│       │   │   ├── 控制流的元素 --> ( 难度等级: [0.3236, 0.3236) || 挂载数据: 无 ) 
│       │   │   │   └── 代码块 --> ( 难度等级: [0.3236, 0.3236) || 挂载数据: 无 ) 
│       │   │   ├── 程序执行 --> ( 难度等级: [0.3236, 0.3237) || 挂载数据: 无 ) 
│       │   │   ├── 控制流语句 --> ( 难度等级: [0.3237, 0.3237) || 挂载数据: 无 ) 
│       │   │   │   ├── else语句 --> ( 难度等级: [0.3237, 0.3237) || 挂载数据: qa: 3 ) 
│       │   │   │   ├── elif语句 --> ( 难度等级: [0.3237, 0.3237) || 挂载数据: qa: 1 ) 
│       │   │   │   ├── 恼人的循环 --> ( 难度等级: [0.3237, 0.3237) || 挂载数据: 无 ) 
│       │   │   │   └── 等价的while循环 --> ( 难度等级: [0.3237, 0.3237) || 挂载数据: qa: 5 ) 
│       │   │   └── 用sys.exit函数提前结束程序 --> ( 难度等级: [0.3237, 0.3238) || 挂载数据: qa: 1 ) 
│       │   └── 字符串操作 --> ( 难度等级: [0.3238, 0.3241) || 挂载数据: 无 ) 
│       │       ├── 将字符串放入其他字符串 --> ( 难度等级: [0.3238, 0.3238) || 挂载数据: qa: 2 ) 
│       │       ├── 有用的字符串方法 --> ( 难度等级: [0.3238, 0.3238) || 挂载数据: 无 ) 
│       │       ├── 使用ord和chr函数的字符的数值 --> ( 难度等级: [0.3238, 0.3239) || 挂载数据: 无 ) 
│       │       ├── 用pyperclip模块复制粘贴字符串 --> ( 难度等级: [0.3239, 0.3239) || 挂载数据: qa: 1 ) 
│       │       ├── 计算字符串的长度 --> ( 难度等级: [0.3239, 0.3239) || 挂载数据: qa: 3 ) 
│       │       ├── 截取字符串 --> ( 难度等级: [0.3239, 0.324) || 挂载数据: qa: 3 ) 
│       │       ├── 分割、合并字符串 --> ( 难度等级: [0.324, 0.324) || 挂载数据: 无 ) 
│       │       ├── 检索字符串 --> ( 难度等级: [0.324, 0.324) || 挂载数据: 无 ) 
│       │       ├── 字母的大小写转换 --> ( 难度等级: [0.324, 0.324) || 挂载数据: qa: 3 ) 
│       │       ├── 去除字符串中的空格和 --> ( 难度等级: [0.324, 0.3241) || 挂载数据: qa: 2 ) 
│       │       └── 格式化字符串 --> ( 难度等级: [0.3241, 0.3241) || 挂载数据: 无 ) 
│       ├── 自动化任务 --> ( 难度等级: [0.3241, 0.3248) || 挂载数据: 无 ) 
│       │   ├── 输入验证 --> ( 难度等级: [0.3241, 0.3242) || 挂载数据: 无 ) 
│       │   │   └── PyInputPlus模块 --> ( 难度等级: [0.3241, 0.3242) || 挂载数据: 无 ) 
│       │   │       ├── 关键字参数min、max、greaterThan和lessThan --> ( 难度等级: [0.3241, 0.3241) || 挂载数据: 无 ) 
│       │   │       ├── 关键字参数blank --> ( 难度等级: [0.3241, 0.3241) || 挂载数据: 无 ) 
│       │   │       ├── 关键字参数limit、timeout和default --> ( 难度等级: [0.3241, 0.3242) || 挂载数据: 无 ) 
│       │   │       ├── 关键字参数allowRegexes和blockRegexes --> ( 难度等级: [0.3242, 0.3242) || 挂载数据: 无 ) 
│       │   │       └── 将自定义验证函数传递给inputCustom --> ( 难度等级: [0.3242, 0.3242) || 挂载数据: 无 ) 
│       │   ├── 组织文件 --> ( 难度等级: [0.3242, 0.3243) || 挂载数据: 无 ) 
│       │   │   ├── shutil模块 --> ( 难度等级: [0.3242, 0.3242) || 挂载数据: 无 ) 
│       │   │   ├── 遍历目录树 --> ( 难度等级: [0.3242, 0.3242) || 挂载数据: 无 ) 
│       │   │   └── 用zipfile模块压缩文件 --> ( 难度等级: [0.3242, 0.3243) || 挂载数据: 无 ) 
│       │   ├── 从Web抓取信息 --> ( 难度等级: [0.3243, 0.3243) || 挂载数据: qa: 1 ) 
│       │   │   ├── 用requests模块从Web下载文件 --> ( 难度等级: [0.3243, 0.3243) || 挂载数据: qa: 1 ) 
│       │   │   ├── 将下载的文件保存到硬盘 --> ( 难度等级: [0.3243, 0.3243) || 挂载数据: 无 ) 
│       │   │   ├── HTML --> ( 难度等级: [0.3243, 0.3243) || 挂载数据: qa: 10; blog: 3 ) 
│       │   │   ├── 用bs4模块解析HTML --> ( 难度等级: [0.3243, 0.3243) || 挂载数据: qa: 1 ) 
│       │   │   └── 用selenium模块控制浏览器 --> ( 难度等级: [0.3243, 0.3243) || 挂载数据: 无 ) 
│       │   ├── 处理Excel电子表格 --> ( 难度等级: [0.3243, 0.3244) || 挂载数据: 无 ) 
│       │   │   ├── Excel文档 --> ( 难度等级: [0.3243, 0.3243) || 挂载数据: qa: 30; blog: 1 ) 
│       │   │   ├── 安装openpyxl模块 --> ( 难度等级: [0.3243, 0.3243) || 挂载数据: 无 ) 
│       │   │   ├── 读取Excel文档 --> ( 难度等级: [0.3243, 0.3244) || 挂载数据: qa: 6; blog: 1 ) 
│       │   │   ├── 写入Excel文档 --> ( 难度等级: [0.3244, 0.3244) || 挂载数据: qa: 6; blog: 1 ) 
│       │   │   ├── 设置单元格的字体风格 --> ( 难度等级: [0.3244, 0.3244) || 挂载数据: 无 ) 
│       │   │   ├── Font对象 --> ( 难度等级: [0.3244, 0.3244) || 挂载数据: 无 ) 
│       │   │   ├── 公式 --> ( 难度等级: [0.3244, 0.3244) || 挂载数据: qa: 1 ) 
│       │   │   └── 调整行和列 --> ( 难度等级: [0.3244, 0.3244) || 挂载数据: 无 ) 
│       │   ├── 处理Google电子表格 --> ( 难度等级: [0.3244, 0.3245) || 挂载数据: 无 ) 
│       │   │   ├── 安装和设置EZSheets --> ( 难度等级: [0.3244, 0.3244) || 挂载数据: 无 ) 
│       │   │   ├── Spreadsheet对象 --> ( 难度等级: [0.3244, 0.3244) || 挂载数据: 无 ) 
│       │   │   ├── 工作表对象 --> ( 难度等级: [0.3244, 0.3245) || 挂载数据: 无 ) 
│       │   │   └── 利用Google Sheets配额 --> ( 难度等级: [0.3245, 0.3245) || 挂载数据: qa: 1; blog: 14 ) 
│       │   ├── 处理PDF和Word文档 --> ( 难度等级: [0.3245, 0.3245) || 挂载数据: 无 ) 
│       │   │   ├── PDF文档 --> ( 难度等级: [0.3245, 0.3245) || 挂载数据: qa: 3; blog: 6 ) 
│       │   │   ├── Word文档 --> ( 难度等级: [0.3245, 0.3245) || 挂载数据: qa: 6; blog: 1 ) 
│       │   │   └── 从Word文档中创建PDF --> ( 难度等级: [0.3245, 0.3245) || 挂载数据: blog: 2 ) 
│       │   ├── 处理CSV文件和JSON数据 --> ( 难度等级: [0.3245, 0.3246) || 挂载数据: 无 ) 
│       │   │   ├── csv模块 --> ( 难度等级: [0.3245, 0.3246) || 挂载数据: qa: 12; blog: 3 ) 
│       │   │   └── json模块 --> ( 难度等级: [0.3246, 0.3246) || 挂载数据: qa: 27; blog: 6 ) 
│       │   ├── 发送电子邮件和短信 --> ( 难度等级: [0.3246, 0.3247) || 挂载数据: 无 ) 
│       │   │   ├── 使用Gmail API发送和接收电子邮件 --> ( 难度等级: [0.3246, 0.3246) || 挂载数据: 无 ) 
│       │   │   ├── SMTP --> ( 难度等级: [0.3246, 0.3246) || 挂载数据: 无 ) 
│       │   │   ├── 发送电子邮件 --> ( 难度等级: [0.3246, 0.3246) || 挂载数据: qa: 1 ) 
│       │   │   ├── IMAP --> ( 难度等级: [0.3246, 0.3247) || 挂载数据: 无 ) 
│       │   │   ├── 用IMAP获取和删除电子邮件 --> ( 难度等级: [0.3247, 0.3247) || 挂载数据: 无 ) 
│       │   │   ├── 使用短信电子邮件网关发送短信 --> ( 难度等级: [0.3247, 0.3247) || 挂载数据: 无 ) 
│       │   │   └── 用Twilio发送短信 --> ( 难度等级: [0.3247, 0.3247) || 挂载数据: 无 ) 
│       │   ├── 操作图像 --> ( 难度等级: [0.3247, 0.3248) || 挂载数据: 无 ) 
│       │   │   ├── 计算机图像基础 --> ( 难度等级: [0.3247, 0.3247) || 挂载数据: 无 ) 
│       │   │   ├── 用pillow操作图像 --> ( 难度等级: [0.3247, 0.3247) || 挂载数据: blog: 1 ) 
│       │   │   └── 在图像上绘画 --> ( 难度等级: [0.3247, 0.3248) || 挂载数据: qa: 3 ) 
│       │   │       ├── 绘制形状 --> ( 难度等级: [0.3247, 0.3247) || 挂载数据: 无 ) 
│       │   │       └── 绘制文本 --> ( 难度等级: [0.3247, 0.3248) || 挂载数据: 无 ) 
│       │   └── 用GUI自动化控制键盘和鼠标 --> ( 难度等级: [0.3248, 0.3248) || 挂载数据: 无 ) 
│       │       ├── 安装pyautogui模块 --> ( 难度等级: [0.3248, 0.3248) || 挂载数据: 无 ) 
│       │       ├── 在macOS上设置无障碍应用程序 --> ( 难度等级: [0.3248, 0.3248) || 挂载数据: 无 ) 
│       │       ├── 走对路 --> ( 难度等级: [0.3248, 0.3248) || 挂载数据: 无 ) 
│       │       ├── 控制鼠标指针移动 --> ( 难度等级: [0.3248, 0.3248) || 挂载数据: 无 ) 
│       │       ├── 控制鼠标交互 --> ( 难度等级: [0.3248, 0.3248) || 挂载数据: qa: 2 ) 
│       │       ├── 规划鼠标运动 --> ( 难度等级: [0.3248, 0.3248) || 挂载数据: 无 ) 
│       │       ├── 处理屏幕 --> ( 难度等级: [0.3248, 0.3248) || 挂载数据: qa: 2 ) 
│       │       ├── 图像识别 --> ( 难度等级: [0.3248, 0.3248) || 挂载数据: qa: 1 ) 
│       │       ├── 获取窗口信息 --> ( 难度等级: [0.3248, 0.3248) || 挂载数据: qa: 4 ) 
│       │       ├── 控制键盘 --> ( 难度等级: [0.3248, 0.3248) || 挂载数据: qa: 4 ) 
│       │       ├── 设置GUI自动化脚本 --> ( 难度等级: [0.3248, 0.3248) || 挂载数据: qa: 2 ) 
│       │       ├── 复习PyAutoGUI的函数 --> ( 难度等级: [0.3248, 0.3248) || 挂载数据: 无 ) 
│       │       └── 显示消息框 --> ( 难度等级: [0.3248, 0.3248) || 挂载数据: qa: 1 ) 
│       ├── 序幕 --> ( 难度等级: [0.3248, 0.3255) || 挂载数据: 无 ) 
│       │   └── Python数据模型 --> ( 难度等级: [0.3248, 0.3255) || 挂载数据: 无 ) 
│       │       ├── 一摞Python风格的纸牌 --> ( 难度等级: [0.3248, 0.3252) || 挂载数据: 无 ) 
│       │       └── 特殊方法一览 --> ( 难度等级: [0.3252, 0.3255) || 挂载数据: 无 ) 
│       ├── 把函数视作对象 --> ( 难度等级: [0.3255, 0.3262) || 挂载数据: 无 ) 
│       │   └── 使用一等函数实现设计模式 --> ( 难度等级: [0.3255, 0.3262) || 挂载数据: 无 ) 
│       │       ├── 案例分析：重构“策略”模式 --> ( 难度等级: [0.3255, 0.3259) || 挂载数据: 无 ) 
│       │       └── “命令”模式 --> ( 难度等级: [0.3259, 0.3262) || 挂载数据: qa: 2 ) 
│       ├── 面向对象惯用法 --> ( 难度等级: [0.3262, 0.327) || 挂载数据: qa: 1 ) 
│       │   ├── 对象引用、可变性和垃圾回收 --> ( 难度等级: [0.3262, 0.3264) || 挂载数据: 无 ) 
│       │   │   ├── 变量不是盒子 --> ( 难度等级: [0.3262, 0.3263) || 挂载数据: 无 ) 
│       │   │   ├── 标识、相等性和别名 --> ( 难度等级: [0.3263, 0.3263) || 挂载数据: 无 ) 
│       │   │   ├── 默认做浅复制 --> ( 难度等级: [0.3263, 0.3263) || 挂载数据: 无 ) 
│       │   │   ├── 函数的参数作为引用时 --> ( 难度等级: [0.3263, 0.3264) || 挂载数据: qa: 2 ) 
│       │   │   ├── del和垃圾回收 --> ( 难度等级: [0.3264, 0.3264) || 挂载数据: 无 ) 
│       │   │   └── Python对不可变类型施加的把戏 --> ( 难度等级: [0.3264, 0.3264) || 挂载数据: 无 ) 
│       │   ├── 符合Python风格的对象 --> ( 难度等级: [0.3264, 0.3266) || 挂载数据: qa: 1 ) 
│       │   │   ├── 对象表示形式 --> ( 难度等级: [0.3264, 0.3264) || 挂载数据: qa: 1 ) 
│       │   │   ├── 再谈向量类 --> ( 难度等级: [0.3264, 0.3265) || 挂载数据: 无 ) 
│       │   │   ├── 备选构造方法 --> ( 难度等级: [0.3265, 0.3265) || 挂载数据: 无 ) 
│       │   │   ├── classmethod与staticmethod --> ( 难度等级: [0.3265, 0.3265) || 挂载数据: 无 ) 
│       │   │   ├── 格式化显示 --> ( 难度等级: [0.3265, 0.3265) || 挂载数据: 无 ) 
│       │   │   ├── 可散列的Vector2d --> ( 难度等级: [0.3265, 0.3265) || 挂载数据: 无 ) 
│       │   │   ├── Python的私有属性和“受保护的”属性 --> ( 难度等级: [0.3265, 0.3266) || 挂载数据: 无 ) 
│       │   │   ├── 使用__slots__类属性节省空间 --> ( 难度等级: [0.3266, 0.3266) || 挂载数据: 无 ) 
│       │   │   └── 覆盖类属性 --> ( 难度等级: [0.3266, 0.3266) || 挂载数据: 无 ) 
│       │   ├── 继承的优缺点 --> ( 难度等级: [0.3266, 0.3268) || 挂载数据: 无 ) 
│       │   │   ├── 子类化内置类型很麻烦 --> ( 难度等级: [0.3266, 0.3267) || 挂载数据: 无 ) 
│       │   │   ├── 多重继承的真实应用 --> ( 难度等级: [0.3267, 0.3267) || 挂载数据: 无 ) 
│       │   │   └── 一个现代示例：Django通用视图中的混入 --> ( 难度等级: [0.3267, 0.3268) || 挂载数据: 无 ) 
│       │   └── 正确重载运算符 --> ( 难度等级: [0.3268, 0.327) || 挂载数据: 无 ) 
│       │       ├── 运算符重载基础 --> ( 难度等级: [0.3268, 0.3268) || 挂载数据: 无 ) 
│       │       ├── 重载向量加法运算符 + --> ( 难度等级: [0.3268, 0.3268) || 挂载数据: 无 ) 
│       │       ├── 重载标量乘法运算符 * --> ( 难度等级: [0.3268, 0.3269) || 挂载数据: 无 ) 
│       │       ├── 众多比较运算符 --> ( 难度等级: [0.3269, 0.3269) || 挂载数据: 无 ) 
│       │       └── 增量赋值运算符 --> ( 难度等级: [0.3269, 0.327) || 挂载数据: 无 ) 
│       ├── 控制流程 --> ( 难度等级: [0.327, 0.3277) || 挂载数据: 无 ) 
│       │   ├── 使用期物处理并发 --> ( 难度等级: [0.327, 0.3273) || 挂载数据: 无 ) 
│       │   │   ├── 阻塞型I/O和GIL --> ( 难度等级: [0.327, 0.327) || 挂载数据: 无 ) 
│       │   │   ├── 使用concurrent.futures模块启动进程 --> ( 难度等级: [0.327, 0.3271) || 挂载数据: 无 ) 
│       │   │   ├── 实验Executor.map方法 --> ( 难度等级: [0.3271, 0.3272) || 挂载数据: qa: 3 ) 
│       │   │   └── 显示下载进度并处理错误 --> ( 难度等级: [0.3272, 0.3273) || 挂载数据: 无 ) 
│       │   └── 使用asyncio包处理并发 --> ( 难度等级: [0.3273, 0.3277) || 挂载数据: 无 ) 
│       │       ├── 避免阻塞型调用 --> ( 难度等级: [0.3273, 0.3274) || 挂载数据: 无 ) 
│       │       ├── 改进asyncio下载脚本 --> ( 难度等级: [0.3274, 0.3275) || 挂载数据: 无 ) 
│       │       └── 使用asyncio包编写服务器 --> ( 难度等级: [0.3275, 0.3277) || 挂载数据: blog: 1 ) 
│       ├── 元编程 --> ( 难度等级: [0.3277, 0.3284) || 挂载数据: qa: 3 ) 
│       │   ├── 动态属性和特性 --> ( 难度等级: [0.3277, 0.3277) || 挂载数据: 无 ) 
│       │   │   ├── 使用动态属性转换数据 --> ( 难度等级: [0.3277, 0.3277) || 挂载数据: 无 ) 
│       │   │   ├── 使用特性验证属性 --> ( 难度等级: [0.3277, 0.3277) || 挂载数据: 无 ) 
│       │   │   ├── 特性全解析 --> ( 难度等级: [0.3277, 0.3277) || 挂载数据: 无 ) 
│       │   │   ├── 定义一个特性工厂函数 --> ( 难度等级: [0.3277, 0.3277) || 挂载数据: 无 ) 
│       │   │   └── 处理属性删除操作 --> ( 难度等级: [0.3277, 0.3277) || 挂载数据: 无 ) 
│       │   ├── 属性描述符 --> ( 难度等级: [0.3277, 0.3277) || 挂载数据: 无 ) 
│       │   │   ├── 描述符示例：验证属性 --> ( 难度等级: [0.3277, 0.3277) || 挂载数据: blog: 1 ) 
│       │   │   ├── 覆盖型与非覆盖型描述符对比 --> ( 难度等级: [0.3277, 0.3277) || 挂载数据: qa: 1 ) 
│       │   │   ├── 方法是描述符 --> ( 难度等级: [0.3277, 0.3277) || 挂载数据: 无 ) 
│       │   │   ├── 描述符用法建议 --> ( 难度等级: [0.3277, 0.3277) || 挂载数据: 无 ) 
│       │   │   └── 描述符的文档字符串和覆盖删除操作 --> ( 难度等级: [0.3277, 0.3277) || 挂载数据: 无 ) 
│       │   ├── 类元编程 --> ( 难度等级: [0.3277, 0.3277) || 挂载数据: 无 ) 
│       │   │   ├── 类工厂函数 --> ( 难度等级: [0.3277, 0.3277) || 挂载数据: 无 ) 
│       │   │   ├── 定制描述符的类装饰器 --> ( 难度等级: [0.3277, 0.3277) || 挂载数据: 无 ) 
│       │   │   ├── 导入时和运行时比较 --> ( 难度等级: [0.3277, 0.3277) || 挂载数据: 无 ) 
│       │   │   ├── 元类基础知识 --> ( 难度等级: [0.3277, 0.3277) || 挂载数据: 无 ) 
│       │   │   ├── 定制描述符的元类 --> ( 难度等级: [0.3277, 0.3277) || 挂载数据: 无 ) 
│       │   │   └── 元类的特殊方法__prepare__ --> ( 难度等级: [0.3277, 0.3277) || 挂载数据: qa: 1 ) 
│       │   ├── 给函数添加一个包装 --> ( 难度等级: [0.3277, 0.3278) || 挂载数据: 无 ) 
│       │   ├── 编写装饰器时如何保存函数的元数据 --> ( 难度等级: [0.3278, 0.3278) || 挂载数据: 无 ) 
│       │   ├── 对装饰器进行解包装 --> ( 难度等级: [0.3278, 0.3278) || 挂载数据: qa: 6 ) 
│       │   ├── 定义一个可接受参数的装饰器 --> ( 难度等级: [0.3278, 0.3278) || 挂载数据: 无 ) 
│       │   ├── 定义一个属性可由用户修改的装饰器 --> ( 难度等级: [0.3278, 0.3279) || 挂载数据: 无 ) 
│       │   ├── 定义一个能接收可选参数的装饰器 --> ( 难度等级: [0.3279, 0.3279) || 挂载数据: 无 ) 
│       │   ├── 利用装饰器对函数参数强制执行类型检查 --> ( 难度等级: [0.3279, 0.3279) || 挂载数据: 无 ) 
│       │   ├── 在类中定义装饰器 --> ( 难度等级: [0.3279, 0.3279) || 挂载数据: 无 ) 
│       │   ├── 把装饰器定义成类 --> ( 难度等级: [0.3279, 0.328) || 挂载数据: 无 ) 
│       │   ├── 把装饰器作用到类和静态方法上 --> ( 难度等级: [0.328, 0.328) || 挂载数据: 无 ) 
│       │   ├── 编写装饰器为被包装的函数添加参数 --> ( 难度等级: [0.328, 0.328) || 挂载数据: 无 ) 
│       │   ├── 利用装饰器给类定义打补丁 --> ( 难度等级: [0.328, 0.3281) || 挂载数据: 无 ) 
│       │   ├── 获取类属性的定义顺序 --> ( 难度等级: [0.3281, 0.3281) || 挂载数据: 无 ) 
│       │   ├── 定义一个能接受可选参数的元类 --> ( 难度等级: [0.3281, 0.3281) || 挂载数据: 无 ) 
│       │   ├── 在*args和**kwargs上强制规定一种参数签名 --> ( 难度等级: [0.3281, 0.3281) || 挂载数据: qa: 1 ) 
│       │   ├── 在类中强制规定编码约定 --> ( 难度等级: [0.3281, 0.3282) || 挂载数据: 无 ) 
│       │   ├── 通过编程的方式来定义类 --> ( 难度等级: [0.3282, 0.3282) || 挂载数据: 无 ) 
│       │   ├── 在定义的时候初始化类成员 --> ( 难度等级: [0.3282, 0.3282) || 挂载数据: 无 ) 
│       │   ├── 通过函数注解来实现方法重载 --> ( 难度等级: [0.3282, 0.3282) || 挂载数据: 无 ) 
│       │   ├── 避免出现重复的属性方法 --> ( 难度等级: [0.3282, 0.3283) || 挂载数据: 无 ) 
│       │   ├── 以简单的方式定义上下文管理器 --> ( 难度等级: [0.3283, 0.3283) || 挂载数据: 无 ) 
│       │   ├── 执行带有局部副作用的代码 --> ( 难度等级: [0.3283, 0.3283) || 挂载数据: 无 ) 
│       │   ├── 解析并分析Python源代码 --> ( 难度等级: [0.3283, 0.3283) || 挂载数据: 无 ) 
│       │   └── 将Python源码分解为字节码 --> ( 难度等级: [0.3283, 0.3284) || 挂载数据: 无 ) 
│       ├── 数据编码与处理 --> ( 难度等级: [0.3284, 0.3291) || 挂载数据: 无 ) 
│       │   ├── 读写CSV数据 --> ( 难度等级: [0.3284, 0.3284) || 挂载数据: 无 ) 
│       │   ├── 读写JSON数据 --> ( 难度等级: [0.3284, 0.3285) || 挂载数据: 无 ) 
│       │   ├── 解析简单的XML文档 --> ( 难度等级: [0.3285, 0.3286) || 挂载数据: 无 ) 
│       │   ├── 以增量方式解析大型XML文件 --> ( 难度等级: [0.3286, 0.3286) || 挂载数据: 无 ) 
│       │   ├── 将字典转换为XML --> ( 难度等级: [0.3286, 0.3287) || 挂载数据: 无 ) 
│       │   ├── 用命名空间来解析XML文档 --> ( 难度等级: [0.3287, 0.3288) || 挂载数据: 无 ) 
│       │   ├── 同关系型数据库进行交互 --> ( 难度等级: [0.3288, 0.3288) || 挂载数据: 无 ) 
│       │   ├── 编码和解码十六进制数字 --> ( 难度等级: [0.3288, 0.3289) || 挂载数据: qa: 1 ) 
│       │   ├── 读写二进制结构的数组 --> ( 难度等级: [0.3289, 0.3289) || 挂载数据: 无 ) 
│       │   ├── 读取嵌套型和大小可变的二进制结构 --> ( 难度等级: [0.3289, 0.329) || 挂载数据: 无 ) 
│       │   └── 数据汇总和统计 --> ( 难度等级: [0.329, 0.3291) || 挂载数据: 无 ) 
│       ├── 并发 --> ( 难度等级: [0.3291, 0.3298) || 挂载数据: qa: 1 ) 
│       │   ├── 启动和停止线程 --> ( 难度等级: [0.3291, 0.3291) || 挂载数据: 无 ) 
│       │   ├── 判断线程是否已经启动 --> ( 难度等级: [0.3291, 0.3292) || 挂载数据: 无 ) 
│       │   ├── 线程间通信 --> ( 难度等级: [0.3292, 0.3292) || 挂载数据: 无 ) 
│       │   ├── 对临界区加锁 --> ( 难度等级: [0.3292, 0.3293) || 挂载数据: 无 ) 
│       │   ├── 避免死锁 --> ( 难度等级: [0.3293, 0.3293) || 挂载数据: 无 ) 
│       │   ├── 保存线程专有状态 --> ( 难度等级: [0.3293, 0.3294) || 挂载数据: 无 ) 
│       │   ├── 创建线程池 --> ( 难度等级: [0.3294, 0.3294) || 挂载数据: 无 ) 
│       │   ├── 实现简单的并行编程 --> ( 难度等级: [0.3294, 0.3295) || 挂载数据: 无 ) 
│       │   ├── 如何规避GIL带来的限制 --> ( 难度等级: [0.3295, 0.3295) || 挂载数据: 无 ) 
│       │   ├── 定义一个Actor任务 --> ( 难度等级: [0.3295, 0.3296) || 挂载数据: 无 ) 
│       │   ├── 实现发布者/订阅者消息模式 --> ( 难度等级: [0.3296, 0.3296) || 挂载数据: 无 ) 
│       │   ├── 使用生成器作为线程的替代方案 --> ( 难度等级: [0.3296, 0.3297) || 挂载数据: 无 ) 
│       │   ├── 轮询多个线程队列 --> ( 难度等级: [0.3297, 0.3297) || 挂载数据: 无 ) 
│       │   └── 在UNIX上加载守护进程 --> ( 难度等级: [0.3297, 0.3298) || 挂载数据: 无 ) 
│       ├── 实用脚本和系统管理 --> ( 难度等级: [0.3298, 0.3305) || 挂载数据: qa: 1 ) 
│       │   ├── 通过重定向、管道或输入文件来作为脚本的输入 --> ( 难度等级: [0.3298, 0.3298) || 挂载数据: 无 ) 
│       │   ├── 终止程序并显示错误信息 --> ( 难度等级: [0.3298, 0.3299) || 挂载数据: 无 ) 
│       │   ├── 解析命令行选项 --> ( 难度等级: [0.3299, 0.3299) || 挂载数据: 无 ) 
│       │   ├── 在运行时提供密码输入提示 --> ( 难度等级: [0.3299, 0.33) || 挂载数据: 无 ) 
│       │   ├── 获取终端大小 --> ( 难度等级: [0.33, 0.33) || 挂载数据: qa: 1 ) 
│       │   ├── 执行外部命令并获取输出 --> ( 难度等级: [0.33, 0.3301) || 挂载数据: 无 ) 
│       │   ├── 创建和解包归档文件 --> ( 难度等级: [0.3301, 0.3301) || 挂载数据: 无 ) 
│       │   ├── 通过名称来查找文件 --> ( 难度等级: [0.3301, 0.3302) || 挂载数据: 无 ) 
│       │   ├── 读取配置文件 --> ( 难度等级: [0.3302, 0.3302) || 挂载数据: 无 ) 
│       │   ├── 给脚本添加日志记录 --> ( 难度等级: [0.3302, 0.3303) || 挂载数据: 无 ) 
│       │   ├── 给库添加日志记录 --> ( 难度等级: [0.3303, 0.3303) || 挂载数据: 无 ) 
│       │   ├── 创建一个秒表计时器 --> ( 难度等级: [0.3303, 0.3304) || 挂载数据: 无 ) 
│       │   ├── 给内存和CPU使用量设定限制 --> ( 难度等级: [0.3304, 0.3304) || 挂载数据: 无 ) 
│       │   └── 加载Web浏览器 --> ( 难度等级: [0.3304, 0.3305) || 挂载数据: 无 ) 
│       ├── C语言扩展 --> ( 难度等级: [0.3305, 0.3312) || 挂载数据: 无 ) 
│       │   ├── 利用ctypes来访问C代码 --> ( 难度等级: [0.3305, 0.3305) || 挂载数据: qa: 2 ) 
│       │   ├── 编写简单的C语言扩展模块 --> ( 难度等级: [0.3305, 0.3306) || 挂载数据: 无 ) 
│       │   ├── 编写一个可操作数组的扩展函数 --> ( 难度等级: [0.3306, 0.3306) || 挂载数据: 无 ) 
│       │   ├── 在C扩展模块中管理不透明指针 --> ( 难度等级: [0.3306, 0.3306) || 挂载数据: 无 ) 
│       │   ├── 在扩展模块中定义并导出C API --> ( 难度等级: [0.3306, 0.3307) || 挂载数据: 无 ) 
│       │   ├── 从C中调用Python --> ( 难度等级: [0.3307, 0.3307) || 挂载数据: qa: 1 ) 
│       │   ├── 在C扩展模块中释放GIL --> ( 难度等级: [0.3307, 0.3307) || 挂载数据: 无 ) 
│       │   ├── 混合使用C和Python环境中的线程 --> ( 难度等级: [0.3307, 0.3308) || 挂载数据: 无 ) 
│       │   ├── 用Swig来包装C代码 --> ( 难度等级: [0.3308, 0.3308) || 挂载数据: 无 ) 
│       │   ├── 用Cython来包装C代码 --> ( 难度等级: [0.3308, 0.3308) || 挂载数据: 无 ) 
│       │   ├── 用Cython来高效操作数组 --> ( 难度等级: [0.3308, 0.3309) || 挂载数据: 无 ) 
│       │   ├── 把函数指针转换为可调用对象 --> ( 难度等级: [0.3309, 0.3309) || 挂载数据: 无 ) 
│       │   ├── 把以NULL结尾的字符串传给C库 --> ( 难度等级: [0.3309, 0.3309) || 挂载数据: blog: 2 ) 
│       │   ├── 把Unicode字符串传递给C库 --> ( 难度等级: [0.3309, 0.331) || 挂载数据: 无 ) 
│       │   ├── 把C字符串转换到Python中 --> ( 难度等级: [0.331, 0.331) || 挂载数据: 无 ) 
│       │   ├── 同编码方式不确定的C字符串打交道 --> ( 难度等级: [0.331, 0.331) || 挂载数据: 无 ) 
│       │   ├── 把文件名传给C扩展模块 --> ( 难度等级: [0.331, 0.3311) || 挂载数据: 无 ) 
│       │   ├── 把打开的文件传给C扩展模块 --> ( 难度等级: [0.3311, 0.3311) || 挂载数据: 无 ) 
│       │   ├── 在C中读取文件型对象 --> ( 难度等级: [0.3311, 0.3311) || 挂载数据: 无 ) 
│       │   ├── 从C中访问可迭代对象 --> ( 难度等级: [0.3311, 0.3312) || 挂载数据: 无 ) 
│       │   └── 排查段错误 --> ( 难度等级: [0.3312, 0.3312) || 挂载数据: qa: 9 ) 
│       ├── 初识Python --> ( 难度等级: [0.3312, 0.3319) || 挂载数据: 无 ) 
│       │   ├── 搭建Python开发环境 --> ( 难度等级: [0.3312, 0.3316) || 挂载数据: 无 ) 
│       │   │   ├── 开发环境概述 --> ( 难度等级: [0.3312, 0.3314) || 挂载数据: qa: 6; blog: 5 ) 
│       │   │   └── 运行已经编写好的.py文件 --> ( 难度等级: [0.3314, 0.3316) || 挂载数据: qa: 5; blog: 1 ) 
│       │   └── Python开发工具 --> ( 难度等级: [0.3316, 0.3319) || 挂载数据: 无 ) 
│       │       └── 使用自带的IDLE --> ( 难度等级: [0.3316, 0.3319) || 挂载数据: 无 ) 
│       ├── Python语言基础 --> ( 难度等级: [0.3319, 0.3326) || 挂载数据: 无 ) 
│       │   ├── Python语法特点 --> ( 难度等级: [0.3319, 0.3322) || 挂载数据: 无 ) 
│       │   │   └── 注释规则 --> ( 难度等级: [0.3319, 0.3322) || 挂载数据: 无 ) 
│       │   ├── Python中的变量 --> ( 难度等级: [0.3322, 0.3324) || 挂载数据: 无 ) 
│       │   │   ├── 理解Python中的变量 --> ( 难度等级: [0.3322, 0.3323) || 挂载数据: 无 ) 
│       │   │   └── 定义变量 --> ( 难度等级: [0.3323, 0.3324) || 挂载数据: qa: 2 ) 
│       │   └── 基本数据类型 --> ( 难度等级: [0.3324, 0.3326) || 挂载数据: 无 ) 
│       │       ├── 布尔类型 --> ( 难度等级: [0.3324, 0.3325) || 挂载数据: 无 ) 
│       │       └── 数据类型转换 --> ( 难度等级: [0.3325, 0.3326) || 挂载数据: qa: 2 ) 
│       └── 流程控制语句 --> ( 难度等级: [0.3326, 0.3333) || 挂载数据: 无 ) 
│           ├── 程序结构 --> ( 难度等级: [0.3326, 0.3329) || 挂载数据: 无 ) 
│           ├── 选择语句 --> ( 难度等级: [0.3329, 0.3331) || 挂载数据: 无 ) 
│           │   ├── if…else语句 --> ( 难度等级: [0.3329, 0.3329) || 挂载数据: qa: 3 ) 
│           │   ├── if…elif…else语句 --> ( 难度等级: [0.3329, 0.333) || 挂载数据: qa: 1 ) 
│           │   └── if语句的嵌套 --> ( 难度等级: [0.333, 0.3331) || 挂载数据: qa: 2 ) 
│           └── 循环语句 --> ( 难度等级: [0.3331, 0.3333) || 挂载数据: 无 ) 
│               └── 循环嵌套 --> ( 难度等级: [0.3331, 0.3333) || 挂载数据: qa: 10 ) 
├── Python中阶 --> ( 难度等级: [0.3333, 0.6667) || 挂载数据: 无 ) 
│   ├── 基本技能 --> ( 难度等级: [0.3333, 0.4) || 挂载数据: 无 ) 
│   │   ├── 时间日期处理 --> ( 难度等级: [0.3333, 0.3417) || 挂载数据: 无 ) 
│   │   │   ├── time --> ( 难度等级: [0.3333, 0.3375) || 挂载数据: qa: 1 ) 
│   │   │   └── datetime --> ( 难度等级: [0.3375, 0.3417) || 挂载数据: qa: 1 ) 
│   │   ├── 数据文件读写 --> ( 难度等级: [0.3417, 0.35) || 挂载数据: 无 ) 
│   │   │   └── excel/csv/hdf/netCDF --> ( 难度等级: [0.3417, 0.35) || 挂载数据: 无 ) 
│   │   ├── 数据库操作 --> ( 难度等级: [0.35, 0.3583) || 挂载数据: 无 ) 
│   │   │   ├── 数据库概述 --> ( 难度等级: [0.35, 0.3512) || 挂载数据: 无 ) 
│   │   │   ├── 数据库安装配置 --> ( 难度等级: [0.3512, 0.3524) || 挂载数据: 无 ) 
│   │   │   ├── SQL语句 --> ( 难度等级: [0.3524, 0.3536) || 挂载数据: qa: 4 ) 
│   │   │   ├── SQLite --> ( 难度等级: [0.3536, 0.3548) || 挂载数据: 无 ) 
│   │   │   │   ├── 创建数据库文件 --> ( 难度等级: [0.3536, 0.3542) || 挂载数据: 无 ) 
│   │   │   │   └── 操作SQLite --> ( 难度等级: [0.3542, 0.3548) || 挂载数据: qa: 2; blog: 10 ) 
│   │   │   ├── MySQL --> ( 难度等级: [0.3548, 0.356) || 挂载数据: 无 ) 
│   │   │   │   ├── 下载安装MySQL --> ( 难度等级: [0.3548, 0.3551) || 挂载数据: qa: 16; blog: 46 ) 
│   │   │   │   ├── 连接数据库 --> ( 难度等级: [0.3551, 0.3554) || 挂载数据: qa: 2 ) 
│   │   │   │   ├── 创建数据表 --> ( 难度等级: [0.3554, 0.3557) || 挂载数据: 无 ) 
│   │   │   │   └── 操作MySQL数据表 --> ( 难度等级: [0.3557, 0.356) || 挂载数据: qa: 1; blog: 10 ) 
│   │   │   ├── MongoDB --> ( 难度等级: [0.356, 0.3571) || 挂载数据: qa: 2 ) 
│   │   │   └── 数据库编程接口 --> ( 难度等级: [0.3571, 0.3583) || 挂载数据: 无 ) 
│   │   │       ├── 连接对象 --> ( 难度等级: [0.3571, 0.3577) || 挂载数据: 无 ) 
│   │   │       └── 游标对象 --> ( 难度等级: [0.3577, 0.3583) || 挂载数据: 无 ) 
│   │   ├── 操作系统和环境 --> ( 难度等级: [0.3583, 0.3667) || 挂载数据: 无 ) 
│   │   │   └── OS/Sys --> ( 难度等级: [0.3583, 0.3667) || 挂载数据: 无 ) 
│   │   ├── 线程进程和协程 --> ( 难度等级: [0.3667, 0.375) || 挂载数据: 无 ) 
│   │   │   ├── 基础概念 --> ( 难度等级: [0.3667, 0.3681) || 挂载数据: 无 ) 
│   │   │   ├── 加锁和解锁 --> ( 难度等级: [0.3681, 0.3694) || 挂载数据: 无 ) 
│   │   │   ├── threading --> ( 难度等级: [0.3694, 0.3708) || 挂载数据: 无 ) 
│   │   │   ├── multiprocessing --> ( 难度等级: [0.3708, 0.3722) || 挂载数据: qa: 1 ) 
│   │   │   ├── queue --> ( 难度等级: [0.3722, 0.3736) || 挂载数据: qa: 1 ) 
│   │   │   └── gevent --> ( 难度等级: [0.3736, 0.375) || 挂载数据: 无 ) 
│   │   ├── 源码打包 --> ( 难度等级: [0.375, 0.3833) || 挂载数据: 无 ) 
│   │   │   └── pyinstaller --> ( 难度等级: [0.375, 0.3833) || 挂载数据: blog: 6 ) 
│   │   ├── 网络编程 --> ( 难度等级: [0.3833, 0.3917) || 挂载数据: 无 ) 
│   │   │   ├── socket --> ( 难度等级: [0.3833, 0.3838) || 挂载数据: qa: 7 ) 
│   │   │   ├── 与HTTP服务交互 --> ( 难度等级: [0.3838, 0.3843) || 挂载数据: 无 ) 
│   │   │   ├── 创建服务器 --> ( 难度等级: [0.3843, 0.3847) || 挂载数据: 无 ) 
│   │   │   │   ├── TCP服务器 --> ( 难度等级: [0.3843, 0.3845) || 挂载数据: qa: 7 ) 
│   │   │   │   └── UDP服务器 --> ( 难度等级: [0.3845, 0.3847) || 挂载数据: 无 ) 
│   │   │   ├── 通过CIDR地址生成对应的IP地址集 --> ( 难度等级: [0.3847, 0.3852) || 挂载数据: 无 ) 
│   │   │   ├── REST接口创建 --> ( 难度等级: [0.3852, 0.3856) || 挂载数据: blog: 1 ) 
│   │   │   ├── 远程调用 --> ( 难度等级: [0.3856, 0.3861) || 挂载数据: 无 ) 
│   │   │   │   ├── 远程方法调用 --> ( 难度等级: [0.3856, 0.3859) || 挂载数据: qa: 13; blog: 2 ) 
│   │   │   │   └── 通过XML-RPC远程调用 --> ( 难度等级: [0.3859, 0.3861) || 挂载数据: 无 ) 
│   │   │   ├── 不同Python解释器之间的交互 --> ( 难度等级: [0.3861, 0.3866) || 挂载数据: 无 ) 
│   │   │   ├── 客户端认证 --> ( 难度等级: [0.3866, 0.387) || 挂载数据: 无 ) 
│   │   │   ├── Socket文件描述符传递 --> ( 难度等级: [0.387, 0.3875) || 挂载数据: blog: 1 ) 
│   │   │   ├── 事件驱动的I/O --> ( 难度等级: [0.3875, 0.388) || 挂载数据: 无 ) 
│   │   │   ├── 大型数组发送与接收 --> ( 难度等级: [0.388, 0.3884) || 挂载数据: 无 ) 
│   │   │   ├── 简介 --> ( 难度等级: [0.3884, 0.3889) || 挂载数据: 无 ) 
│   │   │   │   ├── 客户端/服务端架构 --> ( 难度等级: [0.3884, 0.3885) || 挂载数据: 无 ) 
│   │   │   │   ├── 持久化存储 --> ( 难度等级: [0.3885, 0.3886) || 挂载数据: 无 ) 
│   │   │   │   ├── 数据库基本操作和SQL --> ( 难度等级: [0.3886, 0.3887) || 挂载数据: 无 ) 
│   │   │   │   ├── Web应用：客户端/服务器计算 --> ( 难度等级: [0.3887, 0.3888) || 挂载数据: 无 ) 
│   │   │   │   └── 因特网 --> ( 难度等级: [0.3888, 0.3889) || 挂载数据: 无 ) 
│   │   │   ├── 客户端/服务器架构 --> ( 难度等级: [0.3889, 0.3894) || 挂载数据: 无 ) 
│   │   │   │   ├── 硬件客户端/服务器架构 --> ( 难度等级: [0.3889, 0.389) || 挂载数据: 无 ) 
│   │   │   │   ├── 软件客户端/服务器架构 --> ( 难度等级: [0.389, 0.3891) || 挂载数据: 无 ) 
│   │   │   │   ├── 银行出纳员作为服务器吗 --> ( 难度等级: [0.3891, 0.3892) || 挂载数据: 无 ) 
│   │   │   │   └── 客户端/服务器网络编程 --> ( 难度等级: [0.3892, 0.3894) || 挂载数据: blog: 1 ) 
│   │   │   ├── 套接字：通信端点 --> ( 难度等级: [0.3894, 0.3898) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 套接字 --> ( 难度等级: [0.3894, 0.3895) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 套接字地址：主机-端口对 --> ( 难度等级: [0.3895, 0.3897) || 挂载数据: qa: 1 ) 
│   │   │   │   └── 面向连接的套接字与无连接的套接字 --> ( 难度等级: [0.3897, 0.3898) || 挂载数据: 无 ) 
│   │   │   ├── Python中的网络编程 --> ( 难度等级: [0.3898, 0.3903) || 挂载数据: 无 ) 
│   │   │   │   ├── socket模块函数 --> ( 难度等级: [0.3898, 0.3899) || 挂载数据: blog: 5 ) 
│   │   │   │   ├── 套接字对象（内置）方法 --> ( 难度等级: [0.3899, 0.3899) || 挂载数据: 无 ) 
│   │   │   │   ├── 创建TCP服务器 --> ( 难度等级: [0.3899, 0.39) || 挂载数据: 无 ) 
│   │   │   │   ├── 创建TCP客户端 --> ( 难度等级: [0.39, 0.39) || 挂载数据: 无 ) 
│   │   │   │   ├── 执行TCP服务器和客户端 --> ( 难度等级: [0.39, 0.3901) || 挂载数据: 无 ) 
│   │   │   │   ├── 创建UDP服务器 --> ( 难度等级: [0.3901, 0.3901) || 挂载数据: 无 ) 
│   │   │   │   ├── 创建UDP客户端 --> ( 难度等级: [0.3901, 0.3902) || 挂载数据: 无 ) 
│   │   │   │   ├── 执行UDP服务器和客户端 --> ( 难度等级: [0.3902, 0.3902) || 挂载数据: 无 ) 
│   │   │   │   └── socket模块属性 --> ( 难度等级: [0.3902, 0.3903) || 挂载数据: 无 ) 
│   │   │   ├── *SocketServer模块 --> ( 难度等级: [0.3903, 0.3907) || 挂载数据: 无 ) 
│   │   │   │   ├── 创建SocketServer TCP服务器 --> ( 难度等级: [0.3903, 0.3905) || 挂载数据: 无 ) 
│   │   │   │   └── 创建SocketServer TCP客户端 --> ( 难度等级: [0.3905, 0.3907) || 挂载数据: 无 ) 
│   │   │   ├── *Twisted框架介绍 --> ( 难度等级: [0.3907, 0.3912) || 挂载数据: 无 ) 
│   │   │   │   ├── 创建Twisted Reactor TCP服务器 --> ( 难度等级: [0.3907, 0.391) || 挂载数据: blog: 1 ) 
│   │   │   │   └── 创建Twisted Reactor TCP客户端 --> ( 难度等级: [0.391, 0.3912) || 挂载数据: 无 ) 
│   │   │   └── 相关模块 --> ( 难度等级: [0.3912, 0.3917) || 挂载数据: 无 ) 
│   │   │       └── 其他因特网客户端协议 --> ( 难度等级: [0.3912, 0.3917) || 挂载数据: 无 ) 
│   │   └── 发送邮件 --> ( 难度等级: [0.3917, 0.4) || 挂载数据: qa: 1 ) 
│   │       └── smtplib --> ( 难度等级: [0.3917, 0.4) || 挂载数据: 无 ) 
│   ├── Web应用开发 --> ( 难度等级: [0.4, 0.4667) || 挂载数据: 无 ) 
│   │   ├── Web开发基础知识 --> ( 难度等级: [0.4, 0.4067) || 挂载数据: 无 ) 
│   │   │   ├── HTML/HTML5/CSS --> ( 难度等级: [0.4, 0.4017) || 挂载数据: blog: 2 ) 
│   │   │   ├── 前端数据库和后台 --> ( 难度等级: [0.4017, 0.4033) || 挂载数据: 无 ) 
│   │   │   ├── MVC架构 --> ( 难度等级: [0.4033, 0.405) || 挂载数据: 无 ) 
│   │   │   └── REST和Ajax --> ( 难度等级: [0.405, 0.4067) || 挂载数据: 无 ) 
│   │   ├── Django --> ( 难度等级: [0.4067, 0.4133) || 挂载数据: 无 ) 
│   │   │   ├── Django简介 --> ( 难度等级: [0.4067, 0.407) || 挂载数据: qa: 8; blog: 116 ) 
│   │   │   ├── Django安装配置 --> ( 难度等级: [0.407, 0.4072) || 挂载数据: blog: 14 ) 
│   │   │   ├── DTL(Django Template Language) --> ( 难度等级: [0.4072, 0.4075) || 挂载数据: 无 ) 
│   │   │   ├── Django路由定义 --> ( 难度等级: [0.4075, 0.4078) || 挂载数据: 无 ) 
│   │   │   ├── Django请求数据解析 --> ( 难度等级: [0.4078, 0.4081) || 挂载数据: qa: 1; blog: 5 ) 
│   │   │   ├── Django数据库操作 --> ( 难度等级: [0.4081, 0.4084) || 挂载数据: qa: 1; blog: 23 ) 
│   │   │   ├── Django提交表单 --> ( 难度等级: [0.4084, 0.4087) || 挂载数据: qa: 1 ) 
│   │   │   ├── Django Rest Framework --> ( 难度等级: [0.4087, 0.409) || 挂载数据: blog: 10 ) 
│   │   │   ├── 部署日志与安全 --> ( 难度等级: [0.409, 0.4093) || 挂载数据: 无 ) 
│   │   │   ├── Django开发案例 --> ( 难度等级: [0.4093, 0.4096) || 挂载数据: qa: 1; blog: 17 ) 
│   │   │   ├── Web框架 --> ( 难度等级: [0.4096, 0.4099) || 挂载数据: 无 ) 
│   │   │   ├── “Hello World”应用（一个博客） --> ( 难度等级: [0.4099, 0.4101) || 挂载数据: qa: 3 ) 
│   │   │   ├── 创建模型来添加数据库服务 --> ( 难度等级: [0.4101, 0.4104) || 挂载数据: 无 ) 
│   │   │   │   └── 设置数据库 --> ( 难度等级: [0.4101, 0.4104) || 挂载数据: 无 ) 
│   │   │   ├── Python应用shell --> ( 难度等级: [0.4104, 0.4107) || 挂载数据: 无 ) 
│   │   │   │   ├── 在Django中使用Python shell --> ( 难度等级: [0.4104, 0.4106) || 挂载数据: qa: 9; blog: 7 ) 
│   │   │   │   └── 测试数据模型 --> ( 难度等级: [0.4106, 0.4107) || 挂载数据: 无 ) 
│   │   │   ├── Django管理应用 --> ( 难度等级: [0.4107, 0.411) || 挂载数据: blog: 6 ) 
│   │   │   │   ├── 设置admin --> ( 难度等级: [0.4107, 0.4109) || 挂载数据: 无 ) 
│   │   │   │   └── 使用admin --> ( 难度等级: [0.4109, 0.411) || 挂载数据: qa: 1; blog: 6 ) 
│   │   │   ├── 创建博客的用户界面 --> ( 难度等级: [0.411, 0.4113) || 挂载数据: 无 ) 
│   │   │   │   ├── 创建模板 --> ( 难度等级: [0.411, 0.4111) || 挂载数据: qa: 6 ) 
│   │   │   │   ├── 创建URL模式 --> ( 难度等级: [0.4111, 0.4112) || 挂载数据: 无 ) 
│   │   │   │   └── 创建视图函数 --> ( 难度等级: [0.4112, 0.4113) || 挂载数据: 无 ) 
│   │   │   ├── 改进输出 --> ( 难度等级: [0.4113, 0.4116) || 挂载数据: 无 ) 
│   │   │   ├── 处理用户输入 --> ( 难度等级: [0.4116, 0.4119) || 挂载数据: 无 ) 
│   │   │   │   ├── 添加URLconf项 --> ( 难度等级: [0.4116, 0.4117) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 视图：处理用户输入 --> ( 难度等级: [0.4117, 0.4118) || 挂载数据: qa: 27 ) 
│   │   │   │   └── 跨站点请求伪造 --> ( 难度等级: [0.4118, 0.4119) || 挂载数据: 无 ) 
│   │   │   ├── 表单和模型表单 --> ( 难度等级: [0.4119, 0.4122) || 挂载数据: 无 ) 
│   │   │   │   ├── Django表单简介 --> ( 难度等级: [0.4119, 0.412) || 挂载数据: blog: 5 ) 
│   │   │   │   ├── 模型表单示例 --> ( 难度等级: [0.412, 0.412) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用ModelForm来生成HTML表单 --> ( 难度等级: [0.412, 0.4121) || 挂载数据: blog: 1 ) 
│   │   │   │   └── 处理ModelForm数据 --> ( 难度等级: [0.4121, 0.4122) || 挂载数据: 无 ) 
│   │   │   ├── 视图进阶 --> ( 难度等级: [0.4122, 0.4125) || 挂载数据: blog: 1 ) 
│   │   │   ├── *改善外观 --> ( 难度等级: [0.4125, 0.4128) || 挂载数据: 无 ) 
│   │   │   ├── *中级Django应用：TweetApprover --> ( 难度等级: [0.4128, 0.413) || 挂载数据: 无 ) 
│   │   │   │   ├── 安装Twython库 --> ( 难度等级: [0.4128, 0.4128) || 挂载数据: 无 ) 
│   │   │   │   ├── URL结构 --> ( 难度等级: [0.4128, 0.4129) || 挂载数据: qa: 9; blog: 6 ) 
│   │   │   │   ├── 数据模型 --> ( 难度等级: [0.4129, 0.4129) || 挂载数据: 无 ) 
│   │   │   │   ├── 提交新推文以便审核 --> ( 难度等级: [0.4129, 0.413) || 挂载数据: 无 ) 
│   │   │   │   └── 审核推文 --> ( 难度等级: [0.413, 0.413) || 挂载数据: 无 ) 
│   │   │   └── 资源 --> ( 难度等级: [0.413, 0.4133) || 挂载数据: 无 ) 
│   │   ├── Tornado --> ( 难度等级: [0.4133, 0.42) || 挂载数据: 无 ) 
│   │   │   ├── Tornado简介 --> ( 难度等级: [0.4133, 0.4141) || 挂载数据: 无 ) 
│   │   │   ├── Tornado安装配置 --> ( 难度等级: [0.4141, 0.4148) || 挂载数据: blog: 16 ) 
│   │   │   ├── Tornado提交表单 --> ( 难度等级: [0.4148, 0.4156) || 挂载数据: blog: 1 ) 
│   │   │   ├── Tornado模板 --> ( 难度等级: [0.4156, 0.4163) || 挂载数据: qa: 1; blog: 119 ) 
│   │   │   ├── Tornado数据库操作 --> ( 难度等级: [0.4163, 0.417) || 挂载数据: blog: 8 ) 
│   │   │   ├── Tornado异步Web服务 --> ( 难度等级: [0.417, 0.4178) || 挂载数据: blog: 23 ) 
│   │   │   ├── 外部服务认证（auth） --> ( 难度等级: [0.4178, 0.4185) || 挂载数据: 无 ) 
│   │   │   ├── 部署日志与安全 --> ( 难度等级: [0.4185, 0.4193) || 挂载数据: 无 ) 
│   │   │   └── Tornado开发案例 --> ( 难度等级: [0.4193, 0.42) || 挂载数据: blog: 9 ) 
│   │   ├── Flask --> ( 难度等级: [0.42, 0.4267) || 挂载数据: 无 ) 
│   │   │   ├── Flask简介 --> ( 难度等级: [0.42, 0.4206) || 挂载数据: 无 ) 
│   │   │   │   ├── 安装 --> ( 难度等级: [0.42, 0.4201) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 创建应用目录 --> ( 难度等级: [0.42, 0.42) || 挂载数据: qa: 8 ) 
│   │   │   │   │   ├── 虚拟环境 --> ( 难度等级: [0.42, 0.42) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 在Python 3中创建虚拟环境 --> ( 难度等级: [0.42, 0.42) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 在Python 2中创建虚拟环境 --> ( 难度等级: [0.42, 0.4201) || 挂载数据: qa: 1; blog: 2 ) 
│   │   │   │   │   ├── 使用虚拟环境 --> ( 难度等级: [0.4201, 0.4201) || 挂载数据: 无 ) 
│   │   │   │   │   └── 使用pip安装Python包 --> ( 难度等级: [0.4201, 0.4201) || 挂载数据: qa: 13; blog: 90 ) 
│   │   │   │   ├── 应用的基本结构 --> ( 难度等级: [0.4201, 0.4202) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 初始化 --> ( 难度等级: [0.4201, 0.4201) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 路由和视图函数 --> ( 难度等级: [0.4201, 0.4201) || 挂载数据: blog: 1 ) 
│   │   │   │   │   ├── 一个完整的应用 --> ( 难度等级: [0.4201, 0.4201) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Web开发服务器 --> ( 难度等级: [0.4201, 0.4201) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 动态路由 --> ( 难度等级: [0.4201, 0.4201) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 调试模式 --> ( 难度等级: [0.4201, 0.4201) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 命令行选项 --> ( 难度等级: [0.4201, 0.4202) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 请求–响应循环 --> ( 难度等级: [0.4202, 0.4202) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── 应用和请求上下文 --> ( 难度等级: [0.4202, 0.4202) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── 请求分派 --> ( 难度等级: [0.4202, 0.4202) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── 请求对象 --> ( 难度等级: [0.4202, 0.4202) || 挂载数据: 无 ) 
│   │   │   │   │   │   │   ├── 对象显示 --> ( 难度等级: [0.4202, 0.4202) || 挂载数据: qa: 16; blog: 1 ) 
│   │   │   │   │   │   │   ├── 有效创建大量对象 --> ( 难度等级: [0.4202, 0.4202) || 挂载数据: 无 ) 
│   │   │   │   │   │   │   └── 由字符串调用对象 --> ( 难度等级: [0.4202, 0.4202) || 挂载数据: 无 ) 
│   │   │   │   │   │   └── 请求钩子 --> ( 难度等级: [0.4202, 0.4202) || 挂载数据: 无 ) 
│   │   │   │   │   └── Flask扩展 --> ( 难度等级: [0.4202, 0.4202) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 模板 --> ( 难度等级: [0.4202, 0.4203) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Jinja2模板引擎 --> ( 难度等级: [0.4202, 0.4202) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── 渲染模板 --> ( 难度等级: [0.4202, 0.4202) || 挂载数据: qa: 1 ) 
│   │   │   │   │   │   ├── 变量 --> ( 难度等级: [0.4202, 0.4202) || 挂载数据: 无 ) 
│   │   │   │   │   │   │   ├── 匿名函数捕获变量值 --> ( 难度等级: [0.4202, 0.4202) || 挂载数据: 无 ) 
│   │   │   │   │   │   │   └── 访问闭包中定义的变量 --> ( 难度等级: [0.4202, 0.4202) || 挂载数据: qa: 6 ) 
│   │   │   │   │   │   └── 控制结构 --> ( 难度等级: [0.4202, 0.4202) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 使用Flask-Bootstrap集成Bootstrap --> ( 难度等级: [0.4202, 0.4202) || 挂载数据: blog: 10 ) 
│   │   │   │   │   ├── 自定义错误页面 --> ( 难度等级: [0.4202, 0.4202) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 链接 --> ( 难度等级: [0.4202, 0.4202) || 挂载数据: qa: 2 ) 
│   │   │   │   │   ├── 静态文件 --> ( 难度等级: [0.4202, 0.4202) || 挂载数据: 无 ) 
│   │   │   │   │   └── 使用Flask-Moment本地化日期和时间 --> ( 难度等级: [0.4202, 0.4203) || 挂载数据: 无 ) 
│   │   │   │   ├── Web表单 --> ( 难度等级: [0.4203, 0.4203) || 挂载数据: blog: 26 ) 
│   │   │   │   │   ├── 配置 --> ( 难度等级: [0.4203, 0.4203) || 挂载数据: qa: 1; blog: 1 ) 
│   │   │   │   │   ├── 表单类 --> ( 难度等级: [0.4203, 0.4203) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 把表单渲染成HTML --> ( 难度等级: [0.4203, 0.4203) || 挂载数据: blog: 5 ) 
│   │   │   │   │   ├── 在视图函数中处理表单 --> ( 难度等级: [0.4203, 0.4203) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 重定向和用户会话 --> ( 难度等级: [0.4203, 0.4203) || 挂载数据: qa: 1 ) 
│   │   │   │   │   └── 闪现消息 --> ( 难度等级: [0.4203, 0.4203) || 挂载数据: 无 ) 
│   │   │   │   ├── 数据库 --> ( 难度等级: [0.4203, 0.4204) || 挂载数据: 无 ) 
│   │   │   │   │   ├── SQL数据库 --> ( 难度等级: [0.4203, 0.4204) || 挂载数据: qa: 5; blog: 5 ) 
│   │   │   │   │   ├── NoSQL数据库 --> ( 难度等级: [0.4204, 0.4204) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 使用SQL还是NoSQL --> ( 难度等级: [0.4204, 0.4204) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Python数据库框架 --> ( 难度等级: [0.4204, 0.4204) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 使用Flask-SQLAlchemy管理数据库 --> ( 难度等级: [0.4204, 0.4204) || 挂载数据: qa: 1; blog: 16 ) 
│   │   │   │   │   ├── 定义模型 --> ( 难度等级: [0.4204, 0.4204) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 关系 --> ( 难度等级: [0.4204, 0.4204) || 挂载数据: qa: 2 ) 
│   │   │   │   │   ├── 数据库操作 --> ( 难度等级: [0.4204, 0.4204) || 挂载数据: qa: 1; blog: 1 ) 
│   │   │   │   │   │   ├── 创建表 --> ( 难度等级: [0.4204, 0.4204) || 挂载数据: qa: 1 ) 
│   │   │   │   │   │   ├── 插入行 --> ( 难度等级: [0.4204, 0.4204) || 挂载数据: qa: 1 ) 
│   │   │   │   │   │   ├── 修改行 --> ( 难度等级: [0.4204, 0.4204) || 挂载数据: qa: 7 ) 
│   │   │   │   │   │   ├── 删除行 --> ( 难度等级: [0.4204, 0.4204) || 挂载数据: 无 ) 
│   │   │   │   │   │   └── 查询行 --> ( 难度等级: [0.4204, 0.4204) || 挂载数据: qa: 3 ) 
│   │   │   │   │   ├── 在视图函数中操作数据库 --> ( 难度等级: [0.4204, 0.4204) || 挂载数据: qa: 1 ) 
│   │   │   │   │   ├── 集成Python shell --> ( 难度等级: [0.4204, 0.4204) || 挂载数据: 无 ) 
│   │   │   │   │   └── 使用Flask-Migrate实现数据库迁移 --> ( 难度等级: [0.4204, 0.4204) || 挂载数据: qa: 1; blog: 16 ) 
│   │   │   │   │       ├── 创建迁移仓库 --> ( 难度等级: [0.4204, 0.4204) || 挂载数据: 无 ) 
│   │   │   │   │       ├── 创建迁移脚本 --> ( 难度等级: [0.4204, 0.4204) || 挂载数据: 无 ) 
│   │   │   │   │       ├── 更新数据库 --> ( 难度等级: [0.4204, 0.4204) || 挂载数据: qa: 16; blog: 5 ) 
│   │   │   │   │       └── 添加几个迁移 --> ( 难度等级: [0.4204, 0.4204) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 电子邮件 --> ( 难度等级: [0.4204, 0.4205) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 电子邮件系统组件和协议 --> ( 难度等级: [0.4204, 0.4204) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 发送电子邮件 --> ( 难度等级: [0.4204, 0.4204) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Python和SMTP --> ( 难度等级: [0.4204, 0.4205) || 挂载数据: 无 ) 
│   │   │   │   │   ├── smtplib.SMTP类方法 --> ( 难度等级: [0.4205, 0.4205) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 交互式SMTP示例 --> ( 难度等级: [0.4205, 0.4205) || 挂载数据: 无 ) 
│   │   │   │   │   ├── SMTP的其他内容 --> ( 难度等级: [0.4205, 0.4205) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 接收电子邮件 --> ( 难度等级: [0.4205, 0.4205) || 挂载数据: 无 ) 
│   │   │   │   │   ├── POP和IMAP --> ( 难度等级: [0.4205, 0.4205) || 挂载数据: qa: 1 ) 
│   │   │   │   │   ├── 交互式POP3示例 --> ( 难度等级: [0.4205, 0.4205) || 挂载数据: 无 ) 
│   │   │   │   │   ├── poplib.POP3类方法 --> ( 难度等级: [0.4205, 0.4205) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 客户端程序SMTP和POP3示例 --> ( 难度等级: [0.4205, 0.4205) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 交互式IMAP4示例 --> ( 难度等级: [0.4205, 0.4205) || 挂载数据: 无 ) 
│   │   │   │   │   └── imaplib.IMAP4类中的常用方法 --> ( 难度等级: [0.4205, 0.4205) || 挂载数据: 无 ) 
│   │   │   │   └── 大型应用的结构 --> ( 难度等级: [0.4205, 0.4206) || 挂载数据: 无 ) 
│   │   │   │       ├── 配置选项 --> ( 难度等级: [0.4205, 0.4205) || 挂载数据: 无 ) 
│   │   │   │       ├── 应用包 --> ( 难度等级: [0.4205, 0.4205) || 挂载数据: 无 ) 
│   │   │   │       │   ├── 使用应用工厂函数 --> ( 难度等级: [0.4205, 0.4205) || 挂载数据: 无 ) 
│   │   │   │       │   └── 在蓝本中实现应用功能 --> ( 难度等级: [0.4205, 0.4205) || 挂载数据: qa: 1 ) 
│   │   │   │       ├── 应用脚本 --> ( 难度等级: [0.4205, 0.4206) || 挂载数据: 无 ) 
│   │   │   │       ├── 需求文件 --> ( 难度等级: [0.4206, 0.4206) || 挂载数据: qa: 1 ) 
│   │   │   │       ├── 单元测试 --> ( 难度等级: [0.4206, 0.4206) || 挂载数据: 无 ) 
│   │   │   │       │   └── blog应用的代码审查 --> ( 难度等级: [0.4206, 0.4206) || 挂载数据: qa: 2; blog: 2 ) 
│   │   │   │       ├── 创建数据库 --> ( 难度等级: [0.4206, 0.4206) || 挂载数据: 无 ) 
│   │   │   │       └── 运行应用 --> ( 难度等级: [0.4206, 0.4206) || 挂载数据: qa: 2 ) 
│   │   │   ├── Flask安装配置 --> ( 难度等级: [0.4206, 0.4212) || 挂载数据: 无 ) 
│   │   │   ├── Flask实现HTTP请求与响应 --> ( 难度等级: [0.4212, 0.4218) || 挂载数据: 无 ) 
│   │   │   ├── Flask cookie与session --> ( 难度等级: [0.4218, 0.4224) || 挂载数据: 无 ) 
│   │   │   ├── Flask模板 --> ( 难度等级: [0.4224, 0.423) || 挂载数据: 无 ) 
│   │   │   ├── Flask提交表单 --> ( 难度等级: [0.423, 0.4236) || 挂载数据: 无 ) 
│   │   │   ├── Flask数据库操作 --> ( 难度等级: [0.4236, 0.4242) || 挂载数据: 无 ) 
│   │   │   ├── Bootstrap-Flask --> ( 难度等级: [0.4242, 0.4248) || 挂载数据: 无 ) 
│   │   │   ├── Flask开发REST Web服务 --> ( 难度等级: [0.4248, 0.4255) || 挂载数据: blog: 1 ) 
│   │   │   ├── 部署日志与安全 --> ( 难度等级: [0.4255, 0.4261) || 挂载数据: 无 ) 
│   │   │   └── Flask开发案例 --> ( 难度等级: [0.4261, 0.4267) || 挂载数据: 无 ) 
│   │   ├── 网站可视化 --> ( 难度等级: [0.4267, 0.4333) || 挂载数据: qa: 1 ) 
│   │   │   └── Echarts --> ( 难度等级: [0.4267, 0.4333) || 挂载数据: 无 ) 
│   │   ├── 网站高并发处理 --> ( 难度等级: [0.4333, 0.44) || 挂载数据: 无 ) 
│   │   ├── Web客户端和服务器 --> ( 难度等级: [0.44, 0.4467) || 挂载数据: 无 ) 
│   │   │   ├── Python Web客户端工具 --> ( 难度等级: [0.44, 0.4422) || 挂载数据: 无 ) 
│   │   │   │   ├── 统一资源定位符 --> ( 难度等级: [0.44, 0.4404) || 挂载数据: 无 ) 
│   │   │   │   ├── urlparse模块 --> ( 难度等级: [0.4404, 0.4409) || 挂载数据: 无 ) 
│   │   │   │   ├── urllib模块/包 --> ( 难度等级: [0.4409, 0.4413) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用urllib2 HTTP验证的示例 --> ( 难度等级: [0.4413, 0.4418) || 挂载数据: 无 ) 
│   │   │   │   └── 将HTTP验证示例移植到Python 3中 --> ( 难度等级: [0.4418, 0.4422) || 挂载数据: 无 ) 
│   │   │   ├── Web客户端 --> ( 难度等级: [0.4422, 0.4444) || 挂载数据: 无 ) 
│   │   │   │   ├── 一个简单的Web爬虫/蜘蛛/机器人 --> ( 难度等级: [0.4422, 0.443) || 挂载数据: blog: 3 ) 
│   │   │   │   ├── 解析Web页面 --> ( 难度等级: [0.443, 0.4437) || 挂载数据: blog: 3 ) 
│   │   │   │   └── 可编程的Web浏览 --> ( 难度等级: [0.4437, 0.4444) || 挂载数据: qa: 6; blog: 69 ) 
│   │   │   └── Web（HTTP）服务器 --> ( 难度等级: [0.4444, 0.4467) || 挂载数据: blog: 2 ) 
│   │   ├── Web编程：CGI和WSGI --> ( 难度等级: [0.4467, 0.4533) || 挂载数据: 无 ) 
│   │   │   ├── 帮助Web服务器处理客户端数据 --> ( 难度等级: [0.4467, 0.4478) || 挂载数据: 无 ) 
│   │   │   │   ├── CGI简介 --> ( 难度等级: [0.4467, 0.4469) || 挂载数据: 无 ) 
│   │   │   │   ├── CGI应用程序 --> ( 难度等级: [0.4469, 0.4472) || 挂载数据: 无 ) 
│   │   │   │   ├── cgi模块 --> ( 难度等级: [0.4472, 0.4475) || 挂载数据: 无 ) 
│   │   │   │   └── cgitb模块 --> ( 难度等级: [0.4475, 0.4478) || 挂载数据: 无 ) 
│   │   │   ├── 构建CGI应用程序 --> ( 难度等级: [0.4478, 0.4489) || 挂载数据: 无 ) 
│   │   │   │   ├── 构建Web服务器 --> ( 难度等级: [0.4478, 0.448) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 建立表单页 --> ( 难度等级: [0.448, 0.4482) || 挂载数据: 无 ) 
│   │   │   │   ├── 生成结果页面 --> ( 难度等级: [0.4482, 0.4484) || 挂载数据: qa: 2 ) 
│   │   │   │   ├── 生成表单和结果页面 --> ( 难度等级: [0.4484, 0.4487) || 挂载数据: 无 ) 
│   │   │   │   └── 全面交互的Web站点 --> ( 难度等级: [0.4487, 0.4489) || 挂载数据: blog: 1 ) 
│   │   │   ├── 在CGI中使用Unicode --> ( 难度等级: [0.4489, 0.45) || 挂载数据: 无 ) 
│   │   │   ├── 高级CGI --> ( 难度等级: [0.45, 0.4511) || 挂载数据: 无 ) 
│   │   │   │   ├── mulitipart表单提交和文件上传 --> ( 难度等级: [0.45, 0.4506) || 挂载数据: 无 ) 
│   │   │   │   └── 多值字段 --> ( 难度等级: [0.4506, 0.4511) || 挂载数据: 无 ) 
│   │   │   ├── WSGI简介 --> ( 难度等级: [0.4511, 0.4522) || 挂载数据: 无 ) 
│   │   │   │   ├── 动机（替代CGI） --> ( 难度等级: [0.4511, 0.4512) || 挂载数据: 无 ) 
│   │   │   │   ├── 服务器集成 --> ( 难度等级: [0.4512, 0.4514) || 挂载数据: 无 ) 
│   │   │   │   ├── 外部进程 --> ( 难度等级: [0.4514, 0.4515) || 挂载数据: 无 ) 
│   │   │   │   ├── WSGI简介 --> ( 难度等级: [0.4515, 0.4516) || 挂载数据: 无 ) 
│   │   │   │   ├── WSGI服务器 --> ( 难度等级: [0.4516, 0.4517) || 挂载数据: blog: 3 ) 
│   │   │   │   ├── 参考服务器 --> ( 难度等级: [0.4517, 0.4519) || 挂载数据: 无 ) 
│   │   │   │   ├── WSGI应用示例 --> ( 难度等级: [0.4519, 0.452) || 挂载数据: blog: 3 ) 
│   │   │   │   ├── 中间件及封装WSGI应用 --> ( 难度等级: [0.452, 0.4521) || 挂载数据: 无 ) 
│   │   │   │   └── 在Python 3中使用WSGI --> ( 难度等级: [0.4521, 0.4522) || 挂载数据: 无 ) 
│   │   │   └── 现实世界中的Web开发 --> ( 难度等级: [0.4522, 0.4533) || 挂载数据: 无 ) 
│   │   ├── 云计算：Google App Engine --> ( 难度等级: [0.4533, 0.46) || 挂载数据: 无 ) 
│   │   │   ├── 云计算 --> ( 难度等级: [0.4533, 0.4537) || 挂载数据: 无 ) 
│   │   │   │   ├── 云计算服务的层次 --> ( 难度等级: [0.4533, 0.4535) || 挂载数据: qa: 27 ) 
│   │   │   │   └── App Engine --> ( 难度等级: [0.4535, 0.4537) || 挂载数据: 无 ) 
│   │   │   ├── 沙盒和App Engine SDK --> ( 难度等级: [0.4537, 0.4542) || 挂载数据: blog: 1 ) 
│   │   │   ├── 选择一个App Engine框架 --> ( 难度等级: [0.4542, 0.4546) || 挂载数据: 无 ) 
│   │   │   ├── Python 2.7支持 --> ( 难度等级: [0.4546, 0.455) || 挂载数据: 无 ) 
│   │   │   │   ├── 一般差异 --> ( 难度等级: [0.4546, 0.4548) || 挂载数据: 无 ) 
│   │   │   │   └── 代码中的差异 --> ( 难度等级: [0.4548, 0.455) || 挂载数据: 无 ) 
│   │   │   ├── 将“Hello World”改成一个简单的博客 --> ( 难度等级: [0.455, 0.4554) || 挂载数据: 无 ) 
│   │   │   │   ├── 快速发现改动：30秒内将纯文本转成HTML --> ( 难度等级: [0.455, 0.4551) || 挂载数据: 无 ) 
│   │   │   │   ├── 添加表单 --> ( 难度等级: [0.4551, 0.4552) || 挂载数据: 无 ) 
│   │   │   │   ├── 添加Datastore服务 --> ( 难度等级: [0.4552, 0.4552) || 挂载数据: 无 ) 
│   │   │   │   ├── 迭代改进 --> ( 难度等级: [0.4552, 0.4553) || 挂载数据: 无 ) 
│   │   │   │   └── 开发/SDK控制台 --> ( 难度等级: [0.4553, 0.4554) || 挂载数据: qa: 2 ) 
│   │   │   ├── 添加Memcache服务 --> ( 难度等级: [0.4554, 0.4558) || 挂载数据: 无 ) 
│   │   │   ├── 添加用户服务 --> ( 难度等级: [0.4558, 0.4562) || 挂载数据: 无 ) 
│   │   │   │   ├── Google账号验证 --> ( 难度等级: [0.4558, 0.456) || 挂载数据: 无 ) 
│   │   │   │   └── 联合验证 --> ( 难度等级: [0.456, 0.4562) || 挂载数据: 无 ) 
│   │   │   ├── 远程API shell --> ( 难度等级: [0.4562, 0.4567) || 挂载数据: 无 ) 
│   │   │   ├── 问与答（Python实现） --> ( 难度等级: [0.4567, 0.4571) || 挂载数据: 无 ) 
│   │   │   ├── 使用XMPP发送即时消息 --> ( 难度等级: [0.4571, 0.4575) || 挂载数据: 无 ) 
│   │   │   ├── 处理图片 --> ( 难度等级: [0.4575, 0.4579) || 挂载数据: qa: 9 ) 
│   │   │   ├── 任务队列（非定期任务） --> ( 难度等级: [0.4579, 0.4583) || 挂载数据: 无 ) 
│   │   │   │   ├── 配置app.yaml --> ( 难度等级: [0.4579, 0.458) || 挂载数据: qa: 1; blog: 1 ) 
│   │   │   │   ├── 其他任务创建选项 --> ( 难度等级: [0.458, 0.4581) || 挂载数据: 无 ) 
│   │   │   │   ├── 将发送电子邮件作为任务 --> ( 难度等级: [0.4581, 0.4582) || 挂载数据: 无 ) 
│   │   │   │   └── deferred包 --> ( 难度等级: [0.4582, 0.4583) || 挂载数据: 无 ) 
│   │   │   ├── 使用Appstats进行分析 --> ( 难度等级: [0.4583, 0.4587) || 挂载数据: 无 ) 
│   │   │   │   ├── 在app.yaml中添加标准处理程序 --> ( 难度等级: [0.4583, 0.4585) || 挂载数据: 无 ) 
│   │   │   │   ├── 添加自定义Admin Console页面 --> ( 难度等级: [0.4585, 0.4586) || 挂载数据: 无 ) 
│   │   │   │   └── 作为内置界面启用界面 --> ( 难度等级: [0.4586, 0.4587) || 挂载数据: blog: 1 ) 
│   │   │   ├── URLfetch服务 --> ( 难度等级: [0.4587, 0.4592) || 挂载数据: 无 ) 
│   │   │   ├── 问与答（无Python实现） --> ( 难度等级: [0.4592, 0.4596) || 挂载数据: 无 ) 
│   │   │   │   ├── Cron服务（计划任务作业） --> ( 难度等级: [0.4592, 0.4593) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 预热请求 --> ( 难度等级: [0.4593, 0.4594) || 挂载数据: 无 ) 
│   │   │   │   └── DoS保护 --> ( 难度等级: [0.4594, 0.4596) || 挂载数据: 无 ) 
│   │   │   └── 厂商锁定 --> ( 难度等级: [0.4596, 0.46) || 挂载数据: 无 ) 
│   │   └── Web服务 --> ( 难度等级: [0.46, 0.4667) || 挂载数据: 无 ) 
│   │       ├── Yahoo!金融股票报价服务器 --> ( 难度等级: [0.46, 0.4633) || 挂载数据: 无 ) 
│   │       └── Twitter微博 --> ( 难度等级: [0.4633, 0.4667) || 挂载数据: qa: 1; blog: 1 ) 
│   │           ├── 社交网络 --> ( 难度等级: [0.4633, 0.4644) || 挂载数据: 无 ) 
│   │           ├── 稍微长一点的API组合应用示例 --> ( 难度等级: [0.4644, 0.4656) || 挂载数据: qa: 1 ) 
│   │           └── 额外在线资源 --> ( 难度等级: [0.4656, 0.4667) || 挂载数据: 无 ) 
│   ├── 网络爬虫 --> ( 难度等级: [0.4667, 0.5333) || 挂载数据: qa: 1 ) 
│   │   ├── 基础概念 --> ( 难度等级: [0.4667, 0.469) || 挂载数据: 无 ) 
│   │   │   ├── 什么是网络爬虫 --> ( 难度等级: [0.4667, 0.4673) || 挂载数据: 无 ) 
│   │   │   ├── HTML与DOM树分析 --> ( 难度等级: [0.4673, 0.4679) || 挂载数据: 无 ) 
│   │   │   ├── 常用网络爬虫工具 --> ( 难度等级: [0.4679, 0.4685) || 挂载数据: 无 ) 
│   │   │   └── 相关法律及注意事项 --> ( 难度等级: [0.4685, 0.469) || 挂载数据: 无 ) 
│   │   ├── urllib --> ( 难度等级: [0.469, 0.4714) || 挂载数据: 无 ) 
│   │   │   ├── 处理异常 --> ( 难度等级: [0.469, 0.4698) || 挂载数据: 无 ) 
│   │   │   ├── 解析链接 --> ( 难度等级: [0.4698, 0.4706) || 挂载数据: 无 ) 
│   │   │   └── 分析Robots协议 --> ( 难度等级: [0.4706, 0.4714) || 挂载数据: 无 ) 
│   │   ├── 正则表达式 --> ( 难度等级: [0.4714, 0.4738) || 挂载数据: 无 ) 
│   │   │   ├── RE(Regular Expression ) --> ( 难度等级: [0.4714, 0.4718) || 挂载数据: qa: 1 ) 
│   │   │   ├── 基础语法 --> ( 难度等级: [0.4718, 0.4721) || 挂载数据: 无 ) 
│   │   │   ├── 标签匹配常用规则 --> ( 难度等级: [0.4721, 0.4724) || 挂载数据: 无 ) 
│   │   │   ├── 简介／动机 --> ( 难度等级: [0.4724, 0.4728) || 挂载数据: 无 ) 
│   │   │   ├── 特殊符号和字符 --> ( 难度等级: [0.4728, 0.4731) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用择一匹配符号匹配多个正则表达式模式 --> ( 难度等级: [0.4728, 0.4728) || 挂载数据: qa: 7 ) 
│   │   │   │   ├── 匹配任意单个字符 --> ( 难度等级: [0.4728, 0.4729) || 挂载数据: qa: 6 ) 
│   │   │   │   ├── 从字符串起始或者结尾或者单词边界匹配 --> ( 难度等级: [0.4729, 0.4729) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 创建字符集 --> ( 难度等级: [0.4729, 0.4729) || 挂载数据: 无 ) 
│   │   │   │   ├── 限定范围和否定 --> ( 难度等级: [0.4729, 0.473) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用闭包操作符实现存在性和频数匹配 --> ( 难度等级: [0.473, 0.473) || 挂载数据: 无 ) 
│   │   │   │   ├── 表示字符集的特殊字符 --> ( 难度等级: [0.473, 0.4731) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用圆括号指定分组 --> ( 难度等级: [0.4731, 0.4731) || 挂载数据: 无 ) 
│   │   │   │   └── 扩展表示法 --> ( 难度等级: [0.4731, 0.4731) || 挂载数据: 无 ) 
│   │   │   ├── 一些正则表达式示例 --> ( 难度等级: [0.4731, 0.4735) || 挂载数据: qa: 6 ) 
│   │   │   └── 更长的正则表达式示例 --> ( 难度等级: [0.4735, 0.4738) || 挂载数据: 无 ) 
│   │   ├── Beautiful Soup --> ( 难度等级: [0.4738, 0.4762) || 挂载数据: 无 ) 
│   │   │   ├── Beautiful Soup简介 --> ( 难度等级: [0.4738, 0.4743) || 挂载数据: 无 ) 
│   │   │   ├── 安装配置 --> ( 难度等级: [0.4743, 0.4748) || 挂载数据: 无 ) 
│   │   │   ├── Beautiful Soup对象 --> ( 难度等级: [0.4748, 0.4752) || 挂载数据: qa: 13; blog: 9 ) 
│   │   │   ├── 元素定位 --> ( 难度等级: [0.4752, 0.4757) || 挂载数据: qa: 1 ) 
│   │   │   └── 文档树遍历与搜索 --> ( 难度等级: [0.4757, 0.4762) || 挂载数据: 无 ) 
│   │   ├── lxml --> ( 难度等级: [0.4762, 0.4786) || 挂载数据: 无 ) 
│   │   │   ├── 安装配置 --> ( 难度等级: [0.4762, 0.4766) || 挂载数据: 无 ) 
│   │   │   ├── lxml.etree --> ( 难度等级: [0.4766, 0.477) || 挂载数据: qa: 1 ) 
│   │   │   ├── XPath选择器 --> ( 难度等级: [0.477, 0.4774) || 挂载数据: 无 ) 
│   │   │   ├── find/findall --> ( 难度等级: [0.4774, 0.4778) || 挂载数据: qa: 3 ) 
│   │   │   ├── CSS选择器 --> ( 难度等级: [0.4778, 0.4782) || 挂载数据: blog: 1 ) 
│   │   │   └── 解析HTML --> ( 难度等级: [0.4782, 0.4786) || 挂载数据: 无 ) 
│   │   ├── requests --> ( 难度等级: [0.4786, 0.481) || 挂载数据: 无 ) 
│   │   │   ├── 安装配置 --> ( 难度等级: [0.4786, 0.4788) || 挂载数据: 无 ) 
│   │   │   ├── 发送请求与HTTP请求类型 --> ( 难度等级: [0.4788, 0.479) || 挂载数据: 无 ) 
│   │   │   ├── 传递URL参数 --> ( 难度等级: [0.479, 0.4792) || 挂载数据: qa: 2 ) 
│   │   │   ├── 响应内容 --> ( 难度等级: [0.4792, 0.4794) || 挂载数据: 无 ) 
│   │   │   ├── 定制请求头 --> ( 难度等级: [0.4794, 0.4797) || 挂载数据: 无 ) 
│   │   │   ├── 响应状态码 --> ( 难度等级: [0.4797, 0.4799) || 挂载数据: 无 ) 
│   │   │   ├── Cookie --> ( 难度等级: [0.4799, 0.4801) || 挂载数据: qa: 4 ) 
│   │   │   ├── POST请求 --> ( 难度等级: [0.4801, 0.4803) || 挂载数据: qa: 15 ) 
│   │   │   ├── 身份认证 --> ( 难度等级: [0.4803, 0.4805) || 挂载数据: 无 ) 
│   │   │   ├── 基本用法 --> ( 难度等级: [0.4805, 0.4807) || 挂载数据: blog: 2 ) 
│   │   │   └── 高级用法 --> ( 难度等级: [0.4807, 0.481) || 挂载数据: 无 ) 
│   │   ├── Selenium --> ( 难度等级: [0.481, 0.4833) || 挂载数据: qa: 2 ) 
│   │   │   ├── Selenium简介 --> ( 难度等级: [0.481, 0.4813) || 挂载数据: qa: 49; blog: 256 ) 
│   │   │   ├── 安装配置 --> ( 难度等级: [0.4813, 0.4815) || 挂载数据: 无 ) 
│   │   │   ├── 单元素定位（find_element_id/name/xpath） --> ( 难度等级: [0.4815, 0.4818) || 挂载数据: qa: 1; blog: 3 ) 
│   │   │   ├── 多元素定位（find_elements_id/name/xpath） --> ( 难度等级: [0.4818, 0.4821) || 挂载数据: qa: 5; blog: 3 ) 
│   │   │   ├── 常用方法和属性 --> ( 难度等级: [0.4821, 0.4824) || 挂载数据: 无 ) 
│   │   │   │   ├── 可管理属性创建 --> ( 难度等级: [0.4821, 0.4822) || 挂载数据: qa: 7 ) 
│   │   │   │   ├── 延迟计算属性 --> ( 难度等级: [0.4822, 0.4823) || 挂载数据: 无 ) 
│   │   │   │   ├── 属性的代理访问 --> ( 难度等级: [0.4823, 0.4823) || 挂载数据: qa: 3 ) 
│   │   │   │   ├── 创建用于计算的属性 --> ( 难度等级: [0.4823, 0.4824) || 挂载数据: qa: 1 ) 
│   │   │   │   └── 为属性添加安全保护机制 --> ( 难度等级: [0.4824, 0.4824) || 挂载数据: 无 ) 
│   │   │   ├── 键盘和鼠标操作 --> ( 难度等级: [0.4824, 0.4827) || 挂载数据: 无 ) 
│   │   │   ├── WebDriver API --> ( 难度等级: [0.4827, 0.483) || 挂载数据: qa: 10; blog: 1 ) 
│   │   │   └── 表单交互 --> ( 难度等级: [0.483, 0.4833) || 挂载数据: 无 ) 
│   │   ├── Scrapy框架 --> ( 难度等级: [0.4833, 0.4857) || 挂载数据: 无 ) 
│   │   │   ├── Scrapy简介 --> ( 难度等级: [0.4833, 0.4835) || 挂载数据: 无 ) 
│   │   │   ├── 安装配置 --> ( 难度等级: [0.4835, 0.4836) || 挂载数据: 无 ) 
│   │   │   ├── Scrapy框架组成 --> ( 难度等级: [0.4836, 0.4837) || 挂载数据: qa: 5 ) 
│   │   │   ├── Item Pipeline --> ( 难度等级: [0.4837, 0.4838) || 挂载数据: qa: 1; blog: 2 ) 
│   │   │   ├── Downloader --> ( 难度等级: [0.4838, 0.4839) || 挂载数据: 无 ) 
│   │   │   ├── Spiders --> ( 难度等级: [0.4839, 0.484) || 挂载数据: 无 ) 
│   │   │   ├── Scheduler --> ( 难度等级: [0.484, 0.4842) || 挂载数据: 无 ) 
│   │   │   ├── Scrapy框架介绍 --> ( 难度等级: [0.4842, 0.4843) || 挂载数据: 无 ) 
│   │   │   ├── Scrapy入门 --> ( 难度等级: [0.4843, 0.4844) || 挂载数据: qa: 13; blog: 1 ) 
│   │   │   ├── Selector的用法 --> ( 难度等级: [0.4844, 0.4845) || 挂载数据: qa: 1 ) 
│   │   │   ├── Spider的用法 --> ( 难度等级: [0.4845, 0.4846) || 挂载数据: 无 ) 
│   │   │   ├── Downloader Middleware的用法 --> ( 难度等级: [0.4846, 0.4848) || 挂载数据: 无 ) 
│   │   │   ├── Spider Middleware的用法 --> ( 难度等级: [0.4848, 0.4849) || 挂载数据: 无 ) 
│   │   │   ├── Item Pipeline的用法 --> ( 难度等级: [0.4849, 0.485) || 挂载数据: 无 ) 
│   │   │   ├── Scrapy对接Selenium --> ( 难度等级: [0.485, 0.4851) || 挂载数据: qa: 2; blog: 4 ) 
│   │   │   ├── Scrapy对接Splash --> ( 难度等级: [0.4851, 0.4852) || 挂载数据: 无 ) 
│   │   │   ├── Scrapy通用爬虫 --> ( 难度等级: [0.4852, 0.4854) || 挂载数据: qa: 6; blog: 1 ) 
│   │   │   ├── Scrapyrt的使用 --> ( 难度等级: [0.4854, 0.4855) || 挂载数据: 无 ) 
│   │   │   ├── Scrapy对接Docker --> ( 难度等级: [0.4855, 0.4856) || 挂载数据: 无 ) 
│   │   │   └── Scrapy爬取新浪微博 --> ( 难度等级: [0.4856, 0.4857) || 挂载数据: qa: 4; blog: 1 ) 
│   │   ├── 数据存储 --> ( 难度等级: [0.4857, 0.4881) || 挂载数据: 无 ) 
│   │   │   ├── 文件存储 --> ( 难度等级: [0.4857, 0.4863) || 挂载数据: 无 ) 
│   │   │   │   ├── TXT文本存储 --> ( 难度等级: [0.4857, 0.4859) || 挂载数据: qa: 35; blog: 1 ) 
│   │   │   │   ├── JSON文件存储 --> ( 难度等级: [0.4859, 0.4861) || 挂载数据: qa: 2 ) 
│   │   │   │   └── CSV文件存储 --> ( 难度等级: [0.4861, 0.4863) || 挂载数据: qa: 4 ) 
│   │   │   ├── 数据库存储 --> ( 难度等级: [0.4863, 0.4869) || 挂载数据: qa: 1 ) 
│   │   │   ├── 关系型数据库存储 --> ( 难度等级: [0.4869, 0.4875) || 挂载数据: 无 ) 
│   │   │   │   └── MySQL的存储 --> ( 难度等级: [0.4869, 0.4875) || 挂载数据: 无 ) 
│   │   │   └── 非关系型数据库存储 --> ( 难度等级: [0.4875, 0.4881) || 挂载数据: 无 ) 
│   │   │       ├── MongoDB存储 --> ( 难度等级: [0.4875, 0.4878) || 挂载数据: 无 ) 
│   │   │       └── Redis存储 --> ( 难度等级: [0.4878, 0.4881) || 挂载数据: blog: 1 ) 
│   │   ├── 渲染动态网页 --> ( 难度等级: [0.4881, 0.4905) || 挂载数据: 无 ) 
│   │   │   └── WebKit/Selenium/headless/PhantomJS --> ( 难度等级: [0.4881, 0.4905) || 挂载数据: 无 ) 
│   │   ├── 表单交互处理 --> ( 难度等级: [0.4905, 0.4929) || 挂载数据: 无 ) 
│   │   ├── 超时异常处理 --> ( 难度等级: [0.4929, 0.4952) || 挂载数据: 无 ) 
│   │   │   └── timeout --> ( 难度等级: [0.4929, 0.4952) || 挂载数据: 无 ) 
│   │   ├── 验证码处理 --> ( 难度等级: [0.4952, 0.4976) || 挂载数据: 无 ) 
│   │   │   └── 自动输入/OCR字符识别 --> ( 难度等级: [0.4952, 0.4976) || 挂载数据: blog: 1 ) 
│   │   ├── 高并发处理 --> ( 难度等级: [0.4976, 0.5) || 挂载数据: qa: 1; blog: 1 ) 
│   │   ├── 多线程爬虫 --> ( 难度等级: [0.5, 0.5024) || 挂载数据: 无 ) 
│   │   ├── 开发环境配置 --> ( 难度等级: [0.5024, 0.5048) || 挂载数据: 无 ) 
│   │   │   ├── Python 3的安装 --> ( 难度等级: [0.5024, 0.5026) || 挂载数据: 无 ) 
│   │   │   │   ├── Windows下的安装 --> ( 难度等级: [0.5024, 0.5025) || 挂载数据: blog: 11 ) 
│   │   │   │   ├── Linux下的安装 --> ( 难度等级: [0.5025, 0.5026) || 挂载数据: qa: 1; blog: 21 ) 
│   │   │   │   └── Mac下的安装 --> ( 难度等级: [0.5026, 0.5026) || 挂载数据: qa: 1; blog: 22 ) 
│   │   │   ├── 请求库的安装 --> ( 难度等级: [0.5026, 0.5029) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── requests的安装 --> ( 难度等级: [0.5026, 0.5027) || 挂载数据: qa: 3; blog: 3 ) 
│   │   │   │   ├── Selenium的安装 --> ( 难度等级: [0.5027, 0.5027) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── ChromeDriver的安装 --> ( 难度等级: [0.5027, 0.5028) || 挂载数据: qa: 2; blog: 1 ) 
│   │   │   │   ├── GeckoDriver的安装 --> ( 难度等级: [0.5028, 0.5028) || 挂载数据: 无 ) 
│   │   │   │   ├── PhantomJS的安装 --> ( 难度等级: [0.5028, 0.5029) || 挂载数据: qa: 1 ) 
│   │   │   │   └── aiohttp的安装 --> ( 难度等级: [0.5029, 0.5029) || 挂载数据: qa: 1 ) 
│   │   │   ├── 解析库的安装 --> ( 难度等级: [0.5029, 0.5032) || 挂载数据: 无 ) 
│   │   │   │   ├── lxml的安装 --> ( 难度等级: [0.5029, 0.503) || 挂载数据: 无 ) 
│   │   │   │   ├── Beautiful Soup的安装 --> ( 难度等级: [0.503, 0.503) || 挂载数据: 无 ) 
│   │   │   │   ├── pyquery的安装 --> ( 难度等级: [0.503, 0.5031) || 挂载数据: 无 ) 
│   │   │   │   └── tesserocr的安装 --> ( 难度等级: [0.5031, 0.5032) || 挂载数据: qa: 2 ) 
│   │   │   ├── 数据库的安装 --> ( 难度等级: [0.5032, 0.5034) || 挂载数据: 无 ) 
│   │   │   │   ├── MySQL的安装 --> ( 难度等级: [0.5032, 0.5033) || 挂载数据: 无 ) 
│   │   │   │   ├── MongoDB的安装 --> ( 难度等级: [0.5033, 0.5034) || 挂载数据: 无 ) 
│   │   │   │   └── Redis的安装 --> ( 难度等级: [0.5034, 0.5034) || 挂载数据: blog: 3 ) 
│   │   │   ├── 存储库的安装 --> ( 难度等级: [0.5034, 0.5037) || 挂载数据: 无 ) 
│   │   │   │   ├── PyMySQL的安装 --> ( 难度等级: [0.5034, 0.5035) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── PyMongo的安装 --> ( 难度等级: [0.5035, 0.5036) || 挂载数据: 无 ) 
│   │   │   │   ├── redis-py的安装 --> ( 难度等级: [0.5036, 0.5036) || 挂载数据: qa: 2 ) 
│   │   │   │   └── RedisDump的安装 --> ( 难度等级: [0.5036, 0.5037) || 挂载数据: 无 ) 
│   │   │   ├── Web库的安装 --> ( 难度等级: [0.5037, 0.504) || 挂载数据: 无 ) 
│   │   │   │   ├── Flask的安装 --> ( 难度等级: [0.5037, 0.5038) || 挂载数据: 无 ) 
│   │   │   │   └── Tornado的安装 --> ( 难度等级: [0.5038, 0.504) || 挂载数据: 无 ) 
│   │   │   ├── App爬取相关库的安装 --> ( 难度等级: [0.504, 0.5042) || 挂载数据: 无 ) 
│   │   │   │   ├── Charles的安装 --> ( 难度等级: [0.504, 0.5041) || 挂载数据: 无 ) 
│   │   │   │   ├── mitmproxy的安装 --> ( 难度等级: [0.5041, 0.5041) || 挂载数据: 无 ) 
│   │   │   │   └── Appium的安装 --> ( 难度等级: [0.5041, 0.5042) || 挂载数据: qa: 1 ) 
│   │   │   ├── 爬虫框架的安装 --> ( 难度等级: [0.5042, 0.5045) || 挂载数据: 无 ) 
│   │   │   │   ├── pyspider的安装 --> ( 难度等级: [0.5042, 0.5043) || 挂载数据: 无 ) 
│   │   │   │   ├── Scrapy的安装 --> ( 难度等级: [0.5043, 0.5044) || 挂载数据: 无 ) 
│   │   │   │   ├── Scrapy-Splash的安装 --> ( 难度等级: [0.5044, 0.5044) || 挂载数据: 无 ) 
│   │   │   │   └── Scrapy-Redis的安装 --> ( 难度等级: [0.5044, 0.5045) || 挂载数据: 无 ) 
│   │   │   └── 部署相关库的安装 --> ( 难度等级: [0.5045, 0.5048) || 挂载数据: 无 ) 
│   │   │       ├── Docker的安装 --> ( 难度等级: [0.5045, 0.5045) || 挂载数据: blog: 2 ) 
│   │   │       ├── Scrapyd的安装 --> ( 难度等级: [0.5045, 0.5046) || 挂载数据: 无 ) 
│   │   │       ├── Scrapyd-Client的安装 --> ( 难度等级: [0.5046, 0.5046) || 挂载数据: 无 ) 
│   │   │       ├── Scrapyd API的安装 --> ( 难度等级: [0.5046, 0.5047) || 挂载数据: 无 ) 
│   │   │       ├── Scrapyrt的安装 --> ( 难度等级: [0.5047, 0.5047) || 挂载数据: 无 ) 
│   │   │       └── Gerapy的安装 --> ( 难度等级: [0.5047, 0.5048) || 挂载数据: 无 ) 
│   │   ├── 爬虫基础 --> ( 难度等级: [0.5048, 0.5071) || 挂载数据: 无 ) 
│   │   │   ├── HTTP基本原理 --> ( 难度等级: [0.5048, 0.5052) || 挂载数据: 无 ) 
│   │   │   │   ├── URI和URL --> ( 难度等级: [0.5048, 0.5048) || 挂载数据: qa: 3; blog: 3 ) 
│   │   │   │   ├── 超文本 --> ( 难度等级: [0.5048, 0.5049) || 挂载数据: 无 ) 
│   │   │   │   ├── HTTP和HTTPS --> ( 难度等级: [0.5049, 0.505) || 挂载数据: blog: 8 ) 
│   │   │   │   ├── HTTP请求过程 --> ( 难度等级: [0.505, 0.5051) || 挂载数据: qa: 6 ) 
│   │   │   │   ├── 请求 --> ( 难度等级: [0.5051, 0.5052) || 挂载数据: 无 ) 
│   │   │   │   └── 响应 --> ( 难度等级: [0.5052, 0.5052) || 挂载数据: 无 ) 
│   │   │   ├── 网页基础 --> ( 难度等级: [0.5052, 0.5057) || 挂载数据: 无 ) 
│   │   │   │   ├── 网页的组成 --> ( 难度等级: [0.5052, 0.5054) || 挂载数据: qa: 22 ) 
│   │   │   │   ├── 网页的结构 --> ( 难度等级: [0.5054, 0.5055) || 挂载数据: 无 ) 
│   │   │   │   ├── 节点树及节点间的关系 --> ( 难度等级: [0.5055, 0.5056) || 挂载数据: 无 ) 
│   │   │   │   └── 选择器 --> ( 难度等级: [0.5056, 0.5057) || 挂载数据: 无 ) 
│   │   │   ├── 爬虫的基本原理 --> ( 难度等级: [0.5057, 0.5062) || 挂载数据: 无 ) 
│   │   │   │   ├── 爬虫概述 --> ( 难度等级: [0.5057, 0.5059) || 挂载数据: qa: 66; blog: 27 ) 
│   │   │   │   ├── 能抓怎样的数据 --> ( 难度等级: [0.5059, 0.506) || 挂载数据: qa: 4; blog: 1 ) 
│   │   │   │   └── JavaScript渲染页面 --> ( 难度等级: [0.506, 0.5062) || 挂载数据: qa: 1; blog: 6 ) 
│   │   │   ├── 会话和Cookies --> ( 难度等级: [0.5062, 0.5067) || 挂载数据: qa: 2 ) 
│   │   │   │   ├── 静态网页和动态网页 --> ( 难度等级: [0.5062, 0.5063) || 挂载数据: qa: 2 ) 
│   │   │   │   ├── 无状态HTTP --> ( 难度等级: [0.5063, 0.5065) || 挂载数据: 无 ) 
│   │   │   │   └── 常见误区 --> ( 难度等级: [0.5065, 0.5067) || 挂载数据: 无 ) 
│   │   │   └── 代理的基本原理 --> ( 难度等级: [0.5067, 0.5071) || 挂载数据: 无 ) 
│   │   │       ├── 基本原理 --> ( 难度等级: [0.5067, 0.5068) || 挂载数据: 无 ) 
│   │   │       ├── 代理的作用 --> ( 难度等级: [0.5068, 0.5069) || 挂载数据: qa: 2 ) 
│   │   │       ├── 爬虫代理 --> ( 难度等级: [0.5069, 0.507) || 挂载数据: qa: 1 ) 
│   │   │       ├── 代理分类 --> ( 难度等级: [0.507, 0.507) || 挂载数据: 无 ) 
│   │   │       └── 常见代理设置 --> ( 难度等级: [0.507, 0.5071) || 挂载数据: 无 ) 
│   │   ├── 基本库的使用 --> ( 难度等级: [0.5071, 0.5095) || 挂载数据: 无 ) 
│   │   │   └── 抓取猫眼电影排行 --> ( 难度等级: [0.5071, 0.5095) || 挂载数据: 无 ) 
│   │   ├── 解析库的使用 --> ( 难度等级: [0.5095, 0.5119) || 挂载数据: 无 ) 
│   │   │   ├── 使用XPath --> ( 难度等级: [0.5095, 0.5107) || 挂载数据: qa: 12; blog: 1 ) 
│   │   │   └── 使用pyquery --> ( 难度等级: [0.5107, 0.5119) || 挂载数据: 无 ) 
│   │   ├── Ajax数据爬取 --> ( 难度等级: [0.5119, 0.5143) || 挂载数据: 无 ) 
│   │   │   ├── 什么是Ajax --> ( 难度等级: [0.5119, 0.5125) || 挂载数据: qa: 2; blog: 4 ) 
│   │   │   ├── Ajax分析方法 --> ( 难度等级: [0.5125, 0.5131) || 挂载数据: 无 ) 
│   │   │   ├── Ajax结果提取 --> ( 难度等级: [0.5131, 0.5137) || 挂载数据: 无 ) 
│   │   │   └── 分析Ajax爬取今日头条街拍美图 --> ( 难度等级: [0.5137, 0.5143) || 挂载数据: blog: 1 ) 
│   │   ├── 动态渲染页面爬取 --> ( 难度等级: [0.5143, 0.5167) || 挂载数据: 无 ) 
│   │   │   ├── Splash的使用 --> ( 难度等级: [0.5143, 0.5151) || 挂载数据: 无 ) 
│   │   │   ├── Splash负载均衡配置 --> ( 难度等级: [0.5151, 0.5159) || 挂载数据: 无 ) 
│   │   │   └── 使用Selenium爬取淘宝商品 --> ( 难度等级: [0.5159, 0.5167) || 挂载数据: qa: 2 ) 
│   │   ├── 验证码的识别 --> ( 难度等级: [0.5167, 0.519) || 挂载数据: 无 ) 
│   │   │   ├── 图形验证码的识别 --> ( 难度等级: [0.5167, 0.5173) || 挂载数据: 无 ) 
│   │   │   ├── 极验滑动验证码的识别 --> ( 难度等级: [0.5173, 0.5179) || 挂载数据: qa: 1 ) 
│   │   │   ├── 点触验证码的识别 --> ( 难度等级: [0.5179, 0.5185) || 挂载数据: qa: 3 ) 
│   │   │   └── 微博宫格验证码的识别 --> ( 难度等级: [0.5185, 0.519) || 挂载数据: 无 ) 
│   │   ├── 代理的使用 --> ( 难度等级: [0.519, 0.5214) || 挂载数据: 无 ) 
│   │   │   ├── 代理的设置 --> ( 难度等级: [0.519, 0.5195) || 挂载数据: qa: 2 ) 
│   │   │   ├── 代理池的维护 --> ( 难度等级: [0.5195, 0.52) || 挂载数据: 无 ) 
│   │   │   ├── 付费代理的使用 --> ( 难度等级: [0.52, 0.5205) || 挂载数据: 无 ) 
│   │   │   ├── ADSL拨号代理 --> ( 难度等级: [0.5205, 0.521) || 挂载数据: 无 ) 
│   │   │   └── 使用代理爬取微信公众号文章 --> ( 难度等级: [0.521, 0.5214) || 挂载数据: 无 ) 
│   │   ├── 模拟登录 --> ( 难度等级: [0.5214, 0.5238) || 挂载数据: 无 ) 
│   │   │   ├── 模拟登录并爬取GitHub --> ( 难度等级: [0.5214, 0.5226) || 挂载数据: qa: 7; blog: 3 ) 
│   │   │   └── Cookies池的搭建 --> ( 难度等级: [0.5226, 0.5238) || 挂载数据: 无 ) 
│   │   ├── App的爬取 --> ( 难度等级: [0.5238, 0.5262) || 挂载数据: 无 ) 
│   │   │   ├── Charles的使用 --> ( 难度等级: [0.5238, 0.5242) || 挂载数据: 无 ) 
│   │   │   ├── mitmproxy的使用 --> ( 难度等级: [0.5242, 0.5246) || 挂载数据: qa: 1 ) 
│   │   │   ├── mitmdump爬取“得到”App电子书 --> ( 难度等级: [0.5246, 0.525) || 挂载数据: qa: 4; blog: 1 ) 
│   │   │   ├── Appium的基本使用 --> ( 难度等级: [0.525, 0.5254) || 挂载数据: qa: 1 ) 
│   │   │   ├── Appium爬取微信朋友圈 --> ( 难度等级: [0.5254, 0.5258) || 挂载数据: qa: 13 ) 
│   │   │   └── Appium+mitmdump爬取京东商品 --> ( 难度等级: [0.5258, 0.5262) || 挂载数据: qa: 1 ) 
│   │   ├── pyspider框架的使用 --> ( 难度等级: [0.5262, 0.5286) || 挂载数据: 无 ) 
│   │   │   ├── pyspider框架介绍 --> ( 难度等级: [0.5262, 0.527) || 挂载数据: 无 ) 
│   │   │   ├── pyspider的基本使用 --> ( 难度等级: [0.527, 0.5278) || 挂载数据: 无 ) 
│   │   │   └── pyspider用法详解 --> ( 难度等级: [0.5278, 0.5286) || 挂载数据: 无 ) 
│   │   ├── 分布式爬虫 --> ( 难度等级: [0.5286, 0.531) || 挂载数据: 无 ) 
│   │   │   ├── 分布式爬虫原理 --> ( 难度等级: [0.5286, 0.5292) || 挂载数据: 无 ) 
│   │   │   ├── Scrapy-Redis源码解析 --> ( 难度等级: [0.5292, 0.5298) || 挂载数据: blog: 1 ) 
│   │   │   ├── Scrapy分布式实现 --> ( 难度等级: [0.5298, 0.5304) || 挂载数据: 无 ) 
│   │   │   └── Bloom Filter的对接 --> ( 难度等级: [0.5304, 0.531) || 挂载数据: 无 ) 
│   │   └── 分布式爬虫的部署 --> ( 难度等级: [0.531, 0.5333) || 挂载数据: 无 ) 
│   │       ├── Scrapyd分布式部署 --> ( 难度等级: [0.531, 0.5314) || 挂载数据: qa: 1 ) 
│   │       ├── Scrapyd-Client的使用 --> ( 难度等级: [0.5314, 0.5319) || 挂载数据: qa: 1 ) 
│   │       ├── Scrapyd对接Docker --> ( 难度等级: [0.5319, 0.5324) || 挂载数据: 无 ) 
│   │       ├── Scrapyd批量部署 --> ( 难度等级: [0.5324, 0.5329) || 挂载数据: qa: 1 ) 
│   │       └── Gerapy分布式管理 --> ( 难度等级: [0.5329, 0.5333) || 挂载数据: 无 ) 
│   ├── 桌面应用开发 --> ( 难度等级: [0.5333, 0.6) || 挂载数据: 无 ) 
│   │   ├── Tkinter --> ( 难度等级: [0.5333, 0.5556) || 挂载数据: qa: 4; blog: 2 ) 
│   │   │   ├── Tkinter简介 --> ( 难度等级: [0.5333, 0.537) || 挂载数据: blog: 1 ) 
│   │   │   ├── 安装配置 --> ( 难度等级: [0.537, 0.5407) || 挂载数据: 无 ) 
│   │   │   ├── Tkinter模块 --> ( 难度等级: [0.5407, 0.5444) || 挂载数据: qa: 1; blog: 2 ) 
│   │   │   ├── Tkinter控件 --> ( 难度等级: [0.5444, 0.5481) || 挂载数据: blog: 9 ) 
│   │   │   ├── 标准属性 --> ( 难度等级: [0.5481, 0.5519) || 挂载数据: 无 ) 
│   │   │   └── 几何管理 --> ( 难度等级: [0.5519, 0.5556) || 挂载数据: 无 ) 
│   │   ├── PyQT --> ( 难度等级: [0.5556, 0.5778) || 挂载数据: 无 ) 
│   │   │   ├── PyQT简介 --> ( 难度等级: [0.5556, 0.558) || 挂载数据: 无 ) 
│   │   │   ├── 安装配置 --> ( 难度等级: [0.558, 0.5605) || 挂载数据: 无 ) 
│   │   │   ├── PyQT模块 --> ( 难度等级: [0.5605, 0.563) || 挂载数据: blog: 2 ) 
│   │   │   ├── PyQT布局管理 --> ( 难度等级: [0.563, 0.5654) || 挂载数据: blog: 4 ) 
│   │   │   ├── PyQT菜单和工具栏 --> ( 难度等级: [0.5654, 0.5679) || 挂载数据: blog: 2 ) 
│   │   │   ├── 事件和信号 --> ( 难度等级: [0.5679, 0.5704) || 挂载数据: 无 ) 
│   │   │   ├── PyQT对话框 --> ( 难度等级: [0.5704, 0.5728) || 挂载数据: blog: 117 ) 
│   │   │   ├── PyQT控件 --> ( 难度等级: [0.5728, 0.5753) || 挂载数据: blog: 4 ) 
│   │   │   └── PyQT拖拽与绘图 --> ( 难度等级: [0.5753, 0.5778) || 挂载数据: blog: 1 ) 
│   │   └── WxPython --> ( 难度等级: [0.5778, 0.6) || 挂载数据: qa: 1 ) 
│   │       ├── WxPython简介 --> ( 难度等级: [0.5778, 0.5802) || 挂载数据: blog: 1 ) 
│   │       ├── 安装配置 --> ( 难度等级: [0.5802, 0.5827) || 挂载数据: 无 ) 
│   │       ├── WxPython常用类 --> ( 难度等级: [0.5827, 0.5852) || 挂载数据: blog: 1 ) 
│   │       ├── WxPython布局管理 --> ( 难度等级: [0.5852, 0.5877) || 挂载数据: blog: 2 ) 
│   │       ├── WxPython事件处理 --> ( 难度等级: [0.5877, 0.5901) || 挂载数据: qa: 10; blog: 173 ) 
│   │       ├── WxPython对话框 --> ( 难度等级: [0.5901, 0.5926) || 挂载数据: blog: 4 ) 
│   │       ├── WxPython组件 --> ( 难度等级: [0.5926, 0.5951) || 挂载数据: qa: 1; blog: 2 ) 
│   │       ├── WxPython拖拽处理 --> ( 难度等级: [0.5951, 0.5975) || 挂载数据: 无 ) 
│   │       └── WxPython绘图API --> ( 难度等级: [0.5975, 0.6) || 挂载数据: blog: 4 ) 
│   └── 其他 --> ( 难度等级: [0.6, 0.6667) || 挂载数据: 无 ) 
│       ├── Python总览 --> ( 难度等级: [0.6, 0.6037) || 挂载数据: 无 ) 
│       │   ├── Python总体架构 --> ( 难度等级: [0.6, 0.6012) || 挂载数据: 无 ) 
│       │   ├── Python源码组织 --> ( 难度等级: [0.6012, 0.6025) || 挂载数据: 无 ) 
│       │   └── Python对象初探 --> ( 难度等级: [0.6025, 0.6037) || 挂载数据: 无 ) 
│       │       ├── Python内的对象 --> ( 难度等级: [0.6025, 0.6026) || 挂载数据: 无 ) 
│       │       ├── 对象的分类 --> ( 难度等级: [0.6026, 0.6027) || 挂载数据: 无 ) 
│       │       ├── 对象机制的基石—PyObject --> ( 难度等级: [0.6027, 0.6029) || 挂载数据: 无 ) 
│       │       ├── 定长对象和变长对象 --> ( 难度等级: [0.6029, 0.603) || 挂载数据: 无 ) 
│       │       ├── 类型对象 --> ( 难度等级: [0.603, 0.6032) || 挂载数据: 无 ) 
│       │       ├── 类型的类型 --> ( 难度等级: [0.6032, 0.6033) || 挂载数据: 无 ) 
│       │       ├── 对象的创建 --> ( 难度等级: [0.6033, 0.6034) || 挂载数据: 无 ) 
│       │       ├── 对象的多态性 --> ( 难度等级: [0.6034, 0.6036) || 挂载数据: 无 ) 
│       │       └── 引用计数 --> ( 难度等级: [0.6036, 0.6037) || 挂载数据: 无 ) 
│       ├── 数字对象 --> ( 难度等级: [0.6037, 0.6074) || 挂载数据: 无 ) 
│       │   ├── 整数对象 --> ( 难度等级: [0.6037, 0.6042) || 挂载数据: 无 ) 
│       │   │   ├── PyLongObject对象 --> ( 难度等级: [0.6037, 0.6039) || 挂载数据: blog: 1 ) 
│       │   │   ├── 小整数对象 --> ( 难度等级: [0.6039, 0.6041) || 挂载数据: 无 ) 
│       │   │   └── 大整数对象 --> ( 难度等级: [0.6041, 0.6042) || 挂载数据: qa: 4 ) 
│       │   ├── 数字格式化输出 --> ( 难度等级: [0.6042, 0.6048) || 挂载数据: qa: 5 ) 
│       │   ├── 进制转换 --> ( 难度等级: [0.6048, 0.6053) || 挂载数据: qa: 3 ) 
│       │   ├── 数字运算 --> ( 难度等级: [0.6053, 0.6058) || 挂载数据: qa: 12 ) 
│       │   │   ├── 四舍五入运算 --> ( 难度等级: [0.6053, 0.6054) || 挂载数据: 无 ) 
│       │   │   ├── 浮点数运算 --> ( 难度等级: [0.6054, 0.6055) || 挂载数据: 无 ) 
│       │   │   ├── 复数运算 --> ( 难度等级: [0.6055, 0.6056) || 挂载数据: 无 ) 
│       │   │   ├── 分数运算 --> ( 难度等级: [0.6056, 0.6056) || 挂载数据: 无 ) 
│       │   │   ├── 大型数组运算 --> ( 难度等级: [0.6056, 0.6057) || 挂载数据: qa: 1 ) 
│       │   │   └── 矩阵与线性代数运算 --> ( 难度等级: [0.6057, 0.6058) || 挂载数据: 无 ) 
│       │   ├── 字节到大整数的打包与解包 --> ( 难度等级: [0.6058, 0.6063) || 挂载数据: 无 ) 
│       │   ├── 无穷大与NaN --> ( 难度等级: [0.6063, 0.6069) || 挂载数据: qa: 2 ) 
│       │   └── 随机数 --> ( 难度等级: [0.6069, 0.6074) || 挂载数据: 无 ) 
│       ├── 字符串 --> ( 难度等级: [0.6074, 0.6111) || 挂载数据: 无 ) 
│       │   ├── 字符串对象解析 --> ( 难度等级: [0.6074, 0.6078) || 挂载数据: 无 ) 
│       │   │   ├── 字符串对象的intern机制 --> ( 难度等级: [0.6074, 0.6076) || 挂载数据: 无 ) 
│       │   │   └── 字符串操作效率 --> ( 难度等级: [0.6076, 0.6078) || 挂载数据: qa: 1 ) 
│       │   ├── 字符串操作 --> ( 难度等级: [0.6078, 0.6082) || 挂载数据: 无 ) 
│       │   │   ├── 字符串分割 --> ( 难度等级: [0.6078, 0.6079) || 挂载数据: qa: 33; blog: 1 ) 
│       │   │   ├── 删除不需要的字符 --> ( 难度等级: [0.6079, 0.6079) || 挂载数据: 无 ) 
│       │   │   ├── 字符串清理 --> ( 难度等级: [0.6079, 0.608) || 挂载数据: 无 ) 
│       │   │   ├── 字符串对齐 --> ( 难度等级: [0.608, 0.6081) || 挂载数据: 无 ) 
│       │   │   ├── 字符串拼接 --> ( 难度等级: [0.6081, 0.6081) || 挂载数据: 无 ) 
│       │   │   ├── 字符串插入 --> ( 难度等级: [0.6081, 0.6082) || 挂载数据: 无 ) 
│       │   │   └── 字符串格式化 --> ( 难度等级: [0.6082, 0.6082) || 挂载数据: qa: 1 ) 
│       │   ├── 字符串匹配 --> ( 难度等级: [0.6082, 0.6086) || 挂载数据: 无 ) 
│       │   │   ├── 字符串开头或结尾匹配 --> ( 难度等级: [0.6082, 0.6083) || 挂载数据: qa: 4 ) 
│       │   │   ├── 用Shell通配符匹配字符串 --> ( 难度等级: [0.6083, 0.6084) || 挂载数据: qa: 1 ) 
│       │   │   ├── 最短匹配 --> ( 难度等级: [0.6084, 0.6085) || 挂载数据: 无 ) 
│       │   │   └── 多行匹配 --> ( 难度等级: [0.6085, 0.6086) || 挂载数据: qa: 20 ) 
│       │   ├── 字符串搜索 --> ( 难度等级: [0.6086, 0.6091) || 挂载数据: 无 ) 
│       │   │   ├── 字符串搜索替换 --> ( 难度等级: [0.6086, 0.6088) || 挂载数据: qa: 4; blog: 2 ) 
│       │   │   └── 字符串忽略大小写的搜索替换 --> ( 难度等级: [0.6088, 0.6091) || 挂载数据: qa: 1 ) 
│       │   ├── 将Unicode文本标准化 --> ( 难度等级: [0.6091, 0.6095) || 挂载数据: 无 ) 
│       │   ├── 在正则表达式中使用Unicode字符 --> ( 难度等级: [0.6095, 0.6099) || 挂载数据: 无 ) 
│       │   ├── 令牌解析 --> ( 难度等级: [0.6099, 0.6103) || 挂载数据: 无 ) 
│       │   ├── 简单的递归下降分析器实现 --> ( 难度等级: [0.6103, 0.6107) || 挂载数据: 无 ) 
│       │   └── 字节字符串操作 --> ( 难度等级: [0.6107, 0.6111) || 挂载数据: 无 ) 
│       ├── 数据结构 --> ( 难度等级: [0.6111, 0.6148) || 挂载数据: 无 ) 
│       │   ├── 序列 --> ( 难度等级: [0.6111, 0.6116) || 挂载数据: 无 ) 
│       │   │   ├── 序列对象解析 --> ( 难度等级: [0.6111, 0.6112) || 挂载数据: 无 ) 
│       │   │   ├── 序列解压 --> ( 难度等级: [0.6112, 0.6113) || 挂载数据: qa: 4 ) 
│       │   │   ├── 序列去重并保持顺序 --> ( 难度等级: [0.6113, 0.6113) || 挂载数据: qa: 1 ) 
│       │   │   ├── 序列元素统计 --> ( 难度等级: [0.6113, 0.6114) || 挂载数据: qa: 1 ) 
│       │   │   ├── 过滤序列元素 --> ( 难度等级: [0.6114, 0.6115) || 挂载数据: 无 ) 
│       │   │   ├── 序列元素名称映射 --> ( 难度等级: [0.6115, 0.6116) || 挂载数据: 无 ) 
│       │   │   └── 转换并计算数据 --> ( 难度等级: [0.6116, 0.6116) || 挂载数据: qa: 1 ) 
│       │   ├── 字典 --> ( 难度等级: [0.6116, 0.6122) || 挂载数据: 无 ) 
│       │   │   ├── 字典对象解析 --> ( 难度等级: [0.6116, 0.6117) || 挂载数据: 无 ) 
│       │   │   ├── 字典映射 --> ( 难度等级: [0.6117, 0.6118) || 挂载数据: 无 ) 
│       │   │   ├── 字典排序 --> ( 难度等级: [0.6118, 0.6118) || 挂载数据: qa: 3 ) 
│       │   │   ├── 字典运算 --> ( 难度等级: [0.6118, 0.6119) || 挂载数据: 无 ) 
│       │   │   ├── 字典查找 --> ( 难度等级: [0.6119, 0.612) || 挂载数据: 无 ) 
│       │   │   ├── 通过关键字排序字典 --> ( 难度等级: [0.612, 0.612) || 挂载数据: 无 ) 
│       │   │   ├── 字典提取 --> ( 难度等级: [0.612, 0.6121) || 挂载数据: qa: 3 ) 
│       │   │   └── 字典合并 --> ( 难度等级: [0.6121, 0.6122) || 挂载数据: qa: 1 ) 
│       │   ├── 可迭代对象操作 --> ( 难度等级: [0.6122, 0.6127) || 挂载数据: 无 ) 
│       │   │   ├── 可迭代对象解压 --> ( 难度等级: [0.6122, 0.6123) || 挂载数据: 无 ) 
│       │   │   ├── 保留最后N个元素 --> ( 难度等级: [0.6123, 0.6125) || 挂载数据: 无 ) 
│       │   │   └── 记录分组 --> ( 难度等级: [0.6125, 0.6127) || 挂载数据: 无 ) 
│       │   ├── 查找最大或最小的N个元素 --> ( 难度等级: [0.6127, 0.6132) || 挂载数据: qa: 2 ) 
│       │   ├── 实现一个优先级队列 --> ( 难度等级: [0.6132, 0.6138) || 挂载数据: 无 ) 
│       │   ├── 命名切片 --> ( 难度等级: [0.6138, 0.6143) || 挂载数据: 无 ) 
│       │   └── 排序不支持原生比较的对象 --> ( 难度等级: [0.6143, 0.6148) || 挂载数据: qa: 1 ) 
│       ├── 迭代器与生成器 --> ( 难度等级: [0.6148, 0.6185) || 挂载数据: 无 ) 
│       │   ├── 迭代操作 --> ( 难度等级: [0.6148, 0.6156) || 挂载数据: 无 ) 
│       │   │   ├── 手动遍历迭代器 --> ( 难度等级: [0.6148, 0.6149) || 挂载数据: 无 ) 
│       │   │   ├── 代理迭代 --> ( 难度等级: [0.6149, 0.6149) || 挂载数据: qa: 2 ) 
│       │   │   ├── 实现迭代协议 --> ( 难度等级: [0.6149, 0.615) || 挂载数据: 无 ) 
│       │   │   ├── 反向迭代 --> ( 难度等级: [0.615, 0.6151) || 挂载数据: qa: 2 ) 
│       │   │   ├── 迭代器切片 --> ( 难度等级: [0.6151, 0.6151) || 挂载数据: 无 ) 
│       │   │   ├── 跳过可迭代对象的开始部分 --> ( 难度等级: [0.6151, 0.6152) || 挂载数据: qa: 1 ) 
│       │   │   ├── 排列组合的迭代 --> ( 难度等级: [0.6152, 0.6152) || 挂载数据: 无 ) 
│       │   │   ├── 序列上索引值迭代 --> ( 难度等级: [0.6152, 0.6153) || 挂载数据: 无 ) 
│       │   │   ├── 多个序列迭代 --> ( 难度等级: [0.6153, 0.6154) || 挂载数据: 无 ) 
│       │   │   ├── 集合元素的迭代 --> ( 难度等级: [0.6154, 0.6154) || 挂载数据: 无 ) 
│       │   │   ├── 顺序迭代合并后的排序迭代对象 --> ( 难度等级: [0.6154, 0.6155) || 挂载数据: qa: 1 ) 
│       │   │   └── 迭代器代替while无限循环 --> ( 难度等级: [0.6155, 0.6156) || 挂载数据: 无 ) 
│       │   ├── 使用生成器创建新的迭代模式 --> ( 难度等级: [0.6156, 0.6163) || 挂载数据: qa: 1 ) 
│       │   ├── 带有外部状态的生成器函数 --> ( 难度等级: [0.6163, 0.617) || 挂载数据: 无 ) 
│       │   ├── 创建数据处理管道 --> ( 难度等级: [0.617, 0.6178) || 挂载数据: 无 ) 
│       │   └── 展开嵌套的序列 --> ( 难度等级: [0.6178, 0.6185) || 挂载数据: 无 ) 
│       ├── 文件与I/O --> ( 难度等级: [0.6185, 0.6222) || 挂载数据: 无 ) 
│       │   ├── 读/写操作 --> ( 难度等级: [0.6185, 0.619) || 挂载数据: 无 ) 
│       │   │   ├── 读/写文本数据 --> ( 难度等级: [0.6185, 0.6187) || 挂载数据: qa: 2 ) 
│       │   │   ├── 读/写字节数据 --> ( 难度等级: [0.6187, 0.6189) || 挂载数据: 无 ) 
│       │   │   └── 读/写压缩文件 --> ( 难度等级: [0.6189, 0.619) || 挂载数据: qa: 41; blog: 1 ) 
│       │   ├── 文件操作 --> ( 难度等级: [0.619, 0.6196) || 挂载数据: 无 ) 
│       │   │   ├── 文件的写入 --> ( 难度等级: [0.619, 0.6191) || 挂载数据: qa: 1 ) 
│       │   │   ├── 操作文件路径名 --> ( 难度等级: [0.6191, 0.6191) || 挂载数据: qa: 2 ) 
│       │   │   ├── 文件检查 --> ( 难度等级: [0.6191, 0.6192) || 挂载数据: 无 ) 
│       │   │   ├── 文件列表获取 --> ( 难度等级: [0.6192, 0.6192) || 挂载数据: qa: 1 ) 
│       │   │   ├── 忽略文件名编码 --> ( 难度等级: [0.6192, 0.6192) || 挂载数据: 无 ) 
│       │   │   ├── 打印不合法的文件名 --> ( 难度等级: [0.6192, 0.6193) || 挂载数据: 无 ) 
│       │   │   ├── 文件编码变更 --> ( 难度等级: [0.6193, 0.6193) || 挂载数据: qa: 2 ) 
│       │   │   ├── 在文本文件中写入字节 --> ( 难度等级: [0.6193, 0.6193) || 挂载数据: 无 ) 
│       │   │   ├── 文件描述符包装 --> ( 难度等级: [0.6193, 0.6194) || 挂载数据: 无 ) 
│       │   │   ├── 创建临时文件和文件夹 --> ( 难度等级: [0.6194, 0.6194) || 挂载数据: 无 ) 
│       │   │   ├── 文件迭代 --> ( 难度等级: [0.6194, 0.6194) || 挂载数据: 无 ) 
│       │   │   ├── 二进制文件映射 --> ( 难度等级: [0.6194, 0.6195) || 挂载数据: qa: 2 ) 
│       │   │   ├── 创建和解压归档文件 --> ( 难度等级: [0.6195, 0.6195) || 挂载数据: 无 ) 
│       │   │   ├── 文件查找 --> ( 难度等级: [0.6195, 0.6195) || 挂载数据: 无 ) 
│       │   │   └── 配置文件读取 --> ( 难度等级: [0.6195, 0.6196) || 挂载数据: 无 ) 
│       │   ├── 使用分隔符或行终止符打印 --> ( 难度等级: [0.6196, 0.6201) || 挂载数据: 无 ) 
│       │   ├── 字符串的I/O操作 --> ( 难度等级: [0.6201, 0.6206) || 挂载数据: qa: 5 ) 
│       │   ├── 可变缓冲区中二进制数据的读取 --> ( 难度等级: [0.6206, 0.6212) || 挂载数据: 无 ) 
│       │   ├── 串行端口的数据通信 --> ( 难度等级: [0.6212, 0.6217) || 挂载数据: 无 ) 
│       │   └── 对象序列化 --> ( 难度等级: [0.6217, 0.6222) || 挂载数据: 无 ) 
│       ├── 数据编码及处理 --> ( 难度等级: [0.6222, 0.6259) || 挂载数据: 无 ) 
│       │   ├── 数据读/写 --> ( 难度等级: [0.6222, 0.623) || 挂载数据: 无 ) 
│       │   │   ├── CSV数据读/写 --> ( 难度等级: [0.6222, 0.6224) || 挂载数据: qa: 2 ) 
│       │   │   ├── JSON数据读/写 --> ( 难度等级: [0.6224, 0.6226) || 挂载数据: 无 ) 
│       │   │   ├── 二进制数组数据读/写 --> ( 难度等级: [0.6226, 0.6228) || 挂载数据: qa: 1 ) 
│       │   │   └── 嵌套和可变长二进制数据读取 --> ( 难度等级: [0.6228, 0.623) || 挂载数据: 无 ) 
│       │   ├── XML数据解析 --> ( 难度等级: [0.623, 0.6237) || 挂载数据: 无 ) 
│       │   │   ├── 简单XML数据解析 --> ( 难度等级: [0.623, 0.6232) || 挂载数据: qa: 7; blog: 2 ) 
│       │   │   ├── 解析XML文档 --> ( 难度等级: [0.6232, 0.6235) || 挂载数据: blog: 3 ) 
│       │   │   └── 修改XML --> ( 难度等级: [0.6235, 0.6237) || 挂载数据: qa: 2; blog: 5 ) 
│       │   ├── 字典转换为XML --> ( 难度等级: [0.6237, 0.6244) || 挂载数据: 无 ) 
│       │   ├── 与关系型数据库的交互 --> ( 难度等级: [0.6244, 0.6252) || 挂载数据: 无 ) 
│       │   └── 编码/解码 --> ( 难度等级: [0.6252, 0.6259) || 挂载数据: 无 ) 
│       │       ├── 十六进制数编码和解码 --> ( 难度等级: [0.6252, 0.6256) || 挂载数据: qa: 5 ) 
│       │       └── 编码/解码Base64数据 --> ( 难度等级: [0.6256, 0.6259) || 挂载数据: qa: 4; blog: 1 ) 
│       ├── 函数 --> ( 难度等级: [0.6259, 0.6296) || 挂载数据: 无 ) 
│       │   ├── 函数定义 --> ( 难度等级: [0.6259, 0.6263) || 挂载数据: 无 ) 
│       │   │   ├── 有默认参数的函数定义 --> ( 难度等级: [0.6259, 0.6261) || 挂载数据: qa: 14 ) 
│       │   │   └── 匿名或内联函数定义 --> ( 难度等级: [0.6261, 0.6263) || 挂载数据: 无 ) 
│       │   ├── 函数的参数 --> ( 难度等级: [0.6263, 0.6267) || 挂载数据: 无 ) 
│       │   │   ├── 接收任意数量参数 --> ( 难度等级: [0.6263, 0.6264) || 挂载数据: 无 ) 
│       │   │   ├── 接收关键字参数 --> ( 难度等级: [0.6264, 0.6265) || 挂载数据: 无 ) 
│       │   │   ├── 为参数增加元信息 --> ( 难度等级: [0.6265, 0.6266) || 挂载数据: qa: 1 ) 
│       │   │   └── 减少参数个数 --> ( 难度等级: [0.6266, 0.6267) || 挂载数据: 无 ) 
│       │   ├── 返回多个值的函数 --> ( 难度等级: [0.6267, 0.627) || 挂载数据: 无 ) 
│       │   ├── 类转换为函数 --> ( 难度等级: [0.627, 0.6274) || 挂载数据: qa: 1 ) 
│       │   ├── 回调函数 --> ( 难度等级: [0.6274, 0.6278) || 挂载数据: 无 ) 
│       │   │   ├── 有额外状态信息的回调函数 --> ( 难度等级: [0.6274, 0.6276) || 挂载数据: 无 ) 
│       │   │   └── 内联回调函数 --> ( 难度等级: [0.6276, 0.6278) || 挂载数据: blog: 1 ) 
│       │   ├── 函数的创建和调用 --> ( 难度等级: [0.6278, 0.6281) || 挂载数据: 无 ) 
│       │   │   ├── 创建一个函数 --> ( 难度等级: [0.6278, 0.628) || 挂载数据: qa: 9 ) 
│       │   │   └── 调用函数 --> ( 难度等级: [0.628, 0.6281) || 挂载数据: 无 ) 
│       │   ├── 参数传递 --> ( 难度等级: [0.6281, 0.6285) || 挂载数据: 无 ) 
│       │   │   ├── 了解形式参数和实际参数 --> ( 难度等级: [0.6281, 0.6282) || 挂载数据: 无 ) 
│       │   │   ├── 位置参数 --> ( 难度等级: [0.6282, 0.6283) || 挂载数据: 无 ) 
│       │   │   ├── 关键字参数 --> ( 难度等级: [0.6283, 0.6284) || 挂载数据: 无 ) 
│       │   │   ├── 为参数设置默认值 --> ( 难度等级: [0.6284, 0.6284) || 挂载数据: 无 ) 
│       │   │   └── 可变参数 --> ( 难度等级: [0.6284, 0.6285) || 挂载数据: 无 ) 
│       │   ├── 返回值 --> ( 难度等级: [0.6285, 0.6289) || 挂载数据: 无 ) 
│       │   ├── 变量的作用域 --> ( 难度等级: [0.6289, 0.6293) || 挂载数据: qa: 2 ) 
│       │   │   ├── 局部变量 --> ( 难度等级: [0.6289, 0.6291) || 挂载数据: 无 ) 
│       │   │   └── 全局变量 --> ( 难度等级: [0.6291, 0.6293) || 挂载数据: 无 ) 
│       │   └── 匿名函数 --> ( 难度等级: [0.6293, 0.6296) || 挂载数据: 无 ) 
│       ├── 元编程 --> ( 难度等级: [0.6296, 0.6333) || 挂载数据: 无 ) 
│       │   ├── 装饰器 --> ( 难度等级: [0.6296, 0.6299) || 挂载数据: 无 ) 
│       │   │   ├── 函数添加装饰器 --> ( 难度等级: [0.6296, 0.6297) || 挂载数据: qa: 1 ) 
│       │   │   ├── 装饰器中保留函数元信息 --> ( 难度等级: [0.6297, 0.6297) || 挂载数据: 无 ) 
│       │   │   ├── 解除装饰器 --> ( 难度等级: [0.6297, 0.6297) || 挂载数据: qa: 3; blog: 3 ) 
│       │   │   ├── 带参数的装饰器 --> ( 难度等级: [0.6297, 0.6297) || 挂载数据: qa: 3; blog: 1 ) 
│       │   │   ├── 装饰器自定义属性 --> ( 难度等级: [0.6297, 0.6297) || 挂载数据: 无 ) 
│       │   │   ├── 带可选参数的装饰器 --> ( 难度等级: [0.6297, 0.6298) || 挂载数据: 无 ) 
│       │   │   ├── 函数的类型检查 --> ( 难度等级: [0.6298, 0.6298) || 挂载数据: 无 ) 
│       │   │   ├── 类中定义装饰器 --> ( 难度等级: [0.6298, 0.6298) || 挂载数据: 无 ) 
│       │   │   ├── 装饰器定义为类 --> ( 难度等级: [0.6298, 0.6298) || 挂载数据: 无 ) 
│       │   │   ├── 类和静态方法的装饰器 --> ( 难度等级: [0.6298, 0.6299) || 挂载数据: 无 ) 
│       │   │   ├── 给函数增加参数 --> ( 难度等级: [0.6299, 0.6299) || 挂载数据: qa: 1 ) 
│       │   │   └── 扩充类的功能 --> ( 难度等级: [0.6299, 0.6299) || 挂载数据: 无 ) 
│       │   ├── 元类 --> ( 难度等级: [0.6299, 0.6302) || 挂载数据: 无 ) 
│       │   │   └── 元类定义可选参数 --> ( 难度等级: [0.6299, 0.6302) || 挂载数据: qa: 1 ) 
│       │   ├── 类的属性定义顺序 --> ( 难度等级: [0.6302, 0.6305) || 挂载数据: 无 ) 
│       │   ├── 强制参数签名 --> ( 难度等级: [0.6305, 0.6308) || 挂载数据: 无 ) 
│       │   ├── 强制使用编程规约 --> ( 难度等级: [0.6308, 0.6311) || 挂载数据: 无 ) 
│       │   ├── 以编程方式定义类 --> ( 难度等级: [0.6311, 0.6313) || 挂载数据: 无 ) 
│       │   ├── 初始化类的成员 --> ( 难度等级: [0.6313, 0.6316) || 挂载数据: 无 ) 
│       │   ├── 利用注解实现方法重载 --> ( 难度等级: [0.6316, 0.6319) || 挂载数据: 无 ) 
│       │   ├── 避免重复的属性方法 --> ( 难度等级: [0.6319, 0.6322) || 挂载数据: 无 ) 
│       │   ├── 定义上下文管理器 --> ( 难度等级: [0.6322, 0.6325) || 挂载数据: 无 ) 
│       │   ├── 局部变量域中执行代码 --> ( 难度等级: [0.6325, 0.6328) || 挂载数据: 无 ) 
│       │   ├── Python源码解析 --> ( 难度等级: [0.6328, 0.633) || 挂载数据: 无 ) 
│       │   └── Python字节码拆解 --> ( 难度等级: [0.633, 0.6333) || 挂载数据: 无 ) 
│       ├── 并发编程 --> ( 难度等级: [0.6333, 0.637) || 挂载数据: 无 ) 
│       │   ├── 线程处理 --> ( 难度等级: [0.6333, 0.6339) || 挂载数据: 无 ) 
│       │   │   ├── 线程的启动与停止 --> ( 难度等级: [0.6333, 0.6334) || 挂载数据: qa: 1 ) 
│       │   │   ├── 线程判断 --> ( 难度等级: [0.6334, 0.6335) || 挂载数据: qa: 4; blog: 1 ) 
│       │   │   ├── 线程间通信 --> ( 难度等级: [0.6335, 0.6336) || 挂载数据: 无 ) 
│       │   │   ├── 线程加锁 --> ( 难度等级: [0.6336, 0.6336) || 挂载数据: 无 ) 
│       │   │   ├── 防止死锁 --> ( 难度等级: [0.6336, 0.6337) || 挂载数据: 无 ) 
│       │   │   ├── 线程状态信息保存 --> ( 难度等级: [0.6337, 0.6338) || 挂载数据: 无 ) 
│       │   │   └── 创建线程池 --> ( 难度等级: [0.6338, 0.6339) || 挂载数据: qa: 1 ) 
│       │   ├── 并行编程 --> ( 难度等级: [0.6339, 0.6344) || 挂载数据: 无 ) 
│       │   ├── Actor任务定义 --> ( 难度等级: [0.6344, 0.6349) || 挂载数据: 无 ) 
│       │   ├── 消息发布/订阅模型 --> ( 难度等级: [0.6349, 0.6354) || 挂载数据: 无 ) 
│       │   ├── 生成器代替线程 --> ( 难度等级: [0.6354, 0.636) || 挂载数据: 无 ) 
│       │   ├── 线程队列轮询 --> ( 难度等级: [0.636, 0.6365) || 挂载数据: 无 ) 
│       │   └── 守护进程 --> ( 难度等级: [0.6365, 0.637) || 挂载数据: 无 ) 
│       ├── 脚本编程与系统管理 --> ( 难度等级: [0.637, 0.6407) || 挂载数据: 无 ) 
│       │   ├── 脚本接收 --> ( 难度等级: [0.637, 0.6374) || 挂载数据: qa: 2 ) 
│       │   ├── 终止程序 --> ( 难度等级: [0.6374, 0.6379) || 挂载数据: 无 ) 
│       │   ├── 解析命令行选项 --> ( 难度等级: [0.6379, 0.6383) || 挂载数据: 无 ) 
│       │   ├── 弹出密码输入提示 --> ( 难度等级: [0.6383, 0.6387) || 挂载数据: qa: 3 ) 
│       │   ├── 执行外部命令 --> ( 难度等级: [0.6387, 0.6391) || 挂载数据: qa: 2 ) 
│       │   ├── 添加日志 --> ( 难度等级: [0.6391, 0.6395) || 挂载数据: 无 ) 
│       │   │   ├── 脚本增加日志功能 --> ( 难度等级: [0.6391, 0.6393) || 挂载数据: 无 ) 
│       │   │   └── 函数库增加日志功能 --> ( 难度等级: [0.6393, 0.6395) || 挂载数据: 无 ) 
│       │   ├── 实现计时器 --> ( 难度等级: [0.6395, 0.6399) || 挂载数据: 无 ) 
│       │   ├── 内存和CPU监测 --> ( 难度等级: [0.6399, 0.6403) || 挂载数据: 无 ) 
│       │   └── 启动Web浏览器 --> ( 难度等级: [0.6403, 0.6407) || 挂载数据: 无 ) 
│       ├── Python的内存管理机制 --> ( 难度等级: [0.6407, 0.6444) || 挂载数据: 无 ) 
│       │   ├── Python内存架构 --> ( 难度等级: [0.6407, 0.6417) || 挂载数据: 无 ) 
│       │   ├── 小块空间的内存池 --> ( 难度等级: [0.6417, 0.6426) || 挂载数据: 无 ) 
│       │   │   ├── block --> ( 难度等级: [0.6417, 0.6419) || 挂载数据: 无 ) 
│       │   │   ├── pool --> ( 难度等级: [0.6419, 0.6421) || 挂载数据: 无 ) 
│       │   │   ├── arena --> ( 难度等级: [0.6421, 0.6424) || 挂载数据: 无 ) 
│       │   │   └── 内存池 --> ( 难度等级: [0.6424, 0.6426) || 挂载数据: qa: 1 ) 
│       │   ├── 循环引用的垃圾收集 --> ( 难度等级: [0.6426, 0.6435) || 挂载数据: 无 ) 
│       │   │   └── 三色标记模型 --> ( 难度等级: [0.6426, 0.6435) || 挂载数据: 无 ) 
│       │   └── Python垃圾收集 --> ( 难度等级: [0.6435, 0.6444) || 挂载数据: 无 ) 
│       │       ├── 可收集对象链表 --> ( 难度等级: [0.6435, 0.6438) || 挂载数据: 无 ) 
│       │       ├── 分代垃圾收集 --> ( 难度等级: [0.6438, 0.6441) || 挂载数据: 无 ) 
│       │       └── Python中的标记—清除方法 --> ( 难度等级: [0.6441, 0.6444) || 挂载数据: 无 ) 
│       ├── 性能优化与实践 --> ( 难度等级: [0.6444, 0.6481) || 挂载数据: 无 ) 
│       │   ├── 优化的规则 --> ( 难度等级: [0.6444, 0.6454) || 挂载数据: 无 ) 
│       │   │   ├── 先使程序可以正常工作 --> ( 难度等级: [0.6444, 0.6448) || 挂载数据: 无 ) 
│       │   │   ├── 从用户的角度进行 --> ( 难度等级: [0.6448, 0.6451) || 挂载数据: 无 ) 
│       │   │   └── 保证代码易读 --> ( 难度等级: [0.6451, 0.6454) || 挂载数据: 无 ) 
│       │   ├── 优化策略 --> ( 难度等级: [0.6454, 0.6463) || 挂载数据: 无 ) 
│       │   │   ├── 寻找其他原因 --> ( 难度等级: [0.6454, 0.6457) || 挂载数据: qa: 7 ) 
│       │   │   ├── 度量硬件 --> ( 难度等级: [0.6457, 0.646) || 挂载数据: 无 ) 
│       │   │   └── 编写速度测试代码 --> ( 难度等级: [0.646, 0.6463) || 挂载数据: 无 ) 
│       │   ├── 查找瓶颈 --> ( 难度等级: [0.6463, 0.6472) || 挂载数据: 无 ) 
│       │   │   ├── 剖析CPU使用情况 --> ( 难度等级: [0.6463, 0.6468) || 挂载数据: qa: 1 ) 
│       │   │   └── 剖析内存使用情况 --> ( 难度等级: [0.6468, 0.6472) || 挂载数据: 无 ) 
│       │   └── 降低复杂度 --> ( 难度等级: [0.6472, 0.6481) || 挂载数据: 无 ) 
│       │       ├── 测量回路复杂度 --> ( 难度等级: [0.6472, 0.6475) || 挂载数据: 无 ) 
│       │       ├── 测量大O记号 --> ( 难度等级: [0.6475, 0.6478) || 挂载数据: 无 ) 
│       │       └── 简化 --> ( 难度等级: [0.6478, 0.6481) || 挂载数据: qa: 1 ) 
│       ├── 通用应用主题 --> ( 难度等级: [0.6481, 0.6519) || 挂载数据: 无 ) 
│       │   ├── 因特网客户端编程 --> ( 难度等级: [0.6481, 0.6488) || 挂载数据: 无 ) 
│       │   │   ├── 因特网客户端简介 --> ( 难度等级: [0.6481, 0.6484) || 挂载数据: 无 ) 
│       │   │   ├── 文件传输 --> ( 难度等级: [0.6484, 0.6486) || 挂载数据: 无 ) 
│       │   │   │   ├── 文件传输因特网协议 --> ( 难度等级: [0.6484, 0.6484) || 挂载数据: 无 ) 
│       │   │   │   ├── 文件传输协议 --> ( 难度等级: [0.6484, 0.6484) || 挂载数据: 无 ) 
│       │   │   │   ├── ftplib.FTP类的方法 --> ( 难度等级: [0.6484, 0.6485) || 挂载数据: 无 ) 
│       │   │   │   ├── 交互式FTP示例 --> ( 难度等级: [0.6485, 0.6485) || 挂载数据: 无 ) 
│       │   │   │   ├── 客户端FTP程序示例 --> ( 难度等级: [0.6485, 0.6485) || 挂载数据: 无 ) 
│       │   │   │   └── FTP的其他内容 --> ( 难度等级: [0.6485, 0.6486) || 挂载数据: qa: 1; blog: 1 ) 
│       │   │   └── 网络新闻 --> ( 难度等级: [0.6486, 0.6488) || 挂载数据: 无 ) 
│       │   │       ├── Usenet与新闻组 --> ( 难度等级: [0.6486, 0.6486) || 挂载数据: 无 ) 
│       │   │       ├── 网络新闻传输协议 --> ( 难度等级: [0.6486, 0.6486) || 挂载数据: 无 ) 
│       │   │       ├── nntplib.NNTP类方法 --> ( 难度等级: [0.6486, 0.6487) || 挂载数据: 无 ) 
│       │   │       ├── 交互式NNTP示例 --> ( 难度等级: [0.6487, 0.6487) || 挂载数据: 无 ) 
│       │   │       ├── 客户端程序NNTP示例 --> ( 难度等级: [0.6487, 0.6487) || 挂载数据: 无 ) 
│       │   │       └── NNTP的其他内容 --> ( 难度等级: [0.6487, 0.6488) || 挂载数据: 无 ) 
│       │   ├── 多线程编程 --> ( 难度等级: [0.6488, 0.6494) || 挂载数据: 无 ) 
│       │   │   ├── thread模块 --> ( 难度等级: [0.6488, 0.6489) || 挂载数据: 无 ) 
│       │   │   ├── threading模块 --> ( 难度等级: [0.6489, 0.649) || 挂载数据: 无 ) 
│       │   │   │   ├── Thread类 --> ( 难度等级: [0.6489, 0.649) || 挂载数据: blog: 5 ) 
│       │   │   │   └── threading模块的其他函数 --> ( 难度等级: [0.649, 0.649) || 挂载数据: qa: 2; blog: 3 ) 
│       │   │   ├── 单线程和多线程执行对比 --> ( 难度等级: [0.649, 0.6491) || 挂载数据: qa: 1 ) 
│       │   │   ├── 多线程实践 --> ( 难度等级: [0.6491, 0.6493) || 挂载数据: qa: 5; blog: 1 ) 
│       │   │   │   ├── 图书排名示例 --> ( 难度等级: [0.6491, 0.6492) || 挂载数据: 无 ) 
│       │   │   │   ├── 同步原语 --> ( 难度等级: [0.6492, 0.6492) || 挂载数据: qa: 1 ) 
│       │   │   │   ├── 锁示例 --> ( 难度等级: [0.6492, 0.6492) || 挂载数据: 无 ) 
│       │   │   │   └── 信号量示例 --> ( 难度等级: [0.6492, 0.6493) || 挂载数据: 无 ) 
│       │   │   └── 线程的替代方案 --> ( 难度等级: [0.6493, 0.6494) || 挂载数据: qa: 1 ) 
│       │   │       ├── subprocess模块 --> ( 难度等级: [0.6493, 0.6493) || 挂载数据: qa: 1; blog: 1 ) 
│       │   │       ├── multiprocessing模块 --> ( 难度等级: [0.6493, 0.6493) || 挂载数据: 无 ) 
│       │   │       └── concurrent.futures模块 --> ( 难度等级: [0.6493, 0.6494) || 挂载数据: 无 ) 
│       │   ├── GUI编程 --> ( 难度等级: [0.6494, 0.65) || 挂载数据: 无 ) 
│       │   │   ├── Tkinter示例 --> ( 难度等级: [0.6494, 0.6497) || 挂载数据: 无 ) 
│       │   │   │   ├── Label控件 --> ( 难度等级: [0.6494, 0.6494) || 挂载数据: qa: 1; blog: 7 ) 
│       │   │   │   ├── Button控件 --> ( 难度等级: [0.6494, 0.6495) || 挂载数据: qa: 3; blog: 15 ) 
│       │   │   │   ├── Label和Button控件 --> ( 难度等级: [0.6495, 0.6495) || 挂载数据: 无 ) 
│       │   │   │   ├── Label、Button和Scale控件 --> ( 难度等级: [0.6495, 0.6496) || 挂载数据: 无 ) 
│       │   │   │   ├── 偏函数应用示例 --> ( 难度等级: [0.6496, 0.6496) || 挂载数据: 无 ) 
│       │   │   │   └── 中级Tkinter示例 --> ( 难度等级: [0.6496, 0.6497) || 挂载数据: qa: 20; blog: 224 ) 
│       │   │   └── 其他GUI简介 --> ( 难度等级: [0.6497, 0.65) || 挂载数据: 无 ) 
│       │   │       ├── Tk接口扩展（Tix） --> ( 难度等级: [0.6497, 0.6498) || 挂载数据: 无 ) 
│       │   │       ├── Python MegaWidgets（PMW） --> ( 难度等级: [0.6498, 0.6498) || 挂载数据: 无 ) 
│       │   │       ├── GTK+和PyGTK --> ( 难度等级: [0.6498, 0.6499) || 挂载数据: blog: 1 ) 
│       │   │       └── Tile/Ttk --> ( 难度等级: [0.6499, 0.65) || 挂载数据: blog: 2 ) 
│       │   ├── 数据库编程 --> ( 难度等级: [0.65, 0.6506) || 挂载数据: qa: 1 ) 
│       │   │   ├── Python的DB-API --> ( 难度等级: [0.65, 0.6502) || 挂载数据: qa: 1; blog: 2 ) 
│       │   │   │   ├── 模块属性 --> ( 难度等级: [0.65, 0.65) || 挂载数据: 无 ) 
│       │   │   │   ├── Connection对象 --> ( 难度等级: [0.65, 0.6501) || 挂载数据: blog: 1 ) 
│       │   │   │   ├── Cursor对象 --> ( 难度等级: [0.6501, 0.6501) || 挂载数据: qa: 3 ) 
│       │   │   │   ├── 关系数据库 --> ( 难度等级: [0.6501, 0.6501) || 挂载数据: 无 ) 
│       │   │   │   ├── 使用数据库适配器的示例 --> ( 难度等级: [0.6501, 0.6501) || 挂载数据: blog: 1 ) 
│       │   │   │   └── 数据库适配器示例应用 --> ( 难度等级: [0.6501, 0.6502) || 挂载数据: 无 ) 
│       │   │   ├── ORM --> ( 难度等级: [0.6502, 0.6503) || 挂载数据: 无 ) 
│       │   │   │   ├── 考虑对象，而不是SQL --> ( 难度等级: [0.6502, 0.6502) || 挂载数据: 无 ) 
│       │   │   │   ├── 员工角色数据库示例 --> ( 难度等级: [0.6502, 0.6502) || 挂载数据: 无 ) 
│       │   │   │   ├── SQLAlchemy --> ( 难度等级: [0.6502, 0.6503) || 挂载数据: qa: 2 ) 
│       │   │   │   └── SQLObject --> ( 难度等级: [0.6503, 0.6503) || 挂载数据: 无 ) 
│       │   │   ├── 非关系数据库 --> ( 难度等级: [0.6503, 0.6505) || 挂载数据: 无 ) 
│       │   │   │   └── NoSQL介绍 --> ( 难度等级: [0.6503, 0.6505) || 挂载数据: 无 ) 
│       │   │   └── 相关文献 --> ( 难度等级: [0.6505, 0.6506) || 挂载数据: 无 ) 
│       │   ├── *Microsoft Office编程 --> ( 难度等级: [0.6506, 0.6512) || 挂载数据: 无 ) 
│       │   │   ├── 使用Python进行COM客户端编程 --> ( 难度等级: [0.6506, 0.6508) || 挂载数据: 无 ) 
│       │   │   │   ├── 客户端COM编程 --> ( 难度等级: [0.6506, 0.6507) || 挂载数据: qa: 23; blog: 8 ) 
│       │   │   │   └── 入门 --> ( 难度等级: [0.6507, 0.6508) || 挂载数据: qa: 6; blog: 4 ) 
│       │   │   ├── 入门示例 --> ( 难度等级: [0.6508, 0.6509) || 挂载数据: 无 ) 
│       │   │   │   ├── Excel --> ( 难度等级: [0.6508, 0.6508) || 挂载数据: 无 ) 
│       │   │   │   ├── Word --> ( 难度等级: [0.6508, 0.6508) || 挂载数据: 无 ) 
│       │   │   │   ├── PowerPoint --> ( 难度等级: [0.6508, 0.6509) || 挂载数据: 无 ) 
│       │   │   │   └── Outlook --> ( 难度等级: [0.6509, 0.6509) || 挂载数据: 无 ) 
│       │   │   ├── 中级示例 --> ( 难度等级: [0.6509, 0.6511) || 挂载数据: 无 ) 
│       │   │   │   ├── Excel --> ( 难度等级: [0.6509, 0.651) || 挂载数据: 无 ) 
│       │   │   │   ├── Outlook --> ( 难度等级: [0.651, 0.651) || 挂载数据: qa: 1 ) 
│       │   │   │   └── PowerPoint --> ( 难度等级: [0.651, 0.6511) || 挂载数据: 无 ) 
│       │   │   └── 相关模块/包 --> ( 难度等级: [0.6511, 0.6512) || 挂载数据: 无 ) 
│       │   └── 扩展Python --> ( 难度等级: [0.6512, 0.6519) || 挂载数据: 无 ) 
│       │       ├── 编写Python扩展 --> ( 难度等级: [0.6512, 0.6515) || 挂载数据: 无 ) 
│       │       │   ├── 根据样板编写封装代码 --> ( 难度等级: [0.6512, 0.6513) || 挂载数据: qa: 14 ) 
│       │       │   ├── 编译 --> ( 难度等级: [0.6513, 0.6514) || 挂载数据: qa: 2 ) 
│       │       │   └── 导入并测试 --> ( 难度等级: [0.6514, 0.6515) || 挂载数据: 无 ) 
│       │       └── 相关主题 --> ( 难度等级: [0.6515, 0.6519) || 挂载数据: qa: 2 ) 
│       │           ├── SWIG --> ( 难度等级: [0.6515, 0.6516) || 挂载数据: 无 ) 
│       │           ├── Pyrex --> ( 难度等级: [0.6516, 0.6516) || 挂载数据: 无 ) 
│       │           ├── Cython --> ( 难度等级: [0.6516, 0.6517) || 挂载数据: 无 ) 
│       │           ├── Psyco --> ( 难度等级: [0.6517, 0.6517) || 挂载数据: 无 ) 
│       │           ├── PyPy --> ( 难度等级: [0.6517, 0.6518) || 挂载数据: blog: 2 ) 
│       │           └── 嵌入Python --> ( 难度等级: [0.6518, 0.6519) || 挂载数据: 无 ) 
│       ├── Python中使用正则表达式 --> ( 难度等级: [0.6519, 0.6556) || 挂载数据: 无 ) 
│       │   ├── 正则表达式语法 --> ( 难度等级: [0.6519, 0.6537) || 挂载数据: qa: 1 ) 
│       │   │   ├── 行定位符 --> ( 难度等级: [0.6519, 0.6521) || 挂载数据: 无 ) 
│       │   │   ├── 元字符 --> ( 难度等级: [0.6521, 0.6523) || 挂载数据: 无 ) 
│       │   │   ├── 重复 --> ( 难度等级: [0.6523, 0.6525) || 挂载数据: qa: 1 ) 
│       │   │   ├── 字符类 --> ( 难度等级: [0.6525, 0.6527) || 挂载数据: 无 ) 
│       │   │   ├── 排除字符 --> ( 难度等级: [0.6527, 0.6529) || 挂载数据: qa: 2 ) 
│       │   │   ├── 选择字符 --> ( 难度等级: [0.6529, 0.6531) || 挂载数据: qa: 3 ) 
│       │   │   ├── 转义字符 --> ( 难度等级: [0.6531, 0.6533) || 挂载数据: qa: 2 ) 
│       │   │   ├── 分组 --> ( 难度等级: [0.6533, 0.6535) || 挂载数据: qa: 2 ) 
│       │   │   └── 在Python中使用正则 --> ( 难度等级: [0.6535, 0.6537) || 挂载数据: qa: 2 ) 
│       │   └── 使用re模块实现正则表达式操作 --> ( 难度等级: [0.6537, 0.6556) || 挂载数据: qa: 1 ) 
│       │       ├── 替换字符串 --> ( 难度等级: [0.6537, 0.6546) || 挂载数据: qa: 1 ) 
│       │       └── 使用正则表达式分割字符串 --> ( 难度等级: [0.6546, 0.6556) || 挂载数据: qa: 20; blog: 1 ) 
│       ├── 面向对象程序设计 --> ( 难度等级: [0.6556, 0.6593) || 挂载数据: 无 ) 
│       │   ├── 面向对象概述 --> ( 难度等级: [0.6556, 0.6568) || 挂载数据: 无 ) 
│       │   │   └── 面向对象程序设计的特点 --> ( 难度等级: [0.6556, 0.6568) || 挂载数据: qa: 6 ) 
│       │   ├── 类的定义和使用 --> ( 难度等级: [0.6568, 0.658) || 挂载数据: 无 ) 
│       │   │   ├── 定义类 --> ( 难度等级: [0.6568, 0.6571) || 挂载数据: qa: 10 ) 
│       │   │   ├── 创建__init__方法 --> ( 难度等级: [0.6571, 0.6574) || 挂载数据: qa: 2 ) 
│       │   │   ├── 创建类的成员并访问 --> ( 难度等级: [0.6574, 0.6577) || 挂载数据: qa: 1 ) 
│       │   │   └── 访问限制 --> ( 难度等级: [0.6577, 0.658) || 挂载数据: qa: 1 ) 
│       │   └── 继承 --> ( 难度等级: [0.658, 0.6593) || 挂载数据: 无 ) 
│       │       ├── 继承的基本语法 --> ( 难度等级: [0.658, 0.6584) || 挂载数据: qa: 1 ) 
│       │       ├── 方法重写 --> ( 难度等级: [0.6584, 0.6588) || 挂载数据: 无 ) 
│       │       └── 派生类中调用基类的__init__方法 --> ( 难度等级: [0.6588, 0.6593) || 挂载数据: qa: 1 ) 
│       ├── 模块 --> ( 难度等级: [0.6593, 0.663) || 挂载数据: 无 ) 
│       │   ├── 模块概述 --> ( 难度等级: [0.6593, 0.6602) || 挂载数据: 无 ) 
│       │   ├── 自定义模块 --> ( 难度等级: [0.6602, 0.6611) || 挂载数据: 无 ) 
│       │   │   ├── 创建模块 --> ( 难度等级: [0.6602, 0.6604) || 挂载数据: qa: 13; blog: 3 ) 
│       │   │   ├── 使用import语句导入模块 --> ( 难度等级: [0.6604, 0.6606) || 挂载数据: qa: 9; blog: 1 ) 
│       │   │   ├── 使用from…import语句 --> ( 难度等级: [0.6606, 0.6609) || 挂载数据: qa: 1; blog: 5 ) 
│       │   │   └── 模块搜索目录 --> ( 难度等级: [0.6609, 0.6611) || 挂载数据: 无 ) 
│       │   ├── Python中的包 --> ( 难度等级: [0.6611, 0.662) || 挂载数据: 无 ) 
│       │   │   ├── Python程序的包结构 --> ( 难度等级: [0.6611, 0.6616) || 挂载数据: 无 ) 
│       │   │   └── 以主程序的形式执行 --> ( 难度等级: [0.6616, 0.662) || 挂载数据: 无 ) 
│       │   └── 引用其他模块 --> ( 难度等级: [0.662, 0.663) || 挂载数据: 无 ) 
│       └── 异常处理及程序调试 --> ( 难度等级: [0.663, 0.6667) || 挂载数据: 无 ) 
│           ├── 异常概述 --> ( 难度等级: [0.663, 0.6642) || 挂载数据: 无 ) 
│           ├── 异常处理语句 --> ( 难度等级: [0.6642, 0.6654) || 挂载数据: 无 ) 
│           │   ├── try…except语句 --> ( 难度等级: [0.6642, 0.6645) || 挂载数据: qa: 3 ) 
│           │   ├── try…except…else语句 --> ( 难度等级: [0.6645, 0.6648) || 挂载数据: 无 ) 
│           │   ├── try…except…finally语句 --> ( 难度等级: [0.6648, 0.6651) || 挂载数据: 无 ) 
│           │   └── 使用raise语句抛出异常 --> ( 难度等级: [0.6651, 0.6654) || 挂载数据: qa: 2; blog: 3 ) 
│           └── 程序调试 --> ( 难度等级: [0.6654, 0.6667) || 挂载数据: 无 ) 
│               ├── 使用自带的IDLE进行程序调试 --> ( 难度等级: [0.6654, 0.666) || 挂载数据: 无 ) 
│               └── 使用assert语句调试程序 --> ( 难度等级: [0.666, 0.6667) || 挂载数据: qa: 1 ) 
├── Python高阶 --> ( 难度等级: [0.6667, 1.0) || 挂载数据: 无 ) 
│   ├── 科学计算基础软件包NumPy --> ( 难度等级: [0.6667, 0.7083) || 挂载数据: 无 ) 
│   │   ├── NumPy概述 --> ( 难度等级: [0.6667, 0.6719) || 挂载数据: 无 ) 
│   │   │   ├── NumPy的前世今生 --> ( 难度等级: [0.6667, 0.6677) || 挂载数据: 无 ) 
│   │   │   ├── NumPy数组vs Python列表 --> ( 难度等级: [0.6677, 0.6687) || 挂载数据: 无 ) 
│   │   │   ├── NumPy数组类型和属性 --> ( 难度等级: [0.6687, 0.6698) || 挂载数据: 无 ) 
│   │   │   ├── 维、轴、秩 --> ( 难度等级: [0.6698, 0.6708) || 挂载数据: 无 ) 
│   │   │   └── 广播和矢量化 --> ( 难度等级: [0.6708, 0.6719) || 挂载数据: 无 ) 
│   │   ├── 安装配置 --> ( 难度等级: [0.6719, 0.6771) || 挂载数据: 无 ) 
│   │   ├── 创建数组 --> ( 难度等级: [0.6771, 0.6823) || 挂载数据: 无 ) 
│   │   ├── 操作数组 --> ( 难度等级: [0.6823, 0.6875) || 挂载数据: 无 ) 
│   │   │   ├── 索引 --> ( 难度等级: [0.6823, 0.6829) || 挂载数据: 无 ) 
│   │   │   ├── 切片 --> ( 难度等级: [0.6829, 0.6834) || 挂载数据: qa: 2 ) 
│   │   │   ├── 改变数组结构 --> ( 难度等级: [0.6834, 0.684) || 挂载数据: 无 ) 
│   │   │   ├── 合并和拆分 --> ( 难度等级: [0.684, 0.6846) || 挂载数据: 无 ) 
│   │   │   ├── 复制 --> ( 难度等级: [0.6846, 0.6852) || 挂载数据: 无 ) 
│   │   │   ├── 排序 --> ( 难度等级: [0.6852, 0.6858) || 挂载数据: 无 ) 
│   │   │   ├── 查找 --> ( 难度等级: [0.6858, 0.6863) || 挂载数据: qa: 2 ) 
│   │   │   ├── 筛选 --> ( 难度等级: [0.6863, 0.6869) || 挂载数据: qa: 1 ) 
│   │   │   └── 数组I/O --> ( 难度等级: [0.6869, 0.6875) || 挂载数据: qa: 1 ) 
│   │   ├── 常用函数 --> ( 难度等级: [0.6875, 0.6927) || 挂载数据: 无 ) 
│   │   │   ├── np.nan和np.inf --> ( 难度等级: [0.6875, 0.6882) || 挂载数据: qa: 4 ) 
│   │   │   ├── 函数命名空间 --> ( 难度等级: [0.6882, 0.689) || 挂载数据: 无 ) 
│   │   │   ├── 数学函数 --> ( 难度等级: [0.689, 0.6897) || 挂载数据: 无 ) 
│   │   │   ├── 统计函数 --> ( 难度等级: [0.6897, 0.6905) || 挂载数据: 无 ) 
│   │   │   ├── 插值函数 --> ( 难度等级: [0.6905, 0.6912) || 挂载数据: 无 ) 
│   │   │   ├── 多项式拟合函数 --> ( 难度等级: [0.6912, 0.692) || 挂载数据: 无 ) 
│   │   │   └── 自定义广播函数 --> ( 难度等级: [0.692, 0.6927) || 挂载数据: 无 ) 
│   │   ├── 掩码数组 --> ( 难度等级: [0.6927, 0.6979) || 挂载数据: 无 ) 
│   │   │   ├── 创建掩码数组 --> ( 难度等级: [0.6927, 0.6953) || 挂载数据: 无 ) 
│   │   │   └── 访问掩码数组 --> ( 难度等级: [0.6953, 0.6979) || 挂载数据: 无 ) 
│   │   ├── 矩阵对象 --> ( 难度等级: [0.6979, 0.7031) || 挂载数据: 无 ) 
│   │   │   ├── 创建矩阵 --> ( 难度等级: [0.6979, 0.6997) || 挂载数据: qa: 3 ) 
│   │   │   ├── 矩阵特有属性 --> ( 难度等级: [0.6997, 0.7014) || 挂载数据: 无 ) 
│   │   │   └── 矩阵乘法 --> ( 难度等级: [0.7014, 0.7031) || 挂载数据: 无 ) 
│   │   └── 随机抽样子模块 --> ( 难度等级: [0.7031, 0.7083) || 挂载数据: 无 ) 
│   │       ├── 随机数 --> ( 难度等级: [0.7031, 0.7044) || 挂载数据: 无 ) 
│   │       ├── 随机抽样 --> ( 难度等级: [0.7044, 0.7057) || 挂载数据: 无 ) 
│   │       ├── 正态分布 --> ( 难度等级: [0.7057, 0.707) || 挂载数据: 无 ) 
│   │       └── 伪随机数的深度思考 --> ( 难度等级: [0.707, 0.7083) || 挂载数据: 无 ) 
│   ├── 结构化数据分析工具Pandas --> ( 难度等级: [0.7083, 0.75) || 挂载数据: 无 ) 
│   │   ├── Pandas概览 --> ( 难度等级: [0.7083, 0.7188) || 挂载数据: 无 ) 
│   │   │   ├── Panda的特点 --> ( 难度等级: [0.7083, 0.7135) || 挂载数据: 无 ) 
│   │   │   └── 安装和使用 --> ( 难度等级: [0.7135, 0.7188) || 挂载数据: qa: 1 ) 
│   │   ├── 数据结构 --> ( 难度等级: [0.7188, 0.7292) || 挂载数据: 无 ) 
│   │   │   ├── 索引数组Index --> ( 难度等级: [0.7188, 0.7222) || 挂载数据: 无 ) 
│   │   │   ├── 带标签的一维同构数组Series --> ( 难度等级: [0.7222, 0.7257) || 挂载数据: 无 ) 
│   │   │   └── 带标签的二维异构表格DataFrame --> ( 难度等级: [0.7257, 0.7292) || 挂载数据: qa: 2 ) 
│   │   ├── 基本操作 --> ( 难度等级: [0.7292, 0.7396) || 挂载数据: 无 ) 
│   │   │   ├── 数据预览 --> ( 难度等级: [0.7292, 0.7309) || 挂载数据: 无 ) 
│   │   │   ├── 数据选择 --> ( 难度等级: [0.7309, 0.7326) || 挂载数据: 无 ) 
│   │   │   ├── 改变数据结构 --> ( 难度等级: [0.7326, 0.7344) || 挂载数据: 无 ) 
│   │   │   ├── 改变数据类型 --> ( 难度等级: [0.7344, 0.7361) || 挂载数据: 无 ) 
│   │   │   ├── 广播与矢量化运算 --> ( 难度等级: [0.7361, 0.7378) || 挂载数据: 无 ) 
│   │   │   └── 行列级广播函数 --> ( 难度等级: [0.7378, 0.7396) || 挂载数据: qa: 1 ) 
│   │   └── 高级应用 --> ( 难度等级: [0.7396, 0.75) || 挂载数据: 无 ) 
│   │       ├── 分组 --> ( 难度等级: [0.7396, 0.7409) || 挂载数据: 无 ) 
│   │       ├── 聚合 --> ( 难度等级: [0.7409, 0.7422) || 挂载数据: 无 ) 
│   │       ├── 层次化索引 --> ( 难度等级: [0.7422, 0.7435) || 挂载数据: 无 ) 
│   │       ├── 表级广播函数 --> ( 难度等级: [0.7435, 0.7448) || 挂载数据: 无 ) 
│   │       ├── 日期时间索引对象 --> ( 难度等级: [0.7448, 0.7461) || 挂载数据: 无 ) 
│   │       ├── 透视表 --> ( 难度等级: [0.7461, 0.7474) || 挂载数据: 无 ) 
│   │       ├── 数据可视化 --> ( 难度等级: [0.7474, 0.7487) || 挂载数据: qa: 4; blog: 3 ) 
│   │       └── 数据I/O --> ( 难度等级: [0.7487, 0.75) || 挂载数据: 无 ) 
│   ├── 绘图库Matplotlib --> ( 难度等级: [0.75, 0.7917) || 挂载数据: 无 ) 
│   │   ├── 安装配置 --> ( 难度等级: [0.75, 0.7583) || 挂载数据: 无 ) 
│   │   ├── Matplotlib快速入门 --> ( 难度等级: [0.7583, 0.7667) || 挂载数据: blog: 1 ) 
│   │   │   ├── 画布 --> ( 难度等级: [0.7583, 0.76) || 挂载数据: qa: 1 ) 
│   │   │   ├── 子图与子图布局 --> ( 难度等级: [0.76, 0.7617) || 挂载数据: 无 ) 
│   │   │   ├── 坐标轴与刻度的名称 --> ( 难度等级: [0.7617, 0.7633) || 挂载数据: qa: 1 ) 
│   │   │   ├── 图例和文本标注 --> ( 难度等级: [0.7633, 0.765) || 挂载数据: 无 ) 
│   │   │   └── 显示和保存 --> ( 难度等级: [0.765, 0.7667) || 挂载数据: 无 ) 
│   │   ├── 图形绘制 --> ( 难度等级: [0.7667, 0.775) || 挂载数据: qa: 2 ) 
│   │   │   ├── 曲线图 --> ( 难度等级: [0.7667, 0.7679) || 挂载数据: 无 ) 
│   │   │   ├── 散点图 --> ( 难度等级: [0.7679, 0.769) || 挂载数据: 无 ) 
│   │   │   ├── 直方图 --> ( 难度等级: [0.769, 0.7702) || 挂载数据: 无 ) 
│   │   │   ├── 饼图 --> ( 难度等级: [0.7702, 0.7714) || 挂载数据: qa: 1 ) 
│   │   │   ├── 箱线图 --> ( 难度等级: [0.7714, 0.7726) || 挂载数据: 无 ) 
│   │   │   ├── 绘制图像 --> ( 难度等级: [0.7726, 0.7738) || 挂载数据: qa: 10; blog: 2 ) 
│   │   │   └── 极坐标绘图 --> ( 难度等级: [0.7738, 0.775) || 挂载数据: qa: 1 ) 
│   │   ├── 风格和样式 --> ( 难度等级: [0.775, 0.7833) || 挂载数据: 无 ) 
│   │   │   ├── 画布设置 --> ( 难度等级: [0.775, 0.7759) || 挂载数据: 无 ) 
│   │   │   ├── 子图布局 --> ( 难度等级: [0.7759, 0.7769) || 挂载数据: 无 ) 
│   │   │   ├── 颜色 --> ( 难度等级: [0.7769, 0.7778) || 挂载数据: 无 ) 
│   │   │   ├── 线条和点的样式 --> ( 难度等级: [0.7778, 0.7787) || 挂载数据: 无 ) 
│   │   │   ├── 坐标轴 --> ( 难度等级: [0.7787, 0.7796) || 挂载数据: 无 ) 
│   │   │   ├── 刻度 --> ( 难度等级: [0.7796, 0.7806) || 挂载数据: 无 ) 
│   │   │   ├── 文本 --> ( 难度等级: [0.7806, 0.7815) || 挂载数据: 无 ) 
│   │   │   ├── 图例 --> ( 难度等级: [0.7815, 0.7824) || 挂载数据: 无 ) 
│   │   │   └── 网格设置 --> ( 难度等级: [0.7824, 0.7833) || 挂载数据: 无 ) 
│   │   └── Matplotlib扩展 --> ( 难度等级: [0.7833, 0.7917) || 挂载数据: 无 ) 
│   │       ├── 使用BaseMap绘制地图 --> ( 难度等级: [0.7833, 0.7875) || 挂载数据: qa: 1 ) 
│   │       └── 3D绘图工具包 --> ( 难度等级: [0.7875, 0.7917) || 挂载数据: blog: 1 ) 
│   ├── 科学计算工具包SciPy --> ( 难度等级: [0.7917, 0.8333) || 挂载数据: 无 ) 
│   │   ├── SciPy概览 --> ( 难度等级: [0.7917, 0.7955) || 挂载数据: qa: 1; blog: 133 ) 
│   │   ├── 安装配置 --> ( 难度等级: [0.7955, 0.7992) || 挂载数据: 无 ) 
│   │   ├── 数据插值 --> ( 难度等级: [0.7992, 0.803) || 挂载数据: 无 ) 
│   │   │   ├── 一维插值 --> ( 难度等级: [0.7992, 0.8005) || 挂载数据: 无 ) 
│   │   │   ├── 二维插值 --> ( 难度等级: [0.8005, 0.8018) || 挂载数据: 无 ) 
│   │   │   └── 离散数据插值到网格 --> ( 难度等级: [0.8018, 0.803) || 挂载数据: 无 ) 
│   │   ├── 曲线拟合 --> ( 难度等级: [0.803, 0.8068) || 挂载数据: 无 ) 
│   │   │   ├── 最小二乘法拟合 --> ( 难度等级: [0.803, 0.8043) || 挂载数据: 无 ) 
│   │   │   ├── 使用curve_fit函数拟合 --> ( 难度等级: [0.8043, 0.8056) || 挂载数据: qa: 1; blog: 5 ) 
│   │   │   └── 多项式拟合函数 --> ( 难度等级: [0.8056, 0.8068) || 挂载数据: 无 ) 
│   │   ├── 傅里叶变换 --> ( 难度等级: [0.8068, 0.8106) || 挂载数据: 无 ) 
│   │   │   ├── 时域到频域的转换 --> ( 难度等级: [0.8068, 0.8081) || 挂载数据: 无 ) 
│   │   │   ├── 一维傅里叶变换的应用 --> ( 难度等级: [0.8081, 0.8093) || 挂载数据: 无 ) 
│   │   │   └── 二维傅里叶变换的应用 --> ( 难度等级: [0.8093, 0.8106) || 挂载数据: 无 ) 
│   │   ├── 图像处理 --> ( 难度等级: [0.8106, 0.8144) || 挂载数据: 无 ) 
│   │   │   ├── 图像卷积 --> ( 难度等级: [0.8106, 0.8116) || 挂载数据: 无 ) 
│   │   │   ├── 边缘检测 --> ( 难度等级: [0.8116, 0.8125) || 挂载数据: 无 ) 
│   │   │   ├── 侵蚀和膨胀 --> ( 难度等级: [0.8125, 0.8134) || 挂载数据: 无 ) 
│   │   │   └── 图像测量 --> ( 难度等级: [0.8134, 0.8144) || 挂载数据: 无 ) 
│   │   ├── 积分 --> ( 难度等级: [0.8144, 0.8182) || 挂载数据: 无 ) 
│   │   │   ├── 对给定函数的定积分 --> ( 难度等级: [0.8144, 0.8157) || 挂载数据: 无 ) 
│   │   │   ├── 对给定样本的定积分 --> ( 难度等级: [0.8157, 0.8169) || 挂载数据: 无 ) 
│   │   │   └── 二重定积分 --> ( 难度等级: [0.8169, 0.8182) || 挂载数据: qa: 1 ) 
│   │   ├── 非线性方程求解 --> ( 难度等级: [0.8182, 0.822) || 挂载数据: 无 ) 
│   │   │   ├── 非线性方程 --> ( 难度等级: [0.8182, 0.8201) || 挂载数据: qa: 3 ) 
│   │   │   └── 非线性方程组 --> ( 难度等级: [0.8201, 0.822) || 挂载数据: 无 ) 
│   │   ├── 线性代数 --> ( 难度等级: [0.822, 0.8258) || 挂载数据: 无 ) 
│   │   │   ├── 计算矩阵的行列式 --> ( 难度等级: [0.822, 0.8227) || 挂载数据: 无 ) 
│   │   │   ├── 求解逆矩阵 --> ( 难度等级: [0.8227, 0.8235) || 挂载数据: 无 ) 
│   │   │   ├── 计算特征向量和特征值 --> ( 难度等级: [0.8235, 0.8242) || 挂载数据: 无 ) 
│   │   │   ├── 矩阵的奇异值分解 --> ( 难度等级: [0.8242, 0.825) || 挂载数据: 无 ) 
│   │   │   └── 求解线性方程组 --> ( 难度等级: [0.825, 0.8258) || 挂载数据: 无 ) 
│   │   ├── 聚类 --> ( 难度等级: [0.8258, 0.8295) || 挂载数据: 无 ) 
│   │   │   ├── k-means聚类 --> ( 难度等级: [0.8258, 0.8277) || 挂载数据: 无 ) 
│   │   │   └── 层次聚类 --> ( 难度等级: [0.8277, 0.8295) || 挂载数据: 无 ) 
│   │   └── 空间计算 --> ( 难度等级: [0.8295, 0.8333) || 挂载数据: 无 ) 
│   │       ├── 空间旋转的表述 --> ( 难度等级: [0.8295, 0.8314) || 挂载数据: qa: 1 ) 
│   │       └── 三维旋转 --> ( 难度等级: [0.8314, 0.8333) || 挂载数据: 无 ) 
│   ├── 数据分析 --> ( 难度等级: [0.8333, 0.875) || 挂载数据: 无 ) 
│   │   ├── Python基础 --> ( 难度等级: [0.8333, 0.8352) || 挂载数据: 无 ) 
│   │   │   ├── 创建Python脚本 --> ( 难度等级: [0.8333, 0.8336) || 挂载数据: 无 ) 
│   │   │   ├── 运行Python脚本 --> ( 难度等级: [0.8336, 0.8338) || 挂载数据: 无 ) 
│   │   │   ├── 与命令行进行交互的几项技巧 --> ( 难度等级: [0.8338, 0.834) || 挂载数据: 无 ) 
│   │   │   ├── Python语言基础要素 --> ( 难度等级: [0.834, 0.8343) || 挂载数据: 无 ) 
│   │   │   │   ├── 数值 --> ( 难度等级: [0.834, 0.8341) || 挂载数据: qa: 3 ) 
│   │   │   │   ├── 字符串 --> ( 难度等级: [0.8341, 0.8341) || 挂载数据: 无 ) 
│   │   │   │   ├── 正则表达式与模式匹配 --> ( 难度等级: [0.8341, 0.8341) || 挂载数据: 无 ) 
│   │   │   │   ├── 日期 --> ( 难度等级: [0.8341, 0.8342) || 挂载数据: qa: 2 ) 
│   │   │   │   ├── 列表 --> ( 难度等级: [0.8342, 0.8342) || 挂载数据: 无 ) 
│   │   │   │   ├── 元组 --> ( 难度等级: [0.8342, 0.8342) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 字典 --> ( 难度等级: [0.8342, 0.8343) || 挂载数据: 无 ) 
│   │   │   │   └── 控制流 --> ( 难度等级: [0.8343, 0.8343) || 挂载数据: 无 ) 
│   │   │   ├── 读取文本文件 --> ( 难度等级: [0.8343, 0.8345) || 挂载数据: 无 ) 
│   │   │   │   ├── 创建文本文件 --> ( 难度等级: [0.8343, 0.8344) || 挂载数据: 无 ) 
│   │   │   │   ├── 脚本和输入文件在同一位置 --> ( 难度等级: [0.8344, 0.8344) || 挂载数据: 无 ) 
│   │   │   │   └── 读取文件的新型语法 --> ( 难度等级: [0.8344, 0.8345) || 挂载数据: qa: 4 ) 
│   │   │   ├── 使用glob读取多个文本文件 --> ( 难度等级: [0.8345, 0.8348) || 挂载数据: 无 ) 
│   │   │   ├── 写入文本文件 --> ( 难度等级: [0.8348, 0.835) || 挂载数据: 无 ) 
│   │   │   │   ├── 向first_script.py添加代码 --> ( 难度等级: [0.8348, 0.8349) || 挂载数据: qa: 1; blog: 4 ) 
│   │   │   │   └── 写入CSV文件 --> ( 难度等级: [0.8349, 0.835) || 挂载数据: qa: 3 ) 
│   │   │   └── print语句 --> ( 难度等级: [0.835, 0.8352) || 挂载数据: qa: 2 ) 
│   │   ├── CSV文件 --> ( 难度等级: [0.8352, 0.8371) || 挂载数据: 无 ) 
│   │   │   ├── 筛选特定的行 --> ( 难度等级: [0.8352, 0.8355) || 挂载数据: 无 ) 
│   │   │   │   ├── 行中的值满足某个条件 --> ( 难度等级: [0.8352, 0.8353) || 挂载数据: 无 ) 
│   │   │   │   ├── 行中的值属于某个集合 --> ( 难度等级: [0.8353, 0.8354) || 挂载数据: qa: 6; blog: 3 ) 
│   │   │   │   └── 行中的值匹配于某个模式/ 正则表达式 --> ( 难度等级: [0.8354, 0.8355) || 挂载数据: blog: 1 ) 
│   │   │   ├── 选取特定的列 --> ( 难度等级: [0.8355, 0.8358) || 挂载数据: 无 ) 
│   │   │   │   ├── 列索引值 --> ( 难度等级: [0.8355, 0.8356) || 挂载数据: 无 ) 
│   │   │   │   └── 列标题 --> ( 难度等级: [0.8356, 0.8358) || 挂载数据: qa: 4 ) 
│   │   │   ├── 选取连续的行 --> ( 难度等级: [0.8358, 0.836) || 挂载数据: 无 ) 
│   │   │   ├── 添加标题行 --> ( 难度等级: [0.836, 0.8363) || 挂载数据: 无 ) 
│   │   │   ├── 读取多个CSV文件 --> ( 难度等级: [0.8363, 0.8366) || 挂载数据: qa: 27; blog: 2 ) 
│   │   │   ├── 从多个文件中连接数据 --> ( 难度等级: [0.8366, 0.8369) || 挂载数据: qa: 3 ) 
│   │   │   └── 计算每个文件中值的总和与均值 --> ( 难度等级: [0.8369, 0.8371) || 挂载数据: 无 ) 
│   │   ├── Excel文件 --> ( 难度等级: [0.8371, 0.839) || 挂载数据: 无 ) 
│   │   │   ├── 内省Excel工作簿 --> ( 难度等级: [0.8371, 0.8375) || 挂载数据: 无 ) 
│   │   │   ├── 处理单个工作表 --> ( 难度等级: [0.8375, 0.8379) || 挂载数据: 无 ) 
│   │   │   │   ├── 读写Excel文件 --> ( 难度等级: [0.8375, 0.8376) || 挂载数据: qa: 13; blog: 2 ) 
│   │   │   │   ├── 筛选特定行 --> ( 难度等级: [0.8376, 0.8378) || 挂载数据: 无 ) 
│   │   │   │   └── 选取特定列 --> ( 难度等级: [0.8378, 0.8379) || 挂载数据: 无 ) 
│   │   │   ├── 读取工作簿中的所有工作表 --> ( 难度等级: [0.8379, 0.8383) || 挂载数据: 无 ) 
│   │   │   │   ├── 在所有工作表中筛选特定行 --> ( 难度等级: [0.8379, 0.8381) || 挂载数据: 无 ) 
│   │   │   │   └── 在所有工作表中选取特定列 --> ( 难度等级: [0.8381, 0.8383) || 挂载数据: 无 ) 
│   │   │   ├── 在Excel工作簿中读取一组工作表 --> ( 难度等级: [0.8383, 0.8386) || 挂载数据: 无 ) 
│   │   │   └── 处理多个工作簿 --> ( 难度等级: [0.8386, 0.839) || 挂载数据: 无 ) 
│   │   │       ├── 工作表计数以及每个工作表中的行列计数 --> ( 难度等级: [0.8386, 0.8388) || 挂载数据: qa: 1 ) 
│   │   │       └── 从多个工作簿中连接数据 --> ( 难度等级: [0.8388, 0.839) || 挂载数据: blog: 1 ) 
│   │   ├── 数据库 --> ( 难度等级: [0.839, 0.8409) || 挂载数据: 无 ) 
│   │   │   ├── Python内置的sqlite3 模块 --> ( 难度等级: [0.839, 0.84) || 挂载数据: 无 ) 
│   │   │   │   ├── 向表中插入新记录 --> ( 难度等级: [0.839, 0.8395) || 挂载数据: 无 ) 
│   │   │   │   └── 更新表中记录 --> ( 难度等级: [0.8395, 0.84) || 挂载数据: 无 ) 
│   │   │   └── MySQL数据库 --> ( 难度等级: [0.84, 0.8409) || 挂载数据: 无 ) 
│   │   │       ├── 向表中插入新记录 --> ( 难度等级: [0.84, 0.8403) || 挂载数据: 无 ) 
│   │   │       ├── 查询一个表并将输出写入CSV文件 --> ( 难度等级: [0.8403, 0.8406) || 挂载数据: 无 ) 
│   │   │       └── 更新表中记录 --> ( 难度等级: [0.8406, 0.8409) || 挂载数据: 无 ) 
│   │   ├── 应用程序 --> ( 难度等级: [0.8409, 0.8428) || 挂载数据: 无 ) 
│   │   │   ├── 为CSV文件中数据的任意数目分类计算统计量 --> ( 难度等级: [0.8409, 0.8419) || 挂载数据: 无 ) 
│   │   │   └── 为文本文件中数据的任意数目分类计算统计量 --> ( 难度等级: [0.8419, 0.8428) || 挂载数据: 无 ) 
│   │   ├── 图与图表 --> ( 难度等级: [0.8428, 0.8447) || 挂载数据: blog: 1 ) 
│   │   │   ├── matplotlib --> ( 难度等级: [0.8428, 0.8433) || 挂载数据: 无 ) 
│   │   │   │   ├── 条形图 --> ( 难度等级: [0.8428, 0.8429) || 挂载数据: 无 ) 
│   │   │   │   ├── 直方图 --> ( 难度等级: [0.8429, 0.843) || 挂载数据: 无 ) 
│   │   │   │   ├── 折线图 --> ( 难度等级: [0.843, 0.8431) || 挂载数据: qa: 4 ) 
│   │   │   │   ├── 散点图 --> ( 难度等级: [0.8431, 0.8432) || 挂载数据: blog: 1 ) 
│   │   │   │   └── 箱线图 --> ( 难度等级: [0.8432, 0.8433) || 挂载数据: 无 ) 
│   │   │   ├── pandas --> ( 难度等级: [0.8433, 0.8438) || 挂载数据: 无 ) 
│   │   │   ├── ggplot --> ( 难度等级: [0.8438, 0.8442) || 挂载数据: 无 ) 
│   │   │   └── seaborn --> ( 难度等级: [0.8442, 0.8447) || 挂载数据: 无 ) 
│   │   ├── 描述性统计与建模 --> ( 难度等级: [0.8447, 0.8466) || 挂载数据: 无 ) 
│   │   │   ├── 数据集 --> ( 难度等级: [0.8447, 0.8453) || 挂载数据: 无 ) 
│   │   │   │   ├── 葡萄酒质量 --> ( 难度等级: [0.8447, 0.845) || 挂载数据: 无 ) 
│   │   │   │   └── 客户流失 --> ( 难度等级: [0.845, 0.8453) || 挂载数据: 无 ) 
│   │   │   ├── 葡萄酒质量 --> ( 难度等级: [0.8453, 0.846) || 挂载数据: 无 ) 
│   │   │   │   ├── 描述性统计 --> ( 难度等级: [0.8453, 0.8454) || 挂载数据: qa: 6 ) 
│   │   │   │   ├── 成对变量之间的关系和相关性 --> ( 难度等级: [0.8454, 0.8455) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用最小二乘估计进行线性回归 --> ( 难度等级: [0.8455, 0.8456) || 挂载数据: 无 ) 
│   │   │   │   ├── 系数解释 --> ( 难度等级: [0.8456, 0.8457) || 挂载数据: 无 ) 
│   │   │   │   ├── 自变量标准化 --> ( 难度等级: [0.8457, 0.8459) || 挂载数据: 无 ) 
│   │   │   │   └── 预测 --> ( 难度等级: [0.8459, 0.846) || 挂载数据: 无 ) 
│   │   │   └── 客户流失 --> ( 难度等级: [0.846, 0.8466) || 挂载数据: 无 ) 
│   │   │       ├── 逻辑斯蒂回归 --> ( 难度等级: [0.846, 0.8462) || 挂载数据: 无 ) 
│   │   │       ├── 系数解释 --> ( 难度等级: [0.8462, 0.8464) || 挂载数据: 无 ) 
│   │   │       └── 预测 --> ( 难度等级: [0.8464, 0.8466) || 挂载数据: 无 ) 
│   │   ├── 按计划自动运行脚本 --> ( 难度等级: [0.8466, 0.8485) || 挂载数据: 无 ) 
│   │   │   ├── 任务计划程序（Windows系统） --> ( 难度等级: [0.8466, 0.8475) || 挂载数据: 无 ) 
│   │   │   └── cron工具（macOS系统和Unix系统） --> ( 难度等级: [0.8475, 0.8485) || 挂载数据: 无 ) 
│   │   │       ├── cron表文件：一次性设置 --> ( 难度等级: [0.8475, 0.848) || 挂载数据: 无 ) 
│   │   │       └── 向cron表文件中添加cron任务 --> ( 难度等级: [0.848, 0.8485) || 挂载数据: 无 ) 
│   │   ├── 从这里启航 --> ( 难度等级: [0.8485, 0.8504) || 挂载数据: 无 ) 
│   │   │   ├── 更多的标准库模块和内置函数 --> ( 难度等级: [0.8485, 0.849) || 挂载数据: 无 ) 
│   │   │   │   ├── Python标准库（PSL）：更多的标准模块 --> ( 难度等级: [0.8485, 0.8487) || 挂载数据: blog: 1 ) 
│   │   │   │   └── 内置函数 --> ( 难度等级: [0.8487, 0.849) || 挂载数据: qa: 1 ) 
│   │   │   ├── Python包索引（PyPI）：更多的扩展模块 --> ( 难度等级: [0.849, 0.8494) || 挂载数据: 无 ) 
│   │   │   │   ├── NumPy --> ( 难度等级: [0.849, 0.8491) || 挂载数据: 无 ) 
│   │   │   │   ├── SciPy --> ( 难度等级: [0.8491, 0.8492) || 挂载数据: qa: 1; blog: 8 ) 
│   │   │   │   ├── Scikit-Learn --> ( 难度等级: [0.8492, 0.8493) || 挂载数据: 无 ) 
│   │   │   │   └── 更多的扩展包 --> ( 难度等级: [0.8493, 0.8494) || 挂载数据: 无 ) 
│   │   │   ├── 更多的数据结构 --> ( 难度等级: [0.8494, 0.8499) || 挂载数据: 无 ) 
│   │   │   │   ├── 栈 --> ( 难度等级: [0.8494, 0.8496) || 挂载数据: 无 ) 
│   │   │   │   ├── 队列 --> ( 难度等级: [0.8496, 0.8497) || 挂载数据: 无 ) 
│   │   │   │   └── 树 --> ( 难度等级: [0.8497, 0.8499) || 挂载数据: 无 ) 
│   │   │   └── 从这里启航 --> ( 难度等级: [0.8499, 0.8504) || 挂载数据: 无 ) 
│   │   ├── 准备工作 --> ( 难度等级: [0.8504, 0.8523) || 挂载数据: 无 ) 
│   │   │   ├── 本书内容 --> ( 难度等级: [0.8504, 0.8507) || 挂载数据: 无 ) 
│   │   │   │   └── 什么类型的数据 --> ( 难度等级: [0.8504, 0.8507) || 挂载数据: qa: 1 ) 
│   │   │   ├── 为何利用Python进行数据分析 --> ( 难度等级: [0.8507, 0.851) || 挂载数据: qa: 2 ) 
│   │   │   │   ├── Python作为胶水 --> ( 难度等级: [0.8507, 0.8508) || 挂载数据: 无 ) 
│   │   │   │   ├── 解决“双语言”难题 --> ( 难度等级: [0.8508, 0.8509) || 挂载数据: qa: 3 ) 
│   │   │   │   └── 为何不使用Python --> ( 难度等级: [0.8509, 0.851) || 挂载数据: 无 ) 
│   │   │   ├── 重要的Python库 --> ( 难度等级: [0.851, 0.8513) || 挂载数据: 无 ) 
│   │   │   │   ├── IPython与Jupyter --> ( 难度等级: [0.851, 0.8512) || 挂载数据: qa: 1; blog: 4 ) 
│   │   │   │   └── statsmodels --> ( 难度等级: [0.8512, 0.8513) || 挂载数据: 无 ) 
│   │   │   ├── 安装与设置 --> ( 难度等级: [0.8513, 0.8516) || 挂载数据: 无 ) 
│   │   │   │   ├── Windows --> ( 难度等级: [0.8513, 0.8514) || 挂载数据: 无 ) 
│   │   │   │   ├── Apple（OS X和macOS） --> ( 难度等级: [0.8514, 0.8514) || 挂载数据: qa: 2; blog: 1 ) 
│   │   │   │   ├── GNU/Linux --> ( 难度等级: [0.8514, 0.8515) || 挂载数据: qa: 1; blog: 2 ) 
│   │   │   │   ├── 安装及更新Python包 --> ( 难度等级: [0.8515, 0.8515) || 挂载数据: 无 ) 
│   │   │   │   ├── Python 2和Python --> ( 难度等级: [0.8515, 0.8516) || 挂载数据: 无 ) 
│   │   │   │   └── 集成开发环境和文本编辑器 --> ( 难度等级: [0.8516, 0.8516) || 挂载数据: 无 ) 
│   │   │   ├── 社区和会议 --> ( 难度等级: [0.8516, 0.852) || 挂载数据: 无 ) 
│   │   │   └── 快速浏览本书 --> ( 难度等级: [0.852, 0.8523) || 挂载数据: qa: 1 ) 
│   │   │       ├── 代码示例 --> ( 难度等级: [0.852, 0.852) || 挂载数据: 无 ) 
│   │   │       ├── 示例数据 --> ( 难度等级: [0.852, 0.8521) || 挂载数据: 无 ) 
│   │   │       ├── 导入约定 --> ( 难度等级: [0.8521, 0.8522) || 挂载数据: 无 ) 
│   │   │       └── 术语 --> ( 难度等级: [0.8522, 0.8523) || 挂载数据: 无 ) 
│   │   ├── 内建数据结构、函数及文件 --> ( 难度等级: [0.8523, 0.8542) || 挂载数据: 无 ) 
│   │   │   ├── 数据结构和序列 --> ( 难度等级: [0.8523, 0.8529) || 挂载数据: qa: 1; blog: 1 ) 
│   │   │   │   ├── 内建序列函数 --> ( 难度等级: [0.8523, 0.8526) || 挂载数据: 无 ) 
│   │   │   │   └── 集合 --> ( 难度等级: [0.8526, 0.8529) || 挂载数据: 无 ) 
│   │   │   ├── 函数 --> ( 难度等级: [0.8529, 0.8535) || 挂载数据: 无 ) 
│   │   │   │   ├── 命名空间、作用域和本地函数 --> ( 难度等级: [0.8529, 0.853) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 返回多个值 --> ( 难度等级: [0.853, 0.8531) || 挂载数据: 无 ) 
│   │   │   │   ├── 函数是对象 --> ( 难度等级: [0.8531, 0.8532) || 挂载数据: qa: 34; blog: 2 ) 
│   │   │   │   ├── 匿名（Lambda）函数 --> ( 难度等级: [0.8532, 0.8533) || 挂载数据: qa: 4 ) 
│   │   │   │   ├── 柯里化：部分参数应用 --> ( 难度等级: [0.8533, 0.8534) || 挂载数据: 无 ) 
│   │   │   │   ├── 生成器 --> ( 难度等级: [0.8534, 0.8534) || 挂载数据: 无 ) 
│   │   │   │   └── 错误和异常处理 --> ( 难度等级: [0.8534, 0.8535) || 挂载数据: 无 ) 
│   │   │   └── 文件与操作系统 --> ( 难度等级: [0.8535, 0.8542) || 挂载数据: 无 ) 
│   │   │       └── 字节与Unicode文件 --> ( 难度等级: [0.8535, 0.8542) || 挂载数据: 无 ) 
│   │   ├── NumPy基础：数组与向量化计算 --> ( 难度等级: [0.8542, 0.8561) || 挂载数据: 无 ) 
│   │   │   ├── NumPy ndarray：多维数组对象 --> ( 难度等级: [0.8542, 0.8544) || 挂载数据: 无 ) 
│   │   │   │   ├── 生成ndarray --> ( 难度等级: [0.8542, 0.8542) || 挂载数据: qa: 3 ) 
│   │   │   │   ├── ndarray的数据类型 --> ( 难度等级: [0.8542, 0.8542) || 挂载数据: qa: 1; blog: 3 ) 
│   │   │   │   ├── NumPy数组算术 --> ( 难度等级: [0.8542, 0.8543) || 挂载数据: qa: 27; blog: 256 ) 
│   │   │   │   ├── 基础索引与切片 --> ( 难度等级: [0.8543, 0.8543) || 挂载数据: 无 ) 
│   │   │   │   ├── 布尔索引 --> ( 难度等级: [0.8543, 0.8544) || 挂载数据: 无 ) 
│   │   │   │   ├── 神奇索引 --> ( 难度等级: [0.8544, 0.8544) || 挂载数据: 无 ) 
│   │   │   │   └── 数组转置和换轴 --> ( 难度等级: [0.8544, 0.8544) || 挂载数据: qa: 12; blog: 1 ) 
│   │   │   ├── 通用函数：快速的逐元素数组函数 --> ( 难度等级: [0.8544, 0.8547) || 挂载数据: 无 ) 
│   │   │   ├── 使用数组进行面向数组编程 --> ( 难度等级: [0.8547, 0.855) || 挂载数据: 无 ) 
│   │   │   │   ├── 将条件逻辑作为数组操作 --> ( 难度等级: [0.8547, 0.8548) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 数学和统计方法 --> ( 难度等级: [0.8548, 0.8548) || 挂载数据: 无 ) 
│   │   │   │   ├── 布尔值数组的方法 --> ( 难度等级: [0.8548, 0.8549) || 挂载数据: 无 ) 
│   │   │   │   ├── 排序 --> ( 难度等级: [0.8549, 0.8549) || 挂载数据: qa: 5; blog: 1 ) 
│   │   │   │   └── 唯一值与其他集合逻辑 --> ( 难度等级: [0.8549, 0.855) || 挂载数据: 无 ) 
│   │   │   ├── 使用数组进行文件输入和输出 --> ( 难度等级: [0.855, 0.8552) || 挂载数据: qa: 2 ) 
│   │   │   ├── 线性代数 --> ( 难度等级: [0.8552, 0.8555) || 挂载数据: 无 ) 
│   │   │   ├── 伪随机数生成 --> ( 难度等级: [0.8555, 0.8558) || 挂载数据: qa: 1 ) 
│   │   │   └── 示例：随机漫步 --> ( 难度等级: [0.8558, 0.8561) || 挂载数据: 无 ) 
│   │   │       └── 一次性模拟多次随机漫步 --> ( 难度等级: [0.8558, 0.8561) || 挂载数据: qa: 10 ) 
│   │   ├── pandas入门 --> ( 难度等级: [0.8561, 0.858) || 挂载数据: 无 ) 
│   │   │   ├── pandas数据结构介绍 --> ( 难度等级: [0.8561, 0.8567) || 挂载数据: qa: 29; blog: 4 ) 
│   │   │   │   ├── Series --> ( 难度等级: [0.8561, 0.8563) || 挂载数据: qa: 2 ) 
│   │   │   │   ├── DataFrame --> ( 难度等级: [0.8563, 0.8565) || 挂载数据: qa: 31; blog: 3 ) 
│   │   │   │   └── 索引对象 --> ( 难度等级: [0.8565, 0.8567) || 挂载数据: qa: 1 ) 
│   │   │   ├── 基本功能 --> ( 难度等级: [0.8567, 0.8573) || 挂载数据: 无 ) 
│   │   │   │   ├── 重建索引 --> ( 难度等级: [0.8567, 0.8568) || 挂载数据: 无 ) 
│   │   │   │   ├── 轴向上删除条目 --> ( 难度等级: [0.8568, 0.8569) || 挂载数据: 无 ) 
│   │   │   │   ├── 索引、选择与过滤 --> ( 难度等级: [0.8569, 0.857) || 挂载数据: 无 ) 
│   │   │   │   ├── 整数索引 --> ( 难度等级: [0.857, 0.8571) || 挂载数据: 无 ) 
│   │   │   │   ├── 算术和数据对齐 --> ( 难度等级: [0.8571, 0.8572) || 挂载数据: 无 ) 
│   │   │   │   └── 含有重复标签的轴索引 --> ( 难度等级: [0.8572, 0.8573) || 挂载数据: 无 ) 
│   │   │   └── 描述性统计的概述与计算 --> ( 难度等级: [0.8573, 0.858) || 挂载数据: 无 ) 
│   │   ├── 数据载入、存储及文件格式 --> ( 难度等级: [0.858, 0.8598) || 挂载数据: 无 ) 
│   │   │   ├── 文本格式数据的读写 --> ( 难度等级: [0.858, 0.8584) || 挂载数据: 无 ) 
│   │   │   │   ├── 分块读入文本文件 --> ( 难度等级: [0.858, 0.858) || 挂载数据: 无 ) 
│   │   │   │   ├── 将数据写入文本格式 --> ( 难度等级: [0.858, 0.8581) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 使用分隔格式 --> ( 难度等级: [0.8581, 0.8582) || 挂载数据: 无 ) 
│   │   │   │   ├── JSON数据 --> ( 难度等级: [0.8582, 0.8583) || 挂载数据: 无 ) 
│   │   │   │   └── XML和HTML：网络抓取 --> ( 难度等级: [0.8583, 0.8584) || 挂载数据: qa: 3; blog: 1 ) 
│   │   │   ├── 二进制格式 --> ( 难度等级: [0.8584, 0.8589) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用HDF5格式 --> ( 难度等级: [0.8584, 0.8587) || 挂载数据: qa: 7 ) 
│   │   │   │   └── 读取Microsoft Excel文件 --> ( 难度等级: [0.8587, 0.8589) || 挂载数据: blog: 1 ) 
│   │   │   ├── 与Web API交互 --> ( 难度等级: [0.8589, 0.8594) || 挂载数据: qa: 1 ) 
│   │   │   └── 与数据库交互 --> ( 难度等级: [0.8594, 0.8598) || 挂载数据: 无 ) 
│   │   ├── 数据清洗与准备 --> ( 难度等级: [0.8598, 0.8617) || 挂载数据: 无 ) 
│   │   │   ├── 处理缺失值 --> ( 难度等级: [0.8598, 0.8605) || 挂载数据: 无 ) 
│   │   │   │   ├── 过滤缺失值 --> ( 难度等级: [0.8598, 0.8602) || 挂载数据: 无 ) 
│   │   │   │   └── 补全缺失值 --> ( 难度等级: [0.8602, 0.8605) || 挂载数据: qa: 8 ) 
│   │   │   ├── 数据转换 --> ( 难度等级: [0.8605, 0.8611) || 挂载数据: 无 ) 
│   │   │   │   ├── 删除重复值 --> ( 难度等级: [0.8605, 0.8606) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 使用函数或映射进行数据转换 --> ( 难度等级: [0.8606, 0.8606) || 挂载数据: qa: 50; blog: 3 ) 
│   │   │   │   ├── 替代值 --> ( 难度等级: [0.8606, 0.8607) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 重命名轴索引 --> ( 难度等级: [0.8607, 0.8608) || 挂载数据: 无 ) 
│   │   │   │   ├── 离散化和分箱 --> ( 难度等级: [0.8608, 0.8609) || 挂载数据: 无 ) 
│   │   │   │   ├── 检测和过滤异常值 --> ( 难度等级: [0.8609, 0.861) || 挂载数据: 无 ) 
│   │   │   │   ├── 置换和随机抽样 --> ( 难度等级: [0.861, 0.861) || 挂载数据: 无 ) 
│   │   │   │   └── 计算指标/虚拟变量 --> ( 难度等级: [0.861, 0.8611) || 挂载数据: 无 ) 
│   │   │   └── 字符串操作 --> ( 难度等级: [0.8611, 0.8617) || 挂载数据: 无 ) 
│   │   │       ├── 字符串对象方法 --> ( 难度等级: [0.8611, 0.8614) || 挂载数据: 无 ) 
│   │   │       └── pandas中的向量化字符串函数 --> ( 难度等级: [0.8614, 0.8617) || 挂载数据: blog: 1 ) 
│   │   ├── 数据规整：连接、联合与重塑 --> ( 难度等级: [0.8617, 0.8636) || 挂载数据: 无 ) 
│   │   │   ├── 分层索引 --> ( 难度等级: [0.8617, 0.8624) || 挂载数据: 无 ) 
│   │   │   │   ├── 重排序和层级排序 --> ( 难度等级: [0.8617, 0.862) || 挂载数据: 无 ) 
│   │   │   │   ├── 按层级进行汇总统计 --> ( 难度等级: [0.862, 0.8622) || 挂载数据: blog: 1 ) 
│   │   │   │   └── 使用DataFrame的列进行索引 --> ( 难度等级: [0.8622, 0.8624) || 挂载数据: qa: 10; blog: 2 ) 
│   │   │   ├── 联合与合并数据集 --> ( 难度等级: [0.8624, 0.863) || 挂载数据: 无 ) 
│   │   │   │   ├── 数据库风格的DataFrame连接 --> ( 难度等级: [0.8624, 0.8625) || 挂载数据: 无 ) 
│   │   │   │   ├── 根据索引合并 --> ( 难度等级: [0.8625, 0.8627) || 挂载数据: qa: 3 ) 
│   │   │   │   ├── 沿轴向连接 --> ( 难度等级: [0.8627, 0.8628) || 挂载数据: qa: 1 ) 
│   │   │   │   └── 联合重叠数据 --> ( 难度等级: [0.8628, 0.863) || 挂载数据: 无 ) 
│   │   │   └── 重塑和透视 --> ( 难度等级: [0.863, 0.8636) || 挂载数据: 无 ) 
│   │   │       ├── 使用多层索引进行重塑 --> ( 难度等级: [0.863, 0.8632) || 挂载数据: 无 ) 
│   │   │       ├── 将“长”透视为“宽” --> ( 难度等级: [0.8632, 0.8634) || 挂载数据: 无 ) 
│   │   │       └── 将“宽”透视为“长” --> ( 难度等级: [0.8634, 0.8636) || 挂载数据: 无 ) 
│   │   ├── 绘图与可视化 --> ( 难度等级: [0.8636, 0.8655) || 挂载数据: 无 ) 
│   │   │   ├── 简明matplotlib API入门 --> ( 难度等级: [0.8636, 0.8646) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 图片与子图 --> ( 难度等级: [0.8636, 0.8638) || 挂载数据: 无 ) 
│   │   │   │   ├── 颜色、标记和线类型 --> ( 难度等级: [0.8638, 0.864) || 挂载数据: 无 ) 
│   │   │   │   ├── 刻度、标签和图例 --> ( 难度等级: [0.864, 0.8641) || 挂载数据: 无 ) 
│   │   │   │   ├── 注释与子图加工 --> ( 难度等级: [0.8641, 0.8643) || 挂载数据: 无 ) 
│   │   │   │   ├── 将图片保存到文件 --> ( 难度等级: [0.8643, 0.8644) || 挂载数据: qa: 5 ) 
│   │   │   │   └── matplotlib设置 --> ( 难度等级: [0.8644, 0.8646) || 挂载数据: qa: 21; blog: 12 ) 
│   │   │   └── 其他Python可视化工具 --> ( 难度等级: [0.8646, 0.8655) || 挂载数据: blog: 4 ) 
│   │   ├── 数据聚合与分组操作 --> ( 难度等级: [0.8655, 0.8674) || 挂载数据: 无 ) 
│   │   │   ├── GroupBy机制 --> ( 难度等级: [0.8655, 0.866) || 挂载数据: 无 ) 
│   │   │   │   ├── 遍历各分组 --> ( 难度等级: [0.8655, 0.8656) || 挂载数据: 无 ) 
│   │   │   │   ├── 选择一列或所有列的子集 --> ( 难度等级: [0.8656, 0.8658) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用函数分组 --> ( 难度等级: [0.8658, 0.8659) || 挂载数据: qa: 1 ) 
│   │   │   │   └── 根据索引层级分组 --> ( 难度等级: [0.8659, 0.866) || 挂载数据: 无 ) 
│   │   │   ├── 数据聚合 --> ( 难度等级: [0.866, 0.8665) || 挂载数据: 无 ) 
│   │   │   │   └── 返回不含行索引的聚合数据 --> ( 难度等级: [0.866, 0.8665) || 挂载数据: qa: 2 ) 
│   │   │   ├── 应用：通用拆分-应用-联合 --> ( 难度等级: [0.8665, 0.867) || 挂载数据: 无 ) 
│   │   │   │   ├── 压缩分组键 --> ( 难度等级: [0.8665, 0.8667) || 挂载数据: 无 ) 
│   │   │   │   └── 分位数与桶分析 --> ( 难度等级: [0.8667, 0.867) || 挂载数据: 无 ) 
│   │   │   └── 数据透视表与交叉表 --> ( 难度等级: [0.867, 0.8674) || 挂载数据: 无 ) 
│   │   │       └── 交叉表：crosstab --> ( 难度等级: [0.867, 0.8674) || 挂载数据: blog: 1 ) 
│   │   ├── 时间序列 --> ( 难度等级: [0.8674, 0.8693) || 挂载数据: 无 ) 
│   │   │   ├── 时间序列基础 --> ( 难度等级: [0.8674, 0.8678) || 挂载数据: 无 ) 
│   │   │   │   └── 含有重复索引的时间序列 --> ( 难度等级: [0.8674, 0.8678) || 挂载数据: qa: 2 ) 
│   │   │   ├── 时区处理 --> ( 难度等级: [0.8678, 0.8682) || 挂载数据: 无 ) 
│   │   │   │   ├── 时区的本地化和转换 --> ( 难度等级: [0.8678, 0.8679) || 挂载数据: 无 ) 
│   │   │   │   ├── 时区感知时间戳对象的操作 --> ( 难度等级: [0.8679, 0.8681) || 挂载数据: qa: 1 ) 
│   │   │   │   └── 不同时区间的操作 --> ( 难度等级: [0.8681, 0.8682) || 挂载数据: 无 ) 
│   │   │   ├── 时间区间和区间算术 --> ( 难度等级: [0.8682, 0.8686) || 挂载数据: 无 ) 
│   │   │   │   ├── 区间频率转换 --> ( 难度等级: [0.8682, 0.8683) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 季度区间频率 --> ( 难度等级: [0.8683, 0.8684) || 挂载数据: 无 ) 
│   │   │   │   ├── 将时间戳转换为区间（以及逆转换） --> ( 难度等级: [0.8684, 0.8685) || 挂载数据: qa: 11 ) 
│   │   │   │   └── 从数组生成PeriodIndex --> ( 难度等级: [0.8685, 0.8686) || 挂载数据: qa: 1 ) 
│   │   │   ├── 重新采样与频率转换 --> ( 难度等级: [0.8686, 0.8689) || 挂载数据: 无 ) 
│   │   │   │   ├── 向下采样 --> ( 难度等级: [0.8686, 0.8687) || 挂载数据: 无 ) 
│   │   │   │   ├── 向上采样与插值 --> ( 难度等级: [0.8687, 0.8688) || 挂载数据: 无 ) 
│   │   │   │   └── 使用区间进行重新采样 --> ( 难度等级: [0.8688, 0.8689) || 挂载数据: 无 ) 
│   │   │   └── 移动窗口函数 --> ( 难度等级: [0.8689, 0.8693) || 挂载数据: 无 ) 
│   │   │       ├── 指数加权函数 --> ( 难度等级: [0.8689, 0.8691) || 挂载数据: 无 ) 
│   │   │       ├── 二元移动窗口函数 --> ( 难度等级: [0.8691, 0.8692) || 挂载数据: qa: 4; blog: 1 ) 
│   │   │       └── 用户自定义的移动窗口函数 --> ( 难度等级: [0.8692, 0.8693) || 挂载数据: 无 ) 
│   │   ├── 高阶pandas --> ( 难度等级: [0.8693, 0.8712) || 挂载数据: 无 ) 
│   │   │   ├── 分类数据 --> ( 难度等级: [0.8693, 0.8699) || 挂载数据: 无 ) 
│   │   │   │   ├── 背景和目标 --> ( 难度等级: [0.8693, 0.8695) || 挂载数据: 无 ) 
│   │   │   │   ├── pandas中的Categorical类型 --> ( 难度等级: [0.8695, 0.8696) || 挂载数据: qa: 11 ) 
│   │   │   │   ├── 使用Categorical对象进行计算 --> ( 难度等级: [0.8696, 0.8698) || 挂载数据: 无 ) 
│   │   │   │   └── 分类方法 --> ( 难度等级: [0.8698, 0.8699) || 挂载数据: qa: 2 ) 
│   │   │   ├── 高阶GroupBy应用 --> ( 难度等级: [0.8699, 0.8706) || 挂载数据: 无 ) 
│   │   │   │   ├── 分组转换和“展开”GroupBy --> ( 难度等级: [0.8699, 0.8703) || 挂载数据: qa: 3 ) 
│   │   │   │   └── 分组的时间重新采样 --> ( 难度等级: [0.8703, 0.8706) || 挂载数据: 无 ) 
│   │   │   └── 方法链技术 --> ( 难度等级: [0.8706, 0.8712) || 挂载数据: 无 ) 
│   │   │       └── pipe方法 --> ( 难度等级: [0.8706, 0.8712) || 挂载数据: qa: 1 ) 
│   │   ├── Python建模库介绍 --> ( 难度等级: [0.8712, 0.8731) || 挂载数据: 无 ) 
│   │   │   ├── 使用Patsy创建模型描述 --> ( 难度等级: [0.8712, 0.8717) || 挂载数据: 无 ) 
│   │   │   │   └── Patsy公式中的数据转换 --> ( 难度等级: [0.8712, 0.8717) || 挂载数据: 无 ) 
│   │   │   ├── statsmodels介绍 --> ( 难度等级: [0.8717, 0.8722) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 评估线性模型 --> ( 难度等级: [0.8717, 0.8719) || 挂载数据: qa: 1 ) 
│   │   │   │   └── 评估时间序列处理 --> ( 难度等级: [0.8719, 0.8722) || 挂载数据: 无 ) 
│   │   │   ├── scikit-learn介绍 --> ( 难度等级: [0.8722, 0.8726) || 挂载数据: 无 ) 
│   │   │   └── 继续你的教育 --> ( 难度等级: [0.8726, 0.8731) || 挂载数据: 无 ) 
│   │   └── 数据分析示例 --> ( 难度等级: [0.8731, 0.875) || 挂载数据: qa: 2; blog: 2 ) 
│   │       ├── 从Bitly获取1.USA.gov数据 --> ( 难度等级: [0.8731, 0.8735) || 挂载数据: 无 ) 
│   │       │   ├── 纯Python时区计数 --> ( 难度等级: [0.8731, 0.8733) || 挂载数据: qa: 1 ) 
│   │       │   └── 使用pandas进行时区计数 --> ( 难度等级: [0.8733, 0.8735) || 挂载数据: 无 ) 
│   │       ├── MovieLens 1M数据集 --> ( 难度等级: [0.8735, 0.8739) || 挂载数据: 无 ) 
│   │       │   └── 测量评价分歧 --> ( 难度等级: [0.8735, 0.8739) || 挂载数据: 无 ) 
│   │       ├── 美国1880～2010年的婴儿名字 --> ( 难度等级: [0.8739, 0.8742) || 挂载数据: 无 ) 
│   │       │   └── 分析名字趋势 --> ( 难度等级: [0.8739, 0.8742) || 挂载数据: 无 ) 
│   │       ├── 美国农业部食品数据库 --> ( 难度等级: [0.8742, 0.8746) || 挂载数据: 无 ) 
│   │       └── 2012年联邦选举委员会数据库 --> ( 难度等级: [0.8746, 0.875) || 挂载数据: 无 ) 
│   │           ├── 按职业和雇主的捐献统计 --> ( 难度等级: [0.8746, 0.8747) || 挂载数据: 无 ) 
│   │           ├── 捐赠金额分桶 --> ( 难度等级: [0.8747, 0.8749) || 挂载数据: 无 ) 
│   │           └── 按州进行捐赠统计 --> ( 难度等级: [0.8749, 0.875) || 挂载数据: 无 ) 
│   ├── 人工智能 --> ( 难度等级: [0.875, 0.9167) || 挂载数据: 无 ) 
│   │   ├── 机器学习工具包Scikit-learn --> ( 难度等级: [0.875, 0.8792) || 挂载数据: 无 ) 
│   │   │   ├── Scikit-learn概览 --> ( 难度等级: [0.875, 0.8755) || 挂载数据: qa: 2; blog: 4 ) 
│   │   │   ├── 安装配置 --> ( 难度等级: [0.8755, 0.8759) || 挂载数据: 无 ) 
│   │   │   ├── 数据集 --> ( 难度等级: [0.8759, 0.8764) || 挂载数据: 无 ) 
│   │   │   │   ├── Scikit-learn自带的数据集 --> ( 难度等级: [0.8759, 0.8761) || 挂载数据: 无 ) 
│   │   │   │   ├── 样本生成器 --> ( 难度等级: [0.8761, 0.8762) || 挂载数据: 无 ) 
│   │   │   │   └── 加载其他数据集 --> ( 难度等级: [0.8762, 0.8764) || 挂载数据: qa: 5; blog: 3 ) 
│   │   │   ├── 数据预处理Preprocessing --> ( 难度等级: [0.8764, 0.8769) || 挂载数据: 无 ) 
│   │   │   │   ├── 标准化 --> ( 难度等级: [0.8764, 0.8765) || 挂载数据: 无 ) 
│   │   │   │   ├── 归一化 --> ( 难度等级: [0.8765, 0.8765) || 挂载数据: 无 ) 
│   │   │   │   ├── 正则化 --> ( 难度等级: [0.8765, 0.8766) || 挂载数据: 无 ) 
│   │   │   │   ├── 离散化 --> ( 难度等级: [0.8766, 0.8767) || 挂载数据: 无 ) 
│   │   │   │   ├── 特征编码 --> ( 难度等级: [0.8767, 0.8768) || 挂载数据: 无 ) 
│   │   │   │   └── 缺失值补全 --> ( 难度等级: [0.8768, 0.8769) || 挂载数据: qa: 1 ) 
│   │   │   ├── 分类Classification --> ( 难度等级: [0.8769, 0.8773) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── K-近邻分类 --> ( 难度等级: [0.8769, 0.8769) || 挂载数据: 无 ) 
│   │   │   │   ├── 贝叶斯分类 --> ( 难度等级: [0.8769, 0.877) || 挂载数据: 无 ) 
│   │   │   │   ├── 决策树分类 --> ( 难度等级: [0.877, 0.8771) || 挂载数据: 无 ) 
│   │   │   │   ├── 支持向量机分类 --> ( 难度等级: [0.8771, 0.8771) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 随机森林分类 --> ( 难度等级: [0.8771, 0.8772) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 集成学习Bagging/Boosting --> ( 难度等级: [0.8772, 0.8772) || 挂载数据: 无 ) 
│   │   │   │   └── 神经网络模型 --> ( 难度等级: [0.8772, 0.8773) || 挂载数据: 无 ) 
│   │   │   ├── 回归Regression --> ( 难度等级: [0.8773, 0.8778) || 挂载数据: 无 ) 
│   │   │   │   ├── 线性回归 --> ( 难度等级: [0.8773, 0.8774) || 挂载数据: qa: 2 ) 
│   │   │   │   ├── Lasso回归 --> ( 难度等级: [0.8774, 0.8774) || 挂载数据: 无 ) 
│   │   │   │   ├── 支持向量机回归 --> ( 难度等级: [0.8774, 0.8775) || 挂载数据: 无 ) 
│   │   │   │   ├── K-近邻回归 --> ( 难度等级: [0.8775, 0.8776) || 挂载数据: 无 ) 
│   │   │   │   ├── 决策树回归 --> ( 难度等级: [0.8776, 0.8776) || 挂载数据: 无 ) 
│   │   │   │   ├── 随机森林回归 --> ( 难度等级: [0.8776, 0.8777) || 挂载数据: 无 ) 
│   │   │   │   └── 逻辑回归 --> ( 难度等级: [0.8777, 0.8778) || 挂载数据: qa: 3 ) 
│   │   │   ├── 聚类Clustering --> ( 难度等级: [0.8778, 0.8782) || 挂载数据: 无 ) 
│   │   │   │   ├── K-Means聚类 --> ( 难度等级: [0.8778, 0.8779) || 挂载数据: qa: 1; blog: 1 ) 
│   │   │   │   ├── 均值漂移聚类 --> ( 难度等级: [0.8779, 0.878) || 挂载数据: 无 ) 
│   │   │   │   ├── 基于密度的空间聚类 --> ( 难度等级: [0.878, 0.8781) || 挂载数据: 无 ) 
│   │   │   │   ├── 谱聚类 --> ( 难度等级: [0.8781, 0.8781) || 挂载数据: 无 ) 
│   │   │   │   └── 层次聚类 --> ( 难度等级: [0.8781, 0.8782) || 挂载数据: 无 ) 
│   │   │   │       ├── 自下而上的方法 --> ( 难度等级: [0.8781, 0.8782) || 挂载数据: 无 ) 
│   │   │   │       ├── 聚类之间的距离 --> ( 难度等级: [0.8782, 0.8782) || 挂载数据: qa: 2 ) 
│   │   │   │       ├── 自上而下的方法 --> ( 难度等级: [0.8782, 0.8782) || 挂载数据: 无 ) 
│   │   │   │       └── 图论方法 --> ( 难度等级: [0.8782, 0.8782) || 挂载数据: 无 ) 
│   │   │   ├── 成分分解与降维 --> ( 难度等级: [0.8782, 0.8787) || 挂载数据: 无 ) 
│   │   │   │   ├── 主成分分析 --> ( 难度等级: [0.8782, 0.8784) || 挂载数据: 无 ) 
│   │   │   │   ├── 因子分析 --> ( 难度等级: [0.8784, 0.8785) || 挂载数据: 无 ) 
│   │   │   │   ├── 截断奇异值分解 --> ( 难度等级: [0.8785, 0.8786) || 挂载数据: 无 ) 
│   │   │   │   └── 独立成分分析ICA（Independent Component Analysis） --> ( 难度等级: [0.8786, 0.8787) || 挂载数据: 无 ) 
│   │   │   └── 模型评估与参数调优 --> ( 难度等级: [0.8787, 0.8792) || 挂载数据: 无 ) 
│   │   │       ├── 估计器得分 --> ( 难度等级: [0.8787, 0.8788) || 挂载数据: 无 ) 
│   │   │       ├── 交叉验证 --> ( 难度等级: [0.8788, 0.8789) || 挂载数据: 无 ) 
│   │   │       ├── 评价指标 --> ( 难度等级: [0.8789, 0.879) || 挂载数据: 无 ) 
│   │   │       ├── 参数调优 --> ( 难度等级: [0.879, 0.8791) || 挂载数据: 无 ) 
│   │   │       └── 模型持久化 --> ( 难度等级: [0.8791, 0.8792) || 挂载数据: 无 ) 
│   │   ├── 深度学习 --> ( 难度等级: [0.8792, 0.8833) || 挂载数据: 无 ) 
│   │   │   ├── 神经网络基础知识 --> ( 难度等级: [0.8792, 0.8798) || 挂载数据: 无 ) 
│   │   │   │   ├── 人工智能发展历史 --> ( 难度等级: [0.8792, 0.8792) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 神经元 --> ( 难度等级: [0.8792, 0.8793) || 挂载数据: 无 ) 
│   │   │   │   ├── BP神经网络 --> ( 难度等级: [0.8793, 0.8794) || 挂载数据: qa: 2 ) 
│   │   │   │   ├── 梯度下降 --> ( 难度等级: [0.8794, 0.8795) || 挂载数据: 无 ) 
│   │   │   │   ├── 激励函数 --> ( 难度等级: [0.8795, 0.8795) || 挂载数据: 无 ) 
│   │   │   │   ├── 过拟合、欠拟合 --> ( 难度等级: [0.8795, 0.8796) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 优化器Optimizer --> ( 难度等级: [0.8796, 0.8797) || 挂载数据: 无 ) 
│   │   │   │   └── 常用开发工具 --> ( 难度等级: [0.8797, 0.8798) || 挂载数据: qa: 1 ) 
│   │   │   ├── 环境配置 --> ( 难度等级: [0.8798, 0.8804) || 挂载数据: 无 ) 
│   │   │   │   ├── Windows搭建深度学习环境 --> ( 难度等级: [0.8798, 0.8799) || 挂载数据: blog: 3 ) 
│   │   │   │   ├── Linux搭建深度学习环境 --> ( 难度等级: [0.8799, 0.8801) || 挂载数据: blog: 15 ) 
│   │   │   │   ├── MacOS搭建深度学习环境 --> ( 难度等级: [0.8801, 0.8802) || 挂载数据: 无 ) 
│   │   │   │   └── CPU/GPU环境搭建 --> ( 难度等级: [0.8802, 0.8804) || 挂载数据: qa: 2; blog: 3 ) 
│   │   │   ├── Theano --> ( 难度等级: [0.8804, 0.881) || 挂载数据: 无 ) 
│   │   │   │   ├── Theano基础知识 --> ( 难度等级: [0.8804, 0.8804) || 挂载数据: qa: 2 ) 
│   │   │   │   ├── 定义Layer --> ( 难度等级: [0.8804, 0.8805) || 挂载数据: 无 ) 
│   │   │   │   ├── CNN --> ( 难度等级: [0.8805, 0.8806) || 挂载数据: 无 ) 
│   │   │   │   ├── RNN(GRU/LSTM) --> ( 难度等级: [0.8806, 0.8807) || 挂载数据: 无 ) 
│   │   │   │   ├── Autoencoder --> ( 难度等级: [0.8807, 0.8808) || 挂载数据: 无 ) 
│   │   │   │   ├── 神经网络参数保存 --> ( 难度等级: [0.8808, 0.8809) || 挂载数据: 无 ) 
│   │   │   │   └── 神经网络性能评价 --> ( 难度等级: [0.8809, 0.881) || 挂载数据: 无 ) 
│   │   │   ├── TensorFlow --> ( 难度等级: [0.881, 0.8815) || 挂载数据: 无 ) 
│   │   │   │   ├── TensorFlow基础知识 --> ( 难度等级: [0.881, 0.881) || 挂载数据: qa: 5; blog: 197 ) 
│   │   │   │   ├── Tensor --> ( 难度等级: [0.881, 0.881) || 挂载数据: blog: 3 ) 
│   │   │   │   ├── Session --> ( 难度等级: [0.881, 0.8811) || 挂载数据: blog: 6 ) 
│   │   │   │   ├── Variable --> ( 难度等级: [0.8811, 0.8811) || 挂载数据: blog: 4 ) 
│   │   │   │   ├── Placeholder --> ( 难度等级: [0.8811, 0.8812) || 挂载数据: qa: 1; blog: 1 ) 
│   │   │   │   ├── Dropout --> ( 难度等级: [0.8812, 0.8812) || 挂载数据: 无 ) 
│   │   │   │   ├── Tensorboard --> ( 难度等级: [0.8812, 0.8813) || 挂载数据: blog: 7 ) 
│   │   │   │   ├── CNN --> ( 难度等级: [0.8813, 0.8813) || 挂载数据: 无 ) 
│   │   │   │   ├── RNN(GRU/LSTM) --> ( 难度等级: [0.8813, 0.8814) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── Autoencoder --> ( 难度等级: [0.8814, 0.8814) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── GNN --> ( 难度等级: [0.8814, 0.8815) || 挂载数据: 无 ) 
│   │   │   │   ├── 神经网络参数保存 --> ( 难度等级: [0.8815, 0.8815) || 挂载数据: 无 ) 
│   │   │   │   └── 神经网络性能评价 --> ( 难度等级: [0.8815, 0.8815) || 挂载数据: 无 ) 
│   │   │   ├── Keras --> ( 难度等级: [0.8815, 0.8821) || 挂载数据: 无 ) 
│   │   │   │   ├── Keras基础语法 --> ( 难度等级: [0.8815, 0.8816) || 挂载数据: qa: 4 ) 
│   │   │   │   ├── 兼容Backend --> ( 难度等级: [0.8816, 0.8816) || 挂载数据: 无 ) 
│   │   │   │   ├── 函数模型和序列模型 --> ( 难度等级: [0.8816, 0.8817) || 挂载数据: 无 ) 
│   │   │   │   ├── 定义Layer --> ( 难度等级: [0.8817, 0.8817) || 挂载数据: 无 ) 
│   │   │   │   ├── CNN --> ( 难度等级: [0.8817, 0.8818) || 挂载数据: 无 ) 
│   │   │   │   ├── RNN(GRU/LSTM) --> ( 难度等级: [0.8818, 0.8818) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── Autoencoder --> ( 难度等级: [0.8818, 0.8819) || 挂载数据: 无 ) 
│   │   │   │   ├── GNN --> ( 难度等级: [0.8819, 0.8819) || 挂载数据: 无 ) 
│   │   │   │   ├── 迁移学习 --> ( 难度等级: [0.8819, 0.882) || 挂载数据: 无 ) 
│   │   │   │   ├── BiLSTM-Attention --> ( 难度等级: [0.882, 0.882) || 挂载数据: 无 ) 
│   │   │   │   ├── 生成对抗网络GAN --> ( 难度等级: [0.882, 0.8821) || 挂载数据: 无 ) 
│   │   │   │   ├── 神经网络参数保存 --> ( 难度等级: [0.8821, 0.8821) || 挂载数据: 无 ) 
│   │   │   │   └── 神经网络性能评价 --> ( 难度等级: [0.8821, 0.8821) || 挂载数据: 无 ) 
│   │   │   ├── PyTorch --> ( 难度等级: [0.8821, 0.8827) || 挂载数据: 无 ) 
│   │   │   │   ├── PyTorch基础知识 --> ( 难度等级: [0.8821, 0.8822) || 挂载数据: blog: 234 ) 
│   │   │   │   ├── Tensor --> ( 难度等级: [0.8822, 0.8822) || 挂载数据: blog: 7 ) 
│   │   │   │   ├── Variable --> ( 难度等级: [0.8822, 0.8823) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── 定义Layer --> ( 难度等级: [0.8823, 0.8823) || 挂载数据: 无 ) 
│   │   │   │   ├── 可视化 --> ( 难度等级: [0.8823, 0.8824) || 挂载数据: 无 ) 
│   │   │   │   ├── CNN(TextCNN) --> ( 难度等级: [0.8824, 0.8824) || 挂载数据: blog: 11 ) 
│   │   │   │   ├── RNN(GRU/LSTM) --> ( 难度等级: [0.8824, 0.8825) || 挂载数据: blog: 3 ) 
│   │   │   │   ├── Autoencoder --> ( 难度等级: [0.8825, 0.8825) || 挂载数据: 无 ) 
│   │   │   │   ├── GNN/GCN --> ( 难度等级: [0.8825, 0.8826) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 迁移学习 --> ( 难度等级: [0.8826, 0.8826) || 挂载数据: 无 ) 
│   │   │   │   ├── 生成对抗网络GAN --> ( 难度等级: [0.8826, 0.8826) || 挂载数据: 无 ) 
│   │   │   │   ├── 神经网络参数保存 --> ( 难度等级: [0.8826, 0.8827) || 挂载数据: 无 ) 
│   │   │   │   └── 神经网络性能评价 --> ( 难度等级: [0.8827, 0.8827) || 挂载数据: 无 ) 
│   │   │   └── 强化学习 --> ( 难度等级: [0.8827, 0.8833) || 挂载数据: qa: 1 ) 
│   │   │       ├── 强化学习概念 --> ( 难度等级: [0.8827, 0.8828) || 挂载数据: qa: 15; blog: 24 ) 
│   │   │       ├── Q-Learning --> ( 难度等级: [0.8828, 0.8829) || 挂载数据: qa: 1; blog: 2 ) 
│   │   │       ├── Sarsa --> ( 难度等级: [0.8829, 0.883) || 挂载数据: 无 ) 
│   │   │       ├── DQN(Deep Q Network) --> ( 难度等级: [0.883, 0.8831) || 挂载数据: qa: 1; blog: 2 ) 
│   │   │       ├── Policy Gradients --> ( 难度等级: [0.8831, 0.8832) || 挂载数据: 无 ) 
│   │   │       └── Actor Critic --> ( 难度等级: [0.8832, 0.8833) || 挂载数据: 无 ) 
│   │   ├── 计算机视觉 --> ( 难度等级: [0.8833, 0.8875) || 挂载数据: 无 ) 
│   │   │   ├── 数字图像处理基础 --> ( 难度等级: [0.8833, 0.8835) || 挂载数据: 无 ) 
│   │   │   │   ├── 数字图像处理 --> ( 难度等级: [0.8833, 0.8834) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 图像三要素 --> ( 难度等级: [0.8834, 0.8834) || 挂载数据: 无 ) 
│   │   │   │   ├── 像素及图像类型 --> ( 难度等级: [0.8834, 0.8835) || 挂载数据: 无 ) 
│   │   │   │   └── 图像信号数字转换 --> ( 难度等级: [0.8835, 0.8835) || 挂载数据: 无 ) 
│   │   │   ├── OpenCV基础 --> ( 难度等级: [0.8835, 0.8837) || 挂载数据: 无 ) 
│   │   │   │   ├── 安装配置 --> ( 难度等级: [0.8835, 0.8835) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── OpenCV基础语法 --> ( 难度等级: [0.8835, 0.8836) || 挂载数据: qa: 18; blog: 28 ) 
│   │   │   │   └── 几何图形绘制 --> ( 难度等级: [0.8836, 0.8837) || 挂载数据: 无 ) 
│   │   │   ├── 图像处理入门 --> ( 难度等级: [0.8837, 0.8838) || 挂载数据: 无 ) 
│   │   │   │   ├── 读取显示图像 --> ( 难度等级: [0.8837, 0.8837) || 挂载数据: 无 ) 
│   │   │   │   ├── 读取修改像素 --> ( 难度等级: [0.8837, 0.8837) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 创建复制保存图像 --> ( 难度等级: [0.8837, 0.8838) || 挂载数据: 无 ) 
│   │   │   │   └── 获取图像属性及通道 --> ( 难度等级: [0.8838, 0.8838) || 挂载数据: 无 ) 
│   │   │   ├── 图像算数与逻辑运算 --> ( 难度等级: [0.8838, 0.884) || 挂载数据: 无 ) 
│   │   │   │   ├── 图像加法运算 --> ( 难度等级: [0.8838, 0.8838) || 挂载数据: 无 ) 
│   │   │   │   ├── 图像减法运算 --> ( 难度等级: [0.8838, 0.8839) || 挂载数据: 无 ) 
│   │   │   │   ├── 图像与运算 --> ( 难度等级: [0.8839, 0.8839) || 挂载数据: 无 ) 
│   │   │   │   ├── 图像或运算 --> ( 难度等级: [0.8839, 0.8839) || 挂载数据: 无 ) 
│   │   │   │   ├── 图像异或运算 --> ( 难度等级: [0.8839, 0.8839) || 挂载数据: 无 ) 
│   │   │   │   └── 图像非运算 --> ( 难度等级: [0.8839, 0.884) || 挂载数据: 无 ) 
│   │   │   ├── 图像几何变换 --> ( 难度等级: [0.884, 0.8841) || 挂载数据: 无 ) 
│   │   │   │   ├── 平移变换 --> ( 难度等级: [0.884, 0.884) || 挂载数据: 无 ) 
│   │   │   │   ├── 缩放变换 --> ( 难度等级: [0.884, 0.884) || 挂载数据: 无 ) 
│   │   │   │   ├── 旋转变换 --> ( 难度等级: [0.884, 0.8841) || 挂载数据: 无 ) 
│   │   │   │   ├── 镜像变换 --> ( 难度等级: [0.8841, 0.8841) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 仿射变换 --> ( 难度等级: [0.8841, 0.8841) || 挂载数据: qa: 1 ) 
│   │   │   │   └── 透视变换 --> ( 难度等级: [0.8841, 0.8841) || 挂载数据: qa: 1 ) 
│   │   │   ├── 图像量化与采样 --> ( 难度等级: [0.8841, 0.8843) || 挂载数据: 无 ) 
│   │   │   │   ├── 图像量化处理 --> ( 难度等级: [0.8841, 0.8842) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 图像采样处理 --> ( 难度等级: [0.8842, 0.8842) || 挂载数据: 无 ) 
│   │   │   │   ├── 图像金字塔 --> ( 难度等级: [0.8842, 0.8843) || 挂载数据: qa: 1 ) 
│   │   │   │   └── 局部马赛克处理 --> ( 难度等级: [0.8843, 0.8843) || 挂载数据: 无 ) 
│   │   │   ├── 直方图统计 --> ( 难度等级: [0.8843, 0.8845) || 挂载数据: 无 ) 
│   │   │   │   ├── 直方图概述 --> ( 难度等级: [0.8843, 0.8843) || 挂载数据: 无 ) 
│   │   │   │   ├── 直方图绘制 --> ( 难度等级: [0.8843, 0.8844) || 挂载数据: 无 ) 
│   │   │   │   ├── 掩膜直方图 --> ( 难度等级: [0.8844, 0.8844) || 挂载数据: 无 ) 
│   │   │   │   ├── H-S直方图 --> ( 难度等级: [0.8844, 0.8844) || 挂载数据: qa: 1 ) 
│   │   │   │   └── 直方图对比 --> ( 难度等级: [0.8844, 0.8845) || 挂载数据: 无 ) 
│   │   │   ├── 图像增强 --> ( 难度等级: [0.8845, 0.8846) || 挂载数据: 无 ) 
│   │   │   │   ├── 图像增强 --> ( 难度等级: [0.8845, 0.8845) || 挂载数据: 无 ) 
│   │   │   │   ├── 直方图均衡化 --> ( 难度等级: [0.8845, 0.8845) || 挂载数据: 无 ) 
│   │   │   │   ├── 局部直方图均衡化 --> ( 难度等级: [0.8845, 0.8846) || 挂载数据: 无 ) 
│   │   │   │   ├── 自动色彩均衡化 --> ( 难度等级: [0.8846, 0.8846) || 挂载数据: 无 ) 
│   │   │   │   └── 图像去雾 --> ( 难度等级: [0.8846, 0.8846) || 挂载数据: 无 ) 
│   │   │   ├── 图像平滑 --> ( 难度等级: [0.8846, 0.8848) || 挂载数据: 无 ) 
│   │   │   │   ├── 图像平滑概述 --> ( 难度等级: [0.8846, 0.8846) || 挂载数据: 无 ) 
│   │   │   │   ├── 均值滤波 --> ( 难度等级: [0.8846, 0.8847) || 挂载数据: 无 ) 
│   │   │   │   ├── 方框滤波 --> ( 难度等级: [0.8847, 0.8847) || 挂载数据: 无 ) 
│   │   │   │   ├── 高斯滤波 --> ( 难度等级: [0.8847, 0.8847) || 挂载数据: 无 ) 
│   │   │   │   ├── 中值滤波 --> ( 难度等级: [0.8847, 0.8847) || 挂载数据: 无 ) 
│   │   │   │   └── 双边滤波 --> ( 难度等级: [0.8847, 0.8848) || 挂载数据: 无 ) 
│   │   │   ├── 图像锐化及边缘检测 --> ( 难度等级: [0.8848, 0.8849) || 挂载数据: 无 ) 
│   │   │   │   ├── 一阶微分算法、二阶微分算子 --> ( 难度等级: [0.8848, 0.8848) || 挂载数据: 无 ) 
│   │   │   │   ├── Roberts算子 --> ( 难度等级: [0.8848, 0.8848) || 挂载数据: 无 ) 
│   │   │   │   ├── Prewitt算子 --> ( 难度等级: [0.8848, 0.8848) || 挂载数据: 无 ) 
│   │   │   │   ├── Sobel算子 --> ( 难度等级: [0.8848, 0.8849) || 挂载数据: 无 ) 
│   │   │   │   ├── Laplacian算子 --> ( 难度等级: [0.8849, 0.8849) || 挂载数据: 无 ) 
│   │   │   │   ├── Scharr算子 --> ( 难度等级: [0.8849, 0.8849) || 挂载数据: 无 ) 
│   │   │   │   ├── Canny算子 --> ( 难度等级: [0.8849, 0.8849) || 挂载数据: 无 ) 
│   │   │   │   └── LOG算子 --> ( 难度等级: [0.8849, 0.8849) || 挂载数据: qa: 3 ) 
│   │   │   ├── 图像形态学处理 --> ( 难度等级: [0.8849, 0.8851) || 挂载数据: 无 ) 
│   │   │   │   ├── 图像腐蚀 --> ( 难度等级: [0.8849, 0.885) || 挂载数据: 无 ) 
│   │   │   │   ├── 图像膨胀 --> ( 难度等级: [0.885, 0.885) || 挂载数据: 无 ) 
│   │   │   │   ├── 图像开运算 --> ( 难度等级: [0.885, 0.885) || 挂载数据: 无 ) 
│   │   │   │   ├── 图像闭运算 --> ( 难度等级: [0.885, 0.885) || 挂载数据: 无 ) 
│   │   │   │   ├── 图像梯度运算 --> ( 难度等级: [0.885, 0.8851) || 挂载数据: 无 ) 
│   │   │   │   ├── 图像顶帽运算 --> ( 难度等级: [0.8851, 0.8851) || 挂载数据: 无 ) 
│   │   │   │   └── 图像底帽运算 --> ( 难度等级: [0.8851, 0.8851) || 挂载数据: 无 ) 
│   │   │   ├── 图像分割 --> ( 难度等级: [0.8851, 0.8853) || 挂载数据: 无 ) 
│   │   │   │   ├── 基于阈值的图像分割 --> ( 难度等级: [0.8851, 0.8851) || 挂载数据: qa: 4 ) 
│   │   │   │   ├── 基于边缘检测的图像分割 --> ( 难度等级: [0.8851, 0.8851) || 挂载数据: 无 ) 
│   │   │   │   ├── 基于纹理背景的图像分割 --> ( 难度等级: [0.8851, 0.8852) || 挂载数据: 无 ) 
│   │   │   │   ├── 基于K-Means聚类的区域分割 --> ( 难度等级: [0.8852, 0.8852) || 挂载数据: 无 ) 
│   │   │   │   ├── 基于均值漂移算法的图像分割 --> ( 难度等级: [0.8852, 0.8852) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 基于分水岭算法的图像分割 --> ( 难度等级: [0.8852, 0.8852) || 挂载数据: 无 ) 
│   │   │   │   ├── 图像漫水填充分割 --> ( 难度等级: [0.8852, 0.8852) || 挂载数据: 无 ) 
│   │   │   │   └── 文字区域分割及定位 --> ( 难度等级: [0.8852, 0.8853) || 挂载数据: 无 ) 
│   │   │   ├── 傅里叶变换 --> ( 难度等级: [0.8853, 0.8854) || 挂载数据: 无 ) 
│   │   │   │   ├── 傅里叶变换 --> ( 难度等级: [0.8853, 0.8853) || 挂载数据: qa: 2 ) 
│   │   │   │   ├── 傅里叶逆变换 --> ( 难度等级: [0.8853, 0.8853) || 挂载数据: 无 ) 
│   │   │   │   ├── 高通滤波器 --> ( 难度等级: [0.8853, 0.8854) || 挂载数据: 无 ) 
│   │   │   │   └── 低通滤波器 --> ( 难度等级: [0.8854, 0.8854) || 挂载数据: 无 ) 
│   │   │   ├── 霍夫变换 --> ( 难度等级: [0.8854, 0.8856) || 挂载数据: 无 ) 
│   │   │   │   ├── 霍夫变换 --> ( 难度等级: [0.8854, 0.8855) || 挂载数据: 无 ) 
│   │   │   │   ├── 霍夫线变换 --> ( 难度等级: [0.8855, 0.8855) || 挂载数据: 无 ) 
│   │   │   │   └── 霍夫圆变换 --> ( 难度等级: [0.8855, 0.8856) || 挂载数据: 无 ) 
│   │   │   ├── 图像特效处理 --> ( 难度等级: [0.8856, 0.8857) || 挂载数据: 无 ) 
│   │   │   │   ├── 图像毛玻璃特效 --> ( 难度等级: [0.8856, 0.8856) || 挂载数据: 无 ) 
│   │   │   │   ├── 图像浮雕特效 --> ( 难度等级: [0.8856, 0.8856) || 挂载数据: 无 ) 
│   │   │   │   ├── 图像素描特效 --> ( 难度等级: [0.8856, 0.8856) || 挂载数据: 无 ) 
│   │   │   │   ├── 图像怀旧特效 --> ( 难度等级: [0.8856, 0.8857) || 挂载数据: 无 ) 
│   │   │   │   ├── 图像流年特效 --> ( 难度等级: [0.8857, 0.8857) || 挂载数据: 无 ) 
│   │   │   │   ├── 图像滤镜特效 --> ( 难度等级: [0.8857, 0.8857) || 挂载数据: 无 ) 
│   │   │   │   ├── 图像水波特效 --> ( 难度等级: [0.8857, 0.8857) || 挂载数据: 无 ) 
│   │   │   │   └── 图像卡通特效 --> ( 难度等级: [0.8857, 0.8857) || 挂载数据: 无 ) 
│   │   │   ├── 图像分类 --> ( 难度等级: [0.8857, 0.8859) || 挂载数据: 无 ) 
│   │   │   │   ├── 图像分类概述 --> ( 难度等级: [0.8857, 0.8858) || 挂载数据: 无 ) 
│   │   │   │   ├── 基于机器学习的图像分类 --> ( 难度等级: [0.8858, 0.8858) || 挂载数据: qa: 1; blog: 1 ) 
│   │   │   │   ├── 基于深度学习的图像分类 --> ( 难度等级: [0.8858, 0.8858) || 挂载数据: qa: 2; blog: 3 ) 
│   │   │   │   ├── LeNet --> ( 难度等级: [0.8858, 0.8858) || 挂载数据: 无 ) 
│   │   │   │   ├── VGG --> ( 难度等级: [0.8858, 0.8859) || 挂载数据: 无 ) 
│   │   │   │   ├── AlexNet --> ( 难度等级: [0.8859, 0.8859) || 挂载数据: 无 ) 
│   │   │   │   └── ResNet --> ( 难度等级: [0.8859, 0.8859) || 挂载数据: qa: 1 ) 
│   │   │   ├── 人脸识别 --> ( 难度等级: [0.8859, 0.8861) || 挂载数据: 无 ) 
│   │   │   ├── 目标检测 --> ( 难度等级: [0.8861, 0.8862) || 挂载数据: 无 ) 
│   │   │   │   ├── 目标检测概述 --> ( 难度等级: [0.8861, 0.8861) || 挂载数据: qa: 3; blog: 2 ) 
│   │   │   │   ├── RCNN --> ( 难度等级: [0.8861, 0.8861) || 挂载数据: 无 ) 
│   │   │   │   ├── Fast-RCNN --> ( 难度等级: [0.8861, 0.8861) || 挂载数据: 无 ) 
│   │   │   │   ├── SPPNet --> ( 难度等级: [0.8861, 0.8861) || 挂载数据: 无 ) 
│   │   │   │   ├── Mask-RCNN --> ( 难度等级: [0.8861, 0.8862) || 挂载数据: qa: 2 ) 
│   │   │   │   ├── SSD --> ( 难度等级: [0.8862, 0.8862) || 挂载数据: blog: 1 ) 
│   │   │   │   └── YOLO系列算法 --> ( 难度等级: [0.8862, 0.8862) || 挂载数据: qa: 1 ) 
│   │   │   ├── 深度神经网络概述 --> ( 难度等级: [0.8862, 0.8864) || 挂载数据: 无 ) 
│   │   │   │   ├── 创建神经网络块 --> ( 难度等级: [0.8862, 0.8862) || 挂载数据: 无 ) 
│   │   │   │   ├── TensorFlow介绍 --> ( 难度等级: [0.8862, 0.8863) || 挂载数据: 无 ) 
│   │   │   │   ├── MNIST数据集介绍 --> ( 难度等级: [0.8863, 0.8863) || 挂载数据: 无 ) 
│   │   │   │   ├── Keras深度学习库概述 --> ( 难度等级: [0.8863, 0.8863) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── 基于Keras和MNIST的手写数字识别 --> ( 难度等级: [0.8863, 0.8864) || 挂载数据: qa: 1; blog: 1 ) 
│   │   │   │   │   ├── 训练和测试数据的检索 --> ( 难度等级: [0.8863, 0.8863) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 训练数据的可视化 --> ( 难度等级: [0.8863, 0.8863) || 挂载数据: qa: 1 ) 
│   │   │   │   │   ├── 创建神经网络 --> ( 难度等级: [0.8863, 0.8863) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 训练神经网络 --> ( 难度等级: [0.8863, 0.8863) || 挂载数据: qa: 2 ) 
│   │   │   │   │   └── 测试 --> ( 难度等级: [0.8863, 0.8864) || 挂载数据: 无 ) 
│   │   │   │   └── 理解反向传播 --> ( 难度等级: [0.8864, 0.8864) || 挂载数据: 无 ) 
│   │   │   ├── 卷积神经网络介绍 --> ( 难度等级: [0.8864, 0.8865) || 挂载数据: 无 ) 
│   │   │   │   ├── CNN历史 --> ( 难度等级: [0.8864, 0.8865) || 挂载数据: 无 ) 
│   │   │   │   └── 卷积神经网络 --> ( 难度等级: [0.8865, 0.8865) || 挂载数据: 无 ) 
│   │   │   │       ├── 计算机如何解释图像 --> ( 难度等级: [0.8865, 0.8865) || 挂载数据: qa: 1; blog: 1 ) 
│   │   │   │       ├── 编码实现图像可视化 --> ( 难度等级: [0.8865, 0.8865) || 挂载数据: 无 ) 
│   │   │   │       ├── dropout --> ( 难度等级: [0.8865, 0.8865) || 挂载数据: 无 ) 
│   │   │   │       ├── 输入层 --> ( 难度等级: [0.8865, 0.8865) || 挂载数据: 无 ) 
│   │   │   │       ├── 卷积层 --> ( 难度等级: [0.8865, 0.8865) || 挂载数据: blog: 1 ) 
│   │   │   │       └── 池化层 --> ( 难度等级: [0.8865, 0.8865) || 挂载数据: 无 ) 
│   │   │   ├── 构建CNN并进行性能优化 --> ( 难度等级: [0.8865, 0.8867) || 挂载数据: 无 ) 
│   │   │   │   ├── CNN架构和DNN的缺点 --> ( 难度等级: [0.8865, 0.8866) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 卷积操作 --> ( 难度等级: [0.8865, 0.8866) || 挂载数据: 无 ) 
│   │   │   │   │   └── 池化、步长和填充操作 --> ( 难度等级: [0.8866, 0.8866) || 挂载数据: 无 ) 
│   │   │   │   ├── TensorFlow中的卷积和池化操作 --> ( 难度等级: [0.8866, 0.8866) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 在TensorFlow中应用池化操作 --> ( 难度等级: [0.8866, 0.8866) || 挂载数据: 无 ) 
│   │   │   │   │   └── TensorFlow中的卷积操作 --> ( 难度等级: [0.8866, 0.8866) || 挂载数据: blog: 37 ) 
│   │   │   │   ├── 训练CNN --> ( 难度等级: [0.8866, 0.8867) || 挂载数据: qa: 1 ) 
│   │   │   │   │   ├── 初始化权重和偏置 --> ( 难度等级: [0.8866, 0.8866) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 正则化 --> ( 难度等级: [0.8866, 0.8866) || 挂载数据: 无 ) 
│   │   │   │   │   └── 激活函数 --> ( 难度等级: [0.8866, 0.8867) || 挂载数据: 无 ) 
│   │   │   │   └── 模型性能优化 --> ( 难度等级: [0.8867, 0.8867) || 挂载数据: blog: 1 ) 
│   │   │   │       ├── 隐含层数量 --> ( 难度等级: [0.8867, 0.8867) || 挂载数据: 无 ) 
│   │   │   │       ├── 每个隐含层的神经元个数 --> ( 难度等级: [0.8867, 0.8867) || 挂载数据: 无 ) 
│   │   │   │       ├── 批标准化 --> ( 难度等级: [0.8867, 0.8867) || 挂载数据: 无 ) 
│   │   │   │       ├── 高级正则化及过拟合的避免 --> ( 难度等级: [0.8867, 0.8867) || 挂载数据: 无 ) 
│   │   │   │       ├── 运用哪个优化器 --> ( 难度等级: [0.8867, 0.8867) || 挂载数据: qa: 5; blog: 2 ) 
│   │   │   │       ├── 内存调优 --> ( 难度等级: [0.8867, 0.8867) || 挂载数据: 无 ) 
│   │   │   │       ├── 层的位置调优 --> ( 难度等级: [0.8867, 0.8867) || 挂载数据: 无 ) 
│   │   │   │       ├── 综合所有操作创建第二个CNN --> ( 难度等级: [0.8867, 0.8867) || 挂载数据: 无 ) 
│   │   │   │       ├── 数据集描述和预处理 --> ( 难度等级: [0.8867, 0.8867) || 挂载数据: 无 ) 
│   │   │   │       └── 创建CNN模型 --> ( 难度等级: [0.8867, 0.8867) || 挂载数据: qa: 2 ) 
│   │   │   ├── 经典的CNN模型架构 --> ( 难度等级: [0.8867, 0.8869) || 挂载数据: 无 ) 
│   │   │   │   ├── ImageNet介绍 --> ( 难度等级: [0.8867, 0.8867) || 挂载数据: 无 ) 
│   │   │   │   ├── AlexNet架构 --> ( 难度等级: [0.8867, 0.8868) || 挂载数据: 无 ) 
│   │   │   │   ├── VGGNet架构 --> ( 难度等级: [0.8868, 0.8868) || 挂载数据: 无 ) 
│   │   │   │   ├── GoogLeNet架构 --> ( 难度等级: [0.8868, 0.8868) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 架构洞察 --> ( 难度等级: [0.8868, 0.8868) || 挂载数据: 无 ) 
│   │   │   │   │   └── inception模块 --> ( 难度等级: [0.8868, 0.8868) || 挂载数据: 无 ) 
│   │   │   │   └── ResNet架构 --> ( 难度等级: [0.8868, 0.8869) || 挂载数据: 无 ) 
│   │   │   ├── 转移学习 --> ( 难度等级: [0.8869, 0.887) || 挂载数据: 无 ) 
│   │   │   │   ├── 特征提取方法 --> ( 难度等级: [0.8869, 0.8869) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 目标数据集较小且与原始训练集相似 --> ( 难度等级: [0.8869, 0.8869) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 目标数据集较小且与原始训练集不同 --> ( 难度等级: [0.8869, 0.8869) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 目标数据集很大且与原始训练集相似 --> ( 难度等级: [0.8869, 0.8869) || 挂载数据: 无 ) 
│   │   │   │   │   └── 目标数据集很大且与原始训练集不同 --> ( 难度等级: [0.8869, 0.8869) || 挂载数据: 无 ) 
│   │   │   │   ├── 转移学习示例 --> ( 难度等级: [0.8869, 0.887) || 挂载数据: 无 ) 
│   │   │   │   └── 多任务学习 --> ( 难度等级: [0.887, 0.887) || 挂载数据: 无 ) 
│   │   │   ├── CNN自编码器 --> ( 难度等级: [0.887, 0.8872) || 挂载数据: 无 ) 
│   │   │   │   ├── 自编码器介绍 --> ( 难度等级: [0.887, 0.8871) || 挂载数据: 无 ) 
│   │   │   │   ├── 卷积自编码器 --> ( 难度等级: [0.8871, 0.8871) || 挂载数据: 无 ) 
│   │   │   │   └── 应用 --> ( 难度等级: [0.8871, 0.8872) || 挂载数据: 无 ) 
│   │   │   ├── GAN：使用CNN生成新图像 --> ( 难度等级: [0.8872, 0.8873) || 挂载数据: 无 ) 
│   │   │   │   ├── Pix2pix：基于GAN的图像翻译 --> ( 难度等级: [0.8872, 0.8872) || 挂载数据: 无 ) 
│   │   │   │   │   ├── CycleGAN --> ( 难度等级: [0.8872, 0.8872) || 挂载数据: 无 ) 
│   │   │   │   │   └── 训练GAN模型 --> ( 难度等级: [0.8872, 0.8872) || 挂载数据: qa: 2 ) 
│   │   │   │   ├── GAN的代码示例 --> ( 难度等级: [0.8872, 0.8873) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 计算损失 --> ( 难度等级: [0.8872, 0.8873) || 挂载数据: 无 ) 
│   │   │   │   │   └── 半监督学习和GAN --> ( 难度等级: [0.8873, 0.8873) || 挂载数据: blog: 5 ) 
│   │   │   │   └── 特征匹配 --> ( 难度等级: [0.8873, 0.8873) || 挂载数据: 无 ) 
│   │   │   │       ├── 基于半监督分类的GAN示例 --> ( 难度等级: [0.8873, 0.8873) || 挂载数据: 无 ) 
│   │   │   │       └── 深度卷积GAN --> ( 难度等级: [0.8873, 0.8873) || 挂载数据: 无 ) 
│   │   │   └── CNN和视觉模型的注意力机制 --> ( 难度等级: [0.8873, 0.8875) || 挂载数据: 无 ) 
│   │   │       ├── 图像描述中的注意力机制 --> ( 难度等级: [0.8873, 0.8874) || 挂载数据: 无 ) 
│   │   │       ├── 注意力类型 --> ( 难度等级: [0.8874, 0.8874) || 挂载数据: 无 ) 
│   │   │       │   ├── 硬注意力 --> ( 难度等级: [0.8874, 0.8874) || 挂载数据: 无 ) 
│   │   │       │   └── 软注意力 --> ( 难度等级: [0.8874, 0.8874) || 挂载数据: 无 ) 
│   │   │       ├── 运用注意力改善视觉模型 --> ( 难度等级: [0.8874, 0.8875) || 挂载数据: 无 ) 
│   │   │       │   ├── 视觉CNN模型次优性能的原因 --> ( 难度等级: [0.8874, 0.8874) || 挂载数据: 无 ) 
│   │   │       │   └── 循环视觉注意力模型 --> ( 难度等级: [0.8874, 0.8875) || 挂载数据: qa: 2 ) 
│   │   │       └── 参考文献 --> ( 难度等级: [0.8875, 0.8875) || 挂载数据: 无 ) 
│   │   ├── 自然语言处理 --> ( 难度等级: [0.8875, 0.8917) || 挂载数据: 无 ) 
│   │   │   ├── 自然语言处理概览 --> ( 难度等级: [0.8875, 0.8877) || 挂载数据: 无 ) 
│   │   │   │   ├── 自然语言处理的基本概念 --> ( 难度等级: [0.8875, 0.8876) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 自然语言处理的面临困难 --> ( 难度等级: [0.8876, 0.8877) || 挂载数据: 无 ) 
│   │   │   │   └── 自然语言处理的研究现状 --> ( 难度等级: [0.8877, 0.8877) || 挂载数据: qa: 1 ) 
│   │   │   ├── 预备知识 --> ( 难度等级: [0.8877, 0.888) || 挂载数据: 无 ) 
│   │   │   │   ├── 概率论基础知识 --> ( 难度等级: [0.8877, 0.8877) || 挂载数据: 无 ) 
│   │   │   │   ├── 最大似然估计 --> ( 难度等级: [0.8877, 0.8878) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 隐马尔可夫模型 --> ( 难度等级: [0.8878, 0.8878) || 挂载数据: 无 ) 
│   │   │   │   ├── 贝叶斯网络 --> ( 难度等级: [0.8878, 0.8878) || 挂载数据: 无 ) 
│   │   │   │   ├── 条件概率分布 --> ( 难度等级: [0.8878, 0.8878) || 挂载数据: 无 ) 
│   │   │   │   ├── 信息论基础知识 --> ( 难度等级: [0.8878, 0.8878) || 挂载数据: 无 ) 
│   │   │   │   ├── 熵 --> ( 难度等级: [0.8878, 0.8878) || 挂载数据: 无 ) 
│   │   │   │   ├── 困惑度 --> ( 难度等级: [0.8878, 0.8879) || 挂载数据: 无 ) 
│   │   │   │   ├── 互信息 --> ( 难度等级: [0.8879, 0.8879) || 挂载数据: 无 ) 
│   │   │   │   ├── 神经网络基础知识 --> ( 难度等级: [0.8879, 0.8879) || 挂载数据: 无 ) 
│   │   │   │   ├── CRF --> ( 难度等级: [0.8879, 0.8879) || 挂载数据: 无 ) 
│   │   │   │   ├── BiLSTM+Attention --> ( 难度等级: [0.8879, 0.8879) || 挂载数据: 无 ) 
│   │   │   │   ├── 迁移学习 --> ( 难度等级: [0.8879, 0.8879) || 挂载数据: 无 ) 
│   │   │   │   └── 常用语料库和知识库 --> ( 难度等级: [0.8879, 0.888) || 挂载数据: 无 ) 
│   │   │   ├── jieba --> ( 难度等级: [0.888, 0.8882) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── jieba概述 --> ( 难度等级: [0.888, 0.888) || 挂载数据: 无 ) 
│   │   │   │   ├── jieba分词 --> ( 难度等级: [0.888, 0.8881) || 挂载数据: qa: 2; blog: 1 ) 
│   │   │   │   ├── jieba添加自定义词典 --> ( 难度等级: [0.8881, 0.8881) || 挂载数据: 无 ) 
│   │   │   │   ├── jieba词性标注 --> ( 难度等级: [0.8881, 0.8881) || 挂载数据: 无 ) 
│   │   │   │   └── jieba关键词抽取 --> ( 难度等级: [0.8881, 0.8882) || 挂载数据: 无 ) 
│   │   │   ├── nltk --> ( 难度等级: [0.8882, 0.8884) || 挂载数据: 无 ) 
│   │   │   │   ├── nltk概述 --> ( 难度等级: [0.8882, 0.8882) || 挂载数据: 无 ) 
│   │   │   │   ├── nltk字符串处理 --> ( 难度等级: [0.8882, 0.8883) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── nltk词性标注 --> ( 难度等级: [0.8883, 0.8883) || 挂载数据: blog: 14 ) 
│   │   │   │   ├── nltk词干提取 --> ( 难度等级: [0.8883, 0.8883) || 挂载数据: blog: 3 ) 
│   │   │   │   ├── nltk命名实体识别 --> ( 难度等级: [0.8883, 0.8883) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── nltk分块处理 --> ( 难度等级: [0.8883, 0.8884) || 挂载数据: blog: 198 ) 
│   │   │   │   ├── nltk文本分类 --> ( 难度等级: [0.8884, 0.8884) || 挂载数据: blog: 16 ) 
│   │   │   │   └── nltk情感分析 --> ( 难度等级: [0.8884, 0.8884) || 挂载数据: blog: 11 ) 
│   │   │   ├── Genism --> ( 难度等级: [0.8884, 0.8887) || 挂载数据: 无 ) 
│   │   │   │   ├── TF-IDF --> ( 难度等级: [0.8884, 0.8885) || 挂载数据: qa: 1; blog: 1 ) 
│   │   │   │   ├── similarities --> ( 难度等级: [0.8885, 0.8885) || 挂载数据: 无 ) 
│   │   │   │   ├── LSA --> ( 难度等级: [0.8885, 0.8886) || 挂载数据: 无 ) 
│   │   │   │   ├── LDA --> ( 难度等级: [0.8886, 0.8886) || 挂载数据: 无 ) 
│   │   │   │   └── Word2vec --> ( 难度等级: [0.8886, 0.8887) || 挂载数据: 无 ) 
│   │   │   ├── 词法分析 --> ( 难度等级: [0.8887, 0.8889) || 挂载数据: 无 ) 
│   │   │   │   ├── 分词(英文分词/中文分词) --> ( 难度等级: [0.8887, 0.8887) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 词干提取 --> ( 难度等级: [0.8887, 0.8887) || 挂载数据: 无 ) 
│   │   │   │   ├── 词形还原 --> ( 难度等级: [0.8887, 0.8888) || 挂载数据: 无 ) 
│   │   │   │   ├── 词性标注 --> ( 难度等级: [0.8888, 0.8888) || 挂载数据: 无 ) 
│   │   │   │   └── 命名实体识别 --> ( 难度等级: [0.8888, 0.8889) || 挂载数据: qa: 1 ) 
│   │   │   ├── 句法分析 --> ( 难度等级: [0.8889, 0.8891) || 挂载数据: 无 ) 
│   │   │   │   ├── 短语结构分析 --> ( 难度等级: [0.8889, 0.889) || 挂载数据: 无 ) 
│   │   │   │   └── 依存句法分析 --> ( 难度等级: [0.889, 0.8891) || 挂载数据: 无 ) 
│   │   │   ├── 语义分析 --> ( 难度等级: [0.8891, 0.8894) || 挂载数据: 无 ) 
│   │   │   │   ├── 命名实体消歧 --> ( 难度等级: [0.8891, 0.8892) || 挂载数据: 无 ) 
│   │   │   │   ├── 指代消解 --> ( 难度等级: [0.8892, 0.8892) || 挂载数据: 无 ) 
│   │   │   │   ├── 语义角色标注 --> ( 难度等级: [0.8892, 0.8892) || 挂载数据: 无 ) 
│   │   │   │   ├── 语义关系抽取 --> ( 难度等级: [0.8892, 0.8893) || 挂载数据: 无 ) 
│   │   │   │   ├── 语义依存分析 --> ( 难度等级: [0.8893, 0.8893) || 挂载数据: qa: 4; blog: 3 ) 
│   │   │   │   └── 抽象语义表示 --> ( 难度等级: [0.8893, 0.8894) || 挂载数据: 无 ) 
│   │   │   ├── 词嵌入 --> ( 难度等级: [0.8894, 0.8896) || 挂载数据: qa: 2 ) 
│   │   │   │   ├── Word2Vec --> ( 难度等级: [0.8894, 0.8894) || 挂载数据: 无 ) 
│   │   │   │   ├── GloVe --> ( 难度等级: [0.8894, 0.8894) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── fastText --> ( 难度等级: [0.8894, 0.8895) || 挂载数据: 无 ) 
│   │   │   │   ├── ELMo --> ( 难度等级: [0.8895, 0.8895) || 挂载数据: 无 ) 
│   │   │   │   ├── BERT --> ( 难度等级: [0.8895, 0.8895) || 挂载数据: 无 ) 
│   │   │   │   └── XLNet --> ( 难度等级: [0.8895, 0.8896) || 挂载数据: 无 ) 
│   │   │   ├── 文本挖掘 --> ( 难度等级: [0.8896, 0.8898) || 挂载数据: 无 ) 
│   │   │   │   ├── 文本相似度计算 --> ( 难度等级: [0.8896, 0.8896) || 挂载数据: 无 ) 
│   │   │   │   ├── 文本聚类 --> ( 难度等级: [0.8896, 0.8897) || 挂载数据: 无 ) 
│   │   │   │   ├── 文本分类 --> ( 难度等级: [0.8897, 0.8898) || 挂载数据: blog: 1 ) 
│   │   │   │   └── 文本摘要 --> ( 难度等级: [0.8898, 0.8898) || 挂载数据: qa: 10 ) 
│   │   │   ├── 情感分析 --> ( 难度等级: [0.8898, 0.89) || 挂载数据: 无 ) 
│   │   │   │   ├── 基于情感词典的情感分析 --> ( 难度等级: [0.8898, 0.8899) || 挂载数据: 无 ) 
│   │   │   │   └── 基于深度学习的情感分析 --> ( 难度等级: [0.8899, 0.89) || 挂载数据: 无 ) 
│   │   │   ├── 主题模型 --> ( 难度等级: [0.89, 0.8903) || 挂载数据: 无 ) 
│   │   │   │   ├── LSA --> ( 难度等级: [0.89, 0.8902) || 挂载数据: 无 ) 
│   │   │   │   └── LDA --> ( 难度等级: [0.8902, 0.8903) || 挂载数据: qa: 2 ) 
│   │   │   ├── 机器翻译 --> ( 难度等级: [0.8903, 0.8905) || 挂载数据: 无 ) 
│   │   │   │   ├── IBM统计翻译模型 --> ( 难度等级: [0.8903, 0.8903) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── 短语抽取 --> ( 难度等级: [0.8903, 0.8904) || 挂载数据: 无 ) 
│   │   │   │   ├── 语言模型 --> ( 难度等级: [0.8904, 0.8904) || 挂载数据: qa: 12; blog: 1 ) 
│   │   │   │   ├── GNMT --> ( 难度等级: [0.8904, 0.8904) || 挂载数据: 无 ) 
│   │   │   │   ├── Seq2Seq --> ( 难度等级: [0.8904, 0.8905) || 挂载数据: 无 ) 
│   │   │   │   └── Transformer --> ( 难度等级: [0.8905, 0.8905) || 挂载数据: blog: 1 ) 
│   │   │   ├── 语言模型 --> ( 难度等级: [0.8905, 0.8907) || 挂载数据: 无 ) 
│   │   │   │   ├── n-gram --> ( 难度等级: [0.8905, 0.8906) || 挂载数据: qa: 7 ) 
│   │   │   │   ├── Pitman-Yor过程模型 --> ( 难度等级: [0.8906, 0.8906) || 挂载数据: 无 ) 
│   │   │   │   ├── AWD-LSTM --> ( 难度等级: [0.8906, 0.8906) || 挂载数据: 无 ) 
│   │   │   │   ├── Transformer-XL --> ( 难度等级: [0.8906, 0.8907) || 挂载数据: blog: 2 ) 
│   │   │   │   └── Gated CNN --> ( 难度等级: [0.8907, 0.8907) || 挂载数据: 无 ) 
│   │   │   ├── 智能问答 --> ( 难度等级: [0.8907, 0.891) || 挂载数据: 无 ) 
│   │   │   │   ├── 基于知识的问答 --> ( 难度等级: [0.8907, 0.8908) || 挂载数据: 无 ) 
│   │   │   │   ├── 基于检索的问答 --> ( 难度等级: [0.8908, 0.8909) || 挂载数据: 无 ) 
│   │   │   │   ├── 阅读理解 --> ( 难度等级: [0.8909, 0.8909) || 挂载数据: qa: 4; blog: 1 ) 
│   │   │   │   └── 完形填空 --> ( 难度等级: [0.8909, 0.891) || 挂载数据: 无 ) 
│   │   │   ├── 智能对话 --> ( 难度等级: [0.891, 0.8912) || 挂载数据: 无 ) 
│   │   │   │   ├── 对话行为分类 --> ( 难度等级: [0.891, 0.891) || 挂载数据: 无 ) 
│   │   │   │   ├── 对话状态跟踪 --> ( 难度等级: [0.891, 0.891) || 挂载数据: 无 ) 
│   │   │   │   ├── 检索式聊天机器人 --> ( 难度等级: [0.891, 0.8911) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 生成式聊天机器人 --> ( 难度等级: [0.8911, 0.8911) || 挂载数据: 无 ) 
│   │   │   │   ├── 意图识别 --> ( 难度等级: [0.8911, 0.8912) || 挂载数据: 无 ) 
│   │   │   │   └── 槽填充(Slot Filling) --> ( 难度等级: [0.8912, 0.8912) || 挂载数据: 无 ) 
│   │   │   ├── 语音识别 --> ( 难度等级: [0.8912, 0.8914) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 傅里叶变换 --> ( 难度等级: [0.8912, 0.8912) || 挂载数据: 无 ) 
│   │   │   │   ├── 声学模型 --> ( 难度等级: [0.8912, 0.8913) || 挂载数据: 无 ) 
│   │   │   │   ├── 隐马尔可夫模型 --> ( 难度等级: [0.8913, 0.8913) || 挂载数据: 无 ) 
│   │   │   │   ├── CNN --> ( 难度等级: [0.8913, 0.8913) || 挂载数据: 无 ) 
│   │   │   │   ├── LSTM-HMM --> ( 难度等级: [0.8913, 0.8914) || 挂载数据: 无 ) 
│   │   │   │   ├── 神经网络语言模型 --> ( 难度等级: [0.8914, 0.8914) || 挂载数据: 无 ) 
│   │   │   │   └── MFCC --> ( 难度等级: [0.8914, 0.8914) || 挂载数据: 无 ) 
│   │   │   └── 知识图谱 --> ( 难度等级: [0.8914, 0.8917) || 挂载数据: 无 ) 
│   │   │       ├── 知识图谱构建 --> ( 难度等级: [0.8914, 0.8915) || 挂载数据: 无 ) 
│   │   │       ├── 知识计算 --> ( 难度等级: [0.8915, 0.8916) || 挂载数据: 无 ) 
│   │   │       ├── 知识存储 --> ( 难度等级: [0.8916, 0.8916) || 挂载数据: qa: 2 ) 
│   │   │       └── 知识服务与应用 --> ( 难度等级: [0.8916, 0.8917) || 挂载数据: 无 ) 
│   │   ├── 简介 --> ( 难度等级: [0.8917, 0.8958) || 挂载数据: 无 ) 
│   │   │   ├── 为何选择Python --> ( 难度等级: [0.8917, 0.8924) || 挂载数据: 无 ) 
│   │   │   ├── 何时避免使用Python --> ( 难度等级: [0.8924, 0.8931) || 挂载数据: 无 ) 
│   │   │   ├── Python中的面向对象编程 --> ( 难度等级: [0.8931, 0.8937) || 挂载数据: blog: 1 ) 
│   │   │   ├── 在Python中调用其他语言 --> ( 难度等级: [0.8937, 0.8944) || 挂载数据: 无 ) 
│   │   │   ├── 将Python模型作为微服务 --> ( 难度等级: [0.8944, 0.8951) || 挂载数据: 无 ) 
│   │   │   └── 高性能API和并发编程 --> ( 难度等级: [0.8951, 0.8958) || 挂载数据: 无 ) 
│   │   ├── Python结构化数据提取、转换和加载 --> ( 难度等级: [0.8958, 0.9) || 挂载数据: 无 ) 
│   │   │   ├── MySQL --> ( 难度等级: [0.8958, 0.8962) || 挂载数据: 无 ) 
│   │   │   │   ├── 如何安装MySQLdb --> ( 难度等级: [0.8958, 0.8959) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 数据库连接 --> ( 难度等级: [0.8959, 0.8959) || 挂载数据: 无 ) 
│   │   │   │   ├── INSERT操作 --> ( 难度等级: [0.8959, 0.896) || 挂载数据: qa: 1; blog: 1 ) 
│   │   │   │   ├── READ操作 --> ( 难度等级: [0.896, 0.896) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── DELETE操作 --> ( 难度等级: [0.896, 0.8961) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── UPDATE操作 --> ( 难度等级: [0.8961, 0.8961) || 挂载数据: qa: 2 ) 
│   │   │   │   ├── COMMIT操作 --> ( 难度等级: [0.8961, 0.8962) || 挂载数据: 无 ) 
│   │   │   │   └── ROLL-BACK操作 --> ( 难度等级: [0.8962, 0.8962) || 挂载数据: 无 ) 
│   │   │   ├── Elasticsearch --> ( 难度等级: [0.8962, 0.8966) || 挂载数据: 无 ) 
│   │   │   ├── Neo4j Python驱动 --> ( 难度等级: [0.8966, 0.897) || 挂载数据: 无 ) 
│   │   │   ├── neo4j-rest-client --> ( 难度等级: [0.897, 0.8973) || 挂载数据: 无 ) 
│   │   │   ├── 内存数据库 --> ( 难度等级: [0.8973, 0.8977) || 挂载数据: 无 ) 
│   │   │   ├── Python版本MongoDB --> ( 难度等级: [0.8977, 0.8981) || 挂载数据: 无 ) 
│   │   │   │   ├── 将数据导入集合 --> ( 难度等级: [0.8977, 0.8978) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用pymongo创建连接 --> ( 难度等级: [0.8978, 0.8979) || 挂载数据: 无 ) 
│   │   │   │   ├── 访问数据库对象 --> ( 难度等级: [0.8979, 0.8979) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 插入数据 --> ( 难度等级: [0.8979, 0.898) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 更新数据 --> ( 难度等级: [0.898, 0.898) || 挂载数据: 无 ) 
│   │   │   │   └── 删除数据 --> ( 难度等级: [0.898, 0.8981) || 挂载数据: qa: 2 ) 
│   │   │   ├── Pandas --> ( 难度等级: [0.8981, 0.8985) || 挂载数据: 无 ) 
│   │   │   ├── Python非结构化数据提取、转换和加载 --> ( 难度等级: [0.8985, 0.8989) || 挂载数据: 无 ) 
│   │   │   │   ├── 电子邮件解析 --> ( 难度等级: [0.8985, 0.8987) || 挂载数据: 无 ) 
│   │   │   │   └── 主题爬取 --> ( 难度等级: [0.8987, 0.8989) || 挂载数据: 无 ) 
│   │   │   ├── 稳定方差 --> ( 难度等级: [0.8989, 0.8992) || 挂载数据: 无 ) 
│   │   │   ├── 使周期效应累加 --> ( 难度等级: [0.8992, 0.8996) || 挂载数据: 无 ) 
│   │   │   └── 使数据呈正态分布 --> ( 难度等级: [0.8996, 0.9) || 挂载数据: 无 ) 
│   │   ├── 基于Python的监督学习 --> ( 难度等级: [0.9, 0.9042) || 挂载数据: 无 ) 
│   │   │   ├── 使用Python实现降维 --> ( 难度等级: [0.9, 0.9003) || 挂载数据: 无 ) 
│   │   │   │   └── 相关性分析 --> ( 难度等级: [0.9, 0.9003) || 挂载数据: 无 ) 
│   │   │   ├── 使用Python进行分类 --> ( 难度等级: [0.9003, 0.9007) || 挂载数据: 无 ) 
│   │   │   ├── 决策树 --> ( 难度等级: [0.9007, 0.901) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 哪个属性优先 --> ( 难度等级: [0.9007, 0.9009) || 挂载数据: 无 ) 
│   │   │   │   └── 随机森林分类器 --> ( 难度等级: [0.9009, 0.901) || 挂载数据: 无 ) 
│   │   │   ├── 朴素贝叶斯分类器 --> ( 难度等级: [0.901, 0.9014) || 挂载数据: qa: 1 ) 
│   │   │   ├── 支持向量机 --> ( 难度等级: [0.9014, 0.9017) || 挂载数据: qa: 1 ) 
│   │   │   ├── 最近邻分类器 --> ( 难度等级: [0.9017, 0.9021) || 挂载数据: 无 ) 
│   │   │   ├── 情绪分析 --> ( 难度等级: [0.9021, 0.9024) || 挂载数据: 无 ) 
│   │   │   ├── 图像识别 --> ( 难度等级: [0.9024, 0.9028) || 挂载数据: 无 ) 
│   │   │   ├── 使用Python进行回归 --> ( 难度等级: [0.9028, 0.9031) || 挂载数据: 无 ) 
│   │   │   │   └── 最小二乘估计 --> ( 难度等级: [0.9028, 0.9031) || 挂载数据: qa: 1 ) 
│   │   │   ├── 分类和回归 --> ( 难度等级: [0.9031, 0.9035) || 挂载数据: 无 ) 
│   │   │   ├── 使模型高估或低估 --> ( 难度等级: [0.9035, 0.9038) || 挂载数据: 无 ) 
│   │   │   └── 处理分类型数据 --> ( 难度等级: [0.9038, 0.9042) || 挂载数据: 无 ) 
│   │   ├── 无监督学习—聚类 --> ( 难度等级: [0.9042, 0.9083) || 挂载数据: 无 ) 
│   │   │   ├── K均值聚类 --> ( 难度等级: [0.9042, 0.905) || 挂载数据: 无 ) 
│   │   │   ├── 选择K—肘部法则 --> ( 难度等级: [0.905, 0.9058) || 挂载数据: 无 ) 
│   │   │   ├── 距离或相似性度量 --> ( 难度等级: [0.9058, 0.9067) || 挂载数据: 无 ) 
│   │   │   │   ├── 属性 --> ( 难度等级: [0.9058, 0.906) || 挂载数据: 无 ) 
│   │   │   │   ├── 一般及欧氏距离 --> ( 难度等级: [0.906, 0.9062) || 挂载数据: 无 ) 
│   │   │   │   ├── 平方欧氏距离 --> ( 难度等级: [0.9062, 0.9065) || 挂载数据: qa: 1 ) 
│   │   │   │   └── 字符串之间的编辑距离 --> ( 难度等级: [0.9065, 0.9067) || 挂载数据: 无 ) 
│   │   │   ├── 文档上下文的相似性 --> ( 难度等级: [0.9067, 0.9075) || 挂载数据: 无 ) 
│   │   │   └── 如何判断聚类结果是否良好 --> ( 难度等级: [0.9075, 0.9083) || 挂载数据: 无 ) 
│   │   ├── 时间序列 --> ( 难度等级: [0.9083, 0.9125) || 挂载数据: 无 ) 
│   │   │   ├── 变化的分类 --> ( 难度等级: [0.9083, 0.9087) || 挂载数据: 无 ) 
│   │   │   ├── 包含趋势的序列分析 --> ( 难度等级: [0.9087, 0.9092) || 挂载数据: 无 ) 
│   │   │   │   ├── 曲线拟合 --> ( 难度等级: [0.9087, 0.909) || 挂载数据: 无 ) 
│   │   │   │   └── 从时间序列中去除趋势 --> ( 难度等级: [0.909, 0.9092) || 挂载数据: qa: 1 ) 
│   │   │   ├── 包含周期性的序列数据分析 --> ( 难度等级: [0.9092, 0.9096) || 挂载数据: 无 ) 
│   │   │   ├── 从时间序列中去除周期性 --> ( 难度等级: [0.9096, 0.91) || 挂载数据: 无 ) 
│   │   │   │   ├── 滤波 --> ( 难度等级: [0.9096, 0.9098) || 挂载数据: 无 ) 
│   │   │   │   └── 差分 --> ( 难度等级: [0.9098, 0.91) || 挂载数据: 无 ) 
│   │   │   ├── 平稳时间序列 --> ( 难度等级: [0.91, 0.9104) || 挂载数据: 无 ) 
│   │   │   │   ├── 平稳过程 --> ( 难度等级: [0.91, 0.9101) || 挂载数据: 无 ) 
│   │   │   │   ├── 自相关和相关图 --> ( 难度等级: [0.9101, 0.9103) || 挂载数据: qa: 7; blog: 1 ) 
│   │   │   │   └── 自协方差和自相关函数的估计 --> ( 难度等级: [0.9103, 0.9104) || 挂载数据: 无 ) 
│   │   │   ├── 使用Python进行时间序列分析 --> ( 难度等级: [0.9104, 0.9108) || 挂载数据: 无 ) 
│   │   │   │   ├── 有用的方法 --> ( 难度等级: [0.9104, 0.9106) || 挂载数据: 无 ) 
│   │   │   │   ├── 自回归过程 --> ( 难度等级: [0.9106, 0.9107) || 挂载数据: 无 ) 
│   │   │   │   └── 估计AR过程的参数 --> ( 难度等级: [0.9107, 0.9108) || 挂载数据: 无 ) 
│   │   │   ├── 混合ARMA模型 --> ( 难度等级: [0.9108, 0.9113) || 挂载数据: 无 ) 
│   │   │   ├── 集成ARMA模型 --> ( 难度等级: [0.9113, 0.9117) || 挂载数据: 无 ) 
│   │   │   ├── 一个特殊的场景 --> ( 难度等级: [0.9117, 0.9121) || 挂载数据: 无 ) 
│   │   │   └── 数据缺失 --> ( 难度等级: [0.9121, 0.9125) || 挂载数据: 无 ) 
│   │   └── 大数据分析 --> ( 难度等级: [0.9125, 0.9167) || 挂载数据: qa: 1 ) 
│   │       ├── Hadoop --> ( 难度等级: [0.9125, 0.9135) || 挂载数据: 无 ) 
│   │       │   ├── MapReduce编程 --> ( 难度等级: [0.9125, 0.9127) || 挂载数据: qa: 1; blog: 1 ) 
│   │       │   ├── partitioning函数 --> ( 难度等级: [0.9127, 0.9129) || 挂载数据: 无 ) 
│   │       │   ├── combiner函数 --> ( 难度等级: [0.9129, 0.9131) || 挂载数据: 无 ) 
│   │       │   ├── HDFS文件系统 --> ( 难度等级: [0.9131, 0.9133) || 挂载数据: 无 ) 
│   │       │   └── MapReduce设计模式 --> ( 难度等级: [0.9133, 0.9135) || 挂载数据: 无 ) 
│   │       ├── Spark --> ( 难度等级: [0.9135, 0.9146) || 挂载数据: 无 ) 
│   │       ├── 云分析 --> ( 难度等级: [0.9146, 0.9156) || 挂载数据: 无 ) 
│   │       └── 物联网 --> ( 难度等级: [0.9156, 0.9167) || 挂载数据: 无 ) 
│   ├── 高级教程 --> ( 难度等级: [0.9167, 0.9583) || 挂载数据: 无 ) 
│   │   ├── 原理与哲学 --> ( 难度等级: [0.9167, 0.9208) || 挂载数据: qa: 1 ) 
│   │   │   ├── Python之禅 --> ( 难度等级: [0.9167, 0.9173) || 挂载数据: 无 ) 
│   │   │   │   ├── 优美胜于丑陋 --> ( 难度等级: [0.9167, 0.9167) || 挂载数据: 无 ) 
│   │   │   │   ├── 明了胜于晦涩 --> ( 难度等级: [0.9167, 0.9167) || 挂载数据: 无 ) 
│   │   │   │   ├── 简洁胜于复杂 --> ( 难度等级: [0.9167, 0.9168) || 挂载数据: 无 ) 
│   │   │   │   ├── 复杂胜于难以理解 --> ( 难度等级: [0.9168, 0.9168) || 挂载数据: 无 ) 
│   │   │   │   ├── 扁平胜于嵌套 --> ( 难度等级: [0.9168, 0.9168) || 挂载数据: 无 ) 
│   │   │   │   ├── 宽松胜于紧凑 --> ( 难度等级: [0.9168, 0.9169) || 挂载数据: 无 ) 
│   │   │   │   ├── 可读性很重要 --> ( 难度等级: [0.9169, 0.9169) || 挂载数据: 无 ) 
│   │   │   │   ├── 即便是特例，也不可违背这些规则 --> ( 难度等级: [0.9169, 0.9169) || 挂载数据: 无 ) 
│   │   │   │   ├── 实用性胜于纯粹性 --> ( 难度等级: [0.9169, 0.9169) || 挂载数据: 无 ) 
│   │   │   │   ├── 错误永远不应该悄无声息地过去 --> ( 难度等级: [0.9169, 0.917) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 除非明确地沉默 --> ( 难度等级: [0.917, 0.917) || 挂载数据: 无 ) 
│   │   │   │   ├── 面对模棱两可的情况，拒绝猜测的诱惑 --> ( 难度等级: [0.917, 0.917) || 挂载数据: 无 ) 
│   │   │   │   ├── 应该有一种(最好只有一种)显而易见的方法 --> ( 难度等级: [0.917, 0.9171) || 挂载数据: 无 ) 
│   │   │   │   ├── 尽管这种方式起初可能并不明显，除非你是荷兰人 --> ( 难度等级: [0.9171, 0.9171) || 挂载数据: 无 ) 
│   │   │   │   ├── 做比不做要好 --> ( 难度等级: [0.9171, 0.9171) || 挂载数据: qa: 23 ) 
│   │   │   │   ├── 不假思索就动手还不如不做 --> ( 难度等级: [0.9171, 0.9172) || 挂载数据: 无 ) 
│   │   │   │   ├── 如果实现难以解释，那就是一个糟糕的想法 --> ( 难度等级: [0.9172, 0.9172) || 挂载数据: 无 ) 
│   │   │   │   ├── 如果实现容易解释，则可能是一个好主意 --> ( 难度等级: [0.9172, 0.9172) || 挂载数据: 无 ) 
│   │   │   │   └── 命名空间是一个很棒的想法，让我们做更多这样的事情吧 --> ( 难度等级: [0.9172, 0.9173) || 挂载数据: 无 ) 
│   │   │   ├── 不要重复自己 --> ( 难度等级: [0.9173, 0.9179) || 挂载数据: 无 ) 
│   │   │   ├── 松耦合 --> ( 难度等级: [0.9179, 0.9185) || 挂载数据: 无 ) 
│   │   │   ├── 武士原则 --> ( 难度等级: [0.9185, 0.919) || 挂载数据: 无 ) 
│   │   │   ├── 帕累托原则 --> ( 难度等级: [0.919, 0.9196) || 挂载数据: 无 ) 
│   │   │   ├── 稳健性原则 --> ( 难度等级: [0.9196, 0.9202) || 挂载数据: 无 ) 
│   │   │   └── 向后兼容性 --> ( 难度等级: [0.9202, 0.9208) || 挂载数据: 无 ) 
│   │   ├── 基础知识 --> ( 难度等级: [0.9208, 0.925) || 挂载数据: 无 ) 
│   │   │   ├── 总体概念 --> ( 难度等级: [0.9208, 0.9215) || 挂载数据: 无 ) 
│   │   │   │   ├── 迭代 --> ( 难度等级: [0.9208, 0.9211) || 挂载数据: 无 ) 
│   │   │   │   ├── 缓存 --> ( 难度等级: [0.9211, 0.9213) || 挂载数据: qa: 1 ) 
│   │   │   │   └── 透明度 --> ( 难度等级: [0.9213, 0.9215) || 挂载数据: blog: 1 ) 
│   │   │   ├── 流程控制 --> ( 难度等级: [0.9215, 0.9222) || 挂载数据: 无 ) 
│   │   │   │   ├── 捕获异常 --> ( 难度等级: [0.9215, 0.9216) || 挂载数据: 无 ) 
│   │   │   │   ├── 异常链 --> ( 难度等级: [0.9216, 0.9217) || 挂载数据: 无 ) 
│   │   │   │   ├── 当一切顺利的时候 --> ( 难度等级: [0.9217, 0.9218) || 挂载数据: 无 ) 
│   │   │   │   ├── 继续执行，无论异常如何 --> ( 难度等级: [0.9218, 0.9219) || 挂载数据: 无 ) 
│   │   │   │   ├── 优化循环 --> ( 难度等级: [0.9219, 0.922) || 挂载数据: 无 ) 
│   │   │   │   ├── with语句 --> ( 难度等级: [0.922, 0.9221) || 挂载数据: qa: 2 ) 
│   │   │   │   └── 条件表达式 --> ( 难度等级: [0.9221, 0.9222) || 挂载数据: 无 ) 
│   │   │   ├── 迭代 --> ( 难度等级: [0.9222, 0.9229) || 挂载数据: 无 ) 
│   │   │   │   ├── 序列解包 --> ( 难度等级: [0.9222, 0.9223) || 挂载数据: 无 ) 
│   │   │   │   ├── 列表解析式 --> ( 难度等级: [0.9223, 0.9224) || 挂载数据: 无 ) 
│   │   │   │   ├── 生成器表达式 --> ( 难度等级: [0.9224, 0.9225) || 挂载数据: 无 ) 
│   │   │   │   ├── 集合解析式 --> ( 难度等级: [0.9225, 0.9226) || 挂载数据: 无 ) 
│   │   │   │   ├── 字典解析式 --> ( 难度等级: [0.9226, 0.9227) || 挂载数据: 无 ) 
│   │   │   │   ├── 将迭代器链接在一起 --> ( 难度等级: [0.9227, 0.9228) || 挂载数据: 无 ) 
│   │   │   │   └── 将迭代器压缩在一起 --> ( 难度等级: [0.9228, 0.9229) || 挂载数据: 无 ) 
│   │   │   ├── 容器数据类型 --> ( 难度等级: [0.9229, 0.9236) || 挂载数据: 无 ) 
│   │   │   │   ├── 集合 --> ( 难度等级: [0.9229, 0.9231) || 挂载数据: 无 ) 
│   │   │   │   ├── 命名元组 --> ( 难度等级: [0.9231, 0.9233) || 挂载数据: 无 ) 
│   │   │   │   ├── 有序字典 --> ( 难度等级: [0.9233, 0.9234) || 挂载数据: 无 ) 
│   │   │   │   └── 带有默认值的字典 --> ( 难度等级: [0.9234, 0.9236) || 挂载数据: qa: 1 ) 
│   │   │   ├── 导入代码 --> ( 难度等级: [0.9236, 0.9243) || 挂载数据: 无 ) 
│   │   │   │   ├── 回退(备用)导入 --> ( 难度等级: [0.9236, 0.9237) || 挂载数据: 无 ) 
│   │   │   │   ├── 从即将发布的版本中导入 --> ( 难度等级: [0.9237, 0.9238) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用__all__进行自定义导入 --> ( 难度等级: [0.9238, 0.924) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 相对导入 --> ( 难度等级: [0.924, 0.9241) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── __import__函数 --> ( 难度等级: [0.9241, 0.9242) || 挂载数据: blog: 2 ) 
│   │   │   │   └── importlib模块 --> ( 难度等级: [0.9242, 0.9243) || 挂载数据: 无 ) 
│   │   │   └── 令人兴奋的Python扩展：NIST的随机数信标 --> ( 难度等级: [0.9243, 0.925) || 挂载数据: 无 ) 
│   │   │       ├── 如何安装NIST信标库 --> ( 难度等级: [0.9243, 0.9243) || 挂载数据: 无 ) 
│   │   │       ├── 示例：获取值 --> ( 难度等级: [0.9243, 0.9244) || 挂载数据: 无 ) 
│   │   │       ├── 示例：模拟抛硬币并记录每次正反面的结果 --> ( 难度等级: [0.9244, 0.9244) || 挂载数据: 无 ) 
│   │   │       ├── 安装Pandas和matplotlib --> ( 难度等级: [0.9244, 0.9244) || 挂载数据: 无 ) 
│   │   │       ├── 创建文本文件 --> ( 难度等级: [0.9244, 0.9244) || 挂载数据: 无 ) 
│   │   │       ├── 使用Pandas显示数据 --> ( 难度等级: [0.9244, 0.9245) || 挂载数据: 无 ) 
│   │   │       ├── 进行一些数据分析 --> ( 难度等级: [0.9245, 0.9245) || 挂载数据: blog: 1 ) 
│   │   │       ├── 使用matplotlib进行绘图 --> ( 难度等级: [0.9245, 0.9245) || 挂载数据: blog: 1 ) 
│   │   │       ├── 图表的类型 --> ( 难度等级: [0.9245, 0.9245) || 挂载数据: 无 ) 
│   │   │       ├── 安装Scrapy --> ( 难度等级: [0.9245, 0.9246) || 挂载数据: 无 ) 
│   │   │       ├── 运行Scrapy --> ( 难度等级: [0.9246, 0.9246) || 挂载数据: 无 ) 
│   │   │       ├── 使用Scrapy获取Web数据 --> ( 难度等级: [0.9246, 0.9246) || 挂载数据: 无 ) 
│   │   │       ├── 通过Scrapy浏览网页 --> ( 难度等级: [0.9246, 0.9246) || 挂载数据: 无 ) 
│   │   │       ├── shell选项 --> ( 难度等级: [0.9246, 0.9247) || 挂载数据: 无 ) 
│   │   │       ├── 安装Beautiful Soup --> ( 难度等级: [0.9247, 0.9247) || 挂载数据: 无 ) 
│   │   │       ├── 使用Beautiful Soup --> ( 难度等级: [0.9247, 0.9247) || 挂载数据: 无 ) 
│   │   │       ├── 如何安装feedparser库 --> ( 难度等级: [0.9247, 0.9247) || 挂载数据: 无 ) 
│   │   │       ├── 如何使用feedparser库 --> ( 难度等级: [0.9247, 0.9248) || 挂载数据: 无 ) 
│   │   │       ├── 安装NumPy --> ( 难度等级: [0.9248, 0.9248) || 挂载数据: blog: 1 ) 
│   │   │       ├── 使用NumPy --> ( 难度等级: [0.9248, 0.9248) || 挂载数据: 无 ) 
│   │   │       ├── 使用NumPy数组 --> ( 难度等级: [0.9248, 0.9248) || 挂载数据: blog: 1 ) 
│   │   │       ├── 统计度量 --> ( 难度等级: [0.9248, 0.9249) || 挂载数据: 无 ) 
│   │   │       ├── 如何安装Pillow库 --> ( 难度等级: [0.9249, 0.9249) || 挂载数据: 无 ) 
│   │   │       ├── 图像显示：确定文件的大小和类型并显示 --> ( 难度等级: [0.9249, 0.9249) || 挂载数据: 无 ) 
│   │   │       ├── 图像处理：裁剪图像的一部分 --> ( 难度等级: [0.9249, 0.9249) || 挂载数据: 无 ) 
│   │   │       ├── 随机数 --> ( 难度等级: [0.9249, 0.925) || 挂载数据: qa: 2 ) 
│   │   │       └── 密码生成器 --> ( 难度等级: [0.925, 0.925) || 挂载数据: 无 ) 
│   │   ├── 函数 --> ( 难度等级: [0.925, 0.9292) || 挂载数据: 无 ) 
│   │   │   ├── 参数 --> ( 难度等级: [0.925, 0.9257) || 挂载数据: 无 ) 
│   │   │   │   ├── 规划时的灵活性 --> ( 难度等级: [0.925, 0.9251) || 挂载数据: 无 ) 
│   │   │   │   ├── 可变位置参数 --> ( 难度等级: [0.9251, 0.9252) || 挂载数据: qa: 3 ) 
│   │   │   │   ├── 可变关键字参数 --> ( 难度等级: [0.9252, 0.9253) || 挂载数据: 无 ) 
│   │   │   │   ├── 组合不同类型的参数 --> ( 难度等级: [0.9253, 0.9254) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── 调用具有可变参数的函数 --> ( 难度等级: [0.9254, 0.9255) || 挂载数据: qa: 2 ) 
│   │   │   │   ├── 传递参数 --> ( 难度等级: [0.9255, 0.9256) || 挂载数据: qa: 13 ) 
│   │   │   │   └── 自省 --> ( 难度等级: [0.9256, 0.9257) || 挂载数据: 无 ) 
│   │   │   ├── 装饰器 --> ( 难度等级: [0.9257, 0.9264) || 挂载数据: 无 ) 
│   │   │   │   ├── 闭包 --> ( 难度等级: [0.9257, 0.9259) || 挂载数据: 无 ) 
│   │   │   │   ├── 包装器 --> ( 难度等级: [0.9259, 0.926) || 挂载数据: qa: 1; blog: 1 ) 
│   │   │   │   ├── 带参数的装饰器 --> ( 难度等级: [0.926, 0.9262) || 挂载数据: qa: 1 ) 
│   │   │   │   └── 带参数或不带参数的装饰器 --> ( 难度等级: [0.9262, 0.9264) || 挂载数据: 无 ) 
│   │   │   ├── 函数注解 --> ( 难度等级: [0.9264, 0.9271) || 挂载数据: 无 ) 
│   │   │   │   ├── 提取样板 --> ( 难度等级: [0.9264, 0.9267) || 挂载数据: 无 ) 
│   │   │   │   └── 用装饰器进行注解 --> ( 难度等级: [0.9267, 0.9271) || 挂载数据: 无 ) 
│   │   │   ├── 生成器 --> ( 难度等级: [0.9271, 0.9278) || 挂载数据: 无 ) 
│   │   │   ├── lambda --> ( 难度等级: [0.9278, 0.9285) || 挂载数据: qa: 1 ) 
│   │   │   └── 自省 --> ( 难度等级: [0.9285, 0.9292) || 挂载数据: 无 ) 
│   │   │       ├── 标识对象类型 --> ( 难度等级: [0.9285, 0.9287) || 挂载数据: 无 ) 
│   │   │       ├── 模块和软件包 --> ( 难度等级: [0.9287, 0.9289) || 挂载数据: 无 ) 
│   │   │       └── 文档字符串 --> ( 难度等级: [0.9289, 0.9292) || 挂载数据: 无 ) 
│   │   │           ├── 描述函数的作用 --> ( 难度等级: [0.9289, 0.929) || 挂载数据: 无 ) 
│   │   │           ├── 返回值 --> ( 难度等级: [0.929, 0.9291) || 挂载数据: 无 ) 
│   │   │           └── 包含预期的异常 --> ( 难度等级: [0.9291, 0.9292) || 挂载数据: qa: 1 ) 
│   │   ├── 类 --> ( 难度等级: [0.9292, 0.9333) || 挂载数据: 无 ) 
│   │   │   ├── 继承 --> ( 难度等级: [0.9292, 0.93) || 挂载数据: 无 ) 
│   │   │   │   ├── 多重继承 --> ( 难度等级: [0.9292, 0.9294) || 挂载数据: qa: 3; blog: 1 ) 
│   │   │   │   ├── 方法解析顺序 --> ( 难度等级: [0.9294, 0.9296) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用super函数将控制权传递给其他类 --> ( 难度等级: [0.9296, 0.9298) || 挂载数据: qa: 1 ) 
│   │   │   │   └── 自省 --> ( 难度等级: [0.9298, 0.93) || 挂载数据: 无 ) 
│   │   │   ├── 如何创建类 --> ( 难度等级: [0.93, 0.9308) || 挂载数据: 无 ) 
│   │   │   │   ├── 在运行时创建类 --> ( 难度等级: [0.93, 0.9303) || 挂载数据: qa: 7 ) 
│   │   │   │   ├── 元类 --> ( 难度等级: [0.9303, 0.9306) || 挂载数据: qa: 21; blog: 3 ) 
│   │   │   │   └── 控制命名空间 --> ( 难度等级: [0.9306, 0.9308) || 挂载数据: 无 ) 
│   │   │   ├── 成员变量 --> ( 难度等级: [0.9308, 0.9317) || 挂载数据: 无 ) 
│   │   │   │   ├── 属性 --> ( 难度等级: [0.9308, 0.9312) || 挂载数据: 无 ) 
│   │   │   │   └── 描述器 --> ( 难度等级: [0.9312, 0.9317) || 挂载数据: qa: 1 ) 
│   │   │   ├── 方法 --> ( 难度等级: [0.9317, 0.9325) || 挂载数据: 无 ) 
│   │   │   │   ├── 非绑定方法 --> ( 难度等级: [0.9317, 0.9321) || 挂载数据: 无 ) 
│   │   │   │   └── 绑定方法 --> ( 难度等级: [0.9321, 0.9325) || 挂载数据: qa: 20 ) 
│   │   │   └── 魔术方法 --> ( 难度等级: [0.9325, 0.9333) || 挂载数据: qa: 1 ) 
│   │   │       ├── 处理成员变量 --> ( 难度等级: [0.9325, 0.9329) || 挂载数据: 无 ) 
│   │   │       └── 字符串表示 --> ( 难度等级: [0.9329, 0.9333) || 挂载数据: 无 ) 
│   │   │           ├── 字节字符串 --> ( 难度等级: [0.9329, 0.933) || 挂载数据: qa: 1 ) 
│   │   │           │   ├── 借助chr和ord进行简单的转换 --> ( 难度等级: [0.9329, 0.933) || 挂载数据: 无 ) 
│   │   │           │   └── 借助struct模块进行复杂的转换 --> ( 难度等级: [0.933, 0.933) || 挂载数据: 无 ) 
│   │   │           ├── 文本 --> ( 难度等级: [0.933, 0.9331) || 挂载数据: 无 ) 
│   │   │           │   ├── Unicode --> ( 难度等级: [0.933, 0.9331) || 挂载数据: qa: 4 ) 
│   │   │           │   └── 编码 --> ( 难度等级: [0.9331, 0.9331) || 挂载数据: qa: 1 ) 
│   │   │           ├── 简单的替换 --> ( 难度等级: [0.9331, 0.9332) || 挂载数据: qa: 3 ) 
│   │   │           └── 格式化 --> ( 难度等级: [0.9332, 0.9333) || 挂载数据: 无 ) 
│   │   │               ├── 在对象中查找值 --> ( 难度等级: [0.9332, 0.9332) || 挂载数据: 无 ) 
│   │   │               ├── 区分字符串类型 --> ( 难度等级: [0.9332, 0.9333) || 挂载数据: 无 ) 
│   │   │               ├── 标准格式规范 --> ( 难度等级: [0.9333, 0.9333) || 挂载数据: 无 ) 
│   │   │               ├── 为文本文档制作目录 --> ( 难度等级: [0.9333, 0.9333) || 挂载数据: qa: 2; blog: 1 ) 
│   │   │               └── 自定义格式规范 --> ( 难度等级: [0.9333, 0.9333) || 挂载数据: 无 ) 
│   │   ├── 通用协议 --> ( 难度等级: [0.9333, 0.9375) || 挂载数据: 无 ) 
│   │   │   ├── 基本运算 --> ( 难度等级: [0.9333, 0.9339) || 挂载数据: 无 ) 
│   │   │   │   ├── 数学运算 --> ( 难度等级: [0.9333, 0.9335) || 挂载数据: 无 ) 
│   │   │   │   ├── 按位运算 --> ( 难度等级: [0.9335, 0.9337) || 挂载数据: qa: 4 ) 
│   │   │   │   └── 运算符的变体 --> ( 难度等级: [0.9337, 0.9339) || 挂载数据: 无 ) 
│   │   │   ├── 数字 --> ( 难度等级: [0.9339, 0.9345) || 挂载数据: 无 ) 
│   │   │   │   ├── 符号运算 --> ( 难度等级: [0.9339, 0.9342) || 挂载数据: qa: 2 ) 
│   │   │   │   └── 比较运算 --> ( 难度等级: [0.9342, 0.9345) || 挂载数据: 无 ) 
│   │   │   ├── 可迭代对象 --> ( 难度等级: [0.9345, 0.9351) || 挂载数据: 无 ) 
│   │   │   ├── 序列 --> ( 难度等级: [0.9351, 0.9357) || 挂载数据: 无 ) 
│   │   │   ├── 映射 --> ( 难度等级: [0.9357, 0.9363) || 挂载数据: 无 ) 
│   │   │   ├── _call_方法 --> ( 难度等级: [0.9363, 0.9369) || 挂载数据: 无 ) 
│   │   │   └── 上下文管理器 --> ( 难度等级: [0.9369, 0.9375) || 挂载数据: 无 ) 
│   │   ├── 对象管理 --> ( 难度等级: [0.9375, 0.9417) || 挂载数据: 无 ) 
│   │   │   ├── 命名空间字典 --> ( 难度等级: [0.9375, 0.9385) || 挂载数据: 无 ) 
│   │   │   ├── 垃圾回收 --> ( 难度等级: [0.9385, 0.9396) || 挂载数据: 无 ) 
│   │   │   │   ├── 引用计数 --> ( 难度等级: [0.9385, 0.9389) || 挂载数据: 无 ) 
│   │   │   │   ├── 循环引用 --> ( 难度等级: [0.9389, 0.9392) || 挂载数据: qa: 1 ) 
│   │   │   │   └── 弱引用 --> ( 难度等级: [0.9392, 0.9396) || 挂载数据: 无 ) 
│   │   │   ├── Python对象的序列化 --> ( 难度等级: [0.9396, 0.9406) || 挂载数据: 无 ) 
│   │   │   └── 复制 --> ( 难度等级: [0.9406, 0.9417) || 挂载数据: 无 ) 
│   │   │       ├── 浅层复制 --> ( 难度等级: [0.9406, 0.9411) || 挂载数据: qa: 1; blog: 1 ) 
│   │   │       └── 深层复制 --> ( 难度等级: [0.9411, 0.9417) || 挂载数据: qa: 1 ) 
│   │   ├── 文档的编写 --> ( 难度等级: [0.9417, 0.9458) || 挂载数据: 无 ) 
│   │   │   ├── 恰当地命名 --> ( 难度等级: [0.9417, 0.9427) || 挂载数据: 无 ) 
│   │   │   ├── 注释 --> ( 难度等级: [0.9427, 0.9437) || 挂载数据: 无 ) 
│   │   │   ├── 代码之外的文档 --> ( 难度等级: [0.9437, 0.9448) || 挂载数据: 无 ) 
│   │   │   │   ├── 安装与配置 --> ( 难度等级: [0.9437, 0.9441) || 挂载数据: 无 ) 
│   │   │   │   ├── 教程 --> ( 难度等级: [0.9441, 0.9444) || 挂载数据: qa: 2; blog: 1 ) 
│   │   │   │   └── 参考文档 --> ( 难度等级: [0.9444, 0.9448) || 挂载数据: qa: 4; blog: 1 ) 
│   │   │   └── 用于编写文档的实用工具 --> ( 难度等级: [0.9448, 0.9458) || 挂载数据: 无 ) 
│   │   │       ├── 链接 --> ( 难度等级: [0.9448, 0.9453) || 挂载数据: 无 ) 
│   │   │       └── Sphinx --> ( 难度等级: [0.9453, 0.9458) || 挂载数据: 无 ) 
│   │   ├── 测试 --> ( 难度等级: [0.9458, 0.95) || 挂载数据: 无 ) 
│   │   │   ├── 测试驱动开发 --> ( 难度等级: [0.9458, 0.9469) || 挂载数据: qa: 1 ) 
│   │   │   ├── doctest --> ( 难度等级: [0.9469, 0.9479) || 挂载数据: 无 ) 
│   │   │   │   ├── 格式化代码 --> ( 难度等级: [0.9469, 0.9471) || 挂载数据: 无 ) 
│   │   │   │   ├── 呈现输出 --> ( 难度等级: [0.9471, 0.9474) || 挂载数据: 无 ) 
│   │   │   │   ├── 与文档集成 --> ( 难度等级: [0.9474, 0.9477) || 挂载数据: 无 ) 
│   │   │   │   └── 运行测试 --> ( 难度等级: [0.9477, 0.9479) || 挂载数据: 无 ) 
│   │   │   ├── unittest模块 --> ( 难度等级: [0.9479, 0.949) || 挂载数据: blog: 7 ) 
│   │   │   │   ├── 初始化配置 --> ( 难度等级: [0.9479, 0.9481) || 挂载数据: 无 ) 
│   │   │   │   ├── 编写测试 --> ( 难度等级: [0.9481, 0.9483) || 挂载数据: qa: 15; blog: 1 ) 
│   │   │   │   ├── 其他比较 --> ( 难度等级: [0.9483, 0.9484) || 挂载数据: 无 ) 
│   │   │   │   ├── 测试异常 --> ( 难度等级: [0.9484, 0.9486) || 挂载数据: 无 ) 
│   │   │   │   ├── 测试对象标识 --> ( 难度等级: [0.9486, 0.9488) || 挂载数据: 无 ) 
│   │   │   │   └── 释放资源 --> ( 难度等级: [0.9488, 0.949) || 挂载数据: 无 ) 
│   │   │   └── 提供自定义的测试类 --> ( 难度等级: [0.949, 0.95) || 挂载数据: 无 ) 
│   │   ├── 发布 --> ( 难度等级: [0.95, 0.9542) || 挂载数据: 无 ) 
│   │   │   ├── 许可证 --> ( 难度等级: [0.95, 0.9514) || 挂载数据: 无 ) 
│   │   │   │   ├── GNU通用公共许可证 --> ( 难度等级: [0.95, 0.9503) || 挂载数据: 无 ) 
│   │   │   │   ├── Affero通用公共许可证 --> ( 难度等级: [0.9503, 0.9506) || 挂载数据: qa: 1 ) 
│   │   │   │   ├── GNU宽通用公共许可证 --> ( 难度等级: [0.9506, 0.9508) || 挂载数据: 无 ) 
│   │   │   │   ├── 伯克利软件发行许可证 --> ( 难度等级: [0.9508, 0.9511) || 挂载数据: 无 ) 
│   │   │   │   └── 其他许可证 --> ( 难度等级: [0.9511, 0.9514) || 挂载数据: 无 ) 
│   │   │   ├── 打包 --> ( 难度等级: [0.9514, 0.9528) || 挂载数据: 无 ) 
│   │   │   │   ├── setup.py --> ( 难度等级: [0.9514, 0.9519) || 挂载数据: qa: 16; blog: 2 ) 
│   │   │   │   ├── MANIFEST.in --> ( 难度等级: [0.9519, 0.9523) || 挂载数据: qa: 5; blog: 2 ) 
│   │   │   │   └── sdist命令 --> ( 难度等级: [0.9523, 0.9528) || 挂载数据: 无 ) 
│   │   │   └── 发布 --> ( 难度等级: [0.9528, 0.9542) || 挂载数据: blog: 1 ) 
│   │   └── 构建CSV框架sheets --> ( 难度等级: [0.9542, 0.9583) || 挂载数据: 无 ) 
│   │       ├── 构建声明性框架 --> ( 难度等级: [0.9542, 0.955) || 挂载数据: 无 ) 
│   │       │   ├── 声明性编程简介 --> ( 难度等级: [0.9542, 0.9546) || 挂载数据: 无 ) 
│   │       │   └── 是否构建声明性框架 --> ( 难度等级: [0.9546, 0.955) || 挂载数据: blog: 1 ) 
│   │       ├── 构建框架 --> ( 难度等级: [0.955, 0.9558) || 挂载数据: 无 ) 
│   │       │   ├── 管理选项 --> ( 难度等级: [0.955, 0.9552) || 挂载数据: 无 ) 
│   │       │   ├── 定义字段 --> ( 难度等级: [0.9552, 0.9553) || 挂载数据: 无 ) 
│   │       │   ├── 将字段附加到类 --> ( 难度等级: [0.9553, 0.9555) || 挂载数据: 无 ) 
│   │       │   ├── 添加元类 --> ( 难度等级: [0.9555, 0.9557) || 挂载数据: 无 ) 
│   │       │   └── 整合 --> ( 难度等级: [0.9557, 0.9558) || 挂载数据: 无 ) 
│   │       ├── 字段排序 --> ( 难度等级: [0.9558, 0.9567) || 挂载数据: 无 ) 
│   │       │   ├── DeclarativeMeta.__prepare__ --> ( 难度等级: [0.9558, 0.956) || 挂载数据: 无 ) 
│   │       │   ├── Column.__init__ --> ( 难度等级: [0.956, 0.9562) || 挂载数据: qa: 3 ) 
│   │       │   ├── Column.__new__ --> ( 难度等级: [0.9562, 0.9563) || 挂载数据: 无 ) 
│   │       │   ├── CounterMeta.__call__ --> ( 难度等级: [0.9563, 0.9565) || 挂载数据: 无 ) 
│   │       │   └── 挑选选项 --> ( 难度等级: [0.9565, 0.9567) || 挂载数据: 无 ) 
│   │       ├── 构建字段库 --> ( 难度等级: [0.9567, 0.9575) || 挂载数据: 无 ) 
│   │       │   ├── StringField(字符串字段) --> ( 难度等级: [0.9567, 0.9568) || 挂载数据: qa: 4 ) 
│   │       │   ├── IntegerColumn(整数列) --> ( 难度等级: [0.9568, 0.957) || 挂载数据: 无 ) 
│   │       │   ├── FloatColumn(浮点数列) --> ( 难度等级: [0.957, 0.9572) || 挂载数据: 无 ) 
│   │       │   ├── DecimalColumn(小数列) --> ( 难度等级: [0.9572, 0.9573) || 挂载数据: 无 ) 
│   │       │   └── DateColumn(日期列) --> ( 难度等级: [0.9573, 0.9575) || 挂载数据: 无 ) 
│   │       └── 回到CSV --> ( 难度等级: [0.9575, 0.9583) || 挂载数据: 无 ) 
│   │           ├── 检查参数 --> ( 难度等级: [0.9575, 0.9577) || 挂载数据: 无 ) 
│   │           ├── 填充值 --> ( 难度等级: [0.9577, 0.9579) || 挂载数据: 无 ) 
│   │           ├── 读取器 --> ( 难度等级: [0.9579, 0.9581) || 挂载数据: 无 ) 
│   │           └── 写入器 --> ( 难度等级: [0.9581, 0.9583) || 挂载数据: 无 ) 
│   └── 其他 --> ( 难度等级: [0.9583, 1.0) || 挂载数据: 无 ) 
│       ├── GUI界面编程 --> ( 难度等级: [0.9583, 0.9643) || 挂载数据: 无 ) 
│       │   ├── 初识GUI --> ( 难度等级: [0.9583, 0.9595) || 挂载数据: 无 ) 
│       │   │   ├── 什么是GUI --> ( 难度等级: [0.9583, 0.9587) || 挂载数据: qa: 8; blog: 69 ) 
│       │   │   ├── 常用的GUI框架 --> ( 难度等级: [0.9587, 0.9591) || 挂载数据: blog: 5 ) 
│       │   │   └── 安装wxPython --> ( 难度等级: [0.9591, 0.9595) || 挂载数据: blog: 1 ) 
│       │   ├── 创建应用程序 --> ( 难度等级: [0.9595, 0.9607) || 挂载数据: 无 ) 
│       │   │   ├── 创建一个wx.App的子类 --> ( 难度等级: [0.9595, 0.9599) || 挂载数据: 无 ) 
│       │   │   ├── 直接使用wx.App --> ( 难度等级: [0.9599, 0.9603) || 挂载数据: blog: 1 ) 
│       │   │   └── 使用wx.Frame框架 --> ( 难度等级: [0.9603, 0.9607) || 挂载数据: 无 ) 
│       │   ├── 常用控件 --> ( 难度等级: [0.9607, 0.9619) || 挂载数据: qa: 1 ) 
│       │   │   ├── StaticText文本类 --> ( 难度等级: [0.9607, 0.9611) || 挂载数据: 无 ) 
│       │   │   ├── TextCtrl输入文本类 --> ( 难度等级: [0.9611, 0.9615) || 挂载数据: 无 ) 
│       │   │   └── Button按钮类 --> ( 难度等级: [0.9615, 0.9619) || 挂载数据: blog: 1 ) 
│       │   ├── BoxSizer布局 --> ( 难度等级: [0.9619, 0.9631) || 挂载数据: 无 ) 
│       │   │   ├── 什么是BoxSizer --> ( 难度等级: [0.9619, 0.9625) || 挂载数据: 无 ) 
│       │   │   └── 使用BoxSizer布局 --> ( 难度等级: [0.9625, 0.9631) || 挂载数据: qa: 1; blog: 1 ) 
│       │   └── 事件处理 --> ( 难度等级: [0.9631, 0.9643) || 挂载数据: 无 ) 
│       │       ├── 什么是事件 --> ( 难度等级: [0.9631, 0.9637) || 挂载数据: blog: 1 ) 
│       │       └── 绑定事件 --> ( 难度等级: [0.9637, 0.9643) || 挂载数据: qa: 1 ) 
│       ├── Pygame游戏编程 --> ( 难度等级: [0.9643, 0.9702) || 挂载数据: 无 ) 
│       │   ├── 初识Pygame --> ( 难度等级: [0.9643, 0.9663) || 挂载数据: 无 ) 
│       │   │   ├── 安装Pygame --> ( 难度等级: [0.9643, 0.9653) || 挂载数据: blog: 26 ) 
│       │   │   └── Pygame常用模块 --> ( 难度等级: [0.9653, 0.9663) || 挂载数据: blog: 236 ) 
│       │   ├── Pygame基本使用 --> ( 难度等级: [0.9663, 0.9683) || 挂载数据: 无 ) 
│       │   └── 开发Flappy Bird游戏 --> ( 难度等级: [0.9683, 0.9702) || 挂载数据: blog: 1 ) 
│       │       ├── 游戏简介 --> ( 难度等级: [0.9683, 0.9685) || 挂载数据: 无 ) 
│       │       ├── 游戏分析 --> ( 难度等级: [0.9685, 0.9688) || 挂载数据: qa: 7; blog: 6 ) 
│       │       ├── 搭建主框架 --> ( 难度等级: [0.9688, 0.9691) || 挂载数据: qa: 1 ) 
│       │       ├── 创建小鸟类 --> ( 难度等级: [0.9691, 0.9694) || 挂载数据: 无 ) 
│       │       ├── 创建管道类 --> ( 难度等级: [0.9694, 0.9697) || 挂载数据: 无 ) 
│       │       ├── 计算得分 --> ( 难度等级: [0.9697, 0.97) || 挂载数据: qa: 1 ) 
│       │       └── 碰撞检测 --> ( 难度等级: [0.97, 0.9702) || 挂载数据: 无 ) 
│       ├── 网络爬虫开发 --> ( 难度等级: [0.9702, 0.9762) || 挂载数据: 无 ) 
│       │   ├── 初识网络爬虫 --> ( 难度等级: [0.9702, 0.9722) || 挂载数据: 无 ) 
│       │   │   ├── 网络爬虫概述 --> ( 难度等级: [0.9702, 0.9709) || 挂载数据: qa: 3; blog: 4 ) 
│       │   │   ├── 网络爬虫的分类 --> ( 难度等级: [0.9709, 0.9716) || 挂载数据: 无 ) 
│       │   │   └── 网络爬虫的基本原理 --> ( 难度等级: [0.9716, 0.9722) || 挂载数据: 无 ) 
│       │   ├── 网络爬虫的常用技术 --> ( 难度等级: [0.9722, 0.9742) || 挂载数据: qa: 1 ) 
│       │   │   ├── Python的网络请求 --> ( 难度等级: [0.9722, 0.9726) || 挂载数据: qa: 4; blog: 1 ) 
│       │   │   ├── 请求headers处理 --> ( 难度等级: [0.9726, 0.973) || 挂载数据: qa: 1 ) 
│       │   │   ├── 网络超时 --> ( 难度等级: [0.973, 0.9734) || 挂载数据: qa: 1 ) 
│       │   │   ├── 代理服务 --> ( 难度等级: [0.9734, 0.9738) || 挂载数据: 无 ) 
│       │   │   └── HTML解析之BeautifulSoup --> ( 难度等级: [0.9738, 0.9742) || 挂载数据: qa: 2; blog: 3 ) 
│       │   └── 网络爬虫开发常用框架 --> ( 难度等级: [0.9742, 0.9762) || 挂载数据: 无 ) 
│       │       ├── Scrapy爬虫框架 --> ( 难度等级: [0.9742, 0.9749) || 挂载数据: qa: 1 ) 
│       │       ├── Crawley爬虫框架 --> ( 难度等级: [0.9749, 0.9755) || 挂载数据: qa: 1; blog: 1 ) 
│       │       └── PySpider爬虫框架 --> ( 难度等级: [0.9755, 0.9762) || 挂载数据: 无 ) 
│       ├── 使用进程和线程 --> ( 难度等级: [0.9762, 0.9821) || 挂载数据: 无 ) 
│       │   ├── 什么是进程 --> ( 难度等级: [0.9762, 0.9772) || 挂载数据: 无 ) 
│       │   ├── 创建进程的常用方式 --> ( 难度等级: [0.9772, 0.9782) || 挂载数据: 无 ) 
│       │   │   ├── 使用multiprocessing模块创建进程 --> ( 难度等级: [0.9772, 0.9775) || 挂载数据: qa: 1 ) 
│       │   │   ├── 使用Process子类创建进程 --> ( 难度等级: [0.9775, 0.9778) || 挂载数据: qa: 1; blog: 1 ) 
│       │   │   └── 使用进程池Pool创建进程 --> ( 难度等级: [0.9778, 0.9782) || 挂载数据: qa: 2 ) 
│       │   ├── 进程间通信 --> ( 难度等级: [0.9782, 0.9792) || 挂载数据: 无 ) 
│       │   │   ├── 队列简介 --> ( 难度等级: [0.9782, 0.9785) || 挂载数据: 无 ) 
│       │   │   ├── 多进程队列的使用 --> ( 难度等级: [0.9785, 0.9788) || 挂载数据: qa: 5; blog: 1 ) 
│       │   │   └── 使用队列在进程间通信 --> ( 难度等级: [0.9788, 0.9792) || 挂载数据: blog: 5 ) 
│       │   ├── 什么是线程 --> ( 难度等级: [0.9792, 0.9802) || 挂载数据: 无 ) 
│       │   ├── 创建线程 --> ( 难度等级: [0.9802, 0.9812) || 挂载数据: 无 ) 
│       │   │   ├── 使用threading模块创建线程 --> ( 难度等级: [0.9802, 0.9807) || 挂载数据: 无 ) 
│       │   │   └── 使用Thread子类创建线程 --> ( 难度等级: [0.9807, 0.9812) || 挂载数据: qa: 1; blog: 5 ) 
│       │   └── 线程间通信 --> ( 难度等级: [0.9812, 0.9821) || 挂载数据: 无 ) 
│       │       ├── 什么是互斥锁 --> ( 难度等级: [0.9812, 0.9815) || 挂载数据: qa: 1 ) 
│       │       ├── 使用互斥锁 --> ( 难度等级: [0.9815, 0.9818) || 挂载数据: 无 ) 
│       │       └── 使用队列在线程间通信 --> ( 难度等级: [0.9818, 0.9821) || 挂载数据: 无 ) 
│       ├── 网络编程 --> ( 难度等级: [0.9821, 0.9881) || 挂载数据: 无 ) 
│       │   ├── 网络基础 --> ( 难度等级: [0.9821, 0.9841) || 挂载数据: 无 ) 
│       │   │   ├── TCP/IP简介 --> ( 难度等级: [0.9821, 0.9828) || 挂载数据: qa: 8; blog: 2 ) 
│       │   │   ├── UDP简介 --> ( 难度等级: [0.9828, 0.9835) || 挂载数据: 无 ) 
│       │   │   └── Socket简介 --> ( 难度等级: [0.9835, 0.9841) || 挂载数据: blog: 2 ) 
│       │   ├── TCP编程 --> ( 难度等级: [0.9841, 0.9861) || 挂载数据: 无 ) 
│       │   │   ├── 创建TCP服务器 --> ( 难度等级: [0.9841, 0.9848) || 挂载数据: blog: 3 ) 
│       │   │   ├── 创建TCP客户端 --> ( 难度等级: [0.9848, 0.9854) || 挂载数据: qa: 1; blog: 15 ) 
│       │   │   └── 执行TCP服务器和客户端 --> ( 难度等级: [0.9854, 0.9861) || 挂载数据: 无 ) 
│       │   └── UDP编程 --> ( 难度等级: [0.9861, 0.9881) || 挂载数据: 无 ) 
│       │       ├── 创建UDP服务器 --> ( 难度等级: [0.9861, 0.9868) || 挂载数据: 无 ) 
│       │       ├── 创建UDP客户端 --> ( 难度等级: [0.9868, 0.9874) || 挂载数据: qa: 3 ) 
│       │       └── 执行UDP服务器和客户端 --> ( 难度等级: [0.9874, 0.9881) || 挂载数据: 无 ) 
│       ├── Web编程 --> ( 难度等级: [0.9881, 0.994) || 挂载数据: 无 ) 
│       │   ├── Web基础 --> ( 难度等级: [0.9881, 0.9901) || 挂载数据: 无 ) 
│       │   │   ├── HTTP协议 --> ( 难度等级: [0.9881, 0.9886) || 挂载数据: 无 ) 
│       │   │   ├── Web服务器 --> ( 难度等级: [0.9886, 0.9891) || 挂载数据: blog: 4 ) 
│       │   │   ├── 前端基础 --> ( 难度等级: [0.9891, 0.9896) || 挂载数据: qa: 18; blog: 5 ) 
│       │   │   └── 静态服务器 --> ( 难度等级: [0.9896, 0.9901) || 挂载数据: 无 ) 
│       │   ├── WSGI接口 --> ( 难度等级: [0.9901, 0.9921) || 挂载数据: 无 ) 
│       │   │   ├── CGI简介 --> ( 难度等级: [0.9901, 0.9906) || 挂载数据: 无 ) 
│       │   │   ├── WSGI简介 --> ( 难度等级: [0.9906, 0.9911) || 挂载数据: 无 ) 
│       │   │   ├── 定义WSGI接口 --> ( 难度等级: [0.9911, 0.9916) || 挂载数据: qa: 3; blog: 1 ) 
│       │   │   └── 运行WSGI服务 --> ( 难度等级: [0.9916, 0.9921) || 挂载数据: 无 ) 
│       │   └── Web框架 --> ( 难度等级: [0.9921, 0.994) || 挂载数据: 无 ) 
│       │       ├── 什么是Web框架 --> ( 难度等级: [0.9921, 0.9931) || 挂载数据: qa: 3; blog: 35 ) 
│       │       └── Python中常用的Web框架 --> ( 难度等级: [0.9931, 0.994) || 挂载数据: 无 ) 
│       └── Flask框架 --> ( 难度等级: [0.994, 1.0) || 挂载数据: qa: 1 ) 
│           ├── Flask简介 --> ( 难度等级: [0.994, 0.9955) || 挂载数据: 无 ) 
│           │   ├── 安装虚拟环境 --> ( 难度等级: [0.994, 0.9945) || 挂载数据: blog: 1 ) 
│           │   ├── 安装Flask --> ( 难度等级: [0.9945, 0.995) || 挂载数据: qa: 6; blog: 169 ) 
│           │   └── 第一个Flask程序 --> ( 难度等级: [0.995, 0.9955) || 挂载数据: blog: 14 ) 
│           ├── Flask基础 --> ( 难度等级: [0.9955, 0.997) || 挂载数据: 无 ) 
│           │   ├── 开启调试模式 --> ( 难度等级: [0.9955, 0.9959) || 挂载数据: 无 ) 
│           │   ├── 路由 --> ( 难度等级: [0.9959, 0.9963) || 挂载数据: 无 ) 
│           │   ├── 静态文件 --> ( 难度等级: [0.9963, 0.9967) || 挂载数据: 无 ) 
│           │   └── 蓝图 --> ( 难度等级: [0.9967, 0.997) || 挂载数据: 无 ) 
│           ├── 模板 --> ( 难度等级: [0.997, 0.9985) || 挂载数据: 无 ) 
│           │   ├── 渲染模板 --> ( 难度等级: [0.997, 0.9975) || 挂载数据: 无 ) 
│           │   ├── 变量 --> ( 难度等级: [0.9975, 0.998) || 挂载数据: 无 ) 
│           │   └── 控制结构 --> ( 难度等级: [0.998, 0.9985) || 挂载数据: 无 ) 
│           └── Web表单 --> ( 难度等级: [0.9985, 1.0) || 挂载数据: 无 ) 
│               ├── CSRF保护和验证 --> ( 难度等级: [0.9985, 0.999) || 挂载数据: 无 ) 
│               ├── 表单类 --> ( 难度等级: [0.999, 0.9995) || 挂载数据: 无 ) 
│               └── 把表单渲染成HTML --> ( 难度等级: [0.9995, 1.0) || 挂载数据: 无 ) 
└── 其他 --> ( 难度等级: [0, 0) || 挂载数据: 无 ) 
    ├── 其他类别标签问题 --> ( 难度等级: [0, 0) || 挂载数据: qa: 256 ) 
    ├── 应用类问题 --> ( 难度等级: [0, 0) || 挂载数据: qa: 113 ) 
    └── 第三方包问题 --> ( 难度等级: [0, 0) || 挂载数据: qa: 256 )