如何用栈实现浏览器的前进和后退？

from typing import Optional	
 
	
 
	
class ArrayStack:	
    def __init__(self, nums):	
        # 初始化数组	
        self._data = list()	
        # 数组的大小	
        self._nums = nums	
        # 数组元素个数	
        self._count = 0	
 
	
    def push(self, data) -> bool:	
        '''	
        入栈	
        :param data:	
        :return:	
        '''	
        if (self._count + 1) == self._nums:	
            # 栈已经满了	
            return False	
 
	
        self._data.append(data)	
        self._count += 1	
        return True	
 
	
    def pop(self) -> Optional[int]:	
        '''	
        出栈	
        :return:	
        '''	
        if self._count:	
            value = self._data[self._count - 1]	
            self._data.pop(self._count - 1)	
            self._count -= 1	
            return value	
 
	
    def __repr__(self) -> str:	
        '''	
        打印栈	
        :return:	
        '''	
        nums = reversed(self._data)	
 
	
        return " ".join("[{}]".format(num) for num in nums)	
 
	
 
	
if __name__ == '__main__':	
    stack = ArrayStack(10)	
 
	
    for i in range(15):	
        stack.push(i)	
    # 输出：[8] [7] [6] [5] [4] [3] [2] [1] [0]	
    print(stack)	
 
	
    for _ in range(5):	
        stack.pop()	
    # 输出：[3] [2] [1] [0]	
    print(stack)

from typing import Optional	
 
	
 
	
# 链表结点类	
class Node:	
    def __init__(self, data: int, next=None):	
        self._data = data	
        self._next = next	
 
	
 
	
class LinkedStack:	
    """	
    链表实现的栈	
    """	
 
	
    def __init__(self):	
        self._top = None	
 
	
    def push(self, value: int):	
        '''	
        入栈，将新结点放在链表首部	
        :param value:	
        :return:	
        '''	
        new_top = Node(value)	
        new_top._next = self._top	
        self._top = new_top	
 
	
    def pop(self) -> Optional[int]:	
        if self._top:	
            value = self._top._data	
            self._top = self._top._next	
            return value	
 
	
    def __repr__(self) -> str:	
        '''	
        打印栈元素	
        :return:	
        '''	
        current = self._top	
        nums = []	
        while current:	
            nums.append(current._data)	
            current = current._next	
        return " ".join("[{}]".format(num) for num in nums)	
 
	
if __name__ == '__main__':	
    stack = LinkedStack()	
    # 入栈	
    for i in range(9):	
        stack.push(i)	
    # 输出：入栈结果:  [8] [7] [6] [5] [4] [3] [2] [1] [0]	
    print('入栈结果: ', stack)	
    # 出栈	
    for _ in range(3):	
        stack.pop()	
    # 输出：出栈结果:  [5] [4] [3] [2] [1] [0]	
    print('出栈结果: ', stack)

def add(x, y):	
    sum = x + y	
    return sum	
 
	
def main():	
    a = 1	
    ret = 0	
    res = 0	
    ret = add(3, 5)	
    res = a + ret	
    print('%d', res)

from Stack.linked_stack import LinkedStack	
import copy	
 
	
 
	
class NewLinkedStack(LinkedStack):	
    def is_empty(self):	
        return not self._top	
 
	
 
	
class Browser():	
    def __init__(self):	
        # forward_stack 保存打开浏览器或者前进时候的页面	
        self.forward_stack = NewLinkedStack()	
        # back_stack 保存后退时候从 forward_stack 弹出的页面	
        self.back_stack = NewLinkedStack()	
 
	
    def can_forward(self):	
        if self.back_stack.is_empty():	
            return False	
        return True	
 
	
    def can_back(self):	
        if self.forward_stack.is_empty():	
            return False	
        return True	
 
	
    def open(self, url):	
        print('Open new url {}'.format(url))	
        self.forward_stack.push(url)	
 
	
    def back(self):	
        if self.forward_stack.is_empty():	
            return	
        # 点击后退按钮，从 forward_stack 中弹出当前页面，并保存到 back_stack 中	
        top = self.forward_stack.pop()	
        self.back_stack.push(top)	
        print('back to {}'.format(top))	
 
	
    def forward(self):	
        if self.back_stack.is_empty():	
            return	
        # 点击前进按钮，从　back_stack 中弹出，然后保存到 forward_stack 中	
        top = self.back_stack.pop()	
        self.forward_stack.push(top)	
        print('forward to {}'.format(top))	
 
	
    def __repr__(self):	
        copy_forward_stack = copy.deepcopy(self.forward_stack)	
        url_list = list()	
        while not copy_forward_stack.is_empty():	
            url_list.append(copy_forward_stack.pop())	
        return " ".join("{}".format(url) for url in url_list)	
 
	
 
	
if __name__ == '__main__':	
    browser = Browser()	
    browser.open('a')	
    browser.open('b')	
    browser.open('c')	
    print('open the browser: {}'.format(browser))	
    if browser.can_back():	
        browser.back()	
 
	
    if browser.can_forward():	
        browser.forward()	
 
	
    browser.back()	
    browser.back()	
    browser.back()	
    print('browser: {}'.format(browser))	
 

Open new url a	
Open new url b	
Open new url c	
open the browser: c b a	
back to c	
forward to c	
back to c	
back to b	
back to a	
browser: