Python学习笔记九深入数字（中篇）

变量和基本表达式
1. 变量在它第一次赋值时创建。
2. 变量在表达式中使用将被替换为它们的值。
3. 变量在表达式中使用以前必须已赋值
4. 变量像对象一样不需要在一开始进行声明
换句话说，这些赋值会让变量a和b自动生成。
```
#ipython3

In [1]: a = 3

In [2]: b = 4

In [3]: a + 1,a - 1  
Out[3]: (4, 2)

In [4]: b * 3,b / 2
Out[4]: (12, 2.0)

In [5]: a % 2,b ** 2
Out[5]: (1, 16)

In [6]: b / 2 + a
Out[6]: 5.0

In [7]: print(b / (2.0 + a))
0.8
```
数字显示的格式
```
In [1]: num = 1 / 3.0

In [2]: num
Out[2]: 0.3333333333333333

In [3]: print(num)
0.3333333333333333

In [4]: '%e' % num
Out[4]: '3.333333e-01'

In [5]: '%4.2f' % num
Out[5]: '0.33'

In [6]: '{0:4.2f}'.format(num)
Out[6]: '0.33'
```
这些方法的最后三个使用了字符串格式化，这是灵活地进行格式化的一种工具。
```
In [1]: num = 1 / 3

In [2]: repr(num)
Out[2]: '0.3333333333333333'

In [3]: str(num)
Out[3]: '0.3333333333333333'
```
这两个函数都会把任意对象变换成它们的字符串表示，repr默认的交互式回显，str转变为一种通常对用户更加友好的格式。一些对象两种格式都有，str用于一般用途，repr用于额外的细节。这个概念将会为字符串以及类中的运算符重载做好铺垫。除了为任意对象提供打印字符串，str内置函数也是字符串数据类型的名字，并且能够用一个编码的名字来调用，从而从一个字节字符串解码一个Unicode字符串。

比较：一般的和连续的一般的比较对数字起作用，它们比较操作数的相对大小，并返回一个布尔类型的结果。

In [1]: 1 < 2
Out[1]: True

In [2]: 2.0 >= 1
Out[2]: True

In [3]: 2.0 == 2.0
Out[3]: True

In [4]: 2.0 != 2.0
Out[4]: False

连续比较

In [1]: x = 2

In [2]: y = 4

In [3]: z = 6

In [4]: x < y < z
Out[4]: True

In [5]: x < y and y < z
Out[5]: True

In [6]: x < y > z
Out[6]: False

In [7]: x < y and y > z
Out[7]: False

In [8]: 1 < 2 < 3.0 < 4
Out[8]: True

In [9]: 1 > 2 > 3.0 > 4
Out[9]: False

In [10]: 1 == 2 < 3
Out[10]: False

除法：真除法，Floor除法，传统除法在Python3中，传统除法已经基本被真除法兼并
```
	
In [1]: 10 / 4
Out[1]: 2.5

In [2]: 10 // 4
Out[2]: 2

In [3]: 10 / 4.0
Out[3]: 2.5

In [4]: 10 // 4.0
Out[4]: 2.0
```
/执行真除法，不管操作数的类型，总是返回包含任何余数的一个浮点结果
//执行Floor除法，它截取掉余数并且针对整数操作数返回一个结果，但如果有任何一个操作数是浮点类型，则返回一个浮点数。//的结果数据类型总是依赖于操作数的类型。
```
In [1]: (5 / 2),(5 / 2.0),(5 / -2.0),(5 / -2)
Out[1]: (2.5, 2.5, -2.5, -2.5)

In [2]: (5 // 2),(5 // 2.0),(5 // -2.0),(5 // -2)
Out[2]: (2, 2.0, -3.0, -3)

In [3]: (9 / 3),(9.0 / 3),(9 // 3),(9 // 3.0)
Out[3]: (3.0, 3.0, 3, 3.0)
```
注意负数的情况，Floor除法把结果向下截断到它的下层！即真正结果之下的最新的整数。其直接效果是向下舍入，并不是严格地截断！也不是四舍五入！
复数在Python中，复数是个不同的核心对象类型。复数表示为两个浮点数（实部和虚部）并接在虚部增加了i或者j的后缀。我们能够把非零实部的复数写成由+连接起来的两部分。
```
In [1]: 1j * 1J
Out[1]: (-1+0j)

In [2]: 2 + 1j * 3
Out[2]: (2+3j)

In [3]: (2 + 1j) * 3
Out[3]: (6+3j)
```
复数允许我们分解出它的实部和虚部作为属性，并支持所有一般的数学表达式，并且可以通过标准的cmath模块（复数版的标志数学模块）中的工具进行处理。
十六进制，八进制和二进制计数Python默认地用十进制值显示。如下常量编码会产生具有三种进制的指定值的常规整数。
```
In [1]: 0o1,0o20,0o377
Out[1]: (1, 16, 255)

In [2]: 0x01,0x10,0xFF
Out[2]: (1, 16, 255)

In [3]: 0b1,0b10000,0b11111111
Out[3]: (1, 16, 255)
```
我们可以通过内置函数，将整数转换为其它进制的数字字符串
```
In [1]: oct(64),hex(64),bin(64)
Out[1]: ('0o100', '0x40', '0b1000000')
```
内置的int函数会将一个数字的字符串变换为一个整数，并可以通过第二个参数来确定变换后的数字的进制
```
In [2]: int('64'),int('100',8),int('40',16),int('1000000',2)
Out[2]: (64, 64, 64, 64)

In [3]: int('0x40',16),int('0b1000000',2) 
Out[3]: (64, 64)
```
你能够使用字符串格式化方法调用和表达式将一个整数转换成八进制数和十六进制数的字符串
```
In [1]: '{0:o},{1:x},{2:b}'.format(64,64,64)
Out[1]: '100,40,1000000'

In [2]: '%o,%x,%X' % (64,255,255)
Out[2]: '100,ff,FF'
```