Python变量类型和运算符(运算符)

 python 算数运算符

算术运算符是处理四则运算的符号，在数字的处理中应用得最多。Python 支持所有的基本算术运算符，如表 1 所示

表 1 Python常用算术运算符

运算符	说明	实例	结果
+	加	12.45 + 15	27.45
-	减	4.56 - 0.26	4.3
*	乘	5 * 3.6	18.0
/	除	7 / 2	3.5
%	取余，即返回除法的余数	7 % 2	1
//	整除，返回商的整数部分	7 // 2	3
**	幂，即返回 x 的 y 次方	2 ** 4	16，即 24

 python 赋值运算符

赋值运算符主要用来为变量（或常量）赋值，在使用时，既可以直接用基本赋值运算符“=”将右侧的值赋给左侧的变量，右侧也可以在进行某些运算后再赋值给左侧的变量。

需要初学者特别注意的是，= 和 == 的含义完全不同，前者是赋值号，后者是等号，千万不要混淆。

 = 赋值运算符还可与其他运算符（算术运算符、位运算符等）结合，成为功能更强大的赋值运算符，称为扩展后的运算符

表 1 Python 常用赋值运算符

运算符	说 明	举 例	展开形式
=	最基本的赋值运算	x = y	x = y
+=	加赋值	x += y	x = x + y
-=	减赋值	x -= y	x = x - y
*=	乘赋值	x *= y	x = x * y
/=	除赋值	x /= y	x = x / y
%=	取余数赋值	x %= y	x = x % y
**=	幂赋值	x **= y	x = x ** y
//=	取整数赋值	x //= y	x = x // y
|=	按位或赋值	x |= y	x = x | y
^=	按位与赋值	x ^= y	x = x ^ y
<<=	左移赋值	x <<= y	x = x << y，这里的 y 指的是左移的位数
>>=	右移赋值	x >>= y	x = x >> y，这里的 y 指的是右移的位数

通常情况下，只要能使用扩展后的赋值运算符，都推荐使用这种赋值运算符。

python  位运算符

 位运算符通常在图形、图像处理和创建设备驱动等底层开发中使用。使用位运算符可以直接操作数值的原始 bit 位，尤其是在使用自定义的协议进行通信时，使用位运算符对原始数据进行编码和解码也非常有效。

 位运算符的操作对象是整数类型，它会把数字看做对应的二进制数来进行计算

表 1 Python位运算符

位运算符	说 明	使用形式	举 例
&	按位与	a & b	4 & 5
|	按位或	a | b	4 | 5
^	按位异或	a ^ b	4 ^ 5
~	按位取反	~a	~4
<<	按位左移	a << b	4 << 2，表示数字 4 按位左移 2 位
>>	按位右移	a >> b	4 >> 2，表示数字 4 按位右移 2 位

[root@kube count]# cat demo1.py 
print(2&5)    #与 即：两位同时为“1”，结果才为“1”，否则为0

print(2|5)    #或 即 ：参加运算的两个对象只要有一个为1，其值为1。

print(2^5)    #异 即：参加运算的两个对象，如果两个相应位为“异”（值不同），则该位结果为1，否则为0。

print(~2)     #按位取反 即：将操作数的所有二进制位，1 改为 0，0 改为 1。

print(2<<5)   # 左移运算 即： 左移运算符是将操作数补码形式的二进制数，整体左移指定位数，左移后，左边溢出的位直接丢弃，右边空出来的位以 0 来填充
[root@kube count]# py demo1.py 
0
7
7
-3
64
[root@kube count]# 

 python  比较运算符

比较运算符，也成关系运算符，用于对常量、变量或表达式的结果进行大小、真假等比较，如果比较结果为真，则返回 True；反之，则返回 False。

表 1 Python 比较运算符

比较运算符	功能
>	大于，如果运算符前面的值大于后面的值，则返回 True；否则返回 False
>=	大于或等于，如果运算符前面的值大于或等于后面的值，则返回 True；否则返回 False
<	小于，如果运算符前面的值小于后面的值，则返回 True；否则返回 False
<=	小于或等于，如果运算符前面的值小于或等于后面的值，则返回 True；否则返回 False
==	等于，如果运算符前面的值等于后面的值，则返回 True；否则返回 False
!=	不等于，如果运算符前面的值不等于后面的值，则返回 True；否则返回 False
is	判断两个变量所引用的对象是否相同，如果相同则返回 True
is not	判断两个变量所引用的对象是否不相同，如果不相同则返回 True

 == 用来比较两个变量的值是否相等，而 is 则用来比对两个变量引用的是否是同一个对象

