用python去除文本文件每行中‘<B>’与‘</B>’内容，并删除'<U>'与‘</U>’

可以使用Python的字符串操作和正则表达式来实现。

首先，我们需要打开文件并逐行读取文件内容。然后，使用正则表达式来去除每行中的'<B>'和'</B>'，以及'<U>'和'</U>'。最后，将处理后的内容写回到文件中。

以下是一个示例代码：

import re

# 打开文件并读取内容
with open('filename.txt', 'r') as f:
    lines = f.readlines()

# 处理每行的内容
for i in range(len(lines)):
    # 去除<B>和</B>
    lines[i] = re.sub(r'<B>|</B>', '', lines[i])
    # 去除<U>和</U>
    lines[i] = re.sub(r'<U>|</U>', '', lines[i])

# 将处理后的内容写回文件
with open('filename.txt', 'w') as f:
    f.writelines(lines)

在这个示例代码中，我们使用了Python的正则表达式库re来进行字符串的替换操作。其中，'|'表示或的意思，即同时匹配'<B>'和'</B>'或'<U>'和'</U>'。

相关问题

编写函数，从给定的输入文本文件中按行读入，并按行写入给定的输出文件中。要求：1）去除每行的前导空格或制表符。2）每行前加行号。

以下是一个Python函数，可以实现从输入文本文件中读取每一行，去除前导空格或制表符，并在每行前加上行号，然后将处理后的文本写入到输出文件中。

def process_file(input_file, output_file):
    with open(input_file, 'r') as f_in, open(output_file, 'w') as f_out:
        line_num = 1
        for line in f_in:
            stripped_line = line.lstrip() # 去除前导空格或制表符
            formatted_line = f"{line_num}: {stripped_line}" # 加上行号
            f_out.write(formatted_line)
            line_num += 1

其中，`input_file` 和 `output_file` 分别是输入文件和输出文件的文件路径。你可以根据实际情况修改这两个参数。

例如，如果你有一个输入文件 `input.txt`，里面的内容如下：

  Hello, world!
    This is a test file.
  Let's see if the function works.

那么，调用上述函数并将输入文件和输出文件路径传入，就可以将处理后的文本写入到输出文件中：

process_file('input.txt', 'output.txt')

执行完上述代码后，`output.txt` 的内容将如下：

1:Hello, world!
2:This is a test file.
3:Let's see if the function works.

每行的前导空格和制表符都被去除了，同时每行前加上了行号。可以使用以下 Python 代码实现该功能：

def add_line_number(input_file, output_file):
    with open(input_file, 'r') as f_in, open(output_file, 'w') as f_out:
        line_number = 1
        for line in f_in:
            line = line.lstrip()  # 去除前导空格或制表符
            line_with_number = f'{line_number:>4} {line}'  # 添加行号
            f_out.write(line_with_number)
            line_number += 1

使用方法：

- `input_file` 是输入文件名，需要读取其中的内容并按行写入输出文件。
- `output_file` 是输出文件名，每行开头需要添加行号后写入。

调用该函数即可完成指定的功能，例如：

add_line_number('input.txt', 'output.txt')

以上代码会读取 `input.txt` 文件中的每行内容，去除前导空格或制表符后，每行开头添加行号，再将其写入 `output.txt` 文件中。其中，行号使用四位数表示，例如第一行的行号为 `0001`，第二行的行号为 `0002`，以此类推。以下是一个Python函数，可实现从输入文本文件中读取每行文本，去除每行的前导空格或制表符，并在每行前加上行号，最后将处理后的结果写入给定的输出文件中：

def process_file(input_file, output_file):
    with open(input_file, 'r') as f_in, open(output_file, 'w') as f_out:
        line_num = 1
        for line in f_in:
            line = line.lstrip()
            f_out.write(f"{line_num}. {line}")
            line_num += 1

在这个函数中，`input_file` 是输入文件名，`output_file` 是输出文件名。函数使用了 Python 内置函数 `open()` 来打开文件，并指定文件模式为 `'r'` 或 `'w'`，分别表示只读和只写。使用 `with` 语句可以在代码块结束时自动关闭文件。

