Week 7: Linked List

class LinkedList:
    
    def __init__(self: 'LinkedList', head: object = None, 
                 rest: 'LinkedList' = None) -> None:
        '''
        Attributes of LinkedList:
        1. self.item
        2. self.rest
        3. self.empty
        '''
        self.empty = (head is None) and (rest is None)
        if not self.empty:
            self.item = head
            if rest:
                self.rest = rest
            else: 
                self.rest = LinkedList()
    
    def prepend(self: 'LinkedList', item: object) -> None:
        ''' Add new item to front of self'''
       
        self.empty = False
        self.rest = copy(self)
        self.item = item
        
        
    def decapitate(self: 'LinkedList') -> None:
        ''' Delete item off from front of self'''
        
        if self.empty: # 0 items in LinkedList => no head, no rest
            raise Exception("Can't decapitate empty list!")
        
        elif self.rest.empty: # 1 item in LinkedList => yes head, no rest
            self.empty = True
            del(self.item)
            del(self.rest)
            
        else: # more than 2 items in LinkedList
            self.item = self.rest.item
            self.rest = self.rest.rest
        
    def _contains_(self: 'LinkedList', value: object) -> bool:
        ''' Returns if value is in self 

        3 POSSIBILITIES:
            1. self.empty -> value not in LinkedList -> return False
            2. return if self.item == value
            3. return if value is in self.rest
        '''
        
        return (not self.empty) and (self.item == value or value in self.rest)
        
        
    def __get_item__(self: 'LinkedList', ind:int) -> object:
        ''' Returns item at index ind '''
        
        if self.empty or ind < 0:
            raise IndexError
        elif ind > 0:
            return self.rest.__get_item__(ind - 1)
        else: # ind == 0
            return self.item
        
    def __repr__(self: 'LinkedList'):
        
        if self.empty:
            return 'LinkedList()'
        else:
            return ('LinkedList({}, {})'.format(repr(self.item), repr(self.rest)))

Week 2: Points Covered

property - allows regulation of unwanted user changes

var = property(get_var, set_var, remove_var, None)

Stack

methods:

1. __init__() - initializes items

2. push() - put item on top of stack (end of items)

3. pop() - remove item on top of stack (end of items)

4. isempty() - checks if items is empty (to prevent unwanted popping of empty stack)

Code: http://www.cdf.toronto.edu/~heap/148/W14/Lectures/danny/W2/stack.py

unittest.Testcase - makes sure implementation is consistent with interphase

import unittest

from filename import Classname

class ClassnameEmptyTestCase(unittest.TestCase):

...

3 Shortcuts on Python:

1. sets

list1 = [1,2,3]

list2 = [2,3,4]

set(list1) - set(list2) = (1) #things in list1 not in list2

set(list1).intersection(set(list2)) = (2,3) # things in both list1 and list2

2. list comprehensions - returns new list with expression applied to every item in list

new_list = [expression for item in list]

*does its work for tuples?

3. ternary if - replaces if...else body

expression1 if condition and else expression2

Recursion - when tracing, don't trace every single calculation. if result is calculated from a recursive call (that is simple), simply replace the expression with the result