用Python復習離散數學（一）

　　最近要復習離散數學，不想掛啊，但是又想編程，大家知道啦，程序員離不開代碼啊，所用想邊復習邊寫代碼，所以就自己用代碼去實現一下離散的知識點，當做復習，自知自己的Python很渣，也想借此鞏固一下基礎，哈哈，事不宜遲，開始吧！

　　1.集合

　　概念：集合是由指定范圍內的某些特定對象聚集在一起構成的，元素就是集合中的每一個對象

　　怎么用python實現集合呢，這個我自定義了一個類，這個類中有一個構造方法，底層我用列表是存儲集合中的元素，用add方法可以添加元素，show方法就可以展示元素

class MySet():
    __num = 0
    
    def __init__(self):
        self.s = []
        
    def show(self):
        self.str = '{'
        for x in self.s:
            if x == self.s[self.__num - 1]:
                self.str += x
            else:
                self.str += x + ', '
        self.str += '}'
        print self.str
        
    def add(self, element):
        self.__num += 1
        self.s.append(element)

測試一下：

s = MySet()
s.add('a')
s.add('b')
s.show()

#結果
#{a, b}

這樣好樣就有點味道了，爽爽的，杠杠的。

　　1.1集合與集合的關系

　　在這個這里我們要明白集合的幾個特定性，集合的無序性，MySet類可以符合，但是還有個互異性我們就解決，互異性就是不能出現相同的元素，所以我們的add方法要改造一下：

    def add(self, element):
        __flag = 0
        for x in self.s:
            if x == element:
                __flag = 1
                print '%s element is exist!' % element
        if __flag == 0:
            self.__num += 1
            self.s.append(element)

 這樣就解決了元素的互異性

　　外延性原理：兩個集合A和B相等，當且僅當它們有相同的元素，記為A=B，否則A與B不相等，記為A！=B

　　程序怎么實現呢，我首先向MySet類添加下列方法，length方法拿到集合的長度，get方法根據索引那元素的值，checkExist方法檢查元素是否存在在改集合中，setEqual方法就是判斷集合相等的核心方法。

    def length(self):
        return self.__num
    
    def get(self, index):
        if index >= 0 and index < self.__num:
            return self.s[index]
        else:
            print 'no exist'
    
    def checkExist(self, element):
        for x in self.s:
            if x == element:
                return True
        return False
    
    def setEqual(self, setTemp):
        if self.__num == setTemp.length():
            for x in range(setTemp.length()):
                if self.checkExist(setTemp.get(x)):
                    continue
                else:
                    return False
            return True
        else:
            return False

 測試一下：

s1 = MySet()
s1.add('a')
s1.add('b')
s2 = MySet()
s2.add('a')
s2.add('b')
print s1.setEqual(s2)

#結果
#True

　　判斷是否為子集，這個也就是包含關系，其實我很經常弄錯誰包含誰的，所以現在要搞清楚了：如果B的每個元素都是A的元素，則成B是A的子集，也成稱B被A包含，或者A包含B，就是大的包含小的，OK，理解了，然后就看看程序怎么實現，我們通過isSubset方法去實現判斷：

    def isSubset(self, setTemp):
        for x in range(setTemp.length()):
            if self.checkExist(setTemp.get(x)):
                continue
            else:
                return False
        return True

 　　在集合中有一個非常特殊的集合，不含任何元素的集合，稱為空集，謹記，空集是任何集合的子集，我們通過isEmptySet方法來判斷這個集合是不是空集。 

    def isEmptySet(self):
        if self.__num == 0:
            return True
        else:
            return False

 　　集合的運算：

　　並運算：

union方法及測試：

    def union(self, setTemp):
        newSet = MySet()
        for x in self.s:
            newSet.add(x)
        for x in range(setTemp.length()):
            if newSet.checkExist(setTemp.get(x)):
                continue
            else:
                newSet.add(setTemp.get(x))
        return newSet
    
s1 = MySet()
s1.add('a')
s2 = MySet()
s2.add('b')
s2.add('a')
s2.add('c')
s3 = s1.union(s2)
s3.show() 

 　　交運算：

intersection方法的實現：

    def intersection(self, setTemp):
        newSet = MySet()
        for x in range(setTemp.length()):
            if self.checkExist(setTemp.get(x)):
                newSet.add(setTemp.get(x))
        return newSet

 　　差運算：(A-B表示一個差集，集合中只有屬於A自己獨有的元素)

subtraction方法的實現：

    def subtraction(self, setTemp):
        newSet = MySet()
        for x in self.s:
            if setTemp.checkExist(x):
                continue
            else:
                newSet.add(x)
        return newSet

　　補運算：（首先要判斷一下兩者的關系是不是正確的，然后再去算補集）

complement方法的實現：

    def complement(self, setTemp):
        newSet = MySet()
        if setTemp.isSubset(self):
            for x in range(setTemp.length()):
                if self.checkExist(setTemp.get(x)):
                    continue
                else:
                    newSet.add(setTemp.get(x))
            return newSet
        else:
            print 'error in relation'
            return newSet

　　對稱差運算：（對稱差集就是兩個集合的並集減去兩個集合的交集，其實簡單的說就是並集和交集的差集）

sysmmetric方法的實現：

    def sysmmetric(self, setTemp):
        newSet1 = self.union(setTemp)
        newSet2 = self.intersection(setTemp)
        return newSet1.subtraction(newSet2)