Python Topics : range() Function
Construct Numerical Ranges
Count From Zero
a call to range() with one argument creates a range that counts from zero and up to but exclusive of the number provided 
>>> range(5)
range(0, 5)

>>> list(range(5))
[0, 1, 2, 3, 4]
Count From Start to Stop
can call range() with two arguments
the first value is the start of the range
the range will count up to, but not include, the second value
>>> range(1, 7)
range(1, 7)

>>> list(range(1, 7))
[1, 2, 3, 4, 5, 6]
Count From Start to Stop While Stepping Over Numbers
a third optional argument specifies the step between elements in the range
by default the step is one
can pass any non-zero integer
>>> range(1, 20, 2)
range(1, 20, 2)

>>> list(range(1, 20, 2))
[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
Use range() Function to Create Specific Ranges

range() is not a function
range is a type or class
range() is the constructor of the range class

range is a lazy sequence
when a range is created, the individual elements are not created
elements are created on demand

Handle Ranges Over Negative Numbers
using negative numbers as arguments works similarly to positive numbers 
>>> range(-10, 0)
range(-10, 0)

>>> list(range(-10, 0))
[-10, -9, -8, -7, -6, -5, -4, -3, -2, -1]

>>> range(-7, -3)
range(-7, -3)

>>> list(range(-7, -3))
[-7, -6, -5, -4]
Work With an Empty Range
an empty range will be created when the two arguments are equal 
>>> range(0)
range(0, 0)

>>> list(range(0))
[]

>>> range(4, 2)
range(4, 2)

>>> list(range(4, 2))
[]
Count Backward With Negative Steps
the default range step is 1
any integer can be the step except 0 
>>:> range(20, 0, -2)
range(20, 0, -2)

>>:> list(range(20, 0, -2))
[20, 18, 16, 14, 12, 10, 8, 6, 4, 2]

>>:> range(5, -1, -1)
range(5, -1, -1)

>>:> list(range(5, -1, -1))
[5, 4, 3, 2, 1, 0]
Loop Through Ranges or Use an Alternative

typically use for loops to iterate over ranges
for loop is based on sequence elements and not indexes
while loop repeats an operation until a certain condition is reached

Repeat an Operation
to repeat an operation a for loop is suitable 
>>> for _ in range(3):
...     print("Knock, knock, knock")
...     print("Penny!")
...
Knock, knock, knock
Penny!
Knock, knock, knock
Penny!
Knock, knock, knock
Penny!
two for loops used to create a table 
>>> for number in range(1, 11):
...     for product in range(number, number * 11, number):
...         print(f"{product:>4d}", end="")
...     print()
...
   1   2   3   4   5   6   7   8   9  10
   2   4   6   8  10  12  14  16  18  20
   3   6   9  12  15  18  21  24  27  30
   4   8  12  16  20  24  28  32  36  40
   5  10  15  20  25  30  35  40  45  50
   6  12  18  24  30  36  42  48  54  60
   7  14  21  28  35  42  49  56  63  70
   8  16  24  32  40  48  56  64  72  80
   9  18  27  36  45  54  63  72  81  90
  10  20  30  40  50  60  70  80  90 100
Loop Directly Over the Iterator Instead
in most loops the index of elements isn't necessary 
>>> word = "Loop"
>>> for index in range(len(word)):
...     print(word[index])
...
L
o
o
p
a loop's data source is an iterable
can loop directly on the data source itself 
>>> word = "Loop"
>>> for char in word:
...     print(char)
...
L
o
o
p
Use enumerate() to Create Indices Instead
to work with both indices and the corresponding elements use enumerate()
enumerate takes an iterable as an argument enumerate() generates an index for each element 
>>> word = "Loop"
>>> for index, char in enumerate(word):
...     print(index, char)
...
0 L
1 o
2 o
3 p
optional argument to enumerate() is the start argument
index begins at start instead of 
>>> word = "Loop"
>>> for index, char in enumerate(word, start=1):
...     print(index, char)
...
1 L
2 o
3 o
4 p
below grid represents a treasure map
treasure locations are marked with an X
center of the map is coordinate 0,0 and marked with a o
split() is Python's version of trim() 
>>> grid = """
... .............
... .........X...
... ...X..o......
... .............
... ...........X.
... """.strip()
...
... rows = grid.split("\n")
... for row, line in enumerate(rows, start=-(len(rows) // 2)):
...     for col, char in enumerate(line, start=-(len(line) // 2)):
...         if char == "X":
...             print(f"Treasure found at ({row}, {col})")
...
Treasure found at (-1, 3)
Treasure found at (0, -3)
Treasure found at (2, 5)
Use zip() for Parallel Iteration Instead
if looping over several sequences at the same time, use indices to find elements corresponding to each other 
>>> countries = ["Norway", "Canada", "Burkina Faso"]
>>> capitals = ["Oslo", "Ottawa", "Ouagadougou"]
>>> for index in range(len(countries)):
...     print(f"The capital of {countries[index]} is {capitals[index]}")
...
The capital of Norway is Oslo
The capital of Canada is Ottawa
The capital of Burkina Faso is Ouagadougou
range() is used to create indexes
better to use zip() 
>>> countries = ["Norway", "Canada", "Burkina Faso"]
>>> capitals = ["Oslo", "Ottawa", "Ouagadougou"]
>>> for country, capital in zip(countries, capitals):
...     print(f"The capital of {country} is {capital}")
...
The capital of Norway is Oslo
The capital of Canada is Ottawa
The capital of Burkina Faso is Ouagadougou
zip() generates a tuple
unpack the tuple of each iteration
no need to use indexes
Other Features and Uses of Ranges
Access Individual Numbers of a Range
can use square bracket notation to pick out a single element from a range 
>>> numbers = range(1, 20, 2)

>>> numbers[3]
7

>>> numbers[-2]
17
Create Subranges With Slices
use slices to create new ranges from existing ranges

in slice syntax use a colon (:) to separate arguments
arguments specify start, stop, and optionally a step for the slice
a slice like [1:5] starts from index 1 and runs up to, but not including, index 5
can add a step at the end
[1:5:2] will run from index 1 to 5 but only include every second index 

>>> numbers = range(1, 20, 2)
>>> list(range(1, 20, 2))
[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
>>> numbers[1:5]
range(3, 11, 2)
>>> list(numbers[1:5])
[3, 5, 7, 9]

>>> numbers[1:5:2]
range(3, 11, 4)
>>> list(numbers[1:5:2])
[3, 7]
the expression range(3, 11, 2)
  • 3 - is the starting number of the range
  • 11 - exclusive end number
  • 2 - step size
the expression range(3, 11, 4)
  • 3 - is the starting number of the range
  • 11 - exclusive end number
  • 4 - step size
the step size is 4 because the range being operated on contains the numbers 3, 5, 7 and 9
the new range is constructed using the range being operated with a step of 2
the new range contains the numbers 3 and 7
the difference between the numbers is the step size

Check Whether a Number Is a Member of a Range
can check if a value is contained by a range using the in operator 
>>> year = 2023
>>> year in range(2000, 2100, 4)
False

>>> year = 2024
>>> year in range(2000, 2100, 4)
True
Calculate the Number of Elements in a Range
for single-step ranges the number of elements can be calculated by taking the difference between the arguments
for ranges using steps other than 1 
>>> import math
>>> start, stop, step = 1, 20, 2
>>> math.ceil((stop - start) / step)
10
can also use the len function 
>>> numbers = range(1, 20, 2)
>>> len(numbers)
10
Reverse a Range
can use the reversed() function
function knows how to reverse many iterables 
>>> numbers = range(1, 20, 2)
>>> reversed(numbers)
<range_iterator object at 0x7f92b5050090>

>>> list(reversed(numbers))
[19, 17, 15, 13, 11, 9, 7, 5, 3, 1]
calling reversed() creates a range_iterator object which can be used in loops
range_iterator isn't a full range object
doesn't support many of the features of a range object
can't slice it or ask for its length
can manually create a new reversed range 
>>> def reverse_range(rng):
...     return range(
...         rng.stop - rng.step,
...         rng.start - rng.step,
...         -rng.step,
...     )
...
>>> reverse_range(range(5, 0, -1))
range(1, 6)

>>> reverse_range(reverse_range(range(5, 0, -1)))
range(5, 0, -1)
Create a Range Using Integer-Like Parameters
when setting up rangescan also use integer-like numbers like binary numbers or hexadecimal numbers 
>>> range(0b110)
range(0, 6)

>>> range(0xeb)
range(0, 235)
0b110 is the binary representation of 6
0xeb is the hexadecimal representation of 235
index