Python: Alter elements of a list

Question

I have a list of booleans where occasionally I reset them all to false. After first writing the reset as:

for b in bool_list:
    b = False

I found it doesn't work. I spent a moment scratching my head, then remembered that of course it won't work since I'm only changing a reference to the bool, not its value. So I rewrote as:

for i in xrange(len(bool_list)):
    bool_list[i] = False

and everything works fine. But I found myself asking, "Is that really the most pythonic way to alter all elements of a list?" Are there other ways that manage to be either more efficient or clearer?

Answer 1

If you only have one reference to the list, the following may be easier:

bool_list = [False] * len(bool_list)

This creates a new list populated with False elements.

See my answer to Python dictionary clear for a similar example.

Answer 2

I wouldn't use the range and len. It's a lot cleaner to use enumerate()

for i, v in enumerate(bool_list): #i, v = index and value
    bool_list[i] = False

It's left with an unused variable in this case, but it still looks cleaner in my opinion. There's no noticeable change in performance either.

Answer 3

For value types such as int, bool and string, your 2nd example is about as pretty as its going to get. Your first example will work on any reference types like classes, dicts, or other lists.

Answer 4

If you're willing to use numpy arrays, it's actually really easy to do things like this using array slices.

import numpy

bool_list = numpy.zeros((100,), dtype=numpy.bool)

# do something interesting with bool_list as if it were a normal list

bool_list[:] = False
# all elements have been reset to False now

Answer 5

Here's another version:

bool_list = [False for item in bool_list]

Answer 6

I think

bool_list = [False for element in bool_list]

is as pythonic as it gets. Using lists like this should generaly be faster then a for loop in python too.

Answer 7

bool_list[:] = [False] * len(bool_list)

or

bool_list[:] = [False for item in bool_list]

Answer 8

Summary Performance-wise, numpy or a list multiplication are clear winners, as they are 10-20x faster than other approaches.

I did some performance testing on the various options proposed. I used Python 2.5.2, on Linux (Ubuntu 8.10), with a 1.5 Ghz Pentium M.

Original:

python timeit.py -s 'bool_list = [True] * 1000' 'for x in xrange(len(bool_list)): bool_list[x] = False'

1000 loops, best of 3: 280 usec per loop

Slice-based replacement with a list comprehension:

python timeit.py -s 'bool_list = [True] * 1000' 'bool_list[:] = [False for element in bool_list]'

1000 loops, best of 3: 215 usec per loop

Slice-based replacement with a generator comprehension:

python timeit.py -s 'bool_list = [True] * 1000' 'bool_list[:] = (False for element in bool_list)'

1000 loops, best of 3: 265 usec per loop

Enumerate:

python timeit.py -s 'bool_list = [True] * 1000' 'for i, v in enumerate(bool_list): bool_list[i] = False'

1000 loops, best of 3: 385 usec per loop

Numpy:

python timeit.py -s 'import numpy' -s 'bool_list = numpy.zeros((1000,), dtype=numpy.bool)' 'bool_list[:] = False'

10000 loops, best of 3: 15.9 usec per loop

Slice-based replacement with list multiplication:

python timeit.py -s 'bool_list = [True] * 1000' 'bool_list[:] = [False] * len(bool_list)'

10000 loops, best of 3: 23.3 usec per loop

Reference replacement with list multiplication

 python timeit.py -s 'bool_list = [True] * 1000' 'bool_list = [False] * len(bool_list)'

10000 loops, best of 3: 11.3 usec per loop