数字常量
整数
下表展示了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 | 对象实体测试 |
| 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：值不等可以有两种表达方式，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)
<class 'float'>
当然也可以强制转换类型
>>> a = 3
>>> b = 4.2
>>> type(a+b)
<class 'float'>
>>> 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 "<stdin>", line 1, in <module>
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 "<stdin>", 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中"/"叫传统除法<classic division>。py2中叫真除法<true division>)
#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)
<type 'float'>
#py3.x
>>> 5 // 3
1
>>> 5.0 // 3 #和py2.x一样
1.0
>>> type(5.0 // 3)
<class 'float'>
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 'float'>
>>> type(math.floor(-2.5))
<type 'float'>
#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不同
<class 'int'>
>>> type(math.floor(-2.5))
<class 'int'>
在c中往往使用"/"取整，那么在py中，尽量都使用"//"进行取整
如果想处理负数与正数一样，只保留整数部分，舍弃小数部分。可以用 math.trunc()
#py2.x
>>> math.trunc(-2.5)
-2
>>> type(math.trunc(-2.5))
<type 'int'>
#py3.x
>>> math.trunc(-2.5)
-2
>>> type(math.trunc(-2.5))
<class 'int'>
整数精度
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 "<stdin>", line 1, in <module>
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)
<class 'decimal.Decimal'> #数据类型
分数类型
分数也存在于模块中，导入构造函数（ 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)
<class 'fractions.Fraction'> #数据类型
关于不同运算混合所得类型
分数 和 整数 => 分数
分数 和 浮点数 => 浮点数
也就以类型强制转换，但是将分数强制转换成为浮点数会精度损失。可以设置最大分母简化来便于阅读
>>> a = 1 / 3
>>> a
0.3333333333333333
>>> type(a)
<class 'float'>
>>> 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)
<class 'set'> #集合类型
>>> 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 字典再行比较
1664
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
