理解列表与for循环的复杂性

Question

I have two algorithms in Python, which convert a tuple list into a dictionary:

  def _prep_high_low_data_for_view(self, low_high_list):
    dates = []
    prices = []
    lables = []
    for (x, y, z) in low_high_list:
        dates.append(x)
        prices.append(y)
        lables.append(z)

    return {'date': dates,
            'price': prices,
            'label': lables
            }

The second one being:

    def _prep_high_low_data_for_view(self, low_high_list):
    return {'date': [date for date, _, _ in low_high_list],
            'price': [price for _, price, _ in low_high_list],
            'label': [lable for _, _, lable in low_high_list],
            }

Both algorithms are equivalent in terms of what they do. Is it the case that the second algorithm is worse in terms of complexity, because there are three separate list comprehensions?

Answer 1

You could build the 3 lists using zip:

dates,prices,labels = zip(*low_high_list)

placed in a one line function:

def third_function(low_high_list):
    return dict.fromkeys(zip(["date","price","label"],zip(*low_high_list)))

it will run faster, on average, than second_function() from Florian_H.

TESTS AND RESULTS:

def third_function(low_high_list):
    return dict.fromkeys(zip(["date","price","label"],zip(*low_high_list)))

def fourth_function(low_high_list):
    dates,prices,labels = zip(*low_high_list)
    return { "date":dates, "price":prices, "label":labels }


lst = [tuple(random.randint(0,100) for _ in range(3)) for i in range(10000)]

from timeit import timeit
count = 1000

t0 = timeit(lambda:first_function(lst), number=count)
print("first_function: ",f"{t0:.3f}","1x" )

t = timeit(lambda:second_function(lst), number=count)
print("second_function:",f"{t:.3f}",f"{t0/t:.1f}x" )

t = timeit(lambda:third_function(lst), number=count)
print("third_function: ",f"{t:.3f}",f"{t0/t:.1f}x" )

t = timeit(lambda:fourth_function(lst), number=count)
print("fourth_function:",f"{t:.3f}",f"{t0/t:.1f}x" )

# first_function:  1.338 1x
# second_function: 0.818 1.6x
# third_function:  0.426 3.1x
# fourth_function: 0.375 3.6x

Answer 2

Yes and no.

It's basically O(n) vs O(3n) , but when working with complexities, O(3n) is just shortened to O(n) .

So yeah, both of these are algorithms with the complexity of O(n) , but the first one does three times less operations.

Answer 3

As Markust Meskanen mentioned the first algorithm should be 3 times faster (less complex) but why not just trying it? Here your code with random values and a time measuring.

import random, datetime

def first_function(low_high_list):
    dates = []
    prices = []
    lables = []
    for (x, y, z) in low_high_list:
        dates.append(x)
        prices.append(y)
        lables.append(z)

    return {'date': dates,
            'price': prices,
            'label': lables
            }


def second_function(low_high_list):
    return {'date': [date[0] for date in low_high_list],
            'price': [price[1] for price in low_high_list],
            'label': [label[2] for label in low_high_list],
            }


def second_function(low_high_list):
    return {'date': [date[0] for date in low_high_list],
            'price': [price[1] for price in low_high_list],
            'label': [label[2] for label in low_high_list],
            }


lst = [[random.randint(0,100),random.randint(0,100),random.randint(0,100)] for i in range(10000)]

print("first_function:")
tmp = datetime.datetime.now()
first_function(lst)
print(datetime.datetime.now() - tmp)

print("\nsecond_function:")
tmp = datetime.datetime.now()
second_function(lst)
print(datetime.datetime.now() - tmp)

And voila, the second function is two times faster than the first...

[output]
first_function:
0:00:00.004001

second_function:
0:00:00.002001

So it seems, even though the second function runs three times instead of one, in this case list comprehension is still twice as fast as looping with appending to a list.

1000 times average is still roughly twice as fast:

0:00:00.002820
0:00:00.001568