数字

python的数字类型包括：

整数和浮点数
复数
固定精度的十进制数
有理分数
集合
布尔类型
无穷的整数精度
各种数字内置函数和模块

数字常量

1234, -24, 0, 9999999999 #整数 无穷大小
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 #复数常量

如果一个数字带有小数点或者幂，python会将它变成浮点数。

python2.6中的整数分为一般整数（32位）和长整数（无穷精度）。如果一个整数以l或者L结尾，会强制成为长整数。整数超过32位时会自动转换为长整数。

python3.0中的一般整数和长整数合成一种类型了。自动支持无穷精度了。

内置函数hex(I)，oct(I)，bin(I)可以把一个整数转换为三种对应的进制的字符串。int(str, base)根据给定的进制把一个字符串转换为一个整数。

复数写成实部+虚部的写法，虚部以j或者J结尾。也可通过内置函数complex(real, imag)创建复数。

内置数学工具和扩展

python表达式操作符

yield x #生成器函数发送协议
lambda args: expression # 生成匿名函数
x or y #逻辑或
x and y #逻辑与
not x #逻辑非
x in y, x not in y #成员关系（可迭代对象，集合）
x is y, x is not y #对象实体测试
x < y, x <= y, x > y, x >= y #大小比较，集合子集和超集值相等性操作符
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中，值不相等可以写成x != y或者x <> y，python3.0中只能写x != y。
python2.6中的后引号表达式在3.0中删除。
python2.6和3.0中floor除法表达式（x // y）总是会把余数小数部分去掉。3.0中x / y执行真正除法（保留余数），2.6中传统除法（截取为整数）。
yield返回生成器中的send(...)参数，如果yield不在一个赋值语句的右边，需要用圆括号。
比较操作符可以连用。x < y < z等价于x < y and y < z。

混合操作的优先级

操作符的优先级，上面的表中，越靠后的优先级越高。

同一行的表达式在组合的时候通常从左到右组合（幂运算从右向左组合，比较运算从左到右连接）。

括号分组子表达式

括号的优先级更高。

混合类型自动升级

混合类型表达式中，python先将被操作的对象转换成其中最复杂的类型，然后再运算。复杂度，整数<浮点数<复数。

变量和基本表达式

变量在第一次赋值时创建
变量在表达式中使用将被替换为它们的值
变量在表达式中使用前必须已经赋值
变量像对象一样不需要在一开始声明

比较：一般的和连续的

题外话：str和repr

str()和repr()都会把任意对象变成它们的字符串表示。repr（也就是默认的交互模式回显）产生的结果好像它们是代码；str（打印语句）会转变为一种对用户更加友好的格式。str用于一般用途，repr用于额外细节。

num = 1 / 3
repr(num)
#'0.33333333333333331'
str(num)
#'0.333333333333'

python允许把大小比较连接起来。

x = 2
y = 4
z = 6
x < y < z
#True
x < y and y < z
#True
1 == 2 < 3
#False

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

x / y

传统除法和真除法。在python2.6或之前的版本，这个操作对于整数会省去小数部分，对于浮点数会保持小数部分。在python3.0中会变成真除法（无论任何类型都保留小数）。

x // y

floor除法。python2.2新增操作。python2.6和3.0中均可使用。总是省略小数部分，剩下最小的能整除的部分。

python3.0中取消了传统除法，/代表真除法，//代表floor除法。

python3.0中，/总是执行真除法，总是返回浮点结果。//执行floor除法，针对整数返回一个整数，如果有操作数为浮点数，则返回浮点数。
python2.6中，/执行传统除法，如果两个操作数都是整数，则返回整数，否则，返回浮点数。//执行floor除法，像python3.0一样工作。

支持两个python版本

x = y / z #需要结果总是截断整数
x = y / float(z) #需要结果总是浮点数

可以使用_future_ import division在python2.6中打开python3.0的/

from _future_ import division
10 / 4
#2.5
10 // 4
#2.5

floor除法和截断除法

//通常叫做截断除法，更准确叫做floor除法。因为它的效果是向下舍入，和math模块里的floor()效果相同。

#python3.0
5 / 2, 5 / -2
#(2.5, -2.5)

5 // 2, 5 // -2
#(2, -3)

5 / 2.0, 5 / -2.0
#(2.5, -2.5)

5 // 2.0, 5 // -2.0
#(2.0, -3.0)

在2.6中的情况：

#python2.6
5 / 2, 5 / -2
#(2, -3)

5 // 2, 5 // -2
#(2, -3)

5 / 2.0, 5 / -2.0
#(2.5, -2.5)

5 // 2.0, 5 // -2.0
#(2.0, -3.0)

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

0o1, 0o20, 0o377
#(1, 16, 255)

0x01, 0x10, 0xFF
#(1, 16, 255)

0b1, 0b10000, 0b11111111
#(1, 16, 255)

python拥有内置函数，可以把整数转换为其他进制的数字字符串：

oct(64), hex(64), bin(64)
#('0100', '0x40', '0b1000000')

内置的int()函数会将一个数字字符串变为一个整数，而且有第二个参数可以确定以什么进制来转换这个数字字符串。

int('64'), int('100', 8), int('10', 16), int('1000000', 2)
#(64, 64, 64, 64)

eval()函数会把字符串作为python代码运行。所以它也有类似转换数字的效果。

