Q:

Can someone calculate the time complexity in big Oh notation

Can someone help me explain the big Oh complexity of this algorithm?  I've been trying for an hour, but I don't understand the complexity of the recursion.  I know the 3 first statements are O(1) and thought that the ones underneath that were O(n/2) and O(n/2) so together O(n), but I am not sure. 
def sum(a):
    if len ( a ) == 0:
        return 0
    elif len ( a ) == 1:
        return a [0]
    m = len (a )//2

    b = sum (a [: m ])
    c = sum (a [ m :])

    return b + c

A:

If you consider the number of times you call recursively the function, this number is 2n-1.  For each call, you have a constant number of constant time operations (so O(1)). 
To conclude the time complexity is O(n), linear to the length of the list.   
You may try to define a recurrence relation in order to prove it formally. 
Note
The question may be tricky, due to the slicing operation used at each iteration.  This depends on the implementation details (for python it looks like it is O(k) with k the length of the list but for numpy it should be O(1) as pointed out in the comments) and may be easily replaced by passing indexes (e.g., start, end) and not a sliced list. 
Here I assume the operation takes constant time.