Python入门篇之数字

数字类型
 
数字提供了标量贮存和直接访问。它是不可更改类型，也就是说变更数字的值会生成新的对象。当然，这个过程无论对程序员还是对用户都是透明的，并不会影响软件的开发方式。 Python 支持多种数字类型：整型、长整型、布尔型、双精度浮点型、十进制浮点型和复数。
创建数值对象并用其赋值
(数字对象)
创建数值对象和给变量赋值一样同样简单：

复制代码 代码如下:

>>> anInt=1
>>> along=-555555555555L
>>> afloat=3.141595468565
>>> acomplex=1.334+4.5433j

更新数字对象

通过给数字对象（重新）赋值， 您可以“更新”一个数值对象。我们之所以给更新这两个字加上引号，是因为实际上你并没有更新该对象的原始数值。这是因为数值对象是不可改变对象。Python 的对象模型与常规对象模型有些不同。你所认为的更新实际上是生成了一个新的数值对象，并得到它的引用。 在学习编程的过程中， 我们一直接受这样的教育，变量就像一个盒子， 里面装着变量的值。在Python中，变量更像一个指针指向装变量值的盒子。对不可改变类型来说，你无法改变盒子的内容，但你可以将指针指向一个新盒子。每次将另外的数字赋给变量的时候，实际上创建了一个新的对象并把它赋给变量.(不仅仅是数字，对于所有的不可变类型，都是这么回事)

复制代码 代码如下:

anInt += 1
aFloat = 2.718281828

通过下面的代码测试：
 

复制代码 代码如下:

>>> anInt=1
>>> id(anInt)
10416152
>>> anInt+=1
>>> id(anInt)
10416140

如何删除数字对象

按照Python的法则，你无法真正删除一个数值对象，你仅仅是不再使用它而已。如果你实际上想删除一个数值对象的引用，使用del语句。删除对象的引用之后，你就不能再使用这个引用(变量名)， 除非你给它赋一个新值。如果试图使用一个已经被删除的对象引用，会引发 NameError 异常。

复制代码 代码如下:

del anInt
del aLong, aFloat, aComplex 

Python的四种主要数字类型
 
1.整型
 
Python 有几种整数类型。布尔类型是只有两个值的整型。常规整型是绝大多数现代系统都能识别的整型。Python 也有长整数类型。然而，它表示的数值大小远超过C 语言的长整数。下面我们先来了解一下这些类型，然后再来研究那些用于Python整数类型的运算符和内建函数。
 
1.1 布尔型

Python 从版本 2.3 开始支持布尔类型。该类型的取值范围只有两个值，也就是布尔值 True和布尔值 False。

1.2 标准整数类型

Python 的标准整数类型是最通用的数字类型。在大多数32位机器上，标准整数类型的取值范围是-231到231-1，也就是-2,147,483,648到2,147,483,647。如果在64位机器上使用64位编译器编译Python，那么在这个系统上的整数将是 64 位。下面是一些 Python 标准整数类型对象的例子：
0101 84 -237 0x80 017 -680 -0X92
Python标准整数类型等价于C的（有符号）长整型。整数一般以十进制表示，但是 Python也支持八进制或十六进制来表示整数。如果八进制整数以数字“0”开始， 十六进制整数则以“0x”或“0X”开始。

1.3 长整型

关于Python长整数类型我们必须要提的是，请不要将它和C或其它编译型语言的长整数类型混淆。那些语言的长整数典型的取值范围是32位或64位。Python的长整数类型能表达的数值仅仅与你的机器支持的(虚拟)内存大小有关，换句话说，Python 能轻松表达很大很大很大的整数。长整数类型是标准整数类型的超集，当你的程序需要使用比标准整数类型更大的整数时，长整数类型就有用武之地了。在一个整数值后面加个 L（大写或小写都可以），表示这个整数是长整数。这个整数可以是十进制，八进制，或十六进制。下面是一些长整数的例子：

复制代码 代码如下:

16384L -0x4E8L 017L -2147483648l 052144364L
299792458l 0xDECADEDEADBEEFBADFEEDDEAL -5432101234L
Edit By Vheavens
Edit By Vheavens

