Additionally, make sure your code is well-documented with clear comments explaining what each section of the code does.

Original Answer:

# Define a function that takes in two or more lists as arguments and returns a list containing all elements that are present in both input lists but not in any other list passed as an argument to the function. If there are no common elements between the given lists, it will return an empty list.
def find_common(list1, *args):
    # Create a set from the first input list for faster lookups and removals.
    set_list1 = set(list1)
    
    # Initialize an empty list to hold common elements between all input lists.
    common_elements = []
    
    # Loop through each additional list passed as an argument.
    for other in args:
        # Create a set from the current input list for faster lookups and removals.
        set_other = set(other)
        
        # Find elements that are present in both sets (list1 and other).
        common = set_list1 & set_other
        
        # Loop through the common elements found.
        for elem in common:
            # Check if the element is not already in the final output list.
            if elem not in common_elements:
                # If not, append it to the final output list.
                common_elements.append(elem)
    
    # Return the final output list.
    return common_elements

Refined Answer:
In this refinement, we’ve added a docstring that explains what the function does and how to use it. We’ve also renamed the function “find_common” to “common_elements”. This is more descriptive of what the function returns a list containing common elements between all input lists.

The code itself remains largely unchanged, but we’ve added comments that explain each section in detail. The first comment explains how sets are used for faster lookups and removals. Sets are an efficient data structure for finding shared elements between two or more lists because they allow constant-time membership testing (O(1) time complexity).

The second comment initializes the empty list that will hold common elements between all input lists. This is done outside of any loops to ensure that it’s created only once, regardless of how many additional input lists are passed as arguments.

Finally, we loop through each additional input list and create a set from it for faster lookups and removals. We then find the common elements between this new set and the original set (list1). Any new common elements that aren’t already in our output list are appended to it.