Python 运算符

Python 中的运算符用于对变量和值执行特定操作。Python 拥有许多运算符，它们可以是关键字或特殊字符。运算符作用于的值或变量称为操作数。

Python运算符的类型

Python运算符可以分为以下几类。

1. 算术运算符
2. 逻辑运算符
3. 比较运算符
4. 位运算符
5. 赋值运算符
6. 会员运营商
7. 身份运算符

1. 算术运算符

Python 中的算术运算符通常用于处理数字。它们包括加法、减法、乘法、除法、取模和指数运算运算符。其中一些运算符也适用于字符串。所有算术运算符都是特殊字符。

• +：加号
• -：减法运算符
• *：乘法运算符
• /: 除法运算符
• **：指数运算符
• //: 楼层分割运算符

让我们来看一个Python中算术运算符的例子。

x = 15
y = 7
 
sum = x + y
print("addition =", sum)
 
subtraction = x - y
print("subtraction =", subtraction)
 
multiplication = x * y
print("multiplication =", multiplication)
 
division = x / y
print("division =", division)
 
modulus = x % y
print("modulus =", modulus)
 
exponent = x ** 2
print("exponent =", exponent)
 
floor_division = x // y
print("division =", floor_division)  # 2

输出：

Python 支持字符串的加法和乘法运算符。

print("addition of strings =", ("Python" + " " + "Operators"))
print("multiplication of strings =", ("Python" * 2))

输出：

addition of strings = Python Operators
multiplication of strings = PythonPython

2. 比较运算符

Python 比较运算符用于比较两个值。结果始终是布尔值——True或False。

Python 中的比较运算符列表如下：

• ==：如果两个值相等，则返回 True。
• !=: 如果两个操作数不相等，则返回 True。
• >: 如果左操作数大于右操作数，则返回 True。
• <: 如果左操作数小于右操作数，则返回 True。
• >=: 如果左边的值大于或等于右边的值，则返回 True。
• <=: 如果左边的值小于或等于右边的值，则返回 True。

让我们来看一个在 Python 中使用比较运算符的例子。

x = 10
y = 20
 
print(f'equals = {x == y}')
print(f'not equals = {x != y}')
print(f'greater than = {x > y}')
print(f'less than = {x < y}')
print(f'greater than or equal to = {x >= y}')
print(f'less than or equal to = {x <= y}')

输出：

这些运算符也适用于字符串。如果一个字符串在字典序上位于另一个字符串之后，则认为该字符串大于后者。例如，按字典序比较，“Hi”大于“Hello”。

3. 位运算符

它们也称为二元运算符，并且只对整数进行运算。操作数的值会被转换为二进制数，然后对每一位执行运算。最后，运算结果会被转换回十进制数并返回。

Python 中有 6 个位运算符。

• &：按位与运算符
• |: 按位或运算符
• ^：按位异或运算符
• ~：二进制反码运算符
• <<: 二进制左移运算符
• >>: 二进制右移运算符

x = 10  # 1010
y = 4  #  0100
 
print(f'Binary AND = {x & y}')
print(f'Binary OR = {x | y}')
print(f'Binary XOR = {x ^ y}')
print(f'Binary Ones Complement = {~x}')
print(f'Binary Left Shift by 2 = {x << 2}')
print(f'Binary Right Shift by 3 = {x >> 3}')

输出：

Binary AND = 0
Binary OR = 14
Binary XOR = 14
Binary Ones Complement = -11
Binary Left Shift by 2 = 40
Binary Right Shift by 3 = 1

4. Python 逻辑运算符

Python 中有三个逻辑运算符。它们使用布尔操作数并返回布尔值。它们由 Python 的保留关键字构成。

• and：逻辑与运算符
• or：逻辑或运算符
• not：逻辑非运算符

b1 = True
b2 = False
 
print(f'{b1} and {b2} = {b1 and b2}')
print(f'{b1} and {b2} = {b1 or b2}')
print(f'not {b1} = {not b1}')

输出：

5. 赋值运算符

赋值运算符（=）用于将左操作数的值赋给右操作数。

有些复合赋值运算符可以对两个操作数执行一些算术运算，然后将结果赋值给左边的操作数。

• =: 简单赋值运算符
• +=：将两个操作数相加，然后将结果赋值给右操作数。
• -=：从左操作数中减去右操作数，然后将结果赋值给左操作数。
• *=：将两个操作数相乘，然后将结果赋值给左侧的值。
• /=：将左操作数与右操作数相除，然后将结果赋值给左操作数。
• %=: 对左右操作数取模，然后赋值给左操作数。
• ****=**: 从左到右对操作数取指数，然后赋值给左操作数
• //=：对左右操作数进行向下取整，然后将结果赋值给左操作数。

a = 10  # simple assignment operator
b = 5
 
a += b  # same as a=a+b
print(a)  # 15
 
a -= b  # same as a=a-b
print(a)  # 10
 
a *= b  # same as a = a*b
print(a)  # 50
 
a /= b  # same as a = a/b
print(a)  # 10.0
 
a %= b  # same as a = a%b
print(a)  # 0.0
 