函数通过循环读取输入文件中的每一行，并对每行进行处理。使用 Python 字符串的 `lstrip()` 方法去除每行的前导空格或制表符。然后在每行前加上行号和一个点号，并将处理后的行写入输出文件中。最后，函数使用一个计数器 `line_num` 来跟踪当前行号，并在处理完每一行后将其加 1。以下是一个Python函数的示例，用于从输入文件读取内容并将处理后的内容写入输出文件中，同时去除每行的前导空格或制表符，以及在每行前添加行号。

def process_file(input_file, output_file):
    with open(input_file, 'r') as input_f, open(output_file, 'w') as output_f:
        line_num = 1
        for line in input_f:
            # 去除前导空格或制表符
            line = line.lstrip()
            # 添加行号
            line = f"{line_num}. {line}"
            # 写入输出文件
            output_f.write(line)
            # 更新行号
            line_num += 1

其中，`input_file` 和 `output_file` 分别为输入文件和输出文件的路径。该函数使用 `with` 语句来打开输入文件和输出文件，并对文件进行处理和写入。在循环中，对于每一行，使用 `lstrip()` 函数去除前导空格或制表符，并使用格式化字符串将行号添加到每行开头。最后，使用 `write()` 函数将处理后的行写入输出文件中，并更新行号以便处理下一行。
我可以提供一个Python函数，用于完成这个任务：def read_and_write(input_file, output_file):
line_num = 1
with open(input_file, 'r') as in_file, open(output_file, 'w') as out_file:
for line in in_file:
out_file.write(str(line_num) + ' ' + line.strip() + '\n')
line_num += 1read_and_write(input_file, output_file)下面是一个Python函数，可以实现从输入文本文件中读取每行，去除前导空格或制表符，加入行号后写入输出文件中：

def add_line_number(input_file, output_file):
    with open(input_file, 'r') as f_in, open(output_file, 'w') as f_out:
        line_number = 1
        for line in f_in:
            line = line.lstrip() # 去除前导空格或制表符
            f_out.write(f"{line_number}: {line}") # 每行前加行号
            line_number += 1

函数的输入是一个输入文件名和一个输出文件名。它使用Python的`open`函数打开两个文件，分别用于读取输入文件和写入输出文件。`line_number`变量用于存储当前行号，从1开始递增。函数使用`for`循环逐行读取输入文件，去除前导空格或制表符后，将行号和行内容一起写入输出文件中。在每一行的开头添加行号时，使用了f-string（格式化字符串），它可以很方便地将变量插入到字符串中。最后，函数会自动关闭输入文件和输出文件，无需手动关闭。以下是一个可以实现你要求的函数的示例代码，它会按照你提供的要求读取并写入文件：

def process_file(input_file_path, output_file_path):
    with open(input_file_path, 'r') as input_file, open(output_file_path, 'w') as output_file:
        line_number = 1
        for line in input_file:
            line = line.lstrip() # 去除行首空格或制表符
            output_file.write(f"{line_number}. {line}") # 写入带行号的新行
            line_number += 1

这个函数会打开你提供的输入和输出文件，并循环遍历输入文件的每一行。在处理每一行之前，它会使用 `lstrip()` 方法去除行首的空格或制表符。接着，它会将每一行写入输出文件，并在行首添加行号。最后，这个函数会关闭输入和输出文件。
答：
def readWrite(inFile, outFile):
with open(inFile, 'r') as f1, open(outFile, 'w') as f2:
for i, line in enumerate(f1):
line = line.lstrip()
f2.write(str(i + 1) + ' ' + line)

readWrite(inFile, outFile)下面是一个 Python 函数，它可以实现你所描述的要求：

def process_file(input_file, output_file):
    with open(input_file, 'r') as f_in, open(output_file, 'w') as f_out:
        line_num = 0
        for line in f_in:
            line_num += 1
            line = line.lstrip()  # 去除前导空格或制表符
            f_out.write(f"{line_num}: {line}")  # 加上行号并写入输出文件

