I have written the following Python code:
numbers = [42, 4224, 42422424, -250]
products = numbers*157
products
This leads to the following output:
42,
4224,
42422424,
-250,
42,
4224,
42422424,
-250,
42,
4224,
42422424,
-250,
etc: this order is repeated several times, probably 157 times.
Why does this code not multiply each of the array elements with 157? This should be:
[6594, 663168, 6660320568, -39250]
Multiplying a list by any constant c will repeat the elements in the list by a c number of times.
To better understand what's going on here, you should start by multiplying the list by a smaller constant and eventually work your way up to 157. Let's start by multiplying the list by 1:
products = numbers*1
print(products)
[42, 4224, 42422424, -250]
We can see that multiplying the list by 1 will just send us back our original list, since the elements are only included once in the list. Next, we'll multiply the list by 2:
products = numbers*2
print(products)
[42, 4224, 42422424, -250, 42, 4224, 42422424, -250]
We can see that the elements are repeated twice in the same list. You can increase the constant on your own to observe the increased amount of repetition.
As others have suggested, you can simply use either list comprehension or numpy arrays to retrieve your desired output:
Method 1: List Comprehension
products = [i*157 for i in numbers]
print(products)
[6594, 663168, 6660320568, -39250]
List comprehension is essentially shorthand for writing a loop that multiplies each individual element by 157, in our situation.
Method 2: Numpy Arrays
products = np.array(numbers)*157
print(products)
array([6594, 663168, 6660320568, -39250])
Numpy is a module used for array-processing and data manipulation. You can read more about the benefits of numpy here.
Performance Testing
I'll include some performance differences below. This is also a good example that includes multiplying a list by a constant and multiplying its elements by a constant.
>>> timeit.timeit('[i*157 for i in numbers]', 'numbers=[42, 4224, 42422424, -250]', number=1000000)
0.35015837100013414
>>> timeit.timeit('numbers*157', 'import numpy as np;numbers=np.array([42, 4224, 42422424,-250])', number=1000000)
0.639420188000031
>>> timeit.timeit('[i*157 for i in numbers]', 'numbers=[42, 4224, 42422424,-250]*500', number=1000000)
91.96342155899993
>>> timeit.timeit('numbers*157', 'import numpy as np;numbers=np.array([42, 4224, 42422424,-250]*500)', number=1000000)
1.3476544480001849
Typically, numpy arrays are known to perform better than ordinary Python lists for larger array-like data. However, there are certain instances where Python lists can perform better than numpy arrays, which you can read more about here.
Why does this code not multiply each of the array elements with 157?
You've already got an excellent answer about how to solve your problem of multiplying the numbers in a list by 157. I'll try to address the question of why numbers * 157 behaves the way that it does in Python, rather than the way you think it should.
Being able to repeat the sequence in a list to create a new, longer list is rather useful for initialising a list with some constant initial value. For example, if you want a list of 100 zeroes, you can write [0] * 100. This is a common thing to want to do, so Python makes it easy, and if you read a lot of Python code then you'll become familiar with this "idiom". You might also see for example [None] * 100 to create a list populated with None values.
That second example raises another point; lists in Python can contain any type of data, not just numbers. It would be strange if Python's lists privileged numbers in some way, by having operations which only worked when the list elements were numbers. For example, the expression ['hello', 'world'] * 10 would be an error if this * meant multiplication of numbers.
Another good reason for the behaviour of * on lists is to be consistent with the behaviour of +. In Python when you have two lists and you write list1 + list2, the result will be a new list containing everything in list1 followed by everything in list2. This is called concatenation, and it is very common to want to concatenate lists or other sequences, so Python makes it easy. Given this, it makes sense that numbers + numbers should mean the same thing as numbers * 2; both expressions create a list containing everything from the list numbers, twice.
What you want to do is achieved by numpy arrays. In a normal list array, doing numbers * 157 will do the repetition that you obtained. For your desired output,
import numpy as np
products = np.array(numbers) * 157
This outputs
array([ 6594, 663168, 6660320568, -39250])
