def test_pop(self):
s = Stack()
self.assertRaises(IndexError, s.pop)
for i in range(50):
s.push(i)
for i in range(50):
k = s.pop()
self.assertEqual(k, (49 - i))
self.assertRaises(IndexError, s.pop)
def test_push(self):
s = Stack()
self.assertTrue(s.is_empty())
s.push('a')
self.assertFalse(s.is_empty())
for i in range(50):
n = random.randint(0, 1000)
s.push(n)
self.assertEqual(s.peek(), n)
def test_is_empty(self):
s = Stack()
self.assertTrue(s.is_empty())
for i in range(10):
s.push(i)
self.assertFalse(s.is_empty())
for i in range(10):
s.pop()
self.assertTrue(s.is_empty())
def test_nonempty_stack():
s = Stack()
s.push(1)
s.push(2)
assert len(s) == 2
assert s.pop() == 2
assert len(s) == 1
assert s.pop() == 1
assert len(s) == 0
assert s.pop() == None
def suffix_to_tree(self):
node_stack = Stack()
op_num = 0
for elm in self.exp_elements_suffix:
node = Node()
if elm < Const.Min:
node.type = Const.NumNode
node.num = Num(elm)
else:
op_num += 1
node.type = Const.OpNode
node.right = node_stack.pop()
node.left = node_stack.pop()
node.op = elm
node_stack.push(node)
self.tree = BinaryTree(node_stack.pop(), op_num)
def __init__(self, template):
super().__init__(template)
self.history_stack = Stack()
self.pager = 1
class Pager(View, ABC):
cache_size = 10
# 默认 请求页数 1
# 缓存页面 默认为 10
def __init__(self, template):
super().__init__(template)
self.history_stack = Stack()
self.pager = 1
def on_destroy(self):
self.data = None
def next_pager(self):
self.pager = self.pager + 1
# 缓存上一页的数据
if self.history_stack.size() > self.cache_size:
# 缓存页数据出栈
self.history_stack.pop()
self.history_stack.push(self.data)
self.data = self.get_data()
# 重新打印当前内
def up_pager(self):
# 缓存队列
self.pager = self.pager - 1
# 如果前一页有缓存 不为空
if not self.history_stack.size() == 0:
self.data = self.history_stack.pop()
else:
if self.pager < 2:
self.pager = 1
self.data = self.get_data()
def get_data(self):
self.show_loading()
return json.loads(get_plate_info(self.id, self.pager))
def show_loading(self):
self.print_text("加载中...")
def handler_input(self, ip):
"""
:param ip: 输入
:return: 是否传递输入给 APP
"""
if ip == Config.instance.pg_down:
self.next_pager()
return True
if ip == Config.instance.pg_up:
self.up_pager()
return True
if ip.startswith(Config.instance.prefix_re):
self.do_reply(ip[len(Config.instance.prefix_re):])
return True
if ip == Config.instance.pg_re:
self.refresh()
return True
if is_number(ip):
return self.index_type(ip)
def do_reply(self, text):
"""
text 输入 页
:param text:
:return:
"""
Route.instance.show_toast(post_string(self.id, text))
def index_type(self, ip):
Route.instance.push({"name": "info", "parm": self.data[int(ip)]["id"]})
return True
def on_creat(self):
self.id = Route.instance.cur_intent["parm"]
def analize(self):
check = 1
initialStack = Stack()
workingStack = Stack()
output = []
initialStack.push(')')
initialStack.push('a')
initialStack.push('+')
initialStack.push('a')
initialStack.push('(')
initialStack.push('*')
initialStack.push('a')
workingStack.push(self.grammar.startingSymbol)
while not initialStack.isEmpty():
print(workingStack)
print(initialStack)
print(self.grammar.table[(workingStack.peek(), initialStack.peek())])
if workingStack.peek() == 'e':
workingStack.pop()
if self.grammar.table[(workingStack.peek(), initialStack.peek())][0] == 'pop':
workingStack.pop()
initialStack.pop()
else:
if len(self.grammar.table[(workingStack.peek(), initialStack.peek())]) > 0:
l = copy.deepcopy(self.grammar.table[(workingStack.peek(), initialStack.peek())][0][0])
print(l)
nr = self.grammar.table[(workingStack.peek(), initialStack.peek())][0][1]
print(nr)
workingStack.pop()
while l:
workingStack.push(l[-1])
del l[-1]
output.append(nr)
else:
check=0
print("error")
break
while not workingStack.isEmpty() and check == 1:
output.append(self.grammar.table[(workingStack.peek(), 'e')][0][1])
workingStack.pop()
print(output)
def test_str(self):
s = Stack()
self.assertEqual(str(s), '')
for i in range(5):
s.push(i)
self.assertEqual(str(s), '4\n3\n2\n1\n0')
s.pop()
s.pop()
self.assertEqual(str(s), '2\n1\n0')
s.pop()
s.push(300)
s.push(10)
self.assertEqual(str(s), '10\n300\n1\n0')
while (not s.is_empty()):
s.pop()
n = random.randint(1, 365)
s.push(n)
self.assertEqual(str(s), str(n))
def test_equals(self):
sa = Stack()
sb = Stack()
sc = Stack()
self.assertEqual(sa, sb)
for i in range(50):
n = random.randint(1, 1000)
sa.push(n)
self.assertNotEqual(sa, sb)
while (not sa.is_empty()):
k = sa.pop()
sb.push(k)
sc.push(k)
self.assertEqual(sb, sc)
while (not sb.is_empty()):
k = sb.pop()
sa.push(k)
while (not sc.is_empty()):
k = sc.pop()
sb.push(k)
self.assertEqual(sa, sb)
def test_peek(self):
s = Stack()
self.assertRaises(IndexError, s.peek)
s.push(0)
self.assertEqual(s.peek(), 0)
s.push(1)
self.assertEqual(s.peek(), 1)
s.pop()
self.assertNotEqual(s.peek(), 1)
def test_empty_stack():
s = Stack()
assert s.size() == 0
assert len(s) == 0
def infix_to_suffix(self):
op_stack = Stack()
for element in self.exp_elements_infix:
if element == Const.Pow or element == Const.LeftBracket:
# 左括号和乘方必定入栈
op_stack.push(element)
elif element == Const.Mul or element == Const.Div:
# 乘除法需要弹出乘方与乘除
while op_stack.size() > 0 and \
(op_stack.peek() == Const.Mul or op_stack.peek() == Const.Div or op_stack.peek() == Const.Pow):
op = op_stack.pop()
self.exp_elements_suffix.append(op)
op_stack.push(element)
elif element == Const.Plus or element == Const.Sub:
while op_stack.size() > 0 and (op_stack.peek() !=
Const.LeftBracket):
op = op_stack.pop()
self.exp_elements_suffix.append(op)
op_stack.push(element)
elif element == Const.RightBracket:
while op_stack.peek() != Const.LeftBracket:
op = op_stack.pop()
self.exp_elements_suffix.append(op)
op_stack.pop()
else:
self.exp_elements_suffix.append(element)
while op_stack.size() > 0:
self.exp_elements_suffix.append(op_stack.pop())