你可以将需要处理的输入文件的路径和输出文件的路径作为参数传递给这个函数。例如：

process_file('input.txt', 'output.txt')

这将会读取名为 `input.txt` 的文件，并将处理后的结果写入名为 `output.txt` 的文件中。
可以写一个函数来实现这些要求：def read_write_file(input_file, output_file):
line_number = 0
with open(input_file, 'r') as f_in:
with open(output_file, 'w') as f_out:
for line in f_in:
line_number += 1
line_without_space = line.lstrip() # 去除每行的前导空格或制表符
line_with_number = str(line_number) + ' ' + line_without_space # 每行前加行号
f_out.write(line_with_number) # 将新的行写入到输出文件中以下是一个实现上述功能的Python函数，它接受两个参数，输入文件路径和输出文件路径：

def add_line_numbers(input_file, output_file):
    with open(input_file, 'r') as fin, open(output_file, 'w') as fout:
        line_number = 1
        for line in fin:
            line = line.lstrip()  # 去除前导空格或制表符
            fout.write(f"{line_number}: {line}")  # 写入带行号的行
            line_number += 1

使用示例：

add_line_numbers('input.txt', 'output.txt')

其中，'input.txt' 是输入文件的路径，'output.txt' 是输出文件的路径。注意，如果输出文件已存在，它将被覆盖。以下是一个Python函数，可以实现从输入文本文件中读取每行文本，并将每行文本写入输出文件中，并在每行前加上行号，同时去除每行的前导空格或制表符：

def add_line_number(input_file, output_file):
    with open(input_file, 'r') as f_in, open(output_file, 'w') as f_out:
        for i, line in enumerate(f_in, start=1):
            line = line.lstrip() # 去除前导空格或制表符
            f_out.write(f"{i:2d}. {line}") # 加入行号并写入输出文件

函数使用示例：

input_file = 'input.txt'  # 输入文件名
output_file = 'output.txt'  # 输出文件名
add_line_number(input_file, output_file)  # 调用函数

其中，`input_file` 是输入文件名，`output_file` 是输出文件名，需要根据实际情况修改。函数中使用了Python的文件读写操作，`open()` 函数用于打开文件，`with` 语句用于自动关闭文件。`enumerate()` 函数用于对输入文件中的每行文本进行编号，`start=1` 参数表示从1开始编号。`lstrip()` 函数用于去除每行的前导空格或制表符。最后，使用 `write()` 函数将加入行号的每行文本写入输出文件中。下面是一个 Python 的函数，实现了你所要求的功能：

def add_line_number(input_file_path, output_file_path):
    with open(input_file_path, 'r') as input_file, open(output_file_path, 'w') as output_file:
        line_number = 1
        for line in input_file:
            line = line.lstrip()  # 去除前导空格和制表符
            output_file.write(str(line_number) + ' ' + line)  # 添加行号并写入输出文件
            line_number += 1

这个函数接受两个参数：输入文件路径和输出文件路径。它会打开这两个文件，并逐行读取输入文件。对于每一行，它会首先去除前导空格和制表符（使用 `lstrip()` 方法）。然后它会在行号和内容之间添加一个空格，最后将行号和内容写入输出文件。在这个过程中，行号会逐行增加。以下是Python代码实现：

def add_line_number(input_file, output_file):
    with open(input_file, 'r', encoding='utf-8') as f_in:
        with open(output_file, 'w', encoding='utf-8') as f_out:
            line_number = 0
            for line in f_in:
                line_number += 1
                line = line.lstrip()  # 去除前导空格或制表符
                f_out.write(f"{line_number} {line}")

该函数接受两个参数：输入文件名和输出文件名。函数首先打开输入文件和输出文件，并使用 `with` 语句确保文件在处理完后自动关闭。然后，使用 `lstrip()` 方法去除每行的前导空格或制表符，并在每行前加上行号。最后，将处理后的行写入输出文件中。

