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 运算符存在优先级的关系,但并不推荐过度依赖运算符的优先级,因为这会导致程序的可读性降低。因此,在这里要提醒读者:

  • 不要把一个表达式写得过于复杂,如果一个表达式过于复杂,则把它分成几步来完成。
  • 不要过多地依赖运算符的优先级来控制表达式的执行顺序,这样可读性太差,应尽量使用“()”来控制表达式的执行顺序。
原文地址:https://www.cnblogs.com/zy09/p/11576713.html