Python数字类型：整型、长整型、布尔型、双精度浮点型、十进制浮点型、复数

  • 整型一般以十进制表示

  • 八进制整型以数字0开始

  • 十六进制整型以0x或0X开始

  • 复数属性

    • num.real        该复数的实部

    • num.imag        该复数的虚部

    • mun.conjugate    返回该复数的共轭复数

>>> aComplex = -8.333-1.47j
>>> aComplex
(-8.3330000000000002-1.47j)
>>> aComplex.real
-8.3330000000000002
>>> aComplex.imag
-1.47
>>> aComplex.conjugate

>>> aComplex.conjugate()
(-8.3330000000000002+1.47j)


算术操作符

1、传统除法

>>> 1 / 2
0

2、from __future__ import division指令，可以实现真正的除法运算

>>> from __future__ import division
>>> 1 / 2
0.5


位操作符

  • 取反（~）

  • 按位与（&）

  • 或（|）

  • 异或（^）

  • 左移（<<）

  • 右移（<<）


内建函数

  • cmp()    比较两个数的大小，用1或-1、0表示

  • str()     将数字转换为字符串

  • type()    返回数字对象的类型



数字类型函数

1、转换工厂函数

    函数int()、long()、float()、和complex()用来将其他数值类型转换为相应的数值类型。

2、内建函数示例

>>> int(4.22121)
4
>>> long(43)
43L
>>> float(4)
4.0
>>> complex(4)
(4+0j)
>>> complex(2.4, -8)
(2.3999999999999999-8j)
>>> complex(2.3e-10, 45.3e4)
(2.3000000000000001e-10+453000j)


功能函数

    python有5个运算内建函数用于数值运算：abs()、coerce()、divmod()、pow()和round()

1、abs()返回给定参数的绝对值

>>> abs(-34)
34
>>> abs(10.)
10.0
>>> abs(1.2-2.1j)
2.4186773244895652
>>> abs(0.23 - 0.78)
0.55000000000000004


2、coerce()函数，数据类型转换函数

coerce()函数仅返回一个包含类型转换完毕的两个数值元素的元组

>>> coerce(1,2)
(1, 2)
>>> coerce(1.3, 134L)
(1.3, 134.0)
>>> coerce(1, 134L)
(1L, 134L)
>>> coerce(1j, 134L)
(1j, (134+0j))
>>> coerce(1.23-41j, 134j)
((1.23-41j), 134j)


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

>>> divmod(10,3)
(3, 1)
>>> divmod(10,2)
(5, 0)
>>> divmod(3,10)
(0, 3)
>>> divmod(10,2.5)
(4.0, 0.0)
>>> divmod(2.5,10)
(0.0, 2.5)
>>> divmod(2+1j, 0.5-1j)
__main__:1: DeprecationWarning: complex divmod(), // and % are deprecated
(0j, (2+1j))


4、pow()函数和双星号(**) 操作符都可以进行指数运算。不过二者的区别并不仅仅在于一个是操作符，一个是内建函数。

>>> pow(2,5)
32
>>> pow(2,8)
256
>>> pow(5,2)
25
>>> pow(3.141592, 2)
9.8696002944640018
>>> pow(1+1j, 3)
(-2+2j)


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

>>> round(3)
3.0
>>> round(3.2)
3.0
>>> round(3.121)
3.0
>>> round(3.45)
3.0
>>> round(3.45212121212)
3.0

>>> import math
>>> for i in range(10):
...     print round(math.pi, i)
... 
3.0
3.1
3.14
3.142
3.1416
3.14159
3.141593
3.1415927
3.14159265
3.141592654

>>> round(-3.5)
-4.0
>>> round(-3.8)
-4.0
>>> round(-3.2)
-3.0
>>> round(-3.49)
-3.0
>>> round(-3.49, 1)
-3.5

    round()、int()、math.floor()这几个函数好像做的同一件事，很容易将他们弄混，下面列出他们之间的不同之处。

  • 函数int()直接解去小数部分（返回值为整型）

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

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

下面的例子用4个正数和4个复数作为这三个函数的参数，将返回结果列在一起做个比较：