注意，该函数假设输入文件的每行已经以换行符 `\n` 结尾。如果文件中的行不是以换行符结尾，可能会导致输出格式不正确。可以使用以下函数来实现读取输入文本文件，并按照要求写入输出文件：

def write_numbered_lines(input_file, output_file):
    with open(input_file, 'r') as f_in, open(output_file, 'w') as f_out:
        # 逐行读取输入文件
        for i, line in enumerate(f_in):
            # 去除每行的前导空格或制表符
            line = line.lstrip()
            # 每行前加行号
            f_out.write(f"{i+1}: {line}")

该函数使用了 Python 中的文件读写操作，逐行读取输入文件，并逐行写入输出文件。在读取每行时，使用 `lstrip()` 函数去除该行的前导空格或制表符，并使用 `enumerate()` 函数获得该行的行号，然后将行号和去除前导空格或制表符的内容一起写入输出文件中。以下是使用Python编写的函数，它可以从一个输入文本文件中读取内容，并将每行内容的行号和去除前导空格或制表符的文本写入给定的输出文件中：

def write_numbered_lines(input_file, output_file):
    with open(input_file, 'r') as f_in, open(output_file, 'w') as f_out:
        for i, line in enumerate(f_in, 1):
            line = line.lstrip()  # 去除前导空格或制表符
            f_out.write(f"{i}: {line}")

这个函数中，我们使用`with open`语句来打开输入和输出文件，这样可以确保在操作完成后自动关闭文件。然后，我们使用`enumerate`函数对每一行进行迭代，并记录行号。在每行前加上行号后，我们去除该行的前导空格或制表符，然后将它们写入输出文件中。注意，我们在写入文件时使用了字符串插值（f-string）来将行号和文本合并在一起。

调用这个函数的方法如下：

input_file = 'input.txt'
output_file = 'output.txt'
write_numbered_lines(input_file, output_file)

其中，`input.txt`是输入文件的文件名，`output.txt`是输出文件的文件名。你需要将它们替换为你自己的文件名。以下是一个Python编写的函数，可以实现将给定输入文本文件中的每一行去除前导空格或制表符，然后在每行前加上行号，并将结果写入给定的输出文件中。

def process_file(input_file, output_file):
    with open(input_file, 'r') as fin, open(output_file, 'w') as fout:
        for i, line in enumerate(fin, 1):
            stripped_line = line.lstrip()
            output_line = f"{i:03d}. {stripped_line}"
            fout.write(output_line)

这个函数的主要思路是使用Python内置的`open()`函数打开输入文件和输出文件，然后使用`enumerate()`函数对输入文件中的每一行进行迭代，并同时获取每一行的行号和行内容。在处理每一行时，我们使用`lstrip()`方法去除每行的前导空格或制表符，并使用格式化字符串（f-string）将行号和处理后的行内容组合起来。最后，将结果写入到输出文件中。

注意，`f"{i:03d}. {stripped_line}"`中的`{i:03d}`表示将行号`i`格式化为一个三位数的字符串，不足三位的左侧用零填充。例如，如果行号是1，那么格式化后的字符串就是"001"。下面是一个Python函数，可以按照要求从输入文件中逐行读取，并将结果写入输出文件中：

def process_file(input_file, output_file):
    with open(input_file, 'r') as fin, open(output_file, 'w') as fout:
        line_num = 1
        for line in fin:
            # 去除每行前导空格或制表符
            line = line.lstrip()
            # 添加行号并写入输出文件中
            fout.write(f"{line_num}. {line}")
            line_num += 1

使用方法：

1. 将上面的代码复制到Python文件中，保存为任意名称，例如`process.py`。

2. 在同一目录下创建输入文件，例如`input.txt`，将需要处理的文本内容逐行写入。

3. 在命令行中运行以下命令：

   python process.py input.txt output.txt

其中`output.txt`为输出文件名，可以自定义，如果文件不存在则会自动创建。

