Python运算结果再运算 python如何进行运算

Python语法-基础运算符

• 1.算术运算符
• 2.比较运算符
• 3.赋值运算符

• 1.增量赋值
• 2.交叉赋值
• 3.解压赋值

• 4.逻辑运算符
• 5.成员运算符
• 6.身份运算符

1.算术运算符

运算符种类	符号	代码示例	运算结果	备注说明
加	+	print(1+2)	3	两数相加
减	-	print(1-2)	-1	两数相减
乘	*	print(1*2)	2	两数相乘
除	/	print(1/2)	0.5	两数相除
取整除	//	print(3//2)	1	只保留整数部分,不四舍五入
取余(取模)	%	print(3%2)	1	3除以2 商为1余数为1
次方	**	print(3**2)	9	3的2次方得9

2.比较运算符

运算符种类	符号	代码示例	运算结果	备注说明
大于	>	print(1>2)	False	1是否大于2
小于	<	print(1<2)	True	1是否小于2
等于	==	print(1==2)	False	1是否等于2
不等	!=	print(1!=2)	True	1是否不等于2
大等	>=	print(3>=2)	True	3是否大于等于2
小等	<=	print(3<=2)	False	3是否小于等于2

PS：

• a = b : 将变量b的值赋值到变量a（赋值）；
• a == b :比较变量a与变量b的值是否相等（比较）；

3.赋值运算符

eg.a = 3

1.增量赋值

将算数运算后的值再赋值给参与算数运算的变量

运算符种类	符号	代码示例	运算结果	备注说明
加等	+=	a=1;a += 2	3	等同于a = a + 2
减等	-=	a=1;a -= 2	-1	等同于a = a - 2
乘等	*=	a=2;a *= 2	4	等同于a = a * 2
除等	/=	a=2;a /= 2	1	等同于a = a / 2
整除等	//=	a=3;a //= 2	1	等同于a = a // 2
取余等	%=	a=3;a %= 2	1	等同于a = a % 2
次方等	**=	a=3;a **= 2	9	等同于a = a ** 2

2.交叉赋值

交换两个变量的值

a = 1
b = 2
#想将变量a、b的值互换

#可以这样做,利用一个中间变量
num = a
a = b
b = num

#或者使用交叉赋值
b,a = a,b
print(a) # 2
print(b) # 1

3.解压赋值

1. 将列表中的多个值全部取出来依次赋值给多个变量名

#将列表中的多个值取出来依次赋值给多个变量名，可以这么做
myList = [1,2,3]
a = myList[0]
b = myList[1]
c = myList[2]

#利用解压赋值
a,b,c = myList #包含多个值，就好比一个压缩包，解压赋值因此得名
print(a,b,c) #1 2 3

#上述解压赋值，等号左边的变量名个数必须与右面包含值的个数相同,否则会报错
a,b = myList
# ValueError: too many values to unpack (expected 2)

a,b,c,d = myList
# ValueError: not enough values to unpack (expected 4, got 3)

2. 将列表中的多个值部分取出来依次赋值给多个变量名
   可以将不取的多个部分用*_代替，单个值用_代替。(有点类似sql语法中like中的% 和 _的不同)

# 将列表中的前两个值取出赋值给变量a,b
myList1 = [1,2,3,4,5]
a,b,*_ = myList1
print(a,b) # 1 2
print(*_) # 3 4 5
print(_) # [3,4,5]

#将列表中前一个值和最后两个值取出赋给变量a,b,c
a,*_,b,c = myList1
print(a,b,c) # 1 4 5
print(*_) # 2 3
print(_) # [2,3]

#将列表中的前一个值赋值给a,最后一个值赋值给b,第二个给_，第3,4个为列表
a,_,*_,b = myList1
print(a,b) # 1 5
print(*_) # 3 4
print(_) # [3,4]
# 列表中值2"消失"了。单个 _ 表示该变量被废弃

