Python 运算符

在本文中，我们介绍了Python运算符。

运算符是一个特殊的符号，表示执行了某个过程。编程语言中的运算符取自数学。应用程序处理数据。运算符用于处理数据。

在Python中，我们有几种类型的运算符：

• 算术运算符
• 布尔运算符
• 关系运算符
• 位运算符

一个运算符可能有一个或两个操作数。操作数是运算符的输入（参数）之一。那些只使用一个操作数的运算符称为一元运算符。那些使用两个操作数的人称为二元运算符。

+和-符号可以是加法和减法运算符以及一元符号运算符。视情况而定。

>>> 2
2
>>> +2
2
>>>

加号可以用来表示我们有一个正数。但它大多不被使用。减号更改值的符号。

>>> a = 1
>>> -a
-1
>>> -(-a)
1

乘法和加法运算符是二元运算符的示例。它们与两个操作数一起使用。

>>> 3 * 3
9
>>> 3 + 3
6

Python赋值运算符

赋值运算符=给变量赋值。在数学中，=运算符有不同的含义。在等式中，=运算符是一个相等运算符。等式左边等于右边。

>>> x = 1
>>> x
1

在这里，我们将一个数字分配给x变量。

>>> x = x + 1
>>> x
2

前面的表达式在数学上没有意义。但它在编程中是合法的。表达式的意思是我们给x变量加1，右边等于2，2赋值给x。

>>> a = b = c = 4
>>> print(a, b, c)
4 4 4

可以为多个变量赋值。

>>> 3 = y
  File "<stdin>", line 1
SyntaxError: can't assign to literal

此代码示例导致语法错误。我们不能为文字赋值。

Python算术运算符

以下是Python编程语言中的算术运算符表。

tr>

td>模数

以下示例显示算术运算。

#!/usr/bin/python

# arithmetic.py

a = 10
b = 11
c = 12

add = a + b + c
sub = c - a
mult = a * b
div = c / 3

power = a ** 2

print(add, sub, mult, div)
print(power)

所有这些都是数学中已知的运算符。

$ ./arithmetic.py
33 2 110 4.0
100

有3个运算符处理除法。

#!/usr/bin/python

# division.py

