第四周测试

1.异常捕获完整语法结构

• 在 Python 中，我们可以使用 try…except…语句来捕捉和处理异常。
  • 其完整语法结构如下：

try:
    # 可能抛出异常的代码块
    # ...
except Exception1:
    # 处理 Exception1 异常的代码块
    # ...
except Exception2:
    # 处理 Exception2 异常的代码块
    # ...
except:
    # 处理所有其他异常的代码块
    # ...
else:
    # 如果 try 块中没有抛出任何异常，这里的代码块将会被执行
    # ...
finally:
    # 不管异常是否发生，这里的代码块一定会被执行
    # ...

• 以上是 try…except 的完整语法结构。

try 块：

​ 包含可能抛出异常的代码块。
except 块：

​ 当 try 块中抛出异常时，会寻找相应的 except 块进行处理。可以指定多个 except 块来处理不同的异常信息。
else 块：

​ 在 try 块中没有抛出任何异常时，这里的代码块将会被执行。
finally 块：

​ 无论 try 块中是否抛出异常，这里的代码块一定会被执行。

• 需要注意的是
  • try…except…语句至少需要包含一个 try 块和一个 except 块，else 块和 finally 块是可选的。
  • except 块可以使用不同的异常类型来处理异常，也可以使用一个通用的 except 块来处理所有的异常。
    • 如果只有一个通用的 except 块被设置，那么这个块将会捕捉所有未被特别处理的异常，包括系统错误。
• 在 Python 中，异常是一个类，异常的种类是通过异常类实现的。
  • 我们可以向 except 块传递一个或多个异常类型以捕获特定的异常。
  • 如果没有指定异常类型，那么 except 块将会捕获所有异常类型。
• 例如
  • 以下是在 try…except 块中捕获特定异常的示例：

try:
    num = int(input("请输入一个整数："))
    result = 10 / num
    print("结果是：", result)
except ZeroDivisionError:
    print("除数不能为零")
except ValueError:
    print("输入的不是整数")

• 在这个代码片段中
  • 如果用户输入非整数或者 0
    • try 块中的代码会抛出 ValueError 或者 ZeroDivisionError 异常，这时程序会跳转到对应的 except 块中，输出对应异常的错误信息。
  • 如果没有发生任何异常
    • 那么 else 块中的代码会被执行
      • 即输出 “结果是：” 并且输出计算结果。
  • 不管异常是否发生，finally 块中的代码都会被执行。

2.阐述可迭代对象、迭代器器对象、⽣成器对象彼此有何联系

• 可迭代对象 Iterable：
  • 指支持使用 for...in... 进行遍历的对象。可迭代对象可以是列表、元组、集合、字典、文件等。
  • 可迭代对象可以使用 iter() 方法将其转换为迭代器对象。
  • 在 Python 中，任何实现了__iter__()方法和__next__()方法的对象都是可迭代对象。
• 迭代器对象 Iterator：
  • 一个包含__next__()方法的对象，该方法返回下一个元素或引发 StopIteration 异常。
  • 迭代器对象用于从可迭代序列中取出元素，每次返回一个元素。
  • 所有迭代器都是可迭代对象，但不是所有可迭代对象都是迭代器。
  • 迭代器对象可以使用 iter() 函数获得，也可以通过使用 yield 关键字创建生成器对象。
• 生成器对象 Generator：
  • 生成器是一种特殊的迭代器，在函数中使用 yield 关键字可以将函数转换为生成器。
  • 生成器对象是一种特殊的迭代器，在调用 next() 时可以继续运行之前暂停的函数。
  • 与普通函数不同，生成器函数可以返回多个值，并且可以在整个过程中保持局部变量的值，使得代码更加简单、更具可读性。
