Python-VBA函数之旅-sum函数

一、sum函数的常见应用场景

二、sum函数使用注意事项

三、如何用好sum函数？

1、sum函数：

1-1、Python：

1-2、VBA：

2、推荐阅读：

个人主页： https://myelsa1024.blog.csdn.net/

一、sum函数的常见应用场景

sum函数在Python中是一个非常实用的内置函数，它可以用于各种与数值计算相关的场景，常见的应用场景有：

1、数字列表求和：这是sum()函数最直接的应用场景，假设你有一个包含数字的列表，并希望计算这些数字的总和。

2、数字元组求和：同样，你也可以对元组中的数值进行求和。

3、字符串中数字求和：如果你有一个包含数字字符的字符串，并想要计算这些数字的和，你需要先将字符串转换为整数列表。

4、字典值或键的求和：如果你有一个字典，并且想要对字典中的值或键(如果它们是数值)进行求和。

5、集合中数字求和：集合中的元素是唯一的，但如果你知道集合中的元素都是数值类型，也可以使用sum()函数进行求和。

6、处理嵌套列表：如果你有一个嵌套的列表，并想要计算所有子列表中数字的总和，你需要先将嵌套列表展平。

7、计算可迭代对象中特定属性的总和：当你处理更复杂的对象(如自定义类的实例)时，你可能想要计算这些对象中某个特定属性的总和。

8、数据处理和清洗：在数据处理和清洗的过程中，sum()函数经常用于计算某列的总和，以了解数据的分布或进行简单的统计分析。

9、作为累加器的起始值：你可以使用 start参数为sum()函数提供一个起始值，这在某些情况下可能很有用。

10、数字生成器求和：如果你有一个生成器，它产生数值，你也可以使用sum()函数进行求和。

11、与函数式编程结合使用：在函数式编程中，高阶函数(如sum())经常与其他高阶函数(如map(), filter(), reduce()等)一起使用，以构建更复杂的计算流程。虽然Python的标准库没有提供reduce()函数(但functools模块中有)，但可以使用sum()函数和生成器表达式来模拟类似的功能。

12、与列表推导式结合使用：列表推导式是创建列表的一种简洁方式，与sum()函数结合使用，可以在一行代码中完成复杂的计算。

二、sum函数使用注意事项

在Python中，sum()函数是一个非常有用的内置函数，用于计算可迭代对象(如列表、元组、集合等)中所有元素的和，然而，在使用sum()函数时，需注意以下事项：

1、空可迭代对象：如果传入一个空的可迭代对象(如空列表、空元组等)，sum()函数将返回0，而不是引发错误。

2、非数字类型：sum()函数只能对数字类型(如整数、浮点数等)进行求和；如果可迭代对象中包含非数字类型的元素，将会引发TypeError异常。

3、整数溢出：当使用sum()函数对大量整数进行求和时，如果结果超出了Python整数的表示范围(这通常是一个非常大的数，具体取决于你的Python实现和平台)，将会引发OverflowError异常，但在大多数情况下，这不会发生，因为Python的整数是动态大小的。

4、性能：对于非常大的可迭代对象，使用sum()函数可能会比手动循环求和慢一些，因为sum()函数在内部也需要进行循环，但是，除非你正在处理非常大的数据集，否则这种性能差异通常是可以忽略的。

5、浮点数精度：由于浮点数的表示和计算存在精度问题，使用sum()函数对浮点数进行求和时可能会得到不精确的结果，如果你需要高精度的浮点数求和，可能需要使用专门的数学库，如mpmath或decimal。

6、列表推导式：你可以使用列表推导式(list comprehension)与sum()函数结合，以更简洁的方式对特定条件的元素进行求和。例如，计算列表中所有偶数的和。

7、使用start参数：sum()函数还有一个可选的start参数，用于指定求和的起始值；默认情况下，start的值为0。

三、如何用好sum函数？

要有效地使用Python中的sum()函数，你需遵循以下建议：

