顶部
收藏

Python语言程序设计


作者:
李学刚
定价:
49.00 元
版面字数:
380.00千字
开本:
16开
装帧形式:
平装
页数:
284
最新
印次时间:
2024年11月
ISBN:
978-7-04-052491-8
物料号:
52491-00
出版时间:
2019-10-15
读者对象:
高等职业教育
一级分类:
计算机大类
二级分类:
计算机类
三级分类:
软件技术

本书共8章,内容包括Python 语言基础、基本数据类型和操作、控制结构、序列数据类型和操作、函数与模块、面向对象编程、文件操作以及异常处理,每章由若干节构成,每节又包括若干知识点。此外,每节还配套了相应的同步训练,包括单项选择题、知识填空题、程序填空题、程序阅读题和程序设计题等多种题型,以巩固和提高学生对相关知识的理解和掌握。

本书按理论与实践一体化的教学方式组织编写,精心设计了许多示例用于讲解知识点、例题用于解决实际问题、课堂实践用于消化知识点,教师可采用边理论讲解、边实践操作的方式进行教学。

本书配套有微课视频、授课用PPT、源代码、课堂实践与同步训练参考答案等数字化学习资源。与本书配套的在线开放课程将在“智慧职教MOOC 学院”(http://mooc.icve.com.cn/)上线,学习者可以登录网站进行在线开放课程的学习,授课教师可以调用本课程构建符合自身教学特色的SPOC 课程,详见“智慧职教服务指南”。读者可登录网站进行资源的学习及获取,也可发邮件至编辑邮箱1548103297@qq.com 获取相关资源。

本书可作为高等职业院校电子信息类专业Python 语言程序设计课程的教材,也可作为Python 语言爱好者的学习参考书。

  • 目录
    • 前辅文
      • 第1章 Python语言基础
        • 1.1 Python语言及编码规范
          • 1.1.1 计算机程序设计语言
            • 1.1.2 Python语言简介
              • 1.1.3 Python语言的开发环境
                • 1.1.4 编码规范
                  • 【同步训练1.1】
                  • 1.2 Python语言基本概念
                    • 1.2.1 对象
                      • 1.2.2 标识符
                        • 1.2.3 变量
                          • 1.2.4 函数
                            • 1.2.5 类及其属性和方法
                              • 【同步训练1.2】
                              • 1.3 数据输入和输出
                                • 1.3.1 数据输入
                                  • 1.3.2 数据输出
                                    • 【同步训练1.3】
                                  • 第2章 基本数据类型和操作
                                    • 2.1 基本数据类型
                                      • 2.1.1 整型
                                        • 2.1.2 浮点型
                                          • 2.1.3 复数型
                                            • 2.1.4 布尔型和空值型
                                              • 2.1.5 字符串型
                                                • 【同步训练2.1】
                                                • 2.2 运算符
                                                  • 2.2.1 算术运算符
                                                    • 2.2.2 赋值运算符
                                                      • 2.2.3 位运算符
                                                        • 【同步训练2.2】
                                                        • 2.3 内置函数
                                                          • 2.3.1 数字操作常用内置函数
                                                            • 2.3.2 类型转换常用内置函数
                                                              • 2.3.3 其他常用内置函数
                                                                • 【同步训练2.3】
                                                              • 第3章 控制结构
                                                                • 3.1 程序的三种基本结构
                                                                  • 3.1.1 顺序结构
                                                                    • 3.1.2 选择结构
                                                                      • 3.1.3 循环结构
                                                                      • 3.2 条件表达式
                                                                        • 3.2.1 关系表达式
                                                                          • 3.2.2 逻辑表达式
                                                                            • 3.2.3 同一运算符
                                                                              • 3.2.4 成员运算符
                                                                                • 3.2.5 用表达式表达实际问题
                                                                                  • 【同步训练3.2】
                                                                                  • 3.3 选择结构
                                                                                    • 3.3.1 单分支选择结构if语句
                                                                                      • 3.3.2 二分支选择结构if…else语句
                                                                                        • 3.3.3 多分支选择结构if…elif语句
                                                                                          • 3.3.4 应用实例
                                                                                            • 【同步训练3.3】
                                                                                            • 3.4 循环结构
                                                                                              • 3.4.1 while循环结构
                                                                                                • 3.4.2 for循环结构
                                                                                                  • 3.4.3 循环控制语句
                                                                                                    • 3.4.4 循环嵌套
                                                                                                      • 3.4.5 应用实例
                                                                                                        • 【同步训练3.4】
                                                                                                      • 第4章 序列数据类型和操作
                                                                                                        • 4.1 序列通用操作
                                                                                                          • 4.1.1 序列及分类
                                                                                                            • 4.1.2 序列通用运算符
                                                                                                              • 4.1.3 序列通用内置函数
                                                                                                                • 【同步训练4.1】
                                                                                                                • 4.2 字符串
                                                                                                                  • 4.2.1 创建字符串
                                                                                                                    • 4.2.2 字符串操作
                                                                                                                      • 4.2.3 字符串操作常用方法
                                                                                                                        • 4.2.4 应用实例
                                                                                                                          • 【同步训练4.2】
                                                                                                                          • 4.3 列表
                                                                                                                            • 4.3.1 创建列表
                                                                                                                              • 4.3.2 列表操作
                                                                                                                                • 4.3.3 列表操作常用方法
                                                                                                                                  • 4.3.4 应用实例
                                                                                                                                    • 【同步训练4.3】
                                                                                                                                    • 4.4 元组
                                                                                                                                      • 4.4.1 创建元组
                                                                                                                                        • 4.4.2 元组操作
                                                                                                                                          • 4.4.3 元组操作常用方法
                                                                                                                                            • 4.4.4 应用实例
                                                                                                                                              • 【同步训练4.4】
                                                                                                                                              • 4.5 集合
                                                                                                                                                • 4.5.1 创建集合
                                                                                                                                                  • 4.5.2 集合操作
                                                                                                                                                    • 4.5.3 集合操作常用方法
                                                                                                                                                      • 4.5.4 应用实例
                                                                                                                                                        • 【同步训练4.5】
                                                                                                                                                        • 4.6 字典
                                                                                                                                                          • 4.6.1 创建字典
                                                                                                                                                            • 4.6.2 字典操作
                                                                                                                                                              • 4.6.3 字典操作常用方法
                                                                                                                                                                • 4.6.4 应用实例
                                                                                                                                                                  • 【同步训练4.6】
                                                                                                                                                                • 第5章 函数与模块
                                                                                                                                                                  • 5.1 函数
                                                                                                                                                                    • 5.1.1 函数定义与调用
                                                                                                                                                                      • 5.1.2 函数参数
                                                                                                                                                                        • 5.1.3 参数传递
                                                                                                                                                                          • 5.1.4 匿名函数
                                                                                                                                                                            • 5.1.5 变量的作用域
                                                                                                                                                                              • 5.1.6 函数的各种调用方式
                                                                                                                                                                                • 5.1.7 文档字符串和注释
                                                                                                                                                                                  • 5.1.8 应用实例
                                                                                                                                                                                    • 【同步训练5.1】
                                                                                                                                                                                    • 5.2 模块
                                                                                                                                                                                      • 5.2.1 导入模块
                                                                                                                                                                                        • 5.2.2 创建模块和包
                                                                                                                                                                                          • 5.2.3 math模块
                                                                                                                                                                                            • 5.2.4 time模块
                                                                                                                                                                                              • 5.2.5 copy模块
                                                                                                                                                                                                • 【同步训练5.2】
                                                                                                                                                                                              • 第6章 面向对象编程
                                                                                                                                                                                                • 6.1 类与对象
                                                                                                                                                                                                  • 6.1.1 类的定义
                                                                                                                                                                                                    • 6.1.2 类中数据成员的定义
                                                                                                                                                                                                      • 6.1.3 类中方法的定义
                                                                                                                                                                                                        • 【同步训练6.1】
                                                                                                                                                                                                        • 6.2 属性和方法
                                                                                                                                                                                                          • 6.2.1 私有成员与公有成员
                                                                                                                                                                                                            • 6.2.2 类中外部属性的定义
                                                                                                                                                                                                              • 6.2.3 类方法与静态方法
                                                                                                                                                                                                                • 6.2.4 特殊方法和运算符重载
                                                                                                                                                                                                                  • 【同步训练6.2】
                                                                                                                                                                                                                  • 6.3 继承和多态
                                                                                                                                                                                                                    • 6.3.1 继承的实现
                                                                                                                                                                                                                      • 6.3.2 多态的实现
                                                                                                                                                                                                                        • 6.3.3 多重继承
                                                                                                                                                                                                                          • 【同步训练6.3】
                                                                                                                                                                                                                        • 第7章 文件操作
                                                                                                                                                                                                                          • 7.1 文件的打开和关闭
                                                                                                                                                                                                                            • 7.1.1 文件的基本概念
                                                                                                                                                                                                                              • 7.1.2 打开和关闭文件
                                                                                                                                                                                                                                • 【同步训练7.1】
                                                                                                                                                                                                                                • 7.2 文件的操作
                                                                                                                                                                                                                                  • 7.2.1 文件的读取与定位
                                                                                                                                                                                                                                    • 7.2.2 文件的写入
                                                                                                                                                                                                                                      • 7.2.3 应用实例
                                                                                                                                                                                                                                        • 【同步训练7.2】
                                                                                                                                                                                                                                        • 7.3 使用标准模块处理文件
                                                                                                                                                                                                                                          • 7.3.1 使用os模块处理文件
                                                                                                                                                                                                                                            • 7.3.2 使用pickle模块处理文件
                                                                                                                                                                                                                                              • 【同步训练7.3】
                                                                                                                                                                                                                                            • 第8章 异常处理
                                                                                                                                                                                                                                              • 8.1 捕获和处理异常
                                                                                                                                                                                                                                                • 8.1.1 异常的分类
                                                                                                                                                                                                                                                  • 8.1.2 异常的处理
                                                                                                                                                                                                                                                    • 8.1.3 应用实例
                                                                                                                                                                                                                                                      • 【同步训练8.1】
                                                                                                                                                                                                                                                      • 8.2 主动引发异常和自定义异常类
                                                                                                                                                                                                                                                        • 8.2.1 主动引发异常
                                                                                                                                                                                                                                                          • 8.2.2 自定义异常类
                                                                                                                                                                                                                                                            • 【同步训练8.2】
                                                                                                                                                                                                                                                          • 参考文献

                                                                                                                                                                                                                                                          相关图书