Add typing annotations to Python codes. (#411)

codes/python/chapter_stack_and_queue/array_deque.py

@@ -4,94 +4,94 @@ Created Time: 2023-03-01
 Author: Krahets (krahets@163.com)
 """
 
-import os.path as osp
-import sys
-
+import sys, os.path as osp
 sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
 from modules import *
 
+
 class ArrayDeque:
     """ 基于环形数组实现的双向队列 """
-    def __init__(self, capacity):
-        """  构造方法 """
-        self.nums = [0] * capacity
-        self.front = 0
-        self.que_size = 0
 
-    def capacity(self):
+    def __init__(self, capacity: int) -> None:
+        """ 构造方法 """
+        self.__nums: List[int] = [0] * capacity
+        self.__front: int = 0
+        self.__size: int = 0
+
+    def capacity(self) -> int:
         """ 获取双向队列的容量 """
-        return len(self.nums)
+        return len(self.__nums)
 
-    def size(self):
+    def size(self) -> int:
         """ 获取双向队列的长度 """
-        return self.que_size
+        return self.__size
 
-    def is_empty(self):
+    def is_empty(self) -> bool:
         """ 判断双向队列是否为空 """
-        return self.que_size == 0
+        return self.__size == 0
 
-    def index(self, i):
+    def index(self, i: int) -> int:
         """ 计算环形数组索引 """
         # 通过取余操作实现数组首尾相连
         # 当 i 越过数组尾部后，回到头部
         # 当 i 越过数组头部后，回到尾部
         return (i + self.capacity()) % self.capacity()
 
-    def push_first(self, num):
+    def push_first(self, num: int) -> None:
         """ 队首入队 """
-        if self.que_size == self.capacity():
+        if self.__size == self.capacity():
             print("双向队列已满")
             return
         # 队首指针向左移动一位
         # 通过取余操作，实现 front 越过数组头部后回到尾部
-        self.front = self.index(self.front-1)
+        self.__front = self.index(self.__front - 1)
         # 将 num 添加至队首
-        self.nums[self.front] = num
-        self.que_size += 1
+        self.__nums[self.__front] = num
+        self.__size += 1
 
-    def push_last(self, num):
+    def push_last(self, num: int) -> None:
         """ 队尾入队 """
-        if self.que_size == self.capacity():
+        if self.__size == self.capacity():
             print("双向队列已满")
             return
         # 计算尾指针，指向队尾索引 + 1
-        rear = self.index(self.front + self.que_size)
+        rear = self.index(self.__front + self.__size)
         # 将 num 添加至队尾
-        self.nums[rear] = num
-        self.que_size += 1
+        self.__nums[rear] = num
+        self.__size += 1
 
-    def poll_first(self):
+    def poll_first(self) -> int:
         """ 队首出队 """
         num = self.peek_first()
         # 队首指针向后移动一位
-        self.front = self.index(self.front+1)
-        self.que_size -= 1
+        self.__front = self.index(self.__front + 1)
+        self.__size -= 1
         return num
 
-    def poll_last(self):
+    def poll_last(self) -> int:
         """ 队尾出队 """
         num = self.peek_last()
-        self.que_size -= 1
+        self.__size -= 1
         return num
 
-    def peek_first(self):
+    def peek_first(self) -> int:
         """ 访问队首元素 """
         assert not self.is_empty(), "双向队列为空"
-        return self.nums[self.front]
+        return self.__nums[self.__front]
 
-    def peek_last(self):
+    def peek_last(self) -> int:
         """ 访问队尾元素 """
         assert not self.is_empty(), "双向队列为空"
         # 计算尾元素索引
-        last = self.index(self.front + self.que_size - 1)
-        return self.nums[last]
+        last = self.index(self.__front + self.__size - 1)
+        return self.__nums[last]
 
-    def to_array(self):
+    def to_array(self) -> List[int]:
         """ 返回数组用于打印 """
         # 仅转换有效长度范围内的列表元素
         res = []
-        for i in range(self.que_size):
-            res.append(self.nums[self.index(self.front+i)])
+        for i in range(self.__size):
+            res.append(self.__nums[self.index(self.__front + i)])
         return res
 
 
@@ -105,9 +105,9 @@ if __name__ == "__main__":
     print("双向队列 deque =", deque.to_array())
 
     """ 访问元素 """
-    peek_first = deque.peek_first()
+    peek_first: int = deque.peek_first()
     print("队首元素 peek_first =", peek_first)
-    peek_last = deque.peek_last()
+    peek_last: int = deque.peek_last()
     print("队尾元素 peek_last =", peek_last)
 
     """ 元素入队 """
@@ -117,15 +117,15 @@ if __name__ == "__main__":
     print("元素 1 队首入队后 deque =", deque.to_array())
 
     """ 元素出队 """
-    poll_last = deque.poll_last()
+    poll_last: int = deque.poll_last()
     print("队尾出队元素 =", poll_last, "，队尾出队后 deque =", deque.to_array())
-    poll_first = deque.poll_first()
+    poll_first: int = deque.poll_first()
     print("队首出队元素 =", poll_first, "，队首出队后 deque =", deque.to_array())
 
     """ 获取双向队列的长度 """
-    size = deque.size()
+    size: int = deque.size()
     print("双向队列长度 size =", size)
 
     """ 判断双向队列是否为空 """
-    is_empty = deque.is_empty()
+    is_empty: bool = deque.is_empty()
     print("双向队列是否为空 =", is_empty)

codes/python/chapter_stack_and_queue/array_queue.py

@@ -4,59 +4,57 @@ Created Time: 2022-12-01
 Author: Peng Chen (pengchzn@gmail.com)
 """
 
-import os.path as osp
-import sys
-
+import sys, os.path as osp
 sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
 from modules import *
 
 class ArrayQueue:
     """ 基于环形数组实现的队列 """
-    def __init__(self, size):
+    def __init__(self, size: int) -> None:
         """ 构造方法 """
-        self.__nums = [0] * size  # 用于存储队列元素的数组
-        self.__front = 0          # 队首指针，指向队首元素
-        self.__size = 0           # 队列长度
+        self.__nums: List[int] = [0] * size  # 用于存储队列元素的数组
+        self.__front: int = 0          # 队首指针，指向队首元素
+        self.__size: int = 0           # 队列长度
 
-    def capacity(self):
+    def capacity(self) -> int:
         """ 获取队列的容量 """
         return len(self.__nums)
 
-    def size(self):
+    def size(self) -> int:
         """ 获取队列的长度 """
         return self.__size
 
-    def is_empty(self):
+    def is_empty(self) -> bool:
         """ 判断队列是否为空 """
         return self.__size == 0
 
-    def push(self, num):
+    def push(self, num: int) -> None:
         """ 入队 """
         assert self.__size < self.capacity(), "队列已满"
         # 计算尾指针，指向队尾索引 + 1
         # 通过取余操作，实现 rear 越过数组尾部后回到头部
-        rear = (self.__front + self.__size) % self.capacity()
+        rear: int = (self.__front + self.__size) % self.capacity()
         # 将 num 添加至队尾
         self.__nums[rear] = num
         self.__size += 1
 
-    def poll(self):
+    def poll(self) -> int:
         """ 出队 """
-        num = self.peek()
+        num: int = self.peek()
         # 队首指针向后移动一位，若越过尾部则返回到数组头部
         self.__front = (self.__front + 1) % self.capacity()
         self.__size -= 1
         return num
 
-    def peek(self):
+    def peek(self) -> int:
         """ 访问队首元素 """
         assert not self.is_empty(), "队列为空"
         return self.__nums[self.__front]
 
-    def to_list(self):
+    def to_list(self) -> List[int]:
         """ 返回列表用于打印 """
-        res = [0] * self.size()
-        j = self.__front
+        res: List[int] = [0] * self.size()
+        j: int = self.__front
         for i in range(self.size()):
             res[i] = self.__nums[(j % self.capacity())]
             j += 1
@@ -77,24 +75,24 @@ if __name__ == "__main__":
     print("队列 queue =", queue.to_list())
 
     """ 访问队首元素 """
-    peek = queue.peek()
+    peek: int = queue.peek()
     print("队首元素 peek =", peek)
 
     """ 元素出队 """
-    poll = queue.poll()
+    poll: int = queue.poll()
     print("出队元素 poll =", poll)
     print("出队后 queue =", queue.to_list())
 
     """ 获取队列的长度 """
-    size = queue.size()
+    size: int = queue.size()
     print("队列长度 size =", size)
 
     """ 判断队列是否为空 """
-    is_empty = queue.is_empty()
+    is_empty: bool = queue.is_empty()
     print("队列是否为空 =", is_empty)
 
     """ 测试环形数组 """
     for i in range(10):
-        queue.push(i);
-        queue.poll();
-        print("第", i, "轮入队 + 出队后 queue = ", queue.to_list());
+        queue.push(i)
+        queue.poll()
+        print("第", i, "轮入队 + 出队后 queue = ", queue.to_list())

codes/python/chapter_stack_and_queue/array_stack.py

@@ -10,33 +10,33 @@ from modules import *
 
 class ArrayStack:
     """ 基于数组实现的栈 """
-    def __init__(self):
+    def __init__(self) -> None:
         """ 构造方法 """
-        self.__stack = []
+        self.__stack: List[int] = []
 
-    def size(self):
+    def size(self) -> int:
         """ 获取栈的长度 """
         return len(self.__stack)
 
-    def is_empty(self):
+    def is_empty(self) -> bool:
         """ 判断栈是否为空 """
         return self.__stack == []
 
-    def push(self, item):
+    def push(self, item: int) -> None:
         """ 入栈 """
         self.__stack.append(item)
 
-    def pop(self):
+    def pop(self) -> int:
         """ 出栈 """
         assert not self.is_empty(), "栈为空"
         return self.__stack.pop()
 
-    def peek(self):
+    def peek(self) -> int:
         """ 访问栈顶元素 """
         assert not self.is_empty(), "栈为空"
         return self.__stack[-1]
     
-    def to_list(self):
+    def to_list(self) -> List[int]:
         """ 返回列表用于打印 """
         return self.__stack
 
@@ -55,18 +55,18 @@ if __name__ == "__main__":
     print("栈 stack =", stack.to_list())
 
     """ 访问栈顶元素 """
-    peek = stack.peek()
+    peek: int = stack.peek()
     print("栈顶元素 peek =", peek)
 
     """ 元素出栈 """
-    pop = stack.pop()
+    pop: int = stack.pop()
     print("出栈元素 pop =", pop)
     print("出栈后 stack =", stack.to_list())
 
     """ 获取栈的长度 """
-    size = stack.size()
+    size: int = stack.size()
     print("栈的长度 size =", size)
 
     """ 判断是否为空 """
-    is_empty = stack.is_empty()
+    is_empty: bool = stack.is_empty()
     print("栈是否为空 =", is_empty)

codes/python/chapter_stack_and_queue/deque.py

@@ -4,19 +4,15 @@ Created Time: 2022-11-29
 Author: Peng Chen (pengchzn@gmail.com)
 """
 
-import os.path as osp
-import sys
-
+import sys, os.path as osp
 sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
 from modules import *
 
-from collections import deque
-
 
 """ Driver Code """
 if __name__ == "__main__":
     """ 初始化双向队列 """
-    deque = deque()
+    deque: Deque[int] = collections.deque()
 
     """ 元素入队 """
     deque.append(2)      # 添加至队尾
@@ -27,23 +23,23 @@ if __name__ == "__main__":
     print("双向队列 deque =", deque)
 
     """ 访问元素 """
-    front = deque[0]  # 队首元素
+    front: int = deque[0]  # 队首元素
     print("队首元素 front =", front)
-    rear = deque[-1]  # 队尾元素
+    rear: int = deque[-1]  # 队尾元素
     print("队尾元素 rear =", rear)
 
     """ 元素出队 """
-    pop_front = deque.popleft()  # 队首元素出队
+    pop_front: int = deque.popleft()  # 队首元素出队
     print("队首出队元素  pop_front =", pop_front)
     print("队首出队后 deque =", deque)
-    pop_rear = deque.pop()       # 队尾元素出队
+    pop_rear: int = deque.pop()       # 队尾元素出队
     print("队尾出队元素  pop_rear =", pop_rear)
     print("队尾出队后 deque =", deque)
 
     """ 获取双向队列的长度 """
-    size = len(deque)
+    size: int = len(deque)
     print("双向队列长度 size =", size)
 
     """ 判断双向队列是否为空 """
-    is_empty = len(deque) == 0
+    is_empty: bool = len(deque) == 0
     print("双向队列是否为空 =", is_empty)

codes/python/chapter_stack_and_queue/linkedlist_deque.py

@@ -4,36 +4,35 @@ Created Time: 2023-03-01
 Author: Krahets (krahets@163.com)
 """
 
-import os.path as osp
-import sys
-
+import sys, os.path as osp
 sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
 from modules import *
 
 class ListNode:
     """ 双向链表结点 """
-    def __init__(self, val):
+    def __init__(self, val: int) -> None:
         """ 构造方法 """
-        self.val = val
-        self.next = None  # 后继结点引用（指针）
-        self.prev = None  # 前驱结点引用（指针）
+        self.val: int = val
+        self.next: Optional[ListNode] = None  # 后继结点引用（指针）
+        self.prev: Optional[ListNode] = None  # 前驱结点引用（指针）
 
 class LinkedListDeque:
     """ 基于双向链表实现的双向队列 """
-    def __init__(self):
+    def __init__(self) -> None:
         """ 构造方法 """
-        self.front, self.rear = None, None  # 头结点 front ，尾结点 rear
-        self.__size = 0  # 双向队列的长度
+        self.front: Optional[ListNode] = None # 头结点 front
+        self.rear: Optional[ListNode] = None  # 尾结点 rear
+        self.__size: int = 0        # 双向队列的长度
 
-    def size(self):
+    def size(self) -> int:
         """ 获取双向队列的长度 """
         return self.__size
 
-    def is_empty(self):
+    def is_empty(self) -> bool:
         """ 判断双向队列是否为空 """
         return self.size() == 0
 
-    def push(self, num, is_front):
+    def push(self, num: int, is_front: bool) -> None:
         """ 入队操作 """
         node = ListNode(num)
         # 若链表为空，则令 front, rear 都指向 node
@@ -53,33 +52,33 @@ class LinkedListDeque:
             self.rear = node  # 更新尾结点
         self.__size += 1  # 更新队列长度
 
-    def push_first(self, num):
+    def push_first(self, num: int) -> None:
         """ 队首入队 """
         self.push(num, True)
 
-    def push_last(self, num):
+    def push_last(self, num: int) -> None:
         """ 队尾入队 """
         self.push(num, False)
 
-    def poll(self, is_front):
+    def poll(self, is_front: bool) -> int:
         """ 出队操作 """
         # 若队列为空，直接返回 None
         if self.is_empty():
             return None
         # 队首出队操作
         if is_front:
-            val = self.front.val  # 暂存头结点值
+            val: int = self.front.val  # 暂存头结点值
             # 删除头结点
-            fnext = self.front.next
+            fnext: Optional[ListNode] = self.front.next
             if fnext != None:
                 fnext.prev = None
                 self.front.next = None
             self.front = fnext  # 更新头结点
         # 队尾出队操作
         else:
-            val = self.rear.val  # 暂存尾结点值
+            val: int = self.rear.val  # 暂存尾结点值
             # 删除尾结点
-            rprev = self.rear.prev
+            rprev: Optional[ListNode] = self.rear.prev
             if rprev != None:
                 rprev.next = None
                 self.rear.prev = None
@@ -87,26 +86,26 @@ class LinkedListDeque:
         self.__size -= 1  # 更新队列长度
         return val
 
-    def poll_first(self):
+    def poll_first(self) -> int:
         """ 队首出队 """
         return self.poll(True)
 
-    def poll_last(self):
+    def poll_last(self) -> int:
         """ 队尾出队 """
         return self.poll(False)
 
-    def peek_first(self):
+    def peek_first(self) -> int:
         """ 访问队首元素 """
         return None if self.is_empty() else self.front.val
 
-    def peek_last(self):
+    def peek_last(self) -> int:
         """ 访问队尾元素 """
         return None if self.is_empty() else self.rear.val
 
-    def to_array(self):
+    def to_array(self) -> List[int]:
         """ 返回数组用于打印 """
-        node = self.front
-        res = [0] * self.size()
+        node: Optional[ListNode] = self.front
+        res: List[int] = [0] * self.size()
         for i in range(self.size()):
             res[i] = node.val
             node = node.next
@@ -123,9 +122,9 @@ if __name__ == "__main__":
     print("双向队列 deque =", deque.to_array())
 
     """ 访问元素 """
-    peek_first = deque.peek_first()
+    peek_first: int = deque.peek_first()
     print("队首元素 peek_first =", peek_first)
-    peek_last = deque.peek_last()
+    peek_last: int = deque.peek_last()
     print("队尾元素 peek_last =", peek_last)
 
     """ 元素入队 """
@@ -135,15 +134,15 @@ if __name__ == "__main__":
     print("元素 1 队首入队后 deque =", deque.to_array())
 
     """ 元素出队 """
-    poll_last = deque.poll_last()
+    poll_last: int = deque.poll_last()
     print("队尾出队元素 =", poll_last, "，队尾出队后 deque =", deque.to_array())
-    poll_first = deque.poll_first()
+    poll_first: int = deque.poll_first()
     print("队首出队元素 =", poll_first, "，队首出队后 deque =", deque.to_array())
 
     """ 获取双向队列的长度 """
-    size = deque.size()
+    size: int = deque.size()
     print("双向队列长度 size =", size)
 
     """ 判断双向队列是否为空 """
-    is_empty = deque.is_empty()
+    is_empty: bool = deque.is_empty()
     print("双向队列是否为空 =", is_empty)

codes/python/chapter_stack_and_queue/linkedlist_queue.py

@@ -4,9 +4,7 @@ Created Time: 2022-12-01
 Author: Peng Chen (pengchzn@gmail.com)
 """
 
-import os.path as osp
-import sys
-
+import sys, os.path as osp
 sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
 from modules import *
 
@@ -14,19 +12,19 @@ class LinkedListQueue:
     """ 基于链表实现的队列 """
     def __init__(self):
         """ 构造方法 """
-        self.__front = None  # 头结点 front
-        self.__rear = None   # 尾结点 rear
-        self.__size = 0
+        self.__front: Optional[ListNode] = None  # 头结点 front
+        self.__rear: Optional[ListNode] = None   # 尾结点 rear
+        self.__size: int = 0
 
-    def size(self):
+    def size(self) -> int:
         """ 获取队列的长度 """
         return self.__size
 
-    def is_empty(self):
+    def is_empty(self) -> bool:
         """ 判断队列是否为空 """
         return not self.__front
 
-    def push(self, num):
+    def push(self, num: int) -> None:
         """ 入队 """
         # 尾结点后添加 num
         node = ListNode(num)
@@ -40,7 +38,7 @@ class LinkedListQueue:
             self.__rear = node
         self.__size += 1
 
-    def poll(self):
+    def poll(self) -> int:
         """ 出队 """
         num = self.peek()
         # 删除头结点
@@ -48,14 +46,14 @@ class LinkedListQueue:
         self.__size -= 1
         return num
 
-    def peek(self):
+    def peek(self) -> int:
         """ 访问队首元素 """
         if self.size() == 0:
             print("队列为空")
             return False
         return self.__front.val
 
-    def to_list(self):
+    def to_list(self) -> List[int]:
         """ 转化为列表用于打印 """
         queue = []
         temp = self.__front
@@ -79,18 +77,18 @@ if __name__ == "__main__":
     print("队列 queue =", queue.to_list())
 
     """ 访问队首元素 """
-    peek = queue.peek()
+    peek: int = queue.peek()
     print("队首元素 front =", peek)
 
     """ 元素出队 """
-    pop_front = queue.poll()
+    pop_front: int = queue.poll()
     print("出队元素 poll =", pop_front)
     print("出队后 queue =", queue.to_list())
 
     """ 获取队列的长度 """
-    size = queue.size()
+    size: int = queue.size()
     print("队列长度 size =", size)
 
     """ 判断队列是否为空 """
-    is_empty = queue.is_empty()
+    is_empty: bool = queue.is_empty()
     print("队列是否为空 =", is_empty)

codes/python/chapter_stack_and_queue/linkedlist_stack.py

@@ -12,40 +12,40 @@ class LinkedListStack:
     """ 基于链表实现的栈 """
     def __init__(self):
         """ 构造方法 """
-        self.__peek = None
-        self.__size = 0
+        self.__peek: Optional[ListNode] = None
+        self.__size: int = 0
 
-    def size(self):
+    def size(self) -> int:
         """ 获取栈的长度 """
         return self.__size
 
-    def is_empty(self):
+    def is_empty(self) -> bool:
         """ 判断栈是否为空 """
         return not self.__peek
 
-    def push(self, val):
+    def push(self, val: int) -> None:
         """ 入栈 """
         node = ListNode(val)
         node.next = self.__peek
         self.__peek = node
         self.__size += 1
 
-    def pop(self):
+    def pop(self) -> int:
         """ 出栈 """
-        num = self.peek()
+        num: int = self.peek()
         self.__peek = self.__peek.next
         self.__size -= 1
         return num
 
-    def peek(self):
+    def peek(self) -> int:
         """ 访问栈顶元素 """
         # 判空处理
         if not self.__peek: return None
         return self.__peek.val
 
-    def to_list(self):
+    def to_list(self) -> List[int]:
         """ 转化为列表用于打印 """
-        arr = []
+        arr: List[int] = []
         node = self.__peek
         while node:
             arr.append(node.val)
@@ -68,18 +68,18 @@ if __name__ == "__main__":
     print("栈 stack =", stack.to_list())
 
     """ 访问栈顶元素 """
-    peek = stack.peek()
+    peek: int = stack.peek()
     print("栈顶元素 peek =", peek)
 
     """ 元素出栈 """
-    pop = stack.pop()
+    pop: int = stack.pop()
     print("出栈元素 pop =", pop)
     print("出栈后 stack =", stack.to_list())
 
     """ 获取栈的长度 """
-    size = stack.size()
+    size: int = stack.size()
     print("栈的长度 size =", size)
 
     """ 判断是否为空 """
-    is_empty = stack.is_empty()
+    is_empty: bool = stack.is_empty()
     print("栈是否为空 =", is_empty)

codes/python/chapter_stack_and_queue/queue.py

@@ -4,9 +4,7 @@ Created Time: 2022-11-29
 Author: Peng Chen (pengchzn@gmail.com)
 """
 
-import os.path as osp
-import sys
-
+import sys, os.path as osp
 sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
 from modules import *
 
@@ -14,9 +12,9 @@ from modules import *
 """ Driver Code """
 if __name__ == "__main__":    
     """ 初始化队列 """
-    # 在 Python 中，我们一般将双向队列类 deque 看左队列使用
-    # 虽然 queue.Queue() 是纯正的队列类，但不太好用，因此不建议
-    que = collections.deque()
+    # 在 Python 中，我们一般将双向队列类 deque 看作队列使用
+    # 虽然 queue.Queue() 是纯正的队列类，但不太好用
+    que: Deque[int] = collections.deque()
 
     """ 元素入队 """
     que.append(1)
@@ -27,18 +25,18 @@ if __name__ == "__main__":
     print("队列 que =", que)
 
     """ 访问队首元素 """
-    front = que[0];
-    print("队首元素 front =", front);
+    front: int = que[0]
+    print("队首元素 front =", front)
 
     """ 元素出队 """
-    pop = que.popleft()
+    pop: int = que.popleft()
     print("出队元素 pop =", pop)
     print("出队后 que =", que)
 
     """ 获取队列的长度 """
-    size = len(que)
+    size: int = len(que)
     print("队列长度 size =", size)
 
     """ 判断队列是否为空 """
-    is_empty = len(que) == 0
+    is_empty: bool = len(que) == 0
     print("队列是否为空 =", is_empty)

codes/python/chapter_stack_and_queue/stack.py

@@ -13,7 +13,7 @@ from modules import *
 if __name__ == "__main__":
     """ 初始化栈 """
     # Python 没有内置的栈类，可以把 list 当作栈来使用 
-    stack = []
+    stack: List[int] = []
 
     """ 元素入栈 """
     stack.append(1)
@@ -24,18 +24,18 @@ if __name__ == "__main__":
     print("栈 stack =", stack)
 
     """ 访问栈顶元素 """
-    peek = stack[-1]
+    peek: int = stack[-1]
     print("栈顶元素 peek =", peek)
 
     """ 元素出栈 """
-    pop = stack.pop()
+    pop: int = stack.pop()
     print("出栈元素 pop =", pop)
     print("出栈后 stack =", stack)
 
     """ 获取栈的长度 """
-    size = len(stack)
+    size: int = len(stack)
     print("栈的长度 size =", size)
 
     """ 判断是否为空 """
-    is_empty = len(stack) == 0
+    is_empty: bool = len(stack) == 0
     print("栈是否为空 =", is_empty)