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