Python/data_structures/stacks/stack.py at master · imanghotbi-python/Python · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
from __future__ importannotations

fromtypingimportGeneric, TypeVar

T=TypeVar("T")


classStackOverflowError(BaseException):
pass


classStackUnderflowError(BaseException):
pass


classStack(Generic[T]):
"""A stack is an abstract data type that serves as a collection of
 elements with two principal operations: push() and pop(). push() adds an
 element to the top of the stack, and pop() removes an element from the top
 of a stack. The order in which elements come off of a stack are
 Last In, First Out (LIFO).
 https://en.wikipedia.org/wiki/Stack_(abstract_data_type)
 """

def__init__(self, limit: int=10):
self.stack: list[T] = []
self.limit=limit

def__bool__(self) ->bool:
returnbool(self.stack)

def__str__(self) ->str:
returnstr(self.stack)

defpush(self, data: T) ->None:
"""Push an element to the top of the stack."""
iflen(self.stack) >=self.limit:
raiseStackOverflowError
self.stack.append(data)

defpop(self) ->T:
"""
 Pop an element off of the top of the stack.

 >>> Stack().pop()
 Traceback (most recent call last):
 ...
 data_structures.stacks.stack.StackUnderflowError
 """
ifnotself.stack:
raiseStackUnderflowError
returnself.stack.pop()

defpeek(self) ->T:
"""
 Peek at the top-most element of the stack.

 >>> Stack().pop()
 Traceback (most recent call last):
 ...
 data_structures.stacks.stack.StackUnderflowError
 """
ifnotself.stack:
raiseStackUnderflowError
returnself.stack[-1]

defis_empty(self) ->bool:
"""Check if a stack is empty."""
returnnotbool(self.stack)

defis_full(self) ->bool:
returnself.size() ==self.limit

defsize(self) ->int:
"""Return the size of the stack."""
returnlen(self.stack)

def__contains__(self, item: T) ->bool:
"""Check if item is in stack"""
returniteminself.stack


deftest_stack() ->None:
"""
 >>> test_stack()
 """
stack: Stack[int] =Stack(10)
assertbool(stack) isFalse
assertstack.is_empty() isTrue
assertstack.is_full() isFalse
assertstr(stack) =="[]"

try:
_=stack.pop()
raiseAssertionError() # This should not happen
exceptStackUnderflowError:
assertTrue# This should happen

try:
_=stack.peek()
raiseAssertionError() # This should not happen
exceptStackUnderflowError:
assertTrue# This should happen

foriinrange(10):
assertstack.size() ==i
stack.push(i)

assertbool(stack)
assertnotstack.is_empty()
assertstack.is_full()
assertstr(stack) ==str(list(range(10)))
assertstack.pop() ==9
assertstack.peek() ==8

stack.push(100)
assertstr(stack) ==str([0, 1, 2, 3, 4, 5, 6, 7, 8, 100])

try:
stack.push(200)
raiseAssertionError() # This should not happen
exceptStackOverflowError:
assertTrue# This should happen

assertnotstack.is_empty()
assertstack.size() ==10

assert5instack
assert55notinstack


if__name__=="__main__":
test_stack()