Python运算符

Python算数运算符

摘要：在本节中，你将学习如何使用Python算术运算符来执行数学运算。

在Python中，你使用算术运算符对数字执行数学运算。下表列出了Python中的所有算术运算符：

运算符	描述	a	b	示例	结果
+	加法	5	2	a + b	7
-	减法	5	2	a - b	3
*	乘法	5	2	a * b	10
/	除法（浮点数）	5	2	a / b	2.5
//	整除	5	2	a // b	2
%	取模（求余数）	5	2	a % b	1
**	幂运算（指数运算）	5	2	a ** b	25

加（+）

加法运算符（+）可以让你将两个数字相加。你可以用它来计算数字的总和。例如：

a = 10
b = 3
result = a + b

print(result )

输出：

13

减（-）

减法运算符（-）可让你用第一个数减去第二个数。你可以用它来计算两个值之间的差。例如：

a = 10
b = 3
result = a - b

print(result)

输出：

7

乘（*）

乘法运算符（*）可让你将两个数字相乘。你可以用它来计算面积、按比例缩放数字，以及进行财务计算。

a = 10
b = 3
result = a * b

print(result)

输出：

30

除（/）

除法运算符（/）可让你用第一个数除以第二个数，并返回一个浮点数。你可以用它来计算平均值以及进行财务计算。例如：

a = 10
b = 3
result = a / b

print(result)

输出：

3.3333333333333335

整除（//）

整除运算符（//）可让你进行整数除法运算，并返回一个不带小数部分的数字。例如：

a = 10
b = 3
result = a // b

print(result)

输出：

3

取模（%）

取模运算符（%）可让你返回两个数相除后的余数。

a = 10
b = 3
result = a % b

print(result)

输出：

1

你可以使用取模运算符来检查一个数是奇数（odd）还是偶数（even）：

a = 101

if a % 2 == 1:
    print(f'{a} is odd.');
else:
    print(f'{a} is even.');

输出：

101 is odd.

你也可以使用%运算符来检查某一年是否为闰年（leap）：

year = 2024

if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0):
    print(f"{year} is a leap year.")
else:
    print(f"{year} is not a leap year.")

输出：

2024 is a leap year.

幂（**）

幂运算符（**）将第一个数作为底数，以第二个数为指数进行乘方运算：

a = 10
b = 3
result = a ** b

print(result)

输出：

1000

你可以在科学计算和金融计算中使用幂运算符（**）。例如，你可以使用幂运算符来计算复利：

principal = 1000
interest_rate = 0.05
year = 2
amount = principal * (1 + interest_rate ) ** year

print(f"Total Amount: ${amount:,.2f}")

输出：

Total Amount: $1,102.50

总结

• 使用Python算术运算符来执行数学运算。

Python赋值运算符

摘要：在本节中，你将学习如何使用Python赋值运算符为变量赋值。

赋值运算符

在Python中，你使用赋值运算符为变量赋值。例如，下面使用赋值运算符（=）将数字0赋值给变量count：

count = 0

print(count)

输出：

0

你可以对一个变量进行计算，然后将结果再赋值给该变量，如下所示：

count = 0
count = count + 1

print(count)

输出：

1

在这个例子中，我们将0赋值给变量count，然后将它的值增加1，并把结果再赋值给变量count。

请注意，下面表达式中的=是赋值操作，而不是相等比较：

count = count + 1

在Python中，用于比较两个值的相等运算符是==。你将在比较运算符教程中学习到它。

复合赋值运算符

在编程中，我们常常希望简洁地表达我们的想法。例如，你可以使用复合赋值运算符+=，一步完成对count变量的递增操作，并将结果重新赋值给该变量：

count = 0
count += 1

print(count)

输出：

1

在这个例子中，运算符+=将变量count的值加1，然后把结果再赋值给该变量：

count += 1

这等价于：

count = count + 1

以下是Python中常见的复合赋值运算符：

运算符	描述	a	b	示例	等同于	结果
+=	相加并赋值	5	2	a += b	a = a + b	7
-=	相减并赋值	5	2	a -= b	a = a - b	3
*=	相乘并赋值	5	2	a *= b	a = a * b	10
/=	相除并赋值	5	2	a /= b	a = a / b	2.5
//=	整除并赋值	5	2	a //= b	a = a // b	2
%=	取模并赋值	5	2	a %= b	a = a % b	1
**=	求幂并赋值	5	2	a **= b	a = a ** b	25

加等（+=）

加法并赋值运算符（+=）允许你将一个值加到一个变量上，然后把结果再赋值给该变量。例如：

count = 0
count += 1  # Same as: count = count + 1

print(count)

输出：

1

减等（-=）

减法并赋值运算符（-=）允许你从一个变量中减去一个值，然后将结果重新赋值给该变量：

