顶部
收藏

Python程序设计基础


作者:
楼桦 虞菊花
定价:
49.50 元
版面字数:
460千字
开本:
16开
装帧形式:
平装
版次:
1
最新版次
印刷时间:
暂无
ISBN:
978-7-04-058645-9
物料号:
58645-00
出版时间:
2022-08-09
读者对象:
高等职业教育
一级分类:
计算机大类
二级分类:
计算机类
三级分类:
软件技术

本书是中国特色高水平高职学校和专业建设计划项目中的软件技术(软件与大数据技术)专业群教材建设成果之一。

本书面向零基础的高等职业院校学生,介绍Python编程语言最基本的知识。全书共7章,内容包括Python概述、基本数据类型与操作、程序控制语句、列表与元组、字典与集合、函数与模块、文件的基本操作。全书使用迭代轻量化案例代码组成Python编程语言基础知识结构,无论是内容组织还是案例选取,都严格按照高职院校学生的认知规律进行,由浅入深,利于教学实施,可助Python初学者奠定较为扎实、全面的编程基础。

本书配有微课视频、授课用PPT、案例源码等丰富的数字化学习资源。与本书配套的数字课程“Python程序设计基础”在“智慧职教”平台(www.icve.com.cn)上线,学习者可以登录平台进行在线学习及资源下载,授课教师可以调用本课程构建符合自身教学特色的SPOC课程,详见“智慧职教”服务指南。教师也可发邮件至编辑邮箱1548103297@qq.com获取相关资源。