python2.6中的旧语法八进制数字是以0开头的（数字0），而3.0中是以0o开头的（数字0和字母o）。为了避免错误，请一致使用0o开头表示八进制。

位操作

省略，主要用于操作二进制数。

其他内置数学工具

import math
math.pi, math.e #数学中的常数
#(3.141592653589793, 2.718281828459045)

math.sin(2 * math.pi / 180) #三角函数正弦sin
#0.03489949670250097

math.sqrt(144), math.sqrt(2) #开方
#(12.0, 1.4142135623730951)

pow(2, 4), 2 ** 4 #幂运算
#(16, 16)

abs(-42.0), sum((1, 2, 3, 4)) #绝对值和求和
#(42.0, 10)

min(3, 1, 2, 4), max(3, 1, 2, 4) #求最大最小值
#(1, 4)

math.floor(2.567), math.floor(-2.567) #向下取整
#(2, -3)

math.trunc(2.567), math.trunc(-2.567) #截断小数位
#(2, -2)

int(2.567), int(-2.567) #转换成整数类型
#(2, -2)

round(2.567), round(2.467), round(2.567, 2) #四舍五入 python3.6.1
#(3, 2, 2.57)

'%.1f' % 2.567, '{0:.2f}'.format(2.567) #格式化字符串
#('2.6', '2.57')

在python中可以用三种方式计算开方运算：

import math
math.sqrt(144) #sqrt开方函数

144 ** .5 #144的1/2次幂即开平方

pow(144, .5) #同上

random模块使用需要导入，它能返回0到1之间的任意浮点数，两个数字之间的任意整数，或者在一个序列中的任意一项。

import random

random.random()
#0.4543532453454

random.randint(1, 10)
#5

random.choice([1, 2, 3, 4, 5])
#4

小数数字

小数是导入decimal模块后创建的，它有固定的位数和小数点，所以小数是有固定精度的浮点数。

浮点数缺乏精度，小数能够修正它。

0.1 + 0.1 + 0.1 - 0.3
#5.551115123125783e-17

from decimal import Decimal
Decimal('0.1') + Decimal('0.1') + Decimal('0.1') - Decimal('0.3')
#Decimal('0.0')

decimal模块的上下文对象可以指定精度和舍入模式。

import decimal
decimal.Decimal(1) / decimal.Decimal(7)
#Decimal('0.1428571428571428571428571429')

decimal.getcontext().prec = 4
decimal.Decimal(1) / decimal.Decimal(7)
#Decimal('0.1429')

小数其实是手动舍入和字符串格式化的一种替代方式。

1999 + 1.33
2000.33

decimal.getcontext().prec = 2
pay = decimal.Decimal(str(1999 + 1.33))
pay
#Decimal('2000.33')

小数也可以从浮点数来创建，使用decimal.Decimal.from_float(1.25)。

小数上下文管理器

import decimal
decimal.Decimal('1.00') / decimal.Decimal('3.00')
#Decimal('0.3333333333333333333333333333')

with decimal.localcontext() as ctx:
     ctx.prec = 2
     decimal.Decimal('1.00') / decimal.Decimal('3.00')
#Decimal('0.33')

decimal.Decimal('1.00') / decimal.Decimal('3.00')
#Decimal('0.3333333333333333333333333333')

分数类型

导入fractions模块的Fraction构造函数，传递分子和分母就可以产生一个分数。

from fractions import Fraction
x = Fraction(1, 3)
y = Fraction(4, 6)

x
#Fraction(1, 3)
y
#Fraction(2, 3)
print(y)
#2/3

创建好的分数可以用于计算。

x + y
#Fraction(1, 1)

x - y
#Fraction(-1, 3)

x * y
#Fraction(2, 9)

分数对象也可从浮点数来创建。

Fraction('.25')
#Fraction(1, 4)

Fraction('1.25')
#Fraction(5, 4)

Fraction('.25') + Fraction('1.25')
#Fraction(3, 2)

集合

集合是一些唯一的，不可变得对象的无序集合。它很像一个无值的字典键。

python3.0中的集合知识

创建集合，使用内置的set函数传递一个序列或者可以迭代的对象。

x = set('abcde')
y = set('bdxyz')

集合不包括位置顺序。

x
#{'a', 'e', 'c', 'd', 'b'}

集合支持一般的数学集合运算。

'e' in x #'e'是否在x中
#True

x - y #差集
#{'a', 'e', 'c'}

x | y #并集
#{'a', 'z', 'e', 'c', 'y', 'd', 'x', 'b'}

x & y #交集
#{'d', 'b'}

x ^ y #对称差
#{'a', 'e', 'c', 'y', 'z', 'x'}

x > y, x < y #超集，子集
#(False, False)

add方法插入一个项目，update按位置求并集，remove根据值删除一个项目。

z = x.intersection(y)
z
#{'d', 'b'}

z.add('SPAM')
z
#{'SPAM', 'd', 'b'}

z.update({'X', 'Y'})
z
#{'Y', 'SPAM', 'X', 'd', 'b'}

z.remove('b')
z
#{'Y', 'SPAM', 'X', 'd'}

不可变限制和冻结集合

集合只能包含不可变对象类型，因此，列表和字典不能嵌入集合中。

python3.0中的集合解析

{x for x in 'spam'}
#{'a', 'p', 'm', 's'}

{c * 4 for c in 'spam'}
#{'pppp', 'mmmm', 'aaaa', 'ssss'}