核心风格：用大写字母 “L”表示长整数，目前整型和长整型正在逐渐缓慢的统一，您只有在对长整数调用repr()函数时才有机会看到“L”，如果对长整数对象调用 str()函数就看不到 L。举例如下：

复制代码 代码如下:

>>> aLong = 999999999l
>>> aLong
999999999L
>>> print aLong
999999999 

1.4 整型和长整型的统一
 
这两种整数类型正在逐渐统一为一种。在 Python 2.2 以前，标准整数类型对象超出取值范围会溢出（比如上面提到的大于 232 的数），但是从 Python2.2 以后就再也没有这样的错误了。
 

复制代码 代码如下:

>>> 9999 ** 8
Traceback (most recent call last):
File "", line 1, in ?
OverflowError: integer exponentiation
Python 2.2
>>> 9999 ** 8
99920027994400699944002799920001L 

双精度浮点数
 
Python中的浮点数类似C语言中的double类型，是双精度浮点数，可以用直接的十进制或科学计数法表示。每个浮点数占8个字节（64比特），完全遵守IEEE754号规范（52M/11E/1S），其中52个比特用于表示底，11个比特用于表示指数（可表示的范围大约是正负 10 的 308.25次方），剩下的一个比特表示符号。这看上去相当完美，然而，实际精度依赖于机器架构和创建 Python 解释器的编译器。浮点数值通常都有一个小数点和一个可选的后缀e(大写或小写，表示科学计数法)。在e和指数之间可以用正（+）或负（-）表示指数的正负（正数的话可以省略符号）。下面是一些典型的浮点数值的例子：
 

复制代码 代码如下:

0.0 -777. 1.6 -5.555567119 96e3 * 1.0
4.3e25 9.384e-23 -2.172818 float(12) 1.000000001
3.1416 4.2E-10 -90. 6.022e23 -1.609E-19 

复数 
 
一个实数和一个虚数的组合构成一个复数。一个复数是一对有序浮点数(x, y)。表示为x + yj，其中x是实数部分，y是虚数部分。渐渐的复数在日常运算,机械,电子等行业获得了广泛的应用。由于一些研究人员不断的重复制造用于复数运算的工具，在很久以前的Python1.4 版本里，复数终于成为一个真正的Python 数据类型。
下面是 Python 语言中有关复数的几个概念：

虚数不能单独存在，它们总是和一个值为 0.0 的实数部分一起来构成一个复数。

复数由实数部分和虚数部分构成

表示虚数的语法： real+imagj

实数部分和虚数部分都是浮点数

虚数部分必须有后缀j或J。

1.复数的内建属性
复数对象拥有数据属性，分别为该复数的实部和虚部。复数还拥有conjugate 方法，调用它可以返回该复数的共轭复数对象。
 
复数属性

属性                   描述
num.real             该复数的实部
num num.imag         该复数的虚部
num.conjugate()      返回该复数的共轭复数

复制代码 代码如下:

>>> c=2.3+2.5j
>>> c.real
2.3
>>> c.imag
2.5
>>> c.conjugate()
(2.3-2.5j)

运算符
 
数值类型可进行多种运算。从标准运算符到数值运算符，甚至还有专门的整数运算符。

5.5.1 混合模式运算符

Python支持不同的数字类型相加。当一个整数和一个浮点数相加时， 系统会决定使用整数加法还是浮点数加法（实际上并不存在混合运算）。Python使用数字类型强制转换的方法来解决数字类型不一致的问题，也就是说它会强制将一个操作数转换为同另一个操作数相同的数据类型。这种操作不是随意进行的， 它遵循以下基本规则:
 
首先，如果两个操作数都是同一种数据类型，没有必要进行类型转换。仅当两个操作数类型不一致时， Python才会去检查一个操作数是否可以转换为另一类型的操作数。如果可以，转换它并返回转换结果。
 
由于某些转换是不可能的，比如果将一个复数转换为非复数类型，将一个浮点数转换为整数等等，因此转换过程必须遵守几个规则。要将一个整数转换为浮点数，只要在整数后面加个.0就可以了。要将一个非复数转换为复数，则只需要要加上一个 “0j”的虚数部分。
 
