Python 内置函数系列:s开头系列函数下篇

@staticmethod：静态方法的"装饰器"

1. 基础用法：创建静态方法

class MathUtils:
    @staticmethod
    def add(a, b):
        """静态方法 - 不依赖实例"""
        return a + b

    @staticmethod
    def multiply(a, b):
        return a * b

    def instance_method(self):
        """实例方法"""
        return "这是实例方法"

# 使用静态方法
print(f"加法: {MathUtils.add(5, 3)}")        # 通过类调用
print(f"乘法: {MathUtils.multiply(5, 3)}")

# 也可以通过实例调用
utils = MathUtils()
print(f"通过实例调用: {utils.add(2, 3)}")

2. 实际应用：工具类设计

class StringUtils:
    @staticmethod
    def is_palindrome(text):
        """检查回文"""
        cleaned = ''.join(c.lower() for c in text if c.isalnum())
        return cleaned == cleaned[::-1]

    @staticmethod
    def count_vowels(text):
        """统计元音字母"""
        vowels = 'aeiouAEIOU'
        return sum(1 for char in text if char in vowels)

    @staticmethod
    def safe_convert_to_int(value, default=0):
        """安全转换为整数"""
        try:
            return int(value)
        except (ValueError, TypeError):
            return default

# 使用示例
text = "A man a plan a canal Panama"
print(f"是回文: {StringUtils.is_palindrome(text)}")
print(f"元音数量: {StringUtils.count_vowels(text)}")
print(f"安全转换: {StringUtils.safe_convert_to_int('123')}")

str()：字符串转换的"翻译官"

1. 基础用法：对象转字符串

# 基本类型转换
print(f"数字转字符串: {str(123)}")        # 输出: "123"
print(f"浮点数转字符串: {str(3.14)}")    # 输出: "3.14"
print(f"布尔值转字符串: {str(True)}")    # 输出: "True"

# 列表转字符串
numbers = [1, 2, 3]
print(f"列表转字符串: {str(numbers)}")    # 输出: "[1, 2, 3]"

# 自定义对象
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __str__(self):
        return f"Person: {self.name}, {self.age}岁"

person = Person("张三", 25)
print(f"对象转字符串: {str(person)}")

2. 实际应用：格式化输出

class StringFormatter:
    @staticmethod
    def format_currency(amount):
        """格式化货币"""
        return f"¥{amount:,.2f}"

    @staticmethod
    def truncate_text(text, max_length, suffix="..."):
        """截断文本"""
        if len(text) <= max_length:
            return text
        return text[:max_length - len(suffix)] + suffix

    @staticmethod
    def safe_string_conversion(obj, default=""):
        """安全字符串转换"""
        try:
            return str(obj)
        except:
            return default

# 使用示例
formatter = StringFormatter()

print(f"货币格式: {formatter.format_currency(1234.567)}")
print(f"文本截断: {formatter.truncate_text('这是一段很长的文本需要截断', 10)}")

# 安全转换
class ProblematicObject:
    def __str__(self):
        raise Exception("转换错误")

safe_str = formatter.safe_string_conversion(ProblematicObject())
print(f"安全转换结果: {safe_str}")

sum()：数值求和的"计算器"

1. 基础用法：可迭代对象求和

# 基本求和
numbers = [1, 2, 3, 4, 5]
total = sum(numbers)
print(f"列表求和: {total}")  # 输出: 15

# 指定起始值
numbers = [1, 2, 3]
total_from_10 = sum(numbers, 10)
print(f"从10开始求和: {total_from_10}")  # 输出: 16

# 元组求和
tuple_data = (10, 20, 30)
tuple_sum = sum(tuple_data)
print(f"元组求和: {tuple_sum}")  # 输出: 60

2. 实际应用：统计计算

class StatisticsCalculator:
    @staticmethod
    def calculate_average(numbers):
        """计算平均值"""
        if not numbers:
            return 0
        return sum(numbers) / len(numbers)

    @staticmethod
    def weighted_sum(values, weights):
        """加权求和"""
        if len(values) != len(weights):
            raise ValueError("值和权重长度必须相同")
        return sum(v * w for v, w in zip(values, weights))

    @staticmethod
    def cumulative_sum(numbers):
        """计算累加和"""
        result = []
        current_sum = 0
        for num in numbers:
            current_sum += num
            result.append(current_sum)
        return result

# 使用示例
calc = StatisticsCalculator()

data = [10, 20, 30, 40, 50]
print(f"平均值: {calc.calculate_average(data)}")

values = [1, 2, 3]
weights = [0.1, 0.2, 0.7]
print(f"加权和: {calc.weighted_sum(values, weights)}")

print(f"累加和: {calc.cumulative_sum(data)}")

super()：继承调用的"超级代理"

1. 基础用法：调用父类方法

class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        return "动物叫声"

class Dog(Animal):
    def __init__(self, name, breed):
        super().__init__(name)  # 调用父类构造器
        self.breed = breed

    def speak(self):
        base_sound = super().speak()  # 调用父类方法
        return f"{base_sound} - 汪汪!"

# 使用示例
dog = Dog("旺财", "金毛")
print(f"狗的名字: {dog.name}")
print(f"狗的品种: {dog.breed}")
print(f"狗的叫声: {dog.speak()}")

2. 实际应用：多重继承和方法重写

class Logger:
    def log(self, message):
        print(f"日志: {message}")

class Database:
    def save(self, data):
        print(f"保存数据: {data}")

class UserService(Logger, Database):
    def __init__(self, username):
        self.username = username

    def create_user(self):
        # 调用Logger的方法
        super().log(f"创建用户: {self.username}")
        # 调用Database的方法
        super().save(f"用户数据: {self.username}")
        return f"用户 {self.username} 创建成功"

# 使用示例
service = UserService("张三")
result = service.create_user()
print(result)

# 方法解析顺序查看
print(f"方法解析顺序: {UserService.__mro__}")

总结

通过本文的详细解析，我们深入了解了Python中八个重要的内置功能：

1. 1. @staticmethod - 静态方法装饰器，工具函数、数学计算、格式转换
2. 2. str() - 字符串转换，日志输出、数据展示、格式化
3. 3. sum() - 数值求和，统计计算、数值汇总、数据分析
4. 4. super() - 父类方法调用，继承体系、方法重写、代码复用

关键知识点总结：

• • @staticmethod创建不依赖实例的静态方法
• • str()将对象转换为可读字符串
• • sum()计算可迭代对象的总和
• • super()调用父类方法，支持多重继承

版本兼容性提醒：

• • Python 3.8+：sum()支持start关键字参数
• • Python 3.10+：super()在零参数形式下的改进