顶部
收藏

基于计算思维的Python编程案例教程


作者:
李维仙 主编 郝晓军 李春伟 李国锋 李海健 马康 王怀军 吴欣明 张娟 编著
定价:
48.00 元
版面字数:
460.00千字
开本:
16开
装帧形式:
平装
页数:
300
最新
印次时间:
2026年08月
ISBN:
978-7-04-066844-5
物料号:
66844-00
出版时间:
2026-08-14
读者对象:
高等教育
一级分类:
计算机/教育技术类
二级分类:
计算机基础课程
三级分类:
程序设计技术

本教材以计算思维培养为核心、Python编程为工具,构建“基础-能力-创新”三位一体体系。本书分为3部分15章,先通过第1章计算思维导论阐述计算思维与程序设计基础,随后分三部分展开:第1部分讲解Python基础,涵盖语言特性、环境配置、语法规则及面向对象编程等内容;第2部分通过Turtle绘图、数据可视化等案例训练计算思维;第3部分聚焦企业级应用,实践计算思维的工程化。

本书内容丰富,结构循序渐进,以案例为驱动,融入育人元素与AI技术,注重实践与创新能力的培养,并配套丰富的教学资源。

本书适用读者范围广泛,包括高等学校和职业院校相关专业学生,也适用于软件工程师、程序员及Python编程自学者。

  • 目录
    • 前辅文
      • 第1章 计算思维导论
        • 案例导入
          • 1.1 计算思维概述
            • 1.1.1 计算思维的定义
              • 1.1.2 计算思维解决问题的步骤
                • 1.1.3 计算思维的本质
                  • 1.1.4 计算思维的特征
                  • 1.2 程序设计概述
                    • 1.2.1 程序设计的定义
                      • 1.2.2 程序设计的基本元素
                        • 1.2.3 程序设计的流程
                          • 1.2.4 程序设计的重要性
                          • 案例实现:AI辅助
                            • 习题
                            • 第1部分 Python程序设计基础篇
                              • 第2章 Python简介
                                • 案例导入
                                  • 2.1 计算机程序设计语言的发展历史
                                    • 2.2 Python语言
                                      • 2.2.1 Python的发展历程
                                        • 2.2.2 Python的特点
                                          • 2.2.3 Python的标准库
                                            • 2.2.4 Python的应用领域
                                            • 2.3 安装和配置Python环境
                                              • 2.3.1 Python开发环境下载
                                                • 2.3.2 Python开发环境安装
                                                • 2.4 Python开发工具
                                                  • 2.4.1 IDLE的简单使用
                                                    • 2.4.2 Python的常见开发工具
                                                    • 2.5 Python的编码规范
                                                      • 2.5.1 缩进
                                                        • 2.5.2 注释
                                                        • 案例实现
                                                          • 习题
                                                          • 第3章 Python基础知识
                                                            • 案例导入1
                                                              • 3.1 变量
                                                                • 3.1.1 变量的命名
                                                                  • 3.1.2 变量的数据类型
                                                                    • 3.1.3 变量的数据赋值
                                                                    • 3.2 表达式
                                                                      • 3.2.1 运算符
                                                                        • 3.2.2 运算符的优先级
                                                                        • 3.3 输入输出
                                                                          • 3.3.1 输入
                                                                            • 3.3.2 输出
                                                                            • 案例实现1
                                                                              • 案例导入2
                                                                                • 3.4 预备知识:Turtle库趣味应用
                                                                                  • 3.4.1 Turtle库简介
                                                                                    • 3.4.2 Turtle库的常用函数
                                                                                    • 案例实现2
                                                                                      • 习题
                                                                                      • 第4章 选择和循环
                                                                                        • 案例导入1
                                                                                          • 4.1 条件表达式
                                                                                            • 4.2 选择结构
                                                                                              • 4.2.1 单分支if语句
                                                                                                • 4.2.2 双分支if-else语句
                                                                                                  • 4.2.3 多分支if-elif-else语句
                                                                                                    • 4.2.4 选择结构的嵌套
                                                                                                    • 案例实现1
                                                                                                      • 案例导入2
                                                                                                        • 4.3 循环结构
                                                                                                          • 4.3.1 while语句
                                                                                                            • 4.3.2 for语句
                                                                                                            • 4.4 循环的嵌套
                                                                                                              • 4.5 break语句和continue语句
                                                                                                                • 案例实现2
                                                                                                                  • 习题
                                                                                                                  • 第5章 组合数据类型
                                                                                                                    • 案例导入1
                                                                                                                      • 5.1 组合数据类型概述
                                                                                                                        • 5.2 Python组合数据类型——序列
                                                                                                                          • 5.2.1 序列索引
                                                                                                                            • 5.2.2 序列分片
                                                                                                                              • 5.2.3 序列的相加和相乘
                                                                                                                                • 5.2.4 序列长度、最大值和最小值
                                                                                                                                  • 5.2.5 序列成员运算符(in和not in)
                                                                                                                                    • 5.2.6 序列count()和index()方法
                                                                                                                                      • 5.2.7 序列遍历
                                                                                                                                      • 案例实现1
                                                                                                                                        • 5.3 Python字符串
                                                                                                                                          • 5.3.1 基础操作方法
                                                                                                                                            • 5.3.2 搜索与替换
                                                                                                                                              • 5.3.3 格式化与转换
                                                                                                                                                • 5.3.4 验证与判断
                                                                                                                                                  • 5.3.5 高级方法
                                                                                                                                                  • 5.4 Python列表
                                                                                                                                                    • 5.4.1 列表本质
                                                                                                                                                      • 5.4.2 列表的创建与初始化
                                                                                                                                                        • 5.4.3 列表元素的访问和修改
                                                                                                                                                        • 5.5 Python元组
                                                                                                                                                          • 5.5.1 创建和访问元组
                                                                                                                                                            • 5.5.2 删除整个元组
                                                                                                                                                              • 5.5.3 元组应用场景
                                                                                                                                                              • 案例导入2
                                                                                                                                                                • 5.6 Python组合数据类型——字典
                                                                                                                                                                  • 5.6.1 创建字典
                                                                                                                                                                    • 5.6.2 访问字典
                                                                                                                                                                      • 5.6.3 修改、添加和删除字典元素
                                                                                                                                                                        • 5.6.4 字典遍历
                                                                                                                                                                        • 案例实现2
                                                                                                                                                                          • 案例导入3
                                                                                                                                                                            • 5.6.5 字典嵌套
                                                                                                                                                                            • 案例实现3
                                                                                                                                                                              • 5.7 Python组合数据类型——集合
                                                                                                                                                                                • 5.7.1 集合的概念
                                                                                                                                                                                  • 5.7.2 集合的创建
                                                                                                                                                                                    • 5.7.3 集合的基本操作
                                                                                                                                                                                      • 5.7.4 集合的运算符
                                                                                                                                                                                        • 5.7.5 典型案例
                                                                                                                                                                                        • 习题
                                                                                                                                                                                        • 第6章 函数的设计和使用
                                                                                                                                                                                          • 案例导入1
                                                                                                                                                                                            • 6.1 函数的定义与使用
                                                                                                                                                                                              • 6.1.1 函数的定义
                                                                                                                                                                                                • 6.1.2 函数的调用
                                                                                                                                                                                                  • 6.1.3 函数的返回值
                                                                                                                                                                                                  • 6.2 函数的参数
                                                                                                                                                                                                    • 6.2.1 形参和实参
                                                                                                                                                                                                      • 6.2.2 参数类型
                                                                                                                                                                                                      • 6.3 函数的嵌套
                                                                                                                                                                                                        • 案例实现1
                                                                                                                                                                                                          • 案例导入2
                                                                                                                                                                                                            • 6.4 变量的作用域
                                                                                                                                                                                                              • 6.4.1 局部变量和全局变量
                                                                                                                                                                                                                • 6.4.2 global关键字和nonlocal关键字
                                                                                                                                                                                                                • 6.5 匿名函数
                                                                                                                                                                                                                  • 6.6 递归
                                                                                                                                                                                                                    • 案例实现2
                                                                                                                                                                                                                      • 案例导入3
                                                                                                                                                                                                                        • 6.7 模块
                                                                                                                                                                                                                          • 6.7.1 模块的导入
                                                                                                                                                                                                                            • 6.7.2 自定义模块
                                                                                                                                                                                                                            • 6.8 异常处理
                                                                                                                                                                                                                              • 案例实现1 代码优化
                                                                                                                                                                                                                                • 案例实现3
                                                                                                                                                                                                                                  • 习题
                                                                                                                                                                                                                                  • 第7章 文件操作
                                                                                                                                                                                                                                    • 案例导入1
                                                                                                                                                                                                                                      • 7.1 文件的创建和打开
                                                                                                                                                                                                                                        • 7.1.1 文件的打开
                                                                                                                                                                                                                                          • 7.1.2 文件的新建
                                                                                                                                                                                                                                          • 7.2 文件的写入
                                                                                                                                                                                                                                            • 7.2.1 写入字符串
                                                                                                                                                                                                                                              • 7.2.2 写入多个字符串
                                                                                                                                                                                                                                              • 7.3 文件夹的创建
                                                                                                                                                                                                                                                • 7.3.1 新建文件夹
                                                                                                                                                                                                                                                  • 7.3.2 使用绝对路径创建文件夹
                                                                                                                                                                                                                                                    • 7.3.3 创建多个文件夹
                                                                                                                                                                                                                                                      • 7.3.4 查看文件夹里所有文件夹和文件
                                                                                                                                                                                                                                                      • 案例实现1
                                                                                                                                                                                                                                                        • 案例导入2
                                                                                                                                                                                                                                                          • 7.4 文件的读取
                                                                                                                                                                                                                                                            • 7.4.1 读取全文或前n个字节
                                                                                                                                                                                                                                                              • 7.4.2 按顺序读取行
                                                                                                                                                                                                                                                                • 7.4.3 读取指定行
                                                                                                                                                                                                                                                                • 7.5 读取文件名
                                                                                                                                                                                                                                                                  • 7.5.1 读取文件名
                                                                                                                                                                                                                                                                    • 7.5.2 读取文件扩展名
                                                                                                                                                                                                                                                                    • 案例实现2
                                                                                                                                                                                                                                                                      • 习题
                                                                                                                                                                                                                                                                      • 第8章 面向对象程序设计
                                                                                                                                                                                                                                                                        • 案例导入1
                                                                                                                                                                                                                                                                          • 8.1 面向对象程序设计导论
                                                                                                                                                                                                                                                                            • 8.2 类的定义和使用
                                                                                                                                                                                                                                                                              • 8.2.1 类的定义
                                                                                                                                                                                                                                                                                • 8.2.2 创建类的对象
                                                                                                                                                                                                                                                                                  • 8.2.3 self参数
                                                                                                                                                                                                                                                                                    • 8.2.4 构造方法
                                                                                                                                                                                                                                                                                      • 8.2.5 析构方法
                                                                                                                                                                                                                                                                                        • 8.2.6 类成员和实例成员
                                                                                                                                                                                                                                                                                        • 案例实现1
                                                                                                                                                                                                                                                                                          • 案例导入2
                                                                                                                                                                                                                                                                                            • 8.3 封装
                                                                                                                                                                                                                                                                                              • 8.4 继承
                                                                                                                                                                                                                                                                                                • 8.4.1 单继承
                                                                                                                                                                                                                                                                                                  • 8.4.2 多继承
                                                                                                                                                                                                                                                                                                    • 8.4.3 重写
                                                                                                                                                                                                                                                                                                    • 8.5 多态
                                                                                                                                                                                                                                                                                                      • 案例实现2
                                                                                                                                                                                                                                                                                                        • 习题
                                                                                                                                                                                                                                                                                                      • 第2部分 计算思维能力训练篇
                                                                                                                                                                                                                                                                                                        • 第9章 计算思维中的分解抽象与常见计算
                                                                                                                                                                                                                                                                                                          • 模式简述
                                                                                                                                                                                                                                                                                                            • 9.1 解析问题中的公式模式
                                                                                                                                                                                                                                                                                                              • 9.1.1 解析问题的基本概念
                                                                                                                                                                                                                                                                                                                • 9.1.2 解析问题的求解框架
                                                                                                                                                                                                                                                                                                                • 9.2 递推模式
                                                                                                                                                                                                                                                                                                                  • 9.2.1 递推模式基本概念
                                                                                                                                                                                                                                                                                                                    • 9.2.2 递推模式的求解框架
                                                                                                                                                                                                                                                                                                                    • 9.3 穷举模式
                                                                                                                                                                                                                                                                                                                      • 9.3.1 穷举模式的基本概念
                                                                                                                                                                                                                                                                                                                        • 9.3.2 穷举模式的求解框架
                                                                                                                                                                                                                                                                                                                        • 9.4 分治法模式
                                                                                                                                                                                                                                                                                                                          • 9.4.1 分治法的基本概念
                                                                                                                                                                                                                                                                                                                            • 9.4.2 分治法模式的求解框架
                                                                                                                                                                                                                                                                                                                          • 第10章 Turtle编程·绘制太极图
                                                                                                                                                                                                                                                                                                                            • 综合案例导入
                                                                                                                                                                                                                                                                                                                              • 10.1 关于太极图
                                                                                                                                                                                                                                                                                                                                • 10.1.1 太极图的历史渊源与演变
                                                                                                                                                                                                                                                                                                                                  • 10.1.2 太极图的哲学内涵与象征意义
                                                                                                                                                                                                                                                                                                                                    • 10.1.3 太极图的当代价值与启示
                                                                                                                                                                                                                                                                                                                                    • 10.2 计算思维步骤分解
                                                                                                                                                                                                                                                                                                                                      • 10.2.1 问题分解
                                                                                                                                                                                                                                                                                                                                        • 10.2.2 模式识别
                                                                                                                                                                                                                                                                                                                                          • 10.2.3 抽象
                                                                                                                                                                                                                                                                                                                                            • 10.2.4 算法设计
                                                                                                                                                                                                                                                                                                                                            • 10.3 完整代码实现过程
                                                                                                                                                                                                                                                                                                                                              • 10.4 优化与创新
                                                                                                                                                                                                                                                                                                                                              • 第11章 Turtle编程·绘制彩虹桥
                                                                                                                                                                                                                                                                                                                                                • 综合案例导入
                                                                                                                                                                                                                                                                                                                                                  • 11.1 关于彩虹
                                                                                                                                                                                                                                                                                                                                                    • 11.2 计算思维步骤分解
                                                                                                                                                                                                                                                                                                                                                      • 11.2.1 问题分解:化繁为简的步骤
                                                                                                                                                                                                                                                                                                                                                        • 11.2.2 模式识别:寻找重复与规律
                                                                                                                                                                                                                                                                                                                                                          • 11.2.3 抽象:提炼本质,屏蔽细节
                                                                                                                                                                                                                                                                                                                                                            • 11.2.4 算法设计:构建解决问题的步骤
                                                                                                                                                                                                                                                                                                                                                            • 11.3 完整代码实现过程
                                                                                                                                                                                                                                                                                                                                                              • 11.4 优化与创新
                                                                                                                                                                                                                                                                                                                                                              • 第12章 Matplotlib数据可视化编程
                                                                                                                                                                                                                                                                                                                                                                • 综合案例导入
                                                                                                                                                                                                                                                                                                                                                                  • 12.1 Matplotlib的导入和绘图步骤
                                                                                                                                                                                                                                                                                                                                                                    • 12.1.1 安装、导入Matplotlib
                                                                                                                                                                                                                                                                                                                                                                      • 12.1.2 Matplotlib绘图步骤
                                                                                                                                                                                                                                                                                                                                                                      • 12.2 案例讲解
                                                                                                                                                                                                                                                                                                                                                                        • 12.2.1 从文件导入数据
                                                                                                                                                                                                                                                                                                                                                                          • 12.2.2 提取数据列
                                                                                                                                                                                                                                                                                                                                                                            • 12.2.3 基础图表绘制
                                                                                                                                                                                                                                                                                                                                                                            • 12.3 计算思维步骤分解
                                                                                                                                                                                                                                                                                                                                                                              • 12.3.1 问题分解
                                                                                                                                                                                                                                                                                                                                                                                • 12.3.2 模式识别
                                                                                                                                                                                                                                                                                                                                                                                  • 12.3.3 抽象
                                                                                                                                                                                                                                                                                                                                                                                    • 12.3.4 算法设计
                                                                                                                                                                                                                                                                                                                                                                                    • 12.4 完整代码实现过程
                                                                                                                                                                                                                                                                                                                                                                                      • 12.5 优化与创新
                                                                                                                                                                                                                                                                                                                                                                                      • 第13章 GUI编程·科学计算器设计开发
                                                                                                                                                                                                                                                                                                                                                                                        • 综合案例导入
                                                                                                                                                                                                                                                                                                                                                                                          • 13.1 GUI编程——tkinter
                                                                                                                                                                                                                                                                                                                                                                                            • 13.1.1 tkinter简介
                                                                                                                                                                                                                                                                                                                                                                                              • 13.1.2 tkinter常用控件
                                                                                                                                                                                                                                                                                                                                                                                              • 13.2 计算思维步骤分解
                                                                                                                                                                                                                                                                                                                                                                                                • 13.2.1 需求分析与问题分解
                                                                                                                                                                                                                                                                                                                                                                                                  • 13.2.2 抽象问题与算法设计
                                                                                                                                                                                                                                                                                                                                                                                                  • 13.3 模块代码实现
                                                                                                                                                                                                                                                                                                                                                                                                    • 13.4 完整代码实现过程
                                                                                                                                                                                                                                                                                                                                                                                                      • 13.5 优化与创新
                                                                                                                                                                                                                                                                                                                                                                                                      • 第14章 Pygame编程·汉诺塔游戏
                                                                                                                                                                                                                                                                                                                                                                                                        • 综合案例导入
                                                                                                                                                                                                                                                                                                                                                                                                          • 14.1 游戏开发模块——Pygame
                                                                                                                                                                                                                                                                                                                                                                                                            • 14.1.1 Pygame简介
                                                                                                                                                                                                                                                                                                                                                                                                              • 14.1.2 Pygame常用功能
                                                                                                                                                                                                                                                                                                                                                                                                              • 14.2 关于汉诺塔
                                                                                                                                                                                                                                                                                                                                                                                                                • 14.3 计算思维步骤分解
                                                                                                                                                                                                                                                                                                                                                                                                                  • 14.3.1 问题分解
                                                                                                                                                                                                                                                                                                                                                                                                                    • 14.3.2 模式识别
                                                                                                                                                                                                                                                                                                                                                                                                                      • 14.3.3 算法设计
                                                                                                                                                                                                                                                                                                                                                                                                                      • 14.4 完整代码实现过程
                                                                                                                                                                                                                                                                                                                                                                                                                        • 14.5 优化与创新
                                                                                                                                                                                                                                                                                                                                                                                                                      • 第3部分 Python应用创新篇
                                                                                                                                                                                                                                                                                                                                                                                                                        • 第15章 企业级应用:计算思维的工程化实践
                                                                                                                                                                                                                                                                                                                                                                                                                          • 15.1 软件工程中的计算思维范式
                                                                                                                                                                                                                                                                                                                                                                                                                            • 15.1.1 高复用性设计
                                                                                                                                                                                                                                                                                                                                                                                                                              • 15.1.2 高扩展性实现
                                                                                                                                                                                                                                                                                                                                                                                                                                • 15.1.3 低维护性保障
                                                                                                                                                                                                                                                                                                                                                                                                                                  • 15.1.4 类设计边界控制
                                                                                                                                                                                                                                                                                                                                                                                                                                    • 15.1.5 容器化架构实践
                                                                                                                                                                                                                                                                                                                                                                                                                                      • 15.1.6 组合式开发范式
                                                                                                                                                                                                                                                                                                                                                                                                                                      • 15.2 智能助教机器人(IAR)背景介绍
                                                                                                                                                                                                                                                                                                                                                                                                                                        • 15.3 计算思维的业务场景化实现
                                                                                                                                                                                                                                                                                                                                                                                                                                          • 15.3.1 动态调查问卷系统
                                                                                                                                                                                                                                                                                                                                                                                                                                            • 15.3.2 自适应视频教学系统
                                                                                                                                                                                                                                                                                                                                                                                                                                              • 15.3.3 社交化学习系统
                                                                                                                                                                                                                                                                                                                                                                                                                                                • 15.3.4 智能评测系统

                                                                                                                                                                                                                                                                                                                                                                                                                                          相关图书