TypeError：退出最多需要1个参数，得到3

Question

我制作了一个Python脚本来比较文件（compareRFRegion）。我从Perl脚本调用此脚本：

$cmd_return = `python compareRFRegion.py -c Working/channels_US_full.ini -r RF_US902_full`;

但是我收到了这个错误：

Traceback (most recent call last):
  File "compareRFRegion.py", line 355, in <module>
    input_filename, rf_region_filename)
  File "compareRFRegion.py", line 88, in open_files
    "!!! Check it's in the current directory or the path is correct")
TypeError: exit expected at most 1 arguments, got 3

这是我的Python脚本：

#!/usr/bin/python

import os
import sys
import re
import getopt

# Channel list from .ini
channel_list = []

# Channel list from RF_region.xml
rf_channel_list = []

# lgw list
lgw_list = []
rf_region_list = []


class Channel:

    """attributes
    - index
    - LC
    - subband
    - freqhz
    - usedforrx2

    """

    def __init__(self):

        self.index = 0        # [channel:x]
        #
        self.LC = 0           # name=LCx
        self.subband = 0      # subband=x
        self.freqhz = 0       # freqhz=x
        self.usedforrx2 = 0   # usedforrx2=x
        self.bandwidth = 0    # bandwidth=x
        self.power = 0        # power=x

    def display_channel(self):

        print("Channel #{} - LC{} - Subband = {} - Freq = {} - UsedForRX2 = {} - Power = {}\n".format(self.index,
                                                                                                      self.LC,
                                                                                                      self.subband,
                                                                                                      self.freqhz,
                                                                                                      self.usedforrx2,
                                                                                                      self.power))

    def __eq__(self, channel):

        # if self.LC != channel.LC:
        #     print ("LC different : {} - {} ", self.LC, channel.LC)
        # if self.subband != channel.subband:
        #     print ("Subband different : {} - {} ", self.subband, channel.subband)
        # if self.freqhz != channel.freqhz:
        #     print ("FreqHz different : {} - {} ", self.freqhz, channel.freqhz)
        # if self.usedforrx2 != channel.usedforrx2:
        #     print ("Usedforrx2 different : {} - {} ", self.usedforrx2, channel.usedforrx2)
        # if self.power != channel.power:
        #     print ("Power different : {} - {} ", self.power, channel.power)

        return self.LC == channel.LC and self.subband == channel.subband and self.freqhz == channel.freqhz and self.usedforrx2 == channel.usedforrx2 and self.power == channel.power

    def __ne__(self, channel):
        return not self.__eq__(channel)


# File handling

def open_files(input_filename, rf_region_filename):

    input_file = None
    lgw_file = None

    if input_filename:
        try:
            input_file = open(input_filename, "r")
        except IOError:
            sys.exit("Could not open", input_filename,
                     "!!! Check it's in the current directory or the path is correct")

    try:
        rf_region_file = open(rf_region_filename, "r")
    except IOError:
        input_file.close()
        sys.exit("Could not open", rf_region_filename,
                 "!!! Check it's in the current directory or the path is correct")

    return input_file, rf_region_file


def close_files(input_file, rf_region_file):

    input_file.close()
    rf_region_file.close()


# Read script arguments


def read_param(argv):

    channel_filename = ''
    rf_region_filename = ''
    lgw_filename = ''

    try:
        opts, args = getopt.getopt(argv, "hc:l:r:")
    except getopt.GetoptError:
        print('compareRFRegion.py -c <channel_file> -r <RF_region_file>')
        print('compareRFRegion.py -l <lgw_file> -r <RF_region_file>')
        sys.exit(2)
    for opt, arg in opts:
        if opt == '-h':
            print('compareRFRegion.py -c <channel_file> -r <RF_region_file>')
            print('compareRFRegion.py -l <lgw_file> -r <RF_region_file>')
            sys.exit()
        elif opt in ("-c"):
            channel_filename = arg
        elif opt in ("-l"):
            lgw_filename = arg
        elif opt in ("-r"):
            rf_region_filename = arg
    # print('Channel file is "', channel_filename)
    # print('RF_region file is "', rf_region_filename)

    return channel_filename, lgw_filename, rf_region_filename

