在python中返回具有最唯一值的键的函数有问题_Python_Function_Dictionary_Key_Greedy

在python中返回具有最唯一值的键的函数有问题

python function dictionary

在python中返回具有最唯一值的键的函数有问题,python,function,dictionary,key,greedy,Python,Function,Dictionary,Key,Greedy,我正在尝试实现贪婪算法，在这里我需要找到具有最独特字母的字母表生成器，处理这些字母表并找到下一个最好的生成器，直到处理完所有字母表。但是，当我第一次运行函数get\u next\u best\u generator时，它返回正确的值，但在下一次调用中不返回任何内容，并出现以下错误- 0 [] 键错误：“” 第一次调用的输出-生成器_2 6. [p'，q'，k'，j'，l'，m'，n'，t'] 为什么在第一次呼叫后，它不在呼叫中返回任何内容这是我的密码- # create lists to st

我正在尝试实现贪婪算法，在这里我需要找到具有最独特字母的字母表生成器，处理这些字母表并找到下一个最好的生成器，直到处理完所有字母表。但是，当我第一次运行函数

get\u next\u best\u generator

时，它返回正确的值，但在下一次调用中不返回任何内容，并出现以下错误-

0
[]
键错误：“”

第一次调用的输出-

生成器_2
6.
[p'，q'，k'，j'，l'，m'，n'，t']

为什么在第一次呼叫后，它不在呼叫中返回任何内容

这是我的密码-

# create lists to store covered alphabets and processed generators
alphabets_covered=[]
generator_covered=[]
# create a dict to store generators and the alphabets that they generate
generator_alphabets_dict={'generator_1':['p','q','r'], 'generator_2':['p', 'q','k','j','l','m','n','t'],
                          'generator_3':['x','m'], 'generator_4':['p','e','m','g']}


def get_next_best_generator():
    '''get the generator that generates the most unique alphabets that have not been covered'''
    most_alphabets_count=0
    best_generator_alphabets=[]
    best_generator=''
    #Loop through the dict to find the generator with most unique alphabets
    for generator ,alphabets in generator_alphabets_dict.items():
        unique_alphabets_list = []
        generator_alphabets = list(alphabets)
        # Loop to store the unique alphabets for a generator
        for selected_alphabet in generator_alphabets:
            if selected_alphabet not in alphabets_covered:
                unique_alphabets_list.append(selected_alphabet)
                alphabets_covered.append(selected_alphabet)
        # update all values if current generator's unique element list is greater than its predecessor's       
        if len(unique_alphabets_list) > most_alphabets_count:
            most_alphabets_count = len(unique_alphabets_list)
            best_generator_alphabets = alphabets
            best_generator = generator

    return  most_alphabets_count, best_generator_alphabets , best_generator

# Loop until all alphabets have been covered
while len(alphabets_covered) < 13:


    most_alphabets_count, best_generator_alphabets, best_generator = get_next_best_generator()
    print(best_generator)
    print(most_alphabets_count)
    print(best_generator_alphabets)
    generator_alphabets_dict.pop(best_generator)
    generator_covered.append(best_generator)

预期产量- 发电机2 8. [p'，q'，k'，j'，l'，m'，n'，t'] 发电机3 3. ['x'，'w'，'b'] 发电机4 2. ['e'，'g'] 发电机1 1.

['r']

首先，如果脚本崩溃，请包含完整的堆栈跟踪

出现问题的原因是，在第二次传递函数时，if语句

if len（唯一字母表）>大多数字母表计数

从来都不是真的

原因是，在这个for循环中：

for selected_alphabet in generator_alphabets:
    if selected_alphabet not in alphabets_covered:
        unique_alphabets_list.append(selected_alphabet)
        alphabets_covered.append(selected_alphabet)

在这里，您可以写入

字母表\u covered

，在运行函数一次后，字母表将包含所有唯一的字母，因此第二次遍历if语句将永远不会为真。如果改为通过在函数内部定义变量来更改变量的范围，则仍然可以计算唯一值

最后，因为您不能再将

字母表\u covered

用作while语句限制器，所以将其更改为仅检查

生成器\u字母表\u dict

是否包含任何值

以下是更新的代码：

# create lists to store covered alphabets and processed generators
generator_covered = []
# create a dict to store generators and the alphabets that they generate
generator_alphabets_dict = {'generator_1': ['p', 'q', 'r'], 'generator_2': ['p', 'q', 'k', 'j', 'l', 'm', 'n', 't'],
                            'generator_3': ['x', 'm'], 'generator_4': ['p', 'e', 'm', 'g']}


