range gives you and iterator between (start, end) end not included. So in your case the iterator is (start=len(list_of_numbers), end=6). Since len(list_of_numbers) = 5, this translates to range(5,6) which is 1 element, 5, since 6 is excluded. https://docs.python.org/3/library/functions.html#func-range

In this code part-

array=[1,2,3,4,5]

for record in range(0,2,array): print(record)

The range function takes 3 parameters. First one is starting index,second one is ending index and the third one is the gap in which you want the numbers to be. So,going by an example-

for i in range(0,5,2): print(i)

This code will print 0,2,4 as answer. The range function will start from 0 and will return every 2nd number till 4(not 5,because 5 is excluded).

Your code gives an error because you have mentioned an array as your 3rd parameter but it is expecting an integer

for record in range(0,2,len(array)): print(record)

You could try this,but it will only return 0 because essentially this for loop simplifies to-

for record in range(0,2,5)

So after returning the starting number it will try to get the next 5th number which you dont have(as 2nd parameter is 2). Hope this clarifies.

There are multiple different ways to approach this answer (bold emphasis mine):

What is the reason python uses range in for loops?

This is not a for loop. It is a foreach loop. I.e. it is not a loop that loops over a pre-defined set of loop indices, it is an iterator that iterates over the elements of a collection.

In particular, in

for e in [2, 3, 5, 7, 11, 13, 17]:
    print(e)

The result will not be

0
1
2
3
4
5
6

but

2
3
5
7
11
13
17

What is the reason python uses range in for loops?

It doesn't. It uses an arbitrary expression. More precisely, an arbitrary expression that evaluates to an iterator or to something that can be implicitly converted to an iterator (such as an iterable):

class MyIterator:
    def __init__(self):
        self.counter = -1
        self.lost = [4, 8, 15, 16, 23, 42]

    def __next__(self):
        self.counter += 1

        if self.counter == 6:
            raise StopIteration

        return self.lost[self.counter]

class MyIterable:
    def __iter__(self):
        return MyIterator()

my_iterable = MyIterable()

for num in my_iterable:
    print(num)

# 4
# 8
# 15
# 16
# 23
# 42

Is there some philosophical reasoning behind why python uses this syntax

Yes: It is more general and thus makes the language simpler. The BASIC for loop can do one thing and one thing only: loop over a pre-defined set of loop indices. In fact, it is even more limited than that, because there are further restrictions on the loop indices: they need to be monotonically increasing or decreasing with a fixed step size.

If you want the indices to be non-monotonic, you need a new language construct. If you want the indices to have varying step sizes, you need a new language construct. If you want to iterate over the elements of a collection, you need a new language construct.

With Python's foreach loop, you can simply have a function that generates indices in whatever order you want, and loop over those. You can iterate over the elements of any arbitrary collection, and note that "collection" is interpreted very broadly.

Actually, you can iterate over the elements of any arbitrary iterator. An iterator can be something very general, and it doesn't even have to be finite, e.g. "all prime numbers".

As I have shown above, it is very easy to create your own custom iterators and iterables. It is in fact even more easy using generator functions:

def my_generator():
    yield 4
    yield 8
    yield 15
    yield 16
    yield 23
    yield 42

for num in my_generator():
    print(num)

# 4
# 8
# 15
# 16
# 23
# 42

And even more easy with generator expressions.

If Python is supposed to be more human readable than most languages, in this case particular case it seems to be worse than say Sinclair BASIC.

If you are looping over loop indices in Python (or any modern language, really), you are doing it wrong.

You should be using higher-level iterators instead, such as reduce (you may also know this one under the name fold or more general Catamorphism), accumulate (you may also know this one under the name scan or prefix-sum), cycle, chain, groupby, or product. Or, you should be using list / set / dictionary comprehensions, generator expressions, or algorithms and data structures supplied by the standard library or third-party libraries.