Python 四大内置函数详解：filter、float、format、frozenset

Python 四大内置函数详解：filter、float、format、frozenset | 极客日志

# 基础过滤示例
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}")

# 从数字创建
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(f"无参数：{float()}")  # 输出：0.0

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 False
            if max_val is not None and num > max_val:
                return False
            return True
        except (ValueError, TypeError):
            return False

# 使用示例
converter = SafeFloatConverter()
# 安全转换
test_values = ["3.14", "invalid", "99.9", None, "1e2"]
safe_results = [converter.safe_float_conversion(v) for v in test_values]
print(f"安全转换结果：{safe_results}")

# 数值字符串解析
numeric_strings = ["123", "45.67", "1e-3", "not_a_number", "-999"]
parsed_numbers = converter.parse_numeric_strings(numeric_strings)
print(f"解析后的数值：{parsed_numbers}")

# 范围验证
values_to_check = [10, "25.5", "1000", "-5", "invalid"]
for val in values_to_check:
    is_valid = converter.validate_float_range(val, min_val=0, max_val=100)
    print(f"{val} 在 0-100 范围内：{is_valid}")

# 基本格式化
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
print(f"八进制：{format(64, 'o')}")  # 输出：100
print(f"二进制：{format(10, 'b')}")  # 输出：1010

# 与 str() 的比较
value = 3.1415926
print(f"str() 版本：{str(value)}")  # 输出：3.1415926
print(f"format() 版本：{format(value, '.3f')}")  # 输出：3.142

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

    @staticmethod
    def format_scientific_data(numbers, precision=3):
        """格式化科学数据"""
        return [format(num, f'.{precision}e') for num in numbers]

# 使用示例
formatter = ReportFormatter()
# 货币格式化
amounts = [1234.56, 7890.12, 45.67, 1000000]
currency_formatted = [formatter.format_currency(amt) for amt in amounts]
print(f"货币格式化：{currency_formatted}")

# 百分比数据
percentages = [0.1234, 0.5678, 0.9876]
percent_formatted = formatter.format_percentage_data(percentages)
print(f"百分比数据：{percent_formatted}")

# 表格对齐
table_data = [["产品", "销量", "增长率"], ["手机", 1500, 0.25], ["电脑", 800, 0.15], ["平板", 1200, 0.30]]
aligned_table = formatter.create_aligned_table(table_data, [10, 8, 10])
print("对齐表格:")
for row in aligned_table:
    print(row)

# 科学数据
scientific_data = [1234567, 0.000123, 987654321]
sci_formatted = formatter.format_scientific_data(scientific_data)
print(f"科学计数法：{sci_formatted}")

# 从可迭代对象创建
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 = frozenset([1, 2, 3, 4, 5])
        B = frozenset([4, 5, 6, 7, 8])
        print(f"集合 A: {A}")
        print(f"集合 B: {B}")
        print(f"并集：{A.union(B)}")
        print(f"交集：{A.intersection(B)}")
        print(f"差集 (A-B): {A.difference(B)}")
        print(f"对称差集：{A.symmetric_difference(B)}")

# 使用示例
operations = SetOperations()
# 创建查找表
data = ["apple", "banana", "apple", "cherry", "banana"]
lookup_table = operations.create_immutable_lookup_table(data)
print(f"查找表：{lookup_table}")

# 查找共同元素
list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]
list3 = [5, 6, 7, 8, 9]
common = operations.find_common_elements(list1, list2, list3)
print(f"共同元素：{common}")

# 不可变配置
config = {
    "allowed_users": ["user1", "user2", "user3"],
    "permissions": {"read", "write"},
    "max_connections": 100
}
frozen_config = operations.create_immutable_config(config)
print(f"不可变配置：{frozen_config}")

# 集合运算演示
operations.set_operations_example()

# 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

# 3.4 版本：当 format_spec 不是空字符串时，object().__format__(format_spec) 会触发 TypeError
try:
    result = object().__format__('s')
    print(f"对象格式化：{result}")
except TypeError as e:
    print(f"格式化错误：{e}")

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:
                        pass
            return 0.0

        # 3. format() 的类型检查
        def safe_format(value, format_spec):
            """安全的格式化函数"""
            try:
                return format(value, format_spec)
            except (ValueError, TypeError):
                return str(value)

        return {
            'safe_filter': safe_filter_function,
            'robust_float': robust_float_conversion,
            'safe_format': safe_format
        }

# 使用示例
practices = BestPractices()
tools = practices.safe_data_processing()

# 测试安全过滤
data = [1, 2, "3", "invalid", 5]
safe_result = list(tools['safe_filter'](lambda x: x > 2, data))
print(f"安全过滤结果：{safe_result}")

# 测试健壮转换
test_values = ["123.45", "$99.99", "1,000.50", "invalid"]
converted = [tools['robust_float'](v) for v in test_values]
print(f"健壮转换结果：{converted}")

# 测试安全格式化
format_test = [1000, "hello", 3.14159]
formatted = [tools['safe_format'](v, ',.2f') for v in format_test]
print(f"安全格式化：{formatted}")

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、float、format、frozenset

一、filter()：数据过滤的"智能筛子"

1.1 基础用法：基于条件过滤元素

1.2 实际应用：数据清洗和验证

二、float()：数值转换的"精确天平"

2.1 基础用法：创建浮点数

2.2 实际应用：安全数值转换和数据处理

三、format()：字符串格式化的"魔术师"

3.1 基础用法：值格式化

3.2 实际应用：自定义格式化和报表生成

四、frozenset()：不可变集合的"保险箱"

4.1 基础用法：创建不可变集合

4.2 实际应用：数据去重和集合运算

五、版本变更与兼容性说明

5.1 各函数的版本演进

六、最佳实践与实用技巧

6.1 安全使用建议

6.2 性能优化技巧

七、总结与实用建议

更多推荐文章

相关免费在线工具

Python 四大内置函数详解：filter、float、format、frozenset

一、filter()：数据过滤的"智能筛子"

1.1 基础用法：基于条件过滤元素

1.2 实际应用：数据清洗和验证

二、float()：数值转换的"精确天平"

2.1 基础用法：创建浮点数

2.2 实际应用：安全数值转换和数据处理

三、format()：字符串格式化的"魔术师"

3.1 基础用法：值格式化

3.2 实际应用：自定义格式化和报表生成

四、frozenset()：不可变集合的"保险箱"

4.1 基础用法：创建不可变集合

4.2 实际应用：数据去重和集合运算

五、版本变更与兼容性说明

5.1 各函数的版本演进

六、最佳实践与实用技巧

6.1 安全使用建议

6.2 性能优化技巧

七、总结与实用建议

微信扫一扫，关注极客日志

更多推荐文章

相关免费在线工具