>>> import math
>>> for eachNum in (.2, .7, 1.2, 1.7, -.2, -.7, -1.2, -1.7):
...     print "int(%.1f) \t%+.1f" % (eachNum, float(int(eachNum)))
...     print "floor(%.1f) \t%+.1f" % (eachNum, math.floor(eachNum))
...     print "round(%.1f) \t%+.1f" % (eachNum, round(eachNum))
...     print '-' * 20
... 
int(0.2)     +0.0
floor(0.2)     +0.0
round(0.2)     +0.0
--------------------
int(0.7)     +0.0
floor(0.7)     +0.0
round(0.7)     +1.0
--------------------
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(-0.2)     +0.0
floor(-0.2)     -1.0
round(-0.2)     -0.0
--------------------
int(-0.7)     +0.0
floor(-0.7)     -1.0
round(-0.7)     -1.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
--------------------

数值运算内建函数

函数
 功能
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=1)
 接受一个浮点型flt并对其四舍五入，保存ndig位小数。若不提供ndig参数，则默认小数后0位




仅用于整型的函数

1、进制转换函数

Python除了支持十进制转换，同时也支持八进制和十六进制整型。Python提供了两个内建函数来返回字符串表示的八进制和十六进制中整型，分别是oct()和hex()。它们接受一个整型（任意进制的）对象，并返回一个对应的字符串对象。

>>> hex(255)
'0xff'
>>> hex(230948231)
'0xdc3fd87'
>>> hex(65535*2)
'0x1fffe'
>>> 
>>> oct(255)
'0377'
>>> oct(777)
'01411'
>>> oct(230948231)
'01560776607'
>>> oct(65535*2)
'0377776'


2、ASCII转换函数

Python也提供了ASCII（美国标准信息交换码）码与其序列值之间的转换函数。每个字符对应一个唯一的整型（0~255）。对所有使用ASCII表的计算机来说，这个数值是不变的。这保证了不同系统之间程序行为的一致性。函数chr()接受一个单字节整型值，返回一个字符串，其值为对应的字符。函数ord()则相反，它接受一个字符，返回其对应的整型值。

>>> ord('a')
97
>>> ord('A')
65
>>> ord('b')
98
>>> ord('c')
99
>>> ord('f')
102
>>> ord('0')
48
>>> 
>>> chr(97)
'a'
>>> chr(1)
'\x01'
>>> chr(2)
'\x02'
>>> chr(33)
'!'
>>> chr(34)
'"'
>>> chr(35)
'#'

>>> chr(65L)
'A'
>>> chr(66L)
'B'


仅适用于整型的内建函数

函数
 操作
hex(num)
 将数字转换成十六进制数并以字符串形式返回
oct(num)
 将数字转换成八   进制数并以字符串形式返回
chr(num)
 将ASCII值的数字转换成ASCII字符，范围只能是0<=num<=255
ord(chr)
 接受一个ASCII或Unicode字符（长度为1的字符串），返回相应的ASCII值或Unicode值
unichr(num)
 接受Unicode码值，返回其对应的Unicode字符。所接受的码值范围依赖于你的Python是构建于UCS-2还是UCS-4


其他数字类型

1、布尔数（True和False，对应1和0）

  • 有两个永不改变的值True和False

  • 布尔型是整型的子类

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

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

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

>>> bool

>>> bool(1)
True
>>> bool(0)
False
>>> bool(2)
True
>>> bool(True)
True
>>> bool('1')
True
>>> bool('0')
True
>>> bool([])
False
>>> bool('')
False
>>> bool({})
False
>>> bool((1,))
True
>>> bool(())
False
>>> 

# 使用布尔数
>>> foo = 42
>>> bar = foo < 100
>>> bar
True
>>> print bar + 100
101
>>> print '%s' % bar
True
>>> print '%d' % bar
1
>>> 

# 无__nonzero__()
>>> class C: pass
... 
>>> c = C()
>>> bool(c)
True
>>> bool(C)
True
>>> 
>>> 

# 重载__nonzero__() 使它返回False
>>> class C:
...     def __nonzero__(self):
...         return False
... 
>>> c = C()
>>> bool(c)
False
>>> bool(C)
True


十进制浮点型

可以通过字符串或其他十进制数创建十进制浮点型。需要导入decimal模块以使用Decimal类

>>> from decimal import Decimal
>>> dec = Decimal('.1')    数值要用引号引起
>>> dec
Decimal('0.1')
>>> print dec
0.1

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


random模块