描述
开 本: 16开纸 张: 胶版纸包 装: 平装-胶订是否套装: 否国际标准书号ISBN: 9787111669890
提供10小时配套教学视频，帮助读者更加高效、直观地学习；
将Python基础知识和科学计算相结合，让零基础读者快速入门；
精心挑选大量的典型实例，带领读者从实践中学习Python科学计算；
穿插大量的延伸阅读内容，让读者更加全面和深入地掌握相关知识点；
每章都提供多个配套练习题，帮助读者巩固和提高所学知识；
每章都有“老裴的科学世界”专栏，帮助读者拓宽视野，提高解决实际问题的能力；
提供教学PPT，方便读者学习和相关老师教学使用。
配书资源：
10小时教学视频
实例源代码
教学PPT
《Python科学计算入门与实战（视频教学版）》介绍了作者多年的Python科学计算编程经验，试图为初学者提供一条快速学习的路线，从而有效降低学习门槛和成本。本书将Python科学计算的理论知识与实践经验结合起来，通过大量的典型实例带领零基础读者快速上手。本书图文并茂，在讲解时穿插了上百幅图片，可以帮助读者理解重点和难点。另外，作者还特意为本书制作了教学PPT，并录制了长达10小时的配套教学视频，以帮助读者更加高效、直观地学习。
《Python科学计算入门与实战（视频教学版）》分为6章。第1章以简单公式程序化为主题，介绍Python编程的入门知识、数值数据类型和函数；第2章以复杂公式程序化为主题，介绍Python中的流程控制和多值数据类型；第3章以公式对象化为主题，结合4个实例介绍Python的面向对象编程，以及如何打包Python程序；第4章以公式向量化为主题，介绍Python的著名数值运算库NumPy的基础知识和使用方法；第5章以公式可视化为主题，介绍Python的著名绘图库Matplotlib的使用方法；第6章介绍Python中的随机数生成方法，并配合10余个实例对前面章节的知识进行综合应用。
《Python科学计算入门与实战（视频教学版）》内容丰富，讲解通俗易懂，适合初学科学计算的相关人员阅读，尤其适合高等院校相关专业的本科生和研究生阅读，也适合数据科学和人工智能等相关领域的工程技术人员阅读。另外，本书还适合作为相关培训机构的教学用书。
前言
第1章 简单公式程序化 1
1.1 安装Python 1
1.1.1 安装IDLE 1
1.1.2 安装Anaconda 2
1.1.3 本书为什么使用IDLE 3
1.2 抛物线公式 3
1.2.1 语句、表达式和值 4
1.2.2 变量与赋值 6
1.2.3 注释 14
1.2.4 格式化输出 15
1.2.5 初识对象和类 17
1.2.6 运算符 20
1.3 煮蛋公式 27
1.3.1 库与模块 28
1.3.2 函数 31
1.3.3 复数 51
1.3.4 算法与程序流程 52
1.4 本章小结 54
1.5 习题 55
老裴的科学世界 57
房贷计算器 58
第2章 复杂公式程序化 67
2.1 出租车费 67
2.1.1 条件分支 68
2.1.2 错误与异常 74
2.2 调和级数 80
2.2.1 while循环 81
2.2.2 列表和元组 86
2.2.3 for循环 95
2.2.4 函数和对象 102
2.2.5 函数进阶 108
2.2.6 列表解析 111
2.2.7 生成器 119
2.3 演讲的重点 122
2.3.1 字符串 123
2.3.2 集合 132
2.3.3 字典 139
2.3.4 数据类型总结 148
2.4 本章小结 149
2.5 习题 150
老裴的科学世界 154
中文分词器 154
第3章 公式对象化 165
3.1 抛物线对象 165
3.1.1 定义类 167
3.1.2 属性和方法 167
3.2 鸡蛋对象 174
3.2.1 类属性 174
3.2.2 静态方法 176
3.2.3 层级关系 177
3.3 向量对象 178
3.3.1 运算符 179
3.3.2 其他特殊方法 183
3.4 平面几何 184
3.4.1 类的继承 186
3.4.2 更多知识 192
3.4.3 打包 206
3.4.4 发布到PyPi 212
3.5 本章小结 213
3.6 习题 214
老裴的科学世界 215
球的运动轨迹 215
第4章 公式向量化 224
4.1 地表温度辐射 224
4.1.1 向量化表达 225
4.1.2 ndarray对象 228
4.1.3 创建数组 234
4.2 小明预估成绩 243
4.2.1 数组操作 245
4.2.2 数组运算 278
4.3 弹簧系统 314
4.3.1 线性代数相关函数 314
4.3.2 其他功能 327
4.4 本章小结 332
4.5 习题 332
老裴的科学世界 334
化学方程式配平 334
第5章 公式可视化 340
5.1 绘制曲线图 342
5.1.1 一轴一图形 342
5.1.2 一轴多图形 346
5.1.3 多轴多图形 356
5.1.4 高级绘图 362
5.2 绘制其他图形 373
5.2.1 散点图 373
5.2.2 柱状图 375
5.2.3 饼状图 380
5.2.4 直方图 381
5.2.5 箱形图 382
5.2.6 棉棒图 384
5.2.7 误差棒图 385
5.2.8 阶梯图 386
5.2.9 填充图 387
5.2.10 堆叠图 388
5.2.11 对数图 389
5.2.12 等高线图 390
5.2.13 三维图形 392
5.3 本章小结 395
5.4 习题 395
老裴的科学世界 396
曲柄连杆机构运动动画 396
第6章 随机数与实例 402
6.1 微信随机红包 402
6.1.1 生成随机数 403
6.1.2 随机数种子 407
6.1.3 更多实例 408
6.2 奇妙的圆周率 417
6.2.1 随机数数组 418
6.2.2 更多实例 423
6.3 本章小结 436
6.4 习题 436
老裴的科学世界 437
病毒传播离散模型 437
参考文献 449
……
写作背景
记得2009年笔者还在攻读硕士学位时，一天同年级的一个同学让笔者帮他求解一个最优化问题。当时笔者对最优化计算还是一知半解，于是到学校图书馆借了一本MATLAB最优化计算的图书，照着书上的求解步骤用MATLAB帮他解决了问题。从那时起，笔者就对最优化计算产生了浓厚的兴趣，并开始学习最优化计算的基本原理。时至今日，笔者仍然对最优化计算的理论和实践有着浓厚的兴趣。可以说，是最优化计算吸引笔者走进了科学计算的世界。
后来笔者想开发自己的软件，又学习了C、C 和C#等编程语言，这为笔者后续学习其他语言奠定了一定的基础。现在回想起来，当初之所以没有继续深入学习C和C 语言，是因为对于笔者这样的非计算机专业学生而言，这两种语言无论是学习难度还是使用成本都过高，C#语言虽然简单一些，但是在跨平台方面不具备优势。一次偶然的机会，笔者接触了Python语言，因为有C和C 语言基础，所以学习起来比较容易。自此以后，笔者便一发不可收拾，一用Python就是11年之久。在笔者看来，Python是理工科非计算机专业学生的首选编程语言，因为他们毕业后所从事的工作大多会涉及科学计算，而Python非常适合做科学计算。
尽管市面上的Python图书已经汗牛充栋，但关于科学计算方面的图书却寥寥无几，而且这些图书需要读者有一定的Python编程基础才能阅读，这无疑增加了读者的学习负担。虽然Python很强大，可以胜任各领域的开发工作，但是科学计算并不要求读者全面掌握Python编程，读者也无须为了做科学计算而专门花大把时间精研Python编程。比较理想的做法是，用一本书带领读者掌握Python科学计算。于是，笔者萌生了一个想法：编写一本书，将Python编程的基础知识和科学计算结合起来讲解，让读者更加有针对性地学习，从而快速入门Python科学计算。
写作经历
笔者曾经作为第一作者参与编写了《Python与有限元》一书，介绍如何用Python开发一个有限元分析框架，历经一年，其中，前八个月编写有限元分析框架程序，后四个月完成图书的写作。后来笔者又编写了《从零开始自己动手写区块链》一书，介绍区块链的原理与底层编程知识，历经八个月，前四个月编写区块链模拟器程序，后四个月完成图书的写作。这两本书都有一个共同点：先写好完整的程序，然后将编程的过程用文字描述出来，写作的难点在于程序的实现。本书是笔者参与编写的第三本书，也是写作时间最长的一本书，历时一年零八个月。本书与前两本书有所不同，书中介绍的程序对于笔者来说实现起来很容易，其难点在于如何将Python编程的相关知识与科学计算巧妙地结合起来，让读者能够轻松地走进Python科学计算的世界。为此，本书尝试采用一种新的写作风格：书中的章节划分以科学计算实例为依据，在解决科学计算问题的过程中穿插介绍需要学习的Python编程知识。于是，本书的写作难点成了经典实例的选择问题，因为实例的选择要具有代表性，是读者熟知和感兴趣的例子，还要能够将Python编程知识穿插其中。这无疑是一件极具挑战性的事，本书中的每一个例子都经过了“选择→构思→推翻→重新选择→重新构思→采纳”的复杂过程，这对于笔者这样有选择困难症的人来说，可谓劳心费神。所幸经过大量的遴选，笔者最终选出了较为满意的实例。
《Python科学计算入门与实战（视频教学版）》特色
- 提供了长达10小时的配套教学视频，帮助读者更加高效、直观地学习本书内容。
- 将Python基础知识和科学计算结合起来讲解，让没有任何Python编程基础的读者快速入门。
- 精心挑选了大量的典型实例，带领读者从实践中学习Python科学计算。
- 穿插了大量的延伸阅读内容，帮助读者更加全面和深入地掌握相关知识点。
- 每章都提供了习题，帮助读者巩固和提高所学知识。
- 每章都设置了“老裴的科学世界”学习专栏作为补充学习内容，帮助读者拓宽视野，提高解决实际问题的能力。
- 提供教学PPT，方便读者学习和相关老师教学使用。
《Python科学计算入门与实战（视频教学版）》内容
第1章围绕简单公式程序化的主题展开，介绍了如何使用Python将科学计算中的简单公式程序化，涵盖Python的安装和运行、编程的基本概念、基本语法、运算符和数字数据类型等，还重点介绍了Python中函数的定义。
第2章围绕复杂公式程序化的主题展开，重点介绍了Python中的流程控制，包括条件分支语句和循环语句，另外还介绍了与流程控制相关的内置容器型数据类型，如列表、元组、集合和字典。
第3章围绕公式对象化的主题展开，主要介绍了Python面向对象程序设计，包括类和实例，属性和方法，类的继承和方法的重载等，另外还循序渐进地介绍了如何打包并发布自己编写的库。
第4章围绕公式向量化的主题展开，结合数组运算可视化，全方位地介绍了Python的科学计算库NumPy。
第5章围绕公式可视化的主题展开，详细介绍了Python的高质量二维绘图库Matplotlib的相关绘图功能。
第6章介绍了Python中随机数的生成方法，并配合多个典型实例综合应用前面章节所学的知识。
关于专栏
本书在每章的最后设置了一个专栏——老裴的科学世界，主要介绍一些综合性案例。这些案例有的是对本章所讲知识的综合应用，有的是对下一章所做的铺垫，有的穿插介绍Python的其他功能，如GUI开发、Web开发和动画制作等。开设这个专栏的目的是综合应用所学知识解决实际问题，并拓宽读者的视野，提高读者解决实际问题的能力。与正文相比，专栏对理论和程序的细节介绍较少，用到了GUI和Web开发等领域的一些工具，如果读者有疑问，可以和笔者私下交流。
读者对象
本书面向的读者对象较为广泛，主要有以下几类：
- 没有Python基础的科学计算入门人员；
- 从事科学计算研究的人员；
- 从事科学计算工作的工程技术人员；
- Python科学计算爱好者；
- 高等院校理工科相关专业的学生；
- 相关培训机构的学员。
配书资源获取
《Python科学计算入门与实战（视频教学版）》提供以下配书资源：
- 配套教学视频；
- 源代码文件；
- 教学PPT。
这些资源需要读者自行下载。请在华章公司的网站（www.hzbook.com）上搜索到本书，然后单击“资料下载”按钮，即可在本书页面上找到下载链接。
后续计划
起初，笔者计划将本书的写作分两步：第一步介绍科学计算入门知识，第二步结合科学计算库讲解实践。但是因为科学计算的内容较为庞杂，当完成第一步时，书稿篇幅已较大，超过了原来的计划。在与编辑商量后决定将入门部分单独作为一本书，后续再编写《Python最优化算法实战》及《Python科学计算实例详解》两本书作为实践用书。
致谢
《Python科学计算入门与实战（视频教学版）》在出版的过程中得到了湖北工业大学博士启动基金项目（BSQD14042）的资助，在此表示感谢！
感谢湖北工业大学土木建筑与环境学院的领导与同事！他们的支持、帮助和鼓励，让笔者在面对挑战时能勇往直前。
编写这样的一本书对笔者而言是一个巨大的工程，为了不耽搁进度，笔者邀请了李丽华、陈智和肖衡林三位同行一起完成这件事，在此对他们表示感谢！
感谢欧振旭和姚志娟编辑！本书从宏观把握到细节处理都凝聚了他们的大量心血。
感谢家人在长达一年零八个月的写作时间中对笔者的无私奉献和大力支持！
勘误与支持
因本书涉及的内容比较繁杂，加之作者水平所限，书中可能还存在一些疏漏和错误之处，敬请各位读者批评和指正。读者在阅读本书时若有疑问，可以发送电子邮件到[email protected]以获得帮助。期待您的反馈意见，您的支持是笔者前进的动力。
裴尧尧
于湖北工业大学
第1章 简单公式程序化
数学是科学计算的基础，而数学公式又是数学基础知识的重要组成部分，凝聚着数学中的全部精华，也是我们解答数学问题的依据和工具。所以，要使用计算机进行科学计算，将公式程序化是一个基础又重要的内容。本章将结合简单公式的程序化过程，介绍Python编程的部分基础知识。
1.1 安装Python
工欲善其事，必先利其器。任何一门语言都有其使用环境，比如汉语一般在华人地区使用，德语主要在德国使用，日语主要在日本使用。同样，计算机语言也有其特定的运行环境，通常被称为集成开发环境（Integrated Development Environment，IDE），其包括代码编辑器、编译器、调试器和图形用户界面等工具，或者说是集成了代码的开发、分析、编译与调试等一体化开发功能的程序。
本书的主题是采用Python 3进行科学计算，推荐两个可用的IDE，分别是Python官方程序自带的IDLE及整合了众多科学计算库的Anaconda。
1.1.1 安装IDLE
IDLE是Python官方自带的一个轻量级IDE。打开Python官方网站https://www.python. org/，单击Downloads按钮，找到想要安装的版本（本书所有实例的运行环境为Windows 10操作系统和Python 3.6.5），然后选择和自己的计算机操作系统相匹配的安装文件，如图1.1所示。
由于笔者使用的是64位Windows操作系统，因此下载Windows X86-64 executable installer文件，下载完成后像安装一般.exe文件一样进行安装即可。图1.2为程序安装对话框选项。需要特别注意的是，在安装时请将Add Python 3.6 to PATH选项选中。
图1.1 Python官方安装文件下载
图1.2 安装Python
安装完成后，单击计算机桌面左下角的“开始”按钮，选择Python3.6 | IDLE命令即可打开IDLE。
1.1.2 安装Anaconda
打开Anaconda官网https://www.anaconda.com/，单击Download按钮，然后选择与自己的操作系统相匹配的安装文件下载即可，如图1.3所示。目前Anaconda的常用版本为3.7和2.7，分别对应Python 3和Python 2。操作系统支持Windows、Mac OS和Linux。下载完成后，直接进行安装即可。Windows操作系统下可选择创建桌面快捷方式，也可以使用和IDLE一样的打开方式。
图1.3 Anaconda下载页面
1.1.3 本书为什么使用IDLE
相较IDLE，Anaconda在使用上更简单，它提供了众多提高编程效率的功能，如代码自动补齐、拼写错误检查、便捷完善的调试器等。乍一看，Anaconda优点多多，而笔者却为何执意使用IDLE，而不是Anaconda呢？以下是笔者的考量。
功能强大的IDE弱化了程序员的编程能力，而对于一个初学者而言，IDLE这样的IDE更能锻炼编程能力。学习编程没有太多的捷径可走，必须要多动手。如果学会了IDLE这种功能简单的IDE，上手Anaconda这样功能强大的IDE不会有任何障碍。
而对于一个Python“熟手”或者有一定基础的Pythoner（Python用户的统称），在IDLE或者Anaconda上运行本书的实例都不会有什么问题。
折中考虑，笔者选择IDLE进行全书的讲解。
1.2 抛物线公式
抛物线（Parabola）公式用于描述抛物线轨迹。常见的抛物线公式见公式（1.1），式中x、y分别为直角坐标系中的横纵坐标，a、b、c为常系数，描述抛物线的特征。
y=ax2 bx c （1.1）
常系数a、b、c取不同的数值将得到不同的抛物线。图1.4给出了三条抛物线，各自的常系数为：a=4，b=0，c=10；a=2，b=0，c=10；a=-2，b=24，c=-60。
假设抛物线的常系数是确定的，其横、纵坐标也是确定的映射关系，以第一条抛物线为例（a=4，b=0，c=10），当横坐标x取不同数值时都有相应的纵坐标y与之对应，比如当横坐标x=4时，对应的纵坐标为：
y(4)=4x2 10=4×42 10=74 （1.2）
图1.4 抛物线
接下来，通过将抛物线公式程序化的实例，循序渐进地介绍Python编程的基础知识。
1.2.1 语句、表达式和值
【实例1.1】 计算抛物线y=4x2 10横坐标x=4和x=2分别对应的纵坐标y值。
1．交互式运行Python
安装好Python后，打开IDLE，将会弹出交互式Shell，如图1.5所示。在提示符>>>闪烁的光标后输入：
>>> 4*4**2 10
输入完成后回车，可以看到，屏幕上出现了横坐标x=4对应的纵坐标y=74。输入的“4*4**2 10”是一个Python语句（Statement），是向计算机发出的指令，该语句也被称为一个表达式（Expression）。表达式是由值（Value，也称为运算数）和连接它们的运算符（Operator）组成的。如上例中的“*”“**”“ ”均为运算符，4和10为值。计算一个表达式总会得到一个值，如74。这里的表达式用于描述公式，后续的内容中会介绍更多的表达式，有些也用来表达逻辑。
在Python中，值和运算符之间可以有任意多个空格，但必须确保语句从行首开始，如图1.5所示。
%注意：在Python中，“*”为乘法运算符，“**”为幂运算符。
对于横坐标x=2对应的纵坐标y值，修改表达式为4*2**2 10即可，这是一个重复性的工作。
图1.5 Shell界面
以上运行Python程序的方式也被称作交互式（Interactive）运行方式，即在Shell中输入Python语句，程序将被执行并将结果打印到屏幕上。
2．通过脚本运行Python
另一种运行Python程序的方式是通过脚本（Script），即将多条Python语句集中写在一起，这样可以表达更复杂的逻辑，从而发挥更强大的功能。
脚本被写在Python文件中。创建一个Python文件的步骤是：首先在Shell中选择菜单栏的File | New File命令，然后在其中写入Python语句，完成后将其命名为parabola1，并以.py为后缀名保存到本地磁盘中。以上过程完成了一个简单脚本文件的创建，如图1.6所示为只包含一条语句的脚本文件。
图1.6 编辑脚本文件
按键盘上的F5键或选择文件菜单栏中的Run | Run Module命令即可运行该脚本，Shell将打印出表达式的值，如图1.7所示。
读者通过后续内容的阅读可以观察到，用Python进行科学计算，配合使用交互式和脚本两种运行方式将会达到事半功倍的效果。
另一种快速创建Python文件的方式是创建一个.txt文档，然后修改其后缀名为.py即可。
%注意：本书后续代码将不再采用截图的形式，交互式运行的代码用>>>开头，与脚本代码加以区别。
图1.7 运行Python脚本
1.2.2 变量与赋值
【实例1.2】 计算抛物线y=ax2 bx c当a=-2，b=24，c=-60时，横坐标x=1、2和4对应的纵坐标值y。
1．变量和变量值
如果按照实例1.1中的方法求解实例1.2，需要列出3条表达式语句，每条语句中需要修改两处x的取值。如果公式中的符号过多，如系数a、b、c也发生改变时，则修改表达式的次数也会随之增加，这样的工作不仅烦琐，而且容易出错。编程语言中用变量（Variables）来描述公式和数学函数中的符号。下面在新建的脚本parabola2.py文件中输入如下内容：
a = -2
b = 24
c = -60
x = 1
y = a*x**2 b*x c
print(y)
运行该文件，打印到屏幕上的y值为：
-38
以上程序有6条语句，前5条语句定义了5个变量a、b、c、x和y。其中，前4个变量给定了初始值，由前4个变量组成表达式并将计算结果赋值给第5个变量y，第6条语句将变量y的值打印到屏幕上。
变量是变量值的名称，其作用是建立与变量值之间的对应关系，每个变量都有一个变量值。运行完上面的脚本后，接着在Shell中继续输入：
>>> b
24
>>> x
1
>>> x*y #变量组成表达式，计算得到新的值
-38
可以看到，在脚本中定义的变量在执行后可以在Shell中访问，访问变量可以得到变量值，变量可组成表达式，运算时将变量值代入表达式得到新的值。由于实例1.1中的纵坐标没有定义为变量，导致无法被再次访问，这也说明变量是用于存储值的，方便编程时实时地访问它们。
2．赋值语句
下面总结前面内容中出现的几种语句形式。实例1.1中交互式运行和脚本运行的语句分别为：
4*4**2 10
与
print(4*4**2 10)
在实例1.2中，新的语句形式为：
a = -2
y = a*x**2 b*x c
自此读者可能会产生一个错觉，即数学公式与程序语句可以完美地对应起来。不过计算机语言里的等号（=）与数学公式中的等号有完全不同的含义，在数学公式中，等号表示左右两端的表达式的值相等，而在Python程序中，等号是赋值运算符，执行赋值运算，表示将等号右边（值）赋值给等号左边（变量）。这种由等号、等号左边和等号右边组成的语句也被称为赋值语句，等号左边为变量，等号右边是一个数值或表达式。看如下赋值语句：
>>> a = 3
>>> a = a 3
>>> a
6
>>> a = a*a
>>> a
36
显然，a=a 3在数学上是讲不通的，但在编程语言中却没有问题。以上程序的执行过程为；
（1）对于语句a=3，首先定义一个变量a，并将数值3赋给变量a，此时变量a的值为3。
（2）对于语句a=a 3，由于等号右边为表达式a 3，首先对表达式进行运算，即将变量a的值3代入表达式中，运算结果为3 3=6，然后执行赋值运算，将运算结果6重新赋给变量a，此时变量a的值为6；
（3）对于语句a=a*a，运算同上。由于等号右边为表达式a*a，首先对表达式进行运算，即将变量a的值6代入表达式中，运算结果为6*6=36，然后执行赋值运算，将运算结果36重新赋给变量a，此时变量a的值为36。
%注意：描述左右两边相等用双等号（==），详见1.2.6节。
可以看到，变量值可以通过赋值语句进行修改，也意味着对于实例1.2，当要改变x的值时，可以在初始化赋值语句中修改，也可以用新的语句进行修改。例如：
a = -2
b = 24
c = -60
x = 2
y = a*x**2 b*x c
print(y)
x = 4
print(x,y)
输出结果为：
-20
4 -20
上面的程序在定义变量x时将初始化值由上例中的1改为2，第1个print语句打印出的y值为-20，然后通过赋值语句x=4将变量x的值改为4；从第2个print语句的打印结果可以看到，变量x=4的值由2改为4，但变量y的值并没有发生变化，仍然是-20，原因为程序由上自下顺序执行，在执行变量y的赋值语句时，等号右边表达式中变量x的值仍为2。要修改变量y的值，需要在修改变量x的值后重新执行y的赋值语句，即：
x = 2
y = a*x**2 b*x c
print(y)
x = 4
y = a*x**2 b*x c
print(x,y)
此时结果为：
-20
4 4
到目前为止，共出现了3种不同形式的语句：第1种是表达式语句，一般通过交互式运行；第2种以print开头，也被称为输出语句，print()实际上是一个函数；第3种为最常见的赋值语句。更多关于函数的知识点请继续关注后面的内容。
延伸阅读：再看表达式的组成
实例1.1中的表达式描述为：
4*4**2 10
由数值和算术运算符组成。实例1.2中定义变量y等号右边的表达式描述为：
a*x**2 b*x c
此时由变量、数值和算术运算符组成。当表达式中有变量时，在计算该表达式的值时，会用变量的当前值代替变量，即：
y = -2*1**2 24*1 -60
事实上，以上过程执行的是赋值运算，既然是运算，也可以看作是一种表达式，即赋值表达式。
3．变量的初始化
每个变量在被使用前都需要赋予初始值，否则程序将会提示错误。例如，在Shell中直接输入：
>>> d
Traceback (most recent call last):
File “”, line 1, in
d
NameError: name ‘d’ is not defined
提示报错内容为变量d未被定义。如果在脚本文件中稍做修改，在语句c=-60前加上#号：
#c = -60
再次运行脚本，程序也会出错：
Traceback (most recent call last):
File “D:工作Python科学计算编程入门与实战程序chapter1parabola2.py”,
line 6, in
y = -a*x**2 b*x c
NameError: name ‘c’ is not defined
报错内容为变量c未定义。#号的作用是将其后的代码行注释掉，被注释掉的语句在运行时将会被忽略，即赋值语句c=-60被忽略了，程序在给变量y赋值时，找不到变量c就会报错。这也意味着，计算机运算时变量必须被定义且赋予初始值。
在提示错误后的Shell中继续输入如下内容：
>>> a
-2
>>> b
20
>>> c
Traceback (most recent call last):
File “”, line 1, in
c
NameError: name ‘c’ is not defined
>>> y
Traceback (most recent call last):
File “”, line 1, in
y
NameError: name ‘y’ is not defined
不难发现，变量a和b都可以进行访问，而访问变量c和y时报错，提示未定义。原因是Python程序在执行时是自上而下逐行按顺序执行，后面的错误代码并不影响前面正确代码的运行。
延伸阅读：解释器、Bug和Debug
解释器
编写完成的*.py文件想要运行，必须通过解释器，解释器就是执行Python代码的程序，如IDLE的Shell就是一个解释器。Python有多种版本的解释器，它们分别基于不同的计算机语言开发，下面简要介绍几种解释器。
l CPython：Python官方解释器，从官网下载并安装完成后，就直接获得了解释器CPython。其第一个字母以C开头，是因为该解释器由C语言开发，在运行*.py文件时，实际上就是启动CPython解释器执行。CPython是使用最广泛的Python解释器。
l IPython：基于CPython的另一个交互式解释器，其交互功能相比IDLE的Shell有大幅度的增强，但执行代码的功能和CPython完全一样。
l PyPy：用Python语言实现的解释器，其针对CPython的缺点进行了各方面的改良，在执行效率上有较大的提升，但由于并没有得到官方支持，第三方库的使用受限，所以并没有被广泛使用。
l Jython：是将Python代码编译成Java字节码实现的，在Java虚拟机（JVM）上运行，类似于翻译。
l IronPython：与Jython类似，只不过它是将代码编译成可以在微软.net平台上运行的解释器。
解释器也是一个计算机程序，对于不同的平台（操作系统），编写兼容的解释器可实现Python语言的跨平台。
Bug和Debug
代码中的错误被称为Bug，找到并修改代码中的错误也就被称为Debug，中文也称为代码调试。并不是所有的代码在运行时都会抛出异常（报错），有些代码可以正常运行，但计算结果错误；有些代码要正确运行需要有一定的条件，后续章节中将进行介绍。Debug是一个普通但又有很强挑战性的工作。
对于前文所示的运行脚本，本质上是解释器首先逐行执行语言语句，执行过程为：
>>> a = -2
>>> b = 24
>>> c = -60
>>> x = 1
>>> y = a*x**2 b*x c
>>> print(y)
-38
然后在Shell中访问变量的值：
>>> a
-2
>>> x
1
或者将变量组成表达式：
>>> y*a*c*0.1
-456.0
交互式地访问变量的值可以不使用print语句，而在运行脚本时观察变量值的变化，可以使用print语句，所以print语句常用于程序调试。
延伸阅读：整数和浮点数
Python自带的数据类型数字（Numbers）有两种类型，即整数和浮点数，分别用于描述数学中的整数和小数。前面例子中的1、-2为整数，-456.0为浮点数。在数学中，1和1.0可以认为没有区别，但在计算机语言中，1和1.0却是两种不同的数据类型，二者的值域、占用的内存空间都不同。可以通过type()函数获取数据类型，调用sys模块中的getsizeof()函数查看占用的空间大小。在Shell中输入如下语句：
>>> a = 2
>>> b = 2.0
>>> type(a)
>>> type(b)
>>> import sys
>>> sys.getsizeof(a) #单位字节
28
>>> sys.getsizeof(b)
24
不难发现，a和b的类型并不一样，分别为class（类）int和class float。更多关于class的知识请关注后续内容。
整数和浮点数可以通过int()和float()函数进行类型转换：
>>> int(12.0)
12
>>> float(12)
12.0
整数和浮点数算术运算，规则如下：
l 整数与整数的运算结果是整数；
l 浮点数和浮点数的运算结果是浮点数；
l 整数和浮点数的运算结果是浮点数。
%注意：多条语句写在同一行时需要用分号（;）隔开，但这种写法并不方便阅读。
>>> 1 1;1*1
2
1
>>> 1.2*1.2;1.1 1
1.44
2.1
4．变量的命名规则
Python中的变量名可以由字母、下划线和数字组成，但不能以数字开头，不能和关键字重名，且大小写敏感，即X和x是不同的变量。
在Shell中输入如下命令可以访问当前版本中的常见关键词：
>>> help(“keywords”)
Here is a list of the Python keywords. Enter any keyword to get more help.
False def if raise
None del import return
True elif in try
and else is while
as except lambda with
assert finally nonlocal yield
break for not
class from or
continue global pass
关键词就是已经被Python使用过的名字。暂时可以不用理会这些关键词的具体意义，在后续的章节中将会介绍到。
%注意：help()和前面的print()与type()都是函数。
描述性的变量名能增强代码的可读性，如下面将parabola2.py文件中的变量名进行更改，计算结果不变。
coeffiect_a = -2
coeffiect_b = 20
coeffiect_c = -60
CoordinateX = -2
CoordinateY = coeffiect_a*CoordinateX**2
coeffiect_b*CoordinateX coeffiect_c
print(CoordinateY)
以上的变量名对每一个变量都进行了描述，但似乎并没有让代码可读性更强，而且可以说变得更差了，还增加了编写程序时输入代码的工作量，当然对于提供代码补齐功能的编辑器而言这都不是问题（IDLE通过“ALT /”组合键实现代码补齐功能）。究其原因，是因为我们对抛物线公式非常熟悉，能深刻理解每一个符号的意义，让变量和数学公式符号对应更符合我们的思维习惯。
以上给变量y赋值的语句中，为了不让语句过长而牺牲代码的美观性和可读性，可以采用“”实现续行，其作用为解释器会将两行代码当作一条完整的语句执行，而并不会当作两条语句。
【实例1.3】 求半径为3cm铁球的质量。
铁球的质量等于密度与体积的乘积，公式如下：
（1.3）
由于密度符号ρ并不常见，可以将其命名为density更便于理解；圆周率π没有对应的字母描述，可以取其发音pi；其他符号都很熟悉，所以保持不变。
>>> density = 7.8 #密度
>>> pi = 3.14 #π
>>> r = 3 #半径
>>> v = 4/3*pi*r**3 #体积
>>> m = density*v #质量
>>> m
881.7119999999999
综上所述，在选择变量名时，笔者的建议是，如果公式中的符号意义便于理解且容易表达，则将变量名与公式符号对应，否则可根据符号的英文发音或其英文名称进行命名。同时，笔者推荐变量命名全部小写，独立的单词之间用下划线隔开，比如my_name、little_ potato等。
延伸阅读：计算机程序严格的句法
语句是计算机程序的最小执行单元，每一条语句都要严格按照计算机程序的句法规则执行，拼写错误、逻辑错误等会导致程序中断。试将下面的语句写进文件syntax.py：
var = 10
prinnt(Var)
y = var b
b = 23
该段程序中的错误有3处：
l prinnt拼写错误，应为print，解释器找不到未定义的prinnt；
l Python对大小写敏感，Var和var是不同的变量，解释器找不到未定义的Var；
l 变量b定义在使用之后，由于程序逐行执行，运行到第3行时，解释器找不到未定义的b。
虽然有3处错误，但解释器在执行时每次只会提示一个错误，这是因为程序在遇到错误时会自动中断。以上段程序为例，在执行第2句时，prinnt拼写错误，则程序终止并提示prinnt未定义。
Traceback (most recent call last):
File “D:工作Python科学计算基础程序chapter1syntax.py”, line 2, in
prinnt(Var)
NameError: name ‘prinnt’ is not defined
将print修改正确后，后面的错误会陆续被提示。通过反复提示和修改，最终将得到如下正确的程序：
var = 10
print(var)
b = 23
y = var b
很多IDE都提供了代码编写检查功能，以上错误在程序编辑时会自动提示。虽然IDLE并没有这项功能，但作者仍然采用IDLE来进行教学的原因是，作为一个初学者，过度依赖编辑器的强大功能无疑会弱化编程能力，降低学习效果。假如一个程序员能使用最简单的编辑器编写正确的程序，那么他再使用功能更强大的编辑器也是信手拈来。因此笔者的建议是，新手不要贪图简单、上手容易就使用Anaconda或Pycharm等IDE，而通过辅助功能简单的IDLE“锤炼”后，再去使用这些功能强大（可偷懒）的IDE。
1.2.3 注释
除了变量的命名更规范外，给代码添加注释（Comments）是增加程序可读性的另一个办法。Python中常用的注释方法有两种，分别为单行注释和多行注释。
1．单行注释
单行注释以“#”开头，对于实例1.2脚本文件parabola2.py中的程序，给出如下的解释性注释：
#计算抛物线公式的程序
a = -2 #系数a
b = 20 #系数b
c = -60 #系数c
x = -2 #横坐标x
y = a*x**2 b*x c #横坐标x对应的纵坐标y
print(y) #打印纵坐标y
该程序的运行结果与未注释的程序的运行结果完全相同，但可读性更好。#符号的作用是本行#后的内容将被忽略，所以可以在语句的后面添加#符号进行注释，也可以另起一行独立添加注释。
2．多行注释
要实现一个多行注释可以有两种方法，第一种方法是在注释的每一行前面加上#，例如：
#这是一个Python注释
#它可以增强代码的可读性
#程序员应该多写注释
a = 2
……
第二种方法是使用3个成对的单引号或双引号将注释包裹在其中，例如：
”’
这是一个Python注释
它可以增强代码的可读性
程序员应该多写注释
”’
a = 2
……
或者：
“””
这是一个Python注释
它可以增强代码的可读性
程序员应该多写注释
“””
a = 2
……
在IDLE中，ALT 3和ALT 4是快速注释和取消注释的快捷键。
赏心悦目的注释也是需要大量实践的，例如：注释过的变量、语句不再重复注释；对于在数学公式中未曾出现的变量予以解释性注释等。
【实例1.4】 描述物体垂直上抛运动。
新建一个模块文件comment.py，并在其中写入：
“””
这是一段描述垂直上抛运动的程序。
变量介绍:
g —> 浮点数类型，重力加速度，单位m/s^2
v0 –> 浮点数类型，物体上抛时的初始速度，m/s
t —> 浮点数类型，时间，单位s
y —> 浮点数类型，t时刻物体的高度，单位m
输入: g,v0,t
输出: y
“””
g = 9.8
v0 = 30
t = 2
y = v0*t – 0.5*g*t**2
print(y)
上段程序描述垂直上抛运动，并给出了一个比较直观的多行注释。注释也可以用于代码调试，比如代码描述一个非常复杂的逻辑时，程序可以正常运行，但计算结果错误，可以将程序按逻辑先后顺序分为多个单元，然后按单元逐一执行程序，执行前面的单元时可注释掉后面的单元，待执行的单元要执行时取消其注释即可。
1.2.4 格式化输出
前文实例的输出语句中，通过print()函数仅在屏幕上打印出了变量值，但缺乏描述。为了让程序变得更易懂，例如在屏幕上打印出如下结果：
当横坐标x=1时，对应的纵坐标y=-38。
可以通过修改parabola2.py文件的print(y)语句实现：
print(“当横坐标x=%d时,对应的纵坐标y=%d.”%(x,y))
以上语句如何工作？首先了解一个概念——函数（Function）。前文中的print、help和type语句本质上是对函数的调用。函数有三要素：函数名、括号及括号内的参数，例如：
>>> print(“我喜欢Python科学计算”)
我喜欢Python科学计算
print为函数名，字符串“我喜欢Python科学计算”是参数，参数在括号内，括号必须成对出现。更多关于函数的细节，请关注1.3节。本书中在函数后面加上()以示与变量的区别。
到目前为止，我们接触了Python中的两种数据类型，即整数型（int）和浮点数型（float）。这里介绍第三种数据类型，以成对单引号、双引号和三引号（都是半角字符）包裹的数据类型被称为字符串（str），用以描述符号和文字等，可以通过type()函数查看数据类型：
>>> type(“我喜欢Python科学计算”)
print()函数不仅可以单独打印出数字和字符串，也可以同时打印出多种不同的类型，只是参数间需要用逗号（,）隔开：
>>> print(“I love Python”,20)
I love Python 20
前面的两个字符串“我喜欢Python科学计算”和I love Python中都没有变量，如果想要让字符串中带有变量输出，可以通过字符串格式化输出来实现，即在变量位置使用占位符，例如：
>>> a = 1
>>> print(“带两个小数点的浮点数%0.2f”%a)
带两个小数点的浮点数1.00
>>> print(“输出整数%d”%10.2)
输出整数10
此处的占位符由百分号（%）和一个英文字母组成，字符串末尾紧跟百分号（%）和变量或值（统称为对象，详见1.2.5小节），该结构组成一个字符串，作为print()函数的参数。百分号（%）后的英文字母表示要输出对象的格式，如f表示输出浮点数，f前的0.2表示两位有效数字，d表示输出十进制整数。当对象的类型与占位符输出类型不一致时，解释器会自动执行类型转换，例如在上例中，整数1的输出为浮点数1.00，浮点数10.2的输出为整数10。更多的占位符说明可参考表1.1。
上面的例子只有一个占位符，当有多个对象需要在一个字符串中格式化输出时，可以在相应的位置放上占位符，字符串后紧跟百分号、括号及括号中的对象，对象之间用逗号（,）隔开。比如：
>>> print(“我是%s,我今年%d岁”%(“老裴”,34)) #%s代表输出格式为字符串
我是老裴,我今年34岁
>>> name = “Python”
>>> print(“我是%s,我今年%d岁,我喜欢%s”%(“老裴”,34,name))
我是老裴,我今年34岁,我喜欢Python
>>> print(“我是%d,我今年%s岁”%(34,”老裴”))
我是34,我今年老裴岁
不难发现，占位符顺序应与括号内的对象顺序保持一致。
表1.1 百分号（%）用法常见占位符
格式化输出的优点在于，字符串的输出内容会随着对象的变化而变化。
1.2.5 初识对象和类
1．对象（Objects）
上一节中，将整数34、浮点数1.0、字符串“老裴”等统称为对象。很多初学者也常听到这样的话：Python中的一切皆对象。那么什么是对象呢？先看下面的赋值语句：
a = 3
Python解释器分三步来执行该赋值语句：
（1）创建变量a。
（2）创建一个整数对象（int object），该对象的值为3。创建一个对象可以理解为计算机在内存空间中分配一块区域用于存储该对象。
（3）建立变量与整数对象之间的对应关系，该种关系在Python中也叫引用（Reference），变量指向对象，这类似于其他语言中的指针。
对象有3个特性，标识符、类型和值。在CPython中标识符为对象的内存地址，通过调用内置函数id()获取：
>>> a = 3
>>> id(a)
1379691600
对象的类型通过调用type()函数获取：
>>> type(a)
对象的类型用于判断对象之间的运算，对象的值通过变量访问：
>>> a
3
因此前文所说的变量值实际上是一个对象，与对象值是不同的概念，但将对象代入表达式运算时会调用对象值。变量是一种特殊的存在，变量没有类型，也不存储值，而只存储对象的内存地址，如图1.8所示。访问变量时，首先根据内存地址来找到内存位置，然后访问内存中的对象。
图1.8 变量与对象的关系
重新给变量赋值，变量将与新的对象建立引用，例如：
>>> a = “Python”
>>> id(a)
2595166640816
可以看到，变量a指向的内存地址由1379691600（该地址存储整数对象3）变为了2595166 640816（该地址存储字符串对象“Python”）。
总结解释器执行下面语句的过程。
a = 3
a = “Python”
变量a仅仅扮演了对象名的角色，对于赋值语句a = 3，解释器意识到语句等号右边是一个整数，于是会创建一个整数对象（int object），其值为3，然后让变量a作为该整数对象的名字；对于第二条语句也是同样的过程，当解释器意识到语句等号右边是一个字符串时，会创建一个值为“Python”的字符串对象（str object），然后将变量a作为该字符串对象的名字，也就是建立了变量a到字符串对象Python的引用。
对象可以同时被多个变量引用，例如：
>>> a = 3
>>> b = a
>>> id(a)
1379691600
>>> id(b)
1379691600
变量a和b的内存地址相同，解释器在执行赋值语句b=a时并没有创建一个新整数对象，而是建立了b与整数对象3的引用，b可以看作是对象3的另外一个名字。继续在Shell中输入：
>>> c = 3
>>> d = 4
>>> id(c)
1379691600
>>> id(d)
1379691632
变量c也是整数对象3的别名，此时有3个变量同时引用了同一个对象。继续在Shell中输入：
>>> a = 4
>>> id(a)
1379691632
此时变量a和d引用整数对象4，变量b和c引用整数对象3。上述过程中的变量与对象的引用如图1.9所示。
图1.9 引用的变化
2．类（Class）
如果将Python看成另一个世界，那么Python中的对象就好比是人类世界中存在的实实在在的物件，例如将一个整数类比成一个苹果，或将一个浮点数类比成一台计算机等，各种各样的对象组成Python程序世界。
类的作用是将实实在在的物件抽象并归类，让世界变得更有序。例如，现实世界中有人说“我喜欢吃苹果”和“我想吃放在客厅茶几上的苹果”，前者是指一种水果名称，后者是一个具体实物，前者是对现实世界中满足相同特征事物的统称，后者是组成世界的实体。相应地，在Python世界里，相同的数据类型被归为同一类，比如整数类、浮点数类、字符串类等，类本身不组成Python世界，因为它只是对象的名称，而组成世界的是对象，如2、3.0、Python等。类就像一张空支票，必须填入具体的值才是对象。调用type()函数查看对象的类型，显示结果为class xxx，表示该对象属于xxx类。
>>> a = 2
>>> type(a)
>>> b = 3.0
>>> type(b)
>>> c = “Python”
>>> type(c)
如果读者觉得对象和类比较抽象，大可不必着急，阅读完第3章的内容，再回过头来看相信会有更深刻的理解。
1.2.6 运算符
在前面章节的讲解中，我们仅使用了加法运算（ ）、减法运算（-）、乘法运算（*）、幂运算（**）及赋值运算（=）。接下来将介绍更多的运算符，包括算术运算符、赋值运算符、比较运算符和逻辑运算符。
1．算术运算符
算术运算符用于描述数学中的算术运算。Python中常见的见算术运算符如表1.2所示。
表1.2 常见的算术运算符
（续）
延伸阅读：Python 2与Python 3的除法比较
在Python 2中，如果没有特别的说明，整数的除法运算都是整除，即
>>> 1/2 #输出对象类型不发生转换
0
>>> 1./2 #输出对象与浮点数对象一致
0.5
在Python 3中，取消了这样的运算机制，所有的除法都是真除。
2．赋值运算符
赋值运算是程序中特有的一种运算，实现变量与对象之间的引用建立。Python中的常见赋值运算符如表1.3所示。
表1.3 Python中常见的赋值运算符
延伸阅读：Python中的多重赋值
Python中提供了多重赋值的功能，让代码更简洁、优雅，或者说更Pythonic。例如下面的赋值语句：
a = 1
b = 2
可以用一条语句实现：
a,b = 1,2
还可以通过下面的语句快速实现引用的交换：
a,b = b,a
【实例1.5】 计算平面直角坐标系中的距离。
（1）点(2, 6)到点(5, 9)的距离。
（2）点(4, 3)到直线3x 2y 5=0的距离。
（3）平行直线5x 2y 1=0与5x 2y 4=0之间的距离。
上面的3个问题涉及点到点的距离计算公式、点到直线的距离计算公式，以及平行线之间的距离计算公式。
点到点的距离计算公式：已知两点坐标分别为P1(x1, y1), P2(x2, y2)，则有
点到直线的距离计算公式：已知点的坐标P0(x0, y0)和直线l:Ax By C=0，则有
平行直线间的距离计算公式：已知平行直线l1:Ax By C1=0和l2:Ax By C2=0，则有
以上3个公式中，需要进行绝对值和开平方运算，开平方可以用幂运算，绝对值运算需要调用内置函数abs()。将点的坐标与直线的系数定义为变量，新建一个distance.py文件，并在其中输入：
#点到点的距离计算
x1,y1 = 2,6
x2,y2 = 5,9
d1 = ((x1-x2)**2 (y1-y2)**2)**0.5
print(“点(%.2f,%.2f)到点(%.2f,%.2f)的距离为%.2f”%(x1,y1,x2,y2,d1))
#点到直线的距离计算
x0,y0 = 4,3
A,B,C = 3,2,5
d2 = abs(A*x0 B*y0 C)/(A**2 B**2)**0.5
print(“点(%0.2f,%0.2f)到直线%dx %dy %d=0的距离为%.2f”%(x0,y0,A,B,C,d2))
#平行直线之间的距离计算
A1,B1 = 5,2
C1,C2 = 1,4
d3 = abs(C1-C2)/(A1**2 B1**2)**0.5
s = “平行直线%dx %dy %d=0到%dx %dy %d=0的距离为%.2f”%(A1,B1,C1,A1,B1,C2,d3)
print(s)
程序运行结果：
点(2.00,6.00)到点(5.00,9.00)的距离为4.24
点(4.00,3.00)到直线3x 2y 5=0的距离为6.38
平行直线5x 2y 1=0到5x 2y 4=0的距离为0.56
总结前面的知识不难发现，用计算机描述公式必须给公式中的符号赋予初始值，即创建各种对象，例如给定具体的点坐标或直线系数，因为程序世界是由对象组成的。
3．比较运算符
比较运算符用于描述数学中的比较运算。Python中的比较运算返回一种新的数据类型——布尔（bool）类型。bool类型只取两个值，即True或False，代表运算结果是真或假，本质上是1和0。常见的比较运算符如表1.4所示。
表1.4 Python中常见的比较运算符
比较运算返回的是bool对象，例如：
>>> a = 1 == 2 #将对象1与2进行比较运算的结果赋予变量a
>>> a
False
>>> type(a)
>>> b = 2 > 3 #将对象2与3进行比较运算的结果赋予变量b
>>> type(b)
无论是算术运算还是比较运算，对象本身首先要支持该类运算，否则解释器将无法执行。比如整数对象与字符串对象执行算术运算和比较运算将会失效。举例如下：
>>> 1 “12”
Traceback (most recent call last):
File “”, line 1, in
1 “12”
TypeError: unsupported operand type(s) for : ‘int’ and ‘str’
>>> 1 < “12”
Traceback (most recent call last):
File “”, line 1, in
1 < “12”
TypeError: ‘
延伸阅读：Python中运算符的书写规则
为了让代码看起来更流畅、美观，增加可读性，一般在=、 和-运算符的前后加空格，而/、%、**及//运算符的前后不加空格。例如：
y = a*x**2 b*x c
f = f/a c**2 – d//2
【实例1.6】 a和b均为正数，举例说明以下不等式的正确性。
在Shell中举例证明如下：
>>> a,b = 2,1
>>> expr1 = 2*a*b/(a b)
>>> expr2 = (a*b)**0.5
>>> expr3 = (a b)/2
>>> expr4 = (a**2 b**2)/2
>>> expr1 <= expr2
True
>>> expr2 <= expr3
True
>>> expr3 <= expr4
True
>>> flag = expr1 <= expr2 <= expr3 <= expr4 #将比较运算的结果值赋给变量flag
>>> flag
True
总结前文的实例不难发现，因为程序世界由对象组成，所以计算机程序擅长的是实证，而不是抽象的数学证明。
4．逻辑运算符
逻辑运算是一种用数学方法研究逻辑问题的运算，也称为bool运算。Python中常见的逻辑运算如表1.5所示。
表1.5 Python中常见的逻辑运算
【实例1.7】 任意给定一个年份，判断是否属于闰年。
闰年包括普通闰年和世纪闰年，前者是4的倍数且不是100的倍数，后者是400的倍数。判断某年是否是闰年需观察其是否能被4、100或400整除。以2004为例：
>>> year = 2004
>>> flag1 = year%4
>>> flag2 = year%100
>>> flag3 = year%400
>>> flag1,flag2,flag3
(0, 4, 4)
下面实现逻辑运算，即能被4整除且不能被100整除，或能被400整除：
>>> flag = (flag1 == 0 and flag2 !=0) or (flag3 == 0)
>>> flag
True
反过来，如果不是闰年，即不能被4整除，或能被4整除也能被100整除但不能被400整除：
>>> flag = not(flag1 !=0 or (flag1==0 and flag2==0) and flag3 !=0)
>>> flag
True
反过来分析较之直接判断要稍显复杂。
以上就是对Python中常见运算符的介绍，后续的章节中还会详细介绍这些运算符的使用。
根据前文中对表达式的定义可知，表达式不仅可以用于描述数学公式，也可以用于描述不等式和逻辑关系。更多的表达式形式包括赋值运算表达式、比较运算表达式和逻辑运算表达式等。
5．运算优先级
通过前面的实例可以发现，Python中运算符的优先级和与数学中的运算优先级一致，**（幂运算）最高，其他算术运算次之，比较运算紧随其后，赋值运算最低，如表1.6所示。当然，为了提高优先级，可采用括号。对于复杂的计算公式，为了让代码的可读性更强，在编写代码时多使用括号是明智的做法。
表1.6 Python中运算符的优先级
科学计算中会频繁使用一些特殊函数和常数，如对数函数、平方根函数，圆周率和自然常数等。如何在Python中快捷地使用这些函数和常数呢？接下来的章节将具体介绍。
评论
还没有评论。