• 从0到1的深度学习项目实践
• 0. 选定一篇经典论文；
• 1. 怎么搜索，怎么下载论文；
• 2. 怎么阅读论文：链式反向阅读法+综述阅读法；
• 3. 怎么找到训练数据集；
• 4. 怎么分析数据集；
• 5. 怎么实现论文的模型结构；
• 6. 怎么处理数据集；
• 7. 复现论文模型需要找到哪些参数；
• 8. 评估结果，调试模型；
• 9. 配置GPU服务器环境的流程；
• 10. 训练好的模型如何使用

第 1 集 课程简介，设计原则及学习方法

• 1.1 课程OKR
• 1.2 为什么要用Markdown式讲稿而非keynote
• 1.3 为什么学习Python
• 1.4 为什么做AI要学习Python
• 1.5 为什么学习Python3而不是Python2
• 1.6 课程设计原则
  • 1.6.1 学习Python的正确姿势
  • 1.6.2 AI领域Python的最小知识范围
• 1.7 课程学习方法

第 2 集 Python学习的预备内容

• 2.1 本节课主要内容
• 2.2 Linux系统简介
  • 2.2.1 Linux
  • 2.2.2 跨硬件平台
  • 2.2.3 一切皆是文件
• 2.3 Linux命令行简介
  • 2.3.1 shell
  • 2.3.2 终端仿真器程序-terminal
• 2.4 使用在线编程模块的terminal
• 2.5 Linux文件系统及读写权限简介
• 2.6 Linux目录结构
• 2.7 账户读写权限
  • 2.7.1 看第一列字符串
  • 2.7.2 文件类型
  • 2.7.3 权限类型
• 2.8 Python解释器
  • 2.8.1 Python的程序是怎么执行的
  • 2.8.2 增强版解释器-IPython
  • 2.8.3 更强的工具-Jupyter Notebook
  • 2.8.4 REPL-DD(交互式命令行驱动开发)
• 2.9 在线编程功能
  • 2.9.1 四个模块
  • 2.9.2 使用在线编程模块与本地环境的区别

第 3 集 Python快速面面观(上)

• 3.1 课程介绍
• 3.2 第一个Python程序
• 3.3 输入与输出
• 3.4 Python中应知道的细节
• 3.5 数据类型
• 3.6 常量与基本运算
• 3.7 浅谈变量
• 3.8 List
  • 3.8.1 可变有序集合
  • 3.8.2 List之可变
  • 3.8.3 List之有序
  • 3.8.4 List之集合
• 3.9 Tuple
  • 3.9.1 Tuple之不可变
  • 3.9.2 Tuple之括号歧义
  • 3.9.3 Tuple之可变
• 3.10 Dict
• 3.11 Set
• 3.12 Python入门小坑之除法与字符串
  • 3.12.1 单引号，双引号，三单引号，三双引号
  • 3.12.2 引号作为字符
  • 3.12.3 转义字符
  • 3.12.4 raw string
  • 3.12.5 三引号?
• 3.13 Python入门小坑之字符编码
  • 3.13.1 字符编码常见工作模式
  • 3.13.2 Python中的字符串
  • 3.13.3 字符串的编解码(decode&encode)
• 3.14 Python入门小坑之再谈变量
  • 3.14.1 可变类型与不可变类型
  • 3.14.2 可变对象与不可变对象
  • 3.14.3 Python中的引用与拷贝

第 4 集 Python快速面面观(下)

• 4.1 本集内容简介
• 4.2 布尔变量的基本判断规则与方法
• 4.3 数字的基本判断规则与方法
• 4.4 Python入门小坑之逻辑判断
• 4.5 深入理解Python中的 and和or
• 4.6 if语句
• 4.7 循环之for循环
• 4.8 循环之while循环、break、continue
  • 4.8.1 while循环：只要满足条件则持续操作
  • 4.8.2 break语句：满足条件则跳出循环
  • 4.8.3 continue语句：满足条件则直接进入下个循环
• 4.9 函数
  • 4.9.1 调用内置函数
  • 4.9.2 自定义函数
  • 4.9.3 函数的默认参数
• 4.10 Python入门小坑之默认参数的记忆性
• 4.11 传入任意个数的参数
• 4.12 Python中的面向对象
• 4.13 Python代码的组织-模块
• 4.14 包管理工具pip
• 4.15 Python入门小坑之解释器默认搜索路径

第 5 集 玩转Python中的List

• 5.1 本集内容简介
• 5.2 切片
  • 5.2.1切片功能的三个参数
• 5.3 多重List的浅拷贝与深拷贝
• 5.4 序列的加法，乘法，初始化
  • 5.4.1 序列的加法
  • 5.4.2 序列的乘法
  • 5.4.3 常用的序列初始化方案
