数字¶

整型 Integers¶

整型运算，加减乘：

In [1]:

  1. 2 + 2

Out[1]:

  1. 4

In [2]:

  1. 3 - 4

Out[2]:

  1. -1

In [3]:

  1. 4 * 5

Out[3]:

  1. 20

在Python 2.7中，整型的运算结果只能返回整型，除法的结果也不例外。

例如12 / 5返回的结果并不是2.4，而是2：

In [4]:

  1. 12 / 5

Out[4]:

  1. 2

幂指数：

In [5]:

  1. 2 ** 5

Out[5]:

  1. 32

取余：

In [6]:

  1. 32 % 5

Out[6]:

  1. 2

赋值给变量：

In [7]:

  1. a = 1
  2. a

Out[7]:

  1. 1

使用type()函数来查看变量类型：

In [8]:

  1. type(a)

Out[8]:

  1. int

整型数字的最大最小值：

在 32 位系统中，一个整型 4 个字节，最小值 -2,147,483,648，最大值 2,147,483,647。

在 64 位系统中，一个整型 8 个字节，最小值 -9,223,372,036,854,775,808，最大值 9,223,372,036,854,775,807。

In [9]:

  1. import sys
  2. sys.maxint

Out[9]:

  1. 2147483647

长整型 Long Integers¶

当整型超出范围时，Python会自动将整型转化为长整型，不过长整型计算速度会比整型慢。

In [10]:

  1. a = sys.maxint + 1
  2. print type(a)
  1. <type 'long'>

长整型的一个标志是后面以字母L结尾：

In [11]:

  1. a

Out[11]:

  1. 2147483648L

可以在赋值时强制让类型为长整型：

In [12]:

  1. b = 1234L
  2. type(b)

Out[12]:

  1. long

长整型可以与整型在一起进行计算，返回的类型还是长整型：

In [13]:

  1. a - 4

Out[13]:

  1. 2147483644L

浮点数 Floating Point Numbers¶

In [14]:

  1. a = 1.4
  2. type(a)

Out[14]:

  1. float

在之前的除法例子12 / 5中，假如想要使返回的结果为2.4，可以将它们写成浮点数的形式：

In [15]:

  1. 12.0 / 5.0

Out[15]:

  1. 2.4

In [16]:

  1. 12 / 5.0

Out[16]:

  1. 2.4

In [17]:

  1. 12.0 / 5

Out[17]:

  1. 2.4

上面的例子说明，浮点数与整数进行运算时，返回的仍然是浮点数：

In [18]:

  1. 5 + 2.4

Out[18]:

  1. 7.4

浮点数也可以进行与整数相似的运算，甚至可以取余：

In [19]:

  1. 3.4 - 3.2

Out[19]:

  1. 0.19999999999999973

In [20]:

  1. 12.3 + 32.4

Out[20]:

  1. 44.7

In [21]:

  1. 2.5 ** 2

Out[21]:

  1. 6.25

In [22]:

  1. 3.4 % 2.1

Out[22]:

  1. 1.2999999999999998

Python的浮点数标准与C，Java一致，都是IEEE 754 floating point standard。

注意看 3.4 - 3.2 的结果并不是我们预期的0.2，这是因为浮点数本身储存方式引起的，浮点数本身会存在一点误差。

事实上，Python 中储存的值为'0.199999999999999733546474089962430298328399658203125'，因为这是最接近0.2的浮点数。|

In [23]:

  1. '{:.52}'.format(3.4 - 3.2)

Out[23]:

  1. '0.199999999999999733546474089962430298328399658203125'

当我们使用print显示时，Python会自动校正这个结果

In [24]:

  1. print 3.4 - 3.2
  1. 0.2

可以用sys.float_info来查看浮点数的信息：

In [25]:

  1. import sys
  2. sys.float_info

Out[25]:

  1. sys.float_info(max=1.7976931348623157e+308, max_exp=1024, max_10_exp=308, min=2.2250738585072014e-308, min_exp=-1021, min_10_exp=-307, dig=15, mant_dig=53, epsilon=2.220446049250313e-16, radix=2, rounds=1)

例如浮点数能表示的最大值：

In [26]:

  1. sys.float_info.max

