Python：数字

一、数字简介

数字可以直接访问，是不可更改并且不可分割的原子类型，这些在标准类型的分类中都谈到了。不可更改意味着变更数字值的实质是新对象的创建。当然，这些对于程序员来说都是透明的，不需过多考虑。

1.对象的创建和赋值

1 2 3 4 5

#像大多数脚本语言一样，无需指定类型                                                                                                                                                                                                                                                                                                                                 anInt = 1 aLong = 999999L aFloat = 3.1415 aComplex = 1.2 + 3.3j

2.更新数字对象（即重新赋值，注意其本质：新对象的创建！）

1 2	anInt += 1 aFloat = 3.1415926

3.“删除”数字对象

1

del anInt

注意：我们只是删除了对象的引用，而不是删除了对象本身（相当于使对象内部计数器的值减少1），这时anInt不引用任何对象，就行从来没有定义一样。对象本身的删除是由Python内部的内存管理功能进行的。

二、类型详解

1.整形

标准整形

标准整形是最通用的数字类型。在32位计算机中为4字节，64位计算机中8字节。标准整形是有符号的，因此你可以简单的计算出其数字范围。Python同样支持8进制（以0开始）和16进制（以0x或0X开始）表示。如：128, 100000, 0752, 0xFF,  0XFE86A

长整形

首先不要把Python的长整形和C或其它语言的同名概念混为一谈。Python长整形所能表达的数字范围和计算机的虚拟内存大小有关，也就是说，Python可以很轻松表达很大的整数。

1 2 3 4 5

3656135465463L aLong1 = 946546646L aLong2 = 10L      #后跟L申明为长整形                                                                                                                                                                                                                                                                            aLong3 = 10l      #虽然小写l也可以，但为了避免和数字1混淆                                                                                                                                                                                                                                                                                              #最好使用大写

随着Python的逐渐改进，用户会几乎感觉不到长整形的存在，运算过程中，必要时，整形会自动转换为长整形，从而使得用户将注意力集中在计算逻辑上。

2.双精度浮点型

Python中的浮点型类似C中的double，是双精度的，遵循IEEE754规范。可用10进制或者科学记数法表示：

0.0  -777.  4.2e-10  -1.69e-19

3.复数

复数语法：real + imag j  虚数不能单独存在，必须和值为0的实部部分构成复数。实数部分和虚数部分都是浮点型，虚数部分结尾必须是j或J

复数包含两个浮点属性：real(实数部分)，imag(虚数部分)，还有一个方法：conjugate()，用以获取其共轭复数。

1 2 3 4 5

aComplex = 3.5 + 2.9j aComplex   #返回(3.5+2.9j)                                                                                                                                                                                                                                       aComplex.real  #返回3.5                                                                                                                                                                                                                                       aComplex.imag  #返回2.9                                                                                                                                                                                                                                       aComplex.conjugate()  #返回(3.5-2.9j)

4.布尔型

布尔型只有两个值，“True”和“False”。事实上，布尔型是整形的子类，对于整形的1和0。使用内建函数bool返回布尔对象。布尔型在前面的笔记中已经详细讲过了，这里不再赘述。

1 2 3 4 5 6

bool()   #返回False                                                                                                                                                                                                                           bool(1)  #返回True                                                                                                                                                                                                                           bool(0)  #返回False                                                                                                                                                                                                                           bool(True)  #返回True                                                                                                                                                                                                                           bool(False) #返回False                                                                                                                                                                                                                           True + True #返回2，因bool值实质是整形

5.十进制浮点型（注意：此类型不是标准类型，是由额外模块实现的，需用import引入）

因二进制的一些特性，使其在进行金融以及科学计算时存在不准确性，这常常让程序员很恼火。使用十进制进行这些计算就会好很多，decimal模块提供的Decimal类可以帮助实现十进制运算。

1 2 3 4 5 6 7

from decimal import Decimal                                                                                                                                                                                                            #没见过上述用法？没关系，先明白意思：从模块decimal中引入Decimal类                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       decNumber = Decimal('100.32')  #包裹数字的引号是必须的！                                                                                                                                                                                                            print decNumber + Decimal('234.11')                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       decNumber + 110  #这是错误的，不可混用十进制浮点型和标准浮点型！

三、操作符

1.混合模式下的运算规则

两个不同类型的数字对象进行运算时，Python就要对其中一个进行强制类型转化，继而进行运算，这个道理和C中的自动转化是相似的。基本规则：整形转换为浮点型，非复数转换为复数。总之就是：简单类型向复杂类型转换，不精确类型向更精确类型转换。很简单的道理！

