Python 四个重要内置函数：filter() 用于数据过滤，float() 用于数值转换，format() 用于字符串格式化，frozenset() 用于创建不可变集合。文章包含基础用法、实际应用案例（如数据清洗、报表生成）、版本兼容性说明及最佳实践建议。通过代码示例展示了各函数的特性，如 filter 的惰性求值、float 的科学计数法支持、format 的对齐选项以及 frozenset 作为字典键的能力。旨在帮助开发者掌握这些工具以提升代码质量和效率。
filter() 函数使用指定函数来过滤可迭代对象中的元素，只保留函数返回真值的元素。
# 基础过滤示例
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# 过滤偶数
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
print(f"偶数：{even_numbers}")
# 输出：[2, 4, 6, 8, 10]
# 过滤 None 值
mixed_data = [0, 1, False, True, None, "hello", "", 3.14]
truthy_values = list(filter(None, mixed_data))
print(f"真值元素：{truthy_values}")
# 输出：[1, True, 'hello', 3.14]
# 等价生成器表达式
# filter(function, iterable) 相当于:
# (item for item in iterable if function(item)) # 当 function 不是 None 时
# (item for item in iterable if item) # 当 function 是 None 时
class DataCleaner:
@staticmethod
def remove_outliers(data, threshold_func):
"""移除异常值"""
return list(filter(threshold_func, data))
@staticmethod
def validate_emails(email_list):
"""验证邮箱格式（简单版本）"""
def is_valid_email(email):
return isinstance(email, str) and '@' in email and '.' in email.split('@')[-1]
return list(filter(is_valid_email, email_list))
@staticmethod
def filter_by_type(data, target_type):
"""按类型过滤数据"""
return list(filter(lambda x: isinstance(x, target_type), data))
# 使用示例
cleaner = DataCleaner()
# 移除数值异常值
numbers = [10, 15, 100, 12, 8, 200, 14]
normal_numbers = cleaner.remove_outliers(numbers, lambda x: x < 50)
print(f"正常数值：{normal_numbers}")
# 邮箱验证
emails = ["[email protected]", "invalid", "test@domain", "[email protected]"]
valid_emails = cleaner.validate_emails(emails)
print(f"有效邮箱：{valid_emails}")
# 类型过滤
mixed_data = [1, "hello", 3.14, [1, 2], "world", 42]
strings_only = cleaner.filter_by_type(mixed_data, str)
print(f"仅字符串：{strings_only}")
float() 函数从数字或字符串创建浮点数，支持多种输入格式。
# 从数字创建
print(f"从整数创建：{float(42)}") # 输出：42.0
print(f"从浮点数创建：{float(3.14)}") # 输出：3.14
# 从字符串创建
print(f"带符号字符串：{float('+1.23')}") # 输出：1.23
print(f"带空格字符串：{float(' -12345\n')}") # 输出：-12345.0
print(f"科学计数法：{float('1e-003')}") # 输出：0.001
print(f"大写科学计数法：{float('+1E6')}") # 输出：1000000.0
print(f"无穷大：{float('-Infinity')}") # 输出：-inf
# 特殊值
print(f"NaN: {float('nan')}") # 输出：nan
print(f"无穷大：{float('inf')}") # 输出：inf
# 无参数调用
print()
class SafeFloatConverter:
@staticmethod
def safe_float_conversion(value, default=0.0):
"""安全转换为浮点数"""
try:
return float(value)
except (ValueError, TypeError):
return default
@staticmethod
def parse_numeric_strings(string_list):
"""从字符串列表中解析数值"""
def try_convert(s):
try:
return float(s)
except (ValueError, TypeError):
return None
converted = filter(lambda x: x is not None, map(try_convert, string_list))
return list(converted)
@staticmethod
def validate_float_range(value, min_val=None, max_val=None):
"""验证浮点数范围"""
try:
num = float(value)
if min_val is not None and num < min_val:
return
max_val num > max_val:
(ValueError, TypeError):
converter = SafeFloatConverter()
test_values = [, , , , ]
safe_results = [converter.safe_float_conversion(v) v test_values]
()
numeric_strings = [, , , , ]
parsed_numbers = converter.parse_numeric_strings(numeric_strings)
()
values_to_check = [, , , , ]
val values_to_check:
is_valid = converter.validate_float_range(val, min_val=, max_val=)
()
format() 函数将值转换为格式化字符串，支持丰富的格式化选项。
# 基本格式化
print(f"整数格式化：{format(12345, ',')}") # 输出：12,345
print(f"浮点数格式化：{format(3.14159, '.2f')}") # 输出：3.14
print(f"百分比格式化：{format(0.256, '.1%')}") # 输出：25.6%
# 对齐和填充
print(f"右对齐：{format('hello', '>10')}") # 输出：' hello'
print(f"左对齐：{format('world', '<10')}") # 输出：'world '
print(f"居中对齐：{format('test', '^10')}") # 输出：' test '
print(f"零填充：{format(42, '05d')}") # 输出：00042
# 数字格式化
print(f"十六进制：{format(255, 'x')}") # 输出：ff
()
()
value =
()
()
class ReportFormatter:
@staticmethod
def format_currency(amount, currency_symbol='¥'):
"""格式化货币金额"""
return format(amount, f'{currency_symbol},.2f')
@staticmethod
def format_percentage_data(values):
"""格式化百分比数据"""
return [format(val, '.2%') for val in values]
@staticmethod
def create_aligned_table(data, column_widths):
"""创建对齐的表格数据"""
formatted_rows = []
for row in data:
formatted_cells = []
for i, cell in enumerate(row):
width = column_widths[i]
# 根据内容类型选择格式化方式
if isinstance(cell, (int, float)):
formatted = format(cell, f'>{width}')
else:
formatted = format(str(cell), f'<{width}')
formatted_cells.append(formatted)
formatted_rows.append(' '.join(formatted_cells))
return formatted_rows
():
[(num, ) num numbers]
formatter = ReportFormatter()
amounts = [, , , ]
currency_formatted = [formatter.format_currency(amt) amt amounts]
()
percentages = [, , ]
percent_formatted = formatter.format_percentage_data(percentages)
()
table_data = [[, , ], [, , ], [, , ], [, , ]]
aligned_table = formatter.create_aligned_table(table_data, [, , ])
()
row aligned_table:
(row)
scientific_data = [, , ]
sci_formatted = formatter.format_scientific_data(scientific_data)
()
frozenset() 函数创建不可变的集合对象，适合作为字典键或集合元素。
# 从可迭代对象创建
fset1 = frozenset([1, 2, 3, 4, 5])
print(f"从列表创建：{fset1}") # 输出：frozenset({1, 2, 3, 4, 5})
# 从字符串创建
fset2 = frozenset("hello")
print(f"从字符串创建：{fset2}") # 输出：frozenset({'h', 'e', 'l', 'o'})
# 从范围创建
fset3 = frozenset(range(5))
print(f"从范围创建：{fset3}") # 输出：frozenset({0, 1, 2, 3, 4})
# 空集合
empty_fset = frozenset()
print(f"空集合：{empty_fset}") # 输出：frozenset()
# 作为字典键
dict_with_frozenset = {
frozenset([1, 2, 3]): "集合 1",
frozenset([4, 5, 6]): "集合 2"
}
print(f"字典键示例：{dict_with_frozenset}")
class SetOperations:
@staticmethod
def create_immutable_lookup_table(data_list):
"""创建不可变查找表"""
unique_items = frozenset(data_list)
return {item: index for index, item in enumerate(unique_items)}
@staticmethod
def find_common_elements(*sequences):
"""查找多个序列的共同元素"""
if not sequences:
return frozenset()
# 将所有序列转换为 frozenset 并求交集
sets = [frozenset(seq) for seq in sequences]
common = sets[0]
for s in sets[1:]:
common = common.intersection(s)
return common
@staticmethod
def create_immutable_config(config_dict):
"""创建不可变配置"""
frozen_config = {}
for key, value in config_dict.items():
if isinstance(value, (list, set)):
frozen_config[key] = frozenset(value)
else:
frozen_config[key] = value
return frozen_config
@staticmethod
def set_operations_example():
A = ([, , , , ])
B = ([, , , , ])
()
()
()
()
()
()
operations = SetOperations()
data = [, , , , ]
lookup_table = operations.create_immutable_lookup_table(data)
()
list1 = [, , , , ]
list2 = [, , , , ]
list3 = [, , , , ]
common = operations.find_common_elements(list1, list2, list3)
()
config = {
: [, , ],
: {, },
:
}
frozen_config = operations.create_immutable_config(config)
()
operations.set_operations_example()
filter() 函数
float() 函数的版本变更
# 3.6 版本：支持数字分组下划线
print(f"分组数字：{float('1_000_000.5')}") # 输出：1000000.5
# 3.7 版本：参数变为仅限位置形参
# float(number=0.0) -> 现在必须使用位置参数
# 3.8 版本：__float__() 未定义时回退至 __index__()
class CustomNumber:
def __index__(self):
return 42
custom_num = CustomNumber()
print(f"回退转换：{float(custom_num)}") # 输出：42.0
format() 函数的版本变更
# 3.4 版本：当 format_spec 不是空字符串时，object().__format__(format_spec) 会触发 TypeError
try:
result = object().__format__('s')
print(f"对象格式化：{result}")
except TypeError as e:
print(f"格式化错误：{e}")
frozenset() 函数
class BestPractices:
@staticmethod
def safe_data_processing():
"""安全数据处理示例"""
# 1. filter() 与异常处理结合
def safe_filter_function(func, iterable):
def wrapper(item):
try:
return func(item)
except Exception:
return False
return filter(wrapper, iterable)
# 2. float() 转换的最佳实践
def robust_float_conversion(value):
"""健壮的浮点数转换"""
if value is None:
return 0.0
try:
return float(value)
except (ValueError, TypeError):
# 尝试清理字符串
if isinstance(value, str):
cleaned = value.strip()
# 移除货币符号等非数字字符
import re
cleaned = re.sub(r'[^Ù.-]', '', cleaned)
try:
return float(cleaned)
except ValueError:
():
:
(value, format_spec)
(ValueError, TypeError):
(value)
{
: safe_filter_function,
: robust_float_conversion,
: safe_format
}
practices = BestPractices()
tools = practices.safe_data_processing()
data = [, , , , ]
safe_result = (tools[]( x: x > , data))
()
test_values = [, , , ]
converted = [tools[](v) v test_values]
()
format_test = [, , ]
formatted = [tools[](v, ) v format_test]
()
def performance_tips():
"""性能优化建议"""
# 1. 使用 filter() 代替列表推导式（当处理大数据时）
large_data = range(1000000)
# 更高效的方式（惰性求值）
filtered_data = filter(lambda x: x % 2 == 0, large_data)
# 2. 避免不必要的 float() 调用
def efficient_numeric_processing(numbers):
# 先检查类型，避免不必要的转换
processed = []
for num in numbers:
if isinstance(num, (int, float)):
processed.append(num * 1.1)
else:
try:
processed.append(float(num) * 1.1)
except ValueError:
processed.append(0.0)
return processed
# 3. frozenset() 用于快速查找
large_set = frozenset(range(1000000))
# 查找操作非常快速
print(f"查找性能测试：{999999 in large_set}")
return "性能优化技巧演示完成"
performance_tips()
通过本文的详细解析，我们深入了解了四个重要的 Python 内置函数：
关键知识点总结：
filter(func, iterable) 惰性过滤元素，支持 None 函数float(x) 从数字或字符串创建浮点数，支持科学计数法format(value, spec) 灵活格式化值，支持对齐、精度等选项frozenset(iterable) 创建不可变集合，适合作为字典键版本兼容性提醒：
实用场景推荐：
安全使用建议：
进阶学习方向：
这些内置函数是 Python 编程的基础工具，掌握它们的特性和最佳实践将显著提升代码质量和开发效率。
微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 zeeklog
使用加密算法（如AES、TripleDES、Rabbit或RC4）加密和解密文本明文。 在线工具，加密/解密文本在线工具，online
解析常见 curl 参数并生成 fetch、axios、PHP curl 或 Python requests 示例代码。 在线工具，curl 转代码在线工具，online
将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具，Base64 字符串编码/解码在线工具，online
将字符串、文件或图像转换为其 Base64 表示形式。 在线工具，Base64 文件转换器在线工具，online
将 Markdown（GFM）转为 HTML 片段，浏览器内 marked 解析；与 HTML转Markdown 互为补充。 在线工具，Markdown转HTML在线工具，online
将 HTML 片段转为 GitHub Flavored Markdown，支持标题、列表、链接、代码块与表格等；浏览器内处理，可链接预填。 在线工具，HTML转Markdown在线工具，online