Out[26]:

  1. 1.7976931348623157e+308

浮点数能表示的最接近0的值：

In [27]:

  1. sys.float_info.min

Out[27]:

  1. 2.2250738585072014e-308

浮点数的精度：

In [28]:

  1. sys.float_info.epsilon

Out[28]:

  1. 2.220446049250313e-16

复数 Complex Numbers¶

Python 使用 j 来表示复数的虚部：

In [29]:

  1. a = 1 + 2j
  2. type(a)

Out[29]:

  1. complex

可以查看它的实部，虚部以及共轭：

In [30]:

  1. a.real

Out[30]:

  1. 1.0

In [31]:

  1. a.imag

Out[31]:

  1. 2.0

In [32]:

  1. a.conjugate()

Out[32]:

  1. (1-2j)

交互计算¶

可以将复杂的表达式放在一起计算：

In [33]:

  1. 1 + 2 - (3 * 4 / 6) ** 5 + 7 % 5

Out[33]:

  1. -27

在Python中运算是有优先级的，优先级即算术的先后顺序，比如“先乘除后加减”和“先算括号里面的”都是两种优先级的规则，优先级从高到低排列如下：

  • ( ) 括号
  • ** 幂指数运算
  • * / // % 乘，除，整数除法，取余运算
  • '+ -' 加减
    整数除法，返回的是比结果小的最大整数值：

In [34]:

  1. 12.3 // 5.2

Out[34]:

  1. 2.0

In [35]:

  1. 12.3 // -4

Out[35]:

  1. -4.0

简单的数学函数¶

绝对值：

In [36]:

  1. abs(-12.4)

Out[36]:

  1. 12.4

取整：

In [37]:

  1. round(21.6)

Out[37]:

  1. 22.0

最大最小值：

In [38]:

  1. print min(2, 3, 4, 5)
  2. print max(2, 4, 3)
  1. 2
  2. 4

变量名覆盖¶

不要用内置的函数来命名变量，否则会出现意想不到的结果：

In [39]:

  1. type(max)

Out[39]:

  1. builtin_function_or_method

不要这样做！！！

In [40]:

  1. max = 1
  2. type(max)

Out[40]:

  1. int

In [41]:

  1. max(4, 5)
  1. ---------------------------------------------------------------------------
  2. TypeError                                 Traceback (most recent call last)
  3. <ipython-input-41-c60446be959c> in <module>()
  4. ----> 1 max(4, 5)
  5.  
  6. TypeError: 'int' object is not callable

类型转换¶

浮点数转整型，只保留整数部分：

In [42]:

  1. print int(12.324)
  2. print int(-3.32)
  1. 12
  2. -3

整型转浮点型：

In [43]:

  1. print float(1.2)
  1. 1.2

其他表示¶

除了10进制外，整数还有其他类型的表示方法。

科学计数法：

In [44]:

  1. 1e-6

Out[44]:

  1. 1e-06

16进制，前面加0x修饰，后面使用数字0-9A-F：

In [45]:

  1. 0xFF

Out[45]:

  1. 255

8进制，前面加0或者0o修饰，后面使用数字0-7：

In [46]:

  1. 067

Out[46]:

  1. 55

2进制，前面加0b修饰，后面使用数字0或1：

In [47]:

  1. 0b101010

Out[47]:

  1. 42

原地计算 In-place¶

Python可以使用下面的形式进行原地计算：

In [48]:

  1. b = 2.5
  2. b += 2
  3. print b
  4. b *= 2
  5. print b
  6. b -= 3
  7. print b
  1. 4.5
  2. 9.0
  3. 6.0

布尔型 Boolean Data Type¶

布尔型可以看成特殊的二值变量，其取值为True和False：

In [49]:

  1. q = True
  2. type(q)

Out[49]:

  1. bool

可以用表达式构建布尔型变量：

In [50]:

  1. q = 1 > 2
  2. print q
  1. False

常用的比较符号包括：

  1. <, >, <=, >=, ==, !=

Python支持链式比较：

In [51]:

  1. x = 2 
  2. 1 < x <= 3

Out[51]:

  1. True

原文: https://nbviewer.jupyter.org/github/lijin-THU/notes-python/blob/master/02-python-essentials/02.03-numbers.ipynb