• 5.5 序列的常见内置方法
  • 5.5.1 序列的包含关系：in
  • 5.5.2 序列的长度，最大值，最小值：len，max，min
  • 5.5.3 List与str的相互转换
  • 5.5.4 List的元素与切片的赋值与删除
  • 5.5.5 计数函数：count
  • 5.5.6 列表的排序
  • 5.5.7 Llst的内置方法及其时间空间复杂度
• 5.6 初见 List comprehension

第 6 集 Python中的函数与函数式编程(上)

• 6.1 本集内容简介
• 6.2 认识函数
  • 6.2.1 代码块
  • 6.2.2 函数定义
• 6.3 函数参数
  • 6.3.1 形参与实参
  • 6.3.2 参数的传递
  • 6.3.3 位置参数与关键字参数
• 6.4 名称空间与作用域解析
  • 6.4.1 作用域的产生
  • 6.4.2 作用域的查看(globals()与locals())
  • 6.4.3 作用域间变量的遮盖
  • 6.4.5 修改不同作用域里的变量
  • 6.4.6 作用域的生命周期

第 7 集 Python中的函数与函数式编程(下)

• 7.1 函数式编程概述
  • 7.1.1 程序的状态与命令式编程
  • 7.1.2 函数式编程
• 7.2 一等函数
  • 7.2.1 一等对象
• 7.3 高阶函数
  • 7.3.1 map高阶函数
  • 7.3.2 filter高阶函数
  • 7.3.3 reduce高阶函数
  • 7.3.4 sorted高阶函数
  • 7.3.5 partial高阶函数
• 7.4 匿名函数
  • 7.4.1 用lambda 与用def 的区别在哪
  • 7.4.2 lambda 速写
  • 7.4.3 List + lambda
  • 7.4.4 入门小坑系列之---惰性计算

第 8 集 闭包

• 8.1 再谈变量作用域
  • 8.1.1 从内层函数的角度看，变量使用的两个维度
  • 8.1.2 变量作用域识别三要素
  • 8.1.3 三种变量作用域
  • 8.1.4 实践和金句
  • 8.1.5 Python解释器如何识别变量的作用域?
  • 8.1.6 为什么会有 nonlocal 关键字?
• 8.2 什么是闭包?
  • 8.2.1 闭包的各种实现方式
• 8.3 闭包的作用

第 9 集 装饰器

• 9.1 概述
• 9.2 Why?为什么会出现装饰器这个东西?
  • 9.2.1 不引入多余变量名
  • 9.2.2 显示调用，就近原则
  • 9.2.3 分层封装，充分复用
• 9.3 What? 什么是装饰器
  • 9.3.1 装饰器的堆叠
  • 9.3.2 装饰器在导入时立即执行
  • 9.3.3 带参数的装饰器
• 9.4 How?装饰器怎么用
  • 9.4.1 装饰器的常见使用场景
  • 9.4.2 注册机制或授权机制(与应用开发相关)
  • 9.4.3 参数的数据验证或清洗
  • 9.4.4 复用核心计算模块，仅改变输出方式
• 9.5 总结

第 10 集 理解面向对象编程(OPP)

• 10.1 本节课的OKR
  • 10.1.1 三节课之间的关系：层层递进
  • 10.1.2 本节课的object
  • 10.1.3 本节课的key Result
• 10.2 什么是面向对象，什么是面向过程
  • 10.2.1 面向过程式编程
  • 10.2.2 面向对象式编程
  • 10.2.3 举例说明
• 10.3 面向对象和面向过程的区别
• 10.4 比设计模式更重要的是设计原则
• 10.4.1 面向对象设计的目标
• 10.4.2 面向对象设计的SOLID原则
• 10.4.3 AI场景+Python(语言)+OOP(编程模式)

第 11 集 OOP in Python

• 11.1 本节课的OKR
  • 11.1.1 本节课与上节课的关系
  • 11.1.2 本节课与下节课的关系
  • 11.1.3 本节课的Key Result
• 11.2 面向对象的Python实现
  • 11.2.1 类的创建
  • 11.2.2 类的数据绑定
  • 11.2.3 类的自定义实例化
  • 11.2.4 对象方法
  • 11.2.5 类方法
  • 11.2.6 属性封装
  • 11.2.7 继承(隐式实例化)
  • 11.2.8 继承(显示实例化)
  • 11.2.9 多态
• 11.3 面向对象的重要特性总结

第 12 集 Pythonic OOP(上)

• 12.1 本节课的OKR
  • 12.1.1 本节课的KR
  • 12.1.2 说明
• 12.2 关于双下划线
  • 12.2.1 怎么读
  • 12.2.2 双下划线开头和结尾的变量或方法叫什么
  • 12.2.3 如何认识Python的special method
