python学习day2：运算符+优先级

在Python中，比较运算符用于比较两个值，并返回一个布尔值（True或False）。以下是一些常见的比较运算符及其用法：

比较运算符

• ==：等于，检查两个值是否相等。
• !=：不等于，检查两个值是否不相等。
• >：大于，检查左边的值是否大于右边的值。
• <：小于，检查左边的值是否小于右边的值。
• >=：大于等于，检查左边的值是否大于或等于右边的值。
• <=：小于等于，检查左边的值是否小于或等于右边的值。

a = 5
b = 3

print(a == b)  # False
print(a != b)  # True
print(a > b)   # True
print(a < b)   # False
print(a >= b)  # True
print(a <= b)  # False

运算符优先级

Python中的运算符优先级决定了表达式中运算符的执行顺序。以下是一些常见运算符的优先级（从高到低）：

1. 括号 ()：具有最高优先级，用于明确表达式的计算顺序。
2. 幂运算 **：计算幂次。
3. 乘法 *、除法 /、取余 %、取整除法 //：具有相同的优先级，从左到右计算。
4. 加法 +、减法 -：具有相同的优先级，从左到右计算。
5. 比较运算符 ==、!=、>、<、>=、<=：具有相同的优先级，从左到右计算。
6. 逻辑运算符 not、and、or：not优先级最高，and次之，or最低。
7. 位运算符 &，|，~。

result = 5 + 3 * 2 ** 2  # 5 + 3 * 4 = 5 + 12 = 17
print(result)

result = (5 + 3) * 2 ** 2  # 8 * 4 = 32
print(result)

result = 5 + 3 * 2 == 11  # 5 + 6 == 11 → 11 == 11 → True
print(result)

---

逻辑运算符

and,or,not

and

在Python中，逻辑运算符 and 的行为并非直接返回布尔值 True 或 False，而是根据短路求值规则返回其中一个操作数的值。具体规则如下：

1. and 的返回值规则：

   • 如果第一个操作数为假（False 或"假值"），直接返回第一个操作数的值。

   • 如果第一个操作数为真（True 或"真值"），则返回第二个操作数的值。

2. 表达式 1 and 'abc' 的执行过程：

   • 第一个操作数 1 是非零整数，属于真值 ，因此继续计算第二个操作数 'abc'。

   • 第二个操作数 'abc' 是非空字符串，也是真值，因此整个表达式返回第二个操作数的值 'abc

注意：

and相当于&位运算符，也就是*（乘），当第一个数为假（0）时，后面则不重要。因此，在and中，可能为假（0）的会放前面

or

规则：

• 短路求值：若第一个操作数为真（Truthy），直接返回第一个操作数的值，不再计算第二个。

• 若第一个为假（Falsy）：返回第二个操作数的值（无论第二个是真还是假）。

举例：

a = 0 or 'abc'      # a = 'abc'（第一个是假，返回第二个）
b = '' or 123       # b = 123  （第一个是假，返回第二个）
c = 'hello' or []   # c = 'hello'（第一个是真，直接返回）
d = [] or 0         # d = 0    （两个都是假，返回第二个）
print(a, b, c, d)   # 输出: abc 123 hello 0

典型应用：

• 设置默认值：

name = input("请输入姓名: ") or "Guest"
# 如果用户未输入（空字符串），则 name = "Guest"

注意：

or相当于|位运算符，也就是+（加），当第一个数为真（1）时，后面则不重要。因此，在or中，将可能为真（1）的会放前面

not

规则：

• 返回值 ：始终返回布尔值 True 或 False。

• 逻辑反转 ：将操作数的真假性取反（真→False，假→True）

示例：

a = not 1           # a = False（1 是真值，取反为 False）
b = not 0           # b = True （0 是假值，取反为 True）
c = not 'abc'       # c = False（非空字符串是真值，取反为 False）
d = not []          # d = True （空列表是假值，取反为 True）
print(a, b, c, d)  # 输出: False True False True

关键注意：

• not 是唯一直接返回布尔值的逻辑运算符，而 and 和 or 返回操作数的实际值。

• 若需将非布尔值转换为布尔类型，可以用 bool() 函数：

print(bool('abc'))  # True
print(bool(0))      # False

---

赋值运算符

赋值运算符 用于将值（或表达式的结果）分配给变量。以下是常见的赋值运算符及其用法（以 Python 为例）：

1. 基础赋值运算符 =

• 作用：将右侧的值赋给左侧的变量。

• 示例：

  a = 10       # 将整数 10 赋给变量 a
  name = "Alice"  # 将字符串赋给变量 name

