Commits

Anonymous committed 7c4aa6d

Added First speedtest of for loops.

Comments (0)

Files changed (1)

for_loops_geschwindigkeitstest.py

+#!/usr/bin/env python
+# encoding: utf-8
+
+"""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. 
+    many_tuples = []
+    # 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 = []
+    for i in range(10): 
+        results.append(general_test_function(list_of_functions, many_tuples))
+    
+    # Calculate the mean
+    mean_time = []
+    # Work on each result
+    for i in results: 
+        # Get the times of this result as list. 
+        times_list = []
+        # Work on each function inside the single run to gets its time
+        for j in i: 
+            # 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): 
+            for i in times_list: 
+                mean_time.append(i)
+        # Else, this is a following run, so we can just add to each element. 
+        else: 
+            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"""
+    second_items = []
+    for i, j in many_tuples: 
+        second_items.append(j)
+    return second_items
+
+
+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 = []
+    for i in many_tuples: 
+        second_items.append(i[1])
+    return second_items
+        
+
+
+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, ...].
+@type args: any
+@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
+    from time import time
+
+    # 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
+    start_time = time()
+    finish_time = time()
+    # 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
+    execution_times = []
+    for i in functions: 
+        # Start time of the function. 
+        start_time = time()
+        # Execute the function with the given argument
+        i(*args)
+        # Get the finish time
+        finish_time = time()
+        # Get the difference
+        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. 
+    return execution_times
+
+
+
+### Self-Test ###
+if __name__ == "__main__": 
+    # Test the speed for loops with tuples.
+    # 10 times. 
+    
+    print "10 Speedtests of for loops."
+
+    for i in range(10): 
+        result = test_speed_of_for_loop_with_tuples()
+        # print result
+        # 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)
+    # print mothers
+    
+    # Or just do nothing. 
+    pass