Python(2)练习

import random
import string




x=string.ascii_letters+string.digits+string.punctuation
y=[random.choice(x) for i in range(1000)]
z=''.join(y)
d=dict()
for ch in z:
    d[ch]=d.get(ch,0)+1

import random
import time


def RandomNumbers(number,start,end):
    data=[]
    n=0
    while True:
        element=random.randint(start,end)
        if element not in data:
            data.append(element)
            n+=1
        if n==number-1:
            break
    return data


def RandomNumbers1(number,start,end):
    data=[]
    while True:
        element=random.randint(start,end)
        if element not in data:
            data.append(element)
        if len(data)==number:
            break
    return data


def RandomNumbers2(number,start,end):
    data=set()
    while True:
        data.add(random.randint(start,end))
        if len(data)==number:
            break
    return data


start=time.time()
for i in range(10000):
    RandomNumbers(50,1,100)
print('time used:',time.time()-start)

class BinaryTree:
    def __init__(self,value):
        self.__left=None
        self.__right=None
        self.__data=value


    def insertLeftChild(self,value):    #创建左子树
        if self.__left:
            print('left child tree already exists')
        else:
            self.__left=BinaryTree(value)
            return self.__left
        
    def insertRightChild(self,value):   #创建右子树
        if self.__right:
            print('right child tree already exists')
        else:
            self.__right=BinaryTree(value)
            return self.__right


    def show(self):
        print(self.__data)


    def preOrder(self):     #前序遍历
        print(self.__data)      #输出根节点的值
        if self.__left:
            self.__left.perOrder()      #遍历左子树
        if self.__right:
            self.__right.perOrder()      #遍历右子树


    def posOrder(self):     #后序遍历
        if self.__left:
            self.__left.posOrder()      #遍历左子树
        if self.__right:
            self.__right.posOrder()      #遍历右子树
        print(self.__data)


    def inOrder(self):     #中序遍历
        if self.__left:
            self.__left.inOrder()      #遍历左子树
        print(self.__data)
        if self.__right:
            self.__right.inOrder()      #遍历右子树


if __name__=='__main__':
    print('please use me as a module')

def searchPath(graph,start,end):
    results=[]
    __generatePath(grapg,[start],end,results)
    results.sort(key=lambda x:len(x))
    return results


def __generatePath(grapg,path,end,results):
    current=path[-1]
    if curent==end:
        results.append(path)
    else:
        for n in graph[current]:
            if n not in path:
                __generatePath(grapg,path+[n],end,results)


def showPath(results):
    print('the path from ',results[0][0],'to',results[0][-1],'is:')
    for path in results:
        print(path)


if __name__=='__main__':
    graph={'A':['B','C','D'],
           'B':['E'],
           'C':['D','F'],
           'D':['B','E','G'],
           'E':['D'],
           'F':['D','G'],
           'G':['E']}
    rl=searchPath(graph,'A','D')
    showPath(rl)