目录 | 上一节 (1.2 第一个程序) | 下一节 (1.4 字符串)

1.3 数字

本节讨论数学计算。

数字类型

Python 有 4 种类型的数字：

  • 布尔型
  • 整型
  • 浮点型
  • 复数（虚数）

布尔型（bool）

布尔型数字有两个值：True，False。

  1. a = True
  2. b = False

在数值上，它们被计算成值为 1，0 的数。

  1. c = 4 + True # 5
  2. d = False
  3. if d == 0:
  4.     print('d is False')

但是，不要像上面这样写代码，这会很奇怪。

整型（int）

任意大小的有符号值，或者以任意数为基数的有符号值。

  1. a = 37
  2. b = -299392993727716627377128481812241231
  3. c = 0x7fa8      # 十六进制（Hexadecimal）
  4. d = 0o253       # 八进制（Octal）
  5. e = 0b10001111  # 二进制（Binary）

常用操作：

  1. x + y      加（Add）
  2. x - y      减（Subtract）
  3. x * y      乘（Multiply）
  4. x / y      除（Divide，生成一个浮点数） 
  5. x // y     地板除（Floor Divide，生成一个整数）
  6. x % y      取模（Modulo，余数(remainder)） 
  7. x ** y     幂运算（Power）
  8. x << n     左移位（Bit shift left）
  9. x >> n     右移位（Bit shift right）
  10. x & y      按位与（Bit-wise AND）
  11. x | y      按位或（Bit-wise OR）
  12. x ^ y      按位异或（Bit-wise XOR）
  13. ~x         取反（Bit-wise NOT）
  14. abs(x)     绝对值（Absolute value）

浮点型（float）

使用十进制或者指数表示法来指定浮点数的值：

  1. a = 37.45
  2. b = 4e5 # 4 x 10**5 or 400,000
  3. c = -1.345e-10

使用浮点数表示 IEEE 754 标准的双精度。这与 C 语言中的 double 类型相同。

17 digits of precision
Exponent from -308 to 308

请注意，当代表小数时，浮点数是不精确的。

  1. >>> a = 2.1 + 4.2
  2. >>> a == 6.3
  3. False
  4. >>> a
  5. 6.300000000000001
  6. >>>

这不是 Python 的问题，而是 CPU 硬件上底层浮点硬件的问题。

常用操作：

  1. x + y      加（Add）
  2. x - y      减（Subtract）
  3. x * y      乘（Multiply）
  4. x / y      除（Divide）
  5. x // y     地板除（Floor Divide）
  6. x % y      取模（Modulo）
  7. x ** y     幂运算（Power）
  8. abs(x)     绝对值（Absolute Value）

除了按位运算符之外，浮点数的运算符与整数的运算符是一样的。

其它数学函数可以在 math 中找到。

  1. import math
  2. a = math.sqrt(x)
  3. b = math.sin(x)
  4. c = math.cos(x)
  5. d = math.tan(x)
  6. e = math.log(x)

比较

下面的比较/关系运算符可以应用于数字：

  1. x < y      小于（Less than）
  2. x <= y     小于等于（Less than or equal）
  3. x > y      大于（Greater than）
  4. x >= y     大于等于（Greater than or equal）
  5. x == y     等于（Equal to）
  6. x != y     不等于（Not equal to）

可以使用 and， or，not 组成更复杂的布尔表达式。

这里有一些例子：

  1. if b >= a and b <= c:
  2.     print('b is between a and c')
  4. if not (b < a or b > c):
  5.     print('b is still between a and c')

转换数字

类型名可以被用来将其它数据转换为数字。

  1. a = int(x)    # Convert x to integer
  2. b = float(x)  # Convert x to float

试试下面这些操作：

  1. >>> a = 3.14159
  2. >>> int(a)
  3. 3
  4. >>> b = '3.14159' # It also works with strings containing numbers
  5. >>> float(b)
  6. 3.14159
  7. >>>

练习

提醒：这些练习假定你正在 practical-python/Work 目录中操作，具体在 mortgage.py 文件。

练习 1.7：戴夫的抵押贷款

戴夫决定从 Guido 的抵押贷款、股票投资和比特币交易公司获得 50 万美元的 30 年期固定利率抵押贷款。利率是 5%，每月还款额是 2684.11 美元。

下面这个程序用于计算戴夫在抵押期内需要支付的总金额：

  1. # mortgage.py
  3. principal = 500000.0
  4. rate = 0.05
  5. payment = 2684.11
  6. total_paid = 0.0
  8. while principal > 0:
  9.     principal = principal * (1+rate/12) - payment
  10.     total_paid = total_paid + payment
  12. print('Total paid', total_paid)

输入该程序并执行，你应该会得到答案为 966,279.6。

练习 1.8：额外付款

假设戴夫在抵押期的前 12 个月每月额外支付 1000 美元。

修改程序以包含这部分额外的付款，并且输出已支付的总金额以及所需的月数。

当你执行这个新程序时，它应该报告 342 个月的总付款额是 929,965.62 。

练习 1.9：制作一个额外的付款计算器

修改程序，以便可以更一般地处理额外的付款信息。做到这一点，以便用户可以设置下面这些变量：

  1. extra_payment_start_month = 61
  2. extra_payment_end_month = 108
  3. extra_payment = 1000

使程序查看这些变量，并适当地计算总付款额 。如果戴夫从抵押期的第五年开始，每月额外支付 1000 每月并支付 4 年，那么他将要支付多少？

练习 1.10：制作表格

修改程序，使其显示迄今为止支付的月数，支付的总金额和剩余的本金。输出看起来应该像下面这样：

  1. 1 2684.11 499399.22
  2. 2 5368.22 498795.94
  3. 3 8052.33 498190.15
  4. 4 10736.44 497581.83
  5. 5 13420.55 496970.98
  6. ...
  7. 308 874705.88 3478.83
  8. 309 877389.99 809.21
  9. 310 880074.1 -1871.53
  10. Total paid 880074.1
  11. Months 310

练习 1.11：奖金

使用该程序时，请修复程序以纠正发生在上个月的超额支付。

练习 1.12：一个谜

int() 函数和 float() 函数可以将其它类型的数据转换为数字类型。示例：

  1. >>> int("123")
  2. 123
  3. >>> float("1.23")
  4. 1.23
  5. >>>

考虑到这一点，你能否解释下面这种行为？

  1. >>> bool("False")
  2. True
  3. >>>

目录 | 上一节 (1.2 第一个程序) | 下一节 (1.4 字符串)