让我们开始用 Python 探索数学与科学的世界。本章将从一些简单的问题开始，这样你就可以逐渐了解如何使用 Python。首先是基础的数学运算，随后编写简单的程序来操作和理解数字。

1 基本数学运算

本书中，Python 交互界面将成为我们的朋友。启动 Python 3 的 IDLE 界面，键入print(‘Hello IDLE’)，然后按 Enter 键，在屏幕上输出 Hello IDLE（见图 1-1）。关于如何安装 Python 并启动 IDLE 的说明，请参阅附录 A。IDLE 会按照输入的命令执行，并将单词输出到屏幕上。恭喜你，你刚刚已经编写了一个程序！

当再次看到“>>>”提示时，IDLE 已准备好接收更多的指令。

Python 可以像一个神奇的计算器那样进行简单的计算。只要输入一个表达式， Python 就会对它进行计算。按 Enter 键后，结果会立刻显示。

1-1 Python 3 的 IDLE 界面

试试看。你可以使用加法（+）和减法（−）运算符来加减数字。例如：

>>> 1 + 2 3 >>> 1 + 3.5 4.5 >>> -1 + 2.5 1.5 >>> 100 – 45 55 >>> -1.1 + 5 3.9

使用乘法运算符（*）进行乘法运算：

>>> 3 * 2 6 >>> 3.5 * 1.5 5.25

使用除法运算符（/）进行除法运算：

>>> 3 / 21.5 >>> 4 / 2 2.0

如你所见，当要求 Python 执行除法运算时，它也会返回数字的小数部分。

如果希望结果为整数形式，则应该使用向下取整除法运算符（//）：

>>> 3 // 2 1

向下取整除法运算符将第一个数字除以第二个数字，然后将结果向下取整到最接近的小的整数。当其中一个数字为负数时，这将变得有趣。例如：

>>> -3 // 2 -2

最终结果是小于除法运算结果的整数（除法运算结果是−3/2 = −1.5，所以最终结果是−2）。

另一方面，如果只需要余数，则应该使用模运算符（%）：

>>> 9 % 2 1

可以使用指数运算符（**）计算数字的幂。下面的例子展示了这一点：

>>> 2 ** 2 4 >>> 2 ** 10 1024 >>> 1 ** 10 1

我们也可以使用指数运算符号计算指数小于 1 的幂。例如，n 的平方根可以表示

n2/1，立方根表示为n3/1:

>>> 8 ** (1/3) 2.0

你也可以使用括号将数学运算式组合成更复杂的表达式。Python 会按照标准的 PEMDAS 规则评估表达式的计算顺序—括号、指数、乘法、除法、加法和减法。考虑以下两个表达式，一个没有括号，而另一个有括号：

>>> 5 + 5 * 5 30 >>> (5 + 5) * 5 50

在第一个表达式中，Python 首先计算乘法：5 乘以 5 等于 25；25 加 5 等于 30。在第二个表达式中，Python 首先计算括号中的表达式，正如我们预期的：5 加 5 等10；10 乘以 5 等于 50。

这些是在 Python 中操作数字的最基本原则。接下来我们学习如何给数字命名。

2 标签：给数字命名

当开始设计更复杂的 Python 程序时，我们会给数字命名，有些时候是为了方便，但大部分情况是出于必要。这里有一个简单的例子：

达相同的想法的。然而，考虑到变量也是一个数学术语（例如在方程式 x +2 = 3 中的x），为了避免概念上的混淆，本书只在数学方程式和表达式语境中使用变量这个术语。

3 不同类型的数字

你可能注意到了，之前在介绍数学运算时我们使用了两类数字—没有小数点的数字（称为整数）以及带有小数点的数字（称为浮点数）。无论数字是整数、浮点数、分数，还是罗马数字，人类都能很容易地识别和处理它们。但是，本书编写的一些程序只有在某些特定类型的数字上执行才有意义，所以我们经常需要编写代码来检查是否输入了正确的数字类型。

