Python 2 和 Python 3 有哪些主要区别？
Python 2 和 Python 3 之间存在许多重要的区别，这些区别使得 Python 3 更现代化、更易于使用、更强大。以下是一些主要的区别，我会尽可能详细地解释：
1. `print` 语句与 `print()` 函数
Python 2: `print` 是一个语句（statement）。
```python
Python 2
print "Hello, World!"
print "Hello,", name
```
Python 3: `print()` 是一个函数（function）。
```python
Python 3
print("Hello, World!")
print("Hello,", name)
```
详细解释:
语法改变: 这是最直观和最常被提及的区别。在 Python 2 中，`print` 不需要括号，你可以直接写 `print x`。而在 Python 3 中，`print` 必须写成函数调用的形式 `print(x)`。
灵活性和功能: 将 `print` 改为函数带来了更大的灵活性。例如，你可以使用关键字参数来控制输出的格式，如 `end` 和 `sep`。
```python
Python 3
print("Hello", end="") 不换行
print("World", sep='') 用 '' 分隔
```
兼容性: 许多 Python 2 代码需要修改才能在 Python 3 中运行，仅仅是将 `print x` 改为 `print(x)` 就能解决很多情况，但对于更复杂的打印语句，可能还需要调整。
2. 整数除法
Python 2: `/` 运算符在进行整数除法时，会返回一个整数（截断小数部分）。
```python
Python 2
print 5 / 2 输出: 2
print 5.0 / 2 输出: 2.5
```
Python 3: `/` 运算符始终返回一个浮点数。
```python
Python 3
print(5 / 2) 输出: 2.5
print(5.0 / 2) 输出: 2.5
```
详细解释:
行为差异: 这是另一个导致兼容性问题的常见原因。Python 2 的整数除法行为可能导致意外的结果，特别是当开发者期望得到精确的浮点数结果时。
新运算符 `//`: 为了在 Python 3 中保留 Python 2 的整数除法行为，引入了新的运算符 `//` (地板除法)。
```python
Python 3
print(5 // 2) 输出: 2
```
预期一致性: Python 3 的 `/` 操作符在所有数字类型上表现一致，都返回浮点数，这使得代码的预期行为更加清晰和一致。
3. `range()` 与 `xrange()`
Python 2: 提供了两个函数：
`range(n)`: 返回一个包含从 0 到 n1 的整数列表。对于大的 `n`，这会占用大量内存。
`xrange(n)`: 返回一个 xrange 对象，它是一个迭代器，在需要时生成数字，更节省内存。
```python
Python 2
numbers_list = range(10) 生成一个包含 [0, 1, 2, ..., 9] 的列表
numbers_iterator = xrange(10) 生成一个迭代器
```
Python 3: `range()` 函数的行为与 Python 2 的 `xrange()` 相同，返回一个 range 对象（一种迭代器）。Python 2 的 `range()` 被移除。
```python
Python 3
numbers_iterator = range(10) 生成一个 range 对象 (迭代器)
```
详细解释:
内存效率: Python 3 的 `range()` 更有效率，尤其是处理大型序列时。它不会一次性将所有数字加载到内存中，而是按需生成。
迭代器: `range` 对象在 Python 3 中被设计成一个惰性序列，这意味着它只在迭代时才生成数值，而不是预先创建整个列表。这对于需要迭代大量数字的情况非常有益，可以显著减少内存消耗。
兼容性: 如果你的 Python 2 代码使用了 `xrange()`，并且你想迁移到 Python 3，那么你只需要将 `xrange()` 改为 `range()` 即可。
4. 字符串与字节序列
Python 2:
`str`: 默认是字节串（byte string），表示的是 ASCII 编码的字符串。
`unicode`: 表示 Unicode 字符串。
```python
Python 2
s = "hello" 是 str (字节串)
u = u"hello" 是 unicode (Unicode 字符串)
```
Python 3:
`str`: 默认是 Unicode 字符串。
`bytes`: 表示字节序列。
```python
Python 3
s = "hello" 是 str (Unicode 字符串)
b = b"hello" 是 bytes (字节序列)
```
详细解释:
编码混乱的解决: Python 2 中字符串和 Unicode 的混合使用是许多编码相关错误的主要原因。区分字符串的文本性质和字节的二进制性质在 Python 3 中变得更加明确。
文本 vs. 二进制:
在 Python 3 中，`str` 类型代表文本数据，它存储的是 Unicode 字符。
`bytes` 类型代表原始的字节数据，通常用于文件 I/O（读写二进制文件）、网络通信等需要处理二进制数据的场景。
转换: 在 Python 3 中，你需要显式地在 `str` 和 `bytes` 之间进行编码（encode）和解码（decode）。
```python
Python 3
unicode_string = "你好"
byte_string = unicode_string.encode('utf8') 编码成 UTF8 字节串
print(byte_string) 输出: b'xe4xbdxa0xe5xa5xbd'
decoded_string = byte_string.decode('utf8') 解码成 Unicode 字符串
print(decoded_string) 输出: 你好
```
兼容性: 迁移 Python 2 代码到 Python 3 时，涉及到字符串处理的部分需要特别注意，特别是那些涉及文件读写或网络通信的代码。
5. 异常处理
Python 2: 捕获异常的语法。
```python
Python 2
try:
some code
pass
except Exception, e:
print "Error:", e
```
Python 3: 捕获异常的语法。
```python
Python 3
try:
some code
pass
except Exception as e:
print("Error:", e)
```
详细解释:
语法变化: 在 Python 3 中，捕获异常时，使用 `as` 关键字来将异常对象赋值给一个变量，而不是使用逗号。
`except Exception, e` 的移除: Python 2 的这种语法在 Python 3 中被移除，强制使用更清晰的 `as` 关键字。
6. 迭代器与列表
Python 2: 许多返回列表的函数（如 `map`, `filter`, `zip`）在 Python 3 中改为返回迭代器。
```python
Python 2
my_list = map(lambda x: x2, [1, 2, 3]) my_list 是一个列表 [2, 4, 6]
Python 3
my_iterator = map(lambda x: x2, [1, 2, 3]) my_iterator 是一个 map 对象 (迭代器)
```
详细解释:
内存效率和惰性求值: 这一改变与 `range()` 的改变类似，旨在提高内存效率和支持惰性求值。返回迭代器意味着结果不会立即全部计算并存储在内存中，而是在需要时才逐个生成。
显式转换为列表: 如果你需要一个列表，可以在 Python 3 中显式地将迭代器转换为列表：
```python
Python 3
my_list = list(map(lambda x: x2, [1, 2, 3])) my_list 是一个列表 [2, 4, 6]
```
迭代的通用性: 很多情况下，你只需要迭代结果，而不需要一个完整的列表。返回迭代器使得代码可以更高效地处理大数据集。
7. `__future__` 模块
Python 2: 可以使用 `__future__` 模块导入 Python 3 的特性，以帮助平滑过渡。
```python
Python 2
from __future__ import print_function
from __future__ import division
```
详细解释:
向后兼容的桥梁: `__future__` 模块允许你在 Python 2 代码中启用一些 Python 3 的行为。例如，导入 `from __future__ import print_function` 就可以让你在 Python 2 代码中使用 `print()` 函数语法。
迁移辅助: 这是在 Python 2 代码库中逐步引入 Python 3 特性的重要工具，使得代码在 Python 2 和 Python 3 之间具有更好的兼容性，并为最终的 Python 3 迁移做准备。
8. `raw_input()` vs. `input()`
Python 2:
`raw_input()`: 读取用户输入并返回一个字符串。
`input()`: 读取用户输入，并尝试将其作为 Python 表达式求值。这是一个潜在的安全隐患。
```python
Python 2
name = raw_input("Enter your name: ") name 是字符串
result = input("Enter an expression: ") 尝试求值
```
Python 3:
`input()`: 行为与 Python 2 的 `raw_input()` 相同，总是返回一个字符串。
`raw_input()`: 被移除。
```python
Python 3
name = input("Enter your name: ") name 是字符串
如果想执行表达式，需要使用 eval(input(...))，但通常不推荐
```
详细解释:
安全性和一致性: Python 3 的 `input()` 函数更安全，因为它不会尝试执行用户输入的代码。它始终将输入视为字符串，这更符合大多数用户期望的行为。
简化: 移除了 `raw_input()`，统一了输入处理方式，简化了 API。
9. 字典的 `.keys()`, `.values()`, `.items()`
Python 2: 这些方法返回列表。
```python
Python 2
my_dict = {'a': 1, 'b': 2}
keys = my_dict.keys() keys 是一个列表 ['a', 'b']
```
Python 3: 这些方法返回“视图对象”（view objects），它们是动态的、迭代的，并且提供了一种比列表更有效的方式来访问字典的内容。
```python
Python 3
my_dict = {'a': 1, 'b': 2}
keys = my_dict.keys() keys 是一个 dict_keys 对象 (视图)
```
详细解释:
内存效率和性能: 视图对象不会复制整个列表，而是提供了一个字典内容的“实时”视图。当字典改变时，视图对象也会反映这些变化。这在处理大型字典时可以节省内存并提高性能。
迭代友好: 视图对象可以直接用于迭代，而无需转换为列表。
```python
Python 3
for key in my_dict.keys():
print(key)
```
兼容性: 如果你的 Python 2 代码依赖于这些方法返回列表并对列表进行操作（例如，排序列表），那么在 Python 3 中需要显式地使用 `list()` 将视图对象转换为列表。
```python
Python 3
keys_list = list(my_dict.keys())
```
10. 列表推导式中的生成器表达式
Python 2: 列表推导式和生成器表达式的语法相同。
```python
Python 2
squares_list = [i2 for i in range(10)] 列表推导式，生成列表
squares_generator = (i2 for i in range(10)) 生成器表达式，生成生成器
```
Python 3: 列表推导式和生成器表达式的语法有所区分，但更重要的行为改变是，生成器表达式的变量作用域更严格。
详细解释:
作用域 (主要区别): 在 Python 2 中，列表推导式中的变量在推导式结束后仍然存在于外部作用域。而生成器表达式的变量在迭代结束后消失。
```python
Python 2
result = [i for i in range(5)]
print i 仍然可以访问，值为 4
Python 3
result = [i for i in range(5)]
print(i) NameError: name 'i' is not defined
```
注意: Python 3 在函数内部的行为与此类似，它也使用了更严格的作用域。列表推导式在 Python 3 中被视为一个在函数内部创建的特殊作用域，因此变量不会泄漏到外部。
11. Unicode 和编码处理的改进
如前面字符串部分所述，Python 3 对 Unicode 的处理是内置且清晰的，这是其最重大的改进之一。
12. 其他重要的改变 (简述)
`next()` 方法: Python 2 中，迭代器有 `.next()` 方法，Python 3 中重命名为 `__next__()`。
`exec` 语句 vs. `exec()` 函数: 类似 `print`，`exec` 在 Python 3 中也成为一个函数。
`has_key()` 被移除: Python 3 中，检查字典是否存在某个键，应使用 `in` 操作符 (`key in my_dict`)，而不是 `my_dict.has_key(key)`。
`reload()` 函数: Python 2 中是内置函数，Python 3 中移动到了 `importlib` 模块。
标准库的重组: 一些模块在 Python 3 中被重组或重命名，例如 `urllib` 和 `urllib2` 合并成 `urllib` 包。
元组解包的增强: Python 3 允许使用 `` 来解包元组或列表，例如 `a, rest, b = [1, 2, 3, 4, 5]`。
总结
Python 3 的设计目标是修复 Python 2 中的一些设计缺陷、不一致之处，并引入新的特性以提高语言的现代化程度、易用性和性能。主要的改进集中在：
清晰的字符串和字节区分 (Unicode 支持)
更合理的整数除法
内存效率的提高 (迭代器，视图对象)
更安全的输入处理
更现代化的语法和标准库
尽管 Python 2 在 2020 年已停止维护，但许多现有的代码库仍然在使用 Python 2。理解这些差异对于进行代码迁移和维护至关重要。Python 3 是 Python 的未来，鼓励新项目和迁移现有项目都使用 Python 3。
1. `print` 语句与 `print()` 函数
Python 2: `print` 是一个语句（statement）。
```python
Python 2
print "Hello, World!"
print "Hello,", name
```
Python 3: `print()` 是一个函数（function）。
```python
Python 3
print("Hello, World!")
print("Hello,", name)
```
详细解释:
语法改变: 这是最直观和最常被提及的区别。在 Python 2 中，`print` 不需要括号，你可以直接写 `print x`。而在 Python 3 中，`print` 必须写成函数调用的形式 `print(x)`。
灵活性和功能: 将 `print` 改为函数带来了更大的灵活性。例如，你可以使用关键字参数来控制输出的格式，如 `end` 和 `sep`。
```python
Python 3
print("Hello", end="") 不换行
print("World", sep='') 用 '' 分隔
```
兼容性: 许多 Python 2 代码需要修改才能在 Python 3 中运行，仅仅是将 `print x` 改为 `print(x)` 就能解决很多情况，但对于更复杂的打印语句，可能还需要调整。
2. 整数除法
Python 2: `/` 运算符在进行整数除法时，会返回一个整数（截断小数部分）。
```python
Python 2
print 5 / 2 输出: 2
print 5.0 / 2 输出: 2.5
```
Python 3: `/` 运算符始终返回一个浮点数。
```python
Python 3
print(5 / 2) 输出: 2.5
print(5.0 / 2) 输出: 2.5
```
详细解释:
行为差异: 这是另一个导致兼容性问题的常见原因。Python 2 的整数除法行为可能导致意外的结果，特别是当开发者期望得到精确的浮点数结果时。
新运算符 `//`: 为了在 Python 3 中保留 Python 2 的整数除法行为，引入了新的运算符 `//` (地板除法)。
```python
Python 3
print(5 // 2) 输出: 2
```
预期一致性: Python 3 的 `/` 操作符在所有数字类型上表现一致，都返回浮点数，这使得代码的预期行为更加清晰和一致。
3. `range()` 与 `xrange()`
Python 2: 提供了两个函数：
`range(n)`: 返回一个包含从 0 到 n1 的整数列表。对于大的 `n`，这会占用大量内存。
`xrange(n)`: 返回一个 xrange 对象，它是一个迭代器，在需要时生成数字，更节省内存。
```python
Python 2
numbers_list = range(10) 生成一个包含 [0, 1, 2, ..., 9] 的列表
numbers_iterator = xrange(10) 生成一个迭代器
```
Python 3: `range()` 函数的行为与 Python 2 的 `xrange()` 相同，返回一个 range 对象（一种迭代器）。Python 2 的 `range()` 被移除。
```python
Python 3
numbers_iterator = range(10) 生成一个 range 对象 (迭代器)
```
详细解释:
内存效率: Python 3 的 `range()` 更有效率，尤其是处理大型序列时。它不会一次性将所有数字加载到内存中，而是按需生成。
迭代器: `range` 对象在 Python 3 中被设计成一个惰性序列，这意味着它只在迭代时才生成数值，而不是预先创建整个列表。这对于需要迭代大量数字的情况非常有益，可以显著减少内存消耗。
兼容性: 如果你的 Python 2 代码使用了 `xrange()`，并且你想迁移到 Python 3，那么你只需要将 `xrange()` 改为 `range()` 即可。
4. 字符串与字节序列
Python 2:
`str`: 默认是字节串（byte string），表示的是 ASCII 编码的字符串。
`unicode`: 表示 Unicode 字符串。
```python
Python 2
s = "hello" 是 str (字节串)
u = u"hello" 是 unicode (Unicode 字符串)
```
Python 3:
`str`: 默认是 Unicode 字符串。
`bytes`: 表示字节序列。
```python
Python 3
s = "hello" 是 str (Unicode 字符串)
b = b"hello" 是 bytes (字节序列)
```
详细解释:
编码混乱的解决: Python 2 中字符串和 Unicode 的混合使用是许多编码相关错误的主要原因。区分字符串的文本性质和字节的二进制性质在 Python 3 中变得更加明确。
文本 vs. 二进制:
在 Python 3 中，`str` 类型代表文本数据，它存储的是 Unicode 字符。
`bytes` 类型代表原始的字节数据，通常用于文件 I/O（读写二进制文件）、网络通信等需要处理二进制数据的场景。
转换: 在 Python 3 中，你需要显式地在 `str` 和 `bytes` 之间进行编码（encode）和解码（decode）。
```python
Python 3
unicode_string = "你好"
byte_string = unicode_string.encode('utf8') 编码成 UTF8 字节串
print(byte_string) 输出: b'xe4xbdxa0xe5xa5xbd'
decoded_string = byte_string.decode('utf8') 解码成 Unicode 字符串
print(decoded_string) 输出: 你好
```
兼容性: 迁移 Python 2 代码到 Python 3 时，涉及到字符串处理的部分需要特别注意，特别是那些涉及文件读写或网络通信的代码。
5. 异常处理
Python 2: 捕获异常的语法。
```python
Python 2
try:
some code
pass
except Exception, e:
print "Error:", e
```
Python 3: 捕获异常的语法。
```python
Python 3
try:
some code
pass
except Exception as e:
print("Error:", e)
```
详细解释:
语法变化: 在 Python 3 中，捕获异常时，使用 `as` 关键字来将异常对象赋值给一个变量，而不是使用逗号。
`except Exception, e` 的移除: Python 2 的这种语法在 Python 3 中被移除，强制使用更清晰的 `as` 关键字。
6. 迭代器与列表
Python 2: 许多返回列表的函数（如 `map`, `filter`, `zip`）在 Python 3 中改为返回迭代器。
```python
Python 2
my_list = map(lambda x: x2, [1, 2, 3]) my_list 是一个列表 [2, 4, 6]
Python 3
my_iterator = map(lambda x: x2, [1, 2, 3]) my_iterator 是一个 map 对象 (迭代器)
```
详细解释:
内存效率和惰性求值: 这一改变与 `range()` 的改变类似，旨在提高内存效率和支持惰性求值。返回迭代器意味着结果不会立即全部计算并存储在内存中，而是在需要时才逐个生成。
显式转换为列表: 如果你需要一个列表，可以在 Python 3 中显式地将迭代器转换为列表：
```python
Python 3
my_list = list(map(lambda x: x2, [1, 2, 3])) my_list 是一个列表 [2, 4, 6]
```
迭代的通用性: 很多情况下，你只需要迭代结果，而不需要一个完整的列表。返回迭代器使得代码可以更高效地处理大数据集。
7. `__future__` 模块
Python 2: 可以使用 `__future__` 模块导入 Python 3 的特性，以帮助平滑过渡。
```python
Python 2
from __future__ import print_function
from __future__ import division
```
详细解释:
向后兼容的桥梁: `__future__` 模块允许你在 Python 2 代码中启用一些 Python 3 的行为。例如，导入 `from __future__ import print_function` 就可以让你在 Python 2 代码中使用 `print()` 函数语法。
迁移辅助: 这是在 Python 2 代码库中逐步引入 Python 3 特性的重要工具，使得代码在 Python 2 和 Python 3 之间具有更好的兼容性，并为最终的 Python 3 迁移做准备。
8. `raw_input()` vs. `input()`
Python 2:
`raw_input()`: 读取用户输入并返回一个字符串。
`input()`: 读取用户输入，并尝试将其作为 Python 表达式求值。这是一个潜在的安全隐患。
```python
Python 2
name = raw_input("Enter your name: ") name 是字符串
result = input("Enter an expression: ") 尝试求值
```
Python 3:
`input()`: 行为与 Python 2 的 `raw_input()` 相同，总是返回一个字符串。
`raw_input()`: 被移除。
```python
Python 3
name = input("Enter your name: ") name 是字符串
如果想执行表达式，需要使用 eval(input(...))，但通常不推荐
```
详细解释:
安全性和一致性: Python 3 的 `input()` 函数更安全，因为它不会尝试执行用户输入的代码。它始终将输入视为字符串，这更符合大多数用户期望的行为。
简化: 移除了 `raw_input()`，统一了输入处理方式，简化了 API。
9. 字典的 `.keys()`, `.values()`, `.items()`
Python 2: 这些方法返回列表。
```python
Python 2
my_dict = {'a': 1, 'b': 2}
keys = my_dict.keys() keys 是一个列表 ['a', 'b']
```
Python 3: 这些方法返回“视图对象”（view objects），它们是动态的、迭代的，并且提供了一种比列表更有效的方式来访问字典的内容。
```python
Python 3
my_dict = {'a': 1, 'b': 2}
keys = my_dict.keys() keys 是一个 dict_keys 对象 (视图)
```
详细解释:
内存效率和性能: 视图对象不会复制整个列表，而是提供了一个字典内容的“实时”视图。当字典改变时，视图对象也会反映这些变化。这在处理大型字典时可以节省内存并提高性能。
迭代友好: 视图对象可以直接用于迭代，而无需转换为列表。
```python
Python 3
for key in my_dict.keys():
print(key)
```
兼容性: 如果你的 Python 2 代码依赖于这些方法返回列表并对列表进行操作（例如，排序列表），那么在 Python 3 中需要显式地使用 `list()` 将视图对象转换为列表。
```python
Python 3
keys_list = list(my_dict.keys())
```
10. 列表推导式中的生成器表达式
Python 2: 列表推导式和生成器表达式的语法相同。
```python
Python 2
squares_list = [i2 for i in range(10)] 列表推导式，生成列表
squares_generator = (i2 for i in range(10)) 生成器表达式，生成生成器
```
Python 3: 列表推导式和生成器表达式的语法有所区分，但更重要的行为改变是，生成器表达式的变量作用域更严格。
详细解释:
作用域 (主要区别): 在 Python 2 中，列表推导式中的变量在推导式结束后仍然存在于外部作用域。而生成器表达式的变量在迭代结束后消失。
```python
Python 2
result = [i for i in range(5)]
print i 仍然可以访问，值为 4
Python 3
result = [i for i in range(5)]
print(i) NameError: name 'i' is not defined
```
注意: Python 3 在函数内部的行为与此类似，它也使用了更严格的作用域。列表推导式在 Python 3 中被视为一个在函数内部创建的特殊作用域，因此变量不会泄漏到外部。
11. Unicode 和编码处理的改进
如前面字符串部分所述，Python 3 对 Unicode 的处理是内置且清晰的，这是其最重大的改进之一。
12. 其他重要的改变 (简述)
`next()` 方法: Python 2 中，迭代器有 `.next()` 方法，Python 3 中重命名为 `__next__()`。
`exec` 语句 vs. `exec()` 函数: 类似 `print`，`exec` 在 Python 3 中也成为一个函数。
`has_key()` 被移除: Python 3 中，检查字典是否存在某个键，应使用 `in` 操作符 (`key in my_dict`)，而不是 `my_dict.has_key(key)`。
`reload()` 函数: Python 2 中是内置函数，Python 3 中移动到了 `importlib` 模块。
标准库的重组: 一些模块在 Python 3 中被重组或重命名，例如 `urllib` 和 `urllib2` 合并成 `urllib` 包。
元组解包的增强: Python 3 允许使用 `` 来解包元组或列表，例如 `a, rest, b = [1, 2, 3, 4, 5]`。
总结
Python 3 的设计目标是修复 Python 2 中的一些设计缺陷、不一致之处，并引入新的特性以提高语言的现代化程度、易用性和性能。主要的改进集中在：
清晰的字符串和字节区分 (Unicode 支持)
更合理的整数除法
内存效率的提高 (迭代器，视图对象)
更安全的输入处理
更现代化的语法和标准库
尽管 Python 2 在 2020 年已停止维护，但许多现有的代码库仍然在使用 Python 2。理解这些差异对于进行代码迁移和维护至关重要。Python 3 是 Python 的未来，鼓励新项目和迁移现有项目都使用 Python 3。
网友意见
在进行程序调试时用得最多的语句可能就是 print，在 Python 2 中，print 是一条语句，而 Python3 中作为函数存在。有人可能就有疑问了，我在 Python2 中明明也看到当函数使用：
# py2 print("hello") # 等价 print ("hello") #py3 print("hello") 然而，你看到的只是表象，那么上面两个表达式有什么区别？从输出结果来看是一样的，但本质上，前者是把 ("hello")当作一个整体，而后者 print()是个函数，接收字符串作为参数。
# py2 >>> print("hello", "world") ('hello', 'world') # py3 >>> print("hello", "world") hello world 这个例子更明显了，在 py2 中，print语句后面接的是一个元组对象，而在 py3 中，print 函数可以接收多个位置参数。如果希望在 Python2 中 把 print 当函数使用，那么可以导入 future 模块 中的 print_function
# py2 >>> print("hello", "world") ('hello', 'world') >>> >>> from __future__ import print_function >>> print("hello", "world") hello world 编码
Python2 的默认编码是 asscii，这也是导致 Python2 中经常遇到编码问题的原因之一，至于是为什么会使用 asscii 作为默认编码，原因在于 Python这门语言诞生的时候还没出现 Unicode。Python 3 默认采用了 UTF-8 作为默认编码，因此你不再需要在文件顶部写 # coding=utf-8 了。
# py2 >>> sys.getdefaultencoding() 'ascii' # py3 >>> sys.getdefaultencoding() 'utf-8' 网上不少文章说通过修改默认编码格式来解决 Python2 的编码问题，其实这是个大坑，不要这么干。
字符串
字符串是最大的变化之一，这个变化使得编码问题降到了最低可能。在 Python2 中，字符串有两个类型，一个是 unicode，一个是 str，前者表示文本字符串，后者表示字节序列，不过两者并没有明显的界限，开发者也感觉很混乱，不明白编码错误的原因，不过在 Python3 中两者做了严格区分，分别用 str 表示字符串，byte 表示字节序列，任何需要写入文本或者网络传输的数据都只接收字节序列，这就从源头上阻止了编码错误的问题。
True和False
True 和 False 在 Python2 中是两个全局变量（名字），在数值上分别对应 1 和 0，既然是变量，那么他们就可以指向其它对象，例如：
# py2 >>> True = False >>> True False >>> True is False True >>> False = "x" >>> False 'x' >>> if False: ... print("?") ... ? 显然，上面的代码违背了 Python 的设计哲学 Explicit is better than implicit.。而 Python3 修正了这个缺陷，True 和 False 变为两个关键字，永远指向两个固定的对象，不允许再被重新赋值。
# py3 >>> True = 1 File "<stdin>", line 1 SyntaxError: can't assign to keyword 迭代器
在 Python2 中很多返回列表对象的内置函数和方法在 Python 3 都改成了返回类似于迭代器的对象，因为迭代器的惰性加载特性使得操作大数据更有效率。Python2 中的 range 和 xrange 函数合并成了 range，如果同时兼容2和3，可以这样：
try: range = xrange except: pass 另外，字典对象的 dict.keys()、dict.values() 方法都不再返回列表，而是以一个类似迭代器的 "view" 对象返回。高阶函数 map、filter、zip 返回的也都不是列表对象了。Python2的迭代器必须实现 next 方法，而 Python3 改成了 __next__
nonlocal
我们都知道在Python2中可以在函数里面可以用关键字 global 声明某个变量为全局变量，但是在嵌套函数中，想要给一个变量声明为非局部变量是没法实现的，在Pyhon3，新增了关键字 nonlcoal，使得非局部变量成为可能。
def func(): c = 1 def foo(): c = 12 foo() print(c) func() #1 可以对比上面两段代码的输出结果
def func(): c = 1 def foo(): nonlocal c c = 12 foo() print(c) func() # 12 其实很多内建模块也做了大量调整，Python3 中的模块组织更加清晰，类更加先进，还引入了异步IO，先写这么多
-------更新-------
多谢知友 @YFdyh 指出，py2出现的时候其实已经有了unicode统一编码了，只不过py2为了向后兼容还是沿用了py1.x的设计逻辑
类似的话题
-
Python 2 和 Python 3 之间存在许多重要的区别，这些区别使得 Python 3 更现代化、更易于使用、更强大。以下是一些主要的区别，我会尽可能详细地解释： 1. `print` 语句与 `print()` 函数Python 2: `print` 是一个语句（statement）。``............. -
Python 2 和 Python 3 的出现，确实在 Python 社区内部引发了一段不小的“分裂期”，与其说是分裂，不如说是一种痛苦的阵痛，是向前发展必须经历的“断奶”过程。这背后有很多复杂的原因，让我们一层层剥开来看。首先，得从 Python 2 本身说起。Python 2 在当时是一个非常成.............
-
好了，咱们就站在 2020 年这个时间点，好好聊聊 Python 2 到 3 这个跨越，那会儿（大概是 2008 年，Python 3.0 发布）可真是热闹非凡，讨论得那是天翻地覆。现在回头看，这升级，怎么说呢，就像当年很多人唱衰的“史诗级灾难”，结果硬生生被证明是“一次必要的、痛苦但终将受益的涅槃.............
-
这个问题很简单，在 Python 中，我们经常需要将包含数字的列表（或者更复杂的嵌套列表）转换为包含字符串的列表。这在很多场景下都很有用，比如： 数据导出： 当你需要将数据写入 CSV 文件、JSON 文件或者其他文本格式时，通常需要将数字转换为字符串。 字符串拼接： 如果你需要将数字元素组.............
-
.......
-
Python 作为一种强大的数据科学语言，拥有丰富多样的数据可视化库，为用户提供了从基础绘图到复杂交互式可视化的广泛选择。除了 `matplotlib` 这个被誉为“万能瑞士军刀”的库之外，还有许多其他优秀的库，它们在特定领域、易用性、交互性或美学风格上各有千秋。下面我将详细介绍一些常用的 Pyth.............
-
处理百亿行、数十列的数据是一项巨大的挑战，它不仅仅是简单地将数据加载到内存中，而需要一套系统性的策略来克服内存限制、提高处理效率和保证计算的稳定性。Python/Pandas本身在内存受限的情况下处理如此大规模的数据会遇到困难，但我们可以结合Pandas与其他工具和技术来应对。下面将详细讲解Pyth.............
-
Python 是一门功能强大且用途广泛的语言，有很多很棒的练手项目可以帮助你学习和巩固知识。我会根据不同的学习阶段和兴趣方向，为你推荐一些值得详细介绍的项目，并说明为什么它们是好的练手项目。在开始之前，你需要具备的基础： Python 基础语法： 变量、数据类型（整型、浮点型、字符串、列表、元组.............
-
Python 绝对是一门对面向对象编程 (OOP) 非常友好的语言，并且在很多方面都做得非常出色，让 OOP 的实践变得直观、简洁且强大。但正如所有技术一样，总有改进的空间。下面我将详细阐述 Python 在 OOP 方面的友好性，以及它可能存在的改进空间： Python 对面向对象编程的友好性体现.............
-
Python 语言的强制缩进，也就是“代码块”的定义完全依赖于缩进，而不是像许多其他语言那样使用花括号 `{}` 或 `begin/end` 等关键字，这是一个在开发者社区中长期存在争议的话题。 是否是“败笔”，很大程度上取决于个人的编程习惯、对代码可读性的侧重以及所处的开发环境。下面我将详细阐述支.............
-
Python 在变量的定义和赋值方面，确实与一些其他静态类型语言（例如 C++、Java）存在显著差异，这种差异常常被一些开发者看作是 Python 设计上的一个特点，但将其直接定义为“设计上的缺陷”则需要更深入的分析。要理解这个问题，我们首先需要明确 Python 在变量处理上的核心机制：Pyth.............
-
Python 的标准库和第三方库非常丰富，覆盖了从基础操作到复杂应用的各个领域。以下是对这些库的详细分类和介绍，帮助你了解它们的用途和使用场景： 一、Python 标准库（内置模块）Python 的标准库是随 Python 解释器一同安装的，无需额外安装即可使用。以下是常见的分类和示例： 1. 基础.............
-
Python 的“黑魔法”通常指的是一些不常见、非传统、或者需要深入理解 Python 底层机制才能掌握的技巧。它们能够让你写出更简洁、更强大、甚至有些“反直觉”的代码。这些“黑魔法”往往能极大地提高开发效率，但也可能降低代码的可读性，因此使用时需要权衡。下面我将尽量详细地介绍一些 Python 的.............
-
这个问题嘛，就像问“我该选择披萨还是汉堡？”一样，答案很大程度上取决于你想做什么，以及你对“前景好”的定义。Python和Go，说实话，现在都处于职业生涯的黄金时期，硬要说谁“更好”，实在是个见仁见智的事。不过，咱们可以把它们俩的特点拉出来遛遛，看看哪个更对你的胃口。Python：万金油，社区的拥抱.............
-
关于Python学习年龄这件事，我得说，这事儿挺灵活的，不像定个死规矩那样。我身边就有不少朋友，年龄跨度挺大的，都有自己的收获。如果你是还在学校的学生（小学、初中、高中）： 小学阶段： 我觉得这得看孩子的兴趣和家长引导了。如果孩子本身就对电脑操作、小游戏制作、或者一些逻辑思维的游戏比较感兴趣，那.............
-
在 Python 中，`with ... as ...` 语句主要用于资源管理，特别是文件的打开和关闭，或者其他需要进行清理操作的对象。它的核心目的是 确保无论代码块如何退出（正常结束、抛出异常），都会执行清理操作。如何理解 "跳出" `with...as` 语句？这里的“跳出”可以从两个层面来理解.............
-
没问题，我来给你详细讲讲如何在 Python 中实现“按分类转换列表”。这个需求很常见，比如我们有一个包含各种类型数据的列表，我们想根据数据的类型把它们分成不同的子列表。咱们就用一个实际的例子来讲解，这样更容易理解。假设我们有一个混合类型的列表，里面有数字、字符串、布尔值等等，我们想把它们分别归类到.............
-
在 Python 中，`len(x)` 并不是一个用于补零的函数，它实际上是用来获取序列（如字符串、列表、元组等）长度的。你提到的“利用 `len(x)` 补零”可能是在说，你需要根据某个序列的长度，将另一个序列（通常是数字或字符串）进行补零操作，使其达到一个特定的长度。核心概念：为什么是补零？补零.............
-
好的，我们来聊聊如何用Python实现列表（list）中所有元素两两相加并找出最大值这件事。这听起来是个挺基础的操作，但我们把它拆解开来，深入理解一下其中的逻辑和实现方式。问题拆解：首先，我们要明确这个任务包含几个关键步骤：1. 获取列表： 我们需要一个列表作为输入。2. 两两相加： 列表中的每.............
-
Python 正则替换：让每个匹配项拥有专属身份在日常的文本处理中，我们常常需要根据文本内容的规律性进行修改。Python的正则表达式提供了强大的模式匹配能力，而`re`模块的`re.sub()`函数则是进行替换操作的核心工具。然而，当我们需要将一个正则表达式匹配到的多个不同位置替换成不同的内容时，.............
本站所有内容均为互联网搜索引擎提供的公开搜索信息，本站不存储任何数据与内容，任何内容与数据均与本站无关，如有需要请联系相关搜索引擎包括但不限于百度，google,bing,sogou 等
© 2025 tinynews.org All Rights Reserved. 百科问答小站 版权所有