Your idea is right, but you can write it down a bit simpler:

list_a = [1,2,3,4,5] # or hh[0]
list_b = [6,7,8,9,0] # or hh[1]
multiplied = [a * b for a, b in zip(list_a, list_b)]

Also, if you want / operator to return float, add from __future__ import division at the top of your source.

One way is to use the outer function of np.multiply (and transpose if you want the same order as in your question):

>>> np.multiply.outer(x, y).T
array([[3, 6],
       [4, 8]])

Most ufuncs in NumPy have this useful outer feature (add, subtract, divide, etc.). As @Akavall suggests, np.outer is equivalent for the multiplication case here.

Alternatively, np.einsum can perform the multiplication and transpose in one go:

>>> np.einsum('i,j->ji', x, y)
array([[3, 6],
       [4, 8]])

A third approach is to insert a new axis in one the arrays and then multiply, although this is a little more verbose:

>>> (x[:, np.newaxis] * y).T
array([[3, 6],
       [4, 8]])

For those interested in performance, here are the timings of the operations, from quickest to slowest, on two arrays of length 15:

In [70]: x = np.arange(15)
In [71]: y = np.arange(0, 30, 2)
In [72]: %timeit np.einsum('i,j->ji', x, y)
100000 loops, best of 3: 2.88 µs per loop
In [73]: %timeit np.multiply.outer(x, y).T
100000 loops, best of 3: 5.48 µs per loop
In [74]: %timeit (x[:, np.newaxis] * y).T
100000 loops, best of 3: 6.68 µs per loop
In [75]: %timeit np.outer(x, y).T
100000 loops, best of 3: 12.2 µs per loop

Use a list comprehension mixed with zip():.

Copy[a*b for a,b in zip(lista,listb)]

Just convert your data to arrays and then simply take a product *. The trick here is to create a 1-d vector of your two values with which you want to multiply. The * then performs element wise multiplication

import numpy as np

mult = np.array([1080, 1920])
inp = np.array([[0.4375, 0.3477366255144033], [0.3599537037037037, 0.676954732510288], 
                [0.5648148148148148, 0.720164609053498], [0.8483796296296297, 0.44238683127572015], 
                [0.8726851851851852, 0.3374485596707819]])

result = inp*mult
# array([[ 472.5       ,  667.65432099],
#        [ 388.75      , 1299.75308642],
#        [ 610.        , 1382.71604938],
#        [ 916.25      ,  849.38271605],
#        [ 942.5       ,  647.90123457]])

EDIT:: Time comparison Both methods work similarly

%timeit inp*mult
# 2.89 µs ± 365 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

%timeit np.multiply(inp, mult)
# 2.55 µs ± 322 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

You are simply defining your array so that it is made of python sets. That is a different data structure which is not able to be multiplied, unlike an array.

Just change your code to this:

array1 = np.array([[1,2,3,4],[5,6,7,8]])

The only difference is using square brackets instead of curly ones. These are python list objects (or standard arrays).

array2=array1*array1  
print(array2)

[[ 1  4  9 16]
 [25 36 49 64]]