From bb38554cea8439d69dc16245995e8981bc9df405 Mon Sep 17 00:00:00 2001
From: zyy <3025824771@qq.com>
Date: Tue, 5 Mar 2024 11:06:41 +0800
Subject: [PATCH] zyy

---
 e01_str_quiz.py  | 30 +++++++++++-------
 e02_list_quiz.py | 54 ++++++++++++++++++--------------
 e03_dict_quiz.py | 80 ++++++++++++++++++++++++++++++++++--------------
 3 files changed, 107 insertions(+), 57 deletions(-)

diff --git a/e01_str_quiz.py b/e01_str_quiz.py
index f147c8e..950a7a0 100644
--- a/e01_str_quiz.py
+++ b/e01_str_quiz.py
@@ -2,27 +2,28 @@
 #
 # a string with 'single' quotes
 #
-A001 = ...
+A001 = "a string with 'single' quotes"
 
 
 # 在下面的赋值语句中填写表达式, 使得名称 A002 指向字符串实例
 #
 # a string with "double" quotes
 #
-A002 = ...
+A002 = 'a string with "double" quotes'
 
 
 # 在下面的赋值语句中填写表达式, 使得名称 A003 指向字符串实例
 #
 # a string with 'single' and "double" quotes
 #
-A003 = ...
+A003 = "a string with 'single' and \"double\" quotes"
 
 
 # 下面 Q004 也是字符串字面值的一种写法。
 # 请在 A004 后面写出等价的更简单的表达式, 使得 Q004 == A004
 Q004 = "foo" "bar"
-A004 = ...
+A004 = "foo" + "bar"
+Q004 = A004
 
 
 # 字符串中若包含跳格键 (TAB), 写字面值时需要转义 (escape)
@@ -31,7 +32,7 @@ A004 = ...
 # t    t    t
 #
 # 其中三个字符 t 之间是用 TAB 进行分隔
-A005 = ...
+A005 = "t\tt\tt"
 
 
 # 字符串中若包含换行符 (newline), 写字面值时需要转义 (escape)
@@ -42,7 +43,7 @@ A005 = ...
 # n
 #
 # 其中三个字符 n 之间是用换行符进行分隔
-A006 = ...
+A006 = "n\nn\nn"
 
 
 # 使用字符串的 f-string 功能完成以下函数, 使得
@@ -52,7 +53,9 @@ A006 = ...
 # f007(code="835185", exchange="Bj") == "835185.BJ|835185bj|BJ835185"
 #
 def f007(*, code, exchange):
-    ...
+    upper_exchange = exchange.upper()
+    lower_exchange = exchange.lower()
+    return f"{code}.{upper_exchange}|{code}{lower_exchange}|{upper_exchange}{code}"
 
 
 # 使用字符串的 f-string 功能完成以下函数, 在终端输出整数的 8 位二进制表现形式,
@@ -63,7 +66,8 @@ def f007(*, code, exchange):
 # f008(240) prints "11110000"
 #
 def f008(number, /):
-    ...
+    binary_string = f"{number:08b}"
+    print(binary_string)
 
 
 # 完成以下函数, 用 : 作为分隔符将多个字符串实参连接在一起, 使得
@@ -73,7 +77,7 @@ def f008(number, /):
 # f009("/home") == "/home"
 #
 def f009(*args):
-    ...
+    return ":".join(args)
 
 
 # 完成以下函数, 用 : 作为分隔符将字符串实参分割为字符串列表, 使得
@@ -83,7 +87,7 @@ def f009(*args):
 # f010("/home") == ["/home"]
 #
 def f010(joined):
-    ...
+    return joined.split(":")
 
 
 # 完成以下函数, 根据文件名 filename 实参返回 name, ext 元组,
@@ -94,4 +98,8 @@ def f010(joined):
 # f011("backup.tar.gz") == ("backup.tar", "gz")
 #
 def f011(filename):
-    ...
+    parts = filename.rsplit(".", 1)
+    if len(parts) == 2:
+        return tuple(parts)
+    else:
+        return (parts[0], "")
diff --git a/e02_list_quiz.py b/e02_list_quiz.py
index 2e69c58..5db397f 100644
--- a/e02_list_quiz.py
+++ b/e02_list_quiz.py
@@ -9,17 +9,16 @@ from typing import List, Any, Tuple
 # f001([-2, -3, -1]) == []
 #
 def f001(lst: List[int]) -> List[int]:
-    ...
+    return [x**2 for x in lst if x > 0]
 
 
-# 完成以下函数, 使用列表推导式和内置函数 sum 统计字符 / 的数量, 比如
-#
+# 完成以下函数, 使用列表推导式和内置函数 sum 统计字符 / 的数量, 比如exercise/e0501-builtins/e02_list_quiz.py
 # f002(["/home", "/home/qiang", "/etc"]) == 4
 # f002(["https://www.cueb.edu.cn", "www.baidu.com"]) == 2
 # f002(["pystudy", "exercise"]) == 0
 #
 def f002(lst: List[str]) -> int:
-    ...
+    return sum(s.count("/") for s in lst)
 
 
 # 完成以下函数, 使用列表推导式和内置函数 range、print, 使得
@@ -38,7 +37,7 @@ def f002(lst: List[str]) -> int:
 #
 # 提示: print 若运用灵活, 本题一行代码即可实现
 def f003(n: int, /) -> None:
-    ...
+    [print("L" * i) for i in range(1, n + 1)]
 
 
 # 完成以下函数, 将 item 追加到 lst 列表的最后面, 并返回 None, 比如
@@ -54,7 +53,7 @@ def f003(n: int, /) -> None:
 # my_lst == ["d", "f", "b", "a"]
 #
 def f004(lst: List, item: Any) -> None:
-    ...
+    lst.append(item)
 
 
 # 完成以下函数, 不修改 lst 列表, 但返回一个新的列表实例,
@@ -71,7 +70,7 @@ def f004(lst: List, item: Any) -> None:
 # res == ["d", "f", "b", "a"]
 #
 def f005(lst: List, item: Any) -> List:
-    ...
+    return lst + [item]
 
 
 # 完成以下函数, 将任意数量的位置实参追加到 lst 列表的最后面,
@@ -88,7 +87,7 @@ def f005(lst: List, item: Any) -> List:
 # my_lst == ["d", "f", "b", "a", "h", "c"]
 #
 def f006(lst: List, *args) -> None:
-    ...
+    lst.extend(args)
 
 
 # 完成以下函数, 不修改 lst 列表, 但返回一个新的列表实例,
@@ -105,7 +104,7 @@ def f006(lst: List, *args) -> None:
 # res == ["d", "f", "b", "a", "h", "c"]
 #
 def f007(lst: List, *args) -> List:
-    ...
+    return lst + list(args)
 
 
 # 完成以下函数, 返回一个基于 lst 的新列表实例,
@@ -122,7 +121,7 @@ def f007(lst: List, *args) -> List:
 # res == ["h", "c"]
 #
 def f008(lst: List, n: int) -> List:
-    ...
+    return lst[n:]
 
 
 # 完成以下函数, 返回一个基于 lst 的新列表实例,
@@ -139,7 +138,7 @@ def f008(lst: List, n: int) -> List:
 # res == ["d", "c"]
 #
 def f009(lst: List, n: int) -> List:
-    ...
+    return lst[:n] + lst[-n:]
 
 
 # 完成以下函数, 删除 lst 末尾的 n 个元素, 并返回 None, 比如
@@ -155,7 +154,7 @@ def f009(lst: List, n: int) -> List:
 # my_lst == ["d", "f", "b"]
 #
 def f010(lst: List, n: int) -> None:
-    ...
+    del lst[-n:]
 
 
 # 完成以下函数, 基于 lst 生成一个新的列表实例, 其元素基于 lst,
