我的 Python 代码中的缩进问题在哪里？

我修复了在您的代码中发现的缩进错误，对其进行了一些更改，并添加了一些注释注释："# NOTE: ..."

# == Necessary Imports =========================================================
import sys
import os

from bitstring import BitArray


# == Variables =================================================================
op = ""
rt = ""
rs = ""
imm = ""
ans = ""
shamt = ""
funct = ""
comm = ""
RegDst = ""
ALUSrc = ""
MemtoReg = ""
RegWrite = ""
MemRead = ""
MemWrite = ""
branch = ""
ALUOp1 = ""
ALUOp2 = ""
zeroBit = ""
oper = ""

# == Dictionaries ==============================================================
opDict = {"001000": "addi", "000000": {"100000": "add", "100010": "sub"}}
regValues = [0, 0, 0, 0, 0, 0, 0, 0]
regMap = {
    "00000": 0,
    "00001": 1,
    "00010": 2,
    "00011": 3,
    "00100": 4,
    "00101": 5,
    "00110": 6,
    "00111": 7,
}


# == Main Function =============================================================
def program(request, newFile, newFileTwo, count):
    splitInput(request, newFile)
    ans = (
        str(count)
        + "|"
        + str(regValues)
        .replace(",", "")
        .replace("[", "")
        .replace("]", "")
        .replace(" ", "|")
        + "\n"
    )
    newFileTwo.write(ans)


# == Utility Function ==========================================================
def splitInput(inn, file):
    op = inn[:6]
    if op == "000000":
        # R-Type
        rs = inn[6:11]
        rt = inn[11:16]
        rd = inn[16:21]
        # NOTE: `shamt` shadows the global variable `shamt`.
        shamt = inn[21:26]
        # NOTE: `funct` shadows the global variable `funct`.
        funct = inn[26:33].replace("\n", "")

        # Add / Sub
        if opDict["000000"][funct] == "add":
            decideCtrl("add", file)
            add(rs, rt, rd)
        elif opDict["000000"][funct] == "sub":
            decideCtrl("sub", file)
            sub(rd, rs, rt)

    elif op == "001000":
        # I-Type
        # NOTE: `rt` shadows the global variable `rt`.
        rt = inn[6:11]
        # NOTE: `rs` shadows the global variable `rs`.
        rs = inn[11:16]
        # NOTE: `imm` shadows the global variable `imm`.
        imm = inn[16:32]
        # NOTE: `ans` shadows the global variable `ans`.
        ans = BitArray(bin=imm).int
        decideCtrl("addi", file)
        addi(rt, rs, ans)


# Dedice on control signals
def decideCtrl(op, file):
    RegDst = "1"
    ALUSrc = "0"
    MemtoReg = "0"
    RegWrite = "1"
    MemRead = "0"
    MemWrite = "0"
    branch = "0"
    ALUOp1 = "1"
    ALUOp2 = "0"

    match op:
        case "add":
            # NOTE: `comm` seems to be unused.
            # NOTE: `comm` shadows the global variable `comm`.
            comm = "add"

        case "sub":
            # NOTE: `comm` seems to be unused.
            # NOTE: `comm` shadows the global variable `comm`.
            comm = "sub"

        case "addi":
            RegDst = "0"
            ALUSrc = "1"
            ALUOp1 = "0"
            # NOTE: `comm` seems to be unused.
            # NOTE: `comm` shadows the global variable `comm`.
            comm = "addi"

    file.write(RegDst + ALUSrc + MemtoReg + RegWrite + MemRead + MemWrite
               + branch + ALUOp1 + ALUOp2 + "\n")


# == Functions =================================================================
# NOTE: renamed the function parameters to avoid shadowing the global variables.x
def add(_rs, _rt, _rd):
    regValues[regMap[_rd]] = regValues[regMap[_rs]] + regValues[regMap[_rt]]


# NOTE: renamed the function parameters to avoid shadowing the global variables.x
def sub(_rd, _rs, _rt):
    regValues[regMap[_rd]] = regValues[regMap[_rs]] - regValues[regMap[_rt]]


# NOTE: renamed the function parameters to avoid shadowing the global variables.x
def addi(_rt, _rs, _imm):
    regValues[regMap[_rs]] = regValues[regMap[_rt]] + _imm


def main():

    PCount = 65536
    # NOTE: commented this line, because it's not being used anywhere.
    # QUESTION: where do you define the variable "filename"?
    # with open(filename, mode="r", encoding="utf-8") as file:
    #     storedLines = file.read().splitlines()

    ans = (
        str(regValues)
        .replace(",", "")
        .replace("[", "")
        .replace("]", "")
        .replace(" ", "|")
    )
    # NOTE: specified the `encoding` parameter, as it's a good practice.
    # NOTE: modified to `with open` as it's a good practice.
    with open("outputTwo.txt", mode = "w", encoding = "utf-8") as newFileTwo,\
        open("outputOne.txt", mode = "w", encoding = "utf-8") as newFile:
        newFileTwo.write(f"{PCount}|{ans}\n")

        # NOTE: creating some sample data for `F`, as I couldn't find it anywhere.
        F = [
            "0010000000000000000000000000000000",
            "0010000000000000000000000000000000",
            "0010000000000000000000000000000000",
            "0010000000000000000000000000000000",
            "0010000000000000000000000000000000",
            "0010000000000000000000000000000000",
            "0010000000000000000000000000000000",
            "0010000000000000000000000000000000",
            "0010000000000000000000000000000000",
            "0010000000000000000000000000000000",
        ]

        for count, comms in enumerate(F):
            if count == 100:
                # newFile.close()     # If you use `with open`, you dont't need to close the file.
                # newFileTwo.close()  # If you use `with open`, you dont't need to close the file.
                exit()
            PCount += 4
            program(comms, newFile, newFileTwo, PCount)


# Use open file to store the lines with their indicies
# When beq or bne compare and if:
# true -> grab label imm -> convert to decimal -> divide by 4 to get actual line

# Ad
# While `i` is less than the size of the lines array, iterate through it,
# and do the following logic:
#   storedLines[i] - line of a code in a file. Do logic to each [i]
# Add internal pc counter (`intpc=0`). By each iteration of `i`, `intpc` goes +4
# at the end  of while loop internalPC = 4
# i == internalPC // 4

# App Entry Point
if __name__ == "__main__":
    main()