diff --git a/README.md b/README.md
index 02a1a2d7937f29ebbf21f0c5a13e788af9de43c4..7b935d4a947bcadb550c2c08b459c76d4b583dff 100644
--- a/README.md
+++ b/README.md
@@ -46,7 +46,7 @@ git commit -m "change description"
```
6. 通过`git push origin master`上传作业到自己的Gitee项目里
- 其中`origin`是远端服务器的名字
- - `master`是git分支的名字（默认是master)
+ - `master`是git分支的名字（默认是master）
diff --git a/homework_01_python/.idea/.gitignore b/homework_01_python/.idea/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..359bb5307e8535ab7d59faf27a7377033291821e
--- /dev/null
+++ b/homework_01_python/.idea/.gitignore
@@ -0,0 +1,3 @@
+# 默认忽略的文件
+/shelf/
+/workspace.xml
diff --git a/homework_01_python/.idea/homework_01_python.iml b/homework_01_python/.idea/homework_01_python.iml
new file mode 100644
index 0000000000000000000000000000000000000000..460d4026f75be78deb4130dc643aef2b2b6340d4
--- /dev/null
+++ b/homework_01_python/.idea/homework_01_python.iml
@@ -0,0 +1,12 @@
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/homework_01_python/.idea/inspectionProfiles/Project_Default.xml b/homework_01_python/.idea/inspectionProfiles/Project_Default.xml
new file mode 100644
index 0000000000000000000000000000000000000000..870c928967c88fcebd073b5b1aa85587887ca215
--- /dev/null
+++ b/homework_01_python/.idea/inspectionProfiles/Project_Default.xml
@@ -0,0 +1,12 @@
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/homework_01_python/.idea/inspectionProfiles/profiles_settings.xml b/homework_01_python/.idea/inspectionProfiles/profiles_settings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..105ce2da2d6447d11dfe32bfb846c3d5b199fc99
--- /dev/null
+++ b/homework_01_python/.idea/inspectionProfiles/profiles_settings.xml
@@ -0,0 +1,6 @@
+
+
+
+
+
+
\ No newline at end of file
diff --git a/homework_01_python/.idea/misc.xml b/homework_01_python/.idea/misc.xml
new file mode 100644
index 0000000000000000000000000000000000000000..1d3ce46ba0d13183e3244cba5b930b5e27be4c6b
--- /dev/null
+++ b/homework_01_python/.idea/misc.xml
@@ -0,0 +1,7 @@
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/homework_01_python/.idea/modules.xml b/homework_01_python/.idea/modules.xml
new file mode 100644
index 0000000000000000000000000000000000000000..285efb228972dd9cd386bc98efcafdce8d87d83b
--- /dev/null
+++ b/homework_01_python/.idea/modules.xml
@@ -0,0 +1,8 @@
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/homework_01_python/.idea/vcs.xml b/homework_01_python/.idea/vcs.xml
new file mode 100644
index 0000000000000000000000000000000000000000..6c0b8635858dc7ad44b93df54b762707ce49eefc
--- /dev/null
+++ b/homework_01_python/.idea/vcs.xml
@@ -0,0 +1,6 @@
+
+
+
+
+
+
\ No newline at end of file
diff --git a/homework_01_python/answer_01_string.py b/homework_01_python/answer_01_string.py
new file mode 100644
index 0000000000000000000000000000000000000000..8fa36eeb584b3f9dc56771422e136e0fdea642d0
--- /dev/null
+++ b/homework_01_python/answer_01_string.py
@@ -0,0 +1,21 @@
+"""第 01 题：字符串
+给定一个文章，找出每个单词的出现次数。"""
+
+def count_words(text):
+ """计算文段各单词数目"""
+ words = text.lower().split() # 按空格分割
+ word_count = {}
+ for word in words:
+ word = word.strip(',.?:;"')
+ if word:
+ word_count[word] = word_count.get(word, 0) + 1
+
+ return word_count
+
+text_test = (
+ 'One is always on a strange road, '
+ 'watching strange scenery and listening to strange music. '
+ 'Then one day, '
+ 'you will find that the things you try hard to forget are already gone. '
+)
+print(count_words(text_test))
\ No newline at end of file
diff --git a/homework_01_python/answer_02_combination.py b/homework_01_python/answer_02_combination.py
new file mode 100644
index 0000000000000000000000000000000000000000..e91121dbb037bb7d8fdd41f4aa5ea564a57779fa
--- /dev/null
+++ b/homework_01_python/answer_02_combination.py
@@ -0,0 +1,41 @@
+"""第 02 题：组合
+有 1、2、3、4 个数字，能组成多少个互不相同且无重复数字的三位数？都是多少？"""
+
+def exist(target, number):
+ """检查数表中有无目标数位"""
+ for num in number:
+ if num == target:
+ return True
+ return False
+
+def addit(_digits, number):
+ """无重复地在数子后添加一位"""
+ # digits 存储各单数字，number 存储多位数各位
+ numbers_append = []
+ for digit in _digits:
+ if not exist(digit, number):
+ numbers_append.append(number + [digit])
+ return numbers_append
+
+def combine(_digits, _length):
+ """输出 digits 拼成的所有位数为 length 的数"""
+ numbers = [[]]
+
+ # 以子列表表示各数字
+ for step in range(_length):
+ len_numbers = len(numbers)
+ for row_before in range(len_numbers):
+ row_after = len(numbers) - (len_numbers - row_before)
+ numbers[row_after: row_after + 1] = addit(_digits, numbers[row_after])
+
+ # 将子列表转换为整型
+ numbers = [int(''.join(map(str, sublist))) for sublist in numbers]
+ return numbers
+
+digits = [1, 2, 3, 4]
+length = 3
+combination = combine(digits, length)
+num_combi = len(combination)
+
+print(f'{digits} 要排成无重复的 {length} 位数，共 {num_combi} 种组合，包括：')
+print(*combination, sep=', ')
\ No newline at end of file
diff --git a/homework_01_python/answer_03_judgement.py b/homework_01_python/answer_03_judgement.py
new file mode 100644
index 0000000000000000000000000000000000000000..bb44eda7ecbde49f9cf7818e8058dd94a5d2d2a1
--- /dev/null
+++ b/homework_01_python/answer_03_judgement.py
@@ -0,0 +1,28 @@
+"""第 03 题：判断
+企业发放的奖金根据利润提成。
+从键盘输入当月利润 I，求应发放奖金总数？
+本题不借助多次 if 语句判断，直接使用列表计算"""
+
+def cal_bonus(profit, _rule):
+ """计算奖金"""
+ bonus = 0
+ threshold_former = 0
+ for threshold, rate in _rule:
+ if profit < threshold:
+ bonus += rate * (profit - threshold_former)
+ break
+ else:
+ bonus += rate * (threshold - threshold_former)
+ threshold_former = threshold
+ return bonus
+
+rule = [ # 档次，提成
+ (10, 0.1),
+ (20, 0.075),
+ (40, 0.05),
+ (60, 0.03),
+ (100, 0.015),
+ (float('inf'), 0.01)
+]
+I = float(input("请输入利润，单位：万元\n"))
+print(f'奖金数目为 {cal_bonus(I, rule)}')
\ No newline at end of file
diff --git a/homework_01_python/answer_04_table.py b/homework_01_python/answer_04_table.py
new file mode 100644
index 0000000000000000000000000000000000000000..d1c159e991a6d6593765579341e1782a00ba4f7d
--- /dev/null
+++ b/homework_01_python/answer_04_table.py
@@ -0,0 +1,14 @@
+"""第 04 题：循环
+输出9x9的乘法口诀表"""
+
+def mul_table(_n):
+ """输出最大因数为 n 的乘法表"""
+ for i in range(_n):
+ i += 1
+ for j in range(i):
+ j += 1
+ print(f'{i:d} × {j:d} = {i * j:2d}', end='\t')
+ print()
+
+n = 9 # 最大因数，即输出行数
+mul_table(n)
\ No newline at end of file
diff --git a/homework_01_python/answer_05_while.py b/homework_01_python/answer_05_while.py
new file mode 100644
index 0000000000000000000000000000000000000000..1c8f0b16fc6ee84cdffc048435c907a1bf6d46cc
--- /dev/null
+++ b/homework_01_python/answer_05_while.py
@@ -0,0 +1,20 @@
+"""第 05 题：While 循环
+使用while循环实现输出2-3+4-5+6.....+100的和"""
+
+def addition(_head, _tail):
+ """对 head 至 tail 的所有整数交错求和"""
+ summation = 0
+ addit = _head - 1
+ factor = - 1
+ while addit < _tail:
+ addit += 1
+ factor *= -1
+ summation += factor * addit
+ return summation
+
+head = 2
+tail = 100
+result = addition(head, tail)
+print(f'从 {head} 至 {tail} 的所有整数，其交错和为 {result}')
+
+# 样例输出：51
\ No newline at end of file
diff --git a/homework_01_python/answer_06_sort.py b/homework_01_python/answer_06_sort.py
new file mode 100644
index 0000000000000000000000000000000000000000..1141af30cce5f9d63d02df5730f185b245330939
--- /dev/null
+++ b/homework_01_python/answer_06_sort.py
@@ -0,0 +1,21 @@
+"""第 06 题：排序
+给一个数字列表，将其按照由小到大的顺序排列，同时输出排序后元素在原始列表中的下标"""
+
+def sorting(number):
+ """数字排序"""
+ length = len(number)
+ index = []
+ for idx in range(length):
+ index.append(idx)
+ for idx_move in range(length):
+ for idx_next in range(idx_move + 1, length):
+ if idx_move != idx_next and number[idx_move] > number[idx_next]:
+ number[idx_move], number[idx_next] = number[idx_next], number[idx_move]
+ index[idx_move], index[idx_next] = index[idx_next], index[idx_move]
+ return number, index
+
+nums_raw = [1, 10, 4, 2, 9, 2, 34, 5, 9, 8, 5, 0]
+print("排序前的数列为：", *nums_raw, sep =', ')
+nums_sort, idx_sort = sorting(nums_raw)
+print("排序后的数列为：", *nums_sort, sep =', ')
+print("排序后的索引为：", *idx_sort, sep =', ')
\ No newline at end of file
diff --git a/homework_01_python/answer_07_search.py b/homework_01_python/answer_07_search.py
new file mode 100644
index 0000000000000000000000000000000000000000..c2ec31ab34c1f9a1302431374f9b61a3f787f92d
--- /dev/null
+++ b/homework_01_python/answer_07_search.py
@@ -0,0 +1,170 @@
+"""第 07 题：矩阵搜索
+编写一个高效的算法来搜索 m x n 矩阵 matrix 中的一个目标值 target。该矩阵具有以下特性：
+（1）每行的元素从左到右升序排列。
+（2）每列的元素从上到下升序排列。"""
+
+class Searcher:
+ """数字寻找器
+
+ 思路为：取矩阵居中元素 mid，
+ 若 mid > target，则弃去 mid 右下所有元素；
+ 若 mid < target，则弃去 mid 左上所有元素。
+ 将矩阵剩余部分分成三小矩阵，如此往复迭代。
+ 直到将矩阵分成一维即数列时，使用二分法搜索。"""
+ def __init__(self, _matrix, _target):
+
+ # 恒定属性
+ self.matrix = _matrix
+ height = len(self.matrix)
+ width = len(self.matrix[0])
+ self.matrix_list = [ # 每个小矩阵的四边位置，顺序为上、下、左、右
+ [0, height - 1, 0, width - 1]
+ ]
+ self.idx_object = 0 # 在 matrix_list 中的第 idx_work 中查找 target
+ self.target = _target
+ self.exist = None
+ self.location = None
+
+ # 迭代属性
+ self.height = None
+ self.width = None
+ self.bound = None
+ self.row_mid = None
+ self.col_mid = None
+ self.mid = None
+
+ def divide_matrix(self):
+ """四分矩阵，弃一留三"""
+ if self.mid == self.target: # 在矩阵中找到 target，返回True
+ self.exist = True
+ else: # mid != target，按两者相对大小分割矩阵
+ # 因掩去左上、右下时，四分矩阵的位置不同，只有得知了 mid 与 target 的大小关系，才可知划分方案
+
+ if self.mid > self.target: # 若 mid > target，掩去小矩阵中 mid 右下块，取另三块
+
+ left_upper = [ # 小矩阵左上块
+ self.bound[0],
+ max(self.bound[0], self.row_mid - 1),
+ self.bound[2],
+ max(self.bound[2], self.col_mid - 1)
+ ]
+ left_lower = [ # 小矩阵左下块
+ self.row_mid,
+ self.bound[1],
+ self.bound[2],
+ max(self.bound[2], self.col_mid - 1)
+ ]
+ right_upper = [ # 小矩阵右上块
+ self.bound[0],
+ max(self.bound[0], self.row_mid - 1),
+ self.col_mid,
+ self.bound[3]
+ ]
+
+ self.matrix_list[self.idx_object: self.idx_object + 1] = [
+ left_upper,
+ left_lower,
+ right_upper
+ ]
+ else: # 若 mid < target，掩去小矩阵中 mid 左上块，取另三块
+
+ left_lower = [ # 小矩阵左下块
+ min(self.bound[1], self.row_mid + 1),
+ self.bound[1],
+ self.bound[2],
+ self.col_mid
+ ]
+ right_upper = [ # 小矩阵右上块
+ self.bound[0],
+ self.row_mid,
+ min(self.bound[3], self.col_mid + 1),
+ self.bound[3]
+ ]
+ right_lower = [ # 小矩阵右下块
+ min(self.bound[1], self.row_mid + 1),
+ self.bound[1],
+ min(self.bound[3], self.col_mid + 1),
+ self.bound[3]
+ ]
+
+ self.matrix_list[self.idx_object: self.idx_object + 1] = [
+ left_lower,
+ right_upper,
+ right_lower
+ ]
+
+ def divide_vector(self):
+ """二分向量，寻找目标"""
+ if self.height == 1 and self.width == 1:
+ del self.matrix_list[self.idx_object]
+ if self.mid == self.target:
+ self.exist = True
+ elif len(self.matrix_list) == 0:
+ self.exist = False
+ return
+
+ if self.mid > self.target: # 若 mid > target，取向量向量左 / 上段
+ self.matrix_list[self.idx_object: self.idx_object + 1] = [
+ [
+ self.bound[0],
+ max(self.bound[0], self.row_mid - 1),
+ self.bound[2],
+ max(self.bound[2], self.col_mid - 1)
+ ],
+ ]
+ elif self.mid < self.target: # 若 mid < target，取向量右 / 下段
+ self.matrix_list[self.idx_object: self.idx_object + 1] = [
+ [
+ min(self.bound[1], self.row_mid + 1),
+ self.bound[1],
+ min(self.bound[3], self.col_mid + 1),
+ self.bound[3]
+ ],
+ ]
+ else:
+ self.exist = True
+
+ def search(self):
+ """寻找目标"""
+ while self.exist is None:
+ self.bound = self.matrix_list[self.idx_object] # 正在处理的矩阵四边位置
+ self.height = self.bound[1] - self.bound[0] + 1
+ self.width = self.bound[3] - self.bound[2] + 1
+
+ self.row_mid = self.bound[0] + self.height // 2
+ self.col_mid = self.bound[2] + self.width // 2
+ self.mid = self.matrix[self.row_mid][self.col_mid]
+
+ if self.height == 1 or self.width == 1:
+ self.divide_vector()
+ else:
+ self.divide_matrix()
+
+ if self.exist:
+ self.location = [
+ self.row_mid + 1,
+ self.col_mid + 1
+ ]
+ return
+ elif self.exist is False: # not None 与 is False 均为 True
+ return
+
+target = 24
+matrix = [
+ [1, 4, 7, 11, 15, 17],
+ [2, 5, 8, 12, 19, 25],
+ [3, 6, 9, 16, 22, 27],
+ [10, 13, 14, 17, 24, 28],
+ [18, 21, 23, 26, 30, 31]
+]
+searcher = Searcher(matrix, target)
+searcher.search()
+print('原矩阵为：')
+for row in matrix:
+ print(*row, sep='\t')
+print(f'\n目标数字 {target} '
+ f'\n\t搜索结果为 {searcher.exist}')
+if searcher.exist:
+ print(f'\t数字位置为：'
+ f'\n\t\t上起第 {searcher.location[0]} 行'
+ f'\n\t\t左起第 {searcher.location[1]} 列')
\ No newline at end of file
diff --git a/homework_01_python/answer_08_perfect.py b/homework_01_python/answer_08_perfect.py
new file mode 100644
index 0000000000000000000000000000000000000000..2954adb93eca08a1281b0497bd1309e2f92d6f48
--- /dev/null
+++ b/homework_01_python/answer_08_perfect.py
@@ -0,0 +1,23 @@
+"""第 08 题：完数计算
+找出1000以内的所有完数，并打印输出。"""
+
+def factor(number):
+ """计算因数之和"""
+ sum_factor = 0
+ for i in range(1, number // 2 + 1): # 1 不是完备数，不必为其特殊考虑
+ if number % i == 0:
+ sum_factor += i
+ return sum_factor
+
+def collect(_ceiling):
+ """查找 ceiling 以内的完全数"""
+ _perfect_list = []
+ for num in range(1, _ceiling + 1):
+ if num == factor(num):
+ _perfect_list.append(num)
+ return _perfect_list
+
+ceiling = 1000
+perfect_list = collect(ceiling)
+print(f'{ceiling} 以内的完全数为：', end='')
+print(*perfect_list, sep=', ')
\ No newline at end of file
diff --git a/homework_01_python/answer_09_happy.py b/homework_01_python/answer_09_happy.py
new file mode 100644
index 0000000000000000000000000000000000000000..385560d0567c2f9e1a10f4f7d050ef5ff2b3484f
--- /dev/null
+++ b/homework_01_python/answer_09_happy.py
@@ -0,0 +1,32 @@
+"""第 09 题：快乐数
+编写一个算法来判断一个数 n 是不是快乐数。如果 n 是快乐数打印True ；不是，则打印输出False。"""
+
+def trans(num):
+ """替换数字为其各位平方和"""
+ num_str = str(num)
+ sum_squ = 0
+
+ for _digit in num_str:
+ sum_squ += int(_digit) ** 2
+
+ return sum_squ
+
+def trans_loop(num, _times):
+ """持续替换，直至回到自身"""
+ num = trans(num)
+ is_self = False
+ for _ in range(_times):
+ if num == 1:
+ is_self = True
+ break
+ else:
+ num = trans(num)
+ return is_self
+
+number = 19
+times = 100 # 循环上限次数
+judge = trans_loop(number, times)
+if judge:
+ print(f'{number} 是快乐数')
+else:
+ print(f'{number} 不是快乐数')
\ No newline at end of file
diff --git a/homework_01_python/answer_10_kid.py b/homework_01_python/answer_10_kid.py
new file mode 100644
index 0000000000000000000000000000000000000000..720310bd00f6eb9c470ca13fd9cded85e0a097c2
--- /dev/null
+++ b/homework_01_python/answer_10_kid.py
@@ -0,0 +1,27 @@
+"""第 10 题：连续的子数组和
+给你一个整数数组 nums 和一个整数 k ，编写一个函数来判断该数组是否含有同时满足下述条件的连续子数组：
+子数组大小 至少为 2 ，且子数组元素总和为 k 的倍数。"""
+
+def search(array, target):
+ """寻找满足条件的子数组"""
+ _kid = []
+
+ length = len(array)
+ for lag in range(1, length):
+ for begin in range(length - lag + 1):
+ sums = sum(array[begin : begin + lag + 1])
+ if sums % target == 0:
+ _found = True
+ _kid.append(array[begin: begin + lag + 1])
+ return _kid
+
+nums = [23, 2, 4, 6, 7]
+k = 6
+kids = search(nums, k)
+
+if len(kids) > 0:
+ print(f'数组 {nums} 满足和为 {k} 的连续子数组包括')
+ for i, kid in enumerate(kids):
+ print(f'子数组 {i} ：{kid}')
+else:
+ print(f'{nums} 不含满足和为 {k} 的连续子数组')
\ No newline at end of file
diff --git a/homework_01_python/answer_11_unique.py b/homework_01_python/answer_11_unique.py
new file mode 100644
index 0000000000000000000000000000000000000000..c63349c2f4bfdf134bf53053636ac24ac424108c
--- /dev/null
+++ b/homework_01_python/answer_11_unique.py
@@ -0,0 +1,23 @@
+"""第 11 题：确定字符串是否包含唯一字符
+实现一个算法：识别一个字符串中，是否包含唯一的字符。"""
+
+def check(_strs):
+ """检查重复字符串"""
+ _unique = True
+ for idx_query in range(len(_strs) - 1):
+ query = _strs[idx_query]
+ for idx_key in range(idx_query + 1, len(_strs)):
+ key = _strs[idx_key]
+ if query == key:
+ _unique = False
+ break
+ if not _unique:
+ break
+ return _unique
+
+strs = '1223'
+unique = check(strs)
+if unique:
+ print(f'字符串 {strs} 包含字符唯一')
+else:
+ print(f'字符串 {strs} 包含字符不唯一')
\ No newline at end of file
diff --git a/homework_01_python/answer_12_assembly.py b/homework_01_python/answer_12_assembly.py
new file mode 100644
index 0000000000000000000000000000000000000000..fd294b083d100530ad17639bba5798e8e432aaee
--- /dev/null
+++ b/homework_01_python/answer_12_assembly.py
@@ -0,0 +1,43 @@
+"""第 12 题：能够拼成多少个单词
+给出一个由小写字母组成的字符串 s，使用 s 中的字符来拼凑单词 'balloon'（气球）。
+字符串 s 中的每个字符最多只能被使用一次，求出 s 中的字符最多可以拼凑出多少个单词 'balloon'。"""
+
+def existence(_dict, key_query):
+ """检查字典有无目标键"""
+ exist = False
+ for key in _dict.keys():
+ if key == key_query:
+ exist = True
+ break
+ return exist
+
+
+def scrap(_word):
+ """将单词拆成字母"""
+ word_dict = {}
+ for character in _word:
+ if existence(word_dict, character):
+ word_dict[character] += 1
+ else:
+ word_dict[character] = 1
+ return word_dict
+
+
+def count(_str, _target):
+ """计算字符串可拼目标单词数"""
+ dict_target = scrap(_target)
+ dict_str = scrap(_str)
+ number = int(1e6)
+ for char_target in dict_target.keys():
+ if existence(dict_str, char_target):
+ number = min(number, dict_str[char_target] // dict_target[char_target])
+ else:
+ number = 0
+ break
+ return number
+
+
+word = 'balloon'
+strs = 'loonbalxballpoon'
+factor = count(strs, word)
+print(f'{strs} 可以拼成 {factor} 个 {word}')
diff --git a/homework_01_python/answer_13_activation.py b/homework_01_python/answer_13_activation.py
new file mode 100644
index 0000000000000000000000000000000000000000..1daa305f6aa6494b75c034202652033dd124b89c
--- /dev/null
+++ b/homework_01_python/answer_13_activation.py
@@ -0,0 +1,20 @@
+"""第 13 题：生成激活码
+做为 Apple Store App 独立开发者，你要搞限时促销，为你的应用生成激活码（或者优惠券），
+使用 Python 如何生成 200 个激活码（或者优惠券）？"""
+
+import random
+import string
+
+def generate(_num, _length):
+ """生成指定数量和长度的激活码"""
+ strs = string.ascii_letters + string.digits
+ codes = set()
+ while len(codes) < _num:
+ code = ''.join(random.choices(strs, k=_length))
+ codes.add(code)
+ return codes
+
+num = 200
+length = 11
+activation_codes = generate(num,length)
+print(*activation_codes, sep='\n')
\ No newline at end of file
diff --git a/homework_01_python/answer_14_category.py b/homework_01_python/answer_14_category.py
new file mode 100644
index 0000000000000000000000000000000000000000..2ffad09d423faf17ea02077bf63cb8b604c440d8
--- /dev/null
+++ b/homework_01_python/answer_14_category.py
@@ -0,0 +1,24 @@
+"""第 14 题：遍历目录
+需要把某个目录下面所有的某种类型的文件找到。
+例如把c:\下面所有的.dll或者.exe文件找到。
+需要注意的是，通过递归到每一个目录去查找。"""
+
+import os
+
+def seek(_root, _extensions):
+ """搜索指定目录下带有指定扩展名的文件"""
+ _files_list = []
+ count = 0
+ for _root, dirs, _files in os.walk(_root):
+ count += 1
+ for file in _files:
+ if any(file.endswith(ext) for ext in _extensions):
+ file_path = os.path.join(_root, file)
+ _files_list.append(file_path)
+ return _files_list
+
+root = r'c:\Program Files\Google'
+extensions = ['.dll', '.exe']
+files = seek(root, extensions)
+print(f'\n {root} 下，扩展名为 {extensions} 的文件包括：')
+print('', *files, sep='\n')
\ No newline at end of file
diff --git a/homework_01_python/answer_15_lines.py b/homework_01_python/answer_15_lines.py
new file mode 100644
index 0000000000000000000000000000000000000000..8c21827d672c5fab2c86ee422fb176a1a39f2465
--- /dev/null
+++ b/homework_01_python/answer_15_lines.py
@@ -0,0 +1,30 @@
+"""第 15 题：统计代码行数
+你有个目录，里面是程序（假如是C或者是Python），统计一下你写过多少行代码。
+包括空行和注释，但是要分别（例如C程序多少行，Python程序多少行，等等）列出来。"""
+
+import os
+
+def counting(_languages, _directory):
+ """统计代码行数"""
+ line_dict = {}
+ for lan in _languages:
+ line_dict[lan[0]] = 0
+
+ for root, dirs, files in os.walk(_directory):
+ for file in files:
+ file_path = os.path.join(root, file)
+
+ for lan, ext in _languages:
+ if file.endswith(ext):
+ with open(file_path, 'r', encoding='utf-8') as f:
+ lines = f.readlines()
+ line_dict[lan] += len(lines)
+ return line_dict
+
+directory = r'c:\Users\Lenovo\PyCharmProjects\PythonProject\heyuge'
+languages = [
+ ['Python', '.py'],
+ ['C', ('.c', '.h')]
+]
+results = counting(languages, directory)
+print(f'路径 {directory} 下，各类程序代码总行数为：',results, sep='\n')
\ No newline at end of file
diff --git a/name.txt b/name.txt
new file mode 100644
index 0000000000000000000000000000000000000000..788974aba3198d6559d5c0f753c14027b73040cc
--- /dev/null
+++ b/name.txt
@@ -0,0 +1,4 @@
+```
+何聿戈
+2023300410
+```
\ No newline at end of file