@@ -172,7 +171,7 @@ def f010(lst: List, n: int) -> None:
 # res == ["f", "b", "a", "c", None, None]
 #
 def f011(lst: List) -> List:
-    ...
+    return [x for x in lst if x is not None] + [x for x in lst if x is None]
 
 
 # 完成以下函数, 修改 lst 列表, 令其 None 元素全部移动到最右边尾部, 比如
@@ -189,7 +188,16 @@ def f011(lst: List) -> List:
 #
 # 提示: 可以使用 for 语句, if 语句, del 语句, 和 enumerate 内置函数
 def f012(lst: List) -> None:
-    ...
+    i = 0
+    for j, x in enumerate(lst):
+        if x is not None:
+            lst[i], lst[j] = lst[j], lst[i]
+            i += 1
+    for j in range(i, len(lst)):
+        if lst[j] is None:
+            lst[i], lst[j] = lst[j], lst[i]
+            i += 1
+    del lst[i:]
 
 
 # 完成以下函数, 返回一个新的列表实例, 内容是 hosts 和 ports 的元素
@@ -202,7 +210,7 @@ def f012(lst: List) -> None:
 #
 # 提示: 可以使用 zip 内置函数和 f-string
 def f013(hosts: List[str], ports: List[int]) -> List[str]:
-    ...
+    return [f"{host}:{port}" for host, port in zip(hosts, ports)]
 
 
 # 完成以下函数, 使 lst 列表的元素反转, 并返回 None, 比如
@@ -218,7 +226,7 @@ def f013(hosts: List[str], ports: List[int]) -> List[str]:
 # my_lst == ["b", "f", "d"]
 #
 def f014(lst: List[Any]) -> None:
-    ...
+    lst.reverse()
 
 
 # 完成以下函数, 基于 lst 列表返回一个新的列表实例, 其内容是 lst 内容的反转,
@@ -233,7 +241,7 @@ def f014(lst: List[Any]) -> None:
 # res == ["b", "f", "d"]
 #
 def f015(lst: List[Any]) -> List[Any]:
-    ...
+    return lst[::-1]
 
 
 # 完成以下函数, 使 lst 列表的元素变为升序排序, 并返回 None, 比如
@@ -249,7 +257,7 @@ def f015(lst: List[Any]) -> List[Any]:
 # my_lst == ["b", "d", "f"]
 #
 def f016(lst: List[Any]) -> None:
-    ...
+    lst.sort()
 
 
 # 完成以下函数, 基于 lst 列表返回一个新的列表实例,
@@ -264,7 +272,7 @@ def f016(lst: List[Any]) -> None:
 # res == ["b", "d", "f"]
 #
 def f017(lst: List[Any]) -> List[Any]:
-    ...
+    return sorted(lst)
 
 
 # 完成以下函数, 基于 lst 列表返回一个新的列表实例,
@@ -281,7 +289,7 @@ def f017(lst: List[Any]) -> List[Any]:
 #
 # 提示: 可以使用 abs 内置函数
 def f018(lst: List[int]) -> List[int]:
-    ...
+    return sorted(lst, key=lambda x: abs(x))
 
 
 # 完成以下函数, 基于 lst 列表返回一个新的列表实例,
@@ -298,7 +306,7 @@ def f018(lst: List[int]) -> List[int]:
 #
 # 提示: 可以使用 lambda 匿名函数
 def f019(lst: List[Tuple[int, int]]) -> List[Tuple[int, int]]:
-    ...
+    return sorted(lst, key=lambda x: x[0] - x[1])
 
 
 # 完成以下函数, 基于 lst 列表返回一个排序后的新的列表实例,
@@ -324,7 +332,7 @@ def f019(lst: List[Tuple[int, int]]) -> List[Tuple[int, int]]:
 #
 # 提示: 可以学习一下 str 类型的 index 方法
 def f020(lst: List[Any], order: List[Any]) -> List[Any]:
