Tip: Utilize the zip method:

>>> zip(l1, l2)
[('apple', 'banana'), ('carrot', 'date'), ('eggplant', 'fig')]

In relation to your solution: Python lists are not fixed-size arrays. You can simply add elements to the end:

def interleave_lists(list1, list2):
    # Assumes list1 and list2 have the same length 
    new_list = []

    for i in range(len(list1)):
        new_list.append(list1[i])
        new_list.append(list2[i])

    return new_list

>>> print interleave_lists(list("acegk"), list("bdfhj"))
['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'k', 'j']

The zip function is specifically designed to combine lists together. If you want to prioritize the second list over the first, simply switch the order of arguments.

However, this will result in a sequence of 2-tuples that needs to be flattened. The recommended approach for flattening is to utilize chain. (Avoid using sum as it is not only misleading but also significantly slower.)

Lastly, the output will be an iterable object, specifically an iterator, rather than a list. Therefore, conversion into a list is necessary:

def interleave_lists(x, y):
    return list(itertools.chain.from_iterable(zip(y, x)))

Using the itertools library in Python, you can merge two lists like this:

import itertools

list(itertools.chain(*zip(list1, list2)))
# Result: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']

Alternatively,

You can achieve the same result using itertools.chain.from_iterable with zip:

list(itertools.chain.from_iterable(zip(list1, list2)))
# Result: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']

Check out this inventive Python solution utilizing slice assignment with offset and step size to showcase some of the lesser-known features of the language. While a nested list comprehension or alternative solutions using zip may be more conventional, this approach is an interesting demonstration. It assumes that both lists are equal in length:

def combine_lists(list1, list2):
    result = [0] * len(list1) * 2 #create a list of the required size
    result[::2] = list2 #assign list2 to every second item in the result list
    result[1::2] = list1 #likewise but starting at index 1
    return result

Simple yet effective:

combine_lists(l1, l2)

Opting against using the sum() method in this scenario may lead to complications and inefficiencies, as indicated by comments. To circumvent these potential issues, consider implementing the following approach instead:

[element for sublist in zip(list_2, list_1) for element in sublist]

def intercalate_two_lists(list_one, list_two, start_index_one=0, start_index_two=1, fill_value=nan, increment=1, print_output=False):
    """
    Function to intercalate two lists: list_one and list_two into a new list result_list
    
        start_index_one and start_index_two are indices in result_list where intercalation of list_one or list_two will start.
        Increment is the number of empty elements filled with fill_value added to result_list at each iteration,
        such iteration can be empty if current index in result_list is lower than min(start_index_one, start_index_two).
        Intercalation in result_list starts at min(start_index_one, start_index_two) and the first element of the corresponding list is used.
        Intercalation of the list corresponding to max(start_index_one, start_index_two) starts once the iteration through result_list reaches the index max(start_index_one, start_index_two)
        if start_index_one>0 and start_index_two>0: result_list is appended with fill_value until iteration of result_list reaches min(start_index_one, start_index_two)
        if start_index_one == start_index_two: start_index_two is incremented by 1 (user should avoid this situation)
        start_index_one, start_index_two can be used to swap the order of integration of list_one and list_two, i.e. if start_index_two<start_index_one: list_two will be used first
    Parameters:
    list_one,list_two   (list)(list) lists to intercalate
    start_index_one,start_index_two   (int),(int) indices in result_list to start to intercalate list_one and list_two
    increment    (int) step of increment of result_list (spacing between list_one&list_two elements)
    fill_value     element to put in empty cells of result_list
    IF_PRINT (bool) Track assembly of result_list. Use only for short result_list lists otherwise be ready to saturate your screen with printed output
    
    Return:
    result_list
    """

    len_list_one = len(list_one)
    len_list_two = len(list_two)
    result = list()
    flag_one, flag_two = False, False
    done_one, done_two = False, False
    finish_one, finish_two = True, True
    if start_index_one == start_index_two: start_index_two += 1 # SAFEGUARD
    if increment == 0: increment=1 # SAFEGUARD
    counter, counter_one, counter_two = 0, 0 ,0
    while counter_one < len_list_one or counter_two < len_list_two:
        for x in range(increment):
            result.append(fill_value)
        if all([counter >= start_index_one, finish_one]): flag_one = True; done_one = True; finish_one = False; done_two=False
        elif all([counter >= start_index_two, finish_two]): flag_two = True; done_two = True; finish_two = False; done_one=False
        if print_output: print("beg:" + str(counter) + '\t' + str(counter_one) + '\t' + str(counter_two), done_one, done_two)
        if flag_one:
            if done_one:
                result[-1] = list_one[counter_one]
                counter_one += 1
                if flag_two:
                    if counter_two < len_list_two: done_one = False; done_two = True
                    if print_output: print("end:" + str(counter) + '\t' + str(counter_one) + '\t' + str(counter_two), done_one, done_two)
                    if counter_one == len_list_one: flag_one = False
                    counter += increment
                    if print_output: print(result,'___')
                    continue
        if flag_two:
            if done_two:
                result[-1] = list_two[counter_two]
                counter_two += 1
                if flag_one:
                    if counter_one < len_list_one: done_one=True; done_two = False
        if print_output: print("end:" + str(counter) + '\t' + str(counter_one) + '\t' + str(counter_two), done_one, done_two)
        if counter_one >= len_list_one: flag_one = False
        if counter_two >= len_list_two: flag_two = False
        counter += increment
        if print_output: print(result)
    return result

Application of intercalate_two_lists():

a = ["A", "B", "C", "D", "E", "F", "G"]
b = [1, 2, 3, 4]
# Use the default behavior
print("case1:", intercalate_two_lists(a[:4], b))
print("case2:", intercalate_two_lists(a, b))
print("case3:", intercalate_two_lists(b, a))
# Use advanced modes
print("case4:", intercalate_two_lists(a, b, start_index_one=4, start_index_two=2))
print("case5:", intercalate_two_lists(b, a, start_index_one=3, start_index_two=10, increment=3, print_output=0))
print("case6:", intercalate_two_lists(a[:4], b, start_index_one=2, increment=1, print_output=0))

Results of the above calls:

case1:['A', 1, 'B', 2, 'C', 3, 'D', 4]
case2:['A', 1, 'B', 2, 'C', 3, 'D', 4, 'E', 'F', 'G']
case3:[1, 'A', 2, 'B', 3, 'C', 4, 'D', 'E', 'F', 'G']
case4:[nan, nan, 1, 2, 'A', 3, 'B', 4, 'C', 'D', 'E', 'F', 'G']
case5:[nan, nan, nan, nan, nan, 1, nan, nan, 2, nan, nan, 3, nan, nan, 'A', nan, nan, 4, nan, nan, 'B', nan, nan, 'C', nan, nan, 'D', nan, nan, 'E', nan, nan, 'F', nan, nan, 'G']
case6:[nan, 1, 'A', 2, 'B', 3, 'C', 4, 'D']

Since most answers in this post handle only lists of equal sizes, here is an artistic method capable of handling lists of different sizes.