• 多个指定的数据类型都可以解压
• 可用于字符串, 列表,元组,字典,集合,多用于列表,元组
• 如果用于字典,则解压的结果是 key
• 使用 *_ 来将剩余的值存成一个列表(单个 _ 表示该变量被废弃)
• _ 可以赋值给其他变量，或再使用解压赋值赋值给多个变量

4.逻辑运算符

1. 与或非

运算符种类	符号	代码示例	运算结果	备注说明
与	and	1 and 0	False	条件都为真是结果为真
或	or	1 or 0	True	条件都为假是结果为假
非	not	not 0	True	取反

2. 短路原则

• 短路与：只要and左边的值为Flase，and右边的值将不会执行，返回结果就是False(偷懒原则),如果左边为True则继续判断后面的条件
• 短路或：只要or左边的值为True，or右边的值将不会执行，返回结果就是True(偷懒原则)，如果左边为Flase则继续判断后面的条件

3. 优先级
   not > and > or

#1、三者的优先级关系：not>and>or，同一优先级默认从左往右计算。
>>> 3>4 and 4>3 or 1==3 and 'x' == 'x' or 3 >3
False

#2、最好使用括号来区别优先级，其实意义与上面的一样
'''
原理为：
(1) not的优先级最高,就是把紧跟其后的那个条件结果取反,所以not与紧跟其后的条件不可分割
(2) 如果语句中全部是用and连接，或者全部用or连接，那么按照从左到右的顺序依次计算即可
(3) 如果语句中既有and也有or，那么先用括号把and的左右两个条件给括起来，然后再进行运算
'''
>>> (3>4 and 4>3) or (1==3 and 'x' == 'x') or 3 >3
False 

#3、短路运算：逻辑运算的结果一旦可以确定，那么就以当前处计算到的值作为最终结果返回
>>> 10 and 0 or '' and 0 or 'abc' or 'egon' == 'dsb' and 333 or 10 > 4
我们用括号来明确一下优先级
>>> (10 and 0) or ('' and 0) or 'abc' or ('egon' == 'dsb' and 333) or 10 > 4
短路：       0      ''           'abc'                    
            假     假             真

返回：'abc'

#4、短路运算面试题：
>>> 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

5.成员运算符

用于字符串时，判断子字符串是否在大字符串中（PS：字符串、列表、元组、集合都支持成员运算）

1. in: 某一个对象包含于另外一个对象则返回True

# 判断子字符串是否在大字符串中
print("csdn" in "hello csdn") # True
print("csd" in "hello csdn") # True
print("he dn" in "hello csdn") # False

# 判断key是否存在于字典中（注意：in判断的条件是字典的key）
print(111 in {"k1": 111, 'k2': 222})    # False
print("k1" in {"k1": 111, 'k2': 222})   # True

2. not in: 某一个对象没包含于另外一个对象则返回True

#1. 条件1 not in 条件2（推荐使用,因为not in语义更加明确）
print("csdn" not in "hello csdn")  # False

#2. not 条件1 in 条件2（先运算条件1 in 条件2再取反）
print(not "csdn" in "hello csdn")  # False
# 加上括号很好理解
print(not ("csdn" in "hello csdn")) # False

6.身份运算符

1. is:判断左右两边的 id 是否相等，两个对象的ID相同则返回True

#1.两个不同的内存地址关联不同的变量名,只是存的值一样
a = [1,2]
b = [1,2]
print(a is b) # False

#2.两个变量名关联同一个内存地址
a = [1,2]
b = a
print(a is b) # True

2. **is not**:两个对象的ID不同时is not会返回Ture

a="xxx"
b="yyy"
print(a is not b) #True

3. 值比较 和 址比较

• 值比较：比较变量值是否相等，用 == 来比较

a = [1,2]
b = [1,2]
print(a == b) # True

• 址比较：比较变量所指向的地址是否是同一个，用 is 来比较

a = [1,2]
b = [1,2]
print(a is b) #False

此处涉及到一个缓冲池的问题，可见例如下：

a = "123"
b = "123"
print(a is b) #True

具体缓冲池知识不在此文详解，可见文章：Python缓冲池初探。