# process channel from RF_region.xml


def process_rf_channel(match, channel):

    global rf_channel_list

    if channel is not None:
        rf_channel_list.append(channel)

    channel = Channel()
    return channel


def process_rx2_LC(match, channel):

    global rf_channel_list

    if channel is not None:
        rf_channel_list.append(channel)

    channel = Channel()
    channel.LC = int(match.group(1))
    channel.usedforrx2 = 1
    return channel


def process_rf_freqhz(match, channel):

    channel.freqhz = int(float(match.group(1)) * 1000000)
    return channel


# process channel from channels.ini


def process_channel(match, channel):

    global channel_list
    # we store the previous channel in channel_list (except the first one)
    if channel is not None:
        channel_list.append(channel)

    channel = Channel()
    channel.index = int(match.group(1))
    return channel

# processes for all files


def process_LC(match, channel):

    channel.LC = int(match.group(1))
    return channel


def process_subband(match, channel):

    channel.subband = int(match.group(1))
    return channel


def process_freqhz(match, channel):

    channel.freqhz = int(match.group(1))
    return channel


def process_usedforrx2(match, channel):

    channel.usedforrx2 = int(match.group(1))
    return channel


def process_bandwidth(match, channel):

    channel.bandwidth = int(match.group(1))
    return channel


def process_power(match, channel):

    channel.power = int(match.group(1))
    return channel


# Read functions

def read_channels(channel_file):

    global channel_list

    actions = ((r"\[channel:(\d+)\]", process_channel),
               (r"name=LC((d)?.+)", process_LC),
               (r"subband=(\d+)", process_subband),
               (r"freqhz=(\d+\.\d+)", process_rf_freqhz),
               (r"usedforrx2=([0|1])", process_usedforrx2),
               (r"bandwidth=\$\{BW_(\d+)KHZ\}", process_bandwidth),
               (r"power=(\d+)", process_power))

    channel = None

    for line in channel_file:
        # print(line)
        for regex, action in actions:
            match = re.search(regex, line)
            if match:
                channel = action(match, channel)
                break

    # append the last channel in list
    if channel is not None:
        channel_list.append(channel)


def read_rf_region(rf_region_file):

    global rf_channel_list

    actions = ((r"<[RT]xChannel>", process_rf_channel),
               (r"<LC>(\d+)<\/LC>", process_LC),
               (r"<SB>(\d+)<\/SB>", process_subband),
               (r"<Frequency>(\d+\.\d+)<\/Frequency>", process_rf_freqhz),
               (r"<UsedForRX2>([0|1])<\/UsedForRX2>", process_usedforrx2),
               (r"<Bandwidth>(\d+)<\/Bandwidth>", process_bandwidth),
               (r"<RX2LC>(\d+)<\/RX2LC>", process_rx2_LC),
               (r"<RX2SB>(\d+)<\/RX2SB>", process_subband),
               (r"<RX2Freq>(\d+\.\d+)<\/RX2Freq>", process_rf_freqhz),
               (r"<RX2TxPower>(\d+)<\/RX2TxPower>", process_power))

    channel = None

    for line in rf_region_file:
        # print(line)
        for regex, action in actions:
            match = re.search(regex, line)
            if match:
                channel = action(match, channel)
                break

    # append the last channel in list
    if channel is not None:
        rf_channel_list.append(channel)


def read_rf_region_lgw(rf_region_file):

    global rf_region_list

    regexs = (r"<RFRegionId>(.+)<\/RFRegionId>",
              r"<LRR_power>(\d+)<\/LRR_power>")

    for line in rf_region_file:
        # print(line)
        for regex in regexs:
            match = re.search(regex, line)
            if match:
                rf_region_list.append(match.group(1))
                break


