python基本数据类型--整型(int)

给变量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)  # 1

7整除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)  # 0

6是可以整除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)  # 3

7整除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)  # False

number_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)  # True

number_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)  # False

number_a的值为2，number_b的值也为2，所以number_a是等于number_b的，条件不成立返回False。

number_a = 2
number_b = 1
print(number_a > number_b)  # True

number_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)  # False

number_a的值为2，number_b的值也为2，所以number_a是等于number_b的，条件不成立返回False。

number_a = 1
number_b = 2
print(number_a < number_b)  # True

number_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)  # True

number_a的值为2，number_b的值也为2，所以number_a是等于number_b的，条件成立返回True。

number_a = 1
number_b = 2
print(number_a >= number_b)  # False

number_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)  # True

number_a的值为2，number_b的值也为2，所以number_a是等于number_b的，条件成立返回True。

number_a = 1
number_b = 2
print(number_a <= number_b)  # True

number_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)  # True

a和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)  # False

a是整型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)  # True

a是整型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)  # False

a和b都是整型1，a和b所代表的整型数据1取自内存中的同一个地方，所以a is not b返回False。

爆笑蛙

关注

27
点赞
踩
109

收藏

觉得还不错? 一键收藏
2
评论
python基本数据类型--整型(int)

整型就是数学当中的整数如：1，-1，0，10，-10等等，属于不可迭代对象。整型是不可变的数据类型，在内存中每个整型数据只存在唯一的地址。经常参与到各种的计算当中，所以我们需要知道与整型相关的运算符，主要有算数运算符、比较运算符、赋值运算符、位运算符、身份运算符。
复制链接

扫一扫