1、理解数据类型：确保你正在对数字类型(如整数、浮点数)的可迭代对象使用sum()函数；如果你的可迭代对象包含非数字类型的元素，你需要先对它们进行过滤或转换。

2、处理空序列：记住，当对一个空序列使用sum()时，它将返回0，这通常是期望的行为，但如果你需要对此进行特殊处理，请确保你的代码能够妥善处理这种情况。

3、使用start参数：当你需要给总和添加一个初始值时，使用start参数，这在你需要对特定数据集的偏移或基准值进行求和时特别有用。

4、结合列表推导式：使用列表推导式来快速创建要传递给sum()的数值列表，这特别适用于当你需要对满足特定条件的元素进行求和时。

5、处理浮点数精度：如果你正在处理浮点数，并需要高精度结果，考虑使用decimal模块或专门的数学库，如mpmath；虽然sum()可以用于浮点数，但由于浮点数的表示和计算限制，结果可能不是完全精确的。

6、性能优化：对于非常大的数据集，sum()可能不是最快的解决方案，在这种情况下，考虑使用其他方法，如NumPy库中的numpy.sum()，它针对数值计算进行了优化。

7、异常处理：当使用sum()时，确保你的代码能够妥善处理可能出现的异常，如TypeError(如果尝试对非数字元素进行求和)或OverflowError(如果整数和超出Python整数的范围)。

8、文档和注释：在你的代码中使用文档字符串(docstrings)和注释来解释你如何使用sum()函数以及为什么选择这种方法，这有助于其他人理解你的代码，并在将来维护它时更容易地找到问题。

9、测试：对你的代码进行单元测试，以确保sum()函数按预期工作，这包括测试空序列、非数字类型、浮点数精度以及异常处理。

10、遵循PEP8：确保你的代码遵循Python的官方编码风格指南PEP8，这包括使用有意义的变量名、正确的缩进和空格等，虽然这与直接使用sum()函数不直接相关，但遵循PEP8将使你的代码更易于阅读和维护。

1、sum函数：

1-1、Python：

# 1.函数：sum
# 2.功能：用于计算可迭代对象(如列表、元组、集合等)中所有元素的和
# 3.语法：sum(iterable, /[, start=0])
# 4.参数：
# 4-1、iterable(必须)：表示一个可迭代对象
# 4-2、/：在函数签名中的`/`是一个特殊的分隔符，它用于指示位置参数和关键字参数之间的分隔，即分隔符前面的参数必须是位置参数，后面的参数可以是位置参数或关键字参数等，保持了向前的兼容性
# 4-3、start(可选)：表示求和的起始值，默认情况下，它的值是0
# 5.返回值：返回可迭代对象中所有元素的总和
# 6.说明：
# 7.示例：
# 用dir()函数获取该函数内置的属性和方法
print(dir(sum))
# ['__call__', '__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__',
# '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__name__',
# '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__self__', '__setattr__', '__sizeof__',
# '__str__', '__subclasshook__', '__text_signature__']

# 用help()函数获取该函数的文档信息
help(sum)

# 应用一：数字列表求和
# 示例1：整数列表求和
# 创建一个包含整数的列表
integer_list = [3, 5, 6, 8, 10, 11, 24]
# 使用sum()函数求和
total = sum(integer_list)
# 打印结果
print("整数列表的总和是:", total)
# 整数列表的总和是: 67

# 示例2：浮点数列表求和
# 创建一个包含浮点数的列表
float_list = [1.1, 2.2, 3.3, 4.4]
# 使用sum()函数求和
total = sum(float_list)
# 打印结果
print("浮点数列表的总和是:", total)
# 浮点数列表的总和是: 11.0

# 示例3：混合数字类型列表求和(整数和浮点数)
# 创建一个包含整数和浮点数的列表
mixed_list = [1, 2.2, 3, 4.4]
# 使用sum()函数求和
# 注意：由于列表中包含浮点数，总和也将是浮点数
total = sum(mixed_list)
# 打印结果
print("混合数字类型列表的总和是:", total)
# 混合数字类型列表的总和是: 10.600000000000001

