MK
摩柯社区 - 一个极简的技术知识社区
AI 面试

Python可变与不可变类型

2023-06-136.0k 阅读

Python中的基本数据类型概述

在深入探讨Python的可变与不可变类型之前，让我们先回顾一下Python中的基本数据类型。Python是一种动态类型语言，这意味着变量的类型在运行时确定，而不是在编译时。Python提供了多种基本数据类型，包括数值类型（整数、浮点数、复数）、字符串、布尔类型、序列类型（列表、元组）、映射类型（字典）和集合类型。这些数据类型在Python编程中扮演着基础的角色，理解它们的特性对于编写高效、正确的代码至关重要。

数值类型

  1. 整数（int）：Python中的整数类型可以表示任意大小的整数，不受机器字长的限制。例如：
a = 10
b = 123456789012345678901234567890
print(type(a))  
print(type(b))

在上述代码中，a和b都是整数类型，尽管b是一个非常大的整数，Python依然可以很好地处理。

  1. 浮点数（float）：用于表示带有小数部分的数字。浮点数在计算机中以二进制的形式存储，这可能会导致一些精度问题。例如：
c = 3.14
d = 0.1 + 0.2
print(c)  
print(d)

这里d的结果可能不是我们期望的0.3，而是0.30000000000000004，这是由于浮点数的二进制存储方式导致的精度损失。

  1. 复数（complex）：由实数部分和虚数部分组成，虚数部分以j或J结尾。例如：
e = 3 + 4j
print(type(e))

字符串（str）

字符串是由字符组成的不可变序列。在Python中，字符串可以用单引号、双引号或三引号括起来。例如：

s1 = 'Hello'
s2 = "World"
s3 = '''This is a 
multiline string'''
print(s1)
print(s2)
print(s3)

字符串支持多种操作，如索引、切片、拼接等，但由于其不可变性，这些操作通常会返回新的字符串对象。

布尔类型（bool）

布尔类型只有两个值：True和False，用于表示逻辑判断的结果。例如：

result1 = 5 > 3
result2 = 2 == 2
print(result1)  
print(result2)

序列类型

  1. 列表（list）：列表是一种有序的可变序列，可以包含不同类型的元素。例如：
my_list = [1, 'apple', 3.14, True]
print(my_list)

列表支持多种方法，如添加元素（append、extend）、删除元素（pop、remove）等，这些操作会直接修改列表对象。

  1. 元组（tuple）：元组是一种有序的不可变序列，与列表类似，但一旦创建就不能修改。例如：
my_tuple = (1, 'apple', 3.14)
print(my_tuple)

元组通常用于存储一组相关的数据，并且不希望这组数据被意外修改。

映射类型 - 字典（dict）

字典是一种无序的键值对集合，其中键必须是唯一且不可变的。例如：

my_dict = {'name': 'John', 'age': 30, 'city': 'New York'}
print(my_dict)

字典提供了快速的查找功能，通过键可以快速获取对应的值。

集合类型（set）

集合是一种无序的、不包含重复元素的集合。例如：

my_set = {1, 2, 3, 3}
print(my_set)

集合支持多种集合操作，如并集、交集、差集等。

不可变类型的本质

不可变类型的定义与特性

不可变类型是指一旦创建，其值就不能被修改的数据类型。在Python中，数值类型（整数、浮点数、复数）、字符串、元组和布尔类型都属于不可变类型。当对不可变类型的对象进行操作时，实际上是创建了一个新的对象。

以整数为例，当我们对一个整数进行加法操作时：

a = 5
b = a + 3
print(a)  
print(b)

这里a的值并没有改变，而是创建了一个新的整数对象8并赋值给b。同样，对于字符串：

s = 'hello'
new_s = s + ' world'
print(s)  
print(new_s)

s本身并没有改变，s + ' world'操作创建了一个新的字符串对象并赋值给new_s。

不可变类型的这种特性带来了一些好处。首先，它们是线程安全的，因为多个线程同时访问不可变对象不会导致数据竞争问题。其次，不可变对象可以作为字典的键，因为字典要求键是不可变的，这样可以保证字典的哈希表结构的一致性。

不可变类型的内存管理

在Python中，不可变对象在内存中的存储方式与它们的不可变性密切相关。当创建一个不可变对象时，Python会在内存中分配一块空间来存储该对象的值。如果再次创建一个具有相同值的不可变对象，Python可能会重用之前分配的内存空间，而不是重新分配。

例如，对于整数对象：

a = 10
b = 10
print(id(a))  
print(id(b))

在大多数情况下，a和b的id（即内存地址）是相同的，这表明它们共享相同的内存空间。这是因为Python对于一些常用的小整数对象（通常是 -5 到 256 之间的整数）进行了缓存，以提高内存使用效率。

对于字符串对象，也存在类似的机制，称为字符串驻留（string interning）。当创建两个内容相同的字符串时，Python可能会让它们共享同一个内存对象：

s1 = 'hello'
s2 = 'hello'
print(id(s1))  
print(id(s2))

然而，字符串驻留并不是对所有字符串都适用，例如包含空格或其他特殊字符的字符串可能不会驻留。

