Python基础回顾 - 1

# ()是元组
# []是列表
# ""或者''是字符串
# 元组/列表/字符串都是有序的,意味着可以直接对其中某个特定位置的元素进行访问
# 但是只有列表是可修改的, 元组和字符串不支持直接修改; 同时, 这三种数据类型都是异构的, 意味着可以在一个里面可以使用不同的类型的数据
# {}是集
# 集是无序的, 这是符合直觉的
# 字典是键-值结构:keys-values
# 字典也是无序的, 但是可以通过键对其值进行访问/获取; 要注意, 字典并不是根据键来进行有序维护的, 键的位置是由散列决定的

#这个实验还挺有意思, 表现了一个按序访问和列表/字符串之间的关系
wordlist = ['cat','dog','rabbit']
letterlist = []
for aword in alist:
    for aletter in aword:
        letterlist.append(aletter)
letterlist

# 这个实验就展示了一下迭代的数学公式和代码之间的联系
# newtoon法的公式就是new = (1/2)*(old + n/old)
# 然后不断去迭代就行, 迭代的次数越高精度就越高
def squareroot(n):
    root = n/2
    for times in range(30):
        root = ( 1 / 2) * ( root + ( n / root ) )
    return root
# 现在想来, 所谓面向对象指的其实是一个部位
# 将每一个功能独立的作为一个对象实际上并不合适
# 需要再对qt的运行逻辑进行一些学习, 比如槽如果是依靠slot和signal进行触发传递的话, 要怎么进行程序的设计呢?
# 下面是一个Fraction类的实验
# 这个实验包含了 重写默认实现/定义类
# 还顺带重构了一个__moren__的一个默认模式