本书可作为高职院校软件技术专业Python语言程序设计课程的教材,也可作为刚进入Python领域的零基础编程爱好者的自学用书。

  • 目录
    • 前辅文
      • 第1章 Python概述
        • 1.1 Python简介
          • 1.2 Windows Python编程环境搭建
            • 1.2.1 Visual Studio Code简介
              • 1.2.2 Python与VS Code的安装
              • 1.3 第1行Python代码
                • 1.4 知识点汇总
                  • 1.5 习题
                  • 第2章 基本数据类型与操作
                    • 2.1 数据类型
                      • 2.1.1 字符串型(str类型)
                        • 2.1.2 整型(int类型)
                          • 2.1.3 浮点型(float类型)
                            • 2.1.4 布尔型(bool类型)
                              • 2.1.5 空值型(NoneType类型)
                              • 2.2 数据类型的查看与转换
                                • 2.2.1 数据类型的查看
                                  • 2.2.2 数据类型的转换
                                  • 2.3 变量与运算符
                                    • 2.3.1 变量
                                      • 2.3.2 运算符
                                      • 2.4 字符串处理
                                        • 2.4.1 字符串截取
                                          • 2.4.2 字符串内置函数
                                            • 2.4.3 字符串操作常用方法
                                            • 2.5 格式化输出
                                              • 2.5.1 格式化输出的常规方法
                                                • 2.5.2 格式化操作符(%)
                                                  • 2.5.3 使用format()方法格式化字符串
                                                    • 2.5.4 f字符串的使用
                                                    • 2.6 常见异常类型
                                                      • 2.6.1 程序异常
                                                        • 2.6.2 常见异常分析
                                                        • 2.7 知识点汇总
                                                          • 2.8 习题
                                                          • 第3章 程序控制语句
                                                            • 3.1 条件选择语句if
                                                              • 3.1.1 if语句的基本用法
                                                                • 3.1.2 if...else语句的基本用法
                                                                  • 3.1.3 if...elif...else语句的基本用法
                                                                  • 3.2 循环控制语句while
                                                                    • 3.2.1 while语句的基本用法
                                                                      • 3.2.2 while结构中break和continue语句的用法
                                                                      • 3.3 循环控制语句for
                                                                        • 3.3.1 for语句的基本用法
                                                                          • 3.3.2 for结构中else、break和continue语句的用法
                                                                            • 3.3.3 for循环典型示例
                                                                            • 3.4 程序控制语句应用实例
                                                                              • 3.4.1 用户密码校验
                                                                                • 3.4.2 文本字符计数
                                                                                • 3.5 常见异常类型
                                                                                  • 3.5.1 语法异常
                                                                                    • 3.5.2 值异常
                                                                                      • 3.5.3 缩进异常
                                                                                      • 3.6 知识点汇总
                                                                                        • 3.7 习题
                                                                                        • 第4章 列表与元组
                                                                                          • 4.1 创建列表
                                                                                            • 4.1.1 列表的基本概念
                                                                                              • 4.1.2 直接创建列表
                                                                                                • 4.1.3 使用内置函数list()创建列表
                                                                                                • 4.2 访问列表
                                                                                                  • 4.2.1 使用索引访问列表元素
                                                                                                    • 4.2.2 通过元素值获得列表索引
                                                                                                    • 4.3 编辑列表
                                                                                                      • 4.3.1 添加列表元素
                                                                                                        • 4.3.2 扩展列表
                                                                                                          • 4.3.3 修改列表元素
                                                                                                            • 4.3.4 删除列表元素
                                                                                                            • 4.4 列表元素排序
                                                                                                              • 4.4.1 列表排序函数sort()
                                                                                                                • 4.4.2 通用排序函数sorted()
                                                                                                                • 4.5 列表切片
                                                                                                                  • 4.5.1 正序切片应用
                                                                                                                    • 4.5.2 逆序切片应用
                                                                                                                    • 4.6 嵌套列表
                                                                                                                      • 4.6.1 生成嵌套列表
                                                                                                                        • 4.6.2 嵌套列表的访问
                                                                                                                        • 4.7 遍历列表
                                                                                                                          • 4.7.1 按元素遍历列表
                                                                                                                            • 4.7.2 按索引遍历列表
                                                                                                                            • 4.8 列表推导式
                                                                                                                              • 4.8.1 循环模式
                                                                                                                                • 4.8.2 筛选模式
                                                                                                                                • 4.9 列表常用方法
                                                                                                                                  • 4.9.1 列表元素计数
                                                                                                                                    • 4.9.2 列表元素逆置
                                                                                                                                      • 4.9.3 列表的最大值与最小值
                                                                                                                                      • 4.10 列表应用实例
                                                                                                                                        • 4.11 创建元组
                                                                                                                                          • 4.11.1 直接创建元组
                                                                                                                                            • 4.11.2 使用内置函数创建元组
                                                                                                                                            • 4.12 访问元组
                                                                                                                                              • 4.12.1 使用索引访问元组
                                                                                                                                                • 4.12.2 通过元素值获得元组索引
                                                                                                                                                  • 4.12.3 元组嵌套变量
                                                                                                                                                    • 4.12.4 元组的切片
                                                                                                                                                    • 4.13 序列的封包与解包
                                                                                                                                                      • 4.13.1 序列的封包
                                                                                                                                                        • 4.13.2 序列的完全解包
                                                                                                                                                          • 4.13.3 序列的部分解包
                                                                                                                                                          • 4.14 压缩函数
                                                                                                                                                            • 4.14.1 序列压缩
                                                                                                                                                              • 4.14.2 序列解压缩
                                                                                                                                                              • 4.15 常见异常类型
                                                                                                                                                                • 4.15.1 元组中常见的类型异常
                                                                                                                                                                  • 4.15.2 列表和元组中常见的索引异常
                                                                                                                                                                    • 4.15.3 列表和元组中常见的值异常
                                                                                                                                                                    • 4.16 知识点汇总
                                                                                                                                                                      • 4.17 习题
                                                                                                                                                                      • 第5章 字典与集合
                                                                                                                                                                        • 5.1 创建字典
                                                                                                                                                                          • 5.1.1 字典的基本概念
                                                                                                                                                                            • 5.1.2 字典的无序性
                                                                                                                                                                              • 5.1.3 直接创建字典
                                                                                                                                                                                • 5.1.4 使用内置函数dict()创建字典
                                                                                                                                                                                • 5.2 访问字典
                                                                                                                                                                                  • 5.2.1 字典长度
                                                                                                                                                                                    • 5.2.2 字典的访问
                                                                                                                                                                                      • 5.2.3 字典的innot in运算符
                                                                                                                                                                                      • 5.3 编辑字典
                                                                                                                                                                                        • 5.3.1 添加字典项
                                                                                                                                                                                          • 5.3.2 修改字典项
                                                                                                                                                                                            • 5.3.3 删除字典项
                                                                                                                                                                                            • 5.4 遍历字典
                                                                                                                                                                                              • 5.4.1 键的遍历
                                                                                                                                                                                                • 5.4.2 值的遍历
                                                                                                                                                                                                  • 5.4.3 项的遍历
                                                                                                                                                                                                  • 5.5 嵌套字典
                                                                                                                                                                                                    • 5.5.1 字典嵌套在列表中
                                                                                                                                                                                                      • 5.5.2 列表嵌套在字典中
                                                                                                                                                                                                        • 5.5.3 字典嵌套在字典中
                                                                                                                                                                                                        • 5.6 字典推导式
                                                                                                                                                                                                          • 5.6.1 循环模式
                                                                                                                                                                                                            • 5.6.2 筛选模式
                                                                                                                                                                                                            • 5.7 字典应用实例
                                                                                                                                                                                                              • 5.7.1 字典的逆向查找
                                                                                                                                                                                                                • 5.7.2 选举计票系统
                                                                                                                                                                                                                  • 5.7.3 词频统计
                                                                                                                                                                                                                    • 5.7.4 统计出现相同次数的单词
                                                                                                                                                                                                                    • 5.8 创建集合
                                                                                                                                                                                                                      • 5.8.1 集合的基本概念
                                                                                                                                                                                                                        • 5.8.2 集合的特性
                                                                                                                                                                                                                          • 5.8.3 直接创建集合
                                                                                                                                                                                                                            • 5.8.4 使用内置函数set()创建集合
                                                                                                                                                                                                                            • 5.9 集合运算
                                                                                                                                                                                                                              • 5.9.1 集合的innot in运算符
                                                                                                                                                                                                                                • 5.9.2 集合的并、交、差、对称差运算
                                                                                                                                                                                                                                • 5.10 集合的其他常用操作
                                                                                                                                                                                                                                  • 5.10.1 遍历集合
                                                                                                                                                                                                                                    • 5.10.2 编辑集合
                                                                                                                                                                                                                                    • 5.11 集合推导式
                                                                                                                                                                                                                                      • 5.12 集合应用实例
                                                                                                                                                                                                                                        • 5.13 常见异常类型
                                                                                                                                                                                                                                          • 5.13.1 字典中常见的键异常
                                                                                                                                                                                                                                            • 5.13.2 集合和字典中常见的类型异常
                                                                                                                                                                                                                                            • 5.14 知识点汇总
                                                                                                                                                                                                                                              • 5.15 习题
                                                                                                                                                                                                                                              • 第6章 函数与模块
                                                                                                                                                                                                                                                • 6.1 函数的定义
                                                                                                                                                                                                                                                  • 6.1.1 函数的应用场景
                                                                                                                                                                                                                                                    • 6.1.2 函数的定义与调用
                                                                                                                                                                                                                                                    • 6.2 函数的参数
                                                                                                                                                                                                                                                      • 6.2.1 位置参数
                                                                                                                                                                                                                                                        • 6.2.2 默认参数
                                                                                                                                                                                                                                                          • 6.2.3 可变参数
                                                                                                                                                                                                                                                            • 6.2.4 关键字参数
                                                                                                                                                                                                                                                              • 6.2.5 命名关键字参数
                                                                                                                                                                                                                                                              • 6.3 函数的返回值
                                                                                                                                                                                                                                                                • 6.3.1 简单返回值
                                                                                                                                                                                                                                                                  • 6.3.2 多返回语句
                                                                                                                                                                                                                                                                    • 6.3.3 返回值的类型和数量
                                                                                                                                                                                                                                                                    • 6.4 局部变量与全局变量
                                                                                                                                                                                                                                                                      • 6.4.1 局部变量
                                                                                                                                                                                                                                                                        • 6.4.2 全局变量
                                                                                                                                                                                                                                                                        • 6.5 模块
                                                                                                                                                                                                                                                                          • 6.5.1 模块的导入
                                                                                                                                                                                                                                                                            • 6.5.2 模块的创建
                                                                                                                                                                                                                                                                            • 6.6 函数与模块应用实例
                                                                                                                                                                                                                                                                              • 6.7 常见异常类型
                                                                                                                                                                                                                                                                                • 6.7.1 缩进异常
                                                                                                                                                                                                                                                                                  • 6.7.2 类型异常
                                                                                                                                                                                                                                                                                    • 6.7.3 命名异常
                                                                                                                                                                                                                                                                                      • 6.7.4 其他异常
                                                                                                                                                                                                                                                                                      • 6.8 知识点汇总
                                                                                                                                                                                                                                                                                        • 6.9 习题
                                                                                                                                                                                                                                                                                        • 第7章 文件的基本操作
                                                                                                                                                                                                                                                                                          • 7.1 文件的基本概念
                                                                                                                                                                                                                                                                                            • 7.1.1 文件系统的结构
                                                                                                                                                                                                                                                                                              • 7.1.2 文件的编码
                                                                                                                                                                                                                                                                                                • 7.1.3 文件对象
                                                                                                                                                                                                                                                                                                • 7.2 文件的读写
                                                                                                                                                                                                                                                                                                  • 7.2.1 文件的打开与关闭
                                                                                                                                                                                                                                                                                                    • 7.2.2 读文件
                                                                                                                                                                                                                                                                                                      • 7.2.3 写文件
                                                                                                                                                                                                                                                                                                        • 7.2.4 追加文件
                                                                                                                                                                                                                                                                                                          • 7.2.5 读写多个文件
                                                                                                                                                                                                                                                                                                            • 7.2.6 应用实例
                                                                                                                                                                                                                                                                                                              • 7.2.7 读写JSON文件
                                                                                                                                                                                                                                                                                                                • 7.2.8 读写CSV文件
                                                                                                                                                                                                                                                                                                                • 7.3 os模块
                                                                                                                                                                                                                                                                                                                  • 7.3.1 os模块方法
                                                                                                                                                                                                                                                                                                                    • 7.3.2 os.path模块方法
                                                                                                                                                                                                                                                                                                                    • 7.4 文件应用实例
                                                                                                                                                                                                                                                                                                                      • 7.5 常见异常类型
                                                                                                                                                                                                                                                                                                                        • 7.5.1 文件异常
                                                                                                                                                                                                                                                                                                                          • 7.5.2 目录异常
                                                                                                                                                                                                                                                                                                                          • 7.6 知识点汇总
                                                                                                                                                                                                                                                                                                                            • 7.7 习题
                                                                                                                                                                                                                                                                                                                            • 参考文献

                                                                                                                                                                                                                                                                                                                            相关图书