from typing import List, Any, Tuple


# 完成以下函数, 使用列表推导式进行选择和转换,
# 从 lst 列表里只保留严格大于零的元素, 然后对其取平方, 比如
#
# f001([2, 3, -1, 5, 0, 4]) == [4, 9, 25, 16]
# f001([1, -1, 2, -2, 3, -3]) == [1, 4, 9]
# f001([-2, -3, -1]) == []
#
def f001(lst: List[int]) -> List[int]:
    y = [i**2 for i in lst if i > 0]
    return y


# 完成以下函数, 使用列表推导式和内置函数 sum 统计字符 / 的数量, 比如
#
# 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:
    x = [i.count("/") for i in lst]
    y = sum(x)
    return y


# 完成以下函数, 使用列表推导式和内置函数 range、print, 使得
#
# f003(3) prints
# L
# LL
# LLL
#
# f003(5) prints
# L
# LL
# LLL
# LLLL
# LLLLL
#
# 提示: print 若运用灵活, 本题一行代码即可实现
def f003(n: int, /) -> None:
    [print(chr(76) * i) for i in range(1, n + 1)]


# 完成以下函数, 将 item 追加到 lst 列表的最后面, 并返回 None, 比如
#
# my_lst = [3, 1, 2]
# res = f004(my_lst, 0)
# res is None
# my_lst == [3, 1, 2, 0]
#
# my_lst = ["d", "f", "b"]
# res = f004(my_lst, "a")
# res is None
# my_lst == ["d", "f", "b", "a"]
#
def f004(lst: List, item: Any) -> None:
    res = lst.append(item)


# 完成以下函数, 不修改 lst 列表, 但返回一个新的列表实例,
# 由原 lst 列表追加 item 构成, 比如
#
# my_lst = [3, 1, 2]
# res = f005(my_lst, 0)
# res is not my_lst
# res == [3, 1, 2, 0]
#
# my_lst = ["d", "f", "b"]
# res = f005(my_lst, "a")
# res is not my_lst
# res == ["d", "f", "b", "a"]
#
def f005(lst: List, item: Any) -> List:
    res = lst + [item]  # 加法运算符将列表组合并返回一个新列表
    return res


# 完成以下函数, 将任意数量的位置实参追加到 lst 列表的最后面,
# 并返回 None, 比如
#
# my_lst = [3, 1, 2]
# res = f006(my_lst, 5, 0)
# res is None
# my_lst == [3, 1, 2, 5, 0]
#
# my_lst = ["d", "f", "b"]
# res = f006(my_lst, "a", "h", "c")
# res is None
# my_lst == ["d", "f", "b", "a", "h", "c"]
#
def f006(lst: List, *args) -> None:
    res = lst.extend(args)


# 完成以下函数, 不修改 lst 列表, 但返回一个新的列表实例,
# 由原 lst 列表追加任意数量的位置实参构成, 比如
#
# my_lst = [3, 1, 2]
# res = f007(my_lst, 5, 0)
# res is not my_lst
# res == [3, 1, 2, 5, 0]
#
# my_lst = ["d", "f", "b"]
# res = f007(my_lst, "a", "h", "c")
# res is not my_lst
# res == ["d", "f", "b", "a", "h", "c"]
#
def f007(lst: List, *args) -> List:
    res = lst + list(args)
    return res


# 完成以下函数, 返回一个基于 lst 的新列表实例,
# 不包含 lst 从左起的 n 个元素, 比如
#
# my_lst = [3, 1, 2, 5, 6]
# res = f008(my_lst, 2)
# res is not my_lst
# res == [2, 5, 6]
#
# my_lst = ["d", "f", "b", "a", "h", "c"]
# res = f008(my_lst, 4)
# res is not my_lst
# res == ["h", "c"]
#
def f008(lst: List, n: int) -> List:
    res = lst.copy()
    del res[:n]
    return res


# 完成以下函数, 返回一个基于 lst 的新列表实例,
# 由 lst 从左起的 n 个元素和 lst 从右起的 n 个元素构成, 比如
#
# my_lst = [3, 1, 2, 5, 6]
# res = f009(my_lst, 2)
# res is not my_lst
# res == [3, 1, 5, 6]
#
# my_lst = ["d", "f", "b", "a", "h", "c"]
# res = f009(my_lst, 1)
# res is not my_lst
# res == ["d", "c"]
#
def f009(lst: List, n: int) -> List:
    res = lst.copy()
    del res[n:-n]
    return res