quantity = 5
quantity -= 2  # Same as: quantity = quantity- 2

print(quantity)

输出：

3

乘等（*=）

乘法并赋值运算符（*=）允许你将一个数与变量相乘，然后将结果重新赋值给该变量：

a = 10
a *= 2  # Same as: a = a * 2

print(a)  # Output: 20

输出：

20

除等（/=）

除法并赋值运算符（/=）允许你进行除法运算并将结果赋值回去：

amount = 25
amount /= 2 # same as amount = amount / 2

print(amount)

输出：

12.5

整除等（//=）

整除并赋值运算符（//=）允许你执行整数除法运算，并将结果重新赋值。

amount = 10
amount //= 3  # Same as: amount = amount // 3

print(amount)

输出：

3

取模等（%=）

取模并赋值运算符（%=）计算余数并将其赋值给一个变量：

amount = 10
amount %= 3

print(amount)

输出：

1

幂等（**=）

幂运算并赋值运算符（**=）允许你对一个数进行乘方运算，然后将结果重新赋值：

a = 2
a **= 3  # Same as: a = a ** 3
print(a)

输出：

8

总结

• 使用赋值运算符（=）为变量赋值。
• 使用复合赋值运算符，一步完成计算并将结果赋值给变量。

Python比较运算符

摘要：在本节中，你将了解 Python 的比较运算符，以及如何使用它们来比较两个值。

比较运算符简介

在编程中，你常常需要将一个值与另一个值进行比较。要做到这一点，你需要使用比较运算符。

Python 有六个比较运算符，具体如下：

• 小于（<）
• 小于或等于（<=）
• 大于（>）
• 大于或等于（>=）
• 等于（==）
• 不等于（!=）

这些比较运算符对两个值进行比较，并返回一个布尔值，即要么是 True，要么是 False。

你可以使用这些比较运算符来比较数字和字符串。

小于运算符（<）

小于运算符（<）用于比较两个值，如果左边的值小于右边的值，则返回 True，否则返回 False：

left_value  < right_value

以下示例使用小于（<）运算符来比较两个数字：

x = 10
y = 20

result = x < y
print(result)

result = x > y
print(result)

输出：

True
False

当你对数字使用小于运算符时，这是相当明显（容易理解）的。

下面的示例使用小于运算符（<）来比较两个字符串：

result = 'apple' < 'orange'
print(result)

result = 'banana' < 'apple'
print(result)

输出：

True
False

表达式 'apple' < 'orange' 返回 True，因为单词apple 中的字母 a 在单词 orange 中的字母 o 之前。

同样地，'banana' < 'apple' 返回 False，因为字母b 在字母a 之后。

下面的示例展示了如何对变量使用小于运算符：

x = 10
y = 20

result = x < y
print(result)

result = y < x
print(result)

输出：

True
False

小于等于运算符（<=）

小于或等于运算符用于比较两个值，如果左边的值小于或等于右边的值，它就返回 True，否则返回 False：

left_value <= right_value

以下示例展示了如何使用小于或等于运算符来比较两个数字：

result = 20 <= 20
print(result)

result = 10 <= 20
print(result)

result = 30 <= 30
print(result)

输出：

True
True
True

这个示例展示了如何使用小于或等于运算符来比较两个变量的值：

x = 10
y = 20

result = x <= y
print(result)

result = y <= x
print(result)

输出：

True
False

大于运算符（>）

大于运算符（>）用于比较两个值，如果左边的值大于右边的值，它就返回 True，否则返回 False：

left_value > right_value

这个示例使用大于运算符（>）来比较两个数字：

result = 20 > 10
print(result)

result = 20 > 20
print(result)

result = 10 > 20
print(result)

输出：

True
False
False

这个示例使用大于运算符（>）来比较两个数字：

result = 'apple' > 'orange'
print(result)

result = 'orange' > 'apple'
print(result)

输出：

False
True

大于等于运算符（>=）

大于或等于运算符（>=）用于比较两个值，如果左边的值大于或等于右边的值，它就会返回 True。否则，就会返回 False：

left_value >= right_value

以下示例使用大于或等于运算符来比较两个数字：

result = 20 >= 10
print(result)

result = 20 >= 20
print(result)

result = 10 >= 20
print(result)

输出：

True
True
False

以下示例使用大于或等于运算符来比较两个字符串：

result = 'apple' >= 'apple'
print(result)

result = 'apple' >= 'orange'
print(result)

result = 'orange' >= 'apple'
print(result)

输出：

True
False
True

等于运算符（==）

等于运算符（==）用于比较两个值，如果左边的值等于右边的值，它就返回 True，否则返回 False：

left_value == right_value

以下示例使用等于运算符（==）来比较两个数字：

result = 20 == 10
print(result)

result = 20 == 20
print(result)