• 12.3 从语言设计层面理解Python的数据模型
  • 12.3.1 一切都是对象
  • 12.3.2 Objects 的组成⼀:identity
  • 12.3.3 Objects 的组成二:type
  • 12.3.4 Objects 的组成二:value
  • 12.3.5 存放其他 Object 的reference的Object:Container
• 12.4 Pythonic OOP with Special Method and Attribute
  • 12.4.1 The implicit superclass – object & type object
  • 12.4.2 Integrating Seamlessly with Python
• 12.5 Attribute Access and Properties(Level I:Basic Access)

第 13 集 Pythonic OOP(下)

• 13.1 Attribute Access and Properties(Level II:Property)
• 13.2 Cross-Cutting and Duck Typing
  • 13.2.1 单继承 vs 多态
  • 13.2.2 传统OOP vs 鸭子类型
  • 13.2.3 传统OOP的多态 vs 鸭子类型的多态
  • 13.2.4 MixIn:基于鸭子类型的视角看Multi-Inheritance
  • 13.2.5 Cross-Cutting:基于鸭子类型的视角看Decorator与Special Method
  • 13.2.6 Python语言设计的三个关键词(其实是一件事的三个不同视角)
• 13.3 总结

第 14 集 迭代器协议

• 14.1 本节课的OKR
  • 14.1.1 Objective
  • 14.1.2 Key Result
• 14.2 Iterator Protocol
• 14.3 Generator
  • 14.3.1 yield Expression
  • 14.3.2 Generator Expression
  • 14.3.3 在Python中不要小瞧任何看似微小的区别
• 14.4 为什么需要生成器
  • 14.4.1 用生成器表示全部的斐波那契数列
  • 14.4.2 通过生成器管道模块化处理数据
• 14.5 总结：关于Python中的迭代思维

第 15 集 异常处理

• 15.1 什么是异常
• 15.2 为什么程序会出现异常
• 15.3 通常如何处理
• 15.4 Python中的异常及相关语法
  • 15.4.1 案例：主动抛出异常
  • 15.4.2 案例：被动遇到异常
  • 15.4.3 案例：异常处理语句—未遇到异常
  • 15.4.4 案例：异常处理语句—捕获全部异常
  • 15.4.5 案例：异常处理语句—捕获指定异常
  • 15.4.6 案例：异常处理语句—捕获异常后仍抛出
  • 15.4.7 案例：异常处理语句—捕获异常后显示异常信息但不抛出异常
  • 15.4.8 案例：异常语句与循环的连用
• 15.5 异常的传播
• 15.6 关于异常的后续学习

第 16 集 上下文管理器

• 16.1 概述
  • 16.1.1 为什么要讲Context Manager?
  • 16.1.2 Context Manager与Decorator之间的关系?
  • 16.1.3 本节课的主要内容
• 16.2 Why?为什么我们需要Context Manager?
  • 16.2.1 有始必有终
  • 16.2.2 有始必有终的try/finally实现及相应的Context Manager抽象
  • 16.2.3 When to use Context Manager?
• 16.3 What?什么是Context Manager?与with语句是何关系?
  • 16.3.1 Context Manager is a protocol for Python with statement
  • 16.3.2 案例：Context Manager通用结构
• 16.4 How?Context Manager都怎么使用?
  • 16.4.1 成对出现的模式：Context Manager使用的信号
  • 16.4.2 确保一个打开的流在程序中关闭
  • 16.4.3 确保为测试而准备的代码执行环境在执行完毕后销毁
  • 16.4.5 确保不同线程之间访问共享资源时的线程锁一定会释放
  • 16.4.6 在部分代码处使用高精度模式
  • 16.4.7 管理数据库的连接资源
  • 16.4.8 对某一块代码进行运行时间测量
  • 16.4.9 临时创建文件进行缓存，并在使用完毕后删除
  • 16.4.10 一个功能的代码实现与其工程化的区别

第 17 集 导入时与运行时(上)

• 17.1 概述
• 17.2 安装Python的时候到底安装的是什么？
• 17.3 Python解释器是什么？
• 17.4 解释器由什么组成？
• 17.5 程序运行完整流程
• 17.6 模块是一个对象
• 17.7 模块有自己的作用域
• 17.8 模块只需要导入一次

第 18 集 导入时与运行时（中）

• 18.1 模块通常怎么用（一）：工具包
• 18.2 模块通常怎么用（二）：测试包
• 18.3 模块通常怎么用（三）：配置包
• 18.4 模块怎么变成包
• 18.5 模块有自己的预设字段
• 18.6 如果使用 from pkg import ，你需要知道模块的访问限制变量