# 完成以下函数, 删除 lst 末尾的 n 个元素, 并返回 None, 比如
#
# my_lst = [3, 1, 2, 5, 6]
# res = f010(my_lst, 2)
# res is None
# my_lst == [3, 1, 2]
#
# my_lst = ["d", "f", "b", "a", "h", "c"]
# res = f010(my_lst, 3)
# res is None
# my_lst == ["d", "f", "b"]
#
def f010(lst: List, n: int) -> None:
    del lst[-n:]


# 完成以下函数, 基于 lst 生成一个新的列表实例, 其元素基于 lst,
# 但其中的 None 被全部移动到最右边尾部, 比如
#
# my_lst = [3, None, 2, 5, 6]
# res = f011(my_lst)
# res is not my_lst
# res == [3, 2, 5, 6, None]
#
# my_lst = [None, "f", "b", "a", None, "c"]
# res = f011(my_lst)
# res is not my_lst
# res == ["f", "b", "a", "c", None, None]
#
def f011(lst: List) -> List:
    res = lst.copy()
    x = [
        index for index, value in enumerate(res) if value == None
    ]  # 利用emumerate函数获取列表res的值和索引，并将索引值赋给变量x
    x.reverse()  # 对索引列表进行倒序的原因在于，在删除元素时按照从后往前的顺序一步一步移除；如果是从前往后的话，索引的位置会出现偏差
    y = [res.pop(i) for i in x]  # 通过pop函数删除原来的元素，并返回
    res.extend(y)  # 将返回值添加至列表尾部
    return res


# 完成以下函数, 修改 lst 列表, 令其 None 元素全部移动到最右边尾部, 比如
#
# my_lst = [3, None, 2, 5, 6]
# res = f012(my_lst)
# res is None
# my_lst == [3, 2, 5, 6, None]
#
# my_lst = [None, "f", "b", "a", None, "c"]
# res = f012(my_lst)
# res is None
# my_lst == ["f", "b", "a", "c", None, None]
#
# 提示: 可以使用 for 语句, if 语句, del 语句, 和 enumerate 内置函数
def f012(lst: List) -> None:
    x = [index for index, value in enumerate(lst) if value == None]
    x.reverse()
    y = [lst.pop(i) for i in x]
    lst.extend(y)


# 完成以下函数, 返回一个新的列表实例, 内容是 hosts 和 ports 的元素
# 用 : 连接得出的新字符串, 比如
#
# my_hosts = ["www.cueb.edu.cn", "www.baidu.com", "www.google.com"]
# my_ports = [80, 443, 22]
# res = f013(my_hosts, my_ports)
# res == ["www.cueb.edu.cn:80", "www.baidu.com:443", "www.google.com:22"]
#
# 提示: 可以使用 zip 内置函数和 f-string
def f013(hosts: List[str], ports: List[int]) -> List[str]:
    y = []
    res = dict(zip(hosts, ports))  # 用zip内置函数将两个列表的元素一对一组合，并以返回字典形式的键值对
    for a, b in res.items():  # 放回字典的视图，可以从该视图中用for循环取字典的键值对，也可以将该返回值转为列表
        x = f"{a}:{b}"  # 用f-string将a,b内容赋值给x
        y.append(x)
    return y


# 完成以下函数, 使 lst 列表的元素反转, 并返回 None, 比如
#
# my_lst = [3, 1, 2]
# res = f014(my_lst)
# res is None
# my_lst == [2, 1, 3]
#
# my_lst = ["d", "f", "b"]
# res = f014(my_lst)
# res is None
# my_lst == ["b", "f", "d"]
#
def f014(lst: List[Any]) -> None:
    lst.reverse()


# 完成以下函数, 基于 lst 列表返回一个新的列表实例, 其内容是 lst 内容的反转,
# 而 lst 的内容要保持不变, 比如
#
# my_lst = [3, 1, 2]
# res = f015(my_lst)
# res == [2, 1, 3]
#
# my_lst = ["d", "f", "b"]
# res = f015(my_lst)
# res == ["b", "f", "d"]
#
def f015(lst: List[Any]) -> List[Any]:
    res = lst.copy()
    res.reverse()
    return res


# 完成以下函数, 使 lst 列表的元素变为升序排序, 并返回 None, 比如
#
# my_lst = [3, 1, 2]
# res = f016(my_lst)
# res is None
# my_lst == [1, 2, 3]
#
# my_lst = ["d", "f", "b"]
# res = f016(my_lst)
# res is None
# my_lst == ["b", "d", "f"]
#
def f016(lst: List[Any]) -> None:
    lst.sort()


# 完成以下函数, 基于 lst 列表返回一个新的列表实例,
# 其内容是 lst 经过升序排序后的内容, 而 lst 的内容要保持不变, 比如
#
# my_lst = [3, 1, 2]
# res = f017(my_lst)
# res == [1, 2, 3]
#
# my_lst = ["d", "f", "b"]
# res = f017(my_lst)
# res == ["b", "d", "f"]
#
def f017(lst: List[Any]) -> List[Any]:
    res = lst.copy()
    res.sort()
    return res


