Add typing annotations to Python codes. (#411)

codes/python/chapter_array_and_linkedlist/array.py

@@ -8,7 +8,7 @@ import sys, os.path as osp
 sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
 from modules import *
 
-def random_access(nums):
+def random_access(nums: List[int]) -> int:
     """ 随机访问元素 """
     # 在区间 [0, len(nums)-1] 中随机抽取一个数字
     random_index = random.randint(0, len(nums) - 1)
@@ -18,7 +18,7 @@ def random_access(nums):
 
 # 请注意，Python 的 list 是动态数组，可以直接扩展
 # 为了方便学习，本函数将 list 看作是长度不可变的数组
-def extend(nums, enlarge):
+def extend(nums: List[int], enlarge: int) -> List[int]:
     """ 扩展数组长度 """
     # 初始化一个扩展长度后的数组
     res = [0] * (len(nums) + enlarge)
@@ -28,7 +28,7 @@ def extend(nums, enlarge):
     # 返回扩展后的新数组
     return res
 
-def insert(nums, num, index):
+def insert(nums: List[int], num: int, index: int) -> None:
     """ 在数组的索引 index 处插入元素 num """
     # 把索引 index 以及之后的所有元素向后移动一位
     for i in range(len(nums) - 1, index, -1):
@@ -36,13 +36,13 @@ def insert(nums, num, index):
     # 将 num 赋给 index 处元素
     nums[index] = num
 
-def remove(nums, index):
+def remove(nums: List[int], index: int) -> None:
     """ 删除索引 index 处元素 """
     # 把索引 index 之后的所有元素向前移动一位
     for i in range(index, len(nums) - 1):
         nums[i] = nums[i + 1]
-    
-def traverse(nums):
+
+def traverse(nums: List[int]) -> None:
     """ 遍历数组 """
     count = 0
     # 通过索引遍历数组
@@ -52,28 +52,27 @@ def traverse(nums):
     for num in nums:
         count += 1
 
-def find(nums, target):
+def find(nums: List[int], target: int) -> int:
     """ 在数组中查找指定元素 """
     for i in range(len(nums)):
         if nums[i] == target:
             return i
     return -1
 
-
 """ Driver Code """
 if __name__ == "__main__":
     """ 初始化数组 """
-    arr = [0] * 5
+    arr: List[int] = [0] * 5
     print("数组 arr =", arr)
-    nums = [1, 3, 2, 5, 4]
+    nums: List[int] = [1, 3, 2, 5, 4]
     print("数组 nums =", nums)
     
     """ 随机访问 """
-    random_num = random_access(nums)
+    random_num: int = random_access(nums)
     print("在 nums 中获取随机元素", random_num)
     
     """ 长度扩展 """
-    nums = extend(nums, 3)
+    nums: List[int] = extend(nums, 3)
     print("将数组长度扩展至 8 ，得到 nums =", nums)
     
     """ 插入元素 """
@@ -88,5 +87,5 @@ if __name__ == "__main__":
     traverse(nums)
     
     """ 查找元素 """
-    index = find(nums, 3)
+    index: int = find(nums, 3)
     print("在 nums 中查找元素 3 ，得到索引 =", index)

codes/python/chapter_array_and_linkedlist/linked_list.py

@@ -8,13 +8,13 @@ import sys, os.path as osp
 sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
 from modules import *
 
-def insert(n0, P):
+def insert(n0: ListNode, P: ListNode) -> None:
     """ 在链表的结点 n0 之后插入结点 P """
     n1 = n0.next
     P.next = n1
     n0.next = P
 
-def remove(n0):
+def remove(n0: ListNode) -> None:
     """ 删除链表的结点 n0 之后的首个结点 """
     if not n0.next:
         return
@@ -23,7 +23,7 @@ def remove(n0):
     n1 = P.next
     n0.next = n1
 
-def access(head, index):
+def access(head: ListNode, index: int) -> Optional[ListNode]:
     """ 访问链表中索引为 index 的结点 """
     for _ in range(index):
         if not head:
@@ -31,7 +31,7 @@ def access(head, index):
         head = head.next
     return head
 
-def find(head, target):
+def find(head: ListNode, target: int) -> int:
     """ 在链表中查找值为 target 的首个结点 """
     index = 0
     while head:
@@ -70,9 +70,9 @@ if __name__ == "__main__":
     print_linked_list(n0)
 
     """ 访问结点 """
-    node = access(n0, 3)
+    node: ListNode = access(n0, 3)
     print("链表中索引 3 处的结点的值 = {}".format(node.val))
 
     """ 查找结点 """
-    index = find(n0, 2)
+    index: int = find(n0, 2)
     print("链表中值为 2 的结点的索引 = {}".format(index))

codes/python/chapter_array_and_linkedlist/list.py

@@ -12,11 +12,11 @@ from modules import *
 """ Driver Code """
 if __name__ == "__main__":
     """ 初始化列表 """
-    list = [1, 3, 2, 5, 4]
+    list: List[int] = [1, 3, 2, 5, 4]
     print("列表 list =", list)
 
     """ 访问元素 """
-    num = list[1]
+    num: int = list[1]
     print("访问索引 1 处的元素，得到 num =", num)
 
     """ 更新元素 """
@@ -44,17 +44,17 @@ if __name__ == "__main__":
     print("删除索引 3 处的元素，得到 list =", list)
 
     """ 通过索引遍历列表 """
-    count = 0
+    count: int = 0
     for i in range(len(list)):
         count += 1
 
     """ 直接遍历列表元素 """
-    count = 0
+    count: int = 0
     for n in list:
         count += 1
 
     """ 拼接两个列表 """
-    list1 = [6, 8, 7, 10, 9]
+    list1: List[int] = [6, 8, 7, 10, 9]
     list += list1
     print("将列表 list1 拼接到 list 之后，得到 list =", list)
 

codes/python/chapter_array_and_linkedlist/my_list.py

@@ -12,31 +12,31 @@ class MyList:
     """ 列表类简易实现 """
     def __init__(self):
         """ 构造方法 """
-        self.__capacity = 10                 # 列表容量
-        self.__nums = [0] * self.__capacity  # 数组（存储列表元素）
-        self.__size = 0                      # 列表长度（即当前元素数量）
-        self.__extend_ratio = 2              # 每次列表扩容的倍数
+        self.__capacity: int = 10                       # 列表容量
+        self.__nums: List[int] = [0] * self.__capacity  # 数组（存储列表元素）
+        self.__size: int = 0                            # 列表长度（即当前元素数量）
+        self.__extend_ratio: int = 2                    # 每次列表扩容的倍数
 
-    def size(self):
+    def size(self) -> int:
         """ 获取列表长度（即当前元素数量） """
         return self.__size
     
-    def capacity(self):
+    def capacity(self) -> int:
         """ 获取列表容量 """
         return self.__capacity
     
-    def get(self, index):
+    def get(self, index: int) -> int:
         """ 访问元素 """
         # 索引如果越界则抛出异常，下同
         assert index >= 0 and index < self.__size, "索引越界"
         return self.__nums[index]
 
-    def set(self, num, index):
+    def set(self, num: int, index: int) -> None:
         """ 更新元素 """
         assert index >= 0 and index < self.__size, "索引越界"
         self.__nums[index] = num
     
-    def add(self, num):
+    def add(self, num: int) -> None:
         """ 尾部添加元素 """
         # 元素数量超出容量时，触发扩容机制
         if self.size() == self.capacity():
@@ -44,7 +44,7 @@ class MyList:
         self.__nums[self.__size] = num
         self.__size += 1
 
-    def insert(self, num, index):
+    def insert(self, num: int, index: int) -> None:
         """ 中间插入元素 """
         assert index >= 0 and index < self.__size, "索引越界"
         # 元素数量超出容量时，触发扩容机制
@@ -57,7 +57,7 @@ class MyList:
         # 更新元素数量
         self.__size += 1
 
-    def remove(self, index):
+    def remove(self, index: int) -> int:
         """ 删除元素 """
         assert index >= 0 and index < self.__size, "索引越界"
         num = self.__nums[index]
@@ -69,14 +69,14 @@ class MyList:
         # 返回被删除元素
         return num
 
-    def extend_capacity(self):
+    def extend_capacity(self) -> None:
         """ 列表扩容 """
         # 新建一个长度为 self.__size 的数组，并将原数组拷贝到新数组
         self.__nums = self.__nums + [0] * self.capacity() * (self.__extend_ratio - 1)
         # 更新列表容量
         self.__capacity = len(self.__nums)
     
-    def to_array(self):
+    def to_array(self) -> List[int]:
         """ 返回有效长度的列表 """
         return self.__nums[:self.__size]