Format python codes with black. (#453)

codes/python/chapter_array_and_linkedlist/array.py

@@ -6,18 +6,20 @@ Author: Krahets (krahets@163.com)
 
 import random
 
+
 def random_access(nums: list[int]) -> int:
-    """ 随机访问元素 """
+    """随机访问元素"""
     # 在区间 [0, len(nums)-1] 中随机抽取一个数字
     random_index = random.randint(0, len(nums) - 1)
     # 获取并返回随机元素
     random_num = nums[random_index]
     return random_num
 
+
 # 请注意，Python 的 list 是动态数组，可以直接扩展
 # 为了方便学习，本函数将 list 看作是长度不可变的数组
 def extend(nums: list[int], enlarge: int) -> list[int]:
-    """ 扩展数组长度 """
+    """扩展数组长度"""
     # 初始化一个扩展长度后的数组
     res = [0] * (len(nums) + enlarge)
     # 将原数组中的所有元素复制到新数组
@@ -26,22 +28,25 @@ def extend(nums: list[int], enlarge: int) -> list[int]:
     # 返回扩展后的新数组
     return res
 
+
 def insert(nums: list[int], num: int, index: int) -> None:
-    """ 在数组的索引 index 处插入元素 num """
+    """在数组的索引 index 处插入元素 num"""
     # 把索引 index 以及之后的所有元素向后移动一位
     for i in range(len(nums) - 1, index, -1):
         nums[i] = nums[i - 1]
     # 将 num 赋给 index 处元素
     nums[index] = num
 
+
 def remove(nums: list[int], index: int) -> None:
-    """ 删除索引 index 处元素 """
+    """删除索引 index 处元素"""
     # 把索引 index 之后的所有元素向前移动一位
     for i in range(index, len(nums) - 1):
         nums[i] = nums[i + 1]
 
+
 def traverse(nums: list[int]) -> None:
-    """ 遍历数组 """
+    """遍历数组"""
     count = 0
     # 通过索引遍历数组
     for i in range(len(nums)):
@@ -50,40 +55,42 @@ def traverse(nums: list[int]) -> None:
     for num in nums:
         count += 1
 
+
 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: list[int] = [0] * 5
     print("数组 arr =", arr)
     nums: list[int] = [1, 3, 2, 5, 4]
     print("数组 nums =", nums)
-    
-    """ 随机访问 """
+
+    # 随机访问
     random_num: int = random_access(nums)
     print("在 nums 中获取随机元素", random_num)
-    
-    """ 长度扩展 """
+
+    # 长度扩展
     nums: list[int] = extend(nums, 3)
     print("将数组长度扩展至 8 ，得到 nums =", nums)
-    
-    """ 插入元素 """
+
+    # 插入元素
     insert(nums, 6, 3)
     print("在索引 3 处插入数字 6 ，得到 nums =", nums)
 
-    """ 删除元素 """
+    # 删除元素
     remove(nums, 2)
     print("删除索引 2 处的元素，得到 nums =", nums)
-    
-    """ 遍历数组 """
+
+    # 遍历数组
     traverse(nums)
-    
-    """ 查找元素 """
+
+    # 查找元素
     index: int = find(nums, 3)
     print("在 nums 中查找元素 3 ，得到索引 =", index)

codes/python/chapter_array_and_linkedlist/linked_list.py

@@ -5,17 +5,20 @@ Author: Krahets (krahets@163.com)
 """
 
 import sys, os.path as osp
+
 sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
 from modules import *
 
+
 def insert(n0: ListNode, P: ListNode) -> None:
-    """ 在链表的节点 n0 之后插入节点 P """
+    """在链表的节点 n0 之后插入节点 P"""
     n1 = n0.next
     P.next = n1
     n0.next = P
 
+
 def remove(n0: ListNode) -> None:
-    """ 删除链表的节点 n0 之后的首个节点 """
+    """删除链表的节点 n0 之后的首个节点"""
     if not n0.next:
         return
     # n0 -> P -> n1
@@ -23,16 +26,18 @@ def remove(n0: ListNode) -> None:
     n1 = P.next
     n0.next = n1
 
+
 def access(head: ListNode, index: int) -> ListNode | None:
-    """ 访问链表中索引为 index 的节点 """
+    """访问链表中索引为 index 的节点"""
     for _ in range(index):
         if not head:
             return None
         head = head.next
     return head
 
+
 def find(head: ListNode, target: int) -> int:
-    """ 在链表中查找值为 target 的首个节点 """
+    """在链表中查找值为 target 的首个节点"""
     index = 0
     while head:
         if head.val == target:
@@ -44,8 +49,8 @@ def find(head: ListNode, target: int) -> int:
 
 """ Driver Code """
 if __name__ == "__main__":
-    """ 初始化链表 """
-    # 初始化各个节点 
+    # 初始化链表
+    # 初始化各个节点
     n0 = ListNode(1)
     n1 = ListNode(3)
     n2 = ListNode(2)
@@ -59,20 +64,20 @@ if __name__ == "__main__":
     print("初始化的链表为")
     print_linked_list(n0)
 
-    """ 插入节点 """
+    # 插入节点
     insert(n0, ListNode(0))
     print("插入节点后的链表为")
     print_linked_list(n0)
 
-    """ 删除节点 """
+    # 删除节点
     remove(n0)
     print("删除节点后的链表为")
     print_linked_list(n0)
 
-    """ 访问节点 """
+    # 访问节点
     node: ListNode = access(n0, 3)
     print("链表中索引 3 处的节点的值 = {}".format(node.val))
 
-    """ 查找节点 """
+    # 查找节点
     index: int = find(n0, 2)
     print("链表中值为 2 的节点的索引 = {}".format(index))

codes/python/chapter_array_and_linkedlist/list.py

@@ -6,23 +6,23 @@ Author: Krahets (krahets@163.com)
 
 """ Driver Code """
 if __name__ == "__main__":
-    """ 初始化列表 """
+    # 初始化列表
     arr: list[int] = [1, 3, 2, 5, 4]
     print("列表 arr =", arr)
 
-    """ 访问元素 """
+    # 访问元素
     num: int = arr[1]
     print("访问索引 1 处的元素，得到 num =", num)
 
-    """ 更新元素 """
+    # 更新元素
     arr[1] = 0
     print("将索引 1 处的元素更新为 0 ，得到 arr =", arr)
 
-    """ 清空列表 """
+    # 清空列表
     arr.clear()
     print("清空列表后 arr =", arr)
 
-    """ 尾部添加元素 """
+    # 尾部添加元素
     arr.append(1)
     arr.append(3)
     arr.append(2)
@@ -30,29 +30,29 @@ if __name__ == "__main__":
     arr.append(4)
     print("添加元素后 arr =", arr)
 
-    """ 中间插入元素 """
+    # 中间插入元素
     arr.insert(3, 6)
     print("在索引 3 处插入数字 6 ，得到 arr =", arr)
 
-    """ 删除元素 """
+    # 删除元素
     arr.pop(3)
     print("删除索引 3 处的元素，得到 arr =", arr)
 
-    """ 通过索引遍历列表 """
+    # 通过索引遍历列表
     count: int = 0
     for i in range(len(arr)):
         count += 1
 
-    """ 直接遍历列表元素 """
+    # 直接遍历列表元素
     count: int = 0
     for n in arr:
         count += 1
 
-    """ 拼接两个列表 """
+    # 拼接两个列表
     arr1: list[int] = [6, 8, 7, 10, 9]
     arr += arr1
     print("将列表 arr1 拼接到 arr 之后，得到 arr =", arr)
 
-    """ 排序列表 """
+    # 排序列表
     arr.sort()
     print("排序列表后 arr =", arr)

codes/python/chapter_array_and_linkedlist/my_list.py

@@ -4,36 +4,38 @@ Created Time: 2022-11-25
 Author: Krahets (krahets@163.com)
 """
 
+
 class MyList:
-    """ 列表类简易实现 """
+    """列表类简易实现"""
+
     def __init__(self):
-        """ 构造方法 """
-        self.__capacity: int = 10                       # 列表容量
+        """构造方法"""
+        self.__capacity: int = 10  # 列表容量
         self.__nums: my_list[int] = [0] * self.__capacity  # 数组（存储列表元素）
-        self.__size: int = 0                            # 列表长度（即当前元素数量）
-        self.__extend_ratio: int = 2                    # 每次列表扩容的倍数
+        self.__size: int = 0  # 列表长度（即当前元素数量）
+        self.__extend_ratio: int = 2  # 每次列表扩容的倍数
 
     def size(self) -> int:
-        """ 获取列表长度（即当前元素数量） """
+        """获取列表长度（即当前元素数量）"""
         return self.__size
-    
+
     def capacity(self) -> int:
-        """ 获取列表容量 """
+        """获取列表容量"""
         return self.__capacity
-    
+
     def get(self, index: int) -> int:
-        """ 访问元素 """
+        """访问元素"""
         # 索引如果越界则抛出异常，下同
         assert index >= 0 and index < self.__size, "索引越界"
         return self.__nums[index]
 
     def set(self, num: int, index: int) -> None:
-        """ 更新元素 """
+        """更新元素"""
         assert index >= 0 and index < self.__size, "索引越界"
         self.__nums[index] = num
-    
+
     def add(self, num: int) -> None:
-        """ 尾部添加元素 """
+        """尾部添加元素"""
         # 元素数量超出容量时，触发扩容机制
         if self.size() == self.capacity():
             self.extend_capacity()
@@ -41,7 +43,7 @@ class MyList:
         self.__size += 1
 
     def insert(self, num: int, index: int) -> None:
-        """ 中间插入元素 """
+        """中间插入元素"""
         assert index >= 0 and index < self.__size, "索引越界"
         # 元素数量超出容量时，触发扩容机制
         if self.__size == self.capacity():
@@ -54,7 +56,7 @@ class MyList:
         self.__size += 1
 
     def remove(self, index: int) -> int:
-        """ 删除元素 """
+        """删除元素"""
         assert index >= 0 and index < self.__size, "索引越界"
         num = self.__nums[index]
         # 索引 i 之后的元素都向前移动一位
@@ -66,49 +68,51 @@ class MyList:
         return num
 
     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) -> list[int]:
