Just zip the lists to generate pairs, multiply them and feed to sum:

>>> a = [1,2,3]
>>> b = [4,5,6]
>>> sum(x * y for x, y in zip(a, b))
32

In above zip will return iterable of tuples containing one number from both lists:

>>> list(zip(a, b))
[(1, 4), (2, 5), (3, 6)]

Then generator expression is used to multiply the numbers together:

>>> list(x*y for x, y in list(zip(a, b)))
[4, 10, 18]

Finally sum is used to sum them together for final result:

>>> sum(x*y for x, y in list(zip(a, b)))
32

import operator

def sumproduct(*lists):
    return sum(reduce(operator.mul, data) for data in zip(*lists))

for python 3

import operator
import functools

def sumproduct(*lists):
    return sum(functools.reduce(operator.mul, data) for data in zip(*lists))

In [159]: import sympy as sy

In [160]: from sympy.abc import x

In [161]: terms = [1, x, x*(x-1)]

In [162]: coefficients = [-1,8.1,7]

In [163]: sum(t*c for t, c in zip(terms, coefficients))
Out[163]: 7*x*(x - 1) + 8.1*x - 1

Interestingly, sum(term*coef for term, coef in zip(terms, coefficients)) is a bit faster than sum(coef * term for coef, term in zip(coefficients, terms)):

In [182]: %timeit sum(term * coef for term, coef in zip(terms, coefficients))
10000 loops, best of 3: 34.1 µs per loop

In [183]: %timeit sum(coef * term for coef, term in zip(coefficients, terms))
10000 loops, best of 3: 38.7 µs per loop

The reason for this is because coef * term calls coef.__mul__(term) which then has to call term.__rmul__(coef) since ints do not know how to multiply with sympy Symbols. That extra function call makes coef * term slower than term * coef. (term * coef calls term.__mul__(coef) directly.)

Here are some more microbenchmarks:

In [178]: %timeit sum(IT.imap(op.mul, coefficients, terms))
10000 loops, best of 3: 38 µs per loop

In [186]: %timeit sum(IT.imap(op.mul, terms, coefficients))
10000 loops, best of 3: 32.8 µs per loop

In [179]: %timeit sum(map(op.mul, coefficients, terms))
10000 loops, best of 3: 38.5 µs per loop

In [188]: %timeit sum(map(op.mul, terms, coefficients))
10000 loops, best of 3: 33.3 µs per loop

Notice that the order of the terms and coefficients matters, but otherwise there is little time difference between these variants. For larger input, they also perform about the same:

In [203]: terms = [1, x, x*(x-1)] * 100000

In [204]: coefficients = [-1,8.1,7] * 100000

In [205]: %timeit sum(IT.imap(op.mul, terms, coefficients))
1 loops, best of 3: 3.63 s per loop

In [206]: %timeit sum(term * coef for term, coef in zip(terms, coefficients))
1 loops, best of 3: 3.63 s per loop

In [207]: %timeit sum(map(op.mul, terms, coefficients))
1 loops, best of 3: 3.48 s per loop

Also be aware that if you do not know (through profiling) that this operation is a critical bottleneck in your code, worrying about these slight differences is a waste of your time, since the time it takes to pre-optimize this stuff is far greater than the amount of time you save whilst the code is running. As they say, preoptimization is the root of all evil. I'm probably already guilty of that.

In Python2,

sum(IT.imap(op.mul, coefficients, terms))

uses the least memory.

In Python3, zip and map returns iterators, so

sum(t*c for t, c in zip(terms, coefficients))    
sum(map(op.mul, coefficients, terms))

would also be memory-efficient.

Oh, so many problems in one post ;)

At first you should check if you can convert the list entries into integers. The best use case is to ask for forgivness and use try-except. That means if int(something) raises an Error, catch that specific error and handle it:

>>> def check_for_ints(entry):        try:	        return int(entry)        except ValueError:	        return None>>> check_for_ints("2")2>>> check_for_ints("")>>> check_for_ints("jhkajshkljh")

See, this will only return something that can converted to an integer.

Noe, we're taking your input lists and we're creating two new lists, with proper integers:

>>> list1 = ['10', '9', '', '20', '30', '1']>>> list2 = ['15', '2', '', '58', '0', '2']>>> inter1 = [check_for_ints(i) for i in list1 if not  check_for_ints(i) is None]>>> inter2 = [check_for_ints(i) for i in list2 if not check_for_ints(i) is None]>>> inter1[10, 9, 20, 30, 1]>>> inter2[15, 2, 58, 0, 2]

Now, we have interger lists, let us build a list of products:

>>> product = [i*j for i, j in zip(inter1, inter2)]>>> product[150, 18, 1160, 0, 2]

Finally we only have to sum it up:

>>> sum(product)1330

Or without the intermediate steps:

>>> sum(i*j for i, j in zip(        (check_for_ints(i) for i in list1 if not check_for_ints(i) is None),        (check_for_ints(i) for i in list2 if not check_for_ints(i) is None))        )1330

I used list comprehensions here, a powerful tool and shortcut, if you have problems understanding them, read this very nice piece of documentation. Good luck!

Use numpy for a vectorised solution.

import numpy  as np

A = 5
B = 7
y = np.array([1, 2, 3, 4, 5])
x = np.array([6, 7, 8, 9, 10])

# (y_i-A-B*x_i)^2
res = np.sum((y - A - B*x)**2)

A list-based solution is possible, but not recommended.