这些类型转换的基本原则是： 整数转换为浮点数，非复数转换为复数。在 Python 语言参考中这样描述coerce()方法：
如果有一个操作数是复数， 另一个操作数被转换为复数。
否则，如果有一个操作数是浮点数， 另一个操作数被转换为浮点数。
否则, 如果有一个操作数是长整数，则另一个操作数被转换为长整数；
否则，两者必然都是普通整数，无须类型转换。
数字类型之间的转换是自动进行的，程序员无须自己编码处理类型转换。Python 提供了 coerce() 内建函数来帮助你实现这种转换。
 
参见下面的流程图阐释了强制转换的规则：

算术运算符
 
Python 支持单目运算符正号（+）和负号（－）， 双目运算符， +，－，*，/，%，还有 ** ，分别表示加法，减法，乘法，除法，取余，和幂运算。从 Python2.2 起，还增加了一种新的整除运算符//。

传统除法
如果是整数除法， 传统除法会舍去小数部分，返回一个整数（地板除）。如果操作数之一是浮点数，则执行真正的除法。包括 Python 语言在内的很多语言都是这种行为。看下面的例子：

复制代码 代码如下:

>>> 1 / 2 # perform integer result (floor) # 地板除
0
>>> 1.0 / 2.0 # returns actual quotient#真正除法
0.5 

真正的除法 
 
除法运算总是返回真实的商，不管操作数是整数还是浮点数。在未来版本的 Python中，这将是除法运算的标准行为。现阶段通过执行from __future__ import division指令，也可以做到这一点。
 

复制代码 代码如下:

>>> from __future__ import division
>>>
>>> 1 / 2 # returns real quotient
0.5
>>> 1.0 / 2.0 # returns real quotient
0.5 

地板除

从Python 2.2开始，一个新的运算符//已经被增加进来，以执行地板除：// 除法不管操作数何种数值类型，总是舍去小数部分，返回数字序列中比真正的商小的最接近的数字。
 

复制代码 代码如下:

>>> 1 // 2 # floors result, returns integer # 地板除， 返回整数
0
>>> 1.0 // 2.0 # floors result, returns float # 地板除， 返回浮点数
0.0
>>> -1 // 2 # move left on number line# 返回比 –0.5 小的整数， 也就是 －1
-1 

幂运算

幂运算操作符和一元操作符之间的优先级关系比较特别:幂运算操作符比其左侧操作数的一元操作符优先级低,比起右侧操作数的一元操作符的优先级高,由于这个特性你会在算术运算符表中找到两个** .下面举几个例子:

复制代码 代码如下:

>>> 3 ** 2
9
>>> -3 ** 2 # ** 优先级高于左侧的 -
-9
>>> (-3) ** 2 # 加括号提高 -的优先级
9
>>> 4.0 ** -1.0 # ** 优先级低于右侧的 -
0.25 

第2种情况下解释器先计算3**2再取其相反数,我们需要给"-3"加上括号来得到我们希望的结果。最后一个例子，结果是4**(-1),这是按照规定的优先级获得的结果.

复制代码 代码如下:

>>> 4 ** -1 
Traceback (innermost last):
 
File "", line 1, in ?
ValueError: integer to the negative power

下面是更多 Python 数值运算的例子：

复制代码 代码如下:

>>> -442 - 77
-519
>>>
Edit By Vheavens
Edit By Vheavens                              
>>> 4 ** 3
64
>>>
>>> 4.2 ** 3.2
98.7183139527
>>> 8 / 3
2
>>> 8.0 / 3.0
2.66666666667
>>> 8 % 3
2
>>> (60. - 32.) * ( 5. / 9. )
15.5555555556
>>> 14 * 0x04
56
>>> 0170 / 4
30
>>> 0x80 + 0777
639
>>> 45L * 22L
990L
>>> 16399L + 0xA94E8L
709879L
>>> -2147483648L - 52147483648L
-54294967296L
>>> 64.375+1j + 4.23-8.5j
(68.605-7.5j)
>>> 0+1j ** 2 # same as 0+(lj**2)
(-1+0j)
>>> 1+1j ** 2 # same as 1+(lj**2)
0j
>>> (1+1j) ** 2
2j 

*位运算符（只适用于整数）
 