[root@kube count]# cat demo2.py 
import time
# 获取当前时间
a = time.gmtime()        # a、b 两个变量分别引用不同的对象（每次调用 gmtime() 函数都返回不同的对象）
b =  time.gmtime()
print(a == b) # a和b两个时间相等，输出True
print(a is b) # a和b不是同一个对象，输出False
[root@kube count]# py demo2.py 
True
False
[root@kube count]# 

 python 逻辑运算符

逻辑运算符是对真和假两种布尔值进行运算（操作 bool 类型的变量、常量或表达式），逻辑运算的返回值也是 bool 类型值。

Python 中的逻辑运算符主要包括 and（逻辑与）、or（逻辑或）以及 not（逻辑非）

表 1 Python 逻辑运算符及功能

逻辑运算符	含义	基本格式	功能
and	逻辑与（简称“与”）	a and b	有 2 个操作数 a 和 b，只有它们都是 True 时，才返回 True，否则返回 False。
or	逻辑或（简称“或”）	a or b	有 2 个操作数 a 和 b ，只有它们都是 False 时，才返回 False，否则返回 True。
not	逻辑非（简称“非”）	not a	只需要 1 个操作数 a，如果 a 的值为 True，则返回 False；反之，如果 a 的值为 False，则返回 True。

[root@kube count]# cat demo2.py
import time
# 获取当前时间
a = time.gmtime()
b =  time.gmtime()
print(a == b) # a和b两个时间相等，输出True
print(a is b) # a和b不是同一个对象，输出False
print( not (a is b))
print(2 > 1 and 2 > 3)
print(2 > 1 or 2 < 1)

[root@kube count]# py demo2.py 
True
False
True
False
True
[root@kube count]# 

python 三目运算符

Python 可通过 if 语句来实现三目运算符的功能，因此可以近似地把这种 if 语句当成三目运算符。作为三目运算符的 if 语句的语法格式如下：

三目运算符的规则是：先对逻辑表达式 expression 求值，如果逻辑表达式返回 True，则执行并返回 True_statements 的值；如果逻辑表达式返回 False，则执行并返回 False_statements 的值。

True_statements if expression else False_statements

[root@kube count]# cat demo3.py 
a = 5
b = 3
st = "a大于b" if a > b else  "a不大于b"
# 输出"a大于b"
print(st)
[root@kube count]# py demo3.py 
a大于b
[root@kube count]# 

python  运算符优先级

所谓运算符的优先级，指的是在含有多个逻辑运算符的式子中，到底应该先计算哪一个，后计算哪一个，这与数学中四则运算应遵循“先乘除后加减”是一个道理。

Python 中运算符的运算规则是，优先级高的运算符先执行，优先级低的运算符后执行，同一优先级的运算符按照从左到右的顺序进行。需要注意的是，Python 语言中大部分运算符都是从左向右执行的，只有单目运算符（例如 not 逻辑非运算符）、赋值运算符和三目运算符例外，它们是从右向左执行的。

表 1 按照优先级从高到底的顺序，罗列出了包括分隔符在内的所有运算符的优先级顺序。

表 1 运算符的优先级

运算符说明	Python运算符	优先级
索引运算符	x[index] 或 x[index:index2[:index3]]	18、19
属性访问	x.attrbute	17
乘方	**	16
按位取反	~	15
符号运算符	+（正号）或 -（负号）	14
乘、除	*、/、//、%	13
加、减	+、-	12
位移	>>、<<	11
按位与	&	10
按位异或	^	9
按位或	|	8
比较运算符	==、!=、>、>=、<、<=	7
is 运算符	is、is not	6
in 运算符	in、not in	5
逻辑非	not	4
逻辑与	and	3
逻辑或	or	2

 虽然 Python 运算符存在优先级的关系，但并不推荐过度依赖运算符的优先级，因为这会导致程序的可读性降低。因此，在这里要提醒读者：

• 不要把一个表达式写得过于复杂，如果一个表达式过于复杂，则把它分成几步来完成。
• 不要过多地依赖运算符的优先级来控制表达式的执行顺序，这样可读性太差，应尽量使用“()”来控制表达式的执行顺序。