不可变类型的哈希值

不可变类型的对象具有一个重要的属性 - 哈希值（hash value）。哈希值是一个整数，用于在哈希表中快速定位对象。由于不可变类型的对象值不会改变，所以它们的哈希值在对象的生命周期内是固定的。

可以使用hash()函数来获取对象的哈希值。例如：

a = 10
print(hash(a))  

s = 'hello'
print(hash(s))

字典和集合等数据结构利用对象的哈希值来实现高效的查找和插入操作。因为不可变类型的对象具有固定的哈希值，所以它们可以作为字典的键或集合的元素。

可变类型的本质

可变类型的定义与特性

可变类型是指在创建后其值可以被修改的数据类型。在Python中，列表、字典和集合都属于可变类型。可变类型的对象可以通过其提供的方法来修改自身的内容，而不需要创建新的对象。

以列表为例，我们可以使用append方法向列表中添加元素：

my_list = [1, 2, 3]
my_list.append(4)
print(my_list)

这里my_list对象本身被修改了，而不是创建一个新的列表对象。同样，对于字典，我们可以添加或修改键值对：

my_dict = {'name': 'John'}
my_dict['age'] = 30
print(my_dict)

可变类型的这种灵活性在很多编程场景中非常有用，例如在处理需要动态更新的数据时。

可变类型的内存管理

可变类型的内存管理与不可变类型有所不同。当创建一个可变对象时，Python会分配一块内存来存储对象的头部信息（包括对象的类型、引用计数等）和对象的数据部分。当对象的内容发生变化时，这块内存空间可以被扩展或收缩，而不需要重新分配整个对象的内存。

例如，当我们向列表中添加元素时，列表对象会根据需要动态调整其内部的存储空间：

my_list = []
print(id(my_list))  
my_list.append(1)
print(id(my_list))

在这个过程中，my_list的id（内存地址）保持不变，说明列表对象在原有内存空间上进行了扩展。

然而，当列表的元素数量增长到一定程度，超过了当前分配的内存空间时，列表可能会重新分配一块更大的内存空间，并将原有的元素复制到新的空间中，这个过程称为列表的扩容。

可变类型的哈希问题

与不可变类型不同，可变类型的对象通常没有固定的哈希值。因为可变对象的值可以改变，如果其哈希值在值改变前后保持不变，可能会导致哈希表的不一致。因此，Python规定可变类型的对象不能作为字典的键或集合的元素，否则会引发TypeError。

例如：

my_list = [1, 2, 3]
try:
    my_dict = {my_list: 'value'}
except TypeError as e:
    print(e)

这里会抛出TypeError: unhashable type: 'list'错误，因为列表是可变类型，不具有可用于哈希表的固定哈希值。

可变与不可变类型的比较与应用场景

性能比较

  1. 不可变类型：由于不可变类型的对象在修改时会创建新的对象，所以在频繁修改操作的场景下，可能会导致较多的内存分配和垃圾回收开销。例如，在对字符串进行大量拼接操作时：
import time

start_time = time.time()
s = ''
for i in range(10000):
    s = s + str(i)
end_time = time.time()
print(f"Time taken: {end_time - start_time} seconds")

这种方式会创建大量的中间字符串对象，性能较低。

  1. 可变类型：可变类型在修改自身时不需要创建新的对象，因此在需要频繁修改数据的场景下，性能通常更好。例如，使用列表来存储和修改数据：
import time

start_time = time.time()
my_list = []
for i in range(10000):
    my_list.append(i)
end_time = time.time()
print(f"Time taken: {end_time - start_time} seconds")

这里列表通过append方法直接在原有对象上添加元素，避免了大量的内存分配和对象创建，性能更高。

数据安全性

  1. 不可变类型：不可变类型的数据一旦创建就不能被修改，这在多线程编程或数据共享的场景下提供了更高的数据安全性。例如，在多个线程同时访问一个不可变对象时，不需要担心数据被其他线程意外修改。
import threading

a = 10


def thread_function():
    global a
    # 这里无法修改a的值，因为a是不可变的整数类型
    pass


thread = threading.Thread(target=thread_function)
thread.start()
thread.join()
print(a)
  1. 可变类型：可变类型的数据可以被修改，这在某些情况下可能会带来数据安全隐患。例如，在多个函数或模块共享一个可变对象时，如果一个地方对其进行了修改，可能会影响到其他依赖该对象的部分。
my_list = [1, 2, 3]


def modify_list(lst):
    lst.append(4)


modify_list(my_list)
print(my_list)

这里modify_list函数修改了共享的列表对象my_list，如果在其他地方依赖my_list的原有状态，可能会导致错误。