4. 执行完命令后，输出文件中将会按照行号和去除前导空格或制表符的方式输出每一行的内容。以下是一个Python编写的函数，可以实现从输入文本文件中逐行读取数据并按照指定格式写入到输出文件中：

def format_file(input_file, output_file):
    with open(input_file, 'r') as f1, open(output_file, 'w') as f2:
        line_num = 1
        for line in f1:
            line = line.lstrip()  # 去除每行的前导空格或制表符
            f2.write(f'{line_num}. {line}')  # 每行前加行号
            line_num += 1

使用时，可以调用该函数并传入输入文件和输出文件的文件名：

format_file('input.txt', 'output.txt')

其中，`input.txt`为输入文本文件的文件名，`output.txt`为输出文本文件的文件名。请根据实际情况进行修改。以下是一个可以实现该功能的Python函数，满足要求：

def add_line_numbers(input_file, output_file):
    with open(input_file, 'r') as f_in, open(output_file, 'w') as f_out:
        line_num = 1
        for line in f_in:
            line = line.lstrip()  # 去除前导空格或制表符
            f_out.write(f"{line_num}. {line}")
            line_num += 1

该函数使用了Python内置的文件操作函数 `open()` 打开了输入文件和输出文件，使用 `with` 语句来保证文件在使用完毕后被正确关闭。在循环中读入每一行文本后，使用 `lstrip()` 方法去除该行的前导空格或制表符，并使用字符串格式化的方法 `f"{line_num}. {line}"` 来在该行前加上行号和空格，最后写入到输出文件中。行号从1开始，每写入一行后自动加1。以下是一个实现上述要求的 Python 函数示例：

def add_line_numbers(input_file, output_file):
    with open(input_file, 'r') as f_in, open(output_file, 'w') as f_out:
        line_number = 1
        for line in f_in:
            line = line.lstrip()  # 去除前导空格或制表符
            f_out.write(f"{line_number}. {line}")
            line_number += 1

这个函数使用了 Python 的 `open` 函数来打开输入文件和输出文件，其中 `input_file` 和 `output_file` 分别是输入和输出文件的路径。在函数体内，我们使用了 `with` 语句来确保在文件操作完成后文件会被自动关闭。

接下来，我们使用一个循环来遍历输入文件的每一行。在每一行前，我们首先使用 `lstrip` 方法去除前导空格或制表符，然后使用 `write` 方法将带有行号的行写入输出文件。最后，我们更新行号变量 `line_number`，以便下一行可以使用正确的行号。

要使用这个函数，您只需要将输入文件路径和输出文件路径传递给它即可。例如，如果您的输入文件名为 `input.txt`，输出文件名为 `output.txt`，那么可以这样调用这个函数：

add_line_numbers('input.txt', 'output.txt')

调用完成后，输出文件中的每一行都会带有行号，并且不会包含前导空格或制表符。以下是一个Python函数，实现从给定的输入文件中读取每行文本，去除前导空格或制表符，并在每行前加上行号，然后将结果写入给定的输出文件中：

def add_line_number(input_file, output_file):
    with open(input_file, 'r') as f_in, open(output_file, 'w') as f_out:
        line_number = 0
        for line in f_in:
            line_number += 1
            line = line.lstrip()  # 去除前导空格或制表符
            f_out.write(f'{line_number}: {line}')

其中，`input_file`和`output_file`分别为输入文件和输出文件的文件路径。函数使用了Python的文件读写功能，使用`with open()`语句打开输入和输出文件，以确保在读写完成后自动关闭文件句柄。对于每一行输入文件中的文本，使用`lstrip()`方法去除前导空格或制表符，然后使用`write()`方法将行号和处理后的文本写入输出文件中。
编写函数：def readWrite(inputFile, outputFile):
with open(inputFile, 'r') as f_in, open(outputFile, 'w') as f_out:
for i, line in enumerate(f_in):
line = line.strip() # 去除每行的前导空格或制表符
f_out.write(str(i + 1) + ' ' + line + '\n') # 每行前加行号以下是一个Python的函数，可以实现从输入文本文件中按行读入，去除每行前导空格或制表符，加入行号后再按行写入到输出文件中：