2. 复合赋值运算符

将运算与赋值合并，简化代码。例如 +=、-=、*= 等。

| 运算符 | 含义 | 等价形式 | 示例（假设初始值 a = 5） |
|-------|---------|--------------|---------------------------------------|-----|-----|------------------------|---------|
| += | 加后赋值 | a = a + b | a += 3 → a = 8 |
| -= | 减后赋值 | a = a - b | a -= 2 → a = 3 |
| *= | 乘后赋值 | a = a * b | a *= 4 → a = 20 |
| /= | 除后赋值 | a = a / b | a /= 2 → a = 2.5 |
| //= | 整除后赋值 | a = a // b | a //= 2 → a = 2 |
| %= | 取模后赋值 | a = a % b | a %= 3 → a = 2 |
| **= | 幂运算后赋值 | a = a ** b | a **= 2 → a = 25 |
| &= | 按位与后赋值 | a = a & b | a &= 3 → a = 1（二进制 0101 & 0011） |
| ` | =` | 按位或后赋值 | `a = a | b` | `a | = 3→a = 7（二进制 0101 | 0011`） |
| ^= | 按位异或后赋值 | a = a ^ b | a ^= 3 → a = 6（二进制 0101 ^ 0011） |
| <<= | 左移后赋值 | a = a << b | a <<= 1 → a = 10（二进制左移1位） |
| >>= | 右移后赋值 | a = a >> b | a >>= 1 → a = 2（二进制右移1位） |

3. 链式赋值

• 作用：一次性为多个变量赋相同的值。

x = y = z = 0  # x、y、z 的值均为 0

4. 解包赋值

• 作用：将序列中的值依次赋给多个变量（适用于元组、列表、字符串等可迭代对象）。

• 示例：

a, b, c = [1, 2, 3]    # a=1, b=2, c=3
x, y = "hi"            # x='h', y='i'
# 使用 * 收集剩余值（Python 3.5+）
first, *rest = [10, 20, 30, 40]  # first=10, rest=[20, 30, 40]

5. 海象运算符 :=（Python 3.8+）

• 作用：在表达式中同时进行赋值（称为"赋值表达式"）。

• 示例：

# 传统写法
n = 10
if n > 5:
    print(n)

# 使用海象运算符
if (n := 10) > 5:
    print(n)  # 输出 10

注意事项

可变对象的引用：

list1 = [1, 2, 3]
list2 = list1    # list2 和 list1 指向同一列表对象
list2.append(4)  # list1 也会变为 [1, 2, 3, 4]

若需复制对象，需显式操作（如 list2 = list1.copy()）。

---

成员运算符

在 Python 中，成员运算符用于检查某个元素是否属于某个序列（如字符串、列表、元组、集合、字典等）。以下是成员运算符的详细说明：

1. 成员运算符类型

• in ：如果元素在序列中存在，返回 True，否则返回 False。

• not in ：如果元素在序列中不存在，返回 True，否则返回 False。

2. 使用场景与示例

(1) 列表、元组、集合

检查元素是否存在于容器中：

# 列表
numbers = [1, 2, 3]
print(2 in numbers)       # True
print(5 not in numbers)   # True

# 元组
colors = ("red", "green", "blue")
print("blue" in colors)   # True

# 集合（成员检查效率高）
s = {10, 20, 30}
print(20 in s)            # True

(2) 字符串

检查子字符串是否存在：

text = "Hello, World!"
print("World" in text)    # True
print("Python" not in text)  # True

(3) 字典

默认检查键（Key）是否存在，不检查值（Value）：

d = {"name": "Alice", "age": 25}
print("name" in d)        # True（检查键）
print("Alice" in d)       # False（不检查值）

# 若要检查值是否存在，需显式操作：
print("Alice" in d.values())  # True（检查值）

3. 注意事项

1. 区分字典的键和值 ：

   字典的 in 运算符默认只检查键，若需检查值，需使用 .values() 方法。

2. 大小写敏感 ：

   字符串的成员检查是大小写敏感的：

   print("hello" in "Hello World")  # False（大小写不匹配）

3. 性能差异 ：
   列表、元组 ：in 的时间复杂度为 O(n) （逐个遍历）
   集合、字典的键 ：in 的时间复杂度接近 O(1)（基于哈希表实现，效率高）。

实例对比

# 列表 vs 集合（大容量数据）
big_list = list(range(1_000_000))
big_set = set(big_list)

# 列表的 in 操作较慢
print(999_999 in big_list)  # 需要遍历 → 慢

# 集合的 in 操作极快
print(999_999 in big_set)   # 哈希查找 → 快