数字类型

python3.0,忽略开场白，直面主题……
----------------------------------------------------------------------------------------------
数字类型（numeric type basics）
在python中，数字不是一个真正的对象类型，而是一组类似类型的类别（not a single type,but a category of similar types）
它包括：Ⅰ整数和浮点数
        Ⅱ复数
        Ⅲ 固定精度的十进制数
        Ⅳ 有理分数
        Ⅴ集合
        Ⅵ 布尔类型
        Ⅶ 不限精度的整数
        Ⅷ 各种数字内置函数和模块
----------------------------------------------------------------------------------------------
数字常量（numeric literals）
（假设你已经了解C语言的整数和浮点数类型。）
在3.0中，一般整数（32位）和长整数（无限精度）已经合二为一了

十六进制数，八进制数，二进制数
十六进制以0x或0X开头，八进制数以0o或0O开头，二进制数以0b或0B开头
内置函数hex(I)，oct(I)，bin（I）可以将整数转换成相应格式
int（str， base）将一个数字字符串str按照进制base转换成一个整数
eval(str),也能有同样效果，但是str必须说明数字字符串的基数，如‘0o40’
>>> int(0o12),int('41', 8),int('1101', 2),eval('0x13')
(10, 33, 13, 19)

复数：实部+虚部，real+imag,a+bi或a+bJ
也可以用函数complex（real，imag）创建复数对象

类型转换：有隐式的转换，也有显示的转换。隐式转换在表达式中体现，显示转换可以用类似下面的表达式：
>>> int(3.123)
3
>>> float(3)
3.0
>>> bin(13)
'0b1101'
----------------------------------------------------------------------------------------------
python操作符
位置越往下，优先级越高;在混合类型表达式中，操作对象首先被转换成最复杂的对象

1.在3.0中除法有两种，真除法（true division）和截断除法（floor division），截断除法又分操作数为整数和负数两种情况
X / Y：真除法，在3.0中，当不能整除时，不论操作数是怎样的，结果都会带有小数部分
X // Y：截断除法，且是向下的截断。Ⅰ：当操作数为正数时，截除余数的小数部分，但并非真的一定没有小数部分。它依赖于操作数的类型：如果操作数中有一个浮点数，结果就带一位小数，并且小数位是0，如10/4=2.0（不是2.5，更不是2）；否则，结果就是一个整数。Ⅱ：当操作数为负数时，通常向下截断也会有效，但是可以通过math模块函数获得向上截断的效果
math模块中的截断：
>>> import math
>>> math.floor(2.5)
 2
>>> math.floor(-2.5)
-2
>>> math.trunc(2.5)
 2
>>> math.trunc(-2.5)
-2
>>> 5 / /-2
-3

2.比较
比较的结果为布尔型，且支持连续的比较如：X > Y > Z，等同于X > Y and Y > Z，并且连续的比较可能速度会更快点

3.[...]：列表，用于表示列表常量或列表解析式
  X[i: j: k]等同于X[slice（i，j，k)]，分片对象索引
4.(...)：元组，表达式，生成器表达式（generator expression）语法
5.{...}：字典（dictionary）语法，可以表示集合常量以及字典和集合解析
-----------------------------------------------------------------------------------
数字变量
Ⅰ变量在它第一次赋值时被创建
Ⅱ变量在表达式中将被替换为值
Ⅲ 变量在使用前必须赋值
Ⅳ 变量像对象一样不需要声明

