数字常量

整数

下表展示了python数字类型在程序中的显示方式(作为常量),如例：

数字	常量
1234，-24，0，999999999999	整数(无穷大小)
1.23，1.，3.14e-10，4e210，4.0e+210	浮点数
0177，0x9ff，0b101010	python2.6中的八进制、十六进制和二进制常量
0o177，0x9ff，0b101010	python3.0中的八进制、十六进制和二进制常量
3+4j，3.0+4.0j，3J	复数常量

十六进制的字母（a-f）可小写可大写。

整数变动：

python2.6：两种整数类型：1.一般整数（32位），2.长整数（无穷精度），只要内存空间足够，可以任意位数的精度！

python3：把上述两种并为一种，叫整数。自动支持py2.6的无穷精度。

八进制数变动：

python2.6：八进制以0开头（极易与十进制数混淆）

python3：八进制以0o开头

内置数学工具和扩展

表达式操作符：+，-，*，/，>>,&等

内置数学函数：pow，abs，round，int，hex，bin等

公用模块：random，math等

表达式操作符及程序（表格越后，运算优先级越高）

操作符	描述
yield x	生成器函数发送协议
lambda args: expression	生成匿名函数
x if y else z	三元选择表达式
x or y	逻辑或(只有x为假，才会计算y)
x and y	逻辑与(只有x为真，才会计算y)
not x	逻辑非
x in y, x not in y	成员关系(可迭代对象、集合)
x is y, x is not y	对象实体测试
xy,x>=y,x==y,x!=y	大小比较，集合子集和超集相等性操作符
x\|y	位或、集合并集
x^y	位异或，集合对称差
x&y	位与，集合交集
x<>y	左移或右移y位
x+y,x-y	加法/合并,减法,集合差集
x*y,x%y,x/y,x//y	乘法/重复,余数/格式化,除法:真除法或floor除法
-x,+x	一元减法，识别
~x	按位求补(取反)
x**y	幂运算
x[i]	索引(序列、映射及其他)点号取属性运算，函数调用
x[i:j:k]	分片
x(...)	调用(函数、方法、类及其他可调用的)
x.attr	属性引用
(...)	无组，表达式，生成器表达式
[...]	列表，列表解析
{...}	字典、集合、集合和字典解析

不等值的区别：

python2.6：值不等可以有两种表达方式，1.x != y 2.x <> y

python3: 只有一种 x != y

整数除法的区别：

python2.6：保留整数

>>> 5/3
1

python3：真正的除法，保留余数

>>> 5/3
1.6666666666666667
>>> 5 // 3   #如果像类似py2，则使用//
1

混合类型自动升级（类似c）：

如果整数与浮点数进行运算，整数类型会升级转为浮点数，然后按照浮点数的运算规则与浮点数进行运算，那么输出的结果类型为浮点型

>>> a = 3
>>> b = 4.2
>>> type(a+b)

当然也可以强制转换类型

>>> a = 3
>>> b = 4.2
>>> type(a+b)

>>> c = a + b
>>> int(c)
7
>>> float(c)
7.2

变量和基本的表达式

变量在它第一次赋值时创建
变量在表达式中使用将被替换成它们的值
变量在表达式中使用前必须已赋值
变量不需要像c一样在开始就声明（现用现声明）

>>> a = 5 #此时满足第一条，但是如果下面举行进行a的赋值，那么前面的值将会被覆盖
>>> a
5
>>> a = 6 #覆盖
>>> a
6
>>> 
>>> a = a + B  #此时的B没有被创建声明，所以报错（未定义）
Traceback (most recent call last):
  File "", line 1, in 
NameError: name 'B' is not defined
>>>

使用（）来改变优先级

>>> a = 3   #py2.7 取整的除法
>>> b = 4
>>> b / 2 + a
5
>>> b / (2.0 + a)
0.8

比较：一般的和连续的

#一般的
>>> 1 < 2  #返回bool类型
True
>>> 2 < 1
False
>>> 2 = 2  #单个=是赋值
  File "", line 1 