• 这三个概念之间的关系是
  • 只有实现了 __iter__() 方法的对象才是可迭代对象，同时可迭代对象可以使用 iter() 方法获得一个迭代器对象。
  • 迭代器对象可以被 next() 方法调用来获取里面的值，直到抛出 StopIteration 异常来表示已经到达了最后一个值。
  • 在 Python 中，生成器函数在被调用时返回一个生成器对象，而生成器对象则是一种特殊的迭代器对象。可以使用 yield 关键字来创建生成器函数。
• 因此，我们可以得出以下结论：
  • 可迭代对象可以通过 iter() 方法获得一个迭代器对象，而迭代器对象可以使用 next() 方法获得值。
  • 生成器对象是一种特殊的迭代器对象，可以通过使用 yield 关键字创建生成器函数，在调用 next() 时可以继续运行之前暂停的函数。
  • 所有的迭代器对象都是可迭代对象，但不是所有的可迭代对象都是迭代器对象。

3.⼿写⾃定义range功能代码

• 以下是手写自定义 range() 函数的示例代码：

def my_range(start, end, step=1):
    """自定义 range() 函数，功能与内置的 range() 函数类似"""
    if step == 0:
        raise ValueError("step cannot be zero")
    elif step > 0:
        while start < end:
            yield start
            start += step
    else:
        while start > end:
            yield start
            start += step

• 这个函数接受三个参数：

  • start、end 和 step。
  • 其中 start 表示起始值，end 表示最终值（不包括在范围内），step 表示步长大小，如果未指定，默认为 1。如果 step 参数为 0，则抛出 ValueErro 异常。
  • 这个函数使用了 yield 关键字来创建了一个生成器对象。
  • 在函数中，使用 while 循环来逐步生成范围内的数字。
  • 如果 step 大于 0，则生成起始值+步长、起始值+2步长、起始值+3步长，直到最终值为止。
  • 如果 step 小于 0，则生成起始值-步长、起始值-2步长、起始值-3步长，直到最终值为止。

• 这个自定义 range() 函数与内置的 range() 函数类似，可以使用 for 循环来进行遍历。例如，使用以下代码来生成和遍历一个范围：

  for num in my_range(1, 10, 2):
      print(num)
  

  • 这个代码将会输出 1、3、5、7 和 9，即从 1 开始、步长为 2，生成范围为 10 的数字。

4.⽣成器表达式如何编写，有何注意事项

• 生成器表达式是一种使用简单语法来创建生成器的方式，它使用类似列表推导式的语法，但是返回的是一个迭代器。

  • 生成器表达式的语法结构如下：

  (expression for variable in iterable if condition)
  

• 生成器表达式包含一个 expression，一个可迭代的 iterable，以及可选的一个或多个 if 条件。

  • 这个表达式每次生成一个新的值，并且只在需要时计算，节省了内存和计算成本。
  • 以下是一个使用生成器表达式计算平方数的示例代码：

squares = (x ** 2 for x in range(10))
for square in squares:
    print(square)

• 在这个示例中，使用生成器表达式 (x ** 2 for x in range(10)) 来创建一个生成器。
• 这个生成器会计算 0 到 9 的平方数并生成结果。在 for 循环中遍历这个生成器，并打印每个计算出来的平方数。

生成器表达式有以下注意事项：

• 生成器表达式中使用的变量只在表达式内部有效，不会对外部变量造成影响。
• 生成器表达式只能生成一个新值，它不会像列表推导式一样创建一个完整的列表。
• 生成器表达式的优点是非常节省内存和计算成本，因为它每次只生成一个值，并且只在需要时计算。
• 生成器表达式支持使用 if 条件语句筛选生成的值，语法与列表推导式类似。
• 生成器表达式的返回值是一个迭代器，需要通过遍历操作来获取其中的值。
• 生成器表达式可以嵌套使用，从而实现更为复杂的操作。
• 总体而言，生成器表达式是一种非常灵活、高效的方式来创建生成器，在使用时需要注意表达式内部变量的作用域以及生成器返回的是一个迭代器而不是完整的列表。

