Python 笔记：处理数字(Working with Numbers)1

基本数学运算

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

>>> 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/2
1.5
>>> 4/2
2.0

如你所见，当要求 Python 执行除法运算时，它也会返回数字的小数部分。如果希望结果为整数形式，则应该使用向下取整除法(floor division)运算符(//):

>>> 3//2
1

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

>>> -3//2
-2

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

另一方面，如果只需要余数，则应该使用模运算符( % ):

>>> 9%2
1

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

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

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

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

你也可以使用括号将数学运算式组合成更复杂的表达式。 Python 会按照标准的 PEMDAS 规则评估表达式的计算顺序——括号(parentheses), 指数(exponents), 乘法(multiplication), 除法(division), 加法(addition) 和 减法(subtraction).

考虑以下两个表达式，一个没有括号，而另一个有括号：

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

在第一个表达式中，Python 首先计算乘法：5 乘以 5 等于 25; 25 加 5 等于 30.

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

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

标签(labels)：给数字命名

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

>>> a=3 #1
>>> a+1
4
>>> a=5 #2
>>> a+1
6

其中 # 是注释符号。井号(#)常被用作单行注释符号,在代码中使用#时,它右边的任何数据都会被忽略,当做是注释。

在 #1 处，我们将数字 3 命名为 a. 当计算表达式 a+1 的结果时，Python 发现 a 指代的值是 3, 然后将 3 加上 1, 最后显示结果 4.

在 #2 处，a 指代的值变为 5, a+1 的结果在第二次加法运算时也发生了变化。

使用名称 a 的方便之处在于，你只要简单地改变其指代的值，Python 再引用 a 这个名称时就会使用新值。

这种名称被称为标签，你可能在其他地方听到过变量(variable) 这个术语，变量也是用来表达相同的想法的。然而，考虑到变量也是一个数学术语(例如在方程式 中的 ), 为了避免概念上的混淆，本书只在数学方程式和表达式语境中使用变量这个术语。

不同类型的数字

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

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() 获取输入的整数，并在整数后添加一个小数点，将其转换为浮点数。

分数的操作

Python 也可以操作分数(fractions)，但要做到这一点，我们需要使用 Python 的 fractions 模块(module)。你可以将模块视为由他人编写的程序，但你可以在自己的程序中使用。模块包括类(classes), 函数(functions)甚至标签定义(label definitions). 它可以是 Python 标准库的一部分，也可以从第三方位置分发。在后一种情况下，你必须先安装该模块才能使用它。

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

>>> from fractions import Fraction #1
>>> f=Fraction(3,4) #2
>>> f #3
Fraction(3, 4)

#1 首先我们从 fractions 模块那里导入 Fraction 类

#2 接下来，通过传递分子和分母两个参数来创建这个类的对象，这样就为分数 3/4 创建了一个 Fraction 对象

#3 当我们输出对象时，Python 会以 Fraction(分子，分母) 的形式显示分数，即 Fraction(numerator, denominator)

基本的数学运算，包括比较运算(comparison operations), 都适用于分数(fractions). 你还可以在单个表达式中组合分数(fraction), 整数(integer)和浮点数(floating point number):

>>> Fraction(3,4)+1+1.5
3.25

当表达式中只有一个分数和一个整数时，结果就是分数，即使结果的分母为 1.

>>> Fraction(3,4)+1+Fraction(1/4)
Fraction(2, 1)

以上我们了解了在 Python 中使用分数的基础知识。接下来介绍另一类数字。

复数

到目前为止，我们看到的数字是所谓的实数。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() 函数，并返回一个复数。

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

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

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

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

但模 modulus (%) 和向下取整除法(//) 操作对复数无效。

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

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

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

>>> z=2+3j
>>> z.real
2.0
>>> z.imag
3.0
>>> z.conjugate()
(2-3j)

复数的实部和虚部均为浮点数。借助实部和虚部，你可以通过以下公式计算复数的模：, 其中 和 分别是复数的实部和虚部。在 Python 中，可以如下计算：

>>> (z.real**2+z.imag**2)**0.5
3.605551275463989

计算复数的模的一个更简单的方法是使用 abs() 函数。当使用实数作为参数调用时，abs() 函数将返回绝对值。例如，abs(5) 和 abs(-5) 都返回 5. 然而，对于复数，它返回复数的模：

>>> abs(5)
5
>>> abs(-5)
5
>>> z=2+3j
>>> abs(z)
3.605551275463989

标准的 cmath 模块（其中 c 表示复数）提供了许多专门的函数来处理复数。