Python 中那些令人惊讶的代码行为49

Python，以其简洁性和易读性而闻名的强大编程语言，有时会表现出一些令人惊讶甚至离谱的代码行为。这些行为可能会让经验丰富的开发者感到困惑，并导致潜在的错误。以下是 Python 中一些最令人惊讶的代码行为：

1. 布尔值比较的意外结果

Python 中的布尔值比较并不总是遵循直觉。例如，以下代码将返回 True，即使两个变量都为 False：```python
>>> False == False
True
```

这是因为 Python 将两个 False 值视为同一对象，因此它们等于对方。

2. 元组和列表的奇怪可修改性

通常，元组被认为是不可变的，而列表是可变的。然而，在某些情况下，Python 允许对其进行修改。例如，以下代码将成功修改元组的第一个元素：```python
>>> my_tuple = (1, 2, 3)
>>> my_tuple[0] = 4
>>> my_tuple
(4, 2, 3)
```

这是因为 Python 实际上创建了一个新的元组，第一个元素赋值为 4，而不是修改原始元组。

3. 字符串的列表连接

将字符串列表连接到一起时，Python 的行为可能会令人惊讶。以下代码不会产生预期的结果：```python
>>> my_list = ["a", "b", "c"]
>>> my_string = "".join(my_list)
>>> my_string
'abc'
```

这是因为 join() 函数在连接字符串之前，会将列表转换为字符串。要获得 ['a', 'b', 'c'] 的预期结果，需要使用 join([str(x) for x in my_list])。

4. None 的 Truthiness

Python 的 None 值通常被认为是虚假的，但它有一个意外的属性。在布尔上下文中，None 等于 False。然而，当与其他值进行比较时，None 等于 itself：```python
>>> None == False
True
>>> None == None
True
```

5. 数字比较的陷阱

Python 中的数字比较有时会出现奇怪的结果。例如，以下代码将返回 True，即使第一个数明显大于第二个数：```python
>>> 1.1 < 1
True
```

这是因为 Python 将数字作为浮点数进行比较，而 1.1 的浮点数表示是 1.1000000000000001，它小于 1。

6. 运算符优先级的怪异

Python 中的运算符优先级可能会让人困惑。例如，以下代码将打印 1，而不是预期的 5：```python
>>> 1 + 2 * 3
1
```

这是因为乘法运算符的优先级高于加法运算符。要获得预期的结果，需要使用括号：```python
>>> (1 + 2) * 3
5
```

7. 字典键的可变性

Python 允许使用可变对象作为字典键。然而，这可能会带来问题。例如，以下代码将导致无限循环：```python
>>> my_dict = {}
>>> my_dict[my_dict] = "example"
>>> my_dict[my_dict]
{'example': {'example': {'example': {...}}}}
```

这是因为在将 my_dict 作为键添加到字典时，my_dict 的值也会发生变化，导致无限循环。

8. 赋值运算符的意外结果

Python 的赋值运算符 (=) 的行为可能会令人惊讶。例如，以下代码将修改列表中的所有元素，即使在列表的副本上进行赋值：```python
>>> my_list = [1, 2, 3]
>>> my_list_copy = my_list
>>> my_list_copy[0] = 4
>>> my_list
[4, 2, 3]
```

这是因为列表的副本实际上指向与原始列表相同的底层数据结构。

9. 函数参数的默认值

Python 允许在函数参数中指定默认值。然而，这些默认值在第一次调用函数时才被计算，而不是在每次调用时重新计算。这可能会导致意外的结果：```python
>>> def my_function(x, y=[]):
... (x)
... return y
...
>>> my_function(1)
[1]
>>> my_function(2)
[1, 2]
```

这是因为在首次调用 my_function 时，y 的默认值被计算并存储，并在后续调用中重复使用。

10. 内置函数的奇特行为

Python 的某些内置函数具有令人惊讶的行为。例如，map() 函数将在某些情况下对参数进行求值：```python
>>> def my_function(x):
... return x + 1
...
>>> my_list = [1, 2, 3]
>>> list(map(my_function, my_list))
[2, 3, 4]
>>> list(map(lambda x: x + 1, my_list))
[None, None, None]
```

这是因为 map() 在第一个函数调用中对 my_function 进行求值，并将该值存储在 map 对象中。因此，lambda 函数在后续调用中不会被求值。

Python 中的这些令人惊讶的代码行为突显了在使用该语言时仔细考虑潜在陷阱的重要性。了解这些行为可以帮助开发者编写更健壮、更可预测的代码。虽然这些行为可能会让一些开发者感到困惑，但它们也展示了 Python 的灵活性，并为经验丰富的开发者提供了利用这些行为来创建创新解决方案的机会。

2024-10-29

上一篇：Python 提取学号代码

下一篇：Python 与数据库 SQL：快速上手指南