# 示例4：使用start参数指定起始值
# 创建一个包含整数的列表
integer_list = [3, 5, 6, 8, 10, 11, 24]
# 使用sum()函数求和，并指定起始值为10
total = sum(integer_list, start=10)
# 打印结果
print("从10开始，整数列表的总和是:", total)
# 从10开始，整数列表的总和是: 77

# 应用二：数字元组求和
# 示例1：整数元组求和
# 创建一个包含整数的元组
integer_tuple = (3, 5, 6, 8, 10, 11, 24)
# 使用sum()函数求和
total = sum(integer_tuple)
# 打印结果
print("整数元组的总和是:", total)
# 整数元组的总和是: 67

# 示例2：浮点数元组求和
# 创建一个包含浮点数的元组
float_tuple = (1.1, 2.2, 3.3, 4.4)
# 使用sum()函数求和
total = sum(float_tuple)
# 打印结果
print("浮点数元组的总和是:", total)
# 浮点数元组的总和是: 11.0

# 示例3：混合数字类型元组求和(整数和浮点数)
# 创建一个包含整数和浮点数的元组
mixed_tuple = (1, 2.2, 3, 4.4)
# 使用sum()函数求和
# 注意：由于元组中包含浮点数，总和也将是浮点数
total = sum(mixed_tuple)
# 打印结果
print("混合数字类型元组的总和是:", total)
# 混合数字类型元组的总和是: 10.600000000000001

# 示例4：使用start参数指定起始值
# 创建一个包含整数的元组
integer_tuple = (3, 5, 6, 8, 10, 11, 24)
# 使用sum()函数求和，并指定起始值为10
total = sum(integer_tuple, start=10)
# 打印结果
print("从10开始，整数元组的总和是:", total)
# 从10开始，整数元组的总和是: 77

# 应用三：字符串中数字求和
# 示例1：字符串中仅包含空格分隔的整数
# 假设字符串中仅包含空格分隔的整数
s = "3 5 6 8 10 11 24"
# 使用split()方法将字符串分割为列表，然后转换为整数，最后使用sum()函数求和
numbers = [int(num) for num in s.split()]
total = sum(numbers)
# 打印结果
print("字符串中整数的总和是:", total)
# 字符串中整数的总和是: 67

# 示例2：字符串中包含逗号分隔的整数
# 假设字符串中包含逗号分隔的整数
s = "3,5,6,8,10,11,24"
# 使用replace()方法替换逗号，然后使用split()方法分割字符串，接着转换为整数，最后使用sum()函数求和
numbers = [int(num) for num in s.replace(',', ' ').split()] # 此处注意空格的设置
total = sum(numbers)
# 打印结果
print("字符串中整数的总和是:", total)
# 字符串中整数的总和是: 67

# 示例3：字符串中包含浮点数
# 假设字符串中包含空格分隔的浮点数
s = "1.1 2.2 3.3 4.4"
# 使用split()方法将字符串分割为列表，然后转换为浮点数，最后使用sum()函数求和
numbers = [float(num) for num in s.split()]
total = sum(numbers)
# 打印结果
print("字符串中浮点数的总和是:", total)
# 字符串中浮点数的总和是: 11.0

# 示例4：处理更复杂的字符串(包含非数字字符)
# 假设字符串中包含空格分隔的浮点数
s = "1.1 2.2 3.3 4.4"
# 使用split()方法将字符串分割为列表，然后转换为浮点数，最后使用sum()函数求和
numbers = [float(num) for num in s.split()]
total = sum(numbers)
# 打印结果
print("字符串中浮点数的总和是:", total)
# 字符串中浮点数的总和是: 11.0# 假设字符串中包含一些非数字字符和数字
s = "apple 1.1 banana 2.2 cherry 3.3"
# 使用正则表达式来提取所有的浮点数，并求和
import re
# 查找所有浮点数
numbers = re.findall(r'-?\d+(\.\d+)?', s)  # 这个正则表达式可以匹配整数和浮点数
# 转换为浮点数并求和
total = sum(float(num) for num in numbers if num.replace('.', '', 1).isdigit())  # 排除非数字匹配项
# 打印结果
print("字符串中浮点数的总和是:", total)
# 字符串中浮点数的总和是: 11.0
# 字符串中浮点数的总和是: 0.6000000000000001