5.列举⾄少10个常⻅内置函数及主要功能

以下是至少 10 个常见的内置函数及其主要功能：

print(...)：用于在控制台上输出一个或多个值。
len(...)：用于返回容器（如字符串、列表、元组、字典等）包含的元素个数。
sorted(...)：用于对列表或可迭代对象进行排序操作，返回一个新的排序好的列表。
type(...)：用于返回对象的类型。
range(...)：用于生成一个指定范围内的整数序列。
sum(...)：用于计算一个序列或可迭代对象中所有数值的总和。
str(...)：用于将各种类型的值转换为字符串。
int(...)：用于将各种类型的值转换为整数。
float(...)：用于将各种类型的值转换为浮点数。
input(...)：用于在控制台上获取用户的输入。

以上是常见的 10 个内置函数，每个函数都有其主要的功能。需要注意的是，内置函数不需要先进行导入，可以直接在代码中使用。使用内置函数可以使代码更加简洁和高效。除以上列举的函数外，Python 的标准库中还包含了大量常用的内置函数，可以根据不同的需求进行使用。

其中 map() 和 filter() 函数是具有相似功能的函数，而其他函数则有各自独立的功能

• map(函数, 可迭代对象)：
  • 将可迭代对象的每个元素逐个传入函数中进行处理，返回一个新的可迭代对象，其中包含了处理后的每个元素值。
  • 可以理解为是对列表中的每个元素进行某种变换，如：

result = map(lambda x: x**2, [1, 2, 3, 4, 5])  # 对列表中的每个元素进行平方操作
print(list(result))  # 输出结果为 [1, 4, 9, 16, 25]

• filter(函数, 可迭代对象)：
  • 将可迭代对象中的每个元素逐个传入函数中处理，仅保留函数返回值为 True 的元素，返回一个新的可迭代对象。
  • 即对列表进行过滤返回符合条件的元素集合，如：

result = filter(lambda x: x > 3, [1, 2, 3, 4, 5])  # 保留列表中值大于 3 的元素
print(list(result))  # 输出结果为 [4, 5]

• min(可迭代对象)：
  • 找到可迭代对象中最小的元素并返回，可迭代对象中数据类型需要可比较，如：

result = min([1, 2, 3, 4, 5])  # 找到列表中最小的元素
print(result)  # 输出结果为 1

• max(可迭代对象)：
  • 找到可迭代对象中最大的元素并返回，可迭代对象中数据类型需要可比较，如：

result = max([1, 2, 3, 4, 5])  # 找到列表中最大的元素
print(result)  # 输出结果为 5

• abs(数值)：
  • 返回一个数值的绝对值，如：

result = abs(-1)  # 计算 -1 的绝对值
print(result)  # 输出结果为 1

• enumerate(可迭代对象)：
  • 将可迭代对象中的元素逐一枚举为元组 (index, item) 的形式，并返回一个可迭代对象。
  • 即对列表进行枚举，返回元素索引值和元素值的对应关系，如：

result = enumerate(['a', 'b', 'c'])  # 枚举列表
print(list(result))  # 输出结果为 [(0, 'a'), (1, 'b'), (2, 'c')]


float()/list()/int()：将其他类型强制转换为浮点型、列表和整型，如：

result1 = float("3.14")  # 将字符串转换为浮点型
result2 = list((1, 2, 3))  # 将元组转换为列表
result3 = int("100")  # 将字符串转换为整型
print(result1, result2, result3)  # 输出结果为 3.14, [1, 2, 3], 100

• any(可迭代对象)：
  • 如果可迭代对象中的任意一个元素为真，返回 True；如果所有的元素都为假，则返回 False。
  • 可迭代对象包括字符串、列表、元组等，如：

result = any([0, '', False, [], {}])  # 判断列表中是否有一个元素为真
print(result)  # 输出结果为 False

6.什么是模块，有哪些来源和表现形式