def get_next_best_generator():
    '''get the generator that generates the most unique alphabets that have not been covered'''
    most_alphabets_count = 0
    best_generator_alphabets = []
    best_generator = ''
    alphabets_covered = [] # Moved into the function.

    #Loop through the dict to find the generator with most unique alphabets
    for generator, alphabets in generator_alphabets_dict.items():
        unique_alphabets_list = []
        generator_alphabets = list(alphabets)
        # Loop to store the unique alphabets for a generator
        for selected_alphabet in generator_alphabets:
            if selected_alphabet not in alphabets_covered:
                unique_alphabets_list.append(selected_alphabet)
                alphabets_covered.append(selected_alphabet)
        # update all values if current generator's unique element list is greater than its predecessor's
        if len(unique_alphabets_list) > most_alphabets_count:
            most_alphabets_count = len(unique_alphabets_list)
            best_generator_alphabets = alphabets
            best_generator = generator

    return most_alphabets_count, best_generator_alphabets, best_generator


# Loop until all alphabets have been covered
# the boolean value of an empty dictionary is False, so we can limit it on that.
while generator_alphabets_dict: 
    most_alphabets_count, best_generator_alphabets, best_generator = get_next_best_generator()
    print(best_generator)
    print(most_alphabets_count)
    print(best_generator_alphabets)
    generator_alphabets_dict.pop(best_generator)
    generator_covered.append(best_generator)

我没有向您的函数添加任何逻辑，查看它的输出，我们可以看到

生成器按以下顺序输出：
generator_2
generator_1
generator_4
generator_3

然而，这不是我要做的顺序，因为generator_4
比generator_1
有更多的字符，因此在我看来应该更“独特”
考虑到这一点，我简化了您的代码，以返回更“独特”的顺序：
输出：
Key: generator_2, Value: ['p', 'q', 'k', 'j', 'l', 'm', 'n', 't']
Key: generator_4, Value: ['p', 'e', 'm', 'g']
Key: generator_1, Value: ['p', 'q', 'r']
Key: generator_3, Value: ['x', 'm']

首先，如果脚本崩溃，请包含完整的堆栈跟踪
出现问题的原因是，在第二次传递函数时，if语句if len（唯一字母表）>大多数字母表计数
从来都不是真的
原因是，在这个for循环中：
for selected_alphabet in generator_alphabets:
    if selected_alphabet not in alphabets_covered:
        unique_alphabets_list.append(selected_alphabet)
        alphabets_covered.append(selected_alphabet)

在这里，您可以写入字母表\u covered
，在运行函数一次后，字母表将包含所有唯一的字母，因此第二次遍历if语句将永远不会为真。如果改为通过在函数内部定义变量来更改变量的范围，则仍然可以计算唯一值
最后，因为您不能再将字母表\u covered
用作while语句限制器，所以将其更改为仅检查生成器\u字母表\u dict
是否包含任何值
以下是更新的代码：
# create lists to store covered alphabets and processed generators
generator_covered = []
# create a dict to store generators and the alphabets that they generate
generator_alphabets_dict = {'generator_1': ['p', 'q', 'r'], 'generator_2': ['p', 'q', 'k', 'j', 'l', 'm', 'n', 't'],
                            'generator_3': ['x', 'm'], 'generator_4': ['p', 'e', 'm', 'g']}


def get_next_best_generator():
    '''get the generator that generates the most unique alphabets that have not been covered'''
    most_alphabets_count = 0
    best_generator_alphabets = []
    best_generator = ''
    alphabets_covered = [] # Moved into the function.

    #Loop through the dict to find the generator with most unique alphabets
    for generator, alphabets in generator_alphabets_dict.items():
        unique_alphabets_list = []
        generator_alphabets = list(alphabets)
        # Loop to store the unique alphabets for a generator
        for selected_alphabet in generator_alphabets:
            if selected_alphabet not in alphabets_covered:
                unique_alphabets_list.append(selected_alphabet)
                alphabets_covered.append(selected_alphabet)
        # update all values if current generator's unique element list is greater than its predecessor's
        if len(unique_alphabets_list) > most_alphabets_count:
            most_alphabets_count = len(unique_alphabets_list)
            best_generator_alphabets = alphabets
            best_generator = generator

    return most_alphabets_count, best_generator_alphabets, best_generator


# Loop until all alphabets have been covered
# the boolean value of an empty dictionary is False, so we can limit it on that.
while generator_alphabets_dict: 
    most_alphabets_count, best_generator_alphabets, best_generator = get_next_best_generator()
    print(best_generator)
    print(most_alphabets_count)
    print(best_generator_alphabets)
    generator_alphabets_dict.pop(best_generator)
    generator_covered.append(best_generator)


我没有向您的函数添加任何逻辑，查看它的输出，我们可以看到生成器按以下顺序输出：
generator_2
generator_1
generator_4
generator_3

