python常用运算符【建议收藏】

太阳当空赵_

已于 2023-10-08 20:03:11 修改

阅读量120

点赞数

文章标签： python 开发语言

于 2023-10-08 20:00:02 首次发布

本文链接：https://blog.csdn.net/qq_42849529/article/details/133688211

版权

python常用运算符

一、常用运算符

一、常用运算符

1. 算术运算符

运算符	说明
+	加
-	减
*	乘
/	除
//	取整
%	求余（取模）
**	求幂（求次方）

"""
注意：
 a. 如果整数和浮点数进行运算，结果都是浮点数，换句话说，但凡表达式中出现浮点数进行数学运算，结果都是浮点数
 b. 只要是/运算，结果都是浮点数
 c. //的结果为/的结果的整数部分，不涉及四舍五入
 d. 算术运算符的优先级问题:**  》  *  / //  %  》 + -
"""

# 1.+ -
print(2 + 6)    # 8
print(10 - 4)   # 6
print(2.0 + 6)  # 8.0
print(2 + 6.0)  # 8.0
print(2.0 + 6.0)  # 8.0

# 2.*  /
print(2 * 6)     # 12
print(10 / 4)    # 2.5
print(2.0 * 6)   # 12.0
print(2 * 6.0)   # 12.0
print(2.0 * 6.0) # 12.0
print(10 / 5)    # 2.0

