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

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

执行结果如下：


![](https://img-blog.csdnimg.cn/6027af25b11740399c814b6efa4de766.png)


报错显示变量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

计算过程如下：


![](https://img-blog.csdnimg.cn/68da1aa834c14f99b52efcf220de9b74.png)


2进制数11转换为10进制数就是3了，所以a & b的结果为3。 例子中两个数都是正数，符号位为0，我就把符号位省略了，有负数参与时注意符号位。负数需要在左边添加一个1来表示负号，并且负数不能对齐时添1补齐。负数与整数的按位与运算，举个例子，请看如下代码：

a = -15 # 11111 有符号2进制数，第一个1表示负号（-）
b = 99 # 01100011 有符号2进制数，第一个0表示正号（+）
print(a & b) # 97

计算过程如下：


![](https://img-blog.csdnimg.cn/a981f747e79a45f19396e01424344aff.png)


这里面涉及到有符号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

计算过程如下：


![](https://img-blog.csdnimg.cn/dc1ced4616d74dada263ea79824a2c6d.png)


有符号2进制数11101111转换为10进制数就是-111了，第一个1表示负号，后面的1101111才表示数值大小。所以a & b的结果为-111。


### 位运算符（|）


        |的作用就是对两个数据的2进制数的位做或运算，相同位上都是0时为0，否则为1。举个例子，请看如下代码:

a = 15 # 0b1111
b = 99 # 0b1100011
print(a | b) # 111

计算过程如下：


![](https://img-blog.csdnimg.cn/080f94b276f14d5a8f066c1cabf310bc.png)


 2进制数1101111转换为10进制数就是111了，所以a | b的结果为111。  例子中两个数都是正数，符号位为0，我就把符号位省略了，有负数参与时注意符号位。负数与整数的按位或运算，举个例子，请看如下代码：

a = -15 # 11111 有符号2进制数，第一个1表示负号（-）
b = 99 # 01100011 有符号2进制数，第一个0表示正号（+）
print(a | b) # -13

计算过程如下：


![](https://img-blog.csdnimg.cn/1448728166984340adaaf46c571ed140.png)


有符号2进制数10001101转换为10进制数就是-13了，第一个1表示负号，后面的0001101才表示数值大小。所以a | b的结果为-13。


两个负数的按位或运算，举个例子，请看如下代码：

a = -15 # 11111 有符号2进制数，第一个1表示负号（-）
b = -99 # 11100011 有符号2进制数，第一个1表示负号（-）
print(a | b) # -3

计算过程如下：


![](https://img-blog.csdnimg.cn/30c7d1dfd86b47e5bdd1ae28436dbe71.png)


有符号2进制数10000011转换为10进制数就是-3了，第一个1表示负号，后面的0000011才表示数值大小。所以a | b的结果为-3。


### 位运算符（^）


        ^的作用就是对两个数据的2进制数的位做异或运算，相同位上相等时为0，否则为1。举个例子，请看如下代码:

a = 15 # 0b1111
b = 99 # 0b1100011
print(a ^ b) # 108

计算过程如下：


![](https://img-blog.csdnimg.cn/de192af46216479bb14e0e378c8f477e.png)


 2进制数1101100转换为10进制数就是108了，所以a ^ b的结果为108。  例子中两个数都是正数，符号位为0，我就把符号位省略了，有负数参与时注意符号位。负数与整数的按位异或运算，举个例子，请看如下代码：

a = -15 # 11111 有符号2进制数，第一个1表示负号（-）
b = 99 # 01100011 有符号2进制数，第一个0表示正号（+）
print(a ^ b) # -110

计算过程如下：


![](https://img-blog.csdnimg.cn/5a25826318f247d9ae7368b81a05b0c4.png)


有符号2进制数11101110转换为10进制数就是-110了，第一个1表示负号，后面的1101110才表示数值大小。所以a ^ b的结果为-110。


两个负数的按位异或运算，举个例子，请看如下代码：

a = -15 # 11111 有符号2进制数，第一个1表示负号（-）
b = -99 # 11100011 有符号2进制数，第一个1表示负号（-）
print(a ^ b) # 108

计算过程如下：


![](https://img-blog.csdnimg.cn/2ccbedea437d423cbf0812a823400630.png)


有符号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

计算过程如下：


![](https://img-blog.csdnimg.cn/6f7a939858ff43bfb99c49f2465806bc.png)


有符号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

计算过程如下：


![](https://img-blog.csdnimg.cn/15ccc42231e741dd99bc5746780dff9e.png)


有符号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

计算过程如下：


![](https://img-blog.csdnimg.cn/c7b68ddfd31346d1a42e7931e864104a.png)


有符号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。

 **自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。**

**深知大多数Python工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！**

**因此收集整理了一份《2024年Python开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。**

![img](https://img-blog.csdnimg.cn/img_convert/4e4a98957c2baee63b04e9df5c1019e9.png)

![img](https://img-blog.csdnimg.cn/img_convert/716c6bd71add84c75a6b7105414f2408.png)

![img](https://img-blog.csdnimg.cn/img_convert/754f829844eaeb03ac9b4313c3f9201a.png)

![img](https://img-blog.csdnimg.cn/img_convert/dc5b5903d681b11381049149c45cd268.png)

![img](https://img-blog.csdnimg.cn/img_convert/6c361282296f86381401c05e862fe4e9.png)

![img](https://img-blog.csdnimg.cn/img_convert/9f49b566129f47b8a67243c1008edf79.png)

**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上前端开发知识点，真正体系化！**

**由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新**

**如果你觉得这些内容对你有帮助，可以扫码获取！！！（备注：Python）**

、OPPO等大厂，18年进入阿里一直到现在。**

**深知大多数Python工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！**

**因此收集整理了一份《2024年Python开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。**

[外链图片转存中...(img-CRcEM7iz-1713636633110)]

[外链图片转存中...(img-ZlkwYwjj-1713636633111)]

[外链图片转存中...(img-SWPeYlzW-1713636633112)]

[外链图片转存中...(img-Ab4fqlx4-1713636633113)]

![img](https://img-blog.csdnimg.cn/img_convert/6c361282296f86381401c05e862fe4e9.png)

![img](https://img-blog.csdnimg.cn/img_convert/9f49b566129f47b8a67243c1008edf79.png)

**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上前端开发知识点，真正体系化！**

**由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新**

**如果你觉得这些内容对你有帮助，可以扫码获取！！！（备注：Python）**

![](https://img-blog.csdnimg.cn/img_convert/4bcc9b8b4a94d0ad24c68bf6803f7b15.jpeg)