def add_line_number(input_file, output_file):
    with open(input_file, 'r') as fin:
        lines = fin.readlines()

    with open(output_file, 'w') as fout:
        for i, line in enumerate(lines):
            line = line.lstrip()  # 去除前导空格或制表符
            fout.write(f"{i+1}. {line}")  # 加入行号并写入输出文件

这个函数使用了Python的文件读写操作，`open()`函数用于打开文件并返回文件对象，`readlines()`方法将文件内容按行读取为列表，`writelines()`方法将列表按行写入到输出文件中。函数中使用了`enumerate()`函数来遍历输入文件中的每一行，`lstrip()`方法用于去除每行的前导空格或制表符。

可以按照以下步骤编写函数，实现从输入文件读取并处理每行文本，将结以下是一个Python编写的函数，实现从输入文件中按行读取，并在输出文件中按行写入，并且在每一行前加入行号并去除每行的前导空格或制表符。

def add_line_numbers(input_file, output_file):
    with open(input_file, 'r') as f_in, open(output_file, 'w') as f_out:
        line_number = 0
        for line in f_in:
            line_number += 1
            line = line.lstrip()  # 去除前导空格或制表符
            f_out.write(f"{line_number}: {line}")

在这个函数中，我们使用了Python内置的`open()`函数来打开输入文件和输出文件。然后我们通过循环读取输入文件的每一行，并使用`lstrip()`方法去除前导空格或制表符。在每一行前加上行号，我们使用了Python中的格式化字符串（f-string）。

要使用这个函数，只需要传入输入文件名和输出文件名即可，如下所示：

add_line_numbers('input.txt', 'output.txt')

其中，`input.txt`是输入文件的文件名，`output.txt`是输出文件的文件名。以下是一个Python函数，可以从给定的输入文本文件中按行读取，并将每行前加上行号，并去除每行的前导空格或制表符，最后将结果写入给定的输出文件中：

def add_line_number(input_file, output_file):
    with open(input_file, 'r') as f_in, open(output_file, 'w') as f_out:
        # 逐行读取输入文件
        for line_num, line in enumerate(f_in, 1):
            # 去除前导空格或制表符
            line = line.lstrip()
            # 加上行号并写入输出文件
            f_out.write(f"{line_num}: {line}")

你可以将`input_file`和`output_file`替换为你需要的文件路径，然后调用这个函数即可。可以编写以下的 Python 函数，实现从输入文件中读取每一行，并在输出文件中写入行号和去除前导空格或制表符的文本行：

def add_line_numbers(input_file, output_file):
    with open(input_file, 'r') as f_in, open(output_file, 'w') as f_out:
        line_number = 1
        for line in f_in:
            line = line.lstrip()
            f_out.write(f'{line_number:4}  {line}')
            line_number += 1

其中，`input_file` 和 `output_file` 分别表示输入文件和输出文件的文件名，函数使用 `with` 语句打开文件，确保文件操作完成后自动关闭文件。

函数使用循环逐行读取输入文件的内容，对每行文本进行处理，使用字符串方法 `lstrip()` 去除前导空格或制表符，然后在每行前加上行号并写入输出文件。行号使用格式化字符串进行格式化，输出为四位数的数字，左侧补空格。

注意：如果输入文件中包含 Unicode 字符，需要使用适当的编码方式进行读写操作。函数中使用的是默认的编码方式，如果需要指定编码方式，请在打开文件时指定相应的编码。以下是一个可以实现您要求的 Python 函数：

def add_line_number(input_file, output_file):
    with open(input_file, 'r') as fin, open(output_file, 'w') as fout:
        for line_number, line in enumerate(fin, start=1):
            stripped_line = line.lstrip() # 去除每行前导空格或制表符
            output_line = f"{line_number}: {stripped_line}"
            fout.write(output_line)

