# Python One Line Generator

A generator function is a Pythonic way to create an iterable without explicitly storing it in memory. This reduces memory usage of your code without incurring any additional costs.

The following code shows a function `get_numbers(n)` that returns a list of `n` random numbers.

```import random

# NOT A GENERATOR!
# Create and return a list of numbers
def get_numbers(n):
numbers = []
for i in range(n):
numbers.append(random.random())

# List of n elements exists in memory
return numbers

# Sum up 1000 random numbers
s = 0
for x in get_numbers(1000):
s += x
print(s)```

However, this is not very efficient code because you create a list in advance without need. What if you had 1,000,000,000 numbers? Your memory would quickly fill up!

A better way is to use a generator function with the `yield` keyword that creates the random numbers dynamically as they are iterated over:

```import random

# GENERATOR
# Generate numbers one by one
def generate_numbers(n):
for i in range(n):
yield random.random()

# Sum up 1000 random numbers
s = 0
for x in generate_numbers(1000):
s += x
print(s)```

There are two big advantages to using a generator:

• (1) You don’t have to create a huge list first and store it in memory but generate the next element as you iterate over it.
• (2) It’s shorter and more concise.

However, it may not be concise enough for you! π So, here’s the problem addressed in this article:

Problem: Can we write a one-line generator?

Let’s dive into different methods to accomplish this!

## Method 1: One-Liner Generator Function

`print(sum(random.random() for i in range(1000)))`

The code consists of the following parts:

• The `print()` function prints the result of the expression to the shell.
• The `sum()` function sums over all values in the following iterable.
• The generator expression `random.random() for i in range(1000)` generates 1000 random numbers and feeds them into the outer `sum()` function without creating all of them at once.

This way, we still don’t store the whole list of 1000 numbers in memory but create them dynamically.

## Method 2: Generator Expression in Parentheses

By passing a statement of the form `(expression context)` into the parentheses `()`, such as `(x**2 for x in range(10))`, you create a generator object that modifies each element of an iterator specified in the context. In our example, the generator would create the first 10 square numbers.

But it doesn’t actually instantiate these numbers right away to remain memory-efficient as you can see here:

```numbers = (x**2 for x in range(10))
print(numbers)
# <generator object <genexpr> at 0x0000021FB07F3EB0>```

The numbers are not yet created, only the “blueprint” of how the numbers will be created if you force Python to do that.

Here, you iterate over the generator and print all ten numbers:

```for i in numbers:
print(i)```

Output:

```0
1
4
9
16
25
36
49
64
81```

π Recommended Tutorial: Generator Expressions in Python

## Method 3: exec()

The following method is not pretty—but it solves the problem of creating a generator in a single line of code.

```exec('def g(n):\n    for i in range(n):\n        yield random.random()')
```

The `exec()` function can be used to one-linerize every Python code snippet under the sun. How?

π‘ Just pass the code you want to run as a string and replace all newlines with the newline character `'\n'`. This way, you can create a generator function `g(n)` that dynamically creates `n` random numbers.

You can now iterate them using the standard code snippet:

```s = 0
for x in g(1000):
s += x
print(s)
# 488.318368852096```

Because the numbers are random, the output will be different for you. You can try it yourself in our interactive shell:

Exercise: What’s the output for you? Why is it different than ours?

## Python One-Liners Book: Master the Single Line First!

Python programmers will improve their computer science skills with these useful one-liners.

Python One-Liners will teach you how to read and write “one-liners”: concise statements of useful functionality packed into a single line of code. You’ll learn how to systematically unpack and understand any line of Python code, and write eloquent, powerfully compressed Python like an expert.

The book’s five chapters cover (1) tips and tricks, (2) regular expressions, (3) machine learning, (4) core data science topics, and (5) useful algorithms.

Detailed explanations of one-liners introduce key computer science concepts and boost your coding and analytical skills. You’ll learn about advanced Python features such as list comprehension, slicing, lambda functions, regular expressions, map and reduce functions, and slice assignments.

You’ll also learn how to:

• Leverage data structures to solve real-world problems, like using Boolean indexing to find cities with above-average pollution
• Use NumPy basics such as array, shape, axis, type, broadcasting, advanced indexing, slicing, sorting, searching, aggregating, and statistics
• Calculate basic statistics of multidimensional data arrays and the K-Means algorithms for unsupervised learning
• Create more advanced regular expressions using grouping and named groups, negative lookaheads, escaped characters, whitespaces, character sets (and negative characters sets), and greedy/nongreedy operators
• Understand a wide range of computer science topics, including anagrams, palindromes, supersets, permutations, factorials, prime numbers, Fibonacci numbers, obfuscation, searching, and algorithmic sorting

By the end of the book, you’ll know how to write Python at its most refined, and create concise, beautiful pieces of “Python art” in merely a single line.

Get your Python One-Liners on Amazon!!