*自动转换是通过内建函数coerce()实现的，待会儿会讲到。

2.除法

传统除法“/”，和C语言中类似：

整数相除得整数：    1/2 --> 0

若除数、被除数有一个或两个都是浮点数，执行真正的除法： 1.0/2  -->  0.5

通过以下方法可以使传统除法称为真正的除法：

1 2 3

from __future__ import division                                                                                                                                                                       1/2      #得到0.5，真正的除法！                                                                                                                                                                       1.0/2.0  #得到0.5，真正的除法！

地板除法“//”，即返回商在数轴上左侧最近的整数。

整数相除得到的结果是整数：12//5 --> 2

若除数、被除数有一个或两个都是浮点数，返回的结果是浮点的： 12.0//5.0 --> 2.0

3.其它运算符

其它运算符，如求余，幂运算等签名已经讲过，内容简单，这里不再赘述；和C语言一样，位运算规则不变，这里也不再赘述。

四、内建函数与工厂函数

上一节介绍了cmp(), str(), type() 等内建函数，它们可以用于所有的标准类型。下面要介绍的是专门针对数字的内建函数。

1.转换工厂函数（注意：称之为“工厂函数”，便意味着：转换是表现，实质是创建新对象）

有五个：int(), long(), float(), complex(), bool()

1 2 3 4 5

int(4.225)       #返回4，实质是生产了一个int类型对象                                                                                                                             long(42)         #返回42L                                                                                                                             float(4)         #返回4.0                                                                                                                             complex(11, 9.0) #返回(11+9.0j)                                                                                                                             bool(0.000001)   #返回True

2.功能函数

abs()

返回绝对值，如果参数是整形，返回整形，如果是浮点型，返回浮点类型，同样也可用于复数绝对值的计算，即返回实部和虚部平方和的二次方根。

coecre()

前面提到过它，返回类型转换完毕的两个数值元素的元组：

1 2	coerce(1,1111111111111)   #返回(1L,1111111111111L)                                                                                                               coerce(12.0, 123L)        #返回(12.0, 123.0)

divmod()

此函数将除法和求余结合起来，返回一个包含商和余数的元组：

1 2	divmod(10, 3)    #返回(3, 1)                                                                                                          divmod(2.5, 10)  #返回(0.0, 2.5)

pow()

此函数的功能和"**"一样，实现指数运算：

1 2	pow(2, 5)   #返回32                                                                                                      pow(5, 2)   #返回32

round()

round()做真正的四舍五入！可以用第二个参数指定精确到小数点后第几位：

1 2 3

round(4.499)     #返回4.0                                                                                                 round(4.499, 1)  #返回4.5                                                                                                 round(4.5)       #返回5.0

注意int(), round(), floor()的区别：int直接去掉小数部分，floor取商左侧数轴上最近的整数，round是名副其实的四舍五入。

3.仅用于整形的函数

以下几个函数虽然不能发扬共产主义的好作风，但也是很有用的（但愿文章不会因这句话被河-蟹掉）：

进制转换

hex()：任意进制整数到16进制转换

oct()：任意进制整数到8进制的转换

ASCII转换函数

ord()：字符转换到ASCII码，如：ord('a')，返回97

chr()：ASCII码值转换到字符，如：chr(65)，返回'A'

unichr()：接受Unicode码值，返回相应的字符

五、相应模块

1.针对高级数学运算

对于高级的数学科学运算，可以考虑专用的第三方模块：Numeric(NumPy)，SciPy

2.Python提供了以下扩展模块，用以辅助数值运算：

decimal           实现了十进制浮点运算类Decimal

array               高效数值数组（字符，整形，浮点型等）

math/cmath   提供标准C库数学运算函数

operator         数字操作符的函数实现

random          提供多种伪随机数生成器

*使用时使用”import module_name“导入模块，使用”dir(module_name)“查看模块内容，使用“help(module_name)”获取模块相关的帮助信息

3.核心模块random

程序设计过程中，随机数的使用很频繁，以下是random模块中最常用的函数：

randint()          两个整形参数，返回两者之间的随机参数

randrange()     接受range()类似的参数，返回range(start, end, step)结果的一项

uniform()        几乎和randint一样，不过返回的是两者之间的一个浮点值

random()        返回一个0到1之间的浮点值

choice()          随机返回给定序列的一个元素

六、小结

事实上，在Python中进行数值运算，需要程序员考虑的问题和C/C++比起来少多了，从而使得我们可以将注意力放在计算逻辑上。而且，当你读完这篇笔记会发现，其实我没有讲多少，你也没有学多少，因为，太多的内容，你原来是那么的熟悉！