a = 2
b = 4
 
a **= b  # same as a = a**b
print(a)  # 16
 
a //= b  # same as a = a // b (floor division)
print(a) # 4

6. 成员运算符

Python 中的成员运算符用于检查序列中是否存在某个值。Python 中有两个成员运算符。

• in
• not in

这些运算符通常与if-else条件一起使用。

x = 3
 
my_tuple = (1, 2, 3, 4)
my_list = [1, 2, 3, 4]
my_str = "Hello"
 
print(f'{x} is present in {my_tuple} = {x in my_tuple}')
 
if x in my_list:
    print(f'{x} is present in {my_list}')
 
if 'a' not in my_str:
    print(f'a is not present in {my_str}')

7. 身份运算符

Python 的恒等运算符用于检查两个变量是否指向同一内存位置。共有两个恒等运算符。

• is：如果两个变量都指向同一个内存位置，则返回 True
• is not：如果两个变量都指向不同的内存位置，则返回 True

s1 = [1, 2]
s2 = [1, 2]
s3 = s1
 
print(s1 is s2)  # False
print(s1 is s3)  # True
 
print(s1 is not s2)  # True
print(s1 is not s3)  # False

Python中的运算符优先级

有时一个表达式包含多个运算符。在这种情况下，运算符优先级用于确定执行顺序。

我们可以使用括号创建一组表达式。括号内的表达式会先被计算，然后才能参与后续的计算。 某些运算符具有相同的优先级。在这种情况下，表达式将从左到右进行计算。 下表按优先级降序排列了运算符。

序号	运算符	说明
1	**	指数
2	单目运算符（+x、-x、~x）	“原形”（单目）运算
3	*、/、//、%	乘法、除法、向下取整、取模
4	+、-	加法、减法
5	<<、>>	右移、左移
6	&	按位与
7	`	、^`
8	==、!=、>、<、>=、<=	比较运算符
9	=、+=、-=、*=、/=、//=、%=	赋值运算符
10	is、is not	恒等运算符（身份比较）
11	in、not in	成员运算符
12	not、and、or	逻辑运算符

Python 运算符重载

Python 支持运算符重载。有一些特定的方法可以为对象重载运算符。

让我们看看当某个类不支持某个运算符时会发生什么。

class Data:
    id = 0
 
    def __init__(self, i):
        self.id = i
 
 
d1 = Data(10)
d2 = Data(20)
 
d3 = d1 + d2
print(d3.id)

输出：

Traceback (most recent call last):
  File "/Users/pankaj/Documents/PycharmProjects/PythonTutorialPro/hello-world/operators_examples.py", line 9, in <module>
    d3 = d1 + d2
TypeError: unsupported operand type(s) for +: 'Data' and 'Data'

如果要为 Data 类支持 + 运算符，我们需要为其定义 add() 方法。让我们看看更新后的代码和输出结果。

class Data:
    id = 0
 
    def __init__(self, i):
        self.id = i
 
    def __add__(self, other):
        return Data(self.id + other.id)
 
 
d1 = Data(10)
d2 = Data(20)
 
d3 = d1 + d2
print(d3.id)

输出： 30

下表提供了在 Python 中重载运算符的方法。

操作符	描述	方法
+	添加	__add__(self, other)
-	减法	__sub__(self, other)
*	乘法	__mul__(self, other)
/	真除法	__truediv__(self, other)
//	楼层	__floordiv__(self, other)
%	余	__mod__(self, other)
**	力量	__pow__(self, other)
&	按位与	__and__(self, other)
`	`	按位或
^	按位异或	__xor__(self, other)
>	大于	__gt__(self, other)
>=	大于或等于	__ge__(self, other)
<	少于	__lt__(self, other)
<=	小于或等于	__le__(self, other)
==	等于	__eq__(self, other)
!=	不等于	__ne__(self, other)

Python operator 模块

Python 运算符模块提供了一组与 Python 运算符对应的函数。这些函数名称与特殊方法的名称相同，只是去掉了双下划线。

我们来看一个支持运算符（+、> 和 *）的自定义类的示例。我们将使用运算符模块函数来调用该类对象的这些方法。

import operator
 
class Data:
    id = 0
 
    def __init__(self, i):
        self.id = i
 
    def __add__(self, other):
        return Data(self.id + other.id)
 
    def __gt__(self, other):
        return self.id > other.id
 
    def __mul__(self, other):
        return Data(self.id * other.id)
 
 
d1 = Data(10)
d2 = Data(20)
 
d3 = operator.add(d1, d2)
print(d3.id)
 
d3 = operator.mul(d1, d2)
print(d3.id)
 
flag = operator.gt(d1, d2)
print(flag)

总结

Python 支持许多运算符，可以帮助我们进行常见的算术、比较、赋值、二进制或逻辑运算。最棒的是，许多运算符都可以通过在类中定义特殊方法进行重载。如果您希望程序更面向对象，可以使用 operator 模块，它提供了与这些运算符对应的函数。

接下来是什么？

• Python 数字
• Python 循环
• Python 面向对象编程
• Python 模块
• Python 集合

参考：

• Python operator模块