Python Generators Are Underutilized

    def square_vals(x : list):
        return (val * val for val in x)

    def square_vals(x : list):
        for val in x:
            yield val * val

The first case creates an anonymous generator. When in doubt you can always use the dis module: https://docs.python.org/3/library/dis.html

Also the name and the generator is nicer (for some definition of nice):

   >>> def square_vals(x : list):
   ...    return (v * v for v in x)
   ... 
   >>> square_vals([1,2,3])
   <generator object square_vals.<locals>.<genexpr> at 0x786b8511f5e0>

   >>> def square_vals_yields(x: list):
   ...     for v in x:
   ...         yield v * v
   ... 
   >>> square_vals_yields([1,2,3])
   <generator object square_vals_yields at 0x786b851f5ff0>

    >>> sum((v*v for v in x))

# Really big generator that would probably crash as a list

divmods = (divmod(x,5) for x in range(100000000000000000000000000000000))

# Create a generator from a generator

remains = (remainder for n, remainder in divmods)

# Runs instantly

next(remains)

If you are going to iterate through some of the resulting thing but not all of it then the generator means you aren't throwing away a bunch of the work that you've done.

It can also be more cache friendly. It doesn't need to allocate a whole new lists worth of memory.

One of the downsides of it being lazy is that if list x is mutated between when you create the generator and when you consume it then those changes are reflected in the generator.

I've done some micro benchmarks and it really depends on what you are doing. Profiling it with cProfile, Pyspy or using %timeit in an Ipython shell will tell you if it makes a difference.

Edit: That was wrong. TIL if you write what looks like a tuple comprehension, it's actually a generator.

To answer the original question though, if you write it as a generator with the yield keyword

  def square(nums: list):
    for num in nums:
      yield num * num