• 在 Python 中

  • 模块（Module）通常指一个.py 文件，它可以包含 Python 对象的定义，如函数、类、变量等。
  • 模块可以被导入到其他程序中使用，从而方便地进行代码复用。

• 模块的来源：

  • 标准库模块：
    • Python 标准库中内置的模块，如 math、sys、os 等。
  • 第三方模块：
    • 由其他开发者编写的模块，可以在 PyPI（Python 软件包索引）上下载使用。
  • 自定义模块：
    • 由开发者自己编写的模块，可以包含一些自定义的函数、类、变量等。

• 模块的表现形式：

  • 单文件模块：
    • 将所有 Python 对象定义在同一个.py 文件中，可以通过 import 语句导入使用。
  • 包：
    • 包是一种特殊的目录结构，它将多个单文件模块组织到一起。通常在包目录中包含一个 init.py 文件表示该目录为包，可以通过 import 语句指定包名和模块名导入使用。
  • C 扩展模块：
    • 由 C 语言编写的 Python 扩展模块，可以用来扩展 Python 的功能，提高计算性能。
  • 互联网模块：
    • Python 同样支持使用互联网上的模块，如使用 urllib 模块进行网络请求数据等。

• Python 的模块是可重用的代码单元，开发者可以通过开发和使用模块来提高代码的可维护性、可读性和复用性。模块的使用可以加快开发速度，提高代码的效率和可靠性。

7.import句式内部详细执行流程(执⾏⽂件run.py 模块md.py)

• 假设有两个 Python 文件：run.py 和 md.py。
• run.py 文件中包含如下代码：

import md

result = md.add(1, 2)
print(result)

• md.py 文件中包含如下代码：

def add(x, y):
    return x + y

• 执行 run.py 文件时的 import 语句内部详细执行流程如下：

  • Python 解释器首先会获取 import 关键字后面指定模块名 “md” 向上查找模块文件。

    • 如果找不到则会抛出 ModuleNotFoundError 异常。

  • 如果找到了对应的模块文件，Python 解释器会先检查 sys.modules 字典中是否已经存在该模块对象

    • 如果已经存在则不会再次执行模块的加载和解释，直接返回已有的模块对象。

  • 如果该模块对象不在 sys.modules 字典中，则会创建一个新的模块对象，并将该模块对象添加到 sys.modules 字典中。

    • 在创建模块对象时，Python 解析器会执行该模块文件中的所有语句，并将其中定义的所有函数、类、变量等均添加到该模块对象的命名空间中。

  • 解释器将模块的命名空间对象返回给 import 语句中的变量 md。

  • 通过 md 变量可以访问到 md.py 文件中定义的 add 函数，在 run.py 文件中进行调用并输出结果。

• 在 Python 中，import 语句是确保代码可重复使用的一个关键因素，理解 import 的内部执行流程也有助于理解程序的执行机制和模块的实际工作机制。

8.from...import句式内部详细执行流程(执行⽂件run.py 模块 md.py)

• 假设有两个 Python 文件：run.py 和 md.py。
• run.py 文件中包含如下代码：

from md import add

result = add(1, 2)
print(result)

• md.py 文件中包含如下代码：

def add(x, y):
    return x + y

• 执行 run.py 文件时的 from…import 语句内部详细执行流程如下：

  • Python 解释器首先会获取 import 关键字后面指定模块名 “md” 的模块文件。
    • 如果找不到则会抛出 ModuleNotFoundError 异常。
    • 如果找到了对应的模块文件，Python 解释器会先检查 sys.modules 字典中是否已经存在该模块对象，如果已经存在则不会再次执行模块的加载和解释，直接返回已有的模块对象。
  • 如果该模块对象不在 sys.modules 字典中，则会创建一个新的模块对象，并将该模块对象添加到 sys.modules 字典中。
    • 在创建模块对象时，Python 解析器会执行该模块文件中的所有语句，并将其中定义的所有函数、类、变量等均添加到该模块对象的命名空间中。
    • Python 解释器从创建好的模块对象中获取所需的 add 函数对象并创建一个新的名称为 add 的变量名，并将该函数对象赋值给这个变量，存储在当前的命名空间对象中。
  • 解释器执行后续语句，在 run.py 文件中调用名称为 add 的变量名中存储的 add 函数并输出结果。

