当前位置:首页 > 课后答案 > 计算机科学课后习题答案
《计算机科学概论(英文第11版)》电子书封面

计算机科学概论(英文第11版)

  • 发布时间:2021年04月08日 08:58:56
  • 作者:J.Glenn.Brookshear
  • 出版:人民邮电出版社
  • 大小:68.1 MB
  • 类别:计算机科学资料
  • 格式:PDF
  • 评分:7.6

    计算机科学概论(英文第11版) 课后答案

      给大家带来的是关于计算机科学相关的课后习题答案,介绍了关于计算机科学、计算机概论方面的内容,本书是由人民邮电出版社出版,资源格式为PDF,大小68.1 MB,J.Glenn.Brookshear编写,目前高等院校计算机科学类教材综合评分为:8.8分

      Tags:计算机科学 计算机概论 

      《计算机科学概论(英文第11版)》内容介绍

      本书多年来一直深受世界各国高校师生的欢迎,是美国哈佛大学、麻省理工学院、普林斯顿大学、加州大学伯克利分校等许多著名大学的首选教材,对我国的高校教学也产生了广泛影响。

      本 书以历史眼光,从发展的角度、当前的水平以及现阶段的研究方向等几个方面,全景式描绘了计算机科学各个子学科的主要领域。在内容编排上,本书很好地兼顾了 学科广度和主题深度,把握了最新的技术趋势。本书用算法、数据抽象等核心思想贯穿各个主题,并且充分展现了历史背景、发展历程和新的技术趋势,培养读者的 大局观,为其今后深入学习其他计算机专业课程打下坚实的基础。

      本书深入浅出、图文并茂,内容引人入胜,极易引发读者的兴趣,绝无一般教材的枯燥和晦涩。此外,本书的教学手段多样、习题丰富,并且每章后都附有与本章内容相关的社会现实问题供读者思考和讨论,这些都很好地体现了作者强调培养学生分析问题能力的教学理念...

      目录

      • 第0 章 绪论   1
      • 0.1 算法的作用   1
      • 0.2 计算机器的由来   3
      • 0.3 算法的科学   7
      • 0.4 抽象  8
      • 0.5 学习大纲  8
      • 0.6 社会影响   9
      • 社会问题  11
      • 课外阅读  12
      • 第1 章 数据存储  13
      • 1.1 位和位存储  13
      • 1.1.1 布尔运算   13
      • 1.1.2 门和触发器   14
      • 1.1.3 十六进制记数法   17
      • 1.2 主存储器  18
      • 1.2.1 存储器结构   18
      • 1.2.2 存储器容量的度量   19
      • 1.3 海量存储器  20
      • 1.3.1 磁学系统   20
      • 1.3.2 光学系统   22
      • 1.3.3 闪存驱动器   23
      • 1.3.4 文件存储及检索   24
      • 1.4 用位模式表示信息   25
      • 1.4.1 文本的表示   25
      • 1.4.2 数值的表示   26
      • 1.4.3 图像的表示   27
      • 1.4.4 声音的表示   28
      • *1.5 二进制系统  29
      • 1.5.1 二进制记数法  29
      • 1.5.2 二进制加法   31
      • 1.5.3 二进制中的小数   32
      • *1.6 整数存储  33
      • 1.6.1 二进制补码记数法   33
      • 1.6.2 余码记数法   36
      • *1.7 小数的存储   37
      • 1.7.1 浮点记数法   37
      • 1.7.2 截断误差   39
      • *1.8 数据压缩   41
      • 1.8.1 通用的数据压缩技术   41
      • 1.8.2 图像压缩   43
      • 1.8.3 音频和视频压缩   44
      • *1.9 通信差错   45
      • 1.9.1 奇偶校验位   45
      • 1.9.2 纠错编码   46
      • 复习题  47
      • 社会问题  50
      • 课外阅读  51
      • 第2 章 数据操控  52
      • 2.1 计算机体系结构   52
      • 2.1.1 CPU基础知识  52
      • 2.1.2 存储程序概念  53
      • 2.2 机器语言   54
      • 2.2.1 指令系统   54
      • 2.2.2 一种演示用的机器语言   56
      • 2.3 程序执行   58
      • 2.3.1 程序执行的一个例子  60
      • 2.3.2 程序与数据   62
      • *2.4 算术/逻辑指令   63
      • 2.4.1 逻辑运算   63
      • 2.4.2 循环移位及移位运算   65
      • 2.4.3 算术运算   66
      • *2.5 与其他设备通信   67
      • 2.5.1 控制器的作用  67
      • 2.5.2 直接内存存取  68
      • 2.5.3 握手   69
      • 2.5.4 流行的通信媒介   69
      • 2.5.5 通信速率   70
      • *2.6 其他体系结构  70
      • 2.6.1 流水线   70
      • 2.6.2 多处理器计算机   71
      • 复习题  72
      • 社会问题   77
      • 课外阅读  77
      • 第3 章 操作系统  79
      • 3.1 操作系统的历史  79
      • 3.2 操作系统的体系结构  82
      • 3.2.1 软件概述  82
      • 3.2.2 操作系统组件  84
      • 3.2.3 系统启动  86
      • 3.3 协调机器的活动  88
      • 3.3.1 进程的概念  88
      • 3.3.2 进程管理  88
      • *3.4 处理进程间的竞争  90
      • 3.4.1 信号量  90
      • 3.4.2 死锁  91
      • 3.5 安全性  93
      • 3.5.1 来自机器外部的攻击  93
      • 3.5.2 来自机器内部的攻击  94
      • 复习题  95
      • 社会问题  98
      • 课外阅读  98
      • 第4 章 组网及因特网  99
      • 4.1 网络基础  99
      • 4.1.1 网络分类  99
      • 4.1.2 协议  100
      • 4.1.3 网络互连  102
      • 4.1.4 进程间通信的方法  104
      • 4.1.5 分布式系统   105
      • 4.2 因特网  106
      • 4.2.1 因特网体系结构  106
      • 4.2.2 因特网编址  108
      • 4.2.3 因特网应用  109
      • 4.3 万维网  113
      • 4.3.1 万维网实现  113
      • 4.3.2 HTML  114
      • 4.3.3 XML   117
      • 4.3.4 客户端和服务器端的活动  118
      • *4.4 因特网协议  119
      • 4.4.1 因特网软件的分层方法  119
      • 4.4.2 TCP/IP协议簇  122
      • 4.5 安全性  123
      • 4.5.1 入侵的形式  124
      • 4.5.2 防护和对策  125
      • 4.5.3 加密  126
      • 4.5.4 网络安全的法律途径  128
      • 复习题  130
      • 社会问题  131
      • 课外阅读  132
      • 第5 章 算法  134
      • 5.1 算法的概念  134
      • 5.1.1 概览  134
      • 5.1.2 算法的正式定义  135
      • 5.1.3 算法的抽象本质  136
      • 5.2 算法的表示  136
      • 5.2.1 原语  137
      • 5.2.2 伪代码  139
      • 5.3 算法的发现  142
      • 5.3.1 问题求解的艺术  142
      • 5.3.2 入门  144
      • 5.4 迭代结构  146
      • 5.4.1 顺序搜索法  147
      • 5.4.2 循环控制  148
      • 5.4.3 插入排序算法  151
      • 5.5 递归结构  154
      • 5.5.1 二分搜索算法  154
      • 5.5.2 递归控制  159
      • 5.6 有效性和正确性  160
      • 5.6.1 算法有效性  160
      • 5.6.2 软件验证  163
      • 复习题  167
      • 社会问题  171
      • 课外阅读  171
      • 第6 章 程序设计语言  172
      • 6.1 历史回顾  172
      • 6.1.1 早期程序设计语言  172
      • 6.1.2 独立并超越机器  174
      • 6.1.3 程序设计范型  175
      • 6.2 传统的程序设计概念  179
      • 6.2.1 变量和数据类型  180
      • 6.2.2 数据结构  181
      • 6.2.3 常量和字面量  182
      • 6.2.4 赋值语句  183
      • 6.2.5 控制语句  184
      • 6.2.6 注释  187
      • 6.3 过程单元  188
      • 6.3.1 过程  188
      • 6.3.2 参数  189
      • 6.3.3 函数  192
      • 6.4 语言实现  193
      • 6.4.1 翻译过程  193
      • 6.4.2 软件开发包  198
      • 6.5 面向对象程序设计  199
      • 6.5.1 类和对象  199
      • 6.5.2 构造器   202
      • 6.5.3 附加特性   202
      • *6.6 程序设计中的并发活动   204
      • *6.7 说明性程序设计   206
      • 6.7.1 逻辑推演   206
      • 6.7.2 Prolog    208
      • 复习题  210
      • 社会问题  213
      • 课外阅读  214
      • 第7 章 软件工程   215
      • 7.1 软件工程学科   215
      • 7.2 软件生命周期   217
      • 7.2.1 周期是个整体  217
      • 7.2.2 传统的开发阶段  218
      • 7.3 软件工程方法   220
      • 7.4 模块化  221
      • 7.4.1 模块式实现  222
      • 7.4.2 耦合   224
      • 7.4.3 内聚   225
      • 7.4.4 信息隐藏  225
      • 7.4.5 构件  226
      • 7.5 行业工具   227
      • 7.5.1 较老的工具   227
      • 7.5.2 统一建模语言   228
      • 7.5.3 设计模式  232
      • 7.6 质量保证   233
      • 7.6.1 质量保证的范围  233
      • 7.6.2 软件测试   234
      • 7.7 文档编制   235
      • 7.8 人机界面   236
      • 7.9 软件所有权和责任  238
      • 复习题  240
      • 社会问题  242
      • 课外阅读  243
      • 第8 章 数据抽象  244
      • 8.1 数据结构基础   244
      • 8.1.1 数组   244
      • 8.1.2 列表、栈和队列  245
      • 8.1.3 树   245
      • 8.2 相关概念   247
      • 8.2.1 抽象  247
      • 8.2.2 静态结构与动态结构   247
      • 8.2.3 指针   248
      • 8.3 数据结构的实现   248
      • 8.3.1 数组的存储  248
      • 8.3.2 列表的存储  251
      • 8.3.3 栈和队列的存储  254
      • 8.3.4 二叉树的存储  255
      • 8.3.5 数据结构的操作  257
      • 8.4 一个简短案例   259
      • 8.5 定制的数据类型   263
      • 8.5.1 用户自定义数据类型   263
      • 8.5.2 抽象数据类型   264
      • *8.6 类和对象   266
      • *8.7 机器语言中的指针  267
      • 复习题  269
      • 社会问题  273
      • 课外阅读  274
      • 第9 章 数据库系统  275
      • 9.1 数据库基础  275
      • 9.1.1 数据库系统的重要性  275
      • 9.1.2 模式的作用  276
      • 9.1.3 数据库管理系统  277
      • 9.1.4 数据库模型  278
      • 9.2 关系模型   279
      • 9.2.1 关系设计中的问题   279
      • 9.2.2 关系运算  282
      • 9.2.3 SQL   285
      • *9.3 面向对象数据库  287
      • *9.4 维护数据库的完整性  289
      • 9.4.1 提交/回滚协议  289
      • 9.4.2 锁定   290
      • *9.5 传统的文件结构  291
      • 9.5.1 顺序文件  291
      • 9.5.2 索引文件  294
      • 9.5.3 散列文件  294
      • 9.6 数据挖掘   297
      • 9.7 数据库技术的社会影响  299
      • 复习题  300
      • 社会问题  303
      • 课外阅读  304
      • 第10 章 计算机图形学  305
      • 10.1 计算机图形学的范围   305
      • 10.2 3D图形概述  307
      • 10.3 建模   308
      • 10.3.1 单个物体的建模  308
      • 10.3.2 整个场景的建模  313
      • 10.4 渲染  314
      • 10.4.1 光-表面交互  314
      • 10.4.2 裁剪、扫描转换和隐藏面的消除  316
      • 10.4.3 着色  319
      • 10.4.4 渲染-流水线硬件  320
      • *10.5 处理全局照明  321
      • 10.5.1 光线跟踪   321
      • 10.5.2 辐射度  323
      • 10.6 动画  323
      • 10.6.1 动画基础  323
      • 10.6.2 运动学和动力学  325
      • 10.6.3 动画制作过程  326
      • 复习题  326
      • 社会问题  328
      • 课外阅读  329
      • 第11 章 人工智能  330
      • 11.1 智能与机器  330
      • 11.1.1 智能体  330
      • 11.1.2 研究方法  332
      • 11.1.3 图灵测试  332
      • 11.2 感知  333
      • 11.2.1 理解图像  333
      • 11.2.2 语言处理  335
      • 11.3 推理  338
      • 11.3.1 产生式系统  338
      • 11.3.2 搜索树  340
      • 11.3.3 启发式搜索  342
      • 11.4 其他研究领域  346
      • 11.4.1 知识的表达和处理  346
      • 11.4.2 学习  347
      • 11.4.3 遗传算法  349
      • 11.5 人工神经网络  349
      • 11.5.1 基本特性  350
      • 11.5.2 训练人工神经网络  351
      • 11.5.3 联想记忆  353
      • 11.6 机器人学  356
      • 11.7 后果的思考  358
      • 复习题  359
      • 社会问题  363
      • 课外阅读  364
      • 第12 章 计算理论  365
      • 12.1 函数及其计算  365
      • 12.2 图灵机  367
      • 12.2.1 图灵机的原理  367
      • 12.2.2 丘奇-图灵论题  369
      • 12.3 通用程序设计语言  370
      • 12.3.1 Bare Bones语言  370
      • 12.3.2 用Bare Bones语言编程  372
      • 12.3.3 Bare Bones的通用性  373
      • 12.4 一个不可计算的函数  375
      • 12.4.1 停机问题  375
      • 12.4.2 停机问题的不可解性  376
      • 12.5 问题的复杂性  379
      • 12.5.1 问题复杂性的度量  379
      • 12.5.2 多项式问题与非多项式问题  382
      • 12.5.3 NP问题  383
      • *12.6 公钥密码学  386
      • 12.6.1 模表示法  386
      • 12.6.2 RSA公钥加密系统  387
      • 复习题  389
      • 社会问题  392
      • 课外阅读  392
      • 附录A ASCII 码  394
      • 附录B 处理二进制补码表示的电路  395
      • 附录C 一种简单的机器语言  397
      • 附录D 高级编程语言  399
      • 附录E 迭代结构与递归结构的等价性  401
      • 索引  403
      • 问题与练习答案

      笔记精选

      Python实现的科学计算器功能示例

      本文实例讲述了Python实现的科学计算器功能。分享给大家供大家参考,具体如下:

      import wx
      import re
      import math
      # begin wxGlade: extracode
      # end wxGlade
      ans=0
      ts=""
      class MyFrame(wx.Frame):
        def __init__(self, *args, **kwds):
          # begin wxGlade: MyFrame.__init__
          kwds["style"] = wx.DEFAULT_FRAME_STYLE
          wx.Frame.__init__(self, *args, **kwds)
          self.text_ctrl_1 = wx.TextCtrl(self, -1, "" ,style=wx.TE_READONLY)
          self.text_ctrl_2 = wx.TextCtrl(self, -1, "", style=wx.TE_READONLY)
          self.button_37 = wx.Button(self, -1, "7")
          self.button_38 = wx.Button(self, -1, "8")
          self.button_39 = wx.Button(self, -1, "9")
          self.button_40 = wx.Button(self, -1, "+")
          self.button_41 = wx.Button(self, -1, "-")
          self.button_42 = wx.Button(self, -1, "4")
          self.button_43 = wx.Button(self, -1, "5")
          self.button_44 = wx.Button(self, -1, "6")
          self.button_45 = wx.Button(self, -1, "x")
          self.button_46 = wx.Button(self, -1, "/")
          self.button_47 = wx.Button(self, -1, "1")
          self.button_48 = wx.Button(self, -1, "2")
          self.button_49 = wx.Button(self, -1, "3")
          self.button_50 = wx.Button(self, -1, "(")
          self.button_51 = wx.Button(self, -1, ")")
          self.button_52 = wx.Button(self, -1, "0")
          self.button_53 = wx.Button(self, -1, ".")
          self.button_54 = wx.Button(self, -1, "ans")
          self.button_55 = wx.Button(self, -1, "clear")
          self.button_56 = wx.Button(self, -1, "=")
          self.button_57 = wx.Button(self, -1, "pi")
          self.button_58 = wx.Button(self, -1, "e")
          self.button_59 = wx.Button(self, -1, "1/x")
          self.button_60 = wx.Button(self, -1, "x^2")
          self.button_61 = wx.Button(self, -1, "x^y")
          self.button_62 = wx.Button(self, -1, "sqrt")
          self.button_63 = wx.Button(self, -1, "sin")
          self.button_64 = wx.Button(self, -1, "cos")
          self.button_65 = wx.Button(self, -1, "tan")
          self.button_66 = wx.Button(self, -1, "log")
          self.button_67 = wx.Button(self, -1, "ln")
          self.button_68 = wx.Button(self, -1, "n!")
          self.button_69 = wx.Button(self, -1, "mod")
          self.button_70 = wx.Button(self, -1, "int")
          self.button_71 = wx.Button(self, -1, "yu")
          self.button_72 = wx.Button(self, -1, "|")
          self.button_73 = wx.Button(self, -1, "~")
          self.button_74 = wx.Button(self, -1, "xor")
          self.__set_properties()
          self.__do_layout()
          self.Bind(wx.EVT_BUTTON, self.bu37, self.button_37)
          self.Bind(wx.EVT_BUTTON, self.bu38, self.button_38)
          self.Bind(wx.EVT_BUTTON, self.bu39, self.button_39)
          self.Bind(wx.EVT_BUTTON, self.bu40, self.button_40)
          self.Bind(wx.EVT_BUTTON, self.bu41, self.button_41)
          self.Bind(wx.EVT_BUTTON, self.bu42, self.button_42)
          self.Bind(wx.EVT_BUTTON, self.bu43, self.button_43)
          self.Bind(wx.EVT_BUTTON, self.bu44, self.button_44)
          self.Bind(wx.EVT_BUTTON, self.bu45, self.button_45)
          self.Bind(wx.EVT_BUTTON, self.bu46, self.button_46)
          self.Bind(wx.EVT_BUTTON, self.bu47, self.button_47)
          self.Bind(wx.EVT_BUTTON, self.bu48, self.button_48)
          self.Bind(wx.EVT_BUTTON, self.bu49, self.button_49)
          self.Bind(wx.EVT_BUTTON, self.bu50, self.button_50)
          self.Bind(wx.EVT_BUTTON, self.bu51, self.button_51)
          self.Bind(wx.EVT_BUTTON, self.bu52, self.button_52)
          self.Bind(wx.EVT_BUTTON, self.bu53, self.button_53)
          self.Bind(wx.EVT_BUTTON, self.bu54, self.button_54)
          self.Bind(wx.EVT_BUTTON, self.bu55, self.button_55)
          self.Bind(wx.EVT_BUTTON, self.bu56, self.button_56)
          self.Bind(wx.EVT_BUTTON, self.bu57, self.button_57)
          self.Bind(wx.EVT_BUTTON, self.bu58, self.button_58)
          self.Bind(wx.EVT_BUTTON, self.bu59, self.button_59)
          self.Bind(wx.EVT_BUTTON, self.bu60, self.button_60)
          self.Bind(wx.EVT_BUTTON, self.bu61, self.button_61)
          self.Bind(wx.EVT_BUTTON, self.bu62, self.button_62)
          self.Bind(wx.EVT_BUTTON, self.bu63, self.button_63)
          self.Bind(wx.EVT_BUTTON, self.bu64, self.button_64)
          self.Bind(wx.EVT_BUTTON, self.bu65, self.button_65)
          self.Bind(wx.EVT_BUTTON, self.bu66, self.button_66)
          self.Bind(wx.EVT_BUTTON, self.bu67, self.button_67)
          self.Bind(wx.EVT_BUTTON, self.bu68, self.button_68)
          self.Bind(wx.EVT_BUTTON, self.bu69, self.button_69)
          self.Bind(wx.EVT_BUTTON, self.bu70, self.button_70)
          self.Bind(wx.EVT_BUTTON, self.bu71, self.button_71)
          self.Bind(wx.EVT_BUTTON, self.bu72, self.button_72)
          self.Bind(wx.EVT_BUTTON, self.bu73, self.button_73)
          self.Bind(wx.EVT_BUTTON, self.bu74, self.button_74)
          # end wxGlade
          self.Show(True)
        def __set_properties(self):
          # begin wxGlade: MyFrame.__set_properties
          self.SetTitle("Python Calculater by CYG")
          self.text_ctrl_1.SetMinSize((500, 30))
          self.text_ctrl_2.SetMinSize((500, 50))
          self.button_37.SetMinSize((100, 60))
          self.button_38.SetMinSize((100, 60))
          self.button_39.SetMinSize((100, 60))
          self.button_40.SetMinSize((100, 60))
          self.button_41.SetMinSize((100, 60))
          self.button_42.SetMinSize((100, 60))
          self.button_43.SetMinSize((100, 60))
          self.button_44.SetMinSize((100, 60))
          self.button_46.SetMinSize((100, 60))
          self.button_45.SetMinSize((100, 60))
          self.button_47.SetMinSize((100, 60))
          self.button_48.SetMinSize((100, 60))
          self.button_49.SetMinSize((100, 60))
          self.button_50.SetMinSize((100, 60))
          self.button_51.SetMinSize((100, 60))
          self.button_52.SetMinSize((100, 60))
          self.button_53.SetMinSize((100, 60))
          self.button_54.SetMinSize((100, 60))
          self.button_55.SetMinSize((100, 60))
          self.button_56.SetMinSize((100, 60))
          self.button_57.SetMinSize((83, 50))
          self.button_58.SetMinSize((83, 50))
          self.button_59.SetMinSize((83, 50))
          self.button_60.SetMinSize((83, 50))
          self.button_61.SetMinSize((83, 50))
          self.button_62.SetMinSize((83, 50))
          self.button_63.SetMinSize((83, 50))
          self.button_64.SetMinSize((83, 50))
          self.button_65.SetMinSize((83, 50))
          self.button_66.SetMinSize((83, 50))
          self.button_67.SetMinSize((83, 50))
          self.button_68.SetMinSize((83, 50))
          self.button_69.SetMinSize((83, 50))
          self.button_70.SetMinSize((83, 50))
          self.button_71.SetMinSize((83, 50))
          self.button_72.SetMinSize((83, 50))
          self.button_73.SetMinSize((83, 50))
          self.button_74.SetMinSize((83, 50))
          # end wxGlade
        def __do_layout(self):
          # begin wxGlade: MyFrame.__do_layout
          sizer_2 = wx.BoxSizer(wx.VERTICAL)
          sizer_3 = wx.BoxSizer(wx.VERTICAL)
          grid_sizer_1 = wx.GridSizer(4, 5, 0, 0)
          grid_sizer_2 = wx.GridSizer(3, 6, 0, 0)
          sizer_3.Add(self.text_ctrl_2, 0, 0, 0)
          sizer_3.Add(self.text_ctrl_1, 0, 0, 0)
          grid_sizer_1.Add(self.button_37, 0, 0, 0)
          grid_sizer_1.Add(self.button_38, 0, 0, 0)
          grid_sizer_1.Add(self.button_39, 0, 0, 0)
          grid_sizer_1.Add(self.button_40, 0, 0, 0)
          grid_sizer_1.Add(self.button_41, 0, 0, 0)
          grid_sizer_1.Add(self.button_42, 0, 0, 0)
          grid_sizer_1.Add(self.button_43, 0, 0, 0)
          grid_sizer_1.Add(self.button_44, 0, 0, 0)
          grid_sizer_1.Add(self.button_45, 0, 0, 0)
          grid_sizer_1.Add(self.button_46, 0, 0, 0)
          grid_sizer_1.Add(self.button_47, 0, 0, 0)
          grid_sizer_1.Add(self.button_48, 0, 0, 0)
          grid_sizer_1.Add(self.button_49, 0, 0, 0)
          grid_sizer_1.Add(self.button_50, 0, 0, 0)
          grid_sizer_1.Add(self.button_51, 0, 0, 0)
          grid_sizer_1.Add(self.button_52, 0, 0, 0)
          grid_sizer_1.Add(self.button_53, 0, 0, 0)
          grid_sizer_1.Add(self.button_54, 0, 0, 0)
          grid_sizer_1.Add(self.button_55, 0, 0, 0)
          grid_sizer_1.Add(self.button_56, 0, 0, 0)
          grid_sizer_2.Add(self.button_57, 0, 0, 0)
          grid_sizer_2.Add(self.button_58, 0, 0, 0)
          grid_sizer_2.Add(self.button_59, 0, 0, 0)
          grid_sizer_2.Add(self.button_60, 0, 0, 0)
          grid_sizer_2.Add(self.button_61, 0, 0, 0)
          grid_sizer_2.Add(self.button_62, 0, 0, 0)
          grid_sizer_2.Add(self.button_63, 0, 0, 0)
          grid_sizer_2.Add(self.button_64, 0, 0, 0)
          grid_sizer_2.Add(self.button_65, 0, 0, 0)
          grid_sizer_2.Add(self.button_66, 0, 0, 0)
          grid_sizer_2.Add(self.button_67, 0, 0, 0)
          grid_sizer_2.Add(self.button_68, 0, 0, 0)
          grid_sizer_2.Add(self.button_69, 0, 0, 0)
          grid_sizer_2.Add(self.button_70, 0, 0, 0)
          grid_sizer_2.Add(self.button_71, 0, 0, 0)
          grid_sizer_2.Add(self.button_72, 0, 0, 0)
          grid_sizer_2.Add(self.button_73, 0, 0, 0)
          grid_sizer_2.Add(self.button_74, 0, 0, 0)
          sizer_3.Add(grid_sizer_1, 1, wx.EXPAND, 0)
          sizer_3.Add(grid_sizer_2, 1, wx.EXPAND, 0)
          sizer_2.Add(sizer_3, 1, wx.EXPAND, 0)
          self.SetSizer(sizer_2)
          sizer_2.Fit(self)
          self.Layout()
          # end wxGlade
        def bu37(self, event): # wxGlade: MyFrame.<event_handler>
          global ts
          ts+="7"
          self.text_ctrl_1.AppendText("7")
          event.Skip()
        def bu38(self, event): # wxGlade: MyFrame.<event_handler>
          global ts
          ts+="8"
          self.text_ctrl_1.AppendText("8")
          event.Skip()
        def bu39(self, event): # wxGlade: MyFrame.<event_handler>
          global ts
          ts += "9"
          self.text_ctrl_1.AppendText("9")
          event.Skip()
        def bu40(self, event): # wxGlade: MyFrame.<event_handler>
          global ts
          ts += "+"
          self.text_ctrl_1.AppendText("+")
          event.Skip()
        def bu41(self, event): # wxGlade: MyFrame.<event_handler>
          global ts
          ts += "-"
          self.text_ctrl_1.AppendText("-")
          event.Skip()
        def bu42(self, event): # wxGlade: MyFrame.<event_handler>
          global ts
          ts += "4"
          self.text_ctrl_1.AppendText("4")
          event.Skip()
        def bu43(self, event): # wxGlade: MyFrame.<event_handler>
          global ts
          ts += "5"
          self.text_ctrl_1.AppendText("5")
          event.Skip()
        def bu44(self, event): # wxGlade: MyFrame.<event_handler>
          global ts
          ts += "6"
          self.text_ctrl_1.AppendText("6")
          event.Skip()
        def bu45(self, event): # wxGlade: MyFrame.<event_handler>
          global ts
          ts += "*"
          self.text_ctrl_1.AppendText("*")
          event.Skip()
        def bu46(self, event): # wxGlade: MyFrame.<event_handler>
          global ts
          ts += "/"
          self.text_ctrl_1.AppendText("/")
          event.Skip()
        def bu47(self, event): # wxGlade: MyFrame.<event_handler>
          global ts
          ts += "1"
          self.text_ctrl_1.AppendText("1")
          event.Skip()
        def bu48(self, event): # wxGlade: MyFrame.<event_handler>
          global ts
          ts += "2"
          self.text_ctrl_1.AppendText("2")
          event.Skip()
        def bu49(self, event): # wxGlade: MyFrame.<event_handler>
          global ts
          ts += "3"
          self.text_ctrl_1.AppendText("3")
          event.Skip()
        def bu50(self, event): # wxGlade: MyFrame.<event_handler>
          global ts
          ts += "("
          self.text_ctrl_1.AppendText("(")
          event.Skip()
        def bu51(self, event): # wxGlade: MyFrame.<event_handler>
          global ts
          ts += ")"
          self.text_ctrl_1.AppendText(")")
          event.Skip()
        def bu52(self, event): # wxGlade: MyFrame.<event_handler>
          global ts
          ts += "0"
          self.text_ctrl_1.AppendText("0")
          event.Skip()
        def bu53(self, event): # wxGlade: MyFrame.<event_handler>
          global ts
          ts += "."
          self.text_ctrl_1.AppendText(".")
          event.Skip()
        def bu54(self, event): # wxGlade: MyFrame.<event_handler>
          global ts
          ts += "ans"
          self.text_ctrl_1.AppendText("ans")
          event.Skip()
        def bu55(self, event): # wxGlade: MyFrame.<event_handler>
          global ts
          self.text_ctrl_1.Clear()
          self.text_ctrl_2.Clear()
          ans=0
          ts=""
          event.Skip()
        def minus_operation(self,expresstion):
          minus_operators = re.split("-", expresstion)
          calc_list = re.findall("[0-9]", expresstion)
          if minus_operators[0] == "":
            calc_list[0] = '-%s' % calc_list[0]
          res = reduce(lambda x, y: float(x) - float(y), calc_list)
          return res
        def del_duplicates(self,ts):
          ts = ts.replace("++", "+")
          ts = ts.replace("--", "-")
          ts = ts.replace("+-", "-")
          ts = ts.replace("--", "+")
          ts = ts.replace('- -', "+")
          return ts
        def mutiply_dividend(self,expresstion):
          calc_list = re.split("[*/]", expresstion)
          operators = re.findall("[*/]", expresstion)
          res = None
          for index, i in enumerate(calc_list):
            if res:
              if operators[index - 1] == '*':
                res *= float(i)
              elif operators[index - 1] == '/':
                res /= float(i)
            else:
              res = float(i)
          return res
        def special_features(self,plus_and_minus_operators, multiply_and_dividend):
          for index, i in enumerate(multiply_and_dividend):
            i = i.strip()
            if i.endswith("*") or i.endswith("/"):
              multiply_and_dividend[index] = multiply_and_dividend[index] + plus_and_minus_operators[index] + \
                              multiply_and_dividend[index + 1]
              del multiply_and_dividend[index + 1]
              del plus_and_minus_operators[index]
          return plus_and_minus_operators, multiply_and_dividend
        def minus_special(self,operator_list, calc_list):
          for index, i in enumerate(calc_list):
            if i == '':
              calc_list[index + 1] = i + calc_list[index + 1].strip()
        def figure_up(self,ts):
          ts = ts.strip("()")
          ts = self.del_duplicates(ts)
          plus_and_minus_operators = re.findall("[+-]", ts)
          multiply_and_dividend = re.split("[+-]", ts)
          if len(multiply_and_dividend[0].strip()) == 0:
            multiply_and_dividend[1] = plus_and_minus_operators[0] + multiply_and_dividend[1]
            del multiply_and_dividend[0]
            del plus_and_minus_operators[0]
          plus_and_minus_operators, multiply_and_dividend = self.special_features(plus_and_minus_operators,
                                            multiply_and_dividend)
          for index, i in enumerate(multiply_and_dividend):
            if re.search("[*/]", i):
              sub_res = self.mutiply_dividend(i)
              multiply_and_dividend[index] = sub_res
          #print(multiply_and_dividend, plus_and_minus_operators)
          final_res = None
          for index, item in enumerate(multiply_and_dividend):
            if final_res:
              if plus_and_minus_operators[index - 1] == '+':
                final_res += float(item)
              elif plus_and_minus_operators[index - 1] == '-':
                final_res -= float(item)
            else:
              final_res = float(item)
          return final_res
        def bu56(self, event): # wxGlade: MyFrame.<event_handler>
          global ans
          global ts
          if re.search("pi", ts):
            lists = re.findall("pi", ts)
            for i in range(0, len(lists)):
              te = str(math.pi)
              self.text_ctrl_2.SetValue(te)
              ts = re.sub("pi", te, ts, 1)
              #self.text_ctrl_1.SetValue(ts)
          if re.search("e", ts):
            lists = re.findall("e", ts)
            for i in range(0, len(lists)):
              te = str(math.e)
              self.text_ctrl_2.SetValue(te)
              ts = re.sub("e", te, ts, 1)
              #self.text_ctrl_1.SetValue(ts)
          if re.search("sin.*\)",ts):
            lists=re.findall("sin(.+?)",ts)
            for i in range(0,len(lists)):
              te=float(lists[i])
              te=str(math.sin(te))
              self.text_ctrl_2.SetValue(te)
              ts=re.sub("sin.*?\)",te,ts,1)
              #self.text_ctrl_1.SetValue(ts)
          if re.search("cos.*\)", ts):
            lists = re.findall("cos(.+?)", ts)
            for i in range(0, len(lists)):
              te = float(lists[i])
              te = str(math.cos(te))
              self.text_ctrl_2.SetValue(te)
              ts = re.sub("cos.*?\)", te, ts, 1)
              #self.text_ctrl_1.SetValue(ts)
          if re.search("tan.*\)", ts):
            lists = re.findall("tan(.+?)", ts)
            for i in range(0, len(lists)):
              te = float(lists[i])
              te = str(math.tan(te))
              self.text_ctrl_2.SetValue(te)
              ts = re.sub("tan.*?\)", te, ts, 1)
              #self.text_ctrl_1.SetValue(ts)
          if re.search("ln.*\)", ts):
            lists = re.findall("ln(.+?)", ts)
            for i in range(0, len(lists)):
              te = float(lists[i])
              te = str(math.log(te))
              self.text_ctrl_2.SetValue(te)
              ts = re.sub("ln.*?\)", te, ts, 1)
              #self.text_ctrl_1.SetValue(ts)
          if re.search("log.*\)", ts):
            lists = re.findall("log(.+?)", ts)
            for i in range(0, len(lists)):
              te = float(lists[i])
              te = str(math.log(te)/math.log(10))
              self.text_ctrl_2.SetValue(te)
              ts = re.sub("log.*?\)", te, ts, 1)
              #self.text_ctrl_1.SetValue(ts)
          if re.search("sqrt.*\)", ts):
            lists = re.findall("sqrt(.+?)", ts)
            for i in range(0, len(lists)):
              te = float(lists[i])
              te = str(math.sqrt(te))
              self.text_ctrl_2.SetValue(te)
              ts = re.sub("sqrt.*?\)", te, ts, 1)
              #self.text_ctrl_1.SetValue(ts)
          if re.search("int.*\)", ts):
            lists = re.findall("int(.+?)", ts)
            for i in range(0, len(lists)):
              te=float(lists[i])
              te=int(te)
              te = str(te)
              self.text_ctrl_2.SetValue(te)
              ts = re.sub("int.*?\)", te, ts, 1)
              #self.text_ctrl_1.SetValue(ts)
          if re.search("ans", ts):
            lists = re.findall("ans", ts)
            for i in range(0, len(lists)):
              te = str(ans)
              self.text_ctrl_2.SetValue(te)
              ts = re.sub("ans", te, ts, 1)
              #self.text_ctrl_1.SetValue(ts)
          if re.search("?−?\d∗\.?\d∗?\^?−?\d∗\.?\d∗?", ts):
            lists1 = re.findall("?(−?\d∗\.?\d∗?)?\^", ts)
            lists2 = re.findall("\^?(−?\d∗\.?\d∗)?", ts)
            for i in range(0, len(lists1)):
              te1=float(lists1[i])
              te2=float(lists2[i])
              #print te1
              #print te2
              te=math.pow(te1,te2)
              te = str(te)
              self.text_ctrl_2.SetValue(te)
              ts = re.sub("?[0−9]∗\.?[0−9]∗??\^?[0−9]∗\.?[0−9]∗?", te, ts, 1)
              #self.text_ctrl_1.SetValue(ts)
            #ts = re.sub("?−?\d∗\.?\d∗?\^?−?\d∗\.?\d∗??", te, ts, 1)
          if re.search("?−?\d∗?\!", ts):
              lists = re.findall("?(−?\d+?)?\!", ts)
              for i in range(0, len(lists)):
                te = float(lists[i])
                te = math.factorial(te)
                te = str(te)
                self.text_ctrl_2.SetValue(te)
                ts = re.sub("?−?\d+??\!", te, ts, 1)
                #self.text_ctrl_1.SetValue(ts)
          #print ts
          flag=True
          while flag:
            m = re.search("[()]∗", ts)
            if m:
              sub_res=self.figure_up(m.group())
              ts=ts.replace(m.group(),str(sub_res))
            else:
              ans=self.figure_up(ts)
              flag=False
          self.text_ctrl_2.SetValue(str(ans))
            #ans=
          #self.text_ctrl_2.SetValue(str(ans))
          # self.text_ctrl_1.Clear()
          event.Skip()
        def bu57(self, event): # wxGlade: MyFrame.<event_handler>
          global ts
          ts += "pi"
          self.text_ctrl_1.AppendText("pi")
          event.Skip()
        def bu58(self, event): # wxGlade: MyFrame.<event_handler>
          global ts
          ts += "e"
          self.text_ctrl_1.AppendText("e")
          event.Skip()
        def bu59(self, event): # wxGlade: MyFrame.<event_handler>
          global ts
          ts += "^(-1)"
          self.text_ctrl_1.AppendText("^(-1)")
          event.Skip()
        def bu60(self, event): # wxGlade: MyFrame.<event_handler>
          global ts
          ts += "^2"
          self.text_ctrl_1.AppendText("^2")
          event.Skip()
        def bu61(self, event): # wxGlade: MyFrame.<event_handler>
          global ts
          ts += "^"
          self.text_ctrl_1.AppendText("^")
          event.Skip()
        def bu62(self, event): # wxGlade: MyFrame.<event_handler>
          global ts
          ts += "sqrt("
          self.text_ctrl_1.AppendText("sqrt(")
          event.Skip()
        def bu63(self, event): # wxGlade: MyFrame.<event_handler>
          global ts
          ts += "sin("
          self.text_ctrl_1.AppendText("sin(")
          event.Skip()
        def bu64(self, event): # wxGlade: MyFrame.<event_handler>
          global ts
          ts += "cos("
          self.text_ctrl_1.AppendText("cos(")
          event.Skip()
        def bu65(self, event): # wxGlade: MyFrame# .<event_handler>
          global ts
          ts += "tan("
          self.text_ctrl_1.AppendText("tan(")
          event.Skip()
        def bu66(self, event): # wxGlade: MyFrame.<event_handler>
          global ts
          ts += "log("
          self.text_ctrl_1.AppendText("log(")
          event.Skip()
        def bu67(self, event): # wxGlade: MyFrame.<event_handler>
          global ts
          ts += "ln("
          self.text_ctrl_1.AppendText("ln(")
          event.Skip()
        def bu68(self, event): # wxGlade: MyFrame.<event_handler>
          global ts
          ts += "!"
          self.text_ctrl_1.AppendText("!")
          event.Skip()
        def bu69(self, event): # wxGlade: MyFrame.<event_handler>
          global ts
          ts += "m"
          self.text_ctrl_1.AppendText("m")#qumo
          event.Skip()
        def bu70(self, event): # wxGlade: MyFrame.<event_handler>
          global ts
          ts += "int("
          self.text_ctrl_1.AppendText("int(")
          event.Skip()
        def bu71(self, event): # wxGlade: MyFrame.<event_handler>
          global ts
          ts += "u"
          self.text_ctrl_1.AppendText("u")#yu
          event.Skip()
        def bu72(self, event): # wxGlade: MyFrame.<event_handler>
          global ts
          ts += "|"
          self.text_ctrl_1.AppendText("|")#huo
          event.Skip()
        def bu73(self, event): # wxGlade: MyFrame.<event_handler>
          global ts
          ts += "n("
          self.text_ctrl_1.AppendText("n(")#fei
          event.Skip()
        def bu74(self, event): # wxGlade: MyFrame.<event_handler>
          global ts
          ts += "x"
          self.text_ctrl_1.AppendText("x")#yihuo
          event.Skip()
          # end of class MyFrame
      if __name__ == "__main__":
        app=wx.App(False)
        myframe= MyFrame(None)
        app.MainLoop()
      
      

      PS:这里再为大家推荐几款计算工具供大家进一步参考借鉴:

      在线一元函数(方程)求解计算工具:
      http://tools.jb51.net/jisuanqi/equ_jisuanqi

      科学计算器在线使用_高级计算器在线计算:
      http://tools.jb51.net/jisuanqi/jsqkexue

      在线计算器_标准计算器:
      http://tools.jb51.net/jisuanqi/jsq

      更多关于Python相关内容感兴趣的读者可查看本站专题:《Python数学运算技巧总结》、《Python数据结构与算法教程》、《Python函数使用技巧总结》、《Python字符串操作技巧汇总》、《Python入门与进阶经典教程》及《Python文件与目录操作技巧汇总》

      希望本文所述对大家Python程序设计有所帮助。

      以上就是本次介绍的计算机科学概论(英文第11版)书的全部相关内容,课后答案及相关习题附件可以在下方下载,希望我们整理的资源能够帮助到大家,感谢大家对码农之家的支持。

      上一篇:数字电子技术(第10版/英文版)

      下一篇:没有了

      查看更多
      计算机科学 相关资源
      计算机科学概论
      计算机科学概论 PDF 清晰第5版

      本书由两位知名的计算机科学教育家编写,全面而细致地介绍了计算机科学的各个方面。每章后面都附带有大量的练习,可以帮助你即时重温并掌握这一章所述的内容

      立即下载
      具体数学:计算机科学基础
      具体数学:计算机科学基础 PDF 第2版

      具体数学:计算机科学基础(第2版) 是一本在大学中广泛使用的经典数学教科书.书中讲解了许多计算机科学中用到的数学知识及技巧,教你如何把一个实际问题一步步演化为数学模型,然后通

      立即下载
      计算机科学精粹
      计算机科学精粹 PDF 原书高清版

      计算机科学导论精粹版 摒弃传统计算机科学教材的枯燥方式 将抽象理论具体化、复杂问题简单化 传授实现高效程序设计重要的基础知识

      立即下载
      计算机科学概论
      计算机科学概论 PDF 全书第12版

      计算机科学的全景式呈现經典的导论性教材内容的全新升级版本号全方位掌握全新升级的技术性发展趋向《 计算机科学概论 》很多年来始终备受世界各地高等院校老师学生的热烈欢迎,是哈佛

      立即下载
      像计算机科学家一样思考Python
      像计算机科学家一样思考Python PDF 第2版

      本书以培养读者以计算机科学家一样的思维方式来理解Python语言编程。贯穿全书的主体是如何思考、设计、开发的方法,而具体的编程语言,只是提供了一个具体场景方便介绍的媒介。 全书共

      立即下载
      读者心得
      3小时31分钟前回答

      解决Java中由于数据太大自动转换成科学计数法的问题

      1.java后台 (1)使用BigDecimal类 方式一:String str=new BigDecimal(num+"").toString(); 方式二:String str=new BigDecimal(num.toString()).toString(); (2)使用DecimalFormat类 //注意,这种方式是保留几位小数String str=new DecimalFormat("0.00").format(num); 2.JSP页面 (1)使用jstl标签fmt:formatNumber 导入:%@ taglib uri="http://java.sun.com/jsp/jstl/fmt" prefix="fmt"% 使用:fmt:formatNumber value="num " pattern="#.##" minFractionDigits="2" /fmt:formatNumber (2)使用js脚本 var str=parseFloat(num).toString(); * num : 科学计数法表示的数据 以上这篇解决Java中由于数据太大自动转换成科学计数法的问题就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持码农之……

      码农之家

      厉飞星 提供上传

      资源
      36
      粉丝
      31
      喜欢
      122
      评论
      10

      Copyright 2018-2021 www.xz577.com 码农之家

      版权投诉 / 书籍推广:520161757@qq.com