Python 将整数和浮点数视为不同的类型。如果使用 type()函数，Python 会显示你刚刚输入的数字类型。例如：

>>> type(3) <class 'int'> >>> type(3.5) <class 'float'> >>> type(3.0) <class 'float'>

在这里，你可以看到 Python 将数字 3 分类为整数（类型“int”），但将 3.0 分类为浮点数（类型“float”）。我们都知道 3 和 3.0 在数学上是等同的，但是在许多情况下，Python 会以不同的方式处理这两个数字，因为它们是两种不同的数字类型。

我们在本章中编写的一些程序仅在输入为整数的情况下才能正常工作。正如我们刚刚看到的那样，Python 不会将 1.0 或 4.0 这样的数字识别为整数，所以如果我们想将类似的数字作为这些程序的有效输入，我们必须把它们从浮点数转换为整数。幸运的是，Python 内置的一个函数可以做到这点：

>>> int(3.8) 3 >>> int(3.0) 3

int()函数获取输入的浮点数，去掉小数点后的所有内容，返回得到的整数。float()

函数的工作原理有点儿类似，但它是执行反向的转换：

>>> float(3) 3.0

float()获取输入的整数，并在整数后添加一个小数点，将其转换为浮点数。

3.1 分数的操作

Python 也可以操作分数，但要做到这一点，我们需要使用 Python 的 fractions

模块。你可以将模块视为由他人编写的程序，但你可以在自己的程序中使用。模块包括类、函数甚至标签定义。它可以是 Python 标准库的一部分，也可以从第三方位置分发。在后一种情况下，你必须先安装该模块才能使用它。

fractions 模块是标准库的一部分，意味着它已经安装了。它定义了一个类Fraction，这是用来在我们的程序中输入分数的。在使用之前，我们需要导入（import）该模块，这是一种通知 Python 我们要使用这个模块中的类的方法。我们来看一个简单的例子，创建一个新的标签 f，它指代的是分数 3/4：

3.2 复数

