Python 如何以简洁的方式计算这个总数？

我试图在Python的一些建模中加入一个总结。数学公式为：

i=1直到i=5的总和（f_i*c_i）

---

我怎样才能在Python中输入这个总和，而不必输入每个术语？我以前定义了

f1

到

f5

和

c1

到

c5

。

如果你想自由改变f和c之间的间隔（例如

f[1:5]

和

c[5:9]

），你可以使用压缩切片。请记住，iterables在Python中是零索引的，并且一个片段包含起点而不是终点。因此

f[1:5]

包含四个项目，从索引

1

开始

f = [1,2,3,4,5,6,7,8,9]
c = [10,11,12,13,14,15,16,17,18,19]

print(sum([i*j for i, j in zip(f[1:5], c[1:5])]))

---

对许多变量求和的一种方法是将它们存储在

列表中

并使用for循环在列表上循环。我假设您已经声明了所有

c

和

f

变量

c_numbers = [c1, c2, c3, c4, c5]
f_numbers = [f1, f2, f3, f4, f5]

result = 0
for i in range(len(c_numbers)):
  result += c_numbers[i]*f_numbers[i]

---

除了使用列表，如果您有一个大的数据集，您还可以使用NumPy数组，它只需使用乘法运算符

*

即可实现元素级乘法。然后可以使用

np.sum

对值求和。下面是一个使用小数据集的示例

import numpy as np

a = np.array([1,2,3,4,5])
b = np.array([10, 11, 12, 13, 14])

total = np.sum(a*b)

# 190

正如所建议的，你想要的基本上是点积。所以你也可以

a.dot(b)

---

事先创建列表似乎是您需要做的事情

f = [1,2,3,4]
c = [3,4,5,6]
my_sum = 0

for i in range(5):
        my_sum = my_sum+f[i]*c[i]

---

变量名

f_i

不会成为变量名

f1

，因为它位于另一个名为

i

的变量定义附近。您要做的是根据

i

的值计算变量的名称。在Python中实现这一点的方法是使用一个列表：

f = [1,2,3,4,5]
c = [2,4,6,8,10]

完成此操作后，

f[1]

（而不是

f1

）的值为2（而不是1，因为列表索引是从零开始的）

那你就可以了

sum(f[i] * c[i] for i in range(5))

---

一般来说，在变量名中可以有一个索引是一个常见的新手想法。因为变量名是字符串，所以这实际上会导致更多的问题。除了通过动态生成的名称访问变量的相对困难之外，您还需要确定变量名称是

a_10

还是

a_0010

为此，您有一个称为列表的数据结构，它允许您从单个位置使用实际整数访问元素。您可以将号码存储在一对列表中：

c = [1, 2, 3, 4, 5]
f = [0.1, 0.3, 0.2, 0.5, 0.4]

现在，您可以访问数据

c[0]

，…，

c[4]

，而不是

c_1

，…，

c_5

。该指数是以零为基础的

如果您的数据总是这样配对，您也可以选择在结构中反映这一点。您可以选择一个包含两个元组的列表，而不是两个列表：

cf = [(1, 0.1), (2, 0.3), (3, 0.2), (4, 0.5), (5, 0.4)]

现在，您之前所称的

c_1

将是第一个元组的第一个元素：

cf[0][0]

。类似地，

f_5

将是最后一个元组的第二个元素：

cf[4][1]

您试图计算的乘积之和可以通过以下任一数据排列进行计算：

sum(i * j for i, j in zip(f, c))

或

传递给

sum

的表达式称为生成器表达式。它通常用括号括起来，除非它是函数的唯一参数。表达式将惰性地从每个元素对生成计算出的乘积

如果您正在进行大量的数据分析，您可能希望了解Python的计算库。其中最基本的是numpy，它允许您将数据存储在密集的阵列中，并对其执行快速矢量化操作

要将列表转换为数组，请执行以下操作：

 f = np.array(f)
 c = np.array(c)

现在，产品的总和只是产品的一部分：

c.dot(f)

或者您可以“手动”计算：

或者，你也可以这样做

fc = np.array(fc)

fc

现在将是由两列组成的矩阵，因此您可以执行以下操作：

fc[:, 0].dot(fc[:, 1])

或

一种“pythonic”的方法是使用内置的和函数生成每个术语的对，并计算总数

f1, f2, f3, f4, f5 = 1, 2, 3, 4, 5
c1, c2, c3, c4, c5 = 6, 7, 8, 9, 10

f = [f1, f2, f3, f4, f5]
c = [c1, c2, c3, c4, c5]

print( sum(fi * ci for fi, ci in zip(f, c)) )  # -> 130

显然，如果可行，将数据直接存储在两个列表中会更简洁：

f = [1, 2, 3, 4, 5]
c = [6, 7, 8, 9, 10]

---

不要将

fn，cn

定义为单独的变量，而是将它们添加到列表中。然后您可以使用

sum

和

zip

成对地迭代它们。不要创建单独的变量。使用列表，这样您就可以很容易地引用单个值（使用索引或迭代）。基本上，只要

f

和

c

是5个元素的列表，就可以对范围（5）中的i进行

sum（f[i]*c[i]）

。或者

sum（fi*ci代表fi，ci在zip中（f，c））

f[1:5]

将只包含4个元素。@tobias_k我知道，这就是重点。我不确定OP是否打算采用包容性或排他性的方法，但我确信他们能够找到调整切片的方法。为什么不确定？数学和记法总是包括极限。所以求和超过[：5]（将指数从1..5更改为0..4），或者通过将范围结束于6来求和超过1..5。我想这个讨论是不相关的。在你的答案中加一行，1:5表示4个元素，[1:6]表示5个元素，0是第一个索引，1是第二个索引。这样大家都很开心。OP可以自己决定他/她实际需要什么您是否尝试运行此代码，看看它是否有效？一条建议：避免使用内置函数和变量名称为什么不

A.dot（b）

？反对票不是我的，但是你不可能从一个不想离开的反对票上得到有意义的回应。@MadPhysical:好建议。我会加上：）谢谢

fc.prod(axis=1).sum()

f1, f2, f3, f4, f5 = 1, 2, 3, 4, 5
c1, c2, c3, c4, c5 = 6, 7, 8, 9, 10

f = [f1, f2, f3, f4, f5]
c = [c1, c2, c3, c4, c5]

print( sum(fi * ci for fi, ci in zip(f, c)) )  # -> 130

f = [1, 2, 3, 4, 5]
c = [6, 7, 8, 9, 10]