# 3.//:整除
print(5 / 3)   # 1.6666666667
print(5 // 3)  # 1
print(5.0 // 3)  # 1.0

# 4.%:求余/取模
print(5 % 3)    # 2
print(5.0 % 3)  # 2.0
print(10 % 5)   # 0
print(5.00 % 3)  # 2.0

# 5.**:求幂/求次方
print(5 ** 3)
print(2 ** 10)
print(2.0 ** 10)

# 6.优先级问题
print(2 * 10 ** 3)   # 2000
# 如果要提高某些运算符的优先级，则使用()实现
print((2 * 10) ** 3)  # 8000

2. 赋值运算符

运算符	说明
=	简单赋值运算符
+=、-=、=、/=、%=、//=、*=等	复合赋值运算符

"""
注意：
 a. =用于定义变量或给变量重新赋值
 b. =的右边只要是一个数据或可以计算结果的表达式，都可以给=左边的变量赋值
 c. 无论=右边的表达式多么复杂，永远都是先计算=右边表达式的结果，然后给=左边的变量赋值，换句话，=的优先级最低
 d. += -= *= /=  //=  %=  **=的工作原理：必须先定义变量，然后给该变量进行相应的运算，最后给该变量进行重新赋值
"""

# 1.=
# a
num = 10   # 定义变量
print(num)
num = 88  # 重新赋值
print(88)

# b.
a = 4 + 2 * 3 -10
print(a)

# 2.+=、-=。。。。。
# 工作原理：相当于既进行数学运算，又给变量赋值
# 原因：b += 1等价于b = b + 1
# 错误写法：
# b += 1    # NameError: name 'b' is not defined

# 正确写法：
b = 73   # 定义
b += 5   # 给变量进行了运算，然后重新赋值
print(b)

c = 60
c /= 10
print(c)  # 6.0

d = 10
d **= 2  # d = d ** 2
print(d)  # 100

# 注意：在Python，没有n++或n--运算符

3. 关系运算符

运算符	说明
==	相等
!=	不相等
>	大于
<	小于
>=	大于等于
<=	小于等于

"""
注意：
 a. 关系运算符，也被称为条件运算符或比较运算符
 b. =表示赋值，==表示比较
 c. 关系运算符运算的结果肯定是一个布尔值，表达式成立则结果为True，表达式不成立则结果为False
 d. 关系运算符一般结合if语句或while循环使用
"""

# 1.基本使用
a = 3
b = 5
print(a == b)  # False
print(a != b)  # True
print(a > b)   # False
print(a >= b)  # False
print(a < b)   # True
print(a <= b)  # True

# 2.常用于比较大小的数据类型除了数字之外，还可以是字符串
# 扩展：如果字符串中包含数字，字母或者符号，则可以比较大小，底层的工作原理是ASCII码表
"""
常见ASCII码的大小规则：数字< 大写字母 < 小写字母。
1. 数字比字母要小。如 “7”<“F”；
2. 数字0比数字9要小，并按0到9顺序递增。如 “3”<“8” ；
3. 字母A比字母Z要小，并按A到Z顺序递增。如“A”<“Z” ；
4. 同个字母的大写字母比小写字母要小32。如“A”<“a” 。
5. 几个常见字母的ASCII码大小： “A”为65；“a”为97；“0”为 48 
"""
print('3' > 'f')   # False
print('a' < 'A')   # False

# 注意：如果字符串的长度大于1，则按照相同位置的字符进行依次比较，如果相同位置的字符相同，则顺延比较下一位
print('xyz' > '123')   # True
print('xyz' > 'x23')   # True

# 3.优先级
print(3 + 4 > 10 * 0)   # True
print(10 < 3 * True)    # False

4. 逻辑运算符

逻辑运算符是用来做逻辑计算的，就像之前用到的比较运算符，每一次比较其实就是一次条件判断，都会得到一个相应的True或者False的值，而逻辑运算符的操作数就是一个用来做条件判断的表达式或者变量

运算符	说明
and	与
or	或
not	非

重点：短路原则
a. A and B,如果A为False，不需要计算B的值，整个表达式的结果为False
b. A or B,如果A为True，不需要计算B的值，整个表达式的结果为True
c. and和or混合使用

1> 表达式从左往右运算，如果or的左侧为True，则会短路or后面所有的表达式【不管是and还是or连接】，整个表达式的结果为True
2> 表达式从左往右运算,如果and的左侧为False,则短路后面所有的and，直到or出现，接着计算
3> 如果or的左侧为False，或者and的左侧为True，则不能使用短路逻辑判断

### 重点： 短路原则
"""
注意：
 a. 逻辑运算符主要用于进行逻辑判断，所以一般结合if语句或while循环使用较多
 b. 逻辑运算符结合关系运算符使用较多
 c. 表示假的数据：0   0.0   ""   []   ()    {}   None False等
 d. not xx:不管xx是哪种数据类型，得到的结果肯定是布尔值
   and和or得到的结果不一定是布尔值，根据具体参与运算的数据而定
"""

"""
1.and:与
真 and  假  ----》假
真 and  真  ----》真
假 and  假  ----》假
假 and  真  ----》假

规律：全真为真，有假为假
"""
# 真 and  假  ----》假
print(True and False)   # False
print(34 and 0)  # 0
print(23.7 and 0.0)  # 0.0
print('hello' and '')  # ''
print([34,6,7] and [])  # []

# 真 and  真  ----》真
print(True and 'abc')   #'abc'
print(34 and 19)  #19
print(23.7 and True)  #True
print('hello' and 88)  #88
print([34,6,7] and [45,7,8])  #[45,7,8]

# 假 and  假  ----》假
print(0 and 0.0)  # 0
print(0.0 and False)  # 0.0
print([] and {})  # []
print('' and 0)  # ''

# 假 and  真  ----》假
print(0 and 'faga')  # 0
print(0 and True)  # 0
print(0 and [34,56])  # 0
print(0 and 45)  # 0
print(0 and 34.19)  # 0
"""
结论：
 A and B
 a. 如果A为真，则A and B整体的结果为是B的值
 b. 如果A为假，则A and B整体的结果是A的值，此时的B根本不会参与运算符，被称为短路原则
"""

"""
2. or:或
真 or  假  ----》真
真 or  真  ----》真
假 or  假  ----》假
假 or  真  ----》真

规律：有真为真，全假为假
"""
# 真 or  假  ----》真
print(True or False)   # True
print(34 or 0)  # 34
print(23.7 or 0.0)  # 23.7
print('hello' or '')  # 'hello'
print([34, 6, 7] or [])  # [34, 6, 7]

# 真 or  真  ----》真
print(True or 'abc')  # True
print(34 or 19)  # 34
print(23.7 or True)  # 23.7
print('hello' or 88)  # 'hello'
print([34, 6, 7] or [45,7,8])  # [34, 6, 7]

# 假 or  假  ----》假
print(0 or 0.0)  # 0.0
print(0.0 or 0)  # 0
print({} or [])  # []
print('' or 0.0)  # 0.0
print(0 or '')  # ''

# 假 or  真  ----》真
print(0 or 'faga')  # 'faga'
print(0 or True)  # True
print(0 or [34, 56])  # [34, 56]
print(0 or 45)  # 45
print(0 or 34.19)  # 34.19
"""
结论：
 A or B
 a. 如果A为真，则A or B整体的结果为是A的值，此时的B根本不会参与运算符，被称为短路原则
 b. 如果A为假，则A or B整体的结果是B的值
"""

"""
3. not:非
not 真 ----》假
not 假 ----》真
"""
print(not 0)   # True
print(not 3)   # False
print(not '')  # True
print(not 23.5)  # False
print(not 'abc')  # False
print(not [])  # True

# 4.优先级
print(3 > 5 and 10 < 15)   # False
# 优先级：算术运算符 >  关系运算符  > 逻辑运算符
print(3 + 2 == 5 and 10 < 15 * 2)  # True

5. 成员运算符

in：如果在指定的序列中找到值，则返回True，否则返回False
not in: 如果在指定的序列中没有找到值，则返回True，否则返回False

print('x' in 'xyz')   # True
print('x' not in 'xyz')  # False

print(66 in [34, 10, 99])   # False
print(66 not in [34, 10, 99])  # True

# 注意：成员运算符运算的结果肯定是布尔值，一般用于if语句或for循环

6. 身份运算符

身份运算符用于比较两个对象的存储单元
is:判断两个标识符是不是引用自一个对象
is not:判断两个标识符是不是引用自不同对象

"""
 ==: 用于比较值/内容
 is: 用于比较地址
"""

# 1.int/float/bool/str/tuple:不可变的数据类型
a = 10
b = 10
print(a == b)  # True
print(a is b)  # True

c = 20
print(a == c)  # False
print(a is c)  # False

# 2.list/dict/set:可变的数据类型
list1 = [1,2,3]
list2 = [1,2,3]
print(list1 == list2)  # True
print(list1 is list2)  # False

list3 = [1,2,4]
print(list1 == list3)  # False
print(list1 is list3)  # False

# 结论：
# 如果两个变量的地址相同，则这两个变量中存储的数据一定相同
# 如果两个变量中存储的数据相同，则这两个变量的地址不一定相同