道友我们来详细解析 Python 中非常实用的内置函数 sum()。

1. 函数定义

sum() 函数用于计算可迭代对象中所有元素的总和。

• 语法：sum(iterable, /, start=0)
• 参数：
• iterable：必需，要计算总和的可迭代对象（列表、元组、集合等）
• start：可选，起始值，会加到总和上（默认为 0）
• 返回值：所有元素的总和加上 start 值

2. 基本用法示例

数字列表求和

# 整数列表
numbers = [1, 2, 3, 4, 5]
result = sum(numbers)
print(result)  # 输出： 15

# 浮点数列表
floats = [1.5, 2.5, 3.5]
result = sum(floats)
print(result)  # 输出： 7.5

# 混合数字类型
mixed = [1, 2.5, 3, 4.5]
result = sum(mixed)
print(result)  # 输出： 11.0 (自动提升为浮点数)

使用 start 参数

numbers = [1, 2, 3, 4]

# 默认 start=0
print(sum(numbers))        # 输出： 10

# 设置 start=5
print(sum(numbers, 5))     # 输出： 15 (10 + 5)

# 设置 start=10
print(sum(numbers, 10))    # 输出： 20 (10 + 10)

# 负数的 start
print(sum(numbers, -5))    # 输出： 5 (10 - 5)

其他可迭代对象

# 元组
tuple_nums = (1, 2, 3, 4)
print(sum(tuple_nums))     # 输出： 10

# 集合
set_nums = {1, 2, 3, 4}
print(sum(set_nums))       # 输出： 10

# 范围对象
range_obj = range(1, 6)    # 1, 2, 3, 4, 5
print(sum(range_obj))      # 输出： 15

# 生成器表达式
gen_expr = (x for x in range(1, 6))
print(sum(gen_expr))       # 输出： 15

3. 高级用法和技巧

字符串连接（需要配合 start 参数）

# 错误的用法：不能直接对字符串列表使用 sum()
strings = ['a', 'b', 'c']
# print(sum(strings))  # TypeError: unsupported operand type(s) for +: 'int' and 'str'

# 正确的用法：使用空字符串作为 start
result = sum(strings, '')  # 相当于 '' + 'a' + 'b' + 'c'
print(result)  # 输出： 'abc'

# 更推荐的做法：使用 join()
result = ''.join(strings)
print(result)  # 输出： 'abc'

列表合并

lists = [[1, 2], [3, 4], [5, 6]]
# 错误的用法
# print(sum(lists))  # TypeError

# 正确的用法：使用空列表作为 start
result = sum(lists, [])
print(result)  # 输出： [1, 2, 3, 4, 5, 6]

# 更推荐的做法：使用列表推导式或 itertools.chain()
import itertools
result = list(itertools.chain.from_iterable(lists))
print(result)  # 输出： [1, 2, 3, 4, 5, 6]

自定义对象的求和

class Product:
    def __init__(self, name, price):
        self.name = name
        self.price = price
    
    def __add__(self, other):
        if isinstance(other, Product):
            return self.price + other.price
        return self.price + other
    
    def __radd__(self, other):
        return other + self.price

products = [Product("Apple", 2.5), Product("Banana", 1.8), Product("Orange", 3.2)]

# 使用 sum() 计算总价
total_price = sum(products, 0)
print(f"总价: ${total_price}")  # 输出： 总价: $7.5

# 或者使用生成器表达式
total_price = sum(p.price for p in products)
print(f"总价: ${total_price}")  # 输出： 总价: $7.5

4. 实际应用场景

场景1：统计数据分析

# 计算平均值
scores = [85, 92, 78, 90, 88]
total = sum(scores)
average = total / len(scores)
print(f"总分: {total}, 平均分: {average:.2f}")  # 输出： 总分: 433, 平均分: 86.60

# 计算加权平均
weights = [0.2, 0.3, 0.5]
values = [80, 90, 85]
weighted_avg = sum(w * v for w, v in zip(weights, values))
print(f"加权平均: {weighted_avg:.2f}")  # 输出： 加权平均: 85.50