def read_lgw(lgw_file):

    regexs = (r"rfregionid=(.+)", r"power=(\d+)")

    global lgw_list

    for line in lgw_file:
        # print(line)
        for regex in regexs:
            match = re.search(regex, line)
            if match:
                lgw_list.append(match.group(1))
                break


# Compare functions

def compareChannels():

    for channel, rf_channel in zip(channel_list, rf_channel_list):
        if channel != rf_channel:
            # channel.display_channel()
            # rf_channel.display_channel()
            print(0)
            return

    print(1)


def compareLgw():

    for lgw_param, rf_region_param in zip(lgw_list, rf_region_list):
        if lgw_param != rf_region_param:
            # print(lgw_param)
            # print(rf_region_param)
            print(0)
            return

    print(1)

# def move_rx2_channel():

#     for i, channel in enumerate(rf_channel_list):
#         if channel.usedforrx2 == 1:
#             tmp = rf_channel_list.pop(i)
#             rf_channel_list.append(tmp)
#             return


#if __name__ == "__main__":

channel_filename, lgw_filename, rf_region_filename = read_param(sys.argv[
                                                                1:])
input_filename = ''
input_file = None
isChannelType = True

if channel_filename:
    input_filename = channel_filename
elif lgw_filename:
    input_filename = lgw_filename
    isChannelType = False

input_file, rf_region_file = open_files(
    input_filename, rf_region_filename)

# move_rx2_channel()

if isChannelType:
    read_rf_region(rf_region_file)
    read_channels(input_file)
    compareChannels()
else:
    read_rf_region_lgw(rf_region_file)
    read_lgw(input_file)
    compareLgw()

# print("List size is", len(channel_list))
# print("List rf size is", len(rf_channel_list))

# for channel, rf_channel in zip(channel_list, rf_channel_list):
#     channel.display_channel()
#     rf_channel.display_channel()

close_files(input_file, rf_region_file)

我可以通过添加if __name__ == "__main__":（在此处评论）在linux终端中独立执行此操作。它工作正常。但不是从Perl调用它。也许我从Perl调用Python脚本时缺少一些东西？

Answer 1

请参阅 - https://docs.python.org/3/library/sys.html#sys.exit 你对sys.exit()的3个args的调用是错误的，预计只有一个 - 退出代码（可选）

Answer 2

你用两个很多参数调用sys.exit（因为错误告诉你:)）

sys.exit("Could not open", input_filename,
                 "!!! Check it's in the current directory or the path is correct")

改为例如

print("Could not open", input_filename,
                 "!!! Check it's in the current directory or the path is correct")
sys.exit(1)

Answer 3

而不是

 sys.exit("Could not open", rf_region_filename,
             "!!! Check it's in the current directory or the path is correct")

尝试

sys.exit("Could not open" + rf_region_filename + \
             "!!! Check it's in the current directory or the path is correct")

在逗号中添加与print语句不同，并且不会将它们连接起来。相反，它将三个字符串视为3个不同的参数。添加添加符号将连接它们。

Answer 4

您需要阅读例外情况。它表示你用3个参数调用sys.exit()，但只允许1个。

阅读sys.exit([arg])

上的文档

以下是关于可选参数arg的说明：

  

可选参数arg可以是一个整数，给出退出状态（默认为零）或其他类型的对象。如果它是整数，则零被认为是“成功终止”，并且任何非零值被贝壳等视为“异常终止”。大多数系统要求它在0-127范围内，否则会产生不确定的结果。有些系统有一个约定，用于为特定的退出代码分配特定的含义，但这些通常是不发达的; Unix程序通常使用2表示命令行语法错误，1表示所有其他类型的错误。如果传递了另一种类型的对象，则None等效于传递零，并且任何其他对象将打印到stderr并导致退出代码为1.特别是sys.exit（＆＃34;一些错误消息＆＃34;）是发生错误时退出程序的快捷方法。

所以你需要重构你的代码，因为sys.exit只能获得一个参数。