SyntaxError: can't assign to literal
>>> 2 == 2
True
>>> 2 != 2
False
>>> 2.0 == 2 #可以（数字类型）混合类型的比较
True

#连续的
>>> a = 1
>>> b = 2
>>> c = 3
>>> a < b < c   #本质上等于a < b and b < c
True
>>> a < b and b < c
True

>>> 1 == 2 < 3  #程序判断1是不等于2的然后即终止程序，不再往下进行比较，直接返回false。 
False           #如果还继续向右比较，那么1==2返回0,0<3,那就应该返回true，那就出大事了

除法：传统除法，Floor除法和真除法

"/" 传统除法和真除法

(py2中"/"叫传统除法。py2中叫真除法)

#py2.x
>>> 5 / 3   #对于整数的除法，取整
1
>>> 5.0 /3  #对于浮点数，依旧保持小数部分
1.6666666666666667

#py3.x
>>> 5 / 3        #都会保留小数部分
1.6666666666666667
>>> 5.0 / 3
1.6666666666666667

"//" floor除法

#py2.x
>>> 5 // 3
1
>>> 5.0 // 3  #取整，不过依旧还是浮点数
1.0
>>> type(5.0 // 3)

#py3.x
>>> 5 // 3
1
>>> 5.0 // 3  #和py2.x一样
1.0
>>> type(5.0 // 3)

Floor除法和截断除法

floor除法就是截断除法：截断的规则就是向下舍入。从中学数轴理解，就是向左取最近的整数。py2和py3在输出数字类型上仍有差异！

#py2.x
>>> import math
>>> math.floor(2.5)  #这里与py3.x输出的类型不同
2.0
>>> math.floor(-2.5)
-3.0
>>> 5 // 2
2
>>> 5 // -2
-3
>>> type(math.floor(2.5)) 

>>> type(math.floor(-2.5))

#py3.x
>>> import math
>>> math.floor(2.5)
2
>>> math.floor(-2.5)
-3
>>> 5 // 2
2
>>> 5 // -2
-3
>>> type(math.floor(2.5))  #返回类型与py2.x不同

>>> type(math.floor(-2.5))

在c中往往使用"/"取整，那么在py中，尽量都使用"//"进行取整

如果想处理负数与正数一样，只保留整数部分，舍弃小数部分。可以用 math.trunc()

#py2.x
>>> math.trunc(-2.5)
-2
>>> type(math.trunc(-2.5))

#py3.x
>>> math.trunc(-2.5)
-2
>>> type(math.trunc(-2.5))

整数精度

python3：整数（由py2两种类型合二为一）支持无穷的大小（硬件足够）

python2：整数分为一般整数（32位）和长整数，py2中长整数后面会有一个L来标识

>>> 66666666666666666666666666666666666
66666666666666666666666666666666666L

复数

复数的虚部用j和J来标识

>>> 1j * 1j
(-1+0j)
>>> 1J * 1J
(-1+0j)
>>> 1j * 1J
(-1+0j)

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

>>> 0o1,0o20,0o377   #八进制
(1, 16, 255) #十进制数
>>> 0x1,0x10,0xFF    #十六进制
(1, 16, 255)
>>> 0b1,0b10000,0b11111111  #二进制
(1, 16, 255)

python默认使用十进制值显示，提供了内置函数供调用

oct() ：十转八八进制数尽量都用0o开头

hex()：十转十六

bin()：十转二

>>> oct(16)
'0o20'
>>> hex(16)
'0x10'
>>> bin(16)
'0b10000'

int("数字字符串"，进制数)

>>> x = 1    #此时的x会被当成 0001 ，然后0001向左移了两位，空位插入0，则变成0100（多余的0没打出来）
>>> x << 2
4

>>> int("1111",2)
15
>>> int("100",8)
64
>>> int("100",16)
256
>>> int("100")
100

>>> int(1111,2) #一定要是数字字符串
Traceback (most recent call last):
  File "", line 1, in 
TypeError: int() can't convert non-string with explicit base

也可以用字符串格式化，这个等写到 python 字符串再提。

位操作

位操作：将数当作二进制位串对待的操作

>>> x = 1    #此时将x化为0001，然后左移两位，成0100，就是4（多余的0没打出来）
>>> x << 2
4 
>>> x | 2     #或操作，将x化为0001，将2化为0010，然后按位进行或操作（同0取0，其余取1）
3        #         0001
         #或操作    0010
         #--------------
         #         0011  十进制就是3

>>> x & 3    #与操作，x为0001,3为0011，按位与操作（同1取1，其余取0）
1        #         0001
         #与操作    0011
         #--------------
         #         0001  十进制就是1

>>> x = 6    #xor，异或操作 x为0110，5为0101，按位异或（相同取0，不同取1）
>>> x ^ 5  
3        #         0110
         #xor      0101
         #----------------
         #         0011  十进制就是3

一些内置的数学工具函数

>>> import math
>>> ma
map(  math  max(  
>>> math. #tab出来
math.__class__(         math.__str__(           math.gamma(
math.__delattr__(       math.__subclasshook__(  math.gcd(
math.__dict__           math.acos(              math.hypot(
math.__dir__(           math.acosh(             math.inf
math.__doc__            math.asin(              math.isclose(
math.__eq__(            math.asinh(             math.isfinite(
math.__format__(        math.atan(              math.isinf(
math.__ge__(            math.atan2(             math.isnan(
math.__getattribute__(  math.atanh(             math.ldexp(
math.__gt__(            math.ceil(              math.lgamma(
math.__hash__(          math.copysign(          math.log(
math.__init__(          math.cos(               math.log10(
math.__le__(            math.cosh(              math.log1p(
math.__loader__(        math.degrees(           math.log2(
math.__lt__(            math.e                  math.modf(
math.__name__           math.erf(               math.nan
math.__ne__(            math.erfc(              math.pi
math.__new__(           math.exp(               math.pow(
math.__package__        math.expm1(             math.radians(
math.__reduce__(        math.fabs(              math.sin(
math.__reduce_ex__(     math.factorial(         math.sinh(
math.__repr__(          math.floor(             math.sqrt(
math.__setattr__(       math.fmod(              math.tan(
math.__sizeof__(        math.frexp(             math.tanh(
math.__spec__           math.fsum(              math.trunc(

>>> pow(2,4)   #幂运算
16
>>> abs(-44)   #绝对值
44
>>> sum((1,2,3,4))
10
>>> max((1,2,3,4))
4
>>> min((1,2,3,4))
1

其他数字类型

小数数字

小数是通过一个导入的模块调用函数后创建（ Decimal()函数），而不是通过运行常量表达式创建的。

小数是有固定精度的浮点值。

>>> 0.1 + 0.1 + 0.1 - 0.3     #这是浮点数运算的一个特殊情况，原本该显示成0，而因计算机硬件所限只能显示如下的数字
5.551115123125783e-17
>>> Decimal('0.1') + Decimal('0.1') + Decimal('0.1') - Decimal('0.3')   #小数运算
Decimal('0.0')
>>> 0.1 + 0.1 -0.2   #为什么这次浮点运算就没有出现第一行出现的情况？
0.0

上面出现的问题，相关解释，点击此处

设置全局精度

>>> import decimal
>>> decimal.getcontext().prec = 5   #保留5位小数
>>> decimal.Decimal(3) / decimal.Decimal(7)
Decimal('0.42857')

调用上下文管理器语句设置临时精度（py2和py3都可以）。

>>> with decimal.localcontext() as stone:
...     stone.prec = 3
...     decimal.Decimal(1) / decimal.Decimal(3)
... 
Decimal('0.333')
 
>>> decimal.Decimal(1) / decimal.Decimal(3)   #又变成上面的全局精度
Decimal('0.33333')

>>> a = decimal.Decimal(1) / decimal.Decimal(3)
>>> type(a)
       #数据类型

分数类型

分数也存在于模块中，导入构造函数（ Fraction() ）传递一个分子，一个分母就可以产生一个分数。

>>> from fractions import Fraction
>>> a = Fraction(4, 5)        #前为分子，后为分母
>>> a              
Fraction(4, 5)
>>> b = Fraction(1, 5)
>>> b
Fraction(1, 5)
>>> a + b
Fraction(1, 1)
>>> a - b
Fraction(3, 5)
>>> a / b
Fraction(4, 1)
>>> a * b
Fraction(4, 25)

#也支持浮点数字符串创建

>>> c = Fraction('0.3')
>>> c
Fraction(3, 10)
>>> type(c)
 #数据类型

关于不同运算混合所得类型

分数和整数 => 分数

分数和浮点数 => 浮点数

也就以类型强制转换，但是将分数强制转换成为浮点数会精度损失。可以设置最大分母简化来便于阅读

>>> a = 1 / 3
>>> a
0.3333333333333333
>>> type(a)

>>> Fraction(*a.as_integer_ratio())   #这是书上的格式，暂且理解为 *a看做对a引用
Fraction(6004799503160661, 18014398509481984)
>>> b = Fraction(*a.as_integer_ratio())
>>> b
Fraction(6004799503160661, 18014398509481984)
>>> b.limit_denominator(3)
Fraction(1, 3)
>>> b.limit_denominator(6)  #自动约分
Fraction(1, 3)

集合

集合可以理解为中学所学交并补的集合（相同的只能出现一次，无序性）。

集合里面可以放各种对象类型（列表和字典不能嵌入到集合中），可以根据需要增长和缩短。

>>> x = set('1a2b3cc')  #无序性，唯一性
>>> x
{'a', 'b', 'c', '2', '1', '3'}
>>> type(x)
   #集合类型

>>> a = set('1a2b3c')
>>> b = set('2b3c4d')

>>> a | b        #并
{'a', 'd', 'b', 'c', '2', '1', '3', '4'}

>>> a & b        #交
{'3', 'c', 'b', '2'}

>>> a ^ b        #a与b的差异集合
{'a', '1', 'd', '4'}

>>> '1' in a     #判断‘1’是否在a集合中
True

集合的一些方法函数

>>> a.
a.__and__(                      a.__repr__(
a.__class__(                    a.__ror__(
a.__contains__(                 a.__rsub__(
a.__delattr__(                  a.__rxor__(
a.__dir__(                      a.__setattr__(
a.__doc__                       a.__sizeof__(
a.__eq__(                       a.__str__(
a.__format__(                   a.__sub__(
a.__ge__(                       a.__subclasshook__(
a.__getattribute__(             a.__xor__(
a.__gt__(                       a.add(
a.__hash__                      a.clear(
a.__iand__(                     a.copy(
a.__init__(                     a.difference(
a.__ior__(                      a.difference_update(
a.__isub__(                     a.discard(
a.__iter__(                     a.intersection(
a.__ixor__(                     a.intersection_update(
a.__le__(                       a.isdisjoint(
a.__len__(                      a.issubset(
a.__lt__(                       a.issuperset(
a.__ne__(                       a.pop(
a.__new__(                      a.remove(
a.__or__(                       a.symmetric_difference(
a.__rand__(                     a.symmetric_difference_update(
a.__reduce__(                   a.union(
a.__reduce_ex__(                a.update(

集合是可以遍历的

>>> a
{'a', 'b', 'c', '2', '1', '3'}
>>> for i in a:
...     print (i)
... 
a
b
c
2
1
3

显示的差异

#python2.x
>>> a = set('1a2b3c')
>>> a
set(['a', 'c', 'b', '1', '3', '2'])


#python3.x
>>> a = set('1a2b3c')
>>> a
{'a', 'b', 'c', '2', '1', '3'}

python3后都用{}，集合本质上就是无值的字典在以后python 字典再行比较

python 数字（未完结）