How Can I Efficiently Collect Results from Repeated Calculations in Python?

Collecting the Results of Repeated Calculations

Problem Statement:

I need to collect the results of a calculation performed repeatedly for multiple values of x and use them afterward.

General Approaches

Using an Explicit Loop:

• Create a list or dictionary before the loop and append or associate results as they are calculated:

ys = []
for x in [1, 3, 5]:
    ys.append(x + 1)

ys = {}
x = 19
while x != 1:
    y = next_collatz(x)
    ys[x] = y
    x = y

Using a Comprehension or Generator Expression:

• List comprehension:

  xs = [1, 3, 5]
  ys = [x + 1 for x in xs]

  Copy after login

• Dictionary comprehension:

  ys = {x: x + 1 for x in xs}

  Copy after login

Using map:

• Map a function to a sequence and convert the result to a list:

  def calc_y(an_x):
    return an_x + 1
  xs = [1, 3, 5]
  ys = list(map(calc_y, xs))

  Copy after login

Specific Examples:

Collecting Results for a Fixed Sequence:

def make_list_with_inline_code_and_for():
    ys = []
    for x in [1, 3, 5]:
        ys.append(x + 1)
    return ys

def make_dict_with_function_and_while():
    x = 19
    ys = {}
    while x != 1:
        y = next_collatz(x)
        ys[x] = y # associate each key with the next number in the Collatz sequence.
        x = y # continue calculating the sequence.
    return ys

Managing Changing Data during a Loop:

Using a Generator Expression:

def collatz_from_19():
    def generate_collatz():
        nonlocal x
        yield x
        while x != 1:
            x = next_collatz(x)
            yield x
    x = 19
    return generate_collatz()

Using map:

def collatz_from_19_with_map():
    def next_collatz2(value):
        nonlocal x
        x = value
        return next_collatz(x)
    x = 19
    return map(next_collatz2, range(1))

The above is the detailed content of How Can I Efficiently Collect Results from Repeated Calculations in Python?. For more information, please follow other related articles on the PHP Chinese website!