写在前面
最近这段时间比较充裕,想要系统学习一下python,这个系列算是对自己学习的一个记录吧。同时也想提供一个比较完整详细的python教程供有需要的小伙伴进行学习,大家一起共同进步!!!努力冲冲冲!!!
虽然我也不知道自己能够坚持多久,但我尽量坚持不断更哈哈哈。如果这篇文章对你有帮助的话,请多多点赞支持呀。你们的鼓励和支持就是我坚持的最大动力【比心】。
如果需要查看往期文章的话,可以点击下面的文章链接,全部都已经汇总好了
目录
前言
本文为python学习笔记系列文章。
本文主要介绍了python中各种运算符(算术运算符,赋值运算符,位运算符,逻辑运算符,三目运算符)以及运算符的优先级和结合性。
注:本文主要参考了C语言中文网中的python教程。
算术运算符
算术运算符也即数学运算符,用来对数字进行数学运算,比如加减乘除。下表列出了python 支持的所有基本算术运算符。
运算符 | 说明 | 实例 | 结果 |
---|---|---|---|
+ | 加 | 12.45 + 15 | 27.45 |
- | 减 | 4.56 - 0.26 | 4.3 |
* | 乘 | 5 * 3.6 | 18.0 |
/ | 除法(和数学中的规则一样) | 7 / 2 | 3.5 |
// | 整除(只保留商的整数部分) | 7 // 2 | 3 |
% | 取余,即返回除法的余数 | 7 % 2 | 1 |
** | 幂运算/次方运算,即返回 x 的 y 次方 | 2 ** 4 | 16,即 24 |
接下来将对表中各个算术运算符的用法逐一讲解。
加法运算符
加法运算符跟数学里的规则相同。
主要作用有两个:
1 当两边均为数字时,表示两个数的和。
2 当有一边为字符时,表示字符串拼接。
求和
举例:
# 加法运算符举例--求和
m = 10
n = 97
sum1 = m + n
x = 7.2
y = 15.3
sum2 = x + y
print("sum1=%d, sum2=%.2f" % (sum1, sum2) )
运行结果:
拼接字符串
当
+
用于字符串时,有拼接字符串(将两个字符串连接为一个)的作用。
举例:
# 加法运算符举例--拼接字符串
name = "百度"
url = "http://www.baidu.com/"
user="小明"
age = 18
info = name + "的网址是" + url + ","+user+"已经" + str(age) + "岁了。"
print(info)
运行结果:
说明: str() 函数用来将整数类型的 age 转换成字符串。
减法运算符
减法运算符跟数学里的规则相同。
主要作用有两个:
1 求差;
2 求负。
求差
举例:
# 减法运算符举例--求差
m = 10
n = 97
res1 = m - n
x = 7.3
y = 15.3
res2 = x - y
print(res1, ",", res2)
运行结果:
求负
-
除了可以用作减法运算之外,还可以用作求负运算(正数变负数,负数变正数)。
举例:
# 减法运算符举例--求负
n = 45
n_neg = -n
f = -83.5
f_neg = -f
print(n_neg, ",", f_neg)
运行结果:
注意,单独使用
+
是无效的,不会改变数字的值。
举例:
# 单独使用+是没有效果的
n = 45
m = +n
x = -83.5
y = +x
print(m, ",", y)
运行结果:
乘法运算符
乘法运算也和数学中的规则相同
主要作用是
1 求两数之积
2 重复字符串
求积
举例:
# 乘法运算符举例--求积
n = 4 * 25
f = 34.5 * 2
print(n, ",", f)
运行结果:
重复字符串
*
除了可以用作乘法运算,还可以用来重复字符串,也即将 n 个同样的字符串连接起来。
举例:
# 乘法运算符举例--重复字符串
str1 = "hello "
print(str1 * 4)
运行结果:
除法运算符
Python 支持
/
和//
两个除法运算符,区别为:
/
表示普通除法,使用它计算出来的结果和数学中的计算结果相同。//
表示整除,只保留结果的整数部分,舍弃小数部分;注意是直接丢掉小数部分,而不是四舍五入。
/和//运算符的对比
举例:
# /和//运算符对比举例
# 整数不能除尽
print("23/5 =", 23/5)
print("23//5 =", 23//5)
print("23.0//5 =", 23.0//5)
print("-------------------")
# 整数能除尽
print("25/5 =", 25/5)
print("25//5 =", 25//5)
print("25.0//5 =", 25.0//5)
print("-------------------")
# 小数除法
print("12.4/3.5 =", 12.4/3.5)
print("12.4//3.5 =", 12.4//3.5)
运行结果:
从运行结果可以发现:
/
的计算结果总是小数,不管是否能除尽,也不管参与运算的是整数还是小数。- 当有小数参与运算时,
//
结果才是小数,否则就是整数。注意,除数始终不能为 0,除以 0 是没有意义的,这将导致 ZeroDivisionError 错误。
Python 2.x 中的除法
Python 2.x 只提供了
/
一种除法运算。
- 当
/
两边都是整数时,结果始终是整数;如果不能除尽,就直接舍弃小数部分。- 当
/
两边有一个是小数时,结果始终是小数;如果恰好除尽,小数部分就是 0。
举例:
# python2.x中的除法
#整数除法
print "18/6 =", 18/6
print "47/7 =", 47/7
print "----------------"
#小数除法
print "18.0/6 =", 18.0/6
print "47.0/7 =", 47.0/7
print "29.5/4.2 =", 29.5/4.2
运行结果:
18/6 = 3
47/7 = 6
----------------
18.0/6 = 3.0
47.0/7 = 6.71428571429
29.5/4.2 = 7.02380952381
求余运算符
Python % 运算符用来求得两个数相除的余数,包括整数和小数。Python 使用第一个数字除以第二个数字,得到一个整数的商,剩下的值就是余数。对于小数,求余的结果一般也是小数。
注意,求余运算的本质是除法运算,所以第二个数字也不能是 0,否则会导致 ZeroDivisionError 错误。
举例:
# 求余运算符
print("-----整数求余-----")
print("15%6 =", 15%6)
print("-15%6 =", -15%6)
print("15%-6 =", 15%-6)
print("-15%-6 =", -15%-6)
print("-----小数求余-----")
print("7.7%2.2 =", 7.7%2.2)
print("-7.7%2.2 =", -7.7%2.2)
print("7.7%-2.2 =", 7.7%-2.2)
print("-7.7%-2.2 =", -7.7%-2.2)
print("---整数和小数运算---")
print("23.5%6 =", 23.5%6)
print("23%6.5 =", 23%6.5)
print("23.5%-6 =", 23.5%-6)
print("-23%6.5 =", -23%6.5)
print("-23%-6.5 =", -23%-6.5)
运行结果:
从运行结果可以发现两点:
- 只有当第二个数字是负数时,求余的结果才是负数。换句话说,求余结果的正负和第一个数字没有关系,只由第二个数字决定。
%
两边的数字都是整数时,求余的结果也是整数;但是只要有一个数字是小数,求余的结果就是小数。
次方(乘方)运算符
Python ** 运算符用来求一个 x 的 y 次方,也即次方(乘方)运算符,也可以使用 ** 运算符间接地实现开方运算。
举例:
#乘方运算符
print('----次方运算----')
print('3**4 =', 3**4)
print('2**5 =', 2**5)
print('----开方运算----')
print('81**(1/4) =', 81**(1/4))
print('32**(1/5) =', 32**(1/5))
运行结果:
赋值运算符
赋值运算符用来把右侧的值传递给左侧的变量(或者常量);可以直接将右侧的值交给左侧的变量,也可以进行某些运算后再交给左侧的变量,比如加减乘除、函数调用、逻辑运算等。
python中最基本的赋值运算符是等号=
;结合其它运算符,=
还能扩展出更强大的赋值运算符。
基本赋值运算符
=
是 Python 中最常见、最基本的赋值运算符,用来将一个表达式的值赋给另一个变量。
举例:
# 基本赋值运算符举例
# 将字面量(直接量)赋值给变量
n1 = 100
f1 = 47.5
s1 = "http://c.biancheng.net/python/"
#将一个变量的值赋给另一个变量
n2 = n1
f2 = f1
#将某些运算的值赋给变量
sum1 = 25 + 46
sum2 = n1 % 6
s2 = str(1234) #将数字转换成字符串
s3 = str(100) + "abc"
连续赋值
Python 中的赋值表达式也是有值的,它的值就是被赋的那个值,或者说是左侧变量的值;如果将赋值表达式的值再赋值给另外一个变量,这就构成了连续赋值。
举例:
a = b = c = 100
=
具有右结合性,分析这个表达式:
- c = 100 表示将 100 赋值给 c,所以 c 的值是 100;同时,c = 100 这个子表达式的值也是 100。
- b = c = 100 表示将 c = 100 的值赋给 b,因此 b 的值也是 100。
- 以此类推,a 的值也是 100。
- 最终结果就是,a、b、c 三个变量的值都是 100。
= 和 ==
= 和 == 是两个不同的运算符,= 用来赋值,而 == 用来判断两边的值是否相等。
扩展后的赋值运算符
=
还可与其他运算符(包括算术运算符、位运算符和逻辑运算符)相结合,扩展成为功能更加强大的赋值运算符,如下表所示。
运算符 | 说 明 | 用法举例 | 等价形式 |
---|---|---|---|
= | 最基本的赋值运算 | 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 |
<<= | 左移赋值 | x <<= y | x = x << y,这里的 y 指的是左移的位数 |
>>= | 右移赋值 | x >>= y | x = x >> y,这里的 y 指的是右移的位数 |
举例:
# 扩展后的赋值运算符举例
n1 = 100
f1 = 25.5
n1 -= 80 #等价于 n1=n1-80
f1 *= n1 - 10 #等价于 f1=f1*( n1 - 10 )
print("n1=%d" % n1)
print("f1=%.2f" % f1)
运行结果为:
推荐使用这种赋值运算符。但是这种赋值运算符只能针对已经存在的变量赋值,因为赋值过程中需要变量本身参与运算,如果变量没有提前定义,它的值就是未知的,无法参与运算。例如,下面的写法就是错误的:
n += 10
该表达式等价于 n = n + 10,n 没有提前定义,所以它不能参与加法运算。
位运算符
python位运算按照数据在内存中的二进制位(Bit)进行操作。
Python 位运算符只能用来操作整数类型,它按照整数在内存中的二进制形式进行计算。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 位 |
& 按位与运算符
按位与运算符
&
的运算规则是:只有参与&
运算的两个位都为 1 时,结果才为 1,否则为 0。
第一个Bit位 | 第二个Bit位 | 结果 |
---|---|---|
0 | 0 | 0 |
0 | 1 | 0 |
1 | 0 | 0 |
1 | 1 | 1 |
例如,9&5
可以转换成如下的运算:
0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1001 (9 在内存中的存储) & 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0101 (5 在内存中的存储) ----------------------------------------------------------------------------------- 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0001 (1 在内存中的存储)
&
运算符会对参与运算的两个整数的所有二进制位进行&
运算,9&5
的结果为 1。
又如,-9&5
可以转换成如下的运算:
1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111 (-9 在内存中的存储) & 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0101 (5 在内存中的存储) ----------------------------------------------------------------------------------- 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0101 (5 在内存中的存储)
-9&5
的结果是 5。
注意:&
运算符操作的是数据在内存中存储的原始二进制位,而不是数据本身的二进制形式;其他位运算符也一样。以-9&5
为例,-9 的在内存中的存储和 -9 的二进制形式截然不同:
1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111 (-9 在内存中的存储) -0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1001 (-9 的二进制形式,前面多余的0可以抹掉)
按位与运算通常用来对某些位清 0,或者保留某些位。
举例:
# &与运算符举例
n = 0X8FA6002D
print("%X" % (9&5) )
print("%X" % (-9&5) )
print("%X" % (n&0XFFFF) )
运行结果:
| 按位或运算符
按位或运算符
|
的运算规则是:两个二进制位有一个为 1 时,结果就为 1,两个都为 0 时结果才为 0。
第一个Bit位 | 第二个Bit位 | 结果 |
---|---|---|
0 | 0 | 0 |
0 | 1 | 1 |
1 | 0 | 1 |
1 | 1 | 1 |
例如,9 | 5
可以转换成如下的运算:
0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1001 (9 在内存中的存储) | 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0101 (5 在内存中的存储) ----------------------------------------------------------------------------------- 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1101 (13 在内存中的存储)
9 | 5
的结果为 13。
又如,-9 | 5
可以转换成如下的运算:
1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111 (-9 在内存中的存储) | 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0101 (5 在内存中的存储) ----------------------------------------------------------------------------------- 1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111 (-9 在内存中的存储)
-9 | 5
的结果是 -9。
按位或运算可以用来将某些位置 1,或者保留某些位。
举例:
# |或运算符举例
n = 0X2D
print("%X" % (9|5) )
print("%X" % (-9|5) )
print("%X" % (n|0XFFFF0000) )
运行结果:
^按位异或运算符
按位异或运算
^
的运算规则是:参与运算的两个二进制位不同时,结果为 1,相同时结果为 0。
第一个Bit位 | 第二个Bit位 | 结果 |
---|---|---|
0 | 0 | 0 |
0 | 1 | 1 |
1 | 0 | 1 |
1 | 1 | 0 |
例如,9 ^ 5
可以转换成如下的运算:
0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1001 (9 在内存中的存储) ^ 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0101 (5 在内存中的存储) ----------------------------------------------------------------------------------- 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1100 (12 在内存中的存储)
9 ^ 5
的结果为 12。
又如,-9 ^ 5
可以转换成如下的运算:
1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111 (-9 在内存中的存储) ^ 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0101 (5 在内存中的存储) ----------------------------------------------------------------------------------- 1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0010 (-14 在内存中的存储)
-9 ^ 5
的结果是 -14。
按位异或运算可以用来将某些二进制位反转。
举例:
# ^按位异或运算符举例
n = 0X0A07002D
print("%X" % (9^5) )
print("%X" % (-9^5) )
print("%X" % (n^0XFFFF0000) )
运行结果:
~按位取反运算符
按位取反运算符
~
为单目运算符(只有一个操作数),右结合性,作用是对参与运算的二进制位取反。
例如,~9
可以转换为如下的运算:
~ 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1001 (9 在内存中的存储) ----------------------------------------------------------------------------------- 1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0110 (-10 在内存中的存储)
所以
~9
的结果为 -10。
例如,~-9
可以转换为如下的运算:
~ 1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111 (-9 在内存中的存储) ----------------------------------------------------------------------------------- 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1000 (8 在内存中的存储)
所以
~-9
的结果为 8。
举例:
# ~取反运算符举例
print("%X" % (~9) )
print("%X" % (~-9) )
运行结果:
<<左移运算符
Python 左移运算符
<<
用来把操作数的各个二进制位全部左移若干位,高位丢弃,低位补 0。
例如,9<<3
可以转换为如下的运算:
<< 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1001 (9 在内存中的存储) ----------------------------------------------------------------------------------- 0000 0000 -- 0000 0000 -- 0000 0000 -- 0100 1000 (72 在内存中的存储)
所以
9<<3
的结果为 72。
又如,(-9)<<3
可以转换为如下的运算:
<< 1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111 (-9 在内存中的存储) ----------------------------------------------------------------------------------- 1111 1111 -- 1111 1111 -- 1111 1111 -- 1011 1000 (-72 在内存中的存储)
所以
(-9)<<3
的结果为 -72
如果数据较小,被丢弃的高位不包含 1,那么左移 n 位相当于乘以 2 的 n 次方。
举例:
# <<左移运算符举例
print("%X" % (9<<3) )
print("%X" % ((-9)<<3) )
运行结果:
>>右移运算符
Python 右移运算符
>>
用来把操作数的各个二进制位全部右移若干位,低位丢弃,高位补 0 或 1。如果数据的最高位是 0,那么就补 0;如果最高位是 1,那么就补 1。
例如,9>>3
可以转换为如下的运算:
>> 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1001 (9 在内存中的存储) ----------------------------------------------------------------------------------- 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0001 (1 在内存中的存储)
所以
9>>3
的结果为 1。
又如,(-9)>>3
可以转换为如下的运算:
>> 1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111 (-9 在内存中的存储) ----------------------------------------------------------------------------------- 1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 1110 (-2 在内存中的存储)
所以
(-9)>>3
的结果为 -2
如果被丢弃的低位不包含 1,那么右移 n 位相当于除以 2 的 n 次方(但被移除的位中经常会包含 1)。
举例:
# >>右移运算符举例
print("%X" % (9>>3) )
print("%X" % ((-9)>>3) )
运行结果:
比较运算符(关系运算符)
比较运算符,也称关系运算符,用于对常量、变量或表达式的结果进行大小比较。如果这种比较是成立的,则返回 True(真),反之则返回 False(假)。
python支持的比较运算符如下表所示。
比较运算符 | 说明 |
---|---|
> | 大于,如果> 前面的值大于后面的值,则返回 True,否则返回 False。 |
< | 小于,如果< 前面的值小于后面的值,则返回 True,否则返回 False。 |
== | 等于,如果== 两边的值相等,则返回 True,否则返回 False。 |
>= | 大于等于(等价于数学中的 ≥),如果>= 前面的值大于或者等于后面的值,则返回 True,否则返回 False。 |
<= | 小于等于(等价于数学中的 ≤),如果<= 前面的值小于或者等于后面的值,则返回 True,否则返回 False。 |
!= | 不等于(等价于数学中的 ≠),如果!= 两边的值不相等,则返回 True,否则返回 False。 |
is | 判断两个变量所引用的对象是否相同,如果相同则返回 True,否则返回 False。 |
is not | 判断两个变量所引用的对象是否不相同,如果不相同则返回 True,否则返回 False。 |
举例:
# 比较运算符(关系运算符)举例
print("89是否大于100:", 89 > 100)
print("24*5是否大于等于76:", 24*5 >= 76)
print("86.5是否等于86.5:", 86.5 == 86.5)
print("34是否等于34.0:", 34 == 34.0)
print("False是否小于True:", False < True)
print("True是否等于True:", True < True)
运行结果:
== 和 is 的区别
== 用来比较两个变量的值是否相等,而 is 则用来比对两个变量引用的是否是同一个对象。
举例:
# ==和is的区别
import time #引入time模块
t1 = time.gmtime() # gmtime()用来获取当前时间
t2 = time.gmtime()
print(t1 == t2) #输出True
print(t1 is t2) #输出False
运行结果:
说明:time 模块的 gmtime() 方法用来获取当前的系统时间,精确到秒级,因为程序运行非常快,所以 t1 和 t1 得到的时间是一样的。== 用来判断 t1 和 t2 的值是否相等,所以返回 True。
虽然 t1 和 t2 的值相等,但它们是两个不同的对象(每次调用 gmtime() 都返回不同的对象),所以t1 is t2
返回 False。这就好像两个双胞胎姐妹,虽然她们的外貌是一样的,但它们是两个人。
那么,如何判断两个对象是否相同呢?答案是判断两个对象的内存地址。如果内存地址相同,说明两个对象使用的是同一块内存,当然就是同一个对象了。
逻辑运算符
Python中的逻辑运算符类似数学中的逻辑运算符,如下表所示
逻辑运算符 | 含义 | 基本格式 | 说明 |
---|---|---|---|
and | 逻辑与运算,等价于数学中的“且” | a and b | 当 a 和 b 两个表达式都为真时,a and b 的结果才为真,否则为假。 |
or | 逻辑或运算,等价于数学中的“或” | a or b | 当 a 和 b 两个表达式都为假时,a or b 的结果才是假,否则为真。 |
not | 逻辑非运算,等价于数学中的“非” | not a | 如果 a 为真,那么 not a 的结果为假;如果 a 为假,那么 not a 的结果为真。相当于对 a 取反。 |
逻辑运算符一般和关系运算符结合使用,例如:
14>6 and 45.6 > 90
14>6 结果为 True,成立,45.6>90 结果为 False,不成立,所以整个表达式的结果为 False,也即不成立。
举例:
# 逻辑运算符举例
age = int(input("请输入年龄:"))
height = int(input("请输入身高:"))
if age>=18 and age<=30 and height >=170 and height <= 185 :
print("恭喜,你符合报考飞行员的条件")
else:
print("抱歉,你不符合报考飞行员的条件")
运行结果:
注意:Python 逻辑运算符可以用来操作任何类型的表达式,不管表达式是不是 bool 类型;同时,逻辑运算的结果也不一定是 bool 类型,它也可以是任意类型。
逻辑运算符的本质
在 Python 中,and 和 or 不一定会计算右边表达式的值,有时候只计算左边表达式的值就能得到最终结果。
另外,and 和 or 运算符会将其中一个表达式的值作为最终结果,而不是将 True 或者 False 作为最终结果。
对于 and 运算符,两边的值都为真时最终结果才为真,但是只要其中有一个值为假,那么最终结果就是假,所以 Python 按照下面的规则执行 and 运算:
- 如果左边表达式的值为假,那么就不用计算右边表达式的值了,因为不管右边表达式的值是什么,都不会影响最终结果,最终结果都是假,此时 and 会把左边表达式的值作为最终结果。
- 如果左边表达式的值为真,那么最终值是不能确定的,and 会继续计算右边表达式的值,并将右边表达式的值作为最终结果。
对于 or 运算符,情况是类似的,两边的值都为假时最终结果才为假,只要其中有一个值为真,那么最终结果就是真,所以 Python 按照下面的规则执行 or 运算:
- 如果左边表达式的值为真,那么就不用计算右边表达式的值了,因为不管右边表达式的值是什么,都不会影响最终结果,最终结果都是真,此时 or 会把左边表达式的值作为最终结果。
- 如果左边表达式的值为假,那么最终值是不能确定的,or 会继续计算右边表达式的值,并将右边表达式的值作为最终结果。
举例
# 逻辑运算符的本质
url = "http://c.biancheng.net/cplus/"
print("----False and xxx-----")
print( False and print(url) )
print("----True and xxx-----")
print( True and print(url) )
print("----False or xxx-----")
print( False or print(url) )
print("----True or xxx-----")
print( True or print(url) )
运行结果:
三目运算符(三元运算符)
设现在有两个数字,希望获得其中较大的一个,那么可以使用 if else 语句,例如:
- if a>b:
- max = a;
- else:
- max = b;
但是 Python 提供了一种更加简洁的写法,如下所示:
max = a if a>b else b
这是一种类似于其它编程语言中三目运算符
? :
的写法。
使用 if else 实现三目运算符(条件运算符)的格式如下:exp1 if contion else exp2
condition 是判断条件,exp1 和 exp2 是两个表达式。如果 condition 成立(结果为真),就执行 exp1,并把 exp1 的结果作为整个表达式的结果;如果 condition 不成立(结果为假),就执行 exp2,并把 exp2 的结果作为整个表达式的结果。
前面的语句
max = a if a>b else b
的含义是:
- 如果 a>b 成立,就把 a 作为整个表达式的值,并赋给变量 max;
- 如果 a> b 不成立,就把 b 作为整个表达式的值,并赋给变量 max。
三目运算符的嵌套
Python 三目运算符支持嵌套,如此可以构成更加复杂的表达式。在嵌套时需要注意 if 和 else 的配对,例如:
a if a>b else c if c>d else d
应该理解为:
a if a>b else ( c if c>d else d )
举例:
# 三目运算符的嵌套
a = int( input("Input a: ") )
b = int( input("Input b: ") )
print("a大于b") if a>b else ( print("a小于b") if a<b else print("a等于b") )
可能的运行结果:
该程序是一个嵌套的三目运算符。程序先对 a>b 求值,如果该表达式为 True,程序就返回执行第一个表达式 print("a大于b"),否则将继续执行 else 后面的内容,也就是:
( print("a小于b") if a<b else print("a等于b") ),进入该表达式后,先判断 a<b 是否成立,如果 a<b 的结果为 True,将执行 print("a小于b"),否则执行 print("a等于b")。
运算符优先级和结合性
运算符优先级
所谓优先级,就是当多个运算符同时出现在一个表达式中时,先执行哪个运算符。
例如对于表达式a + b * c
,Python 会先计算乘法再计算加法;b * c
的结果为 8,a + 8
的结果为 24,所以 d 最终的值也是 24。先计算*
再计算+
,说明*
的优先级高于+
。
Python 支持几十种运算符,被划分成将近二十个优先级,有的运算符优先级不同,有的运算符优先级相同,请看下表。
运算符说明 | Python运算符 | 优先级 | 结合性 | 优先级顺序 |
---|---|---|---|---|
小括号 | ( ) | 19 | 无 | 高 ︿ | | | | | | | | | | | | | | | | | | | | | | 低 |
索引运算符 | x[i] 或 x[i1: i2 [:i3]] | 18 | 左 | |
属性访问 | x.attribute | 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 | 左 | |
逗号运算符 | exp1, exp2 | 1 | 左 |
分析下面的例子
4+4<<2
+
的优先级是 12,<<
的优先级是 11,+
的优先级高于<<
,所以先执行 4+4,得到结果 8,再执行 8<<2,得到结果 32,这也是整个表达式的最终结果。
像这种不好确定优先级的表达式,我们可以给子表达式加上( )
,也就是写成下面的样子:
(4+4) << 2
当然,我们也可以使用( )
改变程序的执行顺序,比如:
4+(4<<2)
则先执行 4<<2,得到结果 16,再执行 4+16,得到结果20。
建议:
- 不要把一个表达式写得过于复杂,如果一个表达式过于复杂,可以尝试把它拆分来书写。
- 不要过多地依赖运算符的优先级来控制表达式的执行顺序,这样可读性太差,应尽量使用
( )
来控制表达式的执行顺序。
运算符结合性
所谓结合性,就是当一个表达式中出现多个优先级相同的运算符时,先执行哪个运算符:先执行左边的叫左结合性,先执行右边的叫右结合性。
例如对于表达式对于
100 / 25 * 16
,/
和*
的优先级相同,应该先执行哪一个呢?这个时候就不能只依赖运算符优先级决定了,还要参考运算符的结合性。/
和*
都具有左结合性,因此先执行左边的除法,再执行右边的乘法,最终结果是 64。Python 中大部分运算符都具有左结合性,也就是从左到右执行;只有 ** 乘方运算符、单目运算符(例如 not 逻辑非运算符)、赋值运算符和三目运算符例外,它们具有右结合性,也就是从右向左执行。
当一个表达式中出现多个运算符时,Python 会先比较各个运算符的优先级,按照优先级从高到低的顺序依次执行;当遇到优先级相同的运算符时,再根据结合性决定先执行哪个运算符:如果是左结合性就先执行左边的运算符,如果是右结合性就先执行右边的运算符。
总结
本文主要介绍了python中各种运算符(算术运算符,赋值运算符,位运算符,逻辑运算符,三目运算符)以及运算符的优先级和结合性。算术运算符包括加减乘除,求余和乘方,赋值运算符包括基本赋值运算符合扩展后的赋值运算符如+=,*=。位运算符包括与运算符,或运算符,异或运算符,按位取反运算符以及移位运算符。常见比较运算符,逻辑运算符和三目运算符并讨论了运算符的优先级和结合性。