Python学习笔记：数据类型 - 数字类型

【1】数据类型 - 整数型

【1.1】整型（int）

In [1]: 3 + 2 # 加法
Out[1]: 5

In [2]: 3 - 2 # 减法
Out[2]: 1

In [3]: 7 * 5 # 乘法
Out[3]: 35

In [4]: 7 / 5 # 除法（自动转成浮点类型）
Out[4]: 1.4

In [5]: 7 // 5 # 整除（商为整数部分）
Out[5]: 1

In [6]: 7 % 5 # 取余
Out[6]: 2

In [7]: 2 ** 3 # 指数（2的3次方）
Out[7]: 8

In [8]: 2 ** 100 # 指数（2的100次方），Python支持大数计算
Out[8]: 1267650600228229401496703205376

说明：

操作符	说明
+	加法
-	减法
*	乘法
/	除法
//	整除法（向下取整除法）
%	取余（余数）
**	指数（次方），如：a ** b 为a的b次方

【1.2】布尔型（bool）

In [9]: 3 > 2 # 条件表达式，返回值为布尔型（真值：True）
Out[9]: True

In [10]: 3 == 2 # 条件表达式，返回值为布尔型（假值：True）
Out[10]: False

【1.3】浮点型（float）

In [11]: 3.1415 * 2 # float浮点型
Out[11]: 6.283

In [12]: import math # 导入math模块

In [13]: math.pi # 引用math模块的pi属性
Out[13]: 3.141592653589793

In [14]: math.pi / 2 # 除法（输出为浮点型）
Out[14]: 1.5707963267948966

In [15]: math.pi // 2 整除（输出整除的商：整数，类型仍为浮点型）
Out[15]: 1.0

In [16]: math.pi % 2 取余（输出为浮点型）
Out[16]: 1.1415926535897931

【1.4】复数型（complex）

In [17]: (1 + 1j) + (1 - 1j) # 复数加法
Out[17]: (2+0j)

In [18]: (1 + 1j) - (1 - 1j) # 复数加法
Out[18]: 2j

In [19]: (1 + 1j) * (1 + 1j) # 复数乘法
Out[19]: 2j

In [20]: (1 + 1j) * (1 - 1j) # 复数乘法
Out[20]: (2+0j)

In [21]: (1 + 1j) / (1 - 1j) # 复数除法
Out[21]: 1j

In [22]: (1 + 1j) ** 5 # 复数的指数（5次方）
Out[22]: (-4-4j)

【1.5】类型错误

In [23]: (1+1j)//2 # 复数不能整除
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-23-f9ce4cfa65f8> in <module>
----> 1 (1+1j)//2

TypeError: can't take floor of complex number.

In [24]: (1+1j)%2 # 复数不能取余
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-24-b2c3505b8a69> in <module>
----> 1 (1+1j)%2

TypeError: can't mod complex numbers.

【1.6】获得类型

In [25]: type(1)
Out[25]: int

In [26]: type(True)
Out[26]: bool

In [27]: type(1.0)
Out[27]: float

In [28]: type(1+1j)
Out[28]: complex

【2】进制表示法

【2.1】十进制

Python默认使用十进制，如前面代码所示。

【2.2】十六进制

十六进制：第一个字符是’0’，第2个字符是大小写形式的字母’x’或’X’，其它字符为’0’至’9’的任意数字、'A’到’F’的任意字母（大小写形式均可）

In [29]: 0xff, 0x01
Out[29]: (255, 1)

In [30]: 0XFF, 0X01
Out[30]: (255, 1)

【2.3】八进制

八进制：第一个字符是’0’，第2个字符是大小写形式的字母’o’或’O’，其它字符为’0’至’7’的任意数字

In [31]: 0o1, 0o20, 0o37 # 八进制：第一个字符是'0'，第2个字符是小写字母'o'
Out[31]: (1, 16, 31)

In [32]: 0O1, 0O20, 0O37 # 八进制：第一个字符是'0'，第2个字符是大写字母'O'
Out[32]: (1, 16, 31)

【2.4】二进制

二进制：第一个字符是’0’，第2个字符是大小写形式的字母’b’或’B’，其它字符为’0’至’1’的任意数字

In [33]: 0b1, 0b111, 0b10111 # 二进制：第一个字符是'0'，第2个字符是小写字母'b'
Out[33]: (1, 7, 23)

In [34]: 0B1, 0B111, 0B10111 # 二进制：第一个字符是'0'，第2个字符是大写字母'B'
Out[34]: (1, 7, 23)

【3】进制转换

【3.1】转十六进制

hex()

In [35]: hex(255)
Out[35]: '0xff'

【3.2】转八进制

oct()

In [36]: oct(31)
Out[36]: '0o37'

【3.3】转二进制

bin()

In [37]: bin(15)
Out[37]: '0b1111'

【4】位操作符

【4.1】左移位操作符（<<）

左移位操作符为两个连续的英文小于号，中间不能有空格、制表符等空白符：<<

