Python 使用list实现简单的集合set

#!/usr/bin/python 
# -*- coding: utf-8 -*-

'''
Created on 2015-1-9
@author: beyondzhou
@name: test_linearset.py
'''

def test_linearset():
    
    # import mySet
    from linearset import mySet
    
    print 'Init a set named smith'
    smith = mySet()
    smith.add('CSCI-112')
    smith.add('MATH-121')
    smith.add('HIST-340')
    smith.add('ECON-101')
    
    print '\noutput smith set'
    for element in smith:
        print element
    
    print '\nInit a set named roberts'
    roberts = mySet()
    roberts.add('POL-101')
    roberts.add('ANTH-230')
    roberts.add('CSCI-112')
    roberts.add('ECON-101')
 
    print '\noutput roberts set'
    for element in roberts:
        print element   

    print '\ndo the intersection'
    interSet = smith.interset(roberts)
    for element in interSet:
        print element    
        
    print '\ndo the difference'
    diffSet = smith.difference(roberts)
    for element in diffSet:
        print element    
        
    print '\ndo the union'
    uniSet = smith.union(roberts)
    for element in uniSet:
        print element    
        
    print '\nremove a element in the union'
    uniSet.remove('CSCI-112')
    for element in uniSet:
        print element    
        
if __name__ == "__main__":
    test_linearset()

# Implementation of iter
class _SetIterator:
    def __init__(self, theList):
        self._setItems = theList
        self._curItem = 0
    def __iter__(self):
        return self
    def next(self):
        if self._curItem < len(self._setItems):
            item = self._setItems[self._curItem]
            self._curItem += 1
            return item
        else:
            raise StopIteration
        
# Implementation of the Set ADT container using a Python list
class mySet:
    # Creates an empty set instance
    def __init__(self):
        self._theElements = list()

    # Returns the number of items in the set
    def __len__(self):
        return len(self._theElements)

    # Determines if an element is in the set
    def __contains__(self, element):
        return element in self._theElements

    # Adds a new unique element to the set
    def add(self, element):
        if element not in self:
            self._theElements.append(element)

    # Removes an element from the set
    def remove(self, element):
        assert element in self, "The element must be in the set."
        self._theElements.remove(element)

    # Determines if two sets are equal
    def __eq__(self, setB):
        if len(self) != len(setB):
            return False
        else:
            return self.isSubsetOf(setB)

    # Determines if this set is a subset of setB
    def isSubsetOf(self, setB):
        for element in self:
            if element not in setB:
                return False
        return True

    # Creates a new set from the union of this set and setB
    def union(self, setB):
        newSet = mySet()
        newSet._theElements.extend(self._theElements)
        for element in setB:
            if element not in self:
                newSet._theElements.append(element)
        return newSet

    # Creates a new set from the intersection
    def interset(self, setB):
        newSet = mySet()
        for element in setB:
            if element in self:
                newSet._theElements.append(element)
        return newSet

    def difference(self, setB):
        newSet = mySet()
        for element in self:
            if element not in setB:
                newSet._theElements.append(element)
        return newSet

    # Returns an iterator for traversing the list of items
    def __iter__(self):
        return _SetIterator(self._theElements)

Init a set named smith

output smith set
CSCI-112
MATH-121
HIST-340
ECON-101

Init a set named roberts

output roberts set
POL-101
ANTH-230
CSCI-112
ECON-101

do the intersection
CSCI-112
ECON-101

do the difference
MATH-121
HIST-340

do the union
CSCI-112
MATH-121
HIST-340
ECON-101
POL-101
ANTH-230

remove a element in the union
MATH-121
HIST-340
ECON-101
POL-101
ANTH-230