• 在 Python 中，from…import 语句和 import 语句类似，也是确保代码可重复使用的一个关键因素，理解 from…import 的内部执行流程也有助于理解程序的执行机制和模块的实际工作机制。

9.模块导⼊有哪些注意事项和⼩技巧

• 模块导入是 Python 中常用的功能之一，以下是模块导入时需要注意的一些事项和小技巧：

  • 模块命名不要和 Python 中已有的模块名重复
    • 否则可能会引起命名冲突。
  • 避免在模块中出现相同的变量名和函数名
    • 否则可能会引起变量覆盖和函数重定义等问题。
  • 在遇到导入模块时发生错误时
    • 可以使用 try…except 语句进行异常处理，以避免错误终止程序运行。
  • 要注意使用相对路径或绝对路径导入模块
    • 以确保模块可以被正确读取。
  • 可以使用 as 关键字为导入的模块或函数指定别名
    • 以提高代码可读性。
  • 可以使用 from…import 语句选择性地导入模块中的函数或变量
    • 可以提高程序的执行效率和代码可读性。
  • 如果想要在模块中运行某些代码，可以在模块末尾添加类似于 if __name__ == '__main__': 的语句
    • 这样可以让模块既可以作为独立的程序运行
    • 也可以作为其他程序的模块导入使用。
  • 可以使用 dir() 或 help() 函数查看模块中定义的函数、变量和类等信息，帮助了解和使用模块中的内容。
  • 可以使用 importlib.reload() 函数重新加载已经导入的模块，以防止模块的修改没有生效。
  • 避免在模块中定义全局变量，以免造成在导入模块时就会执行模块中的代码，增加程序复杂度和性能负担。

• 模块导入是 Python 编程中必不可少的一个功能，正确地使用模块导入可以提高程序的复用和可维护性。

10.如何判断当前⽂件是执行⽂件还是模块⽂件

• 在 Python 中，可以通过 built-in 变量 name 来判断当前文件是作为程序入口执行的主文件还是作为模块被导入的子文件。

• 当一个 Python 文件被直接执行时，它的 name 值是 'main'，而当该文件被作为模块导入到其他文件中时，name 值是该模块的名称。

• 例如，当以下代码直接在命令行中执行时，会输出 "This is the main program":

if __name__ == '__main__':
    print("This is the main program")

• 但是，如果该代码作为模块被导入到其他文件中，这个条件语句会被忽略，不会输出 "This is the main program"，因为此时 name 的值不是 'main'。
• 这种方式可以使程序在不同的场合下，按照不同的逻辑进行处理，比如在开发时模块可以被直接运行以测试其功能，而在使用时则被当作库调用来使用。

11.模块的查找顺序是什么，针对该顺序导⼊模块如何做到不会轻易出错

• 在 Python 中，模块的查找顺序遵循以下规则：

  • 首先在当前目录或 sys.path 列表中的路径中查找模块文件，如果找到则直接导入。
  • 如果没找到，则在内置模块列表中查找该模块是否存在，若存在则直接导入。
  • 如果都没有找到，则会进入 sys.path 中列出的路径中逐一查找，直到找到该模块为止，如果没有找到则抛出 ImportError 异常。