-    ...
+    return sorted(lst, key=lambda x: order.index(x))
 
 
 # 完成以下函数, 实现列表列表 (list of list) 的转置 (transpose), 比如
@@ -352,4 +360,4 @@ def f020(lst: List[Any], order: List[Any]) -> List[Any]:
 #
 # 提示: 可以使用列表推导式, 解包表达式和 zip 内置函数
 def f021(lst: List[List]) -> List[List]:
-    ...
+    return [list(x) for x in zip(*lst)]
diff --git a/e03_dict_quiz.py b/e03_dict_quiz.py
index 01319e1..79d3172 100644
--- a/e03_dict_quiz.py
+++ b/e03_dict_quiz.py
@@ -16,7 +16,7 @@ from typing import List, Dict, Tuple, Any
 def f001(dct: Dict[str, float]) -> Dict[str, float]:
     from math import log
 
-    ...
+    return {key.upper(): round(log(value), 4) for key, value in dct.items()}
 
 
 # 完成以下函数, 使用字典推导式进行转换, 键保持不变, 但值列表要取其平均数,
@@ -31,7 +31,7 @@ def f001(dct: Dict[str, float]) -> Dict[str, float]:
 # }
 #
 def f002(dct: Dict[str, List[int]]) -> Dict[str, float]:
-    ...
+    return {key: round(sum(values) / len(values), 1) for key, values in dct.items()}
 
 
 # 完成以下函数, 使用字典推导式进行转换, 将 lst 列表里的元素作为键,
@@ -50,7 +50,11 @@ def f002(dct: Dict[str, List[int]]) -> Dict[str, float]:
 def f003(lst: List[Tuple[float, float]]) -> Dict[Tuple, float]:
     from math import sqrt
 
-    ...
+    return {
+        point: round(sqrt(point[0] ** 2 + point[1] ** 2), 2)
+        for point in lst
+        if sqrt(point[0] ** 2 + point[1] ** 2) < 1
+    }
 
 
 # 完成以下函数, 将 keys 列表和 vals 列表组成一个字典,
@@ -70,7 +74,7 @@ def f003(lst: List[Tuple[float, float]]) -> Dict[Tuple, float]:
 #
 # 提示: 可以使用 zip, dict 内置函数
 def f004(keys: List[str], vals: List[float]) -> Dict[str, float]:
-    ...
+    return dict(zip(keys, vals))
 
 
 # 完成以下函数, 将 keys 列表里的元素作为键, cols 列表列表 (list of list)
@@ -105,7 +109,7 @@ def f004(keys: List[str], vals: List[float]) -> Dict[str, float]:
 #
 # 提示: 可以使用 zip, dict 内置函数
 def f005(keys: List[str], cols: List[List[float]]) -> Dict[str, List[float]]:
-    ...
+    return dict(zip(keys, cols))
 
 
 # 完成以下函数, 将 keys 列表里的元素作为键, rows 列表列表 (list of list)
@@ -138,7 +142,8 @@ def f005(keys: List[str], cols: List[List[float]]) -> Dict[str, List[float]]:
 #
 # 提示: 需要做类似转置的变换, 可以参考 e02_list_quiz.f021
 def f006(keys: List[str], rows: List[List[float]]) -> Dict[str, List[float]]:
-    ...
+    cols = list(map(list, zip(*rows)))
+    return dict(zip(keys, cols))
 
 
 # 完成以下函数, 将 keys 列表里的元素作为键, rows 列表列表 (list of list)
@@ -168,7 +173,7 @@ def f006(keys: List[str], rows: List[List[float]]) -> Dict[str, List[float]]:
 # ]
 #
 def f007(keys: List[str], rows: List[List[float]]) -> List[Dict[str, float]]:
-    ...
+    return [dict(zip(keys, row)) for row in rows]
 
 
 # 完成以下函数, 将 keys 列表里的元素作为键, cols 列表列表 (list of list)
