Reverse a list without using built-in functions

:: is not a function, it's a python literal. as well as []

How to check if ::, [] are functions or not. Simple,

    import dis
    a = [1,2]
    dis.dis(compile('a[::-1]', '', 'eval'))
      1           0 LOAD_NAME                0 (a)
                  3 LOAD_CONST               0 (None)
                  6 LOAD_CONST               0 (None)
                  9 LOAD_CONST               2 (-1)
                 12 BUILD_SLICE              3
                 15 BINARY_SUBSCR
                 16 RETURN_VALUE

If ::,[] were functions, you should find a label CALL_FUNCTION among python instructions executed by a[::-1] statement. So, they aren't.

Look how python instructions looks like when you call a function, lets say list() function

>>> dis.dis(compile('list()', '', 'eval'))
  1           0 LOAD_NAME                0 (list)
              3 CALL_FUNCTION            0
              6 RETURN_VALUE

So, basically

def rev(f):
    return f[::-1]

works fine. But, I think you should do something like Jim suggested in his answer if your question is a homework or sent by you teacher. But, you can add this quickest way as a side note.

If you teacher complains about [::-1] notation, show him the example I gave you.

Your example that works:

y = x[::-1]

uses Python slices notation which is not a function in the sense that I assume you're requesting. Essentially :: acts as a separator. A more verbose version of your code would be:

y = x[len(x):None:-1]

or

y = x[start:end:step]

I probably wouldn't be complaining that python makes your life really, really easily.

Edit to be super pedantic. Someone could argue that calling [] at all is using an inbuilt python function because it's really syntactical sugar for the method __getitem__().

x.__getitem__(0) == x[0]

And using :: does make use of the slice() object.

x.__getitem__(slice(len(x), None, -1) == x[::-1]

But... if you were to argue this, anything you write in python would be using inbuilt python functions.

Another way ( just for completeness :) )

def another_reverse(lst):
    new_lst = lst.copy() # make a copy if you don't want to ruin lst...
    new_lst.reverse() # notice! this will reverse it in place
    return new_lst

Here's a solution that doesn't use built-in functions but relies on list methods. It reverse in-place, as implied by your specification:

>>> x = [1,2,3,4]
>>> def reverse(seq):
...   temp = []
...   while seq:
...     temp.append(seq.pop())
...   seq[:] = temp
... 
>>> reverse(x)
>>> x
[4, 3, 2, 1]
>>> 

ETA

Jim, your answer using insert at position 0 was driving me nuts! That solution is quadratic time! You can use append and pop with a temporary list to achieve linear time using simple list methods. See (reverse is in blue, rev is green):

If it feels a little bit like "cheating" using seq[:] = temp, we could always loop over temp and append every item into seq and the time complexity would still be linear but probably slower since it isn't using the C-based internals.

Here's a solution , using no in-built functions (not even len()) just loops

def reverse(L):

    i = 0
    j = -1
    for x in L:
        j+=1
    while i<j:
        L[i],L[j]=L[j],L[i]
        i+=1
        j-=1
    return L

Another way for completeness, range() takes an optional step parameter that will allow you to step backwards through the list:

def reverse_list(l):
    return [l[i] for i in range(len(l)-1, -1, -1)]

The most pythonic and efficient way to achieve this is by list slicing. And, since you mentioned you do not need any inbuilt function, it completely suffice your requirement. For example:

>>> def reverse_list(list_obj):
...     return list_obj[::-1]
...
>>> reverse_list([1, 3, 5 , 3, 7])
[7, 3, 5, 3, 1]

Just iterate the list from right to left to get the items..

a = [1,2,3,4]

def reverse_the_list(a):
   reversed_list = []
   for i in range(0, len(a)):
     reversed_list.append(a[len(a) - i - 1])
   return reversed_list

new_list = reverse_the_list(a)
print new_list

Without built-in functions

myList = [1,4,7,5,2,3,1]

for i in range(0, len(myList)):
    for j in range(i+1, len(myList)):
        myList[i], myList[j] = myList[j], myList[i]
    
print(myList)

Beautiful answers here, I'd like to add mine without ANY builtin as I just had an interview which required this. Since you don't want to go with the simple list[::-1] option, you can try this also:

def reverse_list(original_list):
    result_list = []
    i = -1
    for _ in original_list:
        result_list.append(original_list[i])
        i -= 1
    return(result_list)

calling the function:

print(reverse_list(['grape', 'banana', 'apple', 'orange', 'papaya', 'mango']))
print(reverse_list([0, 1, 4, 6, 7, 5, 2, 9, 3, 8]))

will output:

['mango', 'papaya', 'orange', 'apple', 'banana', 'grape']
[8, 3, 9, 2, 5, 7, 6, 4, 1, 0]

Do note that the function can also accept a tuple as argument and reverse it appending each item to result_list and finally returns the list.