• 因此，为了避免模块导入时出现错误，需要遵循以下几点：

  • 尽量不要和 Python 中已有的模块重名。
  • 在导入模块时，需要确保模块文件的路径正确，并将它添加到 sys.path 中以确保 Python 解释器可以找到它。
  • 如果导入的模块较多，可以使用相对路径导入，以避免对 sys.path 变量的依赖。
  • 如果存在不同版本的模块，需要根据优先级以及适用范围等因素，来定义导入顺序，并在导入时明确指定需要使用的模块名称或路径。
  • 在导入时，应该尽量避免使用 from module import * 的方式导入，因为这种方式会污染命名空间，可能会导致出错或不可预料的结果。

• 总之，正确导入和使用模块是 Python 编程中必不可少的一环，需要仔细分析每个模块的依赖关系和使用场景，并按照一定的顺序和规范对其进行导入和使用。

12.尽可能完整写出软件开发⽬录规范及相应⽂件及功能

一个完整的软件开发目录规范通常包括以下文件和功能：

docs/ 目录 - 存放项目文档，通常包括需求文档、设计文档、API 文档和用户手册等。
scripts/ 目录 - 存放与项目相关的脚本，通常用于部署、测试、调试、数据转换等。
src/ 目录 - 存放源代码，通常会按照模块或功能划分子目录。示例如下：

src/main.py - 程序入口文件
src/utils/ - 存放通用工具模块
src/core/ - 存放核心模块
src/modules/ - 存放各种模块，每个模块可以单独抽离和使用

tests/ 目录 - 存放测试代码和测试数据，通常会按照模块或功能划分子目录。
dist/ 目录 - 存放编译后和打包后的程序或库文件。
configs/ 目录 - 存放配置文件，比如数据库连接配置、日志格式配置等。
requirements.txt - 存放项目依赖的第三方库及其版本号。
LICENSE.txt - 存放项目的版权声明。
README.md - 项目说明文档，包括项目简介、安装和使用说明等。

以上仅为示例，具体的目录结构和功能根据具体的开发项目和团队需求而定。在实践中，可以根据项目的规模、团队规模、开发周期等因素，来确定合适的目录结构和文件功能。同时，规范化的目录结构和文件功能也有利于团队合作和项目维护。

13.什么是正则表达式，有哪些重要知识部分

• 正则表达式是一种用于匹配和查找文本中符合特定模式的字符序列的表达式。
  • 它是由一些普通字符（例如字母、数字）和一些特殊字符（称为元字符）组成的模式。
  • 应用正则表达式可以方便地从大量文本中提取所需信息、验证数据格式、进行数据清洗等。
• 以下是正则表达式的一些重要知识部分：
  • 基本字符匹配：
    • 正则表达式可以使用文本中的普通字符进行精确匹配。
    • 例如，用正则表达式 /hello/ 可以查找文本中所有包含 “hello” 子串的位置。
  • 字符集：
    • 正则表达式可以使用字符集来表示多个字符中的任何一个。
    • 例如，用正则表达式 /[abc]/ 可以查找文本中所有包含字符 “a”、“b” 或者 “c” 的位置。
  • 量词：
    • 正则表达式可以使用量词来表示一个模式出现的次数。
    • 例如，用正则表达式 /a{2,4}/ 可以匹配连续出现 2 到 4 次的字符 “a”。
  • 边界匹配：
    • 正则表达式可以使用边界匹配符来限定匹配的范围。
    • 例如，用正则表达式 /^hello/ 可以匹配文本中以 “hello” 开头的字符串。
  • 贪婪匹配与非贪婪匹配：
    • 正则表达式中的量词默认为贪婪匹配，即会尽可能多地匹配字符，直到无法匹配为止。
    • 非贪婪匹配则相反，尽可能少地匹配字符。
    • 例如，在匹配字符串 “aaab” 时，正则表达式 /a+?/ 可以匹配 1 个字符 “a”，而正则表达式 /a+/ 则会匹配 3 个字符 “a”。
  • 分组匹配：
    • 正则表达式可以使用圆括号来表示分组，从而可以方便地对分组内的模式进行匹配和操作。
    • 例如，用正则表达式 /(\d{3})(\d{4})(\d{4})/ 可以匹配手机号码。
  • 转义字符：
    • 正则表达式中的特殊字符和元字符可以使用转义字符来表示其字面意义。
    • 例如，用正则表达式 /// 可以匹配斜杠字符。