class _Fraction:
    def __init__(self, top, bottom):
        self.num = top
        self.den = bottom
    # 求最大余数的算法
    def gcd(self,m,n):
        while m%n !=0:
            oldm = m
            oldn = n
            m = oldn
            n = oldm%oldn
        return n
    def show(self):
        print(self.num, "/",self.den)
        
    def __str__(self):
        return str(self.num) + '/' + str(self.den)
    
    def __add__(self, another):
        newnum = self.num * another.den + self.den * another.num
        newden = self.den * another.den
        common = self.gcd(newnum, newden)
        return _Fraction(newnum//common, newden//common)
    def __eq__(self, another):
        t1 = self.num * another.den
        t2 = self.den * another.num
        return t1 == t2

# 面向对象的实践:超类
# 要学会画图设计程序, 知道哪一块, 哪一个部件是做什么用的
class _LogicGate:
    def __init__(self, n):
        self.label = n
        self.output = None
    def getLabel(self):
        return self.label
    
# 这一步其实很漂亮, 它揭示了一个事情在于, 对于一个Parent来说, 我只希望他
# 保留一个访问的接口, 或者说对于Children来说能够被称为"共性"的属性
# 在这里, 不同的Gate之间, 它们都有名字与单输出, 那么针对这个特性, 就可以设计
# 让这个Parent具有这个属性
    def getoutput(self):
        self.output = self.performGateLogic()
        return self.output
# 下面就是一个具体实现的过程
# 根据输入, 能够分为两输入与单输入, 那么就可以分为
# Binary与Unary
# 对于Binary的输入, 又可以分为与门和或门两种, 再继承Binary进行设计
# 如此一来, 就能够做到抽丝剥茧, 层层传递, 将最重要的功能放在最细致的框架里面实现
class _BinaryGate(_LogicGate):
    
    def __init__(self, n):
        super().__init__(n)
        
        self.pinA = None
        self.pinB = None
    
    def getPinA(self):
        if self.pinA == None:
            return int(input("Enter pinA input for gate" + ' ' + self.getLabel() + "-->"))
        else:
            return self.pinA.getfront().getoutput()
    
    def getPinB(self):
        if self.pinB ==None:
            return int(input("Entre pinB input for gate" + ' ' +  self.getLabel() + "-->"))
        else:
            return self.pinB.getfront().getoutput()
    
    def setNextPin(self, source):
        if self.pinA == None:
            self.pinA = source
        else:
            if self.pinB == None:
                self.pinB = source
            else:
                raise RuntimeError("Error:No")
        
class _UnaryGate(_LogicGate):
    def __init__(self, n):
        super().__init__(n)
        
        self.pin = None
    def getPin(self):
        if self.pin == None:
            return int(input("Enter pin input for gate" + ' ' + self.getLabel() + "-->"))
        else:
            return self.pin.getfront().getoutput()
    def setNextPin(self, source):
        self.pin = source

class _AndGate(_BinaryGate):
    
    def __init__(self, n):
        super().__init__(n)
        
    def performGateLogic(self):
        a = self.getPinA()
        b = self.getPinB()
        if a == 1 and b == 1:
            return 1
        else:
            return 0
class _OrGate(_BinaryGate):
    
    def __init__(self, n):
        super().__init__(n)
    
    def performGateLogic(self):
        a = self.getPinA()
        b = self.getPinB()
        if a == 0 and b == 0:
            return 0
        else:
            return 1
class _FeiGate(_UnaryGate):
    def __init__(self, n):
        super().__init__(n)
    def performGateLogic(self):
        temp = self.getPin()
        return 1-temp
class _Connector():
    def __init__(self, front, back):
        self.fg = front
        self.bg = back
        back.setNextPin(self)
    def getfront(self):
        return self.fg
    def getback(self):
        return self.bg
# 上面这段代码的功能用于实现了一个逻辑门电路

# 实现一个栈
class Stack:
    def __init__(self):
        self.items = []
    def isEmpty(self):
        return self.items == []
    def push(self, item):
        self.items.append(item)
    def pop(self):
        return self.items.pop()
    def peek(self):
        return self.items[len(self.items) - 1]
    def size(self):
        return len(self.items)
# 实现一个队列
class Queue:
    def __init__(self):
        self.items = []
    def isEmpty(self):
        return self.items == []
    def eq(self, item):
        self.items.insert(0, item)
    def dq(self):
        return self.items.pop()
    def size(self):
        return len(self.items)
# 实现一个双端队列
class Deque:
    def __init__(self):
        self.items = []
    def isEmpty(self):
        return self.items == []
    def eqf(self, item):
        self.items.insert(0, item)
    def dqf(self):
        return self.items.pop(0)
    def eqb(self, item):
        self.items.append(item)
    def dqb(self):
        return self.items.pop()
    def size(self):
        return len(self.items)
# 实现一个

# 下面是一个用面向对象的思考方式实现的一个打印排队模拟程序
class _printer:
    def __init__(self, ppm):
        self.pagerate = ppm
        self.currentTask = None
        self.timeremain = 0
    def tick(self):
        if self.currentTask != None:
            self.timeremain -= 1
            if self.timeremain <= 0:
                self.currentTask = None
    def busy(self):
        if self.currentTask != None:
            return True
        else:
            return False
    def startNext(self, newtask):
        self.currentTask = newtask
        self.timeremain = newtask.getpage()*60/self.pagerate
import random
class Task:
    def __init__(self, time):
        self.timestamp = time
        self.pages = random.randrange(1, 21)
    def getstamp(self):
        return self.timestamp
    def getpage(self):
        return self.pages
    def waittime(self, currenttime):
        return currenttime - self.timestamp
def simulation(numSeconds, pagesPerMinute):
    labprinter = _printer(pagesPerMinute)
    waitQ = Queue()
    waitingtimes = []
    for currentSecond in range(numSeconds):
        if newPrintTask():
            task = Task(currentSecond)
            waitQ.eq(task)
        if(not labprinter.busy()) and (not waitQ.isEmpty()):
            nexttask = waitQ.dq()
            waitingtimes.append(nexttask.waittime(currentSecond))
            labprinter.startNext(nexttask)
        labprinter.tick()
    averagewait = sum(waitingtimes)/len(waitingtimes)
    print("Average wait %6.2f secs %3d tasks remaining."%(averagewait,waitQ.size()))

def newPrintTask():
    num = random.randrange(1,181)
    if num ==180:
        return True
    else: 
        return False
# 下面是一个回文检测器
def huiwen(check_string):
    deque = Deque()
    for s in check_string:
        deque.eqb(s)
    while deque.size() > 1:
        a = deque.dqf()
        b = deque.dqb()
        if a == b:
            continue
        else:
            return False
    if deque.size() == 1:
        return False
    else:
        return True