@@ -201,7 +206,8 @@ def f007(keys: List[str], rows: List[List[float]]) -> List[Dict[str, float]]:
 #
 # 提示: 需要做类似转置的变换, 可以参考 e02_list_quiz.f021
 def f008(keys: List[str], cols: List[List[float]]) -> List[Dict[str, float]]:
-    ...
+    rows = list(map(list, zip(*cols)))
+    return [dict(zip(keys, row)) for row in rows]
 
 
 # 完成以下函数, 实现从列表字典 (dict of list) (列式数据集 column-wise dataset)
@@ -230,7 +236,7 @@ def f008(keys: List[str], cols: List[List[float]]) -> List[Dict[str, float]]:
 #
 # 提示: 推导式套推导式, 一行代码足矣
 def f009(lst: List[Dict[str, float]]) -> Dict[str, List[float]]:
-    ...
+    return {key: [dic[key] for dic in lst] for key in lst[0]}
 
 
 # 完成以下函数, 实现从列表字典 (dict of list) (列式数据集 column-wise dataset)
@@ -260,7 +266,9 @@ def f009(lst: List[Dict[str, float]]) -> Dict[str, List[float]]:
 # 提示: 综合使用推导式、解包表达式以及 dict, zip, dict.keys, dict.values
 #       等内置类型/函数/方法
 def f010(dct: Dict[str, List]) -> List[Dict]:
-    ...
+    keys = list(dct.keys())
+    values = list(dct.values())
+    return [dict(zip(keys, vs)) for vs in zip(*values)]
 
 
 # 完成以下函数, 使函数不返回值 (返回 None), 但在 dct 字典的最后新增一对
@@ -277,7 +285,8 @@ def f010(dct: Dict[str, List]) -> List[Dict]:
 # my_dct == {"e": 3.14, "f": 2.74, "g": 0.25}
 #
 def f011(dct: Dict, newk: str, newv: Any) -> None:
-    ...
+    dct[newk] = newv
+    return None
 
 
 # 完成以下函数, 使函数不修改 dct 字典, 而是在 dct 字典的基础上返回一个
@@ -292,7 +301,9 @@ def f011(dct: Dict, newk: str, newv: Any) -> None:
 # res == {"e": 3.14, "f": 2.74, "g": 0.25}
 #
 def f012(dct: Dict, newk: str, newv: Any) -> Dict:
-    ...
+    new_dct = dct.copy()
+    new_dct[newk] = newv
+    return new_dct
 
 
 # 完成以下函数, 使函数不修改 dct 字典, 而是在 dct 字典的基础上返回一个
@@ -307,7 +318,9 @@ def f012(dct: Dict, newk: str, newv: Any) -> Dict:
 # res == {"g": 0.25, "e": 3.14, "f": 2.74}
 #
 def f013(dct: Dict, newk: str, newv: Any) -> Dict:
-    ...
+    new_dct = {newk: newv}
+    new_dct.update(dct)
+    return new_dct
 
 
 # 完成以下函数, 使函数不返回值 (返回 None), 但要从 dct 字典里删除掉
@@ -319,11 +332,14 @@ def f013(dct: Dict, newk: str, newv: Any) -> Dict:
 # res is None
 # my_dct == {"a": 3, "c": 2}
 
+
 # my_dct = {"a": 3, "b": 1, "c": 2}
 # res = f014(my_dct, "d") # KeyError
 #
 def f014(dct: Dict, key: str) -> None:
-    ...
+    if key not in dct:
+        raise KeyError("Key not found in dictionary")
+    del dct[key]
 
 
 # 完成以下函数, 从 dct 字典里删除掉键 key 所对应的键值对, 返回键 key 所对应的
@@ -334,11 +350,16 @@ def f014(dct: Dict, key: str) -> None:
 # res == 1
 # my_dct == {"a": 3, "c": 2}
 
+
 # my_dct = {"a": 3, "b": 1, "c": 2}
 # res = f015(my_dct, "d") # KeyError
 #
 def f015(dct: Dict, key: str) -> None:
