+"""Test the speed of different kinds of for loops over lists of tuples.

+The general_test_function can be used to test the execution time of any number of functions.

+def test_speed_of_for_loop_with_tuples():

+ """Test the speed of two different for loops to see, if there's a difference.

+Result: There is no big difference between the two approaches.

+One run: [0.14503340959548949, 0.16319561004638672]

+Another run: [0.12981771707534789, 0.14054121494293212]

+Factor on another run: 1.1451155855

+That's about 14 percent longer execution time for the loop which selects the second item inside the loop.

+On 3 more runs, I got factors between 4% and 10%

+TODO: Test, if the factors are related to the numbers inside the tuples.

+TODO: Test, if a test with Strings comes to the same result.

+ # We need random numbers, so we can create unoptimizeable lists.

+ from random import random

+ # Now we need an empty list.

+ # Which we fill with 100.000 tuples of random numbers.

+ for i in range(100000):

+ many_tuples.append((random(), random()))

+ # Now we get to the real test.

+ # We just call the functions in our test function :)

+ # For this we first create a list of functions we want to test.

+ list_of_functions = [loop_which_directly_calls_each_tuple_item, loop_which_calls_the_whole_tuple_and_then_selects_the_second_item]

+ # And pass it to the general test function with our arg, 10 times.

+ # Results is a list of lists of tuples.

+ results.append(general_test_function(list_of_functions, many_tuples))

+ # Get the times of this result as list.

+ # Work on each function inside the single run to gets its time

+ # Append the time to the times_list.

+ times_list.append(j[0])

+ # Now add the times in the times list to the mean_time.

+ # If the times_list has a different length than the mean_time list, this should be the first run. We need to append the times.

+ if len(times_list) != len(mean_time):

+ # Else, this is a following run, so we can just add to each element.

+ for i in range(len(times_list)):

+ mean_time[i] += times_list[i]

+ # Now we divide each element inside the mean_time by the number of runs (the len of the results.

+ for i in range(len(mean_time)):

+ mean_time[i] = float(mean_time[i]) / len(results)

+ return mean_time # TODO: Calculate the standard deviation, so we know how certain the result is.

+def loop_which_directly_calls_each_tuple_item(many_tuples):

+ """Call each item directly in the loop and return a list of the second item.TODO: Test, if it makes a difference if we call the first or the second item"""

+ for i, j in many_tuples:

+def loop_which_calls_the_whole_tuple_and_then_selects_the_second_item(many_tuples):

+ """Call the whole tuple in the loop and then select the second item when assigning."""

+ second_items.append(i[1])

+def general_test_function(functions, *args):

+ """Compare the execution speed of different functions in the list of functions.

+@type functions: list of functions

+@param functions: [function1, function2, ...].

+@param args: The argument(s) to pass to each of the functions. All functions get all and the same argument(s)"""

+ # We need the current time in seconds

+ # First evaluate how long Python takes to get two times. We need to substract this value from the result to remove a constant offset.

+ # Get the current time two times

+ # Now calculate the difference which is how long Python takes for getting the time.

+ #: The offset due to getting the time two times. This is less than 1*10e-5 s for me.

+ time_offset = finish_time - start_time

+ # Get start and stop times of all functions and put them into a list of tuples: (time_needed, function) - time needed first, so we can sort easily.

+ #: A list of functions with execution speed

+ # Start time of the function.

+ # Execute the function with the given argument

+ time_needed = finish_time - start_time - time_offset

+ # append the tuple of execution time and function to the list of execution_speeds.

+ execution_times.append((time_needed, i))

+ # Return the list of execution times, sorted by functions.

+if __name__ == "__main__":

+ # Test the speed for loops with tuples.

+ print "10 Speedtests of for loops."

+ result = test_speed_of_for_loop_with_tuples()

+ # The factor can only be done this simply for testing two functions.

+ factor = result[1] / result[0]

+ print "Faktor:", factor

+ # Test mother sorting code.

+ # mothers = {"mother1": ["child1", "child2"], "mother2": ["child3"], "mother3": [], "mother4": [1, 2, 3]}

+ # print sort_by_children(mothers)