整型(int)¶
在python3中，整型、长整形、浮点数、负数等都可以称之为数字类型。
int（整型）
在32位机器上，整数的位数为32位，取值范围为-2**31～2**31-1，即-2147483648～2147483647
在64位系统上，整数的位数为64位，取值范围为-2**63～2**63-1，即-9223372036854775808～9223372036854775807
long（长整型）
跟C语言不同，Python的长整数没有指定位宽，即：Python没有限制长整数数值的大小，但实际上由于机器内存有限，我们使用的长整数数值不可能无限大。
注意，自从Python2.2起，如果整数发生溢出，Python会自动将整数数据转换为长整数，所以如今在长整数数据后面不加字母L也不会导致严重后果了。
float（浮点型）
浮点数用来处理实数，即带有小数的数字。类似于C语言中的double类型，占8个字节（64位），其中52位表示底，11位表示指数，剩下的一位表示符号。
complex（复数）
复数由实数部分和虚数部分组成，一般形式为x＋yj，其中的x是复数的实数部分，y是复数的虚数部分，这里的x和y都是实数。
注：Python中存在小数字池：-5 ～ 257
创建int对象¶
int类型通常都是数字，创建数字类型的方式有两种，且在创建的时候值两边不要加双引号或者单引号(引起来的内容是字符串)。
第一种创建整型的方式
>>> number = 9
>>> type(number)
<type 'int'>
第二种创建整型的方式
>>> number = int(9)
>>> type(number)
<type 'int'>
以上两种方式都可以创建整型对象，但是它们也是有本质的区别，第一种方式实际上会转换成第二种方式，然后第二种方式会把括号内的数据交给__int__这个构造方法，构造方法是int类的，然后构造方法会在内存中开辟一块空间用来存放数据，但实际上我们在使用时没有任何区别。
图
def __init__(self, x, base=10): # known special case of int.__init__
通过源码可以看到，__int__的方法有两个参数，其中base=10是可选的参数，x是我们对象的值，base=10其实就是说把我们的值（默认二进制）以十进制的方式输出出来，通过下面的实例可以看到：
>>> var=int('0b100',base=2)
>>> var
4
通过int()可以将一个数字的字符串变成一个整数，并且如果你指定了第二个参数，还可以将进制数转换为整数：
将数字字符串转换为整数，数字字符串通过进制转换为整数
>>> int('99'),int('100',8),int('40'),int('10000000',2)
(99, 64, 40, 128)
将进制数转换为整数
>>> int('0x40',16),int('0b1000000',2)
(64, 64)
把二进制的数字4通过十进制输出出来，4的二进制就是0b100，又有一个知识点就是在类的方法中，所以有以__开头，并且以__结尾的方法都试python内部自己去调用的，我们在写代码的过程中是不需要去调用的，最简单的例子就是__init__。
int内部优化机制¶
图
首先我们知道当我们创建第一个对象var1的时候会在内存中开辟一块空间作为存放var1对象的值用的，当我们创建第二个对象var2的时候也会在内存中开辟一块空间来作为var2对象的值。
这样的话对象var1和var2的值相等时内存是否会同时开辟两块？
➜ ~ python ## python版本
Python 3.5.3 (v3.5.3:1880cb95a742, Jan 16 2017, 08:49:46)
[GCC 4.2.1 (Apple Inc. build 5666) (dot 3)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
创建对象var1和var2
>>> var1 = 123
>>> var2 = 123
查看它们的内存地址，可以发现指向同一个地址
>>> id(var1)
4297558784
>>> id(var2)
4297558784
通过上的结果可以看到 var1 和 var2
的内存地址是相同的，就代表它们的值是使用的同一块空间，当我们把 var2
的值改为456
>>> var1
123
>>> var2
123
>>> var2 = 456
>>> id(var1)
4297558784
>>> id(var2)
4321202000
可以看到 var2 的内存地址变了，对象值不一样，所以他才会改变。
当两个或者多个对象的值都是同一个的时候，那么这些对象都会使用同一个内存地址，这里的值是有范围的，默认为
-5～257
图
>>> var1 = 123
>>> var2 = var1
>>> id(var1)
4297558784
>>> id(var2)
4297558784
>>> var1 = 456
>>> id(var1)
4321202000
>>> id(var2)
4297558784
在-5~257这个范围内对象的值都会引用同一块内存地址
>>> var1 = 12345
>>> var2 = 12345
>>> id(var1)
4323812272
>>> id(var2)
4321202000
var1和var2的值同样是12345，但是它们的内存地址不一样，这就是python在内部做的优化
数字类型的长度限制¶
数字类型在python2.7里面是分整型和长整形这个区别的，也就是说如果你的数字大到一定的范围，那么python会把它转换为长整形，一个数字类型包含32位，可以存储从-2147483648到214483647的整数。
一个长整（long）型会占用更多的空间，64位的可以存储-922372036854775808到922372036854775808的整数。
python3里的long型已经不存在了，而int型可以存储到任意大小的整型，甚至超过64位。
Python内部对整数的处理分为普通整数和长整数，普通整数长度为机器位长，通常都是32位，超过这个范围的整数就自动当长整数处理，而长整数的范围几乎完全没限制，如下：
Python2.7.x
>>> var=123456
>>> var
123456
>>> var=10**20
>>> var
100000000000000000000L
>>> type(var)
# long就是长整型
<type 'long'>
Python3.5.x
>>> var=123456789
>>> var
123456789
>>> var=10**20
>>> var
100000000000000000000
>>> type(var)
<class 'int'>
数字类型所具备的方法¶
mac 或 Linux 在命令行可输入int.然后连续按两个Tab键,查看所有方法
bit_length
返回表示该数字时占用的最少位数
>>> num = 20
>>> num.bit_length()
5
conjugate
返回该复数的共轭复数，复数，比如0+2j,其中num.real,num.imag分别返回其实部和虚部，num.conjugate()，返回其共轭复数对象
>>> num = -20
>>> num.conjugate()
-20
>>> num = 0+2j
>>> num.real
0.0
>>> num.conjugate()
-2j
imag
返回复数的虚数
>>> num = 10
>>> num.imag
0
>>> number = 3.1415926
>>> number.imag
0.0
内置的方法还有 denominator 、 from_bytes 、 numerator 、
real 、 to_bytes ，不常用,可以通过 help(int.numerator)
类似方法查看相关的帮助信息。
混合类型¶
所谓混合类型就是浮点数和整数进行运算
>>> 3.1415926 + 10
13.1415926
浮点数如何和一个正整数相加？python会把两个值转换为其中最复杂的那个对象的类型，然后再对相同类型运算。
数字类型的复杂度¶
整数比浮点数简单、浮点数比复数简单。
取整的方法¶
向下取整¶
>>> a = 4.75
>>> int(a)
4
向上取整¶
>>> import math
>>> math.ceil(2.32)
3
四舍五入¶
>>> round(3.35)
3
>>> round(3.67)
4
分别取整数部分和小数部分¶
>>> import math
>>> math.modf(3.25)
(0.25, 3.0)
>>> math.modf(3.75)
(0.75, 3.0)
>>> math.modf(4.2)
(0.20000000000000018, 4.0)
最后一个输出，涉及到了另一个问题，
即浮点数在计算机中的表示，在计算机中是无法精确的表示小数的，至少目前的计算机做不到这一点。
上例中最后的输出结果只是 0.2 在计算中的近似表示。
Python 和 C 一样, 采用 IEEE 754 规范来存储浮点数。