Python range function and its methods

History overlook

In Python 2.x, the built-in function range() module was commonly used for simple terms of operations, i.e. to generate a string of numbers in a array. However, this approach could be memory-intensive for large ranges since it created a list of all the values in the range at once. Also the function worked only with integers. It didn't support the float type (i.e. floating-point numbers/float value in any of its arguments).

As Python language continued to grow in popularity and Python developers began working with increasingly large datasets, a new function called xrange in Python 2.X was introduced in 2002 as a more memory-efficient alternative. xrange() generates a range object that can be iterated over, but it does not consume memory for the entire range at once.

The xrange() function was particularly useful for types of tasks that involved iterating over large sequences of numbers, as it allowed developers to generate these sequences without running out of memory. Here is an example:

# Generate a range of sequence of integers starting from 0 to 999999
my_range = xrange(1000000)

# Iterate over the values in the range
for i in my_range:
    print(i)

As you can see, the usage of xrange() was quite similar to the traditional function, and the only difference was that it was more memory-efficient.

Although the xrange() function was functionally similar to the range() function, it had a much lower memory footprint. To illustrate the difference in memory usage between the two functions, consider this code snippet:

import sys

# using range()
nums1 = range(1000000)
print(sys.getsizeof(nums1))  # prints 9000112 (approx 9MB)

# using xrange()
nums2 = xrange(1000000)
print(sys.getsizeof(nums2))  # prints 40 (approx 40-byte string)

This code snippet shows that the range() function used approximately 9 megabytes of memory, while the xrange() function used only 40 bytes. This significant difference in memory usage made xrange() an excellent choice for wider ranges

Introduction to types generator functions in Python

Now you might be wondering, how did the xrange() function manage to use less memory than the original function in Python 2.x? What changed? The answer lies in the way that xrange() generates its sequence of numbers.

In Python 2.x, the xrange() function was introduced as a generator function. Unlike the original function which generated an entire list of numbers, xrange() generates numbers on-the-fly as they are needed, which means that it doesn't need to store the entire sequence in static memory storage.

Generator functions are a powerful feature of Python that allow you to generate a sequence of values on-the-fly as they are needed, rather than generating an entire list of values all at once. This can be incredibly useful for situations where you need to generate a large sequence of values, but you don't want to store the entire sequence in memory at once. In fact, the xrange() function in Python 2.x was implemented as a generator function. Generator functions have been a part of Python since version 2.2, which was released in 2001. They have continued to be an important feature of the language, and were further improved in Python 3.x with the introduction of the yield from statement. This allowed for more concise and efficient generation of sequences using nested generator functions.

Here's an example of a simple generator function in Python:

def count_up_to(n):
    i = 1
    while i <= n:
        yield i
        i += 1

This function, count_up_to(n), generates a sequence of integers starting from 1 up to and including n (an inclusive value). But notice that instead of returning the entire sequence at once, it uses the yield keyword to generate each value one at a time. By using the yield keyword to temporarily suspend the function's execution and return a inclusive value to the caller. The function can then be resumed later, with its local state preserved, to continue generating more values.

When you call count_up_to(n), it doesn't actually start generating values until you begin loop iteration over it (e.g. using a for loop with range or calling next() on the iterator range object).

Here's an example of how you might use this generator loop iteration in practice:

 for i in count_up_to(5):
    print(i)
# Output
# 1
# 2
# 3
# 4
# 5

The benefit of using a generator function like this is that it allows you to generate a potentially infinite sequence type without needing to store all iterators in static memory storage at once. It can also be more efficient, since you only generate the values that are actually needed, rather than generating the entire sequence upfront.

Memory efficiency

In Python 3.x, the xrange() function was renamed to range(), and the old function was removed. This was done to simplify the language and eliminate confusion, as the range() function now behaved like the xrange() function in Python 2.x.

But the evolution of the function did not stop there. In Python 3.x, the function was further optimised to allow for lazy evaluation of values. This means that the range() function generates values on the fly, as they are needed, rather than generating them all at once.

This lazy evaluation of values makes the function much more memory-efficient and faster than its predecessors. It also allows for the creation of infinite ranges, which can be iterated over without consuming excessive amounts of memory size.

Generator functions are extremely memory-efficient, as they only generate values on an as-needed basis. They can also be used to generate infinite sequences of values, such as the Fibonacci sequence.

Ease of use in Python code

The range() function is a versatile tool for generating sequences of integers. Its functionality can vary depending on the desired types of sequence, but most commonly it is used to generate a sequence of integers from 0 to n, as demonstrated in the following code:

for i in range(n):
    print(i)

However, the range() function can also be used to generate a reverse range of integers from n to 1. Before delving into this functionality, it is worth exploring the range() function in more detail, as the examples thus far only scratch the surface of its potential uses. The function can take one or more arguments with range. When only one argument is provided, the function generates a sequence of integers from 0 to the argument value. For example, to sum all numbers between 1000 and 5000, the following code example can be used:

for i in count_up_to(5):
    print(i)
# Output
# 1
# 2
# 3
# 4
# 5

While this code in Python works, it iterates over 5000 numbers when only 4000 are needed, which can be wasteful when dealing with larger datasets. To avoid this, a second single argument can be provided, specifying the starting value of the sequence. For example:

sum = 0
for i in range(1000, 5000):
    sum += i
print(sum)  # output = 9995000

This code iterates over 4000 numbers, starting at 1000 and ending at 4999. The same result is achieved more efficiently (with less iterators).

In addition, a third argument can be provided to specify the increment value of the sequence. Commonly the default value is 1. However, in the following example, the numeric built-in value is set to 2:

sum = 0
for i in range(1000, 5000, 2):
    sum += i
print(sum)  # output = 2497500

Here, the sequence is generated from 1000 to 4999 with an increment of 2. It only iterates over 2000 numbers, and the sum of the sequence is half of the previous example. To increment by a value other than 2, a third argument can be passed to the function specifying the desired increment value. For example:

sum = 0
for i in range(1000, 5000, 5):
    sum += i
print(sum)

This generates a sequence from 1000 to 4995 with increments in steps of 5.

The range() function is a powerful tool for generating sequences of integers. By providing one or more arguments, the sequence can be tailored to meet specific needs. This flexibility makes it a valuable Python function for a variety of programming tasks.

Fun assignment: If you haven't noticed it so far, let's see if you can notice it now.

sum = 0
for i in range(2, 10, 2):
    sum += i

# The output of the code is:
print(sum)

Did you guess it? If you did, then great, if you didn't then don't worry, it's not that big of a deal. The output of the above code is 20, which is the sum of all the even numbers between 2 and 10. Now some of you might wonder why 20 and why not 30? Because 2 + 4 + 6 + 8 + 10 = 30, well that's because the function doesn't include the upper limit, so it will only iterate over the numbers from 2 to 9 and not 10.

It's important to note that the function behaves differently depending on the number of optional arguments passed to it. If only one argument is passed, the sequence will start from 0. If two arguments are passed, the sequence will start from the first argument. If three are passed, the sequence will start from the first argument and increment by the value of the third argument. If no third argument is passed, the sequence will increment by 1. It's important to remember that if you want to start a sequence from 0 but increment it by a value other than 1, you still need to pass 3 arguments to the function. Otherwise, Python will assume that you only passed 2 arguments increments in steps by 1. These concepts may seem straightforward now, but as you continue reading this article, there may be more complex concepts that are not immediately obvious.