如何在Python中迭代函数的输出

Question

我正在尝试根据数字序列计算该值，并找出该值与随机生成的数字序列相比如何。要计算序列的值，我有 random_lineup_value 函数，它工作正常。要随机生成 1000 个序列并计算每个序列的值，我有 random_lineup_values 函数。

但是，问题是我无法将原始值与这些随机生成的值进行比较，因为函数的输出不可下标——或者我无法引用此输出中的特定位置。我正在尝试遍历 random_lineup_values 的有序输出，直到初始存储值等于存储在 1000 个值列表中的数字。我尝试将 random_lineup_value 的输出作为列表返回，在函数中使用 yield 而不是 return，并在调用函数时将输出分配给变量，然后尝试遍历存储在新变量，但这些方法都不适用于 Python。知道如何在 Python 中执行此操作吗？

    import random
    
    def lineup_value(order): 
         value = 0 
         for i in range(0,6): 
             if order[i] >= order[8]: 
                 value = value + 4 
             if order[i] >= order[7]: 
                 value = value + 4 
         for i in range(0,5): 
             if order[i] >= order[6]: 
                 value = value + 4 
         for i in [0, 1, 3]: 
             if order[i] >= order[5]: 
                 value = value + 4 
             if order[i] >= order[4]: 
                 value = value + 4 
         if order[3] >= order[2]: 
             value = value + 4 
         if order[1] >= order[2]: 
             value = value + 4 
         return value
    
    def random_lineup_values(order): 
        bootstrapped_values = [] 
        for j in range(0, 1000): 
            random.shuffle(order)                     
            bootstrapped_values.append(lineup_value(order)) 
        return list(bootstrapped_values.sort)
    
    random.seed(10)
    
    batting_order = [115, 101, 76, 125, 120, 135, 88, 94, 97]
    
    value = lineup_value(batting_order) 
    print(str(value) + ' is the value of the lineup') 
    sorted1 = random_lineup_values(batting_order) 
    print(sorted1)
        
    p = 0 
    number = sorted1[p] 
    while int(number) < int(value): 
        p = p + 1 print(p) 
    print(str((1000 - p) / 10) + ' percent of random lineup values would be better than the lineup')
    

Answer 1

错误在这里：

x  = list(bootstrapped_values.sort)

通过删除 .sort 它可以工作。

x  = list(bootstrapped_values)

这里是函数

def random_lineup_values(order): 
    bootstrapped_values = [] 
    for j in range(0, 1000): 
        random.shuffle(order) 
        bootstrapped_values.append(lineup_value(order)) 
        x  = list(bootstrapped_values) # <==  Exception has occurred: TypeError 'builtin_function_or_method' object is not iterable
    return x

错误是这样的： Exception has occurred: TypeError 'builtin_function_or_method' object is not iterable

Answer 2

我怀疑您遇到的问题是您只是对分数进行排序和跟踪，而不是生成它们的 order 列表。如果你把这两个东西放在同一个地方，你可以做你想做的事。 （@D.L 的回答还解决了一个更明显的问题，但我怀疑这个问题是由我正在解决的更大问题的尝试解决方案引起的。）

试试这个，它构建和排序(score, order) 2-tuples 的列表。

def random_lineup_values(order): 
    bootstrapped_values = [] 
    for j in range(0, 1000): 
        random.shuffle(order)                     
        bootstrapped_values.append(lineup_value(order), order.copy())
    bootstrapped_values.sort()
    return bootstrapped_values

请注意，我在元组中添加了order 列表中的copy()，因为建立新订单的改组发生在适当的位置。这也可能意味着您还想在函数开始时复制原始阵容，因此您不会破坏作为参数传递的列表的顺序（但我不完全理解调用代码，所以我不确定你是否关心它）。

Answer 3

我最初没有理解您的问题，但根据您的代码，我猜您想通过确定该订单“价值”的函数运行一个包含击球顺序的列表，并将其与随机生成的 1000 个进行比较不同顺序的值。我做了一些细微的调整，现在它完成了我相信你想要完成的事情。

import random
    
def lineup_value(order): 
     value = 0 
     for i in range(0,6): 
         if order[i] >= order[8]: 
             value = value + 4 
         if order[i] >= order[7]: 
             value = value + 4 
     for i in range(0,5): 
         if order[i] >= order[6]: 
             value = value + 4 
     for i in [0, 1, 3]: 
         if order[i] >= order[5]: 
             value = value + 4 
         if order[i] >= order[4]: 
             value = value + 4 
     if order[3] >= order[2]: 
         value = value + 4 
     if order[1] >= order[2]: 
         value = value + 4 
     return value

def random_lineup_values(order, value): 
    bootstrapped_values = [] 
    newBootStrapped_values = []
    for j in range(0, 1000): 
        random.shuffle(order)                     
        bootstrapped_values.append(lineup_value(order))
    for j in range(0, 1000):
        if(bootstrapped_values[j] > value):
            newBootStrapped_values.append(bootstrapped_values[j])
            
    return list(sorted(newBootStrapped_values))

random.seed(10)

batting_order = [115, 101, 76, 125, 120, 135, 88, 94, 97]

value = lineup_value(batting_order) 
print(str(value) + ' is the value of the original lineup') 

sorted1 = random_lineup_values(batting_order, value)
print(str(len(sorted1)) + ' is the number of better value lineups out of 1000')
    
print(str(len(sorted1) / 10) + ' percent of random lineup values would be better than the lineup')

您会注意到我所做的最大调整是在您的 random_lineup_values 函数中添加了一个额外的 for 循环。第一个 for 循环获取 1000 个随机订单的值。第二个 for 循环获取所有大于原始订单值（应该是您提供的数组中的 68）的值，并将它们附加到新列表中。该列表中的元素数量为 1000 乘以 100（为简化，排序为 1/10）将为您提供更好的击球顺序的百分比。我没有更改任何获取击球顺序值的逻辑，所以如果那里有问题，那将与 lineup_value 函数的逻辑有关，但据我所知，它运行正常。运行此代码后得到的输出是：

68 is the value of the original lineup
113 is the number of better value lineups out of 1000
11.3 percent of random lineup values would be better than the original lineup