itertools and strided list assignment

Question

Given a list, e.g. x = [True]*20, I want to assign False to every other element.

x[::2] = False

raises TypeError: must assign iterable to extended slice

So I naively assumed you could do something like this:

x[::2] = itertools.repeat(False)

or

x[::2] = itertools.cycle([False])

However, as far as I can tell, this results in an infinite loop. Why is there an infinite loop? Is there an alternative approach that does not involve knowing the number of elements in the slice before assignment?

EDIT: I understand that x[::2] = [False] * len(x)/2 works in this case, or you can come up with an expression for the multiplier on the right side in the more general case. I'm trying to understand what causes itertools to cycle indefinitely and why list assignment behaves differently from numpy array assignment. I think there must be something fundamental about python I'm misunderstanding. I was also thinking originally there might be performance reasons to prefer itertools to list comprehension or creating another n-element list.

Answer 1

What you are attempting to do in this code is not what you think (i suspect) for instance:
x[::2] will return a slice containing every odd element of x, since x is of size 20,
the slice will be of size 10, but you are trying to assign a non-iterable of size 1 to it.

to successfully use the code you have you will need to do:

x = [True]*20
x[::2] = [False]*10

wich will assign an iterable of size 10 to a slice of size 10.

Why work in the dark with the number of elements? use

len(x[::2])  

which would be equal to 10, and then use

x[::2] = [False]*len(x[::2])

you could also do something like:

x = [True if (index & 0x1 == 0) else False for index, element in enumerate(x)]

---

EDIT: Due to OP edit

The documentation on cycle says it Repeats indefinitely. which means it will continuously 'cycle' through the iterator it has been given.

Repeat has a similar implementation, however documentation states that it
Runs indefinitely unless the times argument is specified.
which has not been done in the questions code. Thus both will lead to infinite loops.

About the itertools being faster comment. Yes itertools are generally faster than other implementations because they are optimised to be as fast as the creators could make them.

However if you do not want to recreate a list you can use generator expressions such as the following:

x = (True if (index & 0x1 == 0) else False for index, element in enumerate(x))

which do not store all of their elements in memory but produce them as they are needed, however, generator functions can be used up.

for instance:

x = [True]*20
print(x)
y = (True if (index & 0x1 == 0) else False for index, element in enumerate(x))
print ([a for a in y])
print ([a for a in y])

will print x then the elements in the generator y, then a null list, because the generator has been used up.