应用场景

  1. 不可变类型：

    • 数据共享与传递：当需要在不同的模块或函数之间传递数据，并且不希望数据被意外修改时，使用不可变类型。例如，函数的参数传递中，如果希望参数的值在函数内部保持不变，可以使用不可变类型。
    • 哈希表的键：由于不可变类型具有固定的哈希值，适合作为字典的键或集合的元素，用于高效的查找和去重。
    • 配置数据：对于一些配置信息，如数据库连接字符串、系统参数等，使用不可变类型可以确保其值在程序运行过程中不会被意外修改。

  2. 可变类型：

    • 动态数据结构：在需要动态添加、删除或修改元素的数据结构中，如队列、栈等，使用可变类型更为合适。列表可以方便地实现栈和队列的操作。
    • 数据缓存：当需要缓存一些动态变化的数据时，可变类型的字典可以用于存储缓存数据，并根据需要进行更新。
    • 数据处理流水线：在数据处理的流水线中，数据通常需要经过多个步骤的处理和修改，可变类型可以方便地在各个步骤中传递和修改数据。

深入理解可变与不可变类型的嵌套

可变类型与不可变类型的嵌套结构

在实际编程中，我们经常会遇到可变类型与不可变类型相互嵌套的情况。例如，一个列表中可能包含整数、字符串等不可变类型的元素，也可能包含其他列表、字典等可变类型的元素。同样，字典的键可以是不可变类型，而值可以是可变或不可变类型。

以下是一些示例：

# 列表中包含不可变和可变类型元素
my_list = [1, 'hello', [2, 3], {'name': 'John'}]

# 字典中键为不可变类型，值为可变和不可变类型
my_dict = {'key1': 10, 'key2': [1, 2, 3], 'key3': 'world'}

嵌套结构中的修改操作

当对嵌套结构进行修改操作时，需要特别注意可变与不可变类型的特性。对于包含不可变类型元素的可变对象，修改操作通常不会影响到不可变元素本身，而是修改可变对象的结构。

例如：

my_list = [1, 2, 3]
outer_list = [my_list, 4, 5]
my_list.append(4)
print(outer_list)

这里outer_list中的my_list是一个可变对象，当对my_list进行append操作时，outer_list中的my_list也会受到影响，因为它们指向同一个列表对象。

然而，对于包含可变类型元素的不可变对象（如元组中包含列表），虽然元组本身不可变，但可以修改其内部可变类型元素的内容：

my_tuple = ([1, 2], 3)
my_tuple[0].append(3)
print(my_tuple)

这里虽然不能直接修改元组my_tuple，但可以修改其内部列表的内容。

嵌套结构的复制与引用

在处理嵌套结构时，复制和引用的概念也非常重要。当复制一个包含可变对象的对象时，如果只是进行浅复制，可能会导致新对象和原对象共享内部的可变对象，从而引发意外的修改。

例如，使用list.copy()方法进行浅复制：

original_list = [[1, 2], 3]
copied_list = original_list.copy()
original_list[0].append(3)
print(copied_list)

这里copied_list和original_list共享内部的列表[1, 2]，当修改original_list中内部列表时，copied_list也会受到影响。

要避免这种情况，可以使用深复制，copy模块中的deepcopy函数可以实现深复制：

import copy

original_list = [[1, 2], 3]
deep_copied_list = copy.deepcopy(original_list)
original_list[0].append(3)
print(deep_copied_list)

这样deep_copied_list和original_list就不会共享内部的可变对象，修改original_list不会影响到deep_copied_list。

总结可变与不可变类型对Python编程的影响

编程习惯与代码风格

理解可变与不可变类型的特性会影响我们的编程习惯和代码风格。对于不可变类型，由于其不可修改的特性，我们在编写代码时通常会更注重创建新对象的操作，并且在传递不可变对象作为参数时，可以放心地认为其值不会在函数内部被修改。

而对于可变类型，我们需要更加谨慎地处理对其的修改操作，避免在不同的代码部分之间产生意外的副作用。在函数参数传递中，如果传递的是可变对象，函数内部对其的修改可能会影响到函数外部的对象，这就需要在编写函数时明确告知调用者该函数会修改传入的可变对象。

调试与错误排查

在调试代码时，可变与不可变类型的特性也会对错误排查产生影响。如果遇到数据意外被修改的情况，首先要检查涉及的对象是可变还是不可变类型。对于可变类型，需要追踪代码中对其进行修改的地方，可能是在同一个函数中，也可能是在其他函数通过共享对象进行的修改。

而对于不可变类型，如果发现其值似乎发生了变化，很可能是误解了代码逻辑，因为不可变类型本身不会被修改，可能是创建了新的对象而导致了混淆。

代码优化与性能提升

从性能角度来看，合理使用可变与不可变类型可以提升代码的性能。在需要频繁修改数据的场景下，选择可变类型可以减少内存分配和对象创建的开销。但在数据共享和传递的场景中，如果过多使用可变类型可能会带来数据安全问题，需要在性能和数据安全之间进行权衡。

例如，在处理大量字符串拼接时，可以使用io.StringIO或str.join方法来避免频繁创建新的字符串对象，提高性能。而在多线程编程中，使用不可变类型可以减少线程同步的开销，提高程序的并发性能。

总之，深入理解Python的可变与不可变类型对于编写高质量、高效、安全的Python代码至关重要。通过合理运用它们的特性，可以更好地解决各种编程问题，并提升代码的整体质量和性能。