本文详细解析了 Python 三个核心内置函数 len()、list() 和 locals()。len() 用于获取对象长度，支持序列和集合等类型，常用于数据验证和边界检查；list() 用于从可迭代对象创建新列表，适用于数据转换和处理场景；locals() 返回局部命名空间字典，可用于调试和动态编程。文章提供了基础用法代码示例及实际应用类封装，并给出了安全使用建议、版本兼容性提醒及最佳实践，帮助开发者高效利用这些函数提升代码质量。
len() 函数返回对象的长度（元素个数），支持序列和集合等多种数据类型。
# 序列类型长度计算
string = "Hello World"
print(f"字符串长度：{len(string)}") # 输出：11
list_data = [1, 2, 3, 4, 5]
print(f"列表长度：{len(list_data)}") # 输出：5
tuple_data = (10, 20, 30)
print(f"元组长度：{len(tuple_data)}") # 输出：3
# 集合类型长度计算
set_data = {1, 2, 3, 2, 1} # 去重后
print(f"集合长度：{len(set_data)}") # 输出：3
dict_data = {'a': 1, 'b': 2, 'c': 3}
print(f"字典长度：{len(dict_data)}") # 输出：3
# 范围对象
range_obj = range(1, 10)
print(f"范围对象长度：{len(range_obj)}") # 输出：9
class DataValidator:
@staticmethod
def validate_input_length(data, min_len=0, max_len=None):
"""验证输入数据长度"""
data_len = len(data)
if data_len < min_len:
raise ValueError(f"数据长度不能小于{min_len}")
if max_len is not None and data_len > max_len:
raise ValueError(f"数据长度不能超过{max_len}")
return True
@staticmethod
def chunk_data(data, chunk_size):
"""将数据分块"""
if len(data) == 0:
return []
chunks = []
for i in range(0, len(data), chunk_size):
chunk = data[i:i + chunk_size]
chunks.append(chunk)
return chunks
@staticmethod
def compare_structures(struct1, struct2):
"""比较两个数据结构的长度"""
len1 = len(struct1) if hasattr(struct1, '__len__') else 'N/A'
len2 = (struct2) (struct2, )
{
: len1,
: len2,
: len1 == len2 (len1, ) (len2, )
}
validator = DataValidator()
:
validator.validate_input_length(, min_len=, max_len=)
()
ValueError e:
()
data = (())
chunks = validator.chunk_data(data, chunk_size=)
()
list1 = [, , ]
dict1 = {: , : }
result = validator.compare_structures(list1, dict1)
()
list() 函数从可迭代对象创建新的列表，是 Python 中最常用的序列类型。
# 从字符串创建（字符列表）
chars = list("hello")
print(f"字符串转列表：{chars}") # 输出：['h', 'e', 'l', 'l', 'o']
# 从元组创建
tuple_data = (1, 2, 3)
list_from_tuple = list(tuple_data)
print(f"元组转列表：{list_from_tuple}") # 输出：[1, 2, 3]
# 从范围对象创建
numbers = list(range(5))
print(f"范围转列表：{numbers}") # 输出：[0, 1, 2, 3, 4]
# 从集合创建（顺序可能不同）
set_data = {3, 1, 4, 2}
list_from_set = list(set_data)
print(f"集合转列表：{list_from_set}") # 输出：[1, 2, 3, 4]（顺序可能变化）
# 空列表
empty_list = list()
print(f"空列表：{empty_list}") # 输出：[]
# 从字典创建（只获取键）
dict_data = {'a': 1, 'b': 2}
keys_list = list(dict_data)
print(f"字典键列表：{keys_list}") # 输出：['a', 'b']
class ListProcessor:
@staticmethod
def flatten_nested_lists(nested_list):
"""展平嵌套列表"""
result = []
for item in nested_list:
if isinstance(item, list):
result.extend(ListProcessor.flatten_nested_lists(item))
else:
result.append(item)
return result
@staticmethod
def remove_duplicates_preserve_order(sequence):
"""去重并保持顺序"""
seen = set()
return [x for x in sequence if not (x in seen or seen.add(x))]
@staticmethod
def batch_process(iterable, batch_size):
"""批量处理数据"""
items = list(iterable) # 确保是可迭代的
batches = []
for i in range(0, len(items), batch_size):
batch = items[i:i + batch_size]
batches.append(batch)
return batches
@staticmethod
def create_index_map(data):
"""创建值到索引的映射"""
index_map = {}
for idx, value in ((data)):
value index_map:
index_map[value] = []
index_map[value].append(idx)
index_map
processor = ListProcessor()
nested = [[, ], [, [, ]], ]
flat = processor.flatten_nested_lists(nested)
()
data_with_duplicates = [, , , , , , ]
unique_ordered = processor.remove_duplicates_preserve_order(data_with_duplicates)
()
large_data = ()
batches = processor.batch_process(large_data, batch_size=)
()
()
text =
index_map = processor.create_index_map(text)
()
locals() 函数返回当前局部符号表的映射对象，反映当前作用域的变量状态。
def demonstrate_locals():
"""演示 locals() 函数的基本用法"""
x = 10
y = "hello"
z = [1, 2, 3]
# 获取局部变量字典
local_vars = locals()
print("局部变量:")
for var_name, var_value in local_vars.items():
print(f" {var_name}: {var_value}")
# 修改局部变量
local_vars['x'] = 100
local_vars['new_var'] = "动态添加"
print(f"修改后 x 的值：{x}") # 输出：100
print(f"新变量：{new_var}") # 输出：动态添加
return local_vars
# 函数调用
local_dict = demonstrate_locals()
print(f"返回的局部字典：{local_dict}")
# 模块级别的 locals()（与 globals() 相同）
module_locals = locals()
module_globals = globals()
print(f"模块级别 locals 和 globals 相同：{module_locals is module_globals}") # 输出：True
class DebugHelper:
def __init__(self):
self.snapshots = {}
def take_snapshot(self, snapshot_name):
"""拍摄当前局部状态快照"""
current_locals = locals().copy()
# 移除 self 参数
current_locals.pop('self', None)
self.snapshots[snapshot_name] = current_locals
return current_locals
def compare_snapshots(self, snap1_name, snap2_name):
"""比较两个快照的差异"""
snap1 = self.snapshots.get(snap1_name, {})
snap2 = self.snapshots.get(snap2_name, {})
added = {k: v for k, v in snap2.items() if k not in snap1}
removed = {k: v for k, v in snap1.items() if k not in snap2}
changed = {}
for k in set(snap1.keys()) & set(snap2.keys()):
if snap1[k] != snap2[k]:
changed[k] = (snap1[k], snap2[k])
return {'added': added, 'removed': removed, 'changed': changed}
def dynamic_variable_management(self, **kwargs):
"""动态变量管理"""
current_locals = locals()
(, current_locals)
key, value kwargs.items():
()[key] = value
()
():
debugger = DebugHelper()
a =
b =
debugger.take_snapshot()
a =
c =
debugger.take_snapshot()
differences = debugger.compare_snapshots(, )
(, differences)
debugger.dynamic_variable_management(x=, y=, z=)
test_function()
():
external_var =
result = [().get() _ ()]
()
demonstrate_comprehension_locals()
class SafeVariableManager:
def __init__(self):
self._protected_vars = {'self', '_protected_vars'}
def get_public_variables(self):
"""获取公有变量（不包含保护变量）"""
current_locals = locals()
public_vars = {}
for var_name, var_value in current_locals.items():
if not var_name.startswith('_') or var_name in self._protected_vars:
public_vars[var_name] = var_value
return public_vars
def cleanup_temporary_vars(self):
"""清理临时变量"""
current_locals = locals()
vars_to_remove = []
for var_name in current_locals:
if var_name.startswith('_temp_'):
vars_to_remove.append(var_name)
# 注意：在实际函数中，不能直接通过 locals() 删除变量
# 这里返回需要删除的变量名列表
return vars_to_remove
def create_variable_report(self):
"""创建变量状态报告"""
current_locals = locals()
report = {
'total_variables': len(current_locals),
'variable_types': {},
'variable_details': []
}
for var_name, var_value current_locals.items():
var_type = (var_value).__name__
var_type report[]:
report[][var_type] =
report[][var_type] +=
report[].append({
: var_name,
: var_type,
: ((var_value)) (var_value, ) ,
: (var_value)
})
report
():
manager = SafeVariableManager()
normal_var =
_temp_data =
_protected_var =
public_vars = manager.get_public_variables()
(, public_vars)
report = manager.create_variable_report()
(, report)
temp_vars = manager.cleanup_temporary_vars()
(, temp_vars)
demonstrate_safe_management()
def advanced_data_analysis(data_sequence):
"""高级数据分析组合使用多个函数"""
# 使用 list() 确保数据是可迭代的
data_list = list(data_sequence)
# 使用 len() 获取基本信息
data_length = len(data_list)
print(f"数据长度：{data_length}")
# 使用 locals() 记录分析状态
analysis_state = locals().copy()
if data_length > 0:
# 基本统计
unique_elements = list(set(data_list))
unique_count = len(unique_elements)
analysis_state.update({'unique_count': unique_count, 'duplicate_count': data_length - unique_count, 'unique_elements': unique_elements})
# 动态添加分析结果
if 'unique_count' in analysis_state:
duplication_rate = analysis_state['duplicate_count'] / data_length
analysis_state['duplication_rate'] = round(duplication_rate, 2)
return analysis_state
# 使用示例
test_data = [1, 2, 2, 3, 3, 3, 4, 4, 4, 4]
result = advanced_data_analysis(test_data)
print("数据分析结果:")
for key, value in result.items():
if key.startswith() key != :
()
():
current_locals = ()
function_definitions = [
(, x, y: x + y),
(, x, y: x * y),
(, x, y: x ** y)
]
func_name, func function_definitions:
current_locals[func_name] = func
()
current_locals:
result = current_locals[](, )
()
dynamic_function_builder()
通过本文的详细解析，我们深入了解了 Python 中三个重要的内置函数：
关键知识点总结：
len(object) 返回对象的元素个数，支持大多数容器类型list(iterable) 从可迭代对象创建新列表，是常用的序列转换函数locals() 返回当前局部命名空间的字典，但在不同作用域中行为有差异版本兼容性提醒：
locals() 行为有变化（PEP 709）locals() 语义更加明确（PEP 667）len() 可能引发 OverflowError实用场景推荐：
最佳实践建议：
len() 检查大小len() 时捕获 OverflowError安全使用注意事项：
locals() 返回的字典可能不会影响实际变量（在函数作用域中）list() 转换len() 前先验证数据类型进阶学习方向：
__len__() 特殊方法的自定义实现inspect 模块更强大的内省功能这三个函数虽然基础，但它们是 Python 编程的基石。合理使用它们可以让代码更加简洁、清晰，特别是在数据处理、调试和元编程场景中。从简单的长度检查到复杂的动态编程，掌握这些函数将显著提升你的 Python 编程能力。
微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 zeeklog
使用加密算法（如AES、TripleDES、Rabbit或RC4）加密和解密文本明文。 在线工具，加密/解密文本在线工具，online
生成新的随机RSA私钥和公钥pem证书。 在线工具，RSA密钥对生成器在线工具，online
基于 Mermaid.js 实时预览流程图、时序图等图表，支持源码编辑与即时渲染。 在线工具，Mermaid 预览与可视化编辑在线工具，online
解析常见 curl 参数并生成 fetch、axios、PHP curl 或 Python requests 示例代码。 在线工具，curl 转代码在线工具，online
将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具，Base64 字符串编码/解码在线工具，online
将字符串、文件或图像转换为其 Base64 表示形式。 在线工具，Base64 文件转换器在线工具，online