The problem here is that your method implementation doesn't work on all cases.

def reverse_evens(my_list):
    return my_list[::2][::-1]

[::2] is to pick out all the even index elements from the iteralbe; then use [::-1 to reverse the elements.

You have to consider the length of your string

list = [0, 1, 2, 3, 4, 5]

If I use your code, I will get [5, 3, 1], but what I want is actually [4, 2, 0] (even index)

Therefore, you have to separate your code into 2 using if.

if len(list)% 2 == 0:
    <return what?>
else:
    <return what?>

Try it first!! If you have any problem feel free to find me. Good Luck!!

The fact you need to use

return list[::2][::-1]

to pass that challenge is ridiculous. It's anti-Pythonic, and creates additional work that would be obtuse to novitiates or people who are not overly familiar with Python.

My solution, which is vastly more elegant (and is reflected in other comments here) is preferable and considered more ideal syntactically.

return list[::-2]

or 

return list[-1::-2] 

both return the same result. Why can it not be used?

def reverse_evens(given_list):
      return given_list[::2][::-1]

This code as some people have used here DOES complete the challenge. It is what I had to use to complete the challenge, but it does not actually fulfill the conditions that the instructions seem to require.

Since there is no list given, the code should theoretically be written such that in any given list, reverse_evens could be used to return, in reverse order, only the even numbers from that list. Using this code completes the challenge but doesn't work as a catch all for any list, only lists that start and maybe end with an even number. If given_list = [1, 2, 3, 4, 5, 6, 7, 8, 9] what happens is this code will break that list down into every other number, and then return the ones left in reverse order. Essentially, the list breaks down into [1, 3, 5, 7, 9], and then reverses into [9, 7, 5, 3, 1].

This challenge either needs to be modified, or more needs to be taught on the use of the modulo '% 2' in order to use only the even numbers in a list like the one above.

This is an accurate solution that works fine in the shell and using any interpreter except the built in interpreter from treehouse:

def reverse_evens(items): return items[::-2] #reversing order and providing all the even indexes

result: [15, 13, 11, 9, 7, 5, 3, 1]

I believe there is a bug with python collections > slice functions> Challenge Task 4 of 4

THIS WAS MY PREVIOUS COMMENT:

This is an accurate solution that works fine in the shell and using any interpreter except the built in interpreter from treehouse:

def reverse_evens(items): return items[::-2] #reversing order and providing all the even indexes

result: [15, 13, 11, 9, 7, 5, 3, 1]

I believe there is a bug with python collections > slice functions> Challenge Task 4 of 4

However for the built in interpreter on treehouse it is only accepting

TRY THIS AND YOU WILL PASS:

def reverse_evens(items): return items[::2][::-1]

As Tomasz said, there is some issue with treehourse interpreter. The following code works fine in python interpreter for 4th challenge:

def reverse_evens(items):
    return items[::-2]

I tried to write like this, but it is wrong, why? def reverse_evens(ite): ite_new=ite[::-1] ite_new2=ite_new[::2] return ite_new2

How is it different from my approach:

def rev_even(e):
    return e[::-1][::2]

How does it make a difference from:

def rev_even(e):
    return e[::2][::-1]

Aren't they both return same solution?

we never been taught

def reverse_evens(iterable): return iterable[::2][::-1]

aiyaaaaaaaaa

Why this answer is not correct?

def reverse_evens(item_list):
    return item_list[::-2]

list = [1, 2, 3, 4, 5]
print(reverse_evens(list))

My Python interpreter in PyCharm made it work correctly, even in my mac terminal

def reverse_evens(item_list): item = item_list[0::2] return item[::-1]

list = [1, 2, 3, 4, 5] print(reverse_evens(list))

"" def reverse_evens(item_list): item = item_list[0::2] return item[::-1]

list = [1, 2, 3, 4, 5] print(reverse_evens(list)) ""

how is this:

-> return items[::2][::-1]

different from this? :

-> return items[-2:-9999:-1]

Though long, this one works in Jupyter but not in the treehouse interpretor:

def reverse_evens(iterable):  
    L=[]  
    for x in range(0,len(iterable)):  
        if (x % 2) ==0:  
            L.append(iterable[x])  
    L.sort(reverse=True)  
    return L  

The above is not much different than the answer that worked for me for the previous challenge:

 def odds(iterable):  
     L=[]  
     for x in range(0,len(iterable)):  
         if (x % 2) ==1:  
             L.append(iterable[x])  
     return L

The instruction is very confusing. Thank you Andrew Calhoun. Your suggestion works! return list[::2][::-1]

return my_list[::2][::-1]

I think what makes this task most confusing is that this idea of being able to slice a list twice like this has never been touched on up to this point. The syntax looks weird, almost like we're tying to splice a multi-dimensional list?? weird, right?

but I guess this makes enough sense and should pass:

my_list = my_list[::2]
my_list = my_list[::-1]
return my_list

But I'm really confused as to why this does not pass (anymore?):

my_list = my_list[::2]
my_list.reverse()
return my_list

It seems like the most obvious solution to the instructions and yet the feedback when you fail is not at all helpful.

I used this code below and it worked perfectly in a text editor/terminal, but not accepted by this challenge??

def reverse_even(iterable):

    if len(iterable) % 2 == 0:
        return iterable[-2::-2]

    if len(iterable) % 2 == 1:
        return iterable[-1::-2]

actually this is working for me with the python interpreter, not with the question workspace in treehouse.

def reverse_evens(iter):
    iter.sort(reverse=True)
    return iter[0::2]

Wow. This one was tough. After realizing the length of the list would affect the outcome I came up with this solution:

def reverse_evens(iterable_list2): if len(iterable_list2) % 2== 0: new_list = iterable_list2[::2] else: new_list = iterable_list2[0:len(iterable_list2):2]

return(new_list[::-1])

print(reverse_evens(['1','2','3','4','5','6','7','8','9','10','11','12']))

Note: it prints the even index, not the even numbers. In my print example the even index numbers are odd numbers in the list

This is what I have, and the third function worked fine until the 4th challenge, now the 3rd function no longer works for this challenge, so weird.

def first_4(iterable): return iterable[0:4]

def first_and_last_4(iterable): return iterable[:4] + iterable[-4:]

def odds(iterable): return iterable[0::2]

def reverse_evens(iterable): return iterable[4::-2]

This one need to be done with slices. My code is good when i use it in jupyter, but here doesnt work.

n = list(range(6)) def reverse_evens(n): return n[::-2] print(reverse_evens(n))

and result is [5, 3, 1]

HI Here is my answer

def reverse_evens(item_list):
      item = item_list[0::2]
      return item[::-1]


list = [1, 2, 3, 4, 5]
print(reverse_evens(list))