输出：

False
True

下面的示例使用等于运算符（==）来比较两个字符串：

result = 'apple' == 'apple'
print(result)

result = 'apple' == 'orange'
print(result)

输出：

True
False

不等运算符（！=）

不等于运算符（!=）用于比较两个值，如果左边的值不等于右边的值，它就返回 True，否则返回 False：

left_value != right_value

例如，下面使用不等于运算符来比较两个数字：

result = 20 != 20
print(result)

result = 20 != 10
print(result)

输出：

False
True

下面的示例使用不等于运算符来比较两个字符串：

result = 'apple' != 'apple'
print(result)

result = 'apple' != 'orange'
print(result)

输出：

False
True

总结

• 比较运算符用于比较两个值，并返回一个布尔值，即要么为 True（真），要么为 False（假）。
• Python 有六个比较运算符：小于（<）、小于或等于（<=）、大于（>）、大于或等于（>=）、等于（==）以及不等于（!=）。

Python逻辑运算符

摘要：在本节中，你将了解 Python 的逻辑运算符，以及如何使用它们来组合多个条件。

逻辑运算符简介

有时候，你可能想要同时检查多个条件。要做到这一点，你可以使用逻辑运算符。

Python 有三个逻辑运算符：

• 与（and）
• 或（or）
• 非（not）

与运算符（and）

and（与）运算符用于检查两个条件是否同时都为 True（真）：

a and b

如果两个条件都为真，它就返回 True（真）。而如果条件 a 或 b 中有一个为假，它就返回 False（假）。

下面的示例使用 and（与）运算符来组合两个将价格与数字进行比较的条件：

price = 9.99
result = price > 9 and price < 10
print(result)

输出：

True

结果为 True（真），因为价格大于 9 且小于 10。

下面这个示例返回 False（假），因为价格不大于 10。

price = 9.99
result =  price > 10 and price < 20
print(result)

输出：

False

在这个示例中，条件 price > 10 返回 False（假），而第二个条件 price < 20 返回 True（真）。

下表展示了使用 and 运算符组合两个条件时的结果情况：

a	b	a and b
真	真	真
真	假	假
假	假	假
假	真	假

只有当条件 a 和条件 b 都为真时，a and b 这个条件才会返回真。

或运算符（or）

与and（与）运算符类似，or（或）运算符也用于检查多个条件。但只要单个条件中的任意一个为 True（真）或者两个条件都为 True（真）时，它就会返回 True（真）：

a or b

下表展示了使用or运算符组合两个条件时的结果：

a	b	a or b
真	真	真
真	假	真
假	真	真
假	假	假

只有当两个条件都为假时，or运算符才会返回假值。

下面的示例展示了如何使用“或”运算符：

price = 9.99
result =  price > 10 or price < 20
print(result)

在这个示例中，price < 20 返回 True（真），因此，整个表达式返回 True（真）。

下面这个示例返回 False（假），因为两个条件的计算结果都为 False（假）：

price = 9.99
result =  price > 10 or price < 5
print(result)

非运算符（not）

not（非）运算符应用于单个条件。它会反转该条件的结果，即真会变为假，假会变为真：

not a

如果条件为 True，not 运算符返回 False，反之亦然。

下表说明了 not 运算符的结果：

a	not a
真	假
假	真

以下示例使用了 not 运算符。由于 price > 10 返回 False，因此 not price > 10 返回 True：

price = 9.99
result = not price > 10
print(result)

输出：

True

以下是另一个结合了 not 和 and 运算符的示例：

price = 9.99
result =  not (price > 5 and price < 10)
print(result)

输出：

False

在这个示例中，Python 按照以下顺序对条件进行求值：

首先，(price > 5 and price < 10) 求值为 True。
其次，not True 求值为 False。
这就引出了一个重要的概念，称为逻辑运算符的优先级。

逻辑运算符的优先级

当你在一个表达式中混合使用逻辑运算符时，Python 会按照称为“运算符优先级”的顺序对它们进行求值。

以下展示了 not、and 和 or 运算符的优先级：

运算符	优先级
not	高
and	中
or	低

基于这些优先级，Python 会首先为优先级最高的运算符对操作数进行分组，然后为优先级较低的运算符对操作数进行分组，依此类推。

如果一个表达式中有几个优先级相同的逻辑运算符，Python 会从左到右对它们进行求值：

• a or b and c 意味着 a or(b andc)
• a and b or c and d 意味着 (a and b) or(c and d)
• a and b and c or d 意味着 ((a and b) and c) or d
• not a and b or c 意味着 ((not a) and b) or c

总结

• 使用逻辑运算符来组合多个条件。
• Python 有三个逻辑运算符：and（且）、or（或）和 not（非）。
• 逻辑运算符的优先级从高到低依次为：not、and、or。