数字显示格式
>>> 1/3
0.33333333333333331                        #echo as code
>>> print(1/3)
0.333333333333                             #echo as user-friendly form
>>> repr(1/3)                                 
'0.33333333333333331'                      #用数字字符串显示
>>> str(1/3)                                    
'0.333333333333'                           
>>> '%e' % (1/3)
'3.333333e-01'                             #带e的浮点数字符串
>>> '%-7.2f' % (1/3)
'0.33   '                                  #带长度和小数位数和对齐的数字字符串
>>> '%7.2f' % (1/3)
'   0.33'
>>> '{0:7.2f}'.format(1/3)                 #格式化字符串
'   0.33'
>>> '{0:o},{1:x},{2:b}'.format(64, 64, 64)
'100,40,1000000'
>>> '%o, %d, %x' % (13, 13, 13)            #格式输出，但不支持二进制数的方式
'15, 13, d'
------------------------------------------------------------------------------
小数类型
小数通过导入模块来创建
从功能上看，小数对象就是有固定的位数和精度的浮点数。浮点数缺乏精确性：
>>> 0.1 + 0.1 + 0.1 -0.3
5.5511151231257827e-17
>>> Decimal('0.1') + Decimal('0.1') + Decimal('0.1') - Decimal('0.3')
Decimal('0.0')
>>> Decimal('0.1') + Decimal('0.1') + Decimal('0.1') - Decimal('0.30')
Decimal('0.00')

小数类型可以通过decimal.getcontext().prec设置全局精度
也可以通过decimal.localcontext设置临时精度
--------------------------------------------------------------------------------------
分数类型
分数也是通过导入模块的方式创建：
>>> from fractions import Fraction
>>> x = Fraction(1, 3)
>>> x
Fraction(1, 3)
>>> print(x)
1/3

也可以通过浮点数字符串来创建：
>>> Fraction('1.25')
Fraction(5, 4)

分数会保持精确性：
>>> Fraction(5, 4) + Fraction(1, 3)
Fraction(19, 12)

混合类型转换，简单的例子如下：
>>> Fraction.from_float(1.25)
Fraction(5, 4)
>>> (1.25).as_integer_ratio()
(5, 4)
----------------------------------------------------------------------------------
集合（set）
这是唯一的，不可变的，一个无序集合，这些对象支持数学集合理论的定义和运算

用表达式的方法创建集合，以及集合的运算：
>>> x = set('abcdf')
>>> y = set('cdfxyz')
>>> x
{'a', 'c', 'b', 'd', 'f'}
>>> y
{'c', 'd', 'f', 'y', 'x', 'z'}
>>> 'a' in x
True
>>> x - y                                            #属于x集合并且x，y不同的元素
{'a', 'b'}
>>> x | y
{'a', 'c', 'b', 'd', 'f', 'y', 'x', 'z'}
>>> x & y
{'c', 'd', 'f'}
>>> x ^ y
{'a', 'b', 'y', 'x', 'z'}
>>> x > y                                            #x是否包含y
False

用函数创建集合，和表示集合运算：
>>> s = set('spam')
>>> s
{'a', 'p', 's', 'm'}
>>> s.add('alot')
>>> s
{'a', 'p', 's', 'm', 'alot'}
>>> t = set('spa')
>>> t
{'a', 'p', 's'}
>>> t.issubset(s)
True
>>> s.intersection(t)
{'a', 'p', 's'}
>>> t.add('u')
>>> t
{'a', 'p', 's', 'u'}
>>> s.union(t)
{'a', 'm', 'p', 's', 'u', 'alot'}
>>> s.remove('a')
>>> s
{'m', 'p', 's', 'alot'}

集合解析创建
在大括号中，使用集合解析式，可以创建一个集合。集合解析式，通常是一个循环表达式
>>> a = {x**2 for x in[1,2,3,4]}
>>> a
{16, 1, 4, 9}
>>> b = {c*2 for c in 'spam'}                     #“*”在此表示重复
>>> b
{'ss', 'aa', 'pp', 'mm'}

集合只能包含不可变的对象类型，因此列表和字典不能包含其中，但是元组是可以嵌入的如果想在集合中嵌入集合，可以先用frozenset创建一个集合，然后再把它嵌入的其他集合中
>>> v = frozenset('insert')
>>> v
frozenset({'e', 'i', 'n', 's', 'r', 't'})
>>> s.add(v)
>>> s
{ frozenset({'e', 'i', 'n', 's', 'r', 't'}), 'm', 'p', 's', 'alot'}
--------------------------------------------------------------------------------------------
布尔类型
>>> type(True)

>>> isinstance(False, int)
True
以上结果显示，布尔类型有两个实例：True，和False，并且同时，它们也是整数类型的实例