# 应用四：字典值或键的求和
# 示例1：对字典中的值进行求和
# 假设我们有一个字典，其值都是数字
my_dict = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
# 使用字典的values()方法获取所有值，然后用sum()求和
total_values = sum(my_dict.values())
# 打印结果
print("字典中所有值的总和是:", total_values)
# 字典中所有值的总和是: 10

# 示例2：对字典中的键进行求和(假设键是数字)
# 假设我们有一个字典，其键都是整数
my_dict = {1: 'one', 2: 'two', 3: 'three', 4: 'four'}
# 使用字典的keys()方法获取所有键，但注意键需要先转换为整数（如果它们已经是整数则不需要）
# 然后用sum()求和
total_keys = sum(int(key) for key in my_dict.keys())  # 假设键已经是字符串表示的整数
# 打印结果
print("字典中所有键(作为整数)的总和是:", total_keys)
# 如果键已经是整数，可以直接使用
# total_keys = sum(my_dict.keys())  # 仅当键已经是整数时有效
# 字典中所有键(作为整数)的总和是: 10

# 示例3：对字典中满足条件的值进行求和
# 假设我们有一个字典，其值可能是数字或字符串
my_dict = {'a': 1, 'b': 'two', 'c': 3, 'd': 'four', 'e': 5}
# 使用字典推导式和sum()对满足条件的值（这里是数字）进行求和
total_numeric_values = sum(value for value in my_dict.values() if isinstance(value, (int, float)))
# 打印结果
print("字典中所有数字值的总和是:", total_numeric_values)
# 字典中所有数字值的总和是: 9

# 应用五：集合中数字求和
# 假设我们有一个包含数字的集合
my_set = {1, 2, 3, 4, 4}  # 注意集合中的重复元素4只会出现一次
# 使用sum()函数对集合中的数字进行求和
total = sum(my_set)
# 打印结果
print("集合中所有数字的总和是:", total)
# 集合中所有数字的总和是: 10

# 应用六：处理嵌套列表
# 示例1：对嵌套列表中的数字进行求和(假设嵌套列表只包含数字)
nested_list = [[1, 2, 3], [4, 5], [6, 7, 8, 9]]
# 使用列表推导式扁平化列表，并使用sum()求和
total = sum(num for sublist in nested_list for num in sublist)
print("嵌套列表中所有数字的总和是:", total)
# 嵌套列表中所有数字的总和是: 45

# 示例2：对嵌套列表中每个子列表的第一个元素进行求和
nested_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
# 使用列表推导式获取每个子列表的第一个元素，并使用sum()求和
total = sum(sublist[0] for sublist in nested_list)
print("嵌套列表中每个子列表的第一个元素的总和是:", total)
# 嵌套列表中每个子列表的第一个元素的总和是: 12

# 示例3：对嵌套列表中每个子列表的和进行求和(即，先对每个子列表求和，再对结果求和)
nested_list = [[1, 2, 3], [4, 5], [6, 7, 8, 9]]
# 使用列表推导式对每个子列表求和，再使用sum()对结果求和
sublist_sums = [sum(sublist) for sublist in nested_list]
total = sum(sublist_sums)
print("嵌套列表中每个子列表的和的总和是:", total)
# 嵌套列表中每个子列表的和的总和是: 45

# 示例4：对嵌套列表中满足条件的元素进行求和(例如，只对偶数求和)
nested_list = [[1, 2, 3], [4, 6], [8, 9, 10]]
# 使用列表推导式扁平化列表，并过滤出偶数，最后使用sum()求和
total = sum(num for sublist in nested_list for num in sublist if num % 2 == 0)
print("嵌套列表中所有偶数的总和是:", total)
# 嵌套列表中所有偶数的总和是: 30

