顶部
收藏

程序设计思想与方法——问题求解中的计算思维


作者:
陆朝俊
定价:
38.00 元
版面字数:
510千字
开本:
16开
装帧形式:
平装
版次:
1
最新版次
印刷时间:
2019年
ISBN:
978-7-04-038569-4
物料号:
38569-00
出版时间:
2013-11-06
读者对象:
高等教育
一级分类:
计算机/教育技术类
二级分类:
计算机基础课程
三级分类:
程序设计技术

当前高等学校计算机基础教学的一个改革和发展方向是将“计算思维”作为程序设计课程主线,让学生学会如何像计算机科学家那样思考并解决问题,这与传统的以一门编程语言为课程核心的做法是完全不同的。

本书是作者参与教育部大学计算机课程改革项目而形成的产物,全书以问题求解中的计算思维为线索,介绍一般的程序设计思想与方法。具体内容包括:信息和信息处理过程的表示,处理流程的结构化和模块化设计方法,从面向过程方法到面向对象方法的发展,图形和GUI 编程,事件驱动编程和并发编程,蒙特卡罗模拟方法设计等。要强调的是,以上所有思想和方法都是通过生动的实例演示而非枯燥的原理灌输而展开介绍的。虽然本书不是关于编程语言的教材,但是通过本书的学习,学生可以掌握简单而强大的Python 语言,能够利用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 计算思维对其他学科的影响
                        • 1.3 初识Python
                          • 1.3.1 Python 简介
                            • 1.3.2 第一个程序
                              • 1.3.3 程序的执行方式
                                • 1.3.4 Python 语言的基本成分
                                • 1.4 程序排错
                                  • 习题
                                  • 第2 章 用数据表示现实世界
                                    • 2.1 数据和数据类型
                                      • 2.1.1 数据是对现实的抽象
                                        • 2.1.2 常量与变量
                                          • 2.1.3 数据类型
                                            • *2.1.4 Python 的动态类型
                                            • 2.2 数值类型
                                              • 2.2.1 整数类型int
                                                • 2.2.2 长整数类型long
                                                  • 2.2.3 浮点数类型float
                                                    • 2.2.4 数学库模块math
                                                      • *2.2.5 复数类型complex
                                                      • 2.3 字符串类型str
                                                        • 2.3.1 字符串类型的字面值形式
                                                          • 2.3.2 字符串类型的操作
                                                            • 2.3.3 字符的机内表示
                                                              • 2.3.4 字符串类型与其他类型的转换
                                                                • 2.3.5 字符串库string
                                                                • 2.4 布尔类型bool
                                                                  • 2.4.1 关系运算
                                                                    • 2.4.2 逻辑运算
                                                                      • *2.4.3 布尔代数运算定律
                                                                        • *2.4.4 Python 中真假的表示与计算
                                                                        • 2.5 列表和元组类型
                                                                          • 2.5.1 列表类型list
                                                                            • 2.5.2 元组类型tuple
                                                                            • 2.6 数据的输入和输出
                                                                              • 2.6.1 数据的输入
                                                                                • 2.6.2 数据的输出
                                                                                  • 2.6.3 格式化输出
                                                                                  • 2.7 编程案例:查找问题
                                                                                    • 习题
                                                                                    • 第3 章 数据处理的流程控制
                                                                                      • 3.1 顺序控制结构
                                                                                        • 3.2 分支控制结构
                                                                                          • 3.2.1 单分支结构
                                                                                            • 3.2.2 两路分支结构
                                                                                              • 3.2.3 多路分支结构
                                                                                              • 3.3 异常处理
                                                                                                • 3.3.1 传统的错误检测方法
                                                                                                  • 3.3.2 传统错误检测方法的缺点
                                                                                                    • 3.3.3 异常处理机制
                                                                                                    • 3.4 循环控制结构
                                                                                                      • 3.4.1 for 循环
                                                                                                        • 3.4.2 while 循环
                                                                                                          • 3.4.3 循环的非正常中断
                                                                                                            • 3.4.4 嵌套循环
                                                                                                            • 3.5 结构化程序设计
                                                                                                              • 3.5.1 程序开发过程
                                                                                                                • 3.5.2 结构化程序设计的基本内容
                                                                                                                • 3.6 编程案例:如何求n 个数据的最大值
                                                                                                                  • 3.6.1 几种解题策略
                                                                                                                    • 3.6.2 经验总结
                                                                                                                    • *3.7 Python 布尔表达式用作控制结构
                                                                                                                      • 习题
                                                                                                                      • 第4 章 模块化编程
                                                                                                                        • 4.1 模块化编程基本概念
                                                                                                                          • 4.1.1 模块化设计概述
                                                                                                                            • 4.1.2 模块化编程
                                                                                                                              • 4.1.3 编程语言对模块化编程的支持
                                                                                                                              • 4.2 Python 语言中的函数
                                                                                                                                • 4.2.1 用函数减少重复代码
                                                                                                                                  • 4.2.2 用函数改善程序结构
                                                                                                                                    • 4.2.3 用函数增强程序的通用性
                                                                                                                                      • 4.2.4 小结:函数的定义与调用
                                                                                                                                        • 4.2.5 变量的作用域
                                                                                                                                          • 4.2.6 函数的返回值
                                                                                                                                          • 4.3 自顶向下设计
                                                                                                                                            • 4.3.1 顶层设计
                                                                                                                                              • 4.3.2 第二层设计
                                                                                                                                                • 4.3.3 第三层设计
                                                                                                                                                  • 4.3.4 第四层设计
                                                                                                                                                    • 4.3.5 自底向上实现与单元测试
                                                                                                                                                      • 4.3.6 开发过程小结
                                                                                                                                                      • *4.4 Python 模块
                                                                                                                                                        • 4.4.1 模块的创建和使用
                                                                                                                                                          • 4.4.2 Python 程序架构
                                                                                                                                                            • 4.4.3 标准库模块
                                                                                                                                                              • 4.4.4 模块的有条件执行
                                                                                                                                                              • 习题
                                                                                                                                                              • 第5 章 图形编程
                                                                                                                                                                • 5.1 概述
                                                                                                                                                                  • 5.1.1 计算可视化
                                                                                                                                                                    • 5.1.2 图形是复杂数据
                                                                                                                                                                      • 5.1.3 用对象表示复杂数据
                                                                                                                                                                      • 5.2 Tkinter 图形编程
                                                                                                                                                                        • 5.2.1 导入模块及创建根窗口
                                                                                                                                                                          • 5.2.2 创建画布
                                                                                                                                                                            • 5.2.3 在画布上绘图
                                                                                                                                                                              • 5.2.4 图形的事件处理
                                                                                                                                                                              • 5.3 编程案例
                                                                                                                                                                                • 5.3.1 统计图表
                                                                                                                                                                                  • 5.3.2 计算机动画
                                                                                                                                                                                  • 5.4 软件的层次化设计:一个案例
                                                                                                                                                                                    • 5.4.1 层次化体系结构
                                                                                                                                                                                      • 5.4.2 案例:图形库graphics
                                                                                                                                                                                        • 5.4.3 graphics 与面向对象
                                                                                                                                                                                        • 习题
                                                                                                                                                                                        • 第6 章 大量数据的表示和处理
                                                                                                                                                                                          • 6.1 概述
                                                                                                                                                                                            • 6.2 有序的数据集合体
                                                                                                                                                                                              • 6.2.1 字符串
                                                                                                                                                                                                • 6.2.2 列表
                                                                                                                                                                                                  • 6.2.3 元组
                                                                                                                                                                                                  • 6.3 无序的数据集合体
                                                                                                                                                                                                    • 6.3.1 集合
                                                                                                                                                                                                      • 6.3.2 字典
                                                                                                                                                                                                      • 6.4 文件
                                                                                                                                                                                                        • 6.4.1 文件的基本概念
                                                                                                                                                                                                          • 6.4.2 文件操作
                                                                                                                                                                                                            • 6.4.3 编程案例:文本文件分析
                                                                                                                                                                                                              • 6.4.4 缓冲
                                                                                                                                                                                                                • *6.4.5 二进制文件与随机存取
                                                                                                                                                                                                                • *6.5 几种高级数据结构
                                                                                                                                                                                                                  • 6.5.1 链表
                                                                                                                                                                                                                    • 6.5.2 堆栈
                                                                                                                                                                                                                      • 6.5.3 队列
                                                                                                                                                                                                                      • 习题
                                                                                                                                                                                                                      • 第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.3 超类与子类
                                                                                                                                                                                                                                            • 7.3.1 继承
                                                                                                                                                                                                                                              • 7.3.2 覆写
                                                                                                                                                                                                                                                • 7.3.3 多态性
                                                                                                                                                                                                                                                • *7.4 面向对象设计
                                                                                                                                                                                                                                                  • 7.4.1 一种基于词性分析的面向对象设计方法
                                                                                                                                                                                                                                                    • 7.4.2 设计案例:扑克牌游戏
                                                                                                                                                                                                                                                    • 习题
                                                                                                                                                                                                                                                    • 第8 章 图形用户界面
                                                                                                                                                                                                                                                      • 8.1 图形用户界面概述
                                                                                                                                                                                                                                                        • 8.1.1 程序的用户界面
                                                                                                                                                                                                                                                          • 8.1.2 图形界面的组成
                                                                                                                                                                                                                                                            • 8.1.3 事件驱动
                                                                                                                                                                                                                                                            • 8.2 GUI 编程
                                                                                                                                                                                                                                                              • 8.2.1 GUI 编程概述
                                                                                                                                                                                                                                                                • 8.2.2 初识Tkinter
                                                                                                                                                                                                                                                                  • 8.2.3 常见GUI 构件的用法
                                                                                                                                                                                                                                                                    • 8.2.4 布局
                                                                                                                                                                                                                                                                      • *8.2.5 对话框
                                                                                                                                                                                                                                                                      • 8.3 Tkinter 事件驱动编程
                                                                                                                                                                                                                                                                        • 8.3.1 事件和事件对象
                                                                                                                                                                                                                                                                          • 8.3.2 事件处理
                                                                                                                                                                                                                                                                          • 8.4 模型-视图设计方法
                                                                                                                                                                                                                                                                            • 8.4.1 将GUI 应用程序封装成对象
                                                                                                                                                                                                                                                                              • 8.4.2 模型与视图
                                                                                                                                                                                                                                                                                • 8.4.3 编程案例:汇率换算器
                                                                                                                                                                                                                                                                                • 习题
                                                                                                                                                                                                                                                                                • 第9 章 模拟与并发
                                                                                                                                                                                                                                                                                  • 9.1 模拟
                                                                                                                                                                                                                                                                                    • 9.1.1 计算机建模
                                                                                                                                                                                                                                                                                      • 9.1.2 随机问题的建模与模拟
                                                                                                                                                                                                                                                                                        • 9.1.3 编程案例:乒乓球比赛模拟
                                                                                                                                                                                                                                                                                        • 9.2 原型法
                                                                                                                                                                                                                                                                                          • *9.3 并行计算
                                                                                                                                                                                                                                                                                            • 9.3.1 串行、并发与并行
                                                                                                                                                                                                                                                                                              • 9.3.2 进程与线程
                                                                                                                                                                                                                                                                                                • 9.3.3 多线程编程的应用
                                                                                                                                                                                                                                                                                                  • 9.3.4 Python 多线程编程
                                                                                                                                                                                                                                                                                                    • 9.3.5 小结
                                                                                                                                                                                                                                                                                                    • 习题
                                                                                                                                                                                                                                                                                                    • 第10 章 算法设计和分析
                                                                                                                                                                                                                                                                                                      • 10.1 枚举法
                                                                                                                                                                                                                                                                                                        • 10.2 递归
                                                                                                                                                                                                                                                                                                          • 10.3 分治法
                                                                                                                                                                                                                                                                                                            • 10.4 贪心法
                                                                                                                                                                                                                                                                                                              • 10.5 算法分析
                                                                                                                                                                                                                                                                                                                • 10.5.1 算法复杂度
                                                                                                                                                                                                                                                                                                                  • 10.5.2 算法分析实例
                                                                                                                                                                                                                                                                                                                  • 10.6 不可计算的问题
                                                                                                                                                                                                                                                                                                                    • 习题
                                                                                                                                                                                                                                                                                                                    • 第11 章 计算+X
                                                                                                                                                                                                                                                                                                                      • 11.1 计算数学
                                                                                                                                                                                                                                                                                                                        • 11.2 生物信息学
                                                                                                                                                                                                                                                                                                                          • 11.3 计算物理学
                                                                                                                                                                                                                                                                                                                            • 11.4 计算化学
                                                                                                                                                                                                                                                                                                                              • 11.5 计算经济学
                                                                                                                                                                                                                                                                                                                                • 习题
                                                                                                                                                                                                                                                                                                                                • 附录
                                                                                                                                                                                                                                                                                                                                  • 参考文献

                                                                                                                                                                                                                                                                                                                                  相关图书