-        """ 返回有效长度的列表 """
-        return self.__nums[:self.__size]
+        """返回有效长度的列表"""
+        return self.__nums[: self.__size]
 
 
 """ Driver Code """
 if __name__ == "__main__":
-    """ 初始化列表 """
+    # 初始化列表
     my_list = MyList()
-    """ 尾部添加元素 """
+    # 尾部添加元素
     my_list.add(1)
     my_list.add(3)
     my_list.add(2)
     my_list.add(5)
     my_list.add(4)
-    print("列表 my_list = {} ，容量 = {} ，长度 = {}"
-          .format(my_list.to_array(), my_list.capacity(), my_list.size()))
+    print(
+        f"列表 my_list = {my_list.to_array()} ，容量 = {my_list.capacity()} ，长度 = {my_list.size()}"
+    )
 
-    """ 中间插入元素 """
+    # 中间插入元素
     my_list.insert(6, index=3)
     print("在索引 3 处插入数字 6 ，得到 my_list =", my_list.to_array())
 
-    """ 删除元素 """
+    # 删除元素
     my_list.remove(3)
     print("删除索引 3 处的元素，得到 my_list =", my_list.to_array())
 
-    """ 访问元素 """
+    # 访问元素
     num = my_list.get(1)
     print("访问索引 1 处的元素，得到 num =", num)
 
-    """ 更新元素 """
+    # 更新元素
     my_list.set(0, 1)
     print("将索引 1 处的元素更新为 0 ，得到 my_list =", my_list.to_array())
 
-    """ 测试扩容机制 """
+    # 测试扩容机制
     for i in range(10):
         # 在 i = 5 时，列表长度将超出列表容量，此时触发扩容机制
         my_list.add(i)
-    print("扩容后的列表 my_list = {} ，容量 = {} ，长度 = {}"
-          .format(my_list.to_array(), my_list.capacity(), my_list.size()))
+    print(
+        "扩容后的列表 {my_list.to_array()} ，容量 = {my_list.capacity()} ，长度 = {my_list.size()}"
+    )