【Python学习】python学习手册--第五章 数字

数字常量

Python中常用的数字类型是整数和浮点数。
在Python2.6中整数又分为一般整数（32位）和长整数（无穷精度），并且一个整数可以用L或l结尾，让其转化成为长整数。但是在Python3.0上，这两者已经合二为一，成为一个单独的类型-整数类型。
python2.6中的数字常量：

>>> lxm=123l
>>> type(lxm)
<type 'long'>
>>> lxm2=123
>>> type(lxm2)
<type 'int'>
>>> 

python3.5中的数字常量

>>> lxm=123L
  File "<stdin>", line 1
    lxm=123L
           ^
SyntaxError: invalid syntax
>>> lxm=123
>>> type(lxm)
<class 'int'>
>>> 

还有一些其它数字类型：

• 十六进制：数字以0x或者0X开头，数字的中a~f不区分大小写。
• 八进制：数字以0o或者0O开头。
• 二级制：数字0b或0B开头。

这些数字在操作符的作用下做运算，还有内置或第三方扩展很多数学工具：

变量和基本的表达式

在python中：

• 变量在它第一次赋值时创建。
• 变量在表达式中使用将会替代为它们的值。
• 变量在表达式中使用之前必须已赋值。
• 变量像对象一样，不需要在一开始进行声明。

数字的比较（连续的和一般的）

数字类型可以进行大小比较，可以用运算符合连续运算或者一般的单独运算：

>>> 1 != 2             #在python3的版本中，不等判断只能用"!="，而在一起版本还可以用"<>"
True
>>> 1<2 
True
>>> 2<3
True
>>> 1<2 and 2<3          
True
>>> 1>2>3
False
>>> 1<2<3              #数字的连续判断，这并不是把1<2的结果与3比较，而是单纯的判断这个连续不等式是否正确。
True
>>> 

除法

• X / Y：在以前的Python2版本中，这样的除法操作会去掉小数部分，但是在python3中，将会变成真除法（任何情况下都会保留小数部分）。
• X // Y : Floor除法，这样的操作无论在Python2和Python3中都会省略结果的小数部分。

>>> 25 / 8
3.125
>>> 25 // 8
3
>>> 25 // 8.0             #无论是什么类型做除法，都会舍去小数部分。
3.0
>>> 

十六进制，八进制和二进制记数

>>> 0xf,0o7,0b1　　　　　　＃十六进制，八进制，二进制
(15, 7, 1)
>>> 

把十进制分别转化为其它进制数：

>>> oct(64),hex(64),bin(64)               #这种方法转化出来的是相应的字符串。
('0o100', '0x40', '0b1000000')
>>> int('100',8),int('40',16),int('1000000',2)  #可以用int将相应进制的数字转化为整型
(64, 64, 64)
>>> int('0o100',8),int('0x40',16),int('0b1000000',2)
(64, 64, 64)
>>> 

最后，可以使用字符串格式化方法，将一些数字转化成为固定的进制来记数。

>>> "{0:o},{1:x},{2:b}".format(64,64,64)
'100,40,1000000'
>>> 

python3.1+版本可以使用bit_length方法，查看一个整数所占的字节长度:

>>> (4).bit_length()
3
>>> (1).bit_length()
1
>>> (2).bit_length()
2
>>> (9999).bit_length()
14
>>> 

还有其它的一些数学内置工具和函数，在使用时需要导入模块，math、random等。他们中都有很多常规的数学运算，比如开方，幂运算等等。

小数数字

在计算机中，浮点数学缺乏精确性。因为用来存储数值的空间有限。

>>> 0.1+0.1+0.1
0.30000000000000004
>>> print(0.1+0.1+0.1)
0.30000000000000004
>>> 

以上程序的正确结果应该是0.3，用打印结果也不能产生正确的结果，这与硬件相关浮点数运算在精度方面有内在的缺陷。

可以使用python的小数模块解决该问题：

