Как кратко посчитать эту сумму?

Если вам нужна свобода изменения интервалов между f и c (например, f[1:5] и c[5:9]), вы можете использовать заархивированные фрагменты. Имейте в виду, что итерации в 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])]))

Один из способов суммирования многих переменных - сохранить их в list и просмотреть список с помощью цикла 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_2, идущий после a_10, и вам нужно решить, является ли имя переменной 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(i * j for i, j in fc)

Выражение, которое мы передаем sum, называется выражением генератора. Обычно его заключают в круглые скобки, кроме случаев, когда это единственный аргумент функции. Выражение будет лениво возвращать вычисленный продукт для каждой пары элементов.

Если вы много занимаетесь анализом данных, возможно, вам стоит заглянуть в вычислительные библиотеки Python. Самым фундаментальным из них является numpy, который позволяет хранить данные в плотно упакованных массивах и выполнять над ними быстрые векторизованные операции.

Чтобы преобразовать список в массив:

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

Сумма продуктов теперь просто для продукта:

c.dot(f)

Или вы можете вычислить это «вручную»:

(c * f).sum()

В качестве альтернативы вы могли бы сделать

fc = np.array(fc)

fc теперь будет матрицей из двух столбцов, поэтому вы можете сделать что-то вроде:

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

ИЛИ

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

«Питонический» способ сделать это - использовать встроенные функции zip() и 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]