Call int() function on every list element?

Transforming lists: Beyond the basics

Memory-friendly generators

For giant lists, a generator expression can perform the conversion while saving memory:

nums = ['1', '2', '3']
# Generators: because memory is expensive, save it!
ints_gen = (int(x) for x in nums)
ints = list(ints_gen)


A generator yields values one at a time — it's memory-efficient and ideal when dealing with massive data.

The magic of map and unpacking

The map() function paired with unpacking, offers an additional way for the conversion:

nums = ['1', '2', '3']
# Unpacking map: turning fun-sized map into king-sized list.
ints = [*map(int, nums)]


The * operator alongside map is like unwrapping a present, releasing the converted elements from their iterable wrapping into a list.

Comprehensions vs map: The showdown

Though similar in performance, list comprehensions and map() have strengths that might sway your preference. map() is concise, while comprehensions are often more self-explanatory. Choose based on readability.

Tricky scenarios and solutions

Handling mixed-type lists

Non-string elements can throw a spanner in the works. Be ready with this approach:

mixed = ['1', 2, '3']
# Avoiding TypeError minefields with isinstance()
ints = [int(x) for x in mixed if isinstance(x, str)]


This safeguards your code, applying int() only to strings, and dodges potential TypeError landmines.

Safeguarding against conversion errors

Unconvertible string elements in your list? Keep calm and handle errors:

nums = ['a', '2', '3']

def safe_int_convert(x):
    try:
        return int(x)
    except ValueError:
        # When int(x) gives you lemons, return None!
        return None

ints = [safe_int_convert(x) for x in nums]


This ensures safe conversion, non-convertible elements return None.

The functional style with map

The strategy above can be mirrored using map(), where you provide a function as an argument:

nums = ['a', '2', '3']
# Just map and chill!
ints = list(map(safe_int_convert, nums))


This approach safely maps the function onto each list element.

Python versions and their quirks

Python 2.x caveats with map

If you're time-traveling in Python 2.x, beware: map() behaves a bit differently:

nums = ['1', '2', '3']
# Python 2.x map: a map that's already a list. How convenient!
ints = map(int, nums)  # Output is already a list in Python 2.x


There's no need to use list conversion or unpacking as map() hands you a list right off the bat.