# 应用七：计算可迭代对象中特定属性的总和
# 假设我们有一个包含字典的列表，每个字典都有一个'value'键
data = [
    {'name': 'Myelsa', 'value': 18},
    {'name': 'Bruce', 'value': 6},
    {'name': 'Jimmy', 'value': 15},
    # ... 可能还有其他字典
]
# 使用列表推导式从每个字典中提取'value'属性的值，并使用sum()求和
total_value = sum(item['value'] for item in data)
# 打印结果
print("所有字典中'value'属性的总和是:", total_value)
# 所有字典中'value'属性的总和是: 39

# 应用八：数据处理和清洗
# 示例1: 忽略NaN值计算总和
import pandas as pd
# 创建一个包含NaN的DataFrame
data = {
    'Name': ['Myelsa', 'Bruce', 'Jimmy', 'Lucy', 'Jack'],
    'Sales': [100, 200, pd.NA, 300, 250],  # 使用pd.NA代替NaN（在pandas 1.0+中）
    'City': ['New York', 'San Francisco', 'New York', 'Los Angeles', 'Chicago']
}
df = pd.DataFrame(data)
# 计算'Sales'列的总和，忽略NaN值
total_sales = df['Sales'].sum()
print("总销售额是:", total_sales)
# 总销售额是: 850

# 示例2: 数据筛选后计算总和
import pandas as pd
# 假设我们有一个DataFrame
data = {
    'Name': ['Myelsa', 'Bruce', 'Jimmy', 'Lucy', 'Jack'],
    'Sales': [100, 200, 50, 300, 250],
    'City': ['New York', 'San Francisco', 'New York', 'Los Angeles', 'Chicago']
}
df = pd.DataFrame(data)
# 数据处理：只选择'New York'和'San Francisco'城市的销售数据
filtered_df = df[df['City'].isin(['New York', 'San Francisco'])]
# 计算筛选后的'Sales'列的总和
total_sales_filtered = filtered_df['Sales'].sum()
print("New York和San Francisco的总销售额是:", total_sales_filtered)
# New York和San Francisco的总销售额是: 350

# 应用九：作为累加器的起始值
# 示例1: 使用生成器和起始值
# 定义一个生成器
def numbers_generator():
    for i in range(1, 6):
        yield i
# 使用生成器和起始值100
total = sum(numbers_generator(), start=100)
print("生成器产生的元素与起始值100的和是:", total)
# 生成器产生的元素与起始值100的和是: 115

# 示例2: 使用空列表和起始值(将返回起始值本身)
empty_list = []
total = sum(empty_list, start=50)  # 因为列表是空的，所以返回起始值50
print("空列表与起始值50的和是:", total)
# 空列表与起始值50的和是: 50

# 应用十：数字生成器求和
# 示例1: 使用简单的数字生成器
# 定义一个生成器，生成从1到5的数字
def numbers_generator():
    for i in range(1, 6):
        yield i
# 使用sum()函数求和
total = sum(numbers_generator())
print("生成器产生的数字之和是:", total)
# 生成器产生的数字之和是: 15

# 示例2: 使用生成器和起始值
# 定义一个生成器，生成从1到5的数字
def numbers_generator():
    for i in range(1, 6):
        yield i
# 使用sum()函数求和，并指定起始值为10
total = sum(numbers_generator(), start=10)
print("生成器产生的数字与起始值10之和是:", total)
# 生成器产生的数字与起始值10之和是: 25

# 示例3: 使用更复杂的生成器逻辑
# 定义一个生成器，生成平方数，直到平方数大于20
def square_numbers_generator():
    n = 1
    while True:
        square = n ** 2
        if square > 20:
            break
        yield square
        n += 1
# 使用sum()函数求和
total = sum(square_numbers_generator())
print("小于等于20的平方数之和是:", total)
# 小于等于20的平方数之和是: 30