Python整数支持标准位运算：取反(~)，按位 与(&), 或(|) 及 异或(^) 及左移(>)。Python 这样处理位运算：
负数会被当成正数的2进制补码处理。
左移和右移N位等同于无溢出检查的2的N次幂运算：2**N。
对长整数来说, 位运算符使用一种经修改的2进制补码形式，使得符号位可以无限的向左扩展。取反(~)运算的优先级与数字单目运算符相同，是所有位操作符中优先级最高的一个。左移和右移运算的优先级次之，但低于加减法运算。与，或，异或运算优先级最低。所有位运算符按优先级高低列在表 5.4

内建函数与工厂函数
 
标准类型函数
cmp(), str() 和 type()内建函数。这些函数可以用于所有的标准类型。对数字对象来说，这些函数分别比较两个数的大小，将数字转换为字符串，以及返回数字对象的类型。

转换工厂函数
函数 int(), long(), float() 和 complex() 用来将其它数值类型转换为相应的数值类型。从Python2.3开始，Python 的标准数据类型添加了一个新成员：布尔（Boolean）类型。从此 true 和 false 现在有了常量值即 True 和 False(不再是1和0)
 
下面是一些使用内建函数的示例：

复制代码 代码如下:

>>> int(4.25555)
4
>>> long(42)
42L
>>> float(4)
4.0
>>> complex(4)
(4+0j)
>>>>>> complex(2.4, -8)
(2.4-8j)
>>>
>>> complex(2.3e-10, 45.3e4)
(2.3e-10+453000j)

功能函数
Python 有五个运算内建函数用于数值运算： abs(), coerce(), divmod(), pow(), pow() 和 round()。我们将对这些函数逐一浏览，并给出一些有用的例子：
 
abs()返回给定参数的绝对值。如果参数是一个复数，那么就返回 math.sqrt(num.real2 + num.imag2)
 
coerce()仅回一个包含类型转换完毕的两个数值元素的元组
 
divmod()内建函数把除法和取余运算结合起来, 返回一个包含商和余数的元组。对整数来说，它的返回值就是地板除和取余操作的结果。对浮点数来说，返回的商部分是math.floor(num1/num2)，对复数来说，商部分是ath.floor((num1/num2).real)。
 

复制代码 代码如下:

>>> divmod(10, 3)
(3, 1)
>>> divmod(10, 2.5)
(4.0, 0.0)
>>> divmod(2.5, 10)
(0.0, 2.5)
>>> divmod(2+1j, 2.3+4.3j)
(0j, (2+1j))

round()用于对浮点数进行四舍五入运算。它有一个可选的小数位数参数。如果不提供小数位参数，它返回与第一个参数最接近的整数（但仍然是浮点类型）。第二个参数告诉round 函数将结果精确到小数点后指定位数。
 

复制代码 代码如下:

>>> round(3)
3.0
>>> round(3.154)
3.0
>>> round(3.499999, 1)
3.5

>>> import math
>>> for n in range(10):
    print round(math.pi, n)

3.0
3.1
3.14
3.142
3.1416
3.14159
3.141593
3.1415927
3.14159265
3.141592654

数值运算内建函数:
 
函数                               功能
abs(num)                   返回num 的绝对值
coerce(num1, num2)         将num1和num2转换为同一类型，然后以一个元组的形式返回
divmod(num1, num2)         除法－取余运算的结合。返回一个元组(num1/num2,num1 % num2)。对浮点数和复数的商进行下舍入
pow(num1, num2, mod=1)     取num1 的num2次方，如果提供mod参数，则计算结果再对mod进行取余运算
round(flt, ndig=0)         接受一个浮点数 flt 并对其四舍五入，保存 ndig位小数。若不提供ndig 参数，则默认小数点后0位
round()                    仅用于浮点数
 
仅适用于整数的内建函数: 
 
函数                     操作
hex(num)           将数字转换成十六进制数并以字符串形式返回
oct(num)           将数字转换成八进制数并以字符串形式返回
chr(num)           将ASCII值的数字转换成ASCII字符，范围只能是0 ord(chr)           接受一个 ASCII 或 Unicode 字符（长度为1的字符串），返回相应的ASCII或Unicode值。
unichr(num)        接受Unicode码值，返回 其对应的Unicode字符。所接受的码值范围依赖于你的Python是构建于UCS‐2还是UCS‐4