In [38]: 1 << 5 # 1左移5位，即：0b1 << 5：0b100000，十进制的32
Out[38]: 32

【4.2】右移位操作符（>>）

右移位操作符为两个连续的英文大于号，中间不能有空格、制表符等空白符：>>

In [39]: 0xFF >> 3 # 0XFF右移3位，即：0b11111111 >> 3：0b11111，十进制的31
Out[39]: 31

【4.3】位与操作符（&）

位与操作符为&（Shift-7）

In [40]: 1 & 3 # 按二进制的位进行与操作：0b01 & 0b11 = 0b01
Out[40]: 1

In [41]: 0b01 & 0b11 # 按二进制的位进行与操作：0b01 & 0b11 = 0b01
Out[41]: 1

In [42]: bin(0b01 & 0b11) # 按二进制显示（0b01 & 0b11）的结果
Out[42]: '0b1'

【4.4】位或操作符（|）

位或操作符为竖线字符（|）：Shift-\

In [43]: 1 | 2
Out[43]: 3

In [44]: bin(0b01 & 0b10)
Out[44]: '0b0'

In [45]: bin(0b01 | 0b10)
Out[45]: '0b11'

【4.5】位异或操作符^

位异或操作符为^（Shift-6）

In [46]: bin(0b01 ^ 0b10)
Out[46]: '0b11'

In [47]: bin(0b010 ^ 0b100)
Out[47]: '0b110'

【4.6】按位取反操作符~

按位取反操作符~（Shift-`）
按位取反操作符的核心要义是按照每位分别取反，不用关心计算机中的存储格式，即所谓原码、反码、补码。记住一点：Python中一个数与它的按位取反之和是-1。

In [48]: 5, ~5, 5 + ~5, bin(5), bin(~5), bin(5 + ~5)
Out[48]: (5, -6, -1, '0b101', '-0b110', '-0b1')

In [49]: -5, ~-5, -5 + ~-5, bin(-5), bin(~-5), bin(-5 + ~-5)
Out[49]: (-5, 4, -1, '-0b101', '0b100', '-0b1')

【5】其它类型

【5.1】带精度控制的十进制数（Decimal）

float浮点型无法保证数位上的精度。Python标准库引入了Decimal类。

In [1]: 0.1 + 0.1 + 0.1 - 0.3 # 因为精度的原因，0.1+0.1+0.1-0.3≠0
Out[1]: 5.551115123125783e-17

In [2]: from decimal import Decimal # 从decimal模块导入Decimal类

In [3]: Decimal('0.1') + Decimal('0.1') + Decimal('0.1') - Decimal('0.3')
Out[3]: Decimal('0.0')

In [4]: Decimal(3.1) # 以浮点型数字作为参数，不准确
Out[4]: Decimal('3.100000000000000088817841970012523233890533447265625')

In [5]: a, b = 4.55, 4.55

In [6]: a * b # 不精确计算
Out[6]: 20.702499999999997

In [7]: Decimal(a) * Decimal(b) # 不精确计算
Out[7]: Decimal('20.70249999999999838351527615')

In [8]: Decimal(str(a)) * Decimal(str(b)) # 精确计算
Out[8]: Decimal('20.7025')

In [9]: from decimal import getcontext

In [9]: getcontext().prec = 4 # 设置精度为小数点后4位

In [10]: Decimal('1.00') /Decimal('3.0')
Out[10]: Decimal('0.3333')

说明：Decimal类不要使用浮点型作为参数，应该使用字符串以保证精度。

【5.2】分数（Fraction）

In [1]: from fractions import Fraction # 从fractions模块导入Fraction类

In [2]: print(Fraction(1, 2), Fraction(1, 3))
1/2 1/3

In [3]: Fraction(1, 2) + Fraction(1, 3)
Out[3]: Fraction(5, 6)

In [4]: Fraction(1, 3) - Fraction(1, 2)
Out[4]: Fraction(-1, 6)

In [5]: Fraction(1, 2) * Fraction(1, 3)
Out[5]: Fraction(1, 6)

In [6]: Fraction(1, 2) / Fraction(1, 3)
Out[6]: Fraction(3, 2)

【6】变量引用

此部分内容可参考：Python学习笔记D2：对象、变量与引用

In [1]: a = 3 # 变量a链接到整型对象3

In [1]: b = 4 # 变量b链接到整型对象4

In [2]: a + 1, a - 1 # 生成两个新的整型对象：4和2
Out[2]: (4, 2)

In [3]: b * 2, b / 2 # 生成一个新的整型对象：8，一个新的浮点型对象2.0
Out[3]: (8, 2.0)

In [4]: a * b # 生成一个新的整型对象：12
Out[4]: 12

In [5]: a / b # 生成一个新的浮点型对象：0.75
Out[5]: 0.75

In [6]: c = 1 + 1j # 变量c链接到复数型对象1+1j

In [7]: a * c, b / c # 生成两个新的复数型对象：3+3j，2-2j
Out[7]: ((3+3j), (2-2j))