{到目前为止，我们看到的数字是所谓的实数。Python 还支持复数，其中虚部由字母 j 或 J 标识（与在数学符号中常用字母 i 来表示不同）。例如，复数 2 + 3i 在 Python 中表示为 2 + 3j：

>>> a = 2 + 3j >>> type(a) <class 'complex'>

正如你所看到的，当我们对一个复数使用 type()函数时，Python 告诉我们这是一个复数类型的对象。

你还可以使用 complex()函数定义复数：

>>> a = complex(2, 3) >>> a (2 + 3j)

这里我们将复数的实部和虚部作为两个参数传递给 complex()函数，并返回一个复数。

你可以用与实数相同的方式对复数进行加减运算：

>>> b = 3 + 3j >>> a + b (5 + 6j) >>> a - b (-1 + 0j)

复数的乘法和除法也可以进行类似的操作：

>>> a * b (-3 + 15j) >>> a / b (0.8333333333333334 + 0.16666666666666666j)

但模（%）和向下取整除法（//）操作对复数无效。

可以使用 real 和 imag 属性来提取复数的实部和虚部，如下所示：

>>> z = 2 + 3j >>> z.real 2.0 >>> z.imag 3.0

复数的共轭（conjugate）具有相同的实部，但是具有相同大小和相反符号的虚部。可以使用 conjugate()函数获得：

>>> z.conjugate() (2 - 3j)

当编写程序时，使用 input()函数接收用户输入是一种简单且友好的方法。通过它我们可以编写要求用户输入数字的程序，对用户输入的数字执行特定的操作，然

这两个函数就是我们之前看到的 int()函数和 float()函数，但是这次，不是将输入从一类数字转换为另一类，而是将一个字符串作为输入（’1’）并返回一个数字（2或2.0）。然而，有一点要注意，int()函数不能将包含浮点数的字符串转换为整数。如果将一个具有浮点数的字符串（例如“2.5”或“2.0”）输入 int()函数中，你会收到一条错误消息：

>>> int('2.0') Traceback (most recent call last):   File "<pyshell#26>", line 1, in <module>     int('2.0') ValueError: invalid literal for int() with base 10: '2.0'

这是一个异常（exception）的例子，Python 以这种方式告诉你，由于错误它不能继续执行你的程序。在这种情况下，异常是 ValueError 类型（有关异常情况的简单回顾，请参阅附录 B）。

同样，当你输入一个分数如 3/4 时，Python 不能将其转换为等价的浮点数或整数，再次引发 ValueError 异常：

>>> a = float(input()) 3/4 Traceback (most recent call last): File "<pyshell#25>", line 1, in <module>   a=float(input()) ValueError: could not convert string to float: '3/4'

你可能会发现在 try…except 块中执行转换非常有用，这样你就可以处理此异常并提醒用户程序遇到无效输入。下面我们来看看 try…except 的程序块。

4.1 处理异常和无效输入

{:-:}如果你不熟悉 try…except，这里简单介绍一下它的基本思想：如果你在一个 try…except 程序块中执行一个或多个语句，一旦执行出错，你的程序不会崩溃，而是输出一个 Traceback。然后，程序的执行转移到 except 后的块，你可以在其中执行适当的操作，例如，输出有用的错误消息或尝试其他操作。

下面使用 try…except 块执行之前的转换，并在输入无效时输出一条有用的错误消息：

>>> try:  a = float(input('Enter a number: ')) except ValueError:  print('You entered an invalid number')

请注意，我们需要指定要处理的异常类型。在这里，因为要处理 ValueError 异常，所以将异常类型指定为 except ValueError。

>>> a = int(input()) 1.0Traceback (most recent call last):   File "<pyshell#42>", line 1, in <module>     a=int(input()) ValueError: invalid literal for int() with base 10: '1.0'

为了避免这个错误，我们可以设置一个 ValueError 捕获，就像我们之前看到的那样。这样一来，该程序将捕获浮点数，而这在针对整数的程序中则不起作用。然而，它也会标记像 1.0 和 2.0 这样的数字，Python 将这些数字视为浮点数，但是这些数字等同于整数，如果将它们作为正确的 Python 类型输入，就可正常工作。

为了解决这个问题，我们将使用 is_integer()函数来过滤小数点后带有效数字的任何数字（此方法仅针对 Python 中的 float 类型的数字，不适用于已经以整数形式输入的数字）。

这里有一个例子：

>>> 1.1.is_integer() False

在这里，我们调用 is_integer()来检查 1.1 是否为整数，结果为 False，因为 1.1 是一个浮点数。而将 1.0 作为浮点数调用时，检查结果为 True：

>>> 1.0.is_integer() True

我们可以使用 is_integer()过滤掉非整数输入，同时保留 1.0 这样的输入，即表示为浮点数，但等价于整数。稍后我们会看到该方法如何应用于更大的程序。

4.2 将分数和复数作为输入

我们之前学到的 Fraction 类还能够将字符串（例如’3/4’）转换为 Fraction 对象。

事实上，这就是我们接收分数作为输入的方法：

>>> a = Fraction(input('Enter a fraction: ')) Enter a fraction: 3/4>>> aFraction(3, 4)

尝试输入一个分数，如 3/0：

>>> a = Fraction(input('Enter a fraction: ')) Enter a fraction: 3/0Traceback (most recent call last):   File "<pyshell#2>", line 1, in <module>     a= Fraction(input('Enter a fraction: '))  File "/usr/lib64/python3.3/fractions.py", line 167, in __new__    raise ZeroDivisionError('Fraction(%s, 0)' % numerator) ZeroDivisionError: Fraction(3, 0)

ZeroDivisionError 异常信息告诉我们（如同你已经知道的），分母为 0 的分数无效。如果你计划让用户在某个程序中将分数作为输入，最好始终捕获此类异常。你可以这样做：

>>> try:        a= Fraction(input('Enter a fraction: ')) except ZeroDivisionError:    print('Invalid fraction') Enter a fraction: 3/0Invalid fraction

现在，每当程序的用户输入分母为 0 的分数时，Python 将输出分数无效（Invalid

fraction）的信息。

类似地，complex()函数可以将诸如’2+3j’的字符串转换为复数：

>>> z = complex(input('Enter a complex number: ')) Enter a complex number: 2+3j>>> z(2+3j)

如果你输入的字符串为’2 + 3j’（带空格），则会导致 ValueError 错误信息：

>>> z = complex(input('Enter a complex number: ')) Enter a complex number: 2 + 3jTraceback (most recent call last):   File "<pyshell#43>", line 1, in <module>     z= complex(input('Enter a complex number: ')) ValueError: complex() arg is a malformed string

{当将字符串转换为复数时，最好捕获 ValueError 异常，就像我们对其他数字类型所做的那样。

5 编写一个数学计算程序

现在我们已经学习了一些基本的概念，我们可以将它们与 Python 的条件语句和循环语句结合起来，编写一些更高级、更有用的程序。

5.1 计算整数因子

当非零整数 a 除另一个整数 b，余数为0时，a 称为 b 的因子。例如，2_是所有偶数整数的因子。我们可以编写下面的函数来确定非零整数 a 是否是另一个整数 b _的因子：

>>> def is_factor(a, b):         if b % a == 0:             return True         else:             return False

我们使用本章前面介绍的%运算符来计算余数。如果你发现自己在问“4 是不是1024 的因子”这类问题，可以使用 is_factor()函数得到答案：

>>> is_factor(4, 1024) True

对于任何正整数 n，如何找到其所有的正因子？对于1和 n 之间的每个整数，我们检查 n 除以该整数后的余数。如果余数为_0，那么这个整数就是一个因子。使用 range()函数来编写一个程序，它将遍历 1 到 _n 之间的每个数字。

在编写完整的程序之前，先来看看 range()如何工作。range()函数的典型用法如下所示：

>>> for i in range(1, 4):  print(i) 1 2 3

在这里，我们设置了一个 for 循环，并给 range()函数传入了两个参数。range()函数从第一个整数参数（起始值）开始，一直到第二个整数参数（停止值）截止。在这个例子中，我们告诉 Python 输出该范围内的数字，从 1 开始，到 4 停止。注意，这意味着 Python 不会输出 4，所以最后输出的数字是停止值之前的数字 3。同时也要注意，range()函数只接收整数作为参数。

你也可以不指定 range()函数的起始值，在这种情况下，起始值被假定为 0。

例如：

>>> for i in range(5):  print(i) 0 1 2 3 4

{:-:}range()函数产生的两个连续整数之间的差称为步长值（step value）。默认情况下，步长值为 1。要定义其他的步长值，请将其指定为第三个参数（这时，需指定起始值）。例如，下面的程序将输出 10 以下的奇数：

>>> for i in range(1,10,2):  print(i) 1 3 5 7 9

我们已经了解了 range()函数是如何工作的，接下来考虑一个因子计算程序。因为我们将要编写一个相当长的程序，所以在 IDLE 编辑器里编写，而不是在交互式

IDLE 界面中。你可以在 IDLE 中选择 File->New Window（或者 New File）来启动编辑器。请注意，我们首先用三个单引号（’）来注释代码，这些引号之间的文本不会被 Python 作为程序的一部分执行，它们只是我们对程序的注释。

5.2 生成乘法表

考虑三个数字 a、b 和 n，其中 n 是整数，使得 a×n = b。此处我们可以说，b是 a 的第 n 个倍数。例如，4是2的第二个倍数，1024是2的第512个倍数。

一个数字的乘法表列出了该数字的所有倍数。例如，2 的乘法表是这样的（这里给出了 2 的前三个倍数）：

2×1=2

2×2=4

2×3=6

我们的下一个程序就是为用户输入的任何数字生成最大到乘数 10 的乘法表。在这个程序中，我们将使用 format()函数与 print()函数来使程序的输出看起来更友好、更可读。下面简要介绍一下它的工作原理。

format()函数可以插入标签并对其进行设置，以获得一个友好的、可读的字符串输出。例如，假设我们有在杂货店购买的所有水果的名称，并为每种水果创建了单独的标签，现在想输出一个连贯的句子，可以使用 format()函数：

>>> item1 = 'apples' >>> item2 = 'bananas' >>> item3 = 'grapes' >>> print('At the grocery store, I bought some {0} and {1} and {2}'.format(item1, item2, item3)) At the grocery store, I bought some apples and bananas and grapes

首先，我们创建了三个标签（item1、item2 和 item3），每个标签指代不同的字符串（苹果、香蕉和葡萄）。然后，在 print()函数中，我们键入字符串，它包含了三个在大括号中的占位符，分别为{0}、{1}和{2}。接下来是.format()，它的参数为之前创建的三个标签，这会告诉 Python 按照列出的顺序，用这些标签保存的值来填充这三个占位符，因此，在 Python 的输出文本中，第一个标签的内容替换了{0}，第二个标签的内容替换了{1}，依此类推。

{:-:}使用标签指向我们要输出的值并非必要，我们可以在.format()中直接键入值，如下例所示：

>>> print('Number 1: {0} Number 2: {1} '.format(1, 3.578)) Number 1: 1 Number 2: 3.578

请注意，占位符的数量和标签（或键入值）的数量必须相等。

了解了 format()的工作原理之后，接下来让我们看看生成乘法表的程序：

Enter a number : 55.0 x 1 = 5.0 5.0 x 2 = 10.05.0 x 3 = 15.0 5.0 x 4 = 20.0 5.0 x 5 = 25.0 5.0 x 6 = 30.0 5.0 x 7 = 35.0 5.0 x 8 = 40.0 5.0 x 9 = 45.0 5.0 x 10 = 50.0

看到这张清晰又有秩序的乘法表了吗？这正是我们使用了.format()函数，根据可读、统一的模板输出的内容。

你可以使用 format()函数来进一步控制数字输出的形式。例如，如果希望数字只有两位小数，可以参考下面的例子：

>>> '{0}'.format(1.25456) '1.25456' >>> '{0:.2f}'.format(1.25456) '1.25'

第一个 format 语句将我们输入的数字原封不动地输出。在第二个语句中，我们将占位符修改为{0:.2f}，这意味着我们只需要小数点后面的两个数字，其中 f 表示一个浮点数。如你所见，在下一个输出中，小数点后只有两个数字。请注意，如果数字小数点后的位数多于你指定的位数，则该数字将四舍五入，例如：

>>>'{0:.2f}'.format(1.25556) '1.26'

在这里，1.25556 向上取整到最接近的百分位，并输出为 1.26。如果将.2f 应用到整数上，则会在小数点后面添加零：

>>>'{0:.2f}'.format（1）'1.00'

添加两个零是因为我们指定在小数点后输出两个数字。

5.3 转换测量单位

国际单位制定了 7 个基本量，将它们用于导出其他量，其他量称为导出量。长度（包括宽度、高度和深度）、时间、质量和温度是 7 个基本量中的 4 个，它们各自都有一个标准的计量单位，分别为米、秒、千克和开尔文。

但是，这些标准计量单位各自也对应着多个非标准计量单位。你更熟悉温度为 30 摄氏度或 86 华氏度，而不是 303.15 开尔文。这是否意味着 303.15 开尔文比 86 华氏度还要热三倍？并非如此！我们不能仅比较 86 华氏度与 303.15 开尔文的数值，因为它们以不同的计量单位表示，即使它们测量的物理量是相同的（温度）。只有当物理量的两个数值用相同的计量单位表示时，才能比较它们。

不同计量单位之间的转换可能会很棘手，这就是为什么在高中数学课上经常被要求解决涉及不同计量单位之间转换的问题。这是测试你基本数学技能的好方法。

但是，Python 也有很多数学技能，与高中生不同的是，它不会厌倦一遍又一遍地计算数字！接下来，我们将探讨如何编写程序来执行单位转换。

我们从长度开始。在美国和英国，英寸和英里经常用于长度测量，而其他大多数国家使用厘米和千米。

1 英寸约等于 2.54 厘米，你可以使用乘法运算将英寸的计量值转换为厘米。然后你可以将以厘米为单位的计量值除以 100，获得以米为单位的计量值。例如，你可以将 25.5 英寸转换成米：

>>>（25.5 * 2.54）/ 100 0.6476999999999999

另一方面，1 英里大约相当于 1.609 千米，所以如果你看到你的目的地距你 650 英里，那么换算成国际单位的距离应该是 650×1.609 千米：

>>> 650 * 1.6091045.85

现在来看一下温度转换—从华氏温度到摄氏温度，以及反向转换。使用以下公式将以华氏度表示的温度转换成摄氏度温度：

这里，我们创建了一个标签C，值为37（人体正常温度，单位为摄氏度）。然后，使用公式将其转换成华氏度，结果为 98.6 华氏度。

一次又一次地编写这些转换公式是一件麻烦的事。我们编写一个可以进行单位转换的程序。该程序将提供一个菜单，允许用户选择要执行的转换，询问相关输入，然后输出计算结果。程序如下所示：

5.4 求二次方程的根

假设有一个方程式，如 x + 500−79 = 10，你需要求得未知变量 x 的值，你会怎么做？重新排列这些等式项，使常数（500、−79 和 10）在方程一侧，而变量（x）在另一侧，这将得到等式：x = 10−500 + 79。

根据右边表达式的结果得到 x 的值，即方程的解，也称为这个方程的根。在Python 中，可以执行以下操作：

>>> x = 10 - 500 + 79>>> x-411

这是一个线性方程的例子。一旦你重新排列了方程式两边的计算项，方程就容易计算了。另外，对于x2+2x+1=0这样的方程式，求 x _的值通常涉及计算一个被称为二次方程的复杂表达式。这些二次方程通常表示为ax2+bx + c =0，其中a、b 和c 都是常数。计算二次方程的根的公式如下：

>>> x_1 =（-b + D）/（2 * a）>>> x_1-1.0>>> x_2 =（-b - D）/（2 * a）>>> x_2-1.0

在这个例子中，两个根的值是相同的，如果将该值代入方程x2+2x+1，则方程的计算结果为 0。

我们的下一个程序将实现把所有这些步骤组合到 roots()函数中，该函数将 a、b和 c 的值作为参数，计算并输出所有的根：

'''Quadratic equation root calculator'''def roots(a,b,c):    D =(b * b-4 * a * c)** 0.5    x_1 =(-b + D)/(2 * a)    x_2 =(-b - D)/(2 * a)    print('x1:{0}'.format(x_1))    print('x2:{0}'.format(x_2))if__name__ =='__main__':    a = input('Enter a:')    b = input('Enter b:')    c = input('Enter c:')    roots(float(a),float(b),float(c))

在这段程序中，首先，我们使用标签 a、b 和 c 来指代二次方程中三个常数的值。然后，我们将这三个值作为参数调用 roots()函数（先将它们转换为浮点数），将 a、b 和 c 代入二次方程的公式中，计算并输出该方程的根。

当你执行程序时，首先询问输入 a、b 和 c 的值，这些值对应于用户想要计算的根的二次方程。

Enter a: 1Enter b: 2Enter c: 1x1：-1.000000x2：-1.000000

尝试求解一些 a、b、c 取不同常数值时的二次方程，程序将正确地找到根。可能你知道二次方程也可以有复数的根。例如，方程 x2+x+1=0__的根都是复数。以

上程序也能让你求解这类方程。让我们再次执行程序（常数是 a = 1、b = 1_和 c _= 1）：

Enter a: 1Enter b: 1Enter c: 1x1: (-0.49999999999999994+0.8660254037844386j)x2: (-0.5-0.8660254037844386j)

以上输出的根是复数（用 j 表示），程序可以很好地计算和显示它们。