• 总之，正则表达式是一种功能强大的文本匹配工具，可以使用各种元字符和模式匹配方式，实现文本提取和数据验证等常见工作，是编程和数据处理中不可缺少的工具之一。

14.re模块都有哪些功能及各⾃功能

• Python 中的 re（regular expression）模块是处理正则表达式的标准库，提供了多种匹配模式和操作方法，常用的功能包括：

  • re.match(pattern, string)：
    • 从字符串开头开始匹配，如果匹配成功则返回匹配对象，否则返回 None。
  • re.search(pattern, string)：
    • 在整个字符串中搜索匹配，返回第一个匹配对象，否则返回 None。
  • re.findall(pattern, string)：
    • 查找字符串中所有匹配项，并返回一个包含所有匹配子串的列表。
  • re.sub(pattern, repl, string)：
    • 将字符串中所有匹配正则表达式的子串用另一个字符串代替。
  • re.split(pattern, string)：
    • 使用正则表达式分割字符串并返回一个列表。
  • re.compile(pattern, flags)：
    • 预编译一个正则表达式，并返回一个正则表达式对象，可以用于多次匹配操作。

• 在 re 模块中，常用的标志有：

  • re.I：
    • 使匹配对大小写不敏感。
  • re.M：
    • 多行匹配。
  • re.S：
    • 允许 . 匹配任何字符，包括换行符。
  • re.A：
    • 使 \w、\W、\b、\B、\d、\D、\s 和 \S 只匹配 ASCII 字符。

• re 模块的各个方法的功能如下：

  • re.match(pattern, string, flags=0)：
    • 尝试从字符串的开头匹配一个模式，如果不是从开头就无法匹配成功。返回一个匹配对象，否则返回 None。
  • re.search(pattern, string, flags=0)：
    • 搜索整个字符串以找到匹配的模式。找到了，就返回一个匹配对象，否则返回 None。
  • re.findall(pattern, string, flags=0)：
    • 返回字符串中所有非重叠的匹配模式，返回一个包含所有匹配子串的列表。
  • re.split(pattern, string, maxsplit=0, flags=0)：
    • 按照匹配的模式分隔字符串。
  • re.sub(pattern, repl, string, count=0, flags=0)：
    • 用另一个字符串替换字符串中所有匹配的模式，返回字符串。
  • re.compile(pattern[, flags])：
    • 编译正则表达式返回一个正则表达式对象。

15.阐述使⽤正则表达式获取红⽜分公司数据的完整流程

• 获取红牛分公司数据的完整流程如下：

  • 确定需求和数据来源：
    • 首先需要明确需求，即需要哪些数据、从哪里获取数据。
    • 例如，在获取红牛分公司的数据时，需要明确需要获取哪些信息，
    • 例如公司名称、地址、联系方式等。数据来源可以是网站、API、文件或数据库等。
  • 分析数据结构和规律：
    • 需要通过抓包、浏览器开发工具或数据文件等方式，获取数据的结构和规律。
    • 例如，在获取红牛分公司数据时，需要了解数据来源网站的页面结构、数据请求接口和数据格式等。
  • 编写正则表达式：
    • 根据数据结构和规律，编写正则表达式来匹配需要的数据。
    • 例如，可以使用正则表达式来匹配公司名称、地址、联系方式等信息。
  • 测试正则表达式：
    • 需要对编写的正则表达式进行测试和调试，确保能够匹配到需要的数据。
  • 编写代码实现数据提取：
    • 根据需要，可以使用 Python 的 re 模块或其他库来实现正则表达式的匹配和数据提取。
    • 可以将提取的数据存储到文件或数据库中，或以其他方式进行处理和分析。
  • 最后，需要对编写的代码进行测试和验证，确保能够正确获取需要的数据。