# 示例4: 使用生成器表达式和sum()
# 使用生成器表达式生成从1到5的数字
total = sum(i for i in range(1, 6))
print("生成器表达式产生的数字之和是:", total)
# 使用生成器表达式生成平方数，直到平方数大于20
total = sum(i ** 2 for i in range(1, int(20 ** 0.5) + 1) if i ** 2 <= 20)
print("小于等于20的平方数之和是:", total)
# 生成器表达式产生的数字之和是: 15
# 小于等于20的平方数之和是: 30

# 应用十一：与函数式编程结合使用
# 示例1: 使用map()和sum()
# 定义一个列表
numbers = [1, 2, 3, 4, 5]
# 使用map()将列表中的每个元素平方，然后用sum()求和
squared_sum = sum(map(lambda x: x ** 2, numbers))
print("列表中每个元素的平方和是:", squared_sum)
# 列表中每个元素的平方和是: 55

# 示例2: 使用filter()和sum()
# 定义一个列表
numbers = [1, 2, 3, 4, 5, 0, -1, -2]
# 使用filter()过滤出列表中的正数，然后用sum()求和
positive_sum = sum(filter(lambda x: x > 0, numbers))
print("列表中的正数之和是:", positive_sum)
# 列表中的正数之和是: 15

# 示例3: 使用reduce()和sum()(尽管reduce()通常用于更复杂的场景)
from functools import reduce
# 定义一个列表
numbers = [1, 2, 3, 4, 5]
# 使用reduce()和lambda函数模拟sum()的功能
reduced_sum = reduce(lambda x, y: x + y, numbers)
print("使用reduce()函数求和的结果是:", reduced_sum)
# 使用reduce()函数求和的结果是: 15

# 应用十一：与列表推导式结合使用
# 示例1: 使用列表推导式和sum()
# 定义一个列表
numbers = [1, 2, 3, 4, 5]
# 使用列表推导式平方列表中的每个元素，然后用sum()求和
squared_sum_listcomp = sum([x ** 2 for x in numbers])
print("使用列表推导式平方列表中每个元素的和是:", squared_sum_listcomp)
# 使用列表推导式平方列表中每个元素的和是: 55

# 示例2: 列表推导式生成平方数列表，并用sum()求和
# 定义一个数字列表
numbers = [1, 2, 3, 4, 5]
# 使用列表推导式生成平方数列表，并用sum()求和
squared_sum = sum([x ** 2 for x in numbers])
print("列表中每个元素的平方和是:", squared_sum)
# 列表中每个元素的平方和是: 55

# 示例3: 列表推导式过滤偶数并求和
# 定义一个包含奇数和偶数的数字列表
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# 使用列表推导式过滤出偶数，并用sum()求和
even_sum = sum([x for x in numbers if x % 2 == 0])
print("列表中的偶数之和是:", even_sum)
# 列表中的偶数之和是: 30

# 示例4: 列表推导式与条件语句结合，求和满足条件的元素
# 定义一个包含正数和负数的数字列表
numbers = [1, -2, 3, -4, 5, -6, 7, -8, 9, -10]
# 使用列表推导式选取正数，并用sum()求和
positive_sum = sum([x for x in numbers if x > 0])
print("列表中的正数之和是:", positive_sum)
# 列表中的正数之和是: 25
# 示例5: 列表推导式生成斐波那契数列(前N项)，并求和
# 定义fibonacci生成器函数
def fibonacci_generator(n):
    a, b = 0, 1
    for _ in range(n):
        yield a
        a, b = b, a + b
# 使用生成器函数来创建一个包含斐波那契数列前10项的列表
fibonacci_sequence = list(fibonacci_generator(10))
# 或者，如果你不想改变原来的生成器函数，你可以直接这样生成斐波那契数列列表
# fibonacci_sequence = [0, 1] + [fibonacci_sequence[i-1] + fibonacci_sequence[i-2] for i in range(2, 10)]
# 注意：这里的fibonacci_sequence需要事先初始化为包含至少两个元素的列表[0, 1]
# 使用sum()函数求和斐波那契数列
fibonacci_sum = sum(fibonacci_sequence)
print("斐波那契数列(前10项)的和是:", fibonacci_sum)
# 斐波那契数列(前10项)的和是: 88