print(9 / 3)
print(9 / 4)
print(9 // 4)
print(9 % 4)

该示例演示了除法运算符。

print(9 / 4)

结果为2.25。在Python2.x中，/运算符是整数除法运算符。这在Python3中发生了变化。在Python3中，/运算符返回一个十进制数。

print(9 // 4)

//运算符是Python3中的整数运算符。

print(9 % 4)

%运算符称为模运算符。它找到一个数除以另一个数的余数。9%4，9模4是1，因为4进入9两次，余数为1。

$ ./division.py
3.0
2.25
2
1

>>> 'return' + 'of' + 'the' + 'king'
'returnoftheking'

加法运算符也可用于连接字符串。

>>> 3 + ' apples'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for +: 'int' and 'str'

我们不能添加整数和字符串。这会导致TypeError。

>>> str(3) + ' apples'
'3 apples'

要使示例正常运行，我们必须使用str函数将数字转换为字符串。

另一方面，乘法运算符可以与字符串和数字一起使用。

>>> 'dollar ' * 5
'dollar dollar dollar dollar dollar '

Python布尔运算符

在Python中，我们有and、or和not布尔运算符。使用布尔运算符，我们执行逻辑运算。这些最常与if和while关键字一起使用。

#!/usr/bin/python

# andop.py

print(True and True)
print(True and False)
print(False and True)
print(False and False)

此示例显示逻辑与运算符。仅当两个操作数都为True时，逻辑and运算符才计算为True。

$ ./andop.py
True
False
False
False

如果任一操作数为True，则逻辑或运算符的计算结果为True。

#!/usr/bin/python

# orop.py

print(True or True)
print(True or False)
print(False or True)
print(False or False)

如果运算符的一侧为True，则运算结果为True。

$ ./orop.py
True
True
True
False

否定运算符not使TrueFalse和False是的。

#!/usr/bin/python

# negation.py

print(not False)
print(not True)
print(not ( 4 < 3 ))

该示例显示了not运算符的实际应用。

$ ./negation.py
True
False
True

And,or运算符被短路评估。短路求值表示仅当第一个参数不足以确定表达式的值时才对第二个参数求值：当and的第一个参数求值为false时，整体值必须为false；并且当第一个参数或的计算结果为真时，整体值必须为真。

以下示例演示短路评估。

#!/usr/bin/python

# short_circuit.py

x = 10
y = 0

if (y != 0 and x/y < 100):
      print("a small value")

表达式的第一部分计算为False。不计算表达式的第二部分。否则，我们会得到一个ZeroDivisionError。

Python关系运算符

关系运算符用于比较值。这些运算符总是产生一个布尔值。

上表显示了Python关系运算符。

>>> 3 < 4
True
>>> 4 == 3
False
>>> 4 >= 3
True

正如我们已经提到的，关系运算符返回布尔值：True或False。

请注意，关系运算符不限于数字。我们也可以将它们用于其他对象。尽管它们可能并不总是有意义。

>>> "six" == "six"
True
>>> 'a' < 'b'
True

我们也可以比较字符串对象。

>>> 'a' < 'b'

这里到底发生了什么？计算机不认识字符或字符串。对他们来说，一切都只是一个数字。字符是存储在特定表中的特殊数字，例如ASCII。

>>> 'a' > 6
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unorderable types: str() > int()

无法对不同的数据类型使用关系运算符。此代码会导致TypeError。

#!/usr/bin/python

# compare.py

print('a' < 'b')

print("a is:", ord('a'))
print("b is:", ord('b'))

在内部，a和b字符是数字。所以当我们比较两个字符时，我们比较的是他们存储的数字。内置的ord函数返回单个字符的ASCII值。

$ ./compare.py
True
a is: 97
b is: 98

事实上，我们比较两个数字：97和98。

>>> "ab" > "aa"
True

假设我们有一个包含更多字符的字符串。如果第一个字符相等，我们比较下一个。在我们的例子中，第二个位置的b字符比a字符具有更大的值。这就是为什么“ab”字符串大于“aa”字符串。当然，以这种方式比较字符串没有多大意义。但这在技术上是可行的。

Python对象身份运算符

对象标识运算符，is和notis，检查其运算符是否为同一对象。

#!/usr/bin/python

# object_identity.py

print(None == None)
print(None is None)

print(True is True)

print([] == [])
print([] is [])

print("Python" is "Python")

==运算符测试相等性，而is运算符测试对象身份。我们是否在谈论同一个对象。请注意，多个变量可能引用同一个对象。

$ ./object_identity.py
True
True
True
True
False
True

输出可能会让您感到惊讶。在Python语言中，只有一个None和一个True对象。这就是为什么True与True相等且相同。无论如何，只有一个真理。空列表[]等于另一个空列表[]。但它们并不相同。Python将它们放在两个不同的内存位置。它们是两个不同的对象。因此is运算符返回False。

另一方面，“Python”是“Python”返回True。这是因为优化：如果两个字符串文字相等，则它们已被放入相同的内存位置。由于字符串是一个不可变的实体，因此不会造成任何伤害。

Python成员运算符

in和notin成员资格运算符测试序列中的成员资格，例如字符串、列表或元组。

#!/usr/bin/python

# membership.py

items = ("coin", "book", "pencil", "spoon", "paper")

if "coin" in items:
    print("There is a coin in the tuple")
else:
    print("There is no coin in the tuple")

if "bowl" not in items:
    print("There is no bowl in the tuple")
else:
    print("There is a bowl in the tuple")

使用成员资格运算符，我们测试一个项目是否存在于元组中。

if "coin" in items:

使用in运算符，我们检查"coin"是否存在于items元组中。

if "bowl" not in items:

使用notin运算符，我们检查"bowl"是否不存在于items元组中。

$ ./membership.py
There is a coin in the tuple
There is no bowl in the tuple

Python三元运算符

三元运算符是一个简单简洁的条件赋值语句。

exp1 if condition else exp2

如果条件为真，则计算exp1并返回结果。如果条件为假，则计算exp2并返回其结果。

#!/usr/bin/python

# ternary.py

age = 31

adult = True if age >= 18 else False

print("Adult: {0}".format(adult))

在许多国家/地区，成年取决于您的年龄。如果您的年龄超过特定年龄，您就是成年人。这是三元运算符的情况。

adult = True if age >= 18 else False

首先评估条件。如果年龄大于或等于18岁，则返回True。如果不是，则返回else关键字后的值。然后将返回的值分配给adult变量。

$ ./ternary.py
Adult: True

一个31岁的人是成年人。

Python按位运算符

小数对人类来说很自然。二进制数是计算机固有的。二进制、八进制、十进制或十六进制符号只是相同数字的表示法。按位运算符处理二进制数的位。我们有二进制运算符和移位运算符。按位运算符很少用于Python等高级语言。

按位取反运算符将每个1更改为0，将0更改为1。

>>> ~7
-8
>>> ~-8
7

运算符将数字7的所有位取反。其中一位还确定数字是否为负数。如果我们再次取反所有位，我们再次得到数字7。

按位与运算符在两个数字之间执行逐位比较。仅当操作数中的对应位均为1时，位位置的结果才为1。

     00110
  &  00011
   = 00010

第一个数是6的二进制数，第二个是3，最后的结果是2。

>>> 6 & 3
2
>>> 3 & 6
2

按位或运算符执行两个数字之间的逐位比较。如果操作数中的相应位中的任何一个为1，则位位置的结果为1。

     00110
  |  00011
   = 00111

结果是00110或十进制的7。

>>> 6 | 3
7

按位异或运算符在两个数字之间执行逐位比较。如果操作数中相应位的一个或另一个（但不是两个）为1，则位位置的结果为1。

     00110
  ^  00011
   = 00101

结果为00101或十进制数5。

>>> 6 ^ 3
5

正如我们提到的，位运算符很少用于Python和其他高级语言。然而，在某些情况下，它们会被使用。一个例子是面具。掩码是一种特定的位模式。它确定是否设置了某些属性。

让我们举一个GUI编程的例子。

#!/usr/bin/python

# bitwise_or.py

import wx

app = wx.App()
window = wx.Frame(None, style=wx.MAXIMIZE_BOX | wx.RESIZE_BORDER
	| wx.SYSTEM_MENU | wx.CAPTION |	 wx.CLOSE_BOX)
window.Show(True)

app.MainLoop()

这是一个wxPython代码的小例子。wx.MAXIMIZE_BOX、wx.RESIZE_BORDER、wx.SYSTEM_MENU、wx.CAPTION和wx.CLOSE_BOX是常量。按位或运算符将所有这些常量添加到掩码中。在我们的例子中，所有这些属性都使用按位或运算符设置并应用于wx.Frame小部件。

最后，我们还有位移运算符。位移运算符向右或向左移动位。

number << n : multiply number 2 to the nth power
number >> n : divide number by 2 to the nth power

这些运算符也称为算术移位。

     00110
  >> 00001
   = 00011

我们将数字6的每一位都向右移动。等于6除以2。结果为00011或小数点3。

>>> 6 >> 1
3

     00110
  << 00001
   = 01100

我们将数字6的每一位向左移动。它等于数字6乘以2。结果为01100或十进制的12。

>>> 6 << 1
12

Python复合赋值运算符

复合赋值运算符由两个运算符组成。它们是速记运算符。

>>> i = 1
>>> i = i + 1
>>> i
2
>>> i += 1
>>> i
3

+=复合运算符是这些速记运算符之一。

其他复合运算符是：

-=   *=   /=   //=   %=   **=   &=   |=   ^=   >>=   <<=

Python运算符优先级

运算符优先级告诉我们首先评估哪些运算符。优先级级别对于避免表达式中的歧义是必要的。

以下表达式的结果是28还是40？

3 + 5 * 5

与数学一样，乘法运算符的优先级高于加法运算符。所以结果是28。

(3 + 5) * 5

要改变评估的顺序，我们可以使用方括号。方括号内的表达式总是先求值。

以下列表显示了Python中的运算符优先级。

unary +  -  ~
**
*  /  %
+  -
>>  <<
&
^
|
<  <=  ==  >=  >  !=  is
not
and
or

同一行的运算符具有相同的优先级。优先级从下到上增长。

#!/usr/bin/python

# precedence.py

print(3 + 5 * 5)
print((3 + 5) * 5)

print(2 ** 3 * 5)
print(not True or True)
print(not (True or True))

在此代码示例中，我们展示了一些常用表达式。每个表达式的结果取决于优先级。

print(2 ** 3 * 5)

幂运算符的优先级高于乘法运算符。首先，计算2**3，返回8。然后将结果乘以5，结果为40。

print(not True or True)

在这种情况下，not运算符具有更高的优先级。首先，第一个True值取反为False，然后or运算符组合False和True，最后给出True。

$ ./precedence.py
28
40
40
True
False

关系运算符的优先级高于逻辑运算符。

#!/usr/bin/python

# positive.py

a = 1
b = 2

if (a > 0 and b > 0):
   print("a and b are positive integers")

和运算符等待两个布尔值。如果其中一个操作数不是布尔值，我们就会得到一个语法错误。在Python中，关系运算符在逻辑与之前求值。

$ ./positive.py
a and b are positive integers

Python关联性规则

有时优先级不能令人满意地确定表达式的结果。还有一个规则称为关联性。运算符的结合性决定了具有相同优先级的运算符的求值顺序。

9 / 3 * 3

这个表达式的结果是9还是1？乘法、删除和模运算符从左到右关联。因此表达式的计算方式如下：(9/3)*3结果为9。

算术运算符、布尔运算符、关系运算符和按位运算符都是从左到右关联的。

另一方面，赋值运算符是右关联的。

>>> a = b = c = d = 0
>>> a, b, c, d
(0, 0, 0, 0)

如果关联是从左到右，前面的表达式就不可能了。

复合赋值运算符从右到左关联。

>>> j = 0
>>> j *= 3 + 1
>>> j
0

您可能期望结果为1。但实际结果为0。因为关联性。先计算右边的表达式，然后应用复合赋值运算符。

在本文中，我们讨论了Python中的运算符。

列出所有Python教程。