>>> from decimal import Decimal 
>>> Decimal('0.1')+Decimal('0.1')+Decimal('0.1')
Decimal('0.3')
>>> 

对于无限的小数，有限的内存无法表示，浮点数的局限尤为明显。分数和小数都提供了得到精确结果的办法，但是还是要付出速度上的代价。

分数

在python中使用分数时，需要导入模块：

>>> from fractions import Fraction
>>> x=Fraction(1,3)
>>> x
Fraction(1, 3)
>>> y=Fraction(1,4)
>>> x+y
Fraction(7, 12)
>>> 

分数也可以通过一些浮点数来创建：

>>> f=Fraction(0.25)
>>> f
Fraction(1, 4)

但是有些情况下浮点数不能总是可以用来创建分数，因为有些时候，这里的浮点数表示出来是不精确的：

>>> Fraction(0.33)
Fraction(5944751508129055, 18014398509481984)
>>> Fraction(0.33).limit_denominator(100)               #可以限制分母的大小来限制精度，来简化这样的效果。
Fraction(33, 100)
>>> Fraction(0.33).limit_denominator(10) 
Fraction(1, 3)

集合

在python2.4版本中，引入相关的集合概念，它是唯一的，不可变的对象的无序集合。这些对象支持数学上集合概念的相关操作（比如并集，交集等）。

>>> x=set("abcdefg")
>>> y=set("fghijkl")
>>> x={'a','b','c','d','e','f','g'}
>>> y={'f','g','h','i','j','k','l'}            #支持两种声明方式
>>> x - y
{'a', 'd', 'c', 'b', 'e'}
>>> x | y
{'b', 'a', 'h', 'k', 'l', 'e', 'd', 'j', 'g', 'c', 'i', 'f'}
>>> x & y                                      #效果与 x.intersection(y)一致
{'g', 'f'}
>>> y - x 
{'j', 'i', 'h', 'l', 'k'}
>>> x.add('z')                                 #集合中加入元素
>>> x
{'b', 'a', 'e', 'd', 'z', 'g', 'c', 'f'}
>>> 

集合作为一种可迭代的容器。也可以使用循环或者解析这样的操作：

>>> for i in x :
...  print(i)
... 
b
a
e
d
z
g
c
f
>>> {i**2 for i in {1,2,3,4,5,6}}                # 集合解析
{1, 4, 36, 9, 16, 25}
>>> 

集合是一种强大而灵活的工具，但是需要注意的是：集合只能够包含不可变的对象类型，因此列表和字典不能嵌入到集合中，具有不可变性的数据类型（数字 字符串 元组）都能加入到集合中，所以需要嵌入复合值时，只能嵌入元组来达到目的。集合本身也是不能加入到另一个集合中的，因为集合是可变的。

集合的使用

集合中的元素具有唯一性，利用这个特点，可以去掉其它类型中，重复的元素。

>>> l=[1,2,3,4,5,6,7,7,7,7,8,8,9,9]
>>> l
[1, 2, 3, 4, 5, 6, 7, 7, 7, 7, 8, 8, 9, 9]
>>> set(l)
{1, 2, 3, 4, 5, 6, 7, 8, 9}
>>> list(set(l))
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> 

利用集合的运算达到一些查找共同对象等。

布尔型

Python中的布尔型数据类型，包含了2个值：True和False。它们的值是Python预先定义的内置变量名。实际上仅仅是整数类型上的1和0。内部的定制效果让布尔型就只是输出True和False而不是1和0。

>>> type(True)
<class 'bool'>
>>> isinstance(True,int)         #True是int实例
True
>>> True==1                      #True的值等于1
True
>>> True is 1                    #但是True与1并不是同一个对象
False
>>> True + 4
5
>>> 

Python还有很多其他数字扩展，最广泛的就是numpy，往往比作为免费，灵活的matlab。

总结

Python中的数字对象和他们的操作是比较简单，使用时，需要多多注意浮点数的精度问题，表达式，和类型转化。