Bro, I tried the same thing but they showed me error! donno why!

Another thing to consider is that the object passed in the items parameter may handle indices differently than a standard list (maybe it doesn't support negative indices, for example). In that case, checking that index is between -len(items) and len(items)-1 might lead to unexpected behavior.

challenge accepted! (look at my solution)

The philosophy that dominates in Python is "It is easier to ask for forgiveness than permission". Many things in Python are implemented through exceptions, including every single iterator. They know when they've reached the end of the data because of a StopIteration exception being raised. They are designed to be performant enough that you can use them without too much worry, as long as the exception condition is still considerably less likely than the exception-free path. As always, it's recommended to use timeit to profile code if a section of code is performance-critical to determine what changes make a significant difference, but in general, a tight try and except block improves the reliability and sometimes the readability of code. Optimizations are being made all the time, and now Python 3.11's patch notes even claim that a try block that doesn't raise an exception is now "zero cost".

not sure why these 1 liners are always voted best practice. i think they are more so clever. still very nicely done! will take a half hour to study this now lol

I believe it isn't

list comprehensions are faster than lambda expressions, great...

Well ofc yours is slower because sorting is O(n log n)

IT WAS ALMOST TOO NUTTY FOR ME

study on what self does, and how instances of classes work

class RandomClass():
  def __init__(self, INPUT1, INPUT2, etc..):
    self.INPUT1 = INPUT1   # this takes the inputs and makes them part of the class..
    self.INPUT2 = INPUT2
    self.hiddendata = ["data", "accessed", "by", "entire", "class"] # data that is inate to the class
    
  def add(self, input1, input2):     #self here as well. so you can access self.hiddendata for example
    return self.hiddendata, input1 + input2

there is only 1 object tested. example:

x = Arith("five")
print(x.add("seven"))
this should return "twelve"

interesting! The behaviour of indexing helps :)

This one is nuttier :-)