-    ...
+    try:
+        value = dct.pop(key)
+        return value
+    except KeyError:
+        raise KeyError("Key not found in dictionary")
 
 
 # 完成以下函数, 从 dct 字典里删除掉键 key 所对应的键值对, 返回键 key 所对应的
@@ -349,12 +370,13 @@ def f015(dct: Dict, key: str) -> None:
 # res == 1
 # my_dct == {"a": 3, "c": 2}
 
+
 # my_dct = {"a": 3, "b": 1, "c": 2}
 # res = f016(my_dct, "d")
 # res is None
 #
 def f016(dct: Dict, key: str) -> None:
-    ...
+    return dct.pop(key, None)
 
 
 # 完成以下函数, 使得: 若 dct 字典里存在键 akey, 则不对 dct 做任何改变;
@@ -372,7 +394,7 @@ def f016(dct: Dict, key: str) -> None:
 # my_dct = {"a": 3, "c": 2, "b: 5"}
 #
 def f017(dct: Dict, akey: str, aval: Any) -> Any:
-    ...
+    return dct.setdefault(akey, aval)
 
 
 # 完成以下函数, 使函数不返回值 (返回 None), 使用其传入的任意命名实参
@@ -389,7 +411,7 @@ def f017(dct: Dict, akey: str, aval: Any) -> Any:
 # my_dct = {"a": 5, "b": 1, "c": 2, "e": 4, "d": 0}
 #
 def f018(dct: Dict, **kvs) -> None:
-    ...
+    dct.update(kvs)
 
 
 # 完成以下函数, 使函数返回一个新的字典实例, 该字典以 dct 字典为基础,
@@ -404,7 +426,9 @@ def f018(dct: Dict, **kvs) -> None:
 # res = {"a": 5, "b": 1, "c": 2, "e": 4, "d": 0}
 #
 def f019(dct: Dict, **kvs) -> Dict:
-    ...
+    new_dct = dct.copy()
+    new_dct.update(kvs)
+    return new_dct
 
 
 # 完成以下函数, 修改 dct1 和 dct2 两字典实例, 使其内容相互对换,
@@ -425,7 +449,14 @@ def f019(dct: Dict, **kvs) -> Dict:
 # my_dct2 = {"d": 5, "c": 1}
 #
 def f020(dct1: Dict, dct2: Dict) -> None:
-    ...
+    dct1_keys = list(dct1.keys())
+    dct2_keys = list(dct2.keys())
+
+    for key in dct1_keys:
+        dct2[key] = dct1.pop(key)
+
+    for key in dct2_keys:
+        dct1[key] = dct2.pop(key)
 
 
 # 完成以下函数, 返回 dct 字典里 key 键所对应的值, 如果 key 键在 dct 字典里
@@ -439,7 +470,7 @@ def f020(dct1: Dict, dct2: Dict) -> None:
 # res = f021(my_dct, "e")  # KeyError
 #
 def f021(dct: Dict[str, Any], key: str) -> Any:
-    ...
+    return dct[key]
 
 
 # 完成以下函数, 返回 dct 字典里 key 键所对应的值, 如果 key 键在 dct 字典里
@@ -454,7 +485,7 @@ def f021(dct: Dict[str, Any], key: str) -> Any:
 # res is None
 #
 def f022(dct: Dict[str, Any], key: str) -> Any:
-    ...
+    return dct.get(key)
 
 
 # 完成以下函数, 从若干个提供的字典里, 依次查找 key 键所对应的值,
@@ -478,4 +509,7 @@ def f022(dct: Dict[str, Any], key: str) -> Any:
 #
 # 提示: 可以考虑构造一个融合字典, 从中 get
 def f023(key: str, *dcts: Tuple[Dict[str, Any]]) -> Any:
-    ...
+    for dct in dcts:
+        if key in dct:
+            return dct[key]
+    return None
-- 
Gitee