If you accidentally created an infinite loop and your program sits for a few seconds without printing anything out or terminating, restart the console.
You can do this in Spyder by hitting Ctrl + c (Ctrl key and the c button on your keyboard) in the console. Or go to the button beside the red square at the top of your console and select Restart Kernel. If this doesn't work, restart Anaconda/Spyder.
You can do this in IDLE by clicking Ctrl + F6 or by going to the menu Shell -> Restart Shell

L.append[3] to add (only) one element
L.extend([6,9])
del(L[2]) to delete element at a specific index
L.pop() remove last element and return it
L.pop(2) remove 3rd element and return it
L.remove(2) remove the 1st instance of the specific element (return error if the element is not in the list)
list(stringname) to convert a string to a list
s.split(5) convert a string to a list with two elements <before and after the chosen one)
"".join(L) creates a string by joining the elements of a list.
L.sort() to sort a list and change it
sorted[L] to get a new shorted version of the list'
L.reverse() to reverse a list and change it
L.index(1) finds where it first occurs
listA.count(4) counts how many times the element 4 occurs in the list
L2=L creates the alias L2 copying elements form L. Alias L2 changes when L changes
L3=L[:] creates the clone L3 copying elements form L. Clone L3 doesn't change according to L
L2==L3 checks elements , L2 is L3 checks identity to see if it is alias

Objects have data inside of them but they also have methods and functions. And we get to that by using that dot. 
object.dosomething()
E.g. L.append['f'] 

- abstraction = make a distinction between how to implement the object and how to use it.
- I don't have to think about the internal representation. I don't have to think about the details of how to get at it. I simply know that there are a set of methods associated with it. => I build layers of abstractions that are going to inherit from other classes of objects.
-  I build my own class of objects on top of Python objects.

Why bother sorting before searching?
sort the list first in order to perform a lot of searches
O(sort + K* log(len(L)) < K * O(len(L))
for large K the time to sort is irrelevant 

Bisection Search (list must be sorted)
Complexity linear O(n) ,  O(len(L))
def Bisection_Search(L, x)
    for i to range(len(L)):
        if x==L[i]:
            return True
         elif x>L[i]:
             return False
   return False
 

Bisection Search  - logarithmic complexity O(log(len(L)) because it used indexes to cut the list in half each time
def bisect_Search2(L, x):
    def bisect_Search_helper(L, x, start, end):
        if start==end:
            return L[start]==x
        middle=(start+end)//2
        if L[middle]==x:
            return True
        elif L[middle]>x:
            if start==middle:
                return False
            else:
                return bisect_Search_helper(L, x, start, middle-1)
        else:
            return bisect_Search_helper(L, x, middle+1, end)
    if L==[]:
        return False
    else:
        return bisect_Search_helper(L, x, 0, len(L)-1)       

Bisection Search  - logarithmic complexity O(n log(len(L))
because it is logarithmic for each recursive call and makes a copy of the list
def bisect_Search1(L, x):
    if L==[]:
        return False
    elif len(L)==1:
        return L[0]==x
    else:
        middle=len(L)//2
        if L[middle]>x:
            return bisect_Search1(L[:middle], x)
        else:
            return bisect_Search1(L[middle:], x)

e.g plt.plot(x, y) (x and y could be lists and should have the same length)
if I do a lot of plots they are all shown in the same figure :(
to have a different figure for each plot then: plt.figure('Name')
to label the axis of the plot then: plt.xlabel('Name') , plt.ylabel('Name')
to put a title to the plot: plt.title('Name')
plt.clf() to clear and redraw a plot

1) set limits on the values of the axis
e.g. plt.ylimit(0,1000)
2) plot multiple function in the same display = ovelaying plots
to add a legend that identifies each plot
plt.plot(x, y, label='Name')
plt.legend()  or plt.legend(loc='upper left')
to change the color and the line of the graph I add an argument in the plot:
plt.plot(x, y, 'argument', linewidth=5 ) the argument can contain the color: r,g,b,k and the line type:-,o,--,^ and linewidth determines how thick the line wiil be
e.g: plt.plt(x, y, 'ro', linewidth=5)