然而，这不是我要做的顺序，因为generator_4
比generator_1
有更多的字符，因此在我看来应该更“独特”
考虑到这一点，我简化了您的代码，以返回更“独特”的顺序：
输出：
Key: generator_2, Value: ['p', 'q', 'k', 'j', 'l', 'm', 'n', 't']
Key: generator_4, Value: ['p', 'e', 'm', 'g']
Key: generator_1, Value: ['p', 'q', 'r']
Key: generator_3, Value: ['x', 'm']

您的大多数错误似乎归结为局部变量和全局变量范围的混乱。例如，在函数get\u next\u best\u generator（）
中，您已将变量best\u generator
定义为一个值为“”的字符串。然后尝试使用操作best\u generator=generator
为字符串重新赋值。这是抛出一个错误。因此，这需要是全局性的，或者您需要重新考虑返回数据的格式。例如，您可以在列表中存储变量most\u alphabets\u count
、best\u generator\u alphabets
和best\u generator
。然后在返回时对其进行迭代，如果值是从上次检查中更新的，则分配这些值。下面是一个基于您的代码的示例：
# create lists to store covered alphabets and processed generators
alphabets_covered=[]
generator_covered=[]
# create a dict to store generators and the alphabets that they generate
generator_alphabets_dict={
    'generator_1':['p','q','r'],
    'generator_2':['p','q','k','j','l','m','n','t'],
    'generator_3':['x','m'],
    'generator_4':['p','e','m','g']
    }


def get_next_best_generator():
    '''get the generator that generates the most unique alphabets that have not been covered'''
    most_alphabets_count=0
    best_generator_alphabets=[]
    value_list = []
    print(generator_alphabets_dict)
    #Loop through the dict to find the generator with most unique alphabets
    for generator ,alphabets in generator_alphabets_dict.items():
        unique_alphabets_list = []
        for select_alphabet in alphabets:
            if select_alphabet not in alphabets_covered:
                unique_alphabets_list.append(select_alphabet)
                alphabets_covered.append(select_alphabet)
        # update all values if current generator's unique element list is greater than its predecessor's       
        if len(unique_alphabets_list) > most_alphabets_count:
            value_list.append(len(unique_alphabets_list))
            value_list.append(alphabets)
            value_list.append(generator)  
    return value_list

# Loop until all alphabets have been covered
def mainloop():
    counter = 0
    while len(alphabets_covered) < 13 and len(generator_alphabets_dict.keys()) > 0 and counter < 10:
        counter += 1
        print(f'Loop counter: {counter}')
        try:
            my_values = get_next_best_generator()
            most_alphabets_count = my_values[0] 
            best_generator_alphabets = my_values[1] 
            best_generator = my_values[2] 
        except Exception as e:
            print(f'Error in assigning variables values to most_alphabets_count, best_generator_alphabets, best_generator: {e}')

        print(f'best_generator: {best_generator}')
        print(f'most_alphabets_count: {most_alphabets_count}')
        print(f'best_generator_alphabets: {best_generator_alphabets}')
        try:
            if best_generator in generator_alphabets_dict.keys():
                generator_alphabets_dict.pop((best_generator))
                generator_covered.append(best_generator)
            else:
                print(f'key not found in dict')
        except Exception as e:
            print(f"ERROR: {e}\n")
        else:
            print('process complete with no errors\n')
        finally:
            print('process complete')


def print_dict(my_dict):
    for k, v in my_dict.items:
        print(f'Current values in dict:\n')
        print(f'key:{k}')
        print(f'value:{v}')

if __name__ == '__main__':
    mainloop()

#创建列表以存储覆盖的字母表和已处理的生成器
字母表_covered=[]
发电机_包括=[]
#创建一个dict来存储生成器及其生成的字母表
发电机字母表={
'生成器_1'：['p'，'q'，'r']，
‘生成器_2’：[‘p’、‘q’、‘k’、‘j’、‘l’、‘m’、‘n’、‘t’]，
'生成器_3'：['x'，'m']，
'生成器_4'：['p'，'e'，'m'，'g']
}
def get_next_best_生成器（）：
''获取生成尚未涵盖的最独特字母的生成器''
大多数字母\u计数=0
最佳字母生成器字母表=[]
值_列表=[]
打印（生成器字母表）
#在dict中循环查找具有最独特字母表的生成器
对于generator，generator_alphabets_dict.items（）中的字母表：
唯一字母列表=[]
对于“选择字母表中的字母表”：
如果选择字母表中未包含的字母表：
唯一字母列表。附加（选择字母）
字母表。附加（选择字母表）
#如果当前生成器的唯一元素列表大于其前身的唯一元素列表，则更新所有值
如果len（唯一字母列表）>大多数字母计数：
值列表。追加（len（唯一字母列表））
值列表。附加（字母表）
值\u列表。追加（生成器）
返回值列表
#循环直到所有字母都被覆盖
def mainloop（）：
计数器=0
而len（字母表）小于13，len（生成器字母表）大于0，计数器小于10：
计数器+=1
打印（f'循环计数器：{cou