# 完成以下函数, 基于 lst 列表返回一个新的列表实例,2
# 其内容是 lst 经过排序后的内容, 其排序的标准是按元素的绝对值进行升序排序,
# 而 lst 的内容要保持不变, 比如
#
# my_lst = [3, 1, -2]
# res = f018(my_lst)
# res == [1, -2, 3]
#
# my_lst = [4, 1, -3, 2]
# res = f018(my_lst)
# res == [1, 2, -3, 4]
#
# 提示: 可以使用 abs 内置函数
def f018(lst: List[int]) -> List[int]:
    res = lst.copy()
    res.sort(key=abs)  # key参数的是一个函数，它指定可迭代对象中的每一个元素来按照该函数进行排序
    return res


# 完成以下函数, 基于 lst 列表返回一个新的列表实例,
# lst 列表里的内容是整数二元组,
# 排序的标准是按二元组前后两元素的差值进行升序排序, 比如
#
# my_lst = [(4, 3), (5, 1), (3, 1)]
# res = f019(my_lst)
# res == [(4, 3), (3, 1), (5, 1)]
#
# my_lst = [(4, -3), (5, 5), (1, 2), (3, 1)]
# res = f019(my_lst)
# res == [(1, 2), (5, 5), (3, 1), (4, -3)]
#
# 提示: 可以使用 lambda 匿名函数
def f019(lst: List[Tuple[int, int]]) -> List[Tuple[int, int]]:
    res = lst.copy()
    res.sort(
        key=lambda tuple: tuple[0] - tuple[1]
    )  # 补充:lambda参数含义，这里是tuple(其本质就是一个占位符)；这个tuple会遍历res列表当中的每一个元素
    # 这里分别是(4,-3),(5,5),(1,2),(3,1),并将这些元素进行表达式的计算，计算的返回值则决定了排序的顺序
    return res


# 完成以下函数, 基于 lst 列表返回一个排序后的新的列表实例,
# order 列表是人为给定的排序顺序, 比如 order 可以是
#
# ["优秀", "良好", "及格", "不及格"]
#
# 或者可以是
#
# ["Mon", "Tue", "Wen", "Thu", "Fri", "Sat", "Sun"]
#
# 排序的标准是按 order 所指定的元素顺序进行升序排序, 比如
#
# my_lst = ["良好", "不及格", "优秀", "良好"]
#
# res = f020(my_lst)
# res == ["优秀", "良好", "良好", "不及格"]
#
# my_lst = ["Tue", "Fri", "Tue", "Fri", "Mon"]
# my_order = ["Mon", "Tue", "Wen", "Thu", "Fri", "Sat", "Sun"]
# res = f020(my_lst)
# res == ["Mon", "Tue", "Tue", "Fri", "Fri"]
#
# 提示: 可以学习一下 str 类型的 index 方法
def f020(lst: List[Any], order: List[Any]) -> List[Any]:
    res = lst.copy()
    res.sort(  # sort中的key参数用法：key是一个用于生成排序键的函数，前面的可迭代对象(这里是res)会根据这个排序键进行排序，默认是None
        key=lambda x: order.index(x)
    )  # 用lambda函数中的x遍历res列表中的每一个元素，并利用列表的index方法，返回该元素在order列表中的索引，并按照该索引值进对Lst重新排序
    return res


# 完成以下函数, 实现列表列表 (list of list) 的转置 (transpose), 比如
#
# my_lst = [
#     ["aaa", "bbb", "ccc"],
#     [3.112, 4.721, 1.874],
# ]
# f021(my_lst) == [
#     ["aaa", 3.112],
#     ["bbb", 4.721],
#     ["ccc", 1.874],
# ]
#
# my_lst = [
#     ["ddd", "eee"],
#     [8.764, 4.329],
#     [0.926, 3.927],
#     [5.551, 7.452],
# ]
# f021(my_lst) == [
#     ["ddd", 8.764, 0.926, 5.551],
#     ["eee", 4.329, 3.927, 7.452],
# ]
#
# 提示: 可以使用列表推导式, 解包表达式和 zip 内置函数
def f021(lst: List[List]) -> List[List]:
    x = list(
        zip(*lst)
    )  # 使用zip(*lst)对lst列表内的元素进行解包，将lst内部各个列表的对应元素打包在一起(是以一个个元组呈现的)，从而实现元素的转置，最后再通过List将结果转为列表
    y = [list(i) for i in x]  # 遍历x列表中的每一个元组，并将这一个个元组转为列表
    return y