Python-五类基本运算符

1、算数运算符

假定一下变量：a = 10, b = 20

运算符	描述	实例
+	加，两个对象相加	a + b 输出结果 30
-	减，得到负数或是一个数减去另一个数	a - b 输出结果 -10
*	乘，两个数相乘或是返回一个被重复若干次的字符串	a * b 输出结果 200
**	幂，返回x的y次幂	a ** b 为10的20次方
/	除，x除以y	b / a 输出结果 2
//	取整除，返回商的整数部分	9 // 2输出结果 4，9.0 // 2.0 输出结果4.0
%	取模，返回除法的余数	b % a 输出结果 0

+	-	*	**	/	//	%
print(10 + 3)  # 加，13
print(10 - 3)  # 减，7
print(10 * 3)  # 乘，30
print(10 ** 3)  # 次方，1000
print(10 / 3)  # 除，3.3333333333333335
print(10 // 3)  # 取商，3
print(10 % 3)  # 取余，1

print(10 * 3.333)  # int类型与float类型统称为数字类型，他们两者是可以混着玩的
其他类型的数据也可以使用 + * 运算，但是效率很低基本不用
print([1,2,3]+[3,4,5])  # [1, 2, 3, 3, 4, 5]
print([1,2,3]*3)  # [1, 2, 3, 1, 2, 3, 1, 2, 3]

2、比较运算符

假定一下变量：a = 10, b = 20

运算符	描述	实例
==	等于，比较对象是否相等	(a == b) 返回 False
!=	不等于，比较两个对象是否不想等	(a != b) 返回 True
>	大于，比较 > 左边的值是否大于右边的值	(a > b) 返回 False
>=	大于等于，比较 >= 左边的值是否大于或等于右边的值	(a >= b) 返回 False
<	小于，比较 < 左边的值是否小于右边的值	(a < b) 返回 True
<=	小于等于，比较 <= 左边的值是否小于或等于右边的值	(a <= b) 返回 True

==	!=	>	<	>=	<=
print(10 == 10)
print(10 > 10)
print(10 >= 10)
print("abc" != "ddd")

print(10 > 3.1)
print(10 > "12")  # 不能比大小，不同类型数据之间不能进行比较

print("a12" == "a12")
print([1,2,3] == [1,2,3])

字符串通常用 len() 计算长度去比较
# 了解，字符串进行比较是按照ASCII表的顺序，对应位置进行比较
"abc"
"az"
print("abc" > "az")

l1=[111,222,333]
# l2=[111,999]
l2=[111,"aaa"]  # 列表进行比较也是对应位置比较，且对应位置的数据类型要一致
print(l1 > l2)  # 报错

print({"k1":111,"k2":222} == {"k2":222,"k1":111})   # 字典不需要顺序一样，但是key和value要一致，返回值为 True 
print({"k1":111,"k2":222} == {"k2":111,"k1":222})   # 返回值为 False

3、赋值运算符

运算符	描述	实例
=	简单的赋值运算符	c = a + b 将 a + b 的运算结果赋值为 c
+=	加法赋值运算符	c += a 等效于 c = c + a
-=	减法赋值运算符	c -= a 等效于 c = c - a
*=	乘法赋值运算符	c *= a 等效于 c = c * a
/=	除法赋值运算符	c /= a 等效于 c = c / a
%=	取模赋值运算符	c %= a 等效于 c = c % a
**=	幂赋值运算符	c **= a 等效于 c = c * * a
//=	取整除赋值运算符	c //= a 等效于 c = c // a

3.1、增量赋值

age += 2  # age = age + 2
age -= 2
age **= 2  # age = age ** 2
print(age)

3.2、链式赋值

x = 10
y = x
z = y
print(id(x))
print(id(y))
print(id(z))
# 链式赋值
x = y = z = 10 

3.3、交叉赋值

x = 10
y = 20
# 思路原理
temp = x
x = y
y = temp
# 交叉赋值
x, y = y, x
print(x)
print(y)

3.4、解压赋值

salary = [1.1, 2.2, 3.3, 4.4, 5.5]
# 思路原理
mon1 = salary[0]
mon2 = salary[1]
mon3 = salary[2]
mon4 = salary[3]
mon5 = salary[4]
mon1, mon2, mon3, mon4, mon5 = salary  # 按照这个格式，用和值数量相同的变量名来保存解压后的值
print(mon1, mon2, mon3, mon4, mon5)
# 有弊端（需要改进）
变量名多一个不行少一个不行，必须与值一一对应
mon1, mon2, mon3, mon4 = salary  # 报错，值太多，没有足够的变量名来赋值保存
mon1, mon2, mon3, mon4, mon5, mon6 = salary  # 报错，值太少，多余的变量名没有值

# 改进后（用 *_ 来替换不需要的值所对应的变量名）
mon1, mon2, mon3, *_ = salary
print(mon1, mon2, mon3)
print(_)

mon1, mon2, *_, mon5 = salary
print(mon1)
print(mon2)
print(mon5)
# 对于字典类型来说，解压赋值拿到的是相对应的 key 值
dic={"k1":111, "k2":222, 'K3':333}
x, y, z = dic
print(x, y, z)

x, *_ = dic
print(x)
print(_)

4、逻辑运算符

4.1、not

not：代表把紧跟其后的条件结果取反
print(not 10 > 3)  # 输出结果 False

4.2、and

and：连接左右两个条件，左右两个条件必须同时成立，最终结果才为True
print(True and 1 > 0 and "aaa" == "aaa")  # 输出结果 True
print(True and 1 < 0 and "aaa" == "aaa")  # 输出结果 False

4.3、or

or：连接左右两个条件，左右两个条件但凡是有一个成立，最终结果就为True
print(True or 1 > 0 or "aaa" == "aaa")  # 输出结果 True
print(False or 1 < 0 or "aaa" != "aaa")  # 输出结果 True

4.4、短路运算

又称偷懒原则，即
and 连接多个条件时，只要第一个条件遇到结果为False，则最终结果为False
or 连接多个条件时，只要第一个条件遇到结果为True，则最终结果为True
# 示例
print(1 and 3 or 4)  # 输出结果 3
# 短路运算面试题：
>>> 1 or 3
1
>>> 1 and 3
3
>>> 0 and 2 and 1
0
>>> 0 and 2 or 1
1
>>> 0 and 2 or 1 or 4
1
>>> 0 or False and 1
False 

4.5、优先级

优先级： not > and > or，也可以自己用()来规定优先级
# 示例
3>4 and 4>3 or not 1==3 and 'x' == 'x' or 3 >3
# 思路，用()按照默认优先级划分清楚
res = (3>4 and 4>3) or (not 1==3 and 'x' == 'x') or 3 >3

print(res)  # 输出结果 True

5、成员运算符

in / not in
判断子字符串是否在一个大字符串里面