• 总之，使用正则表达式获取红牛分公司数据的流程包括需求分析、数据结构分析、正则表达式编写、测试和实现等步骤，需要结合具体需求和数据特点进行调整和优化，以便能够顺利获取需要的数据。

16.阐述时间相关模块都有哪些及各⾃主要功能

• Python 中常用的时间相关模块有以下几个：

• time：

  • 该模块提供了访问与处理时间的一般函数，特别是提供了与 POSIX 系统相似的函数接口。
  • 主要功能：获取当前时间、休眠一定时间、计时器函数、时间转化函数等。

• datetime：

  • 该模块提供了一个 datetime 类，支持时区、可字序列化等功能，可以方便地进行日期和时间的计算和操作。
  • 主要功能：日期和时间计算、时间比较、日期和时间格式化、时区处理等。

• calendar：

  • 该模块提供了一组与日历相关的函数和类，可以用于获取某年、某月的日历和日期计算等。
  • 主要功能：生成日历、获取月份和年份的天数、获取某年某月的第一天和最后一天等。

• timeit：

  • 该模块提供了一个 Timer 类，用于测量代码执行时间，从而可以帮助实现更高效的代码。
  • 主要功能：测量函数和代码片段的执行时间、提供计时器类等。

• arrow：

  • 该第三方模块提供了一个易用的、功能丰富的时间处理库，可以支持常见的时间计算、日期比较、格式化等操作。
  • 主要功能：时间计算、日期比较、格式化、时区处理等。

• 总的来说，这些时间相关的模块都提供了各自独特的功能和特点，可以根据具体需求来选择适合的模块和方法进行处理。时间和日期的处理是程序中常见的操作，掌握这些模块的使用方式对于正确处理时间的关键数据是必不可少的。

17.默写能够产⽣任意位数随机验证码程序代码

# -*-coding: Utf-8 -*-
# @File : 异常捕获完整语法 .py
# author: Chimengmeng
# blog_url : https://www.cnblogs.com/dream-ze/
# Time：2023/6/10

import random


def get_random_code(n):
    # 随机生成数字
    number = str(random.randint(0, 9))
    # 随机生成大写字母
    code_Big = chr(random.randint(65, 90))
    # 随机生成小写字母
    code_Small = chr(random.randint(97, 122))
    # 随机字符串待选项
    choice = ['*', '/', '_', '\\', '&']
    # 随机字符串
    spical_code = random.choice(choice)
    # 初始化随机字符串
    random_code = ''
    # 循环拼接字符串
    for i in range(n):
        temp = random.choice([number, code_Big, code_Small, spical_code])
        random_code += temp

    return random_code


random_code = get_random_code(6)
print(random_code)
# 六位随机验证码
# yy&1I1

项目实战

详见git：https://gitee.com/chi-meng/weekly-testing-items/tree/master/Login_Register

需求

按照软件开发⽬录规范创建出完整⽬录
1.核⼼逻辑⽂件中编写⽤户注册登录功能 将校验⽤户是否存在,和数据保存写⼊common.py中独⽴成两个函数，核⼼逻辑调⽤上述功,能完成完整业务逻辑
2.common.py⽂件中编写⼀个可以统计函数运⾏时间的装饰器,给每个核⼼逻辑功能添加上统计时间功能
3.单⽤户单⽂件
4.添加查看全体⽤户数据功能,⽤户选择需要查看的⽤户数据后直接打印出该⽤户数据的全部信息
 (⾃由发挥 可以直接格式化美化输出)

分析业务需求

\- 用户注册功能
\- 校验用户是否存在
\- 数据存在不让注册
\- 数据不存在写入目标文件
\- 用户登录功能

\- 统计函数运行时间装饰器
\- 查看全体用户信息功能
\- 查看个人信息的功能