python基本数据类型--整型(int)
目录
整型(int)的定义
整型 算术运算符
算术运算符（+）
算术运算符（-）
算术运算符（*）
算术运算符（/）
算术运算符（%）
算术运算符（//）
算术运算符（**）
整型 比较运算符
比较运算符（==）
比较运算符（!=）
比较运算符（>）
比较运算符（<）
比较运算符（>=）
比较运算符（<=）
整型 赋值运算符
赋值运算符（=）
赋值运算符（+=）
赋值运算符（-=）
赋值运算符（*=）
赋值运算符（/=）
赋值运算符（%=）
赋值运算符（//=）
赋值运算符（**=）
整型 位运算符
位运算符（&）
位运算符（|）
位运算符（^）
位运算符（~）
位运算符（<<）
位运算符（>>）
整型 身份运算符
身份运算符（is）
身份运算符（is not）
整型(int)的定义
整型就是数学当中的整数如：1，-1，0，10，-10等等，属于不可迭代对象。整型是不可变的数据类型，在内存中每个整型数据只存在唯一的地址。在代码中我们可以使用以下3种方式来表示整型数据。
第一种，直接给变量赋值为一个整数。
number = 1
print(number) # 1给变量number赋值为1，此时number的数据类型为整型，number的值为1。
第二种，使用int函数。
number = int(1)
print(number) # 1给变量number赋值为1，此时number的数据类型为整型，number的值为1。其实这两种方式在python解释器看来都是一样的，因为第一种写法更简单，所以我们常用第一种写法。但是第二种方式还有一个特殊的作用，就是可以把浮点型转换成整型，这是第一种方式做不到的。如下：
number = int(1.6)
print(number) # 1给变量number赋值为1，此时number的数据类型为整型，number的值为1。这种方式会把浮点型的小数部分直接去掉，只保留整数部分，再赋值给变量。
第三种，使用int函数把数字字符串转换为整型。
number = int("1")
print(number) # 1给变量number赋值为1，此时number的数据类型为整型，number的值为1。这种方式是把字符串"1"转换为整型1，需要注意的是这种方式只能把纯数字的字符串转换为整型。我再给大家将一下这种方式的其它使用情况，这些知识是不需要现阶段掌握的。初学者不需要深究这些知识，等到以后需要用到这些方法的时候，再回来查看，你就会自然明白了。int类中把字符串转换为整型的初始化函数如下：
def __init__(self, x, base=10):其中参数x是用来接收字符串的，参数base是用来接收传入字符串进制的。因为base是一个省缺参数，它有一个默认值10，当我们不传入base的值时，base的值为10。如果我们传入的字符串为"0b"开头的2进制数的字符串时，我们需要传入base=2来说明我们传入的是2进制数字符串，如下所示：
a = int("0b100", base=2) # 把表示2进制数的字符串"0b100"转换为10进制的4
print(a) # 4这就是把2进制数的字符串转换为10进制的方法，10进制数转换为2进制数，我们可以使用bin函数，如下所示：
a = bin(4) # 把10进制数4转换为2进制数，再把转换后的2进制数赋值给变量a
print(a) # 0b100如果我们传入的字符串为"0o"开头的8进制数的字符串时，我们需要传入base=8来说明我们传入的是8进制数字符串，如下所示：
b = int("0o100", base=8) # 把表示8进制数的字符串"0o100"转换为10进制的64
print(b) # 64这就是把8进制数的字符串转换为10进制的方法，10进制数转换为8进制数，我们可以使用oct函数，如下所示：
b = oct(64) # 把10进制数64转换为8进制数0o100，再把转换后的8进制数赋值给变量b
print(b) # 0o100如果我们传入的字符串为"0x"开头的16进制数的字符串时，我们需要传入base=16来说明我们传入的是16进制数字符串，如下所示：
c = int("0x100", base=16) # 把表示16进制数的字符串"0x100"转换为10进制的256
print(c) # 256这就是把16进制数的字符串转换为10进制的方法，10进制数转换为16进制数，我们可以使用hex函数，如下所示：
c = hex(256) # 把10进制数256转换为16进制数0x100，再把转换后的16进制数赋值给变量c
print(c) # 0x100整型 算术运算符
| + | 加号，可以做加法 |
| - | 减号，可以做减法 |
| * | 乘号，可以做乘法 |
| / | 除号，可以做除法 |
| % | 取余，做整除，能整除时返回0，不能整除时返回余数 |
| // | 取整，做整除，只返回商，不返回余数 |
| ** | 求幂，做幂运算（次方） |
算术运算符（+）
就是做数学中的加法运算，把两个数相加求和。举个例子，请看如下代码：
number_a = 3
number_b = 2
number_c = number_a + number_b
print(number_c) # 5整型number_a和number_b相加求和，再把结果赋值给number_c，所以number_c的值为5。
算术运算符（-）
就是做数学中的减法运算，把两个数相减求差。举个例子，请看如下代码：
number_a = 3
number_b = 2
number_c = number_a - number_b
print(number_c) # 1整型number_a和number_b相减求差，再把结果赋值给number_c，所以number_c的值为1。
算术运算符（*）
就是做数学中的乘法运算，把两个数相乘求积。举个例子，请看如下代码：
number_a = 3
number_b = 2
number_c = number_a * number_b
print(number_c) # 6整型number_a和number_b相乘求积，再把结果赋值给number_c，所以number_c的值为6。
算术运算符（/）
就是做数学中的除法运算，把两个数相除求商。举个例子，请看如下代码：
number_a = 3
number_b = 2
number_c = number_a / number_b
print(number_c) # 1.5整型number_a和number_b相除求商，再把结果赋值给number_c，所以number_c的值为1.5。这里需要注意的是除法运算返回的是浮点型数据，就是小数，6除以2返回的也是3.0而不是3。
算术运算符（%）
就是做数学中的取余运算，把两个数相整除，当不能整除时会有余数，就返回这个余数；当可以整除时，余数为0，就返回0。举个例子，请看如下代码：
number_a = 7
number_b = 2
number_c = number_a % number_b
print(number_c) # 17整除2得3余1，返回余数1，把余数1赋值给number_c，所以number_c的值为1。
number_a = 6
number_b = 2
number_c = number_a % number_b
print(number_c) # 06是可以整除2的，但整除时也可以说余数为0。6整除2得3余0，返回余数0，把余数0赋值给number_c，所以number_c的值为0。
算术运算符（//）
就是做数学中的整除，把两个数相整除求商。只返回商，不返回余数。举个例子，请看如下代码：
number_a = 7
number_b = 2
number_c = number_a // number_b
print(number_c) # 37整除2得3余1，返回商3，把商3赋值给number_c，所以number_c的值为3。
算术运算符（**）
就是做数学中的幂运算，求x的n次方。举个例子，请看如下代码：
number_a = 2
number_b = 3
number_c = number_a ** number_b
print(number_c) # 8求number_a的number_b次方，number_a的值为2，number_b的值为3。所以就是2的3次方等于8，所以number_c的值为8。
整型 比较运算符
| == | 等于，判断左右两边是否相等 |
| != | 不等于，判断左右两边是否不相等 |
| > | 大于，判断左边是否大于右边 |
| < | 小于，判断左边是否小于右边 |
| >= | 大于等于，判断左边是否大于或等于右边 |
| <= | 小于等于，判断左边是否小于或等于右边 |
比较运算符（==）
用于判断左右两边的值是否相等，如果相等返回真（True），如果不相等则返回假（False）。True和False是python中的bool值，True表示真False表示假，bool值也属于python的基本数据类型。我们这里可以这样去理解，当条件成立时为True，条件不成立时为False。举个例子，请看下面的代码：
number_a = 2
number_b = 2
print(number_a == number_b) # True判断number_a是否等于number_b，number_a的值为2，number_b的值也为2，所以number_a和number_b是相等的，条件成立返回True。
number_a = 2
number_b = 3
print(number_a == number_b) # Falsenumber_a的值为2，number_b的值为3，所以number_a和number_b是不相等的，条件不成立返回False。
比较运算符（!=）
用于判断左右两边的值是否不相等，如果不相等时返回True，如果相等时返回False。举个例子，请看下面的代码：
number_a = 2
number_b = 2
print(number_a != number_b) # False判断number_a是否不等于number_b，number_a的值为2，number_b的值也为2，所以number_a和number_b是相等的，条件不成立返回False。
number_a = 2
number_b = 3
print(number_a != number_b) # Truenumber_a的值为2，number_b的值为3，所以number_a和number_b是不相等的，条件成立返回True。
比较运算符（>）
用于判断左边是否大于右边，如果大于返回True，如果不大于时（小于或等于时）返回False。举个例子，请看下面的代码：
number_a = 2
number_b = 3
print(number_a > number_b) # False判断number_a是否大于number_b，number_a的值为2，number_b的值为3，所以number_a是小于number_b的，条件不成立返回False。
number_a = 2
number_b = 2
print(number_a > number_b) # Falsenumber_a的值为2，number_b的值也为2，所以number_a是等于number_b的，条件不成立返回False。
number_a = 2
number_b = 1
print(number_a > number_b) # Truenumber_a的值为2，number_b的值为1，所以number_a是大于number_b的，条件成立返回True。
比较运算符（<）
用于判断左边是否小于右边，如果小于返回True，如果不小于时（大于或等于时）返回False。举个例子，请看下面的代码：
number_a = 3
number_b = 2
print(number_a < number_b) # False判断number_a是否小于number_b，number_a的值为3，number_b的值为2，所以number_a是大于number_b的，条件不成立返回False。
number_a = 2
number_b = 2
print(number_a < number_b) # Falsenumber_a的值为2，number_b的值也为2，所以number_a是等于number_b的，条件不成立返回False。
number_a = 1
number_b = 2
print(number_a < number_b) # Truenumber_a的值为1，number_b的值为2，所以number_a是小于number_b的，条件成立返回True。
比较运算符（>=）
用于判断左边是否大于或等于右边，如果大于等于返回True，如果不大于等于时（小于时）返回False。举个例子，请看下面的代码：
number_a = 3
number_b = 2
print(number_a >= number_b) # True判断number_a是否大于或等于number_b，number_a的值为3，number_b的值为2，所以number_a是大于number_b的，条件成立返回True。
number_a = 2
number_b = 2
print(number_a >= number_b) # Truenumber_a的值为2，number_b的值也为2，所以number_a是等于number_b的，条件成立返回True。
number_a = 1
number_b = 2
print(number_a >= number_b) # Falsenumber_a的值为1，number_b的值为2，所以number_a是小于number_b的，条件不成立返回False。
比较运算符（<=）
用于判断左边是否小于或等于右边，如果小于等于返回True，如果不小于等于时（大于时）返回False。举个例子，请看下面的代码：
number_a = 3
number_b = 2
print(number_a <= number_b) # False判断number_a是否小于或等于number_b，number_a的值为3，number_b的值为2，所以number_a是大于number_b的，条件不成立返回False。
number_a = 2
number_b = 2
print(number_a <= number_b) # Truenumber_a的值为2，number_b的值也为2，所以number_a是等于number_b的，条件成立返回True。
number_a = 1
number_b = 2
print(number_a <= number_b) # Truenumber_a的值为1，number_b的值为2，所以number_a是小于number_b的，条件成立返回True。
整型 赋值运算符
| = | 赋值运算符（前面就已经用到了，给某个变量赋值） |
| += | 加法赋值运算符，加等于 |
| -= | 减法赋值运算符，减等于 |
| *= | 乘法赋值运算符，乘等于 |
| /= | 除法赋值运算符，除等于 |
| %= | 取余赋值运算符，求余等于 |
| //= | 取整赋值运算符，求模等于 |
| **= | 求幂赋值运算符，求幂等于 |
赋值运算符（=）
用于给变量赋值，也可以说给数据取名字，方便操作数据，这里的数据包括python中的任意对象。对于整型数据来说，是把整型数据赋值给某个变量。举个例子，请看下面的代码：
number_a = 1
number_b = 2
number_c = number_a + number_b把整型数据1赋值给变量number_a，number_a的值为1。把整型数据2赋值给变量number_b，number_b的值为2。number_a和number_b进行加法运算，把求和结果整型数据3赋值给变量number_c。
=的特殊用法，用于交换两个变量的值。这两个变量的值可以是不同类型的数据，因为目前我们只讲了整型数据，所以我们这里只用整型数据举个例子，请看下面的代码：
number_a = 1
number_b = 2
print(number_a) # 1
print(number_b) # 2
number_a, number_b = number_b, number_a
print(number_a) # 2
print(number_b) # 1通过=我们可以把两个变量的值进行交换。通过上面的代码，我们还可以发现一个现象，就是=可以同时对多个变量进行赋值。只要左边的变量个数和右边的python对象个数相等就行，举个例子，请看下面的代码：
number_a, number_b, number_c = 1, 21, 6
print(number_a) # 1
print(number_b) # 21
print(number_c) # 6我们只用了一个=，就同时给3个变量赋值了，变量的顺序和值的顺序是一一对应的。
赋值运算符（+=）
加法赋值运算符，顾名思义先做加法再赋值。+=作用的对象必须是一个已经定义过的变量，就是这个变量必须已经赋值了。如果我们直接作用于一个未定义的变量会报错，比如下面的代码：
number += 1执行结果如下：
报错显示变量number未定义。所以我们要对一个变量使用+=，必须先给这个变量赋值。请看下面的代码：
number = 2
number += 3 # number = number + 3
print(number) # 5
第一行代码number = 2，给变量number赋值为2，number定义为整型数据值为2。第二行代码number += 3，相当于number = number + 3。先执行number + 3，相加求和结果为5，再把结果5赋值给number，这时number的值就变成5了。有的同学可能不太理解number = number + 1这种写法，我们可以把它想象成下面这种写法：
number = 2
number_s = number + 3
number = number_s
print(number) # 5多用一个变量number_s来接收number + 3的值，这时number_s的值为5。再把number_s的值赋给number，就是重新给number赋值，number的值就由原来的2变为现在的5了。number = number + 3就是把number_s给省略了，这样就比较好理解了。为什么可以省略，因为CPU中的寄存器可以临时存储数据，替代了用变量存储数据的行为，并且CPU从寄存器中存取数据比从内存中存取数据快很多倍。
赋值运算符（-=）
减法赋值运算符，顾名思义先做减法再赋值。-=作用的对象也必须是一个已经定义过的变量，举个例子，请看下面的代码：
number = 2
number -= 3 # number = number -3
print(number) # -1第一行代码number = 2，给变量number赋值为2，number定义为整型数据值为2。第二行代码number -= 3，相当于number = number - 3。先执行number - 3，相减求差结果为-1，再把结果-1赋值给number，这时number的值就变成-1了。理解方式参考+=。
赋值运算符（*=）
乘法赋值运算符，顾名思义先做乘法再赋值。*=作用的对象也必须是一个已经定义过的变量，举个例子，请看下面的代码：
number = 2
number *= 3 # number = number * 3
print(number) # 6第一行代码number = 2，给变量number赋值为2，number定义为整型数据值为2。第二行代码number *= 3，相当于number = number * 3。先执行number * 3，相乘求积结果为6，再把结果6赋值给number，这时number的值就变成6了。理解方式参考+=。
赋值运算符（/=）
除法赋值运算符，顾名思义先做除法再赋值。/=作用的对象也必须是一个已经定义过的变量，举个例子，请看下面的代码：
number = 6
number /= 3 # number = number / 3
print(number) # 2.0第一行代码number = 6，给变量number赋值为6，number定义为整型数据值为6。第二行代码number /= 3，相当于number = number / 3。先执行number / 3，相除求商结果为2.0，再把结果2.0赋值给number，这时number的值就变成2.0了。理解方式参考+=。
赋值运算符（%=）
取余赋值运算符，顾名思义先做整除取余再赋值。%=作用的对象也必须是一个已经定义过的变量，举个例子，请看下面的代码：
number = 7
number %= 3 # number = number % 3
print(number) # 1第一行代码number = 7，给变量number赋值为7，number定义为整型数据值为7。第二行代码number %= 3，相当于number = number % 3。先执行number % 3，整除取余结果为1，再把结果1赋值给number，这时number的值就变成1了。理解方式参考+=。
赋值运算符（//=）
取整赋值运算符，顾名思义先做整除取整再赋值。//=作用的对象也必须是一个已经定义过的变量，举个例子，请看下面的代码：
number = 7
number //= 3 # number = number // 3
print(number) # 2第一行代码number = 7，给变量number赋值为7，number定义为整型数据值为7。第二行代码number //= 3，相当于number = number // 3。先执行number // 3，整除取整结果为2，再把结果2赋值给number，这时number的值就变成2了。理解方式参考+=。
赋值运算符（**=）
求幂赋值运算符，顾名思义先做幂运算再赋值。**=作用的对象也必须是一个已经定义过的变量，举个例子，请看下面的代码：
number = 7
number **= 3 # number = number ** 3
print(number) # 343第一行代码number = 7，给变量number赋值为7，number定义为整型数据值为7。第二行代码number **= 3，相当于number = number ** 3。先执行number ** 3，做幂运算结果为343，再把结果343赋值给number，这时number的值就变成343了。理解方式参考+=。
整型 位运算符
位运算符（有点类似CPU中的逻辑电路计算原理，偏底层），初学者不用掌握。可以说掌握了也用不到，我在python代码中从来没用到过[doge]，可能是我还没有接触到需要使用它的领域吧！位运算符是作用于2进制的位上的，位就是我们所说的个位十位百位千位万位等等。
| & | 按位与（有符号2进制，相同位上都为1时为1，其他情况为0） |
| | | 按位或（有符号2进制，相同位上都为0时为0，其他情况为1） |
| ^ | 按位异或（有符号2进制，相同位上相等时为0，不相等时为1） |
| ~ | 按位取反（有符号2进制，0变1，1变0） |
| << | 左移（有符号2进制，向左移动n位） |
| >> | 右移（有符号2进制，向右移动n位） |
位运算符（&）
&的作用就是对两个数据的2进制数的位做与运算，相同位上都是1时为1，否则为0。举个例子，请看如下代码:
a = 15 # 0b1111
b = 99 # 0b1100011
print(a & b) # 3计算过程如下：
2进制数11转换为10进制数就是3了，所以a & b的结果为3。 例子中两个数都是正数，符号位为0，我就把符号位省略了，有负数参与时注意符号位。负数需要在左边添加一个1来表示负号，并且负数不能对齐时添1补齐。负数与整数的按位与运算，举个例子，请看如下代码：
a = -15 # 11111 有符号2进制数，第一个1表示负号（-）
b = 99 # 01100011 有符号2进制数，第一个0表示正号（+）
print(a & b) # 97计算过程如下：
这里面涉及到有符号2进制数的反码和补码规则，要弄懂它的计算过程就必须要知道有符号2进制数的反码和补码规则。有符号2进制正数，原码反码补码都一样；有符号2进制负数，反码为原码除符号位以外都取反，补码为反码加一。注意有符号负数原-反-补的逆向过程补-反-原。有符号2进制数01100001转换为10进制数就是97了，第一个0表示正号，后面的1100001才表示数值大小。所以a & b的结果为97。
两个负数的按位与运算，举个例子，请看如下代码：
a = -15 # 11111 有符号2进制数，第一个1表示负号（-）
b = -99 # 11100011 有符号2进制数，第一个1表示负号（-）
print(a & b) # -111计算过程如下：
有符号2进制数11101111转换为10进制数就是-111了，第一个1表示负号，后面的1101111才表示数值大小。所以a & b的结果为-111。
位运算符（|）
|的作用就是对两个数据的2进制数的位做或运算，相同位上都是0时为0，否则为1。举个例子，请看如下代码:
a = 15 # 0b1111
b = 99 # 0b1100011
print(a | b) # 111计算过程如下：
2进制数1101111转换为10进制数就是111了，所以a | b的结果为111。 例子中两个数都是正数，符号位为0，我就把符号位省略了，有负数参与时注意符号位。负数与整数的按位或运算，举个例子，请看如下代码：
a = -15 # 11111 有符号2进制数，第一个1表示负号（-）
b = 99 # 01100011 有符号2进制数，第一个0表示正号（+）
print(a | b) # -13计算过程如下：
有符号2进制数10001101转换为10进制数就是-13了，第一个1表示负号，后面的0001101才表示数值大小。所以a | b的结果为-13。
两个负数的按位或运算，举个例子，请看如下代码：
a = -15 # 11111 有符号2进制数，第一个1表示负号（-）
b = -99 # 11100011 有符号2进制数，第一个1表示负号（-）
print(a | b) # -3计算过程如下：
有符号2进制数10000011转换为10进制数就是-3了，第一个1表示负号，后面的0000011才表示数值大小。所以a | b的结果为-3。
位运算符（^）
^的作用就是对两个数据的2进制数的位做异或运算，相同位上相等时为0，否则为1。举个例子，请看如下代码:
a = 15 # 0b1111
b = 99 # 0b1100011
print(a ^ b) # 108计算过程如下：
2进制数1101100转换为10进制数就是108了，所以a ^ b的结果为108。 例子中两个数都是正数，符号位为0，我就把符号位省略了，有负数参与时注意符号位。负数与整数的按位异或运算，举个例子，请看如下代码：
a = -15 # 11111 有符号2进制数，第一个1表示负号（-）
b = 99 # 01100011 有符号2进制数，第一个0表示正号（+）
print(a ^ b) # -110计算过程如下：
有符号2进制数11101110转换为10进制数就是-110了，第一个1表示负号，后面的1101110才表示数值大小。所以a ^ b的结果为-110。
两个负数的按位异或运算，举个例子，请看如下代码：
a = -15 # 11111 有符号2进制数，第一个1表示负号（-）
b = -99 # 11100011 有符号2进制数，第一个1表示负号（-）
print(a ^ b) # 108计算过程如下：
有符号2进制数01101100转换为10进制数就是108了，第一个0表示正号，后面的1101100才表示数值大小。所以a ^ b的结果为108。
位运算符（~）
~的作用就是把一个数据的2进制数位的值取相反值，就是0变1，1变0。但又不是简单的0变1，1变0。这里面涉及到有符号2进制数的反码和补码规则，要弄懂它的计算过程就必须要知道有符号2进制数的反码和补码规则。如果不知道，我们也可以不了解它的计算过程，直接记住整型的按位取反结论：~ n = - (n + 1)。举个例子，请看如下代码：
a = 8 # 0b1000
print(~ a) # -9计算过程如下：
有符号2进制数11001转换为10进制数就是-9了，第一个1表示负号，后面的1001才表示数值大小。 所以~ a的结果为-9。如果看不懂上面的计算过程，就记住结论：~ n = - (n + 1)。
位运算符（<<）
<<的作用就是把一个数据的2进制数的位向左移动n个位置，例如x << n就是把x的2进制数的位向左移动n个位置。移动n个位置后会产生n个空位，n个空位全部添0补齐。举个例子，请看如下代码：
a = 3
print(a << 2) # 12计算过程如下：
有符号2进制数01100转换为10进制数就是12了，第一个0表示正号，后面的1100才表示数值大小。所以a << 2的结果为12。
位运算符（>>）
>>的作用就是把一个数据的2进制数的位向右移动n个位置，例如x >> n就是把x的2进制数的位向右移动n个位置。移动n个位置后会产生n个空位，正数空位用0填充，负数空位用1填充。举个例子，请看如下代码：
a = 3
print(a >> 2) # 0计算过程如下：
有符号2进制数000转换为10进制数就是0了，第一个0表示正号，后面的00才表示数值大小。所以a >> 2的结果为0。（如果你的CPU是32位的这里应该是32个0，我这里为了方便理解只用了3个0）
整型 身份运算符
其实不太需要身份运算符来判断两个整型数据的内存地址是否一致。因为整型数据具有不可变的特性，这就导致了只要两个整型数据的值相等，它们的内存地址就是一样的。所以我们完全可以使用==和!=来代替身份运算符在整型中的作用，但我们不要把==和!=与身份运算符搞混了。==和!=判断的是值是否相等，而身份运算符判断的是内存地址是否相同。对于可变的数据类型来说，即使它们的值相等，它们的内存地址也是不同的。
| is | 判断左右两边的内存地址是否相同，相同返回True，否则返回False |
| is not | 判断左右两边的内存地址是否不同，不同返回True，否则返回False |
身份运算符（is）
is用于判断左右两个对象的内存地址是否相同，如果相同返回True，不同返回False。举个例子，请看下面的代码：
a = 1
b = 1
print(id(a)) # 内存地址：140733625866000
print(id(b)) # 内存地址：140733625866000
print(a is b) # Truea和b都是整型1，因为整型是不可变的数据类型，所以两个相同的整型数据一定取自同一个地方。我们可以使用id函数来查看python中任意对象的内存地址，使用id函数后我们发现a和b的内存地址确实是相同的。a和b所代表的整型数据1取自内存中的同一个地方，所以a is b返回True。
a = 1
b = 2
print(id(a)) # 内存地址：140733625866000
print(id(b)) # 内存地址：140733625866032
print(a is b) # Falsea是整型1，b是整型2。因为整型数据1和2存放在内存中不同的地方，所以a is b返回False。
身份运算符（is not）
is not用于判断左右两个对象的内存地址是否不同，如果不同返回True，相同返回False。举个例子，请看下面的代码：
a = 1
b = 2
print(id(a)) # 内存地址：140733625866000
print(id(b)) # 内存地址：140733625866032
print(a is not b) # Truea是整型1，b是整型2。因为整型数据1和2存放在内存中不同的地方，所以a is not b返回True。
a = 1
b = 1
print(id(a)) # 内存地址：140733625866000
print(id(b)) # 内存地址：140733625866000
print(a is not b) # Falsea和b都是整型1，a和b所代表的整型数据1取自内存中的同一个地方，所以a is not b返回False。