See below.

.extend isn't more efficient than +=. It's actually a little slower.

$ python -m timeit 'a = [123]; a.extend([456, 789])'
1000000 loops, best of 3: 0.405 usec per loop
$ python -m timeit 'a = [123]; a.extend([456, 789])'
1000000 loops, best of 3: 0.408 usec per loop
$ python -m timeit 'a = [123]; a.extend([456, 789])'
1000000 loops, best of 3: 0.418 usec per loop


vs.

$ python -m timeit 'a = [123]; a += [456, 789]'
1000000 loops, best of 3: 0.389 usec per loop
$ python -m timeit 'a = [123]; a += [456, 789]'
1000000 loops, best of 3: 0.38 usec per loop
$ python -m timeit 'a = [123]; a += [456, 789]'
1000000 loops, best of 3: 0.39 usec per loop


I learned about this a long time ago, and refreshed my memory just now. Basically, under the hood in C (and I just verified this in the Python code), they're the same exact thing (except += sanity-checks the return type). The difference is in how they're invoked in Python.
In Python's bytecode, += is an operator, which is fast to execute. You put some data on the stack, invoke the operator, and you're done. It looks like this:

>>> a += [123, 456]

  3           6 LOAD_FAST                0 (a)
              9 LOAD_CONST               1 (123)
             12 LOAD_CONST               2 (456)
             15 BUILD_LIST               2
             18 INPLACE_ADD


.extend() is a function call, which looks like this:


>>> a.extend([123, 456])

  3           6 LOAD_FAST                0 (a)
              9 LOAD_ATTR                0 (extend)
             12 LOAD_CONST               1 (123)
             15 LOAD_CONST               2 (456)
             18 BUILD_LIST               2
             21 CALL_FUNCTION            1
             24 POP_TOP


This, it turns out, is a lot more expensive. Function calls involve setting up a whole lot more state, looking up the function in the dictionary, checking the stack against the stored function signatures, building a list of args and kwargs based on the stack and the function's list of defaults, preparing the final stack, calling the function, then undoing a bunch of that.
Operators don't do most of that. They're strict in their function signatures and their code paths in CPython are a lot tighter. Their registration is a slot in a struct, instead of a key in a dictionary. They don't have to manipulate the data going in or do the kinds of checking required by functions. All around, they're a lot faster. That's where the performance gains in the timeit loops above come from.