场景2：财务计算

# 计算多个交易的总和
transactions = [100, -50, 75, -30, 200]
balance = sum(transactions)
print(f"最终余额: ${balance}")  # 输出： 最终余额: $295

# 计算累计收益
investments = [1000, 500, 750]
returns = [0.05, 0.08, 0.06]  # 收益率

total_return = sum(inv * ret for inv, ret in zip(investments, returns))
print(f"总收益: ${total_return:.2f}")  # 输出： 总收益: $137.00

场景3：数据处理和聚合

# 从字典列表中提取并求和
sales_data = [
    {'product': 'A', 'sales': 100},
    {'product': 'B', 'sales': 200},
    {'product': 'C', 'sales': 150}
]

total_sales = sum(item['sales'] for item in sales_data)
print(f"总销售额: {total_sales}")  # 输出： 总销售额: 450

# 使用 map() 函数
total_sales = sum(map(lambda x: x['sales'], sales_data))
print(f"总销售额: {total_sales}")  # 输出： 总销售额: 450

5. 性能考虑和最佳实践

与循环比较的性能

import timeit

# 测试数据
large_list = list(range(10000))

# 测试 sum() 性能
sum_time = timeit.timeit('sum(l)', globals=globals(), number=1000)

# 测试 for 循环性能
loop_time = timeit.timeit('''
total = 0
for num in l:
    total += num
''', globals=globals(), number=1000)

print(f"sum() 时间: {sum_time:.4f}秒")
print(f"for循环时间: {loop_time:.4f}秒")
# sum() 通常比手写循环更快，因为它是用C实现的

内存效率考虑

# 对于非常大的数据集，使用生成器而不是列表
def large_data_generator():
    for i in range(1000000):
        yield i

# 内存效率高的方式
total = sum(large_data_generator())
print(f"总和: {total}")  # 输出： 499999500000

# 内存效率低的方式（不要这样做）
# total = sum([i for i in range(1000000)])  # 会创建整个列表在内存中

6. 错误处理和边界情况

# 空可迭代对象
empty_list = []
print(sum(empty_list))        # 输出： 0
print(sum(empty_list, 10))    # 输出： 10

# 包含非数字元素
mixed = [1, 2, '3', 4]
try:
    print(sum(mixed))         # TypeError: unsupported operand type(s) for +: 'int' and 'str'
except TypeError as e:
    print(f"错误: {e}")

# 使用过滤来处理混合数据
mixed = [1, 2, '3', 4, 'abc', 5]
numbers_only = (x for x in mixed if isinstance(x, (int, float)))
print(sum(numbers_only))      # 输出： 12 (1+2+4+5)

7. 与相关函数的比较

import math
import numpy as np

# 浮点数精度问题
floats = [0.1] * 10

print(sum(floats))          # 输出： 0.9999999999999999 (精度问题)
print(math.fsum(floats))    # 输出： 1.0 (更精确)

# 使用 numpy
arr = np.array([1, 2, 3, 4, 5])
print(np.sum(arr))          # 输出： 15

8. 注意事项

1. 类型一致性：所有元素必须是可相加的类型
2. 浮点数精度：对于需要高精度的浮点数求和，使用 math.fsum()
3. 内存使用：对于极大数据集，使用生成器而不是列表
4. 字符串处理：不要用 sum() 来连接字符串，用 join()

# 不推荐的字符串连接方式
words = ['hello', ' ', 'world']
result = sum(words, '')  # 能工作，但效率低
print(result)  # 输出： 'hello world'

# 推荐的方式
result = ''.join(words)  # 更高效
print(result)  # 输出： 'hello world'

总结

sum() 是 Python 中最常用和最高效的内置函数之一，几乎在所有需要求和的场景中都会用到。掌握它的各种用法和最佳实践对于编写高效的 Python 代码非常重要。