python 计算机核心数,二、Python'核心编程（数字）

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 

>>> 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模块