该函数使用 `with` 语句打开输入文件和输出文件，然后使用 `enumerate` 函数对每行进行循环，并使用 `lstrip` 方法去除每行的前导空格或制表符。最后，将每行前加上行号并写入输出文件中。

您可以将函数保存到一个 Python 文件中，然后在命令行或其他 Python 脚本中导入并调用该函数，如下所示：

from your_module import add_line_number

input_file = 'input.txt'
output_file = 'output.txt'

add_line_number(input_file, output_file)

其中 `your_module` 是包含 `add_line_number` 函数的 Python 模块的名称，`input.txt` 是输入文件的路径，`output.txt` 是输出文件的路径。\u4e0b\u9762\u662f\u4e00\u4e2aPython\u4ee3\u7801\uff0c\u53ef\u4ee5\u5b8c\u6210\u4f60\u7684\u8981\u6c42\uff1a

def add_line_numbers(input_file, output_file):
    # 打开输入文件和输出文件
    with open(input_file, 'r', encoding='utf-8') as f_in, open(output_file, 'w', encoding='utf-8') as f_out:
        # 初始化行号为1
        line_num = 1
        # 逐行读取输入文件中的内容
        for line in f_in:
            # 去除行末的换行符
            line = line.rstrip('\n')
            # 如果行不为空，则添加行号和换行符
            if line:
                f_out.write('{:4d}: {}\n'.format(line_num, line))
                line_num += 1
            # 如果行为空，则只添加换行符
            else:
                f_out.write('\n')

\u4e0a\u9762\u7684\u4ee3\u7801\u4f7f\u7528Python\u8bed\u8a00\u7f16\u5199\uff0c\u8be5\u51fd\u6570\u540c\u65f6\u63d0\u4f9b\u4e86\u8f93\u5165\u6587\u4ef6\u540d\u548c\u8f93\u51fa\u6587\u4ef6\u540d\u3002

\u8fd9\u4e2a\u51fd\u6570\u901a\u8fc7\u5b8c\u6210\u4e86\u4f60\u7684\u8981\u6c42\uff1a

1. \u5c06\u8f93\u5165\u6587\u4ef6\u4e2d\u7684\u6bcf\u884c\u90fd\u8bfb\u53d6\u51fa\u6765\u3002
2. \u5982\u679c\u6bcf\u884c\u4e0d\u662f\u7a7a\u884c\uff0c\u5219\u5c06\u4e4b\u524d\u7684\u884c\u53f7\u8f6c\u6362\u6210\u5e26\u6709\u7a7a\u683c\u7684\u6587\u5b57\u7b26\u4e32\uff0c\u7136\u540e\u6dfb\u52a0\u539f\u6765\u7684\u5185\u5bb9\u548c\u8f6c\u6362\u540e\u7684\u884c\u53f7\u3002
3. \u5982\u679c\u6bcf\u884c\u662f\u7a7a\u884c\uff0c\u5219\u53ea\u9700\u8981\u5728\u8f93\u51fa\u6587\u4ef6\u4e2d\u6dfb\u52a0\u7a7a\u884c\u5c31\u53ef\u4ee5\u4e86\u3002

\u4f7f\u7528\u8fd9\u4e2a\u51fd\u6570\uff0c\u4f

以下是一个示例Python函数，它接受一个输入文件路径和一个输出文件路径作为参数，并删除每行的前导空格和制表符，并在每行前添加行号：

def add_line_numbers(input_file_path, output_file_path):
    with open(input_file_path, 'r') as input_file, open(output_file_path, 'w') as output_file:
        for line_number, line in enumerate(input_file, 1):
            line = line.lstrip()  # 去掉前导空格和制表符
            line = f"{line_number}. {line}"  # 添加行号
            output_file.write(line)

你可以调用这个函数并将你想要的输入文件路径和输出文件路径传递给它。例如，如果你的输入文件是名为“input.txt”的文件，输出文件名为“output.txt”，则可以像这样调用该函数：

add_line_numbers('input.txt', 'output.txt')

这将读取“input.txt”中的每一行，将其削减并添加行号，然后将其写入“output.txt”中。