Apply additions on a base array based on date ranges
To preface, PEP8 recommends 4 spaces instead of 2 spaces for indentation, so I've written all below code as such.

There is a subtle bug in your program (and may be nonexistent at all, the requirements are ambiguous here), but:

if elem['date'] &lt; mod_arr[mod_index]['date']:
    elem['value'] += mod_arr[mod_index]['value']
else:
    elem['value'] += mod_arr[mod_index + 1]['value']
    mod_index += 1


assumes that mod_array[mod_index + 1]["date"] &gt; mod_array[mod_index]["date"], though your requirements never say that "date" is strictly increasing (and mod_array being sorted doesn't imply this).

We can handle this by changing the if / else to a while:

while elem['date'] &gt;= mod_arr[mod_index]['date']:
    mod_index += 1

elem['value'] += mod_arr[mod_index]['value']


Note that this also increments mod_index before the mutation of elem["value"], allowing us to de-duplicate its mutation. 

Since we are only moving forward in mod_arr, we actually don't need mod_index at all. We can do mod_array_iter = iter(mod_array), and replace mod_index += 1 with mod = next(mod_array_iter). This also helps us avoid any off-by-one errors.

Another benefit of using iter here is it opens up an easy way to exit the function if mod_array is empty (implying no mutations to base_arr should be done, the original program didn't account for this) or if we've traversed through all of mod_array_iter (implying necessary mutations to base_arr have been done, original program accounted for this with the if and inner break). We can use a try / except for both of those cases, and get rid of the initial if with inner break.

Final code ends up looking like (wrapped is a function for reusability):

def mutate_base_arr(base_arr, mod_arr):
    mod_arr_iter = iter(mod_arr)

    try:
        mod = next(mod_arr_iter)

        for elem in base_arr:
            while elem['date'] &gt;= mod['date']:
                mod = next(mod_arr_iter)

            elem['value'] += mod['value']
    except StopIteration:
        return


If you really wanted to take this a step further, you could get rid of the while and duplicate nexts by using itertools, yielding this version of the function:

def mutate_base_arr(base_arr, mod_arr):
    mod_arr_iter = iter(mod_arr)

    try:
        for elem in base_arr:
            valid_mod = next(mod for mod in mod_arr_iter if elem["date"] &lt; mod["date"])
            mod_arr_iter = itertools.chain([valid_mod], mod_arr_iter)

            elem['value'] += valid_mod['value']
    except StopIteration:
        return


Though I'm not sure if I'd recommend this, as having to prepend valid_mod with mod_arr_iter each iteration so it can be re-checked next iteration of the for is a bit unusual.