Python程序设计


从基础开始掌握AI中的Python开发,从0到1 实现一个真正的深度学习实践项目,创造能够改造世界的轮子!

        

课程难度

基础

已经参加学习的人数

461

课程主讲师

丁老师

学习次数

62589

课程设计原则
课程OKR
  • 掌握AI领域里的Python开发
  • 会用:独立用Python实现机器学习算法
  • 会读:读懂开源社区的代码,并可以进行修改和扩展
  • 会写:写的Python代码更加Pythonic,更容易协作和交流
  • 会学:Python大厦的地基已经打好,后续Python进阶的路你就可以走的很顺利
学习Python的正确姿势(非常重要!)
  • 不是非常系统性的全面学习
  • 也不是直接用一个个的小项目去动手练习
  • 从学习目的出发,找到一个最小的学习范围
  • 把这个最小范围系统性的学习到非常扎实的程度
  • 其余的知识,看到了,或者需要用了,交给Google来碎片化的补充学习即可
AI领域Python的最小知识范围
  • Python的类型,变量,流程控制语句
  • 字符与编码
  • 数据容器
  • 函数式编程基础
  • 面向对象的视角理解Python的对象模型
  • 迭代器
  • 上下文管理器
  • Numpy


项目实践
  • 从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 ,你需要知道模块的访问限制变量

第 19 集 导入时与运行时(下)

  • 19.1 案例:模块,类,函数,在导入时与运行时的行为
  • 19.2 案例:加上装饰器,类中类,看导入时与运行时
  • 19.3 如果没有if_name_="_main_",会发生什么?
  • 19.4 总结

第 20 集 结束语:后面的路靠你自己了

  • 20.1 回顾一下整个课程内容
  • 20.2 从课程的特点谈谈对Python教学的理解
  • 20.3 课程的KR藏于课程设计中,而O的实现要靠你后续的努力
导师团队

丁老师

毕业于北航测控系。现任某AI公司技术副总裁,AI软件系统架构师,GitHub百星作者,HackerRank Python板块满分,累积面试100+AI算法研发及Python开发人员。


Lantern

硕士,毕业于清华大学计算机系,主要负责实验平台,实践项目的技术支持,在人工智能算法、工程化方面有深厚的造诣与丰富的实际经验。


Q & A

授课方式是?

为了保障课程质量,提高学习效率, 课程采用录播形式。视频精心录制与剪辑制作,时间比直播更灵活,方便随时观看学习。

课程周期是多久?

为了让大家在一定时间内集中精力学习,《深度学习Python开发-基础篇》课程有效期有6个月时间,对于单独学习这门课程来说,时间是充裕的。

遇到问题可以咨询么?

学习过程中遇到的任何问题都可以提出来,会有专业导师进行3个月的在线答疑,解决你学习中遇到的任何问题与困难。

如何开取发票?

购买成功后,扫描下方二维码,将具体开票信息发送给小编即可。

如何延长有效期?

课程到期后,电脑端登录官网可以续费,续费价格是官网原价的5%,有效期半年(不包括在线答疑)。注意:到期前两周内课程详情页面会出现【续费】按钮,点击按钮进行续费即可。


更多问题、课程咨询、资料获取,扫码找小编






 课程咨询