Python基础：02数字

        1：Python标准整数类型等价于C的（有符号）长整型。整数一般以十进制表示，但是Python也支持八进制或十六进制来表示整数。八进制整数以数字“0”开始， 十六进制整数则以“0x”或“0X”开始。

 

        2：Python中的长整型和C或其它编译型语言的长整数不同。那些语言的长整数典型的取值范围是32位或64位。而Python的长整数类型能表达的数值仅仅与机器支持的(虚拟)内存大小有关。所以，Python能轻松表达很大很大很大的整数。

        普通用户会几乎感觉不到长整型的存在。必要时整型会悄悄自动转换为长整型。

 

        3：Python 中的浮点数类似C语言中的double类型。

 

        4：Python支持不同的数字类型相加，Python使用数字类型强制转换的方法来解决数字类型不一致的问题。

        当两个操作数类型不一致时，Python会检查一个操作数是否可以转换为另一类型的操作数。如果可以，转换它并返回转换结果。某些转换是不可能的，比如果将一个复数转换为非复数类型，将一个浮点数转换为整数等等，因此转换过程必须遵守几个规则。

        要将一个整数转换为浮点数，只要在整数后面加个 .0 就可以了。 要将一个非复数转换为复数，则只需要要加上一个 “0j”的虚数部分。这些类型转换的基本原则是： 整数转换为浮点数， 非复数转换为复数。具体描述如下：

        如果有一个操作数是复数， 另一个操作数被转换为复数。

        否则，如果有一个操作数是浮点数， 另一个操作数被转换为浮点数。

        否则，如果有一个操作数是长整数，则另一个操作数被转换为长整数；

        否则，两者必然都是普通整数，无须类型转换。

 

        5：在Python中，对整数操作数，采用传统除法，舍去小数部分（地板除），返回一个整数，如果操作数之一是浮点数，则执行真正的除法。比如：

>>> 1 / 2                          # perform integerresult (floor) # 地板除

0

>>> 1.0 / 2.0                    # returns actual quotient#真正除法

0.5

 

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

>>> from __future__ import division

>>> 

>>> 1 / 2                          # returns realquotient

0.5

>>> 1.0 / 2.0                    # returns real quotient

0.5

 

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

>>> 1 // 2           # 地板除， 返回整数

0

>>> 1.0 // 2.0     # 地板除， 返回浮点数

0.0

>>> -1 // 2          # 返回比 –0.5 小的整数， 也就是-1

-1

 

        6：位操作符

        Python整数支持标准位运算：取反(~)，按位与(&),或(|) 及异或(^)及左移(<<)和右移(>>)。Python 这样处理位运算：

        负数会被当成正数的 2 进制补码处理。

        左移和右移 N 位等同于无溢出检查的2的N次幂运算： 2**N。

        对长整数来说, 位运算符使用一种经修改的 2 进制补码形式，使得符号位可以无限的向左扩展。

        取反(~)运算的优先级与数字单目运算符相同，是所有位操作符中优先级最高的一个。 左移和右移运算的优先级次之，但低于加减法运算。与， 或， 异或运算优先级最低。所有位运算符按优先级高低列在下表中。

位运算符

 功能

~num

 单目运算，对数的每一位取反。结果为-(num+1）

num1 << num2

 Num1 左移 num2 位

num1 >> num2

 Num1 右移 num2 位

num1 & num2

 num1 与 num2 按位与

num1 ^ num2

 num1 异或 num2

num1 | num2

 num1 与 num2 按位或

        下面是几个使用整数30(011110)，45(101101)，60(111100)进行位运算的例子：

>>> 30 & 45

12

>>> 30 | 45

63

>>> 45 & 60

44

>>> 45 | 60

61

>>> ~30

-31

>>> ~45

-46

>>> 45 << 1

90

>>> 60 >> 2

15

>>> 30 ^ 45

51

 

       7：divmod函数

       divmod函数把除法和区域运算结合起来，返回一个包含商和余数的元组。对整数来说， 它的返回值就是地板除和取余操作的结果。对浮点数来说，返回的商部分是math.floor(num1/num2)。

>>> divmod(10, 3)

(3, 1)

>>> divmod(3, 10)

 (0, 3)

>>> divmod(10, 2.5)

(4.0, 0.0)

>>> divmod(2.5,10)

(0.0, 2.5)

 

       8：round函数、math.floor函数

round(number[, ndigits])

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

        round函数有时返回的结果可能不是意料之中的，比如round(2.675,2)返回2.67而不是2.68，这不是bug，而是因为大多数十进制小数不能由二进制浮点数精确的表示。（可以参考：Floating PointArithmetic: Issues and Limitations.）

>>> round(3)

3.0

>>> round(3.45)

3.0

>>> round(3.4999999)

3.0

>>> round(3.4999999, 1)

3.5

>>>round(-3.5)

-4.0

>>>round(-3.4)

-3.0

>>> round(-3.49)

-3.0

>>> round(-3.49, 1)

-3.5

        值得注意的是 round() 函数是按四舍五入的规则进行取整。也就是round(0.5)得到1，round(-0.5)得到－1。

 

        注意，如果需要对浮点数做精确度运算，还是不要用round了，因为可能会得到意想不到的结果，比如在Python 2.6.6中，有下列的例子：

>>>round(0.1,  2)

0.10000000000000001

 

        int(), round(), math.floor()不同之处：

函数 int()直接截去小数部分。（返回值为整数）

函数 floor()得到最接近原数但小于原数的整数。（返回值为浮点数）

函数 round()得到最接近原数的整数。（返回值为浮点数）

    一些例子结果如下：

int(1.2)               +1.0

floor(1.2)            +1.0

round(1.2)         +1.0

--------------------

int(1.7)               +1.0

floor(1.7)            +1.0

round(1.7)         +2.0

--------------------

int(-1.2)              -1.0

floor(-1.2)   -2.0

round(-1.2)        -1.0

--------------------

int(-1.7)              -1.0

floor(-1.7)   -2.0

round(-1.7)        -2.0

 

        9：Python 提供了两个内建函数来返回字符串表示的8进制和16进制整数。它们分别是oct()和 hex()。它们都接受一个整数（任意进制的）对象，并返回一个对应值的字符串对象。例子：

>>> hex(255)

'0xff'

>>> hex(23094823l)

'0x1606627L'

>>> hex(65535*2)

'0x1fffe'

>>> 

>>> oct(255)

'0377'

>>> oct(23094823l)

'0130063047L'

 

        10：布尔型

        从Python2.3开始，Python添加了布尔类型。

        布尔值看上去是“True” 和“False，但是事实上是整型的子类，对应与整数的1 和0。

        没有__nonzero__()方法的对象的默认值是 True。

        对于值为零的任何数字或空集（空列表、空元组和空字典等）在Python中的布尔值都是False。

        在数学运算中，Boolean值的True 和False分别对应于1 和 0。

 

        11：十进制浮点数

        从Python2.4 起（参阅PEP327）十进制浮点制成为一个Python 特性。这主要是因为下面的语句经常会让一些编写科学计算或金融应用程序的程序员抓狂：

>>> 0.1

0.1000000000000001

        之所以这样，是因为绝大多数C语言的双精度实现都遵守IEEE 754 规范，其中52 位用于底。因此浮点值只能有52位精度，十进制小数不能由二进制浮点数精确的表示。

        使用十进制来做同样的事情，感觉就会好很多，它可以有任意的精度。注意，不能混用十进制浮点数和普通的浮点数。你可以通过字符串或其它十进制数创建十进制数浮点数。必须导入 decimal 模块以便使用 Decimal 类：

>>> from decimal import Decimal

>>> dec = Decimal('.1')

>>> dec

Decimal("0.1")

>>> print dec

0.1

>>> dec + 1.0

Traceback (most recent call last): File"<stdin>", line 1, in ?

File "/usr/local/lib/python2.4/decimal.py",line 906, in __add__

other = _convert_other(other)

File "/usr/local/lib/python2.4/decimal.py",line 2863, in

_convert_other

raise TypeError, "You can interact Decimal only withint, long or

Decimal data types."

TypeError: You can interact Decimal only with int, longor Decimal data types.

>>> 

>>> dec + Decimal('1.0')

Decimal("1.1")

>>> print dec + Decimal('1.0')

1.1

        十进制数和其它数值类型一样，可以使用同样的算术运算符。浮点数，参考 http://www.zhihu.com/question/20128906