By Claudiu

2008-10-31 05:55:36 8 Comments

What's the difference between the list methods append() and extend()?


@Giovanni G. PY 2017-10-18 07:33:13

Append vs Extend

enter image description here

With append you can append a single element that will extend the list:

>>> a = [1,2]
>>> a.append(3)
>>> a

If you want to extend more than one element you should use extend, because you can only append one elment or one list of element:

>>> a.append([4,5])
>>> a
>>> [1,2,3,[4,5]]

So that you get a nested list

Instead with extend, you can extend a single element like this

>>> a = [1,2]
>>> a.extend([3])
>>> a

Or, differently, from append, extend more elements in one time without nesting the list into the original one (that's the reason of the name extend)

>>> a.extend([4,5,6])
>>> a

Adding one element with both methods

enter image description here

Both append and extend can add one element to the end of the list, though append is simpler.

append 1 element

>>> x = [1,2]
>>> x.append(3)
>>> x

extend one element

>>> x = [1,2]
>>> x.extend([3])
>>> x

Adding more elements... with different results

If you use append for more than one element, you have to pass a list of elements as arguments and you will obtain a NESTED list!

>>> x = [1,2]
>>> x.append([3,4])
>>> x

With extend, instead, you pass a list as an argument, but you will obtain a list with the new element that is not nested in the old one.

>>> z = [1,2] 
>>> z.extend([3,4])
>>> z

So, with more elements, you will use extend to get a list with more items. However, appending a list will not add more elements to the list, but one element that is a nested list as you can clearly see in the output of the code.

enter image description here

enter image description here

@kender 2008-10-31 06:02:25

append: Appends object at the end.

x = [1, 2, 3]
x.append([4, 5])
print (x)

gives you: [1, 2, 3, [4, 5]]

extend: Extends list by appending elements from the iterable.

x = [1, 2, 3]
x.extend([4, 5])
print (x)

gives you: [1, 2, 3, 4, 5]

@Rohan 2017-05-29 22:10:07

What is the difference between extend and simply using the addition operator - in the above example, x = x + [4, 5]?

@Aaron Hall 2017-07-17 17:14:55

Actually there's a big difference - x + [4, 5] gives you a new list assigned to x - x.extend() mutates the original list. I elaborate in my answer here below.

@Astitva Srivastava 2018-12-13 14:54:54

@AaronHall @Rohan but it is same as x += [4,5].

@MilkyWay90 2018-12-21 16:22:02

@AstitvaSrivastava Actually, I think extend is faster in terms of bytecode

@Anthony 2019-03-15 14:53:10

The keyword when using append is Object. If you try to use extend and you pass in a dictionary, it will append the key, and not the whole hash to the end of the array.

@kmario23 2017-12-30 18:38:32

An English dictionary defines the words append and extend as:

append: add (something) to the end of a written document.
extend: make larger. Enlarge or expand

With that knowledge, now let's understand

1) The difference between append and extend


  • Appends any Python object as-is to the end of the list (i.e. as a the last element in the list).
  • The resulting list may be nested and contain heterogeneous elements (i.e. list, string, tuple, dictionary, set, etc.)


  • Accepts any iterable as its argument and makes the list larger.
  • The resulting list is always one-dimensional list (i.e. no nesting) and it may contain heterogeneous elements in it (e.g. characters, integers, float) as a result of applying list(iterable).

2) Similarity between append and extend

  • Both take exactly one argument.
  • Both modify the list in-place.
  • As a result, both returns None.


lis = [1, 2, 3]

# 'extend' is equivalent to this
lis = lis + list(iterable)

# 'append' simply appends its argument as the last element to the list
# as long as the argument is a valid Python object

@Harley Holcombe 2008-10-31 05:57:37

append adds an element to a list, and extend concatenates the first list with another list (or another iterable, not necessarily a list.)

>>> li = ['a', 'b', 'mpilgrim', 'z', 'example']
>>> li
['a', 'b', 'mpilgrim', 'z', 'example']

>>> li.append("new")
>>> li
['a', 'b', 'mpilgrim', 'z', 'example', 'new']

>>> li.append(["new", 2])
>>> li
['a', 'b', 'mpilgrim', 'z', 'example', 'new', ['new', 2]]

>>> li.insert(2, "new")
>>> li
['a', 'b', 'new', 'mpilgrim', 'z', 'example', 'new', ['new', 2]]

>>> li.extend(["two", "elements"])
>>> li
['a', 'b', 'new', 'mpilgrim', 'z', 'example', 'new', ['new', 2], 'two', 'elements']

@tessie 2016-08-31 18:14:42

extend(L) extends the list by appending all the items in the given list L.

>>> a
[1, 2, 3]
a.extend([4])  #is eqivalent of a[len(a):] = [4]
>>> a
[1, 2, 3, 4]
a = [1, 2, 3]
>>> a
[1, 2, 3]
>>> a[len(a):] = [4]
>>> a
[1, 2, 3, 4]

@CodyChan 2013-10-31 13:12:10

The append() method adds a single item to the end of the list.

x = [1, 2, 3]
x.append([4, 5])
# gives you
[1, 2, 3, [4, 5], 'abc']

The extend() method takes one argument, a list, and appends each of the items of the argument to the original list. (Lists are implemented as classes. “Creating” a list is really instantiating a class. As such, a list has methods that operate on it.)

x = [1, 2, 3]
x.extend([4, 5])
# gives you
[1, 2, 3, 4, 5, 'a', 'b', 'c']

From Dive Into Python.

@aneroid 2014-09-25 09:28:07

You can't extend with just 6 since it's not iterable. And the second output in your example is wrong. 'abc' gets added as a single element since you passed it in to extend as a list with one element ['abc']: [1, 2, 3, 4, 5, 'abc']. To make your example output correct, change the abc line to: x.extend('abc'). And remove the x.extend(6) or change it to x.extend([6]).

@Aaron Hall 2015-01-23 22:44:37

What is the difference between the list methods append and extend?

  • append adds its argument as a single element to the end of a list. The length of the list itself will increase by one.
  • extend iterates over its argument adding each element to the list, extending the list. The length of the list will increase by however many elements were in the iterable argument.


The list.append method appends an object to the end of the list.


Whatever the object is, whether a number, a string, another list, or something else, it gets added onto the end of my_list as a single entry on the list.

>>> my_list
['foo', 'bar']
>>> my_list.append('baz')
>>> my_list
['foo', 'bar', 'baz']

So keep in mind that a list is an object. If you append another list onto a list, the first list will be a single object at the end of the list (which may not be what you want):

>>> another_list = [1, 2, 3]
>>> my_list.append(another_list)
>>> my_list
['foo', 'bar', 'baz', [1, 2, 3]]
                     #^^^^^^^^^--- single item at the end of the list.


The list.extend method extends a list by appending elements from an iterable:


So with extend, each element of the iterable gets appended onto the list. For example:

>>> my_list
['foo', 'bar']
>>> another_list = [1, 2, 3]
>>> my_list.extend(another_list)
>>> my_list
['foo', 'bar', 1, 2, 3]

Keep in mind that a string is an iterable, so if you extend a list with a string, you'll append each character as you iterate over the string (which may not be what you want):

>>> my_list.extend('baz')
>>> my_list
['foo', 'bar', 1, 2, 3, 'b', 'a', 'z']

Operator Overload, __add__ (+) and __iadd__ (+=)

Both + and += operators are defined for list. They are semantically similar to extend.

my_list + another_list creates a third list in memory, so you can return the result of it, but it requires that the second iterable be a list.

my_list += another_list modifies the list in-place (it is the in-place operator, and lists are mutable objects, as we've seen) so it does not create a new list. It also works like extend, in that the second iterable can be any kind of iterable.

Don't get confused - my_list = my_list + another_list is not equivalent to += - it gives you a brand new list assigned to my_list.

Time Complexity

Append has constant time complexity, O(1).

Extend has time complexity, O(k).

Iterating through the multiple calls to append adds to the complexity, making it equivalent to that of extend, and since extend's iteration is implemented in C, it will always be faster if you intend to append successive items from an iterable onto a list.


You may wonder what is more performant, since append can be used to achieve the same outcome as extend. The following functions do the same thing:

def append(alist, iterable):
    for item in iterable:

def extend(alist, iterable):

So let's time them:

import timeit

>>> min(timeit.repeat(lambda: append([], "abcdefghijklmnopqrstuvwxyz")))
>>> min(timeit.repeat(lambda: extend([], "abcdefghijklmnopqrstuvwxyz")))

Addressing a comment on timings

A commenter said:

Perfect answer, I just miss the timing of comparing adding only one element

Do the semantically correct thing. If you want to append all elements in an iterable, use extend. If you're just adding one element, use append.

Ok, so let's create an experiment to see how this works out in time:

def append_one(a_list, element):

def extend_one(a_list, element):
    """creating a new list is semantically the most direct
    way to create an iterable to give to extend"""

import timeit

And we see that going out of our way to create an iterable just to use extend is a (minor) waste of time:

>>> min(timeit.repeat(lambda: append_one([], 0)))
>>> min(timeit.repeat(lambda: extend_one([], 0)))

We learn from this that there's nothing gained from using extend when we have only one element to append.

Also, these timings are not that important. I am just showing them to make the point that, in Python, doing the semantically correct thing is doing things the Right Way™.

It's conceivable that you might test timings on two comparable operations and get an ambiguous or inverse result. Just focus on doing the semantically correct thing.


We see that extend is semantically clearer, and that it can run much faster than append, when you intend to append each element in an iterable to a list.

If you only have a single element (not in an iterable) to add to the list, use append.

@ilias iliadis 2018-03-31 18:06:48

@Aaron Hall One small comment in algorithm for timing. "extend_one" may return "slightly wrong" time because the creation of a list is also involved. Probably better is to create the items as variables (ex1 = 0 and ex2 = [0]) and pass these variables, if you want to be more strict.

@Jean-Francois T. 2018-04-23 03:54:20

Perfect answer indeed. What about performance of l1 += l2 vs l1.extend(l2)?

@ShadowRanger 2018-08-17 19:10:51

@Jean-FrancoisT.: l1 += l2 and l1.extend(l2) ultimately execute the same code (the list_extend function in listobject.c). The only differences are: 1. += reassigns l1 (to itself for lists, but the reassignment supports immutable types that aren't the same object after), which makes it illegal if l1 is actually an attribute of an immutable object; for example, t = ([],), t[0] += lst would fail, while t[0].extend(lst) would work. 2. l1 += l2 uses dedicated bytecodes, while l1.extend(l2) uses generalized method dispatch; this makes += faster than extend.

@ShadowRanger 2018-08-17 19:20:26

The fact that += must reassign l1 does mean that in some cases, the slower dispatch of extend is partially or wholly made up for by not assigning back to the left hand side. For example, if the list is an attribute of an object, self.l1 += l2 and self.l1.extend(l2) have identical performance on my Python 3.6 install, simply because real operation is more like self.l1 = self.l1.__iadd__(l2), which means it must perform a moderately expensive STORE_ATTR that self.l1.extend(l2) doesn't have to.

@ShadowRanger 2018-08-17 19:32:25

Simple comparison in local tests: For a local variable (so the += is just using STORE_FAST, which is super cheap), where the value being added is an existing list with one item in it, with the operation repeated 1000 times, += took about 33 ns on average, while extend took 78 ns, a difference of 45 ns. If l1 is a global (requires more expensive STORE_GLOBAL), the difference narrows to 17 ns. If l1 is actually local.l1 (requires even more expensive STORE_ATTR), there is no meaningful difference between += and extend (timings roughly identical; extend sometimes wins).

@tparker 2018-12-22 22:38:08

Could you clarify the difference in behavior between my_list = my_list + another_list and my_list += another_list? What's the practical difference between modifying an existing list and creating a new list to have identical contents and rebinding the name?

@vivek 2018-07-17 07:19:35

Append and extend are one of the extensibility mechanisms in python.

Append: Adds an element to the end of the list.

my_list = [1,2,3,4]

To add a new element to the list, we can use append method in the following way.


The default location that the new element will be added is always in the (length+1) position.

Insert: The insert method was used to overcome the limitations of append. With insert, we can explicitly define the exact position we want our new element to be inserted at.

Method descriptor of insert(index, object). It takes two arguments, first being the index we want to insert our element and second the element itself.

Example: my_list = [1,2,3,4]
my_list[4, 'a']

Extend: This is very useful when we want to join two or more lists into a single list. Without extend, if we want to join two lists, the resulting object will contain a list of lists.

a = [1,2]
b = [3]
print (a)

If we try to access the element at pos 2, we get a list ([3]), instead of the element. To join two lists, we'll have to use append.

a = [1,2]
b = [3]
print (a)

To join multiple lists

a = [1]
b = [2]
c = [3]
print (a)

@Mike - SMT 2018-08-03 13:19:51

Why are you answering a question that has already been answer many times? This question is 10 years old...

@Calculus 2017-12-04 10:17:53

To distinguish them intuitively

l1 = ['a', 'b', 'c']
l2 = ['d', 'e', 'f']
['a', 'b', 'c', ['d', 'e', 'f']]

It's like l1 reproduce a body inside her body(nested).

# Reset l1 = ['a', 'b', 'c']
['a', 'b', 'c', 'd', 'e', 'f']

It's like that two separated individuals get married and construct an united family.

Besides I make an exhaustive cheatsheet of all list's methods for your reference.

list_methods = {'Add': {'extend', 'append', 'insert'},
                'Remove': {'pop', 'remove', 'clear'}
                'Sort': {'reverse', 'sort'},
                'Search': {'count', 'index'},
                'Copy': {'copy'},

@Chaitanya 2013-05-12 19:51:07

append(object) - Updates the list by adding an object to the list.

x = [20]
# List passed to the append(object) method is treated as a single object.
x.append([21, 22, 23])
# Hence the resultant list length will be 2
--> [20, [21, 22, 23]]

extend(list) - Essentially concatenates two lists.

x = [20]
# The parameter passed to extend(list) method is treated as a list.
# Eventually it is two lists being concatenated.
x.extend([21, 22, 23])
# Here the resultant list's length is 4
[20, 21, 22, 23]

@kiriloff 2013-05-12 18:21:40

extend() can be used with an iterator argument. Here is an example. You wish to make a list out of a list of lists this way:


list2d = [[1,2,3],[4,5,6], [7], [8,9]]

you want

[1, 2, 3, 4, 5, 6, 7, 8, 9]

You may use itertools.chain.from_iterable() to do so. This method's output is an iterator. Its implementation is equivalent to

def from_iterable(iterables):
    # chain.from_iterable(['ABC', 'DEF']) --> A B C D E F
    for it in iterables:
        for element in it:
            yield element

Back to our example, we can do

import itertools
list2d = [[1,2,3],[4,5,6], [7], [8,9]]
merged = list(itertools.chain.from_iterable(list2d))

and get the wanted list.

Here is how equivalently extend() can be used with an iterator argument:

merged = []
[1, 2, 3, 4, 5, 6, 7, 8, 9]

@pppery 2018-07-13 03:20:44

This answer does not contrast extend with append and therefore does not answer the question

@ilias iliadis 2018-03-31 18:46:17

append "extends" the list (in place) by only one item, the single object passed (as argument).

extend "extends" the list (in place) by as many items as the object passed (as argument) contains.

This may be slightly confusing for str objects.

  1. If you pass a string as argument: append will add a single string item at the end but extend will add as many "single" 'str' items as the length of that string.
  2. If you pass a list of strings as argument: append will still add a single 'list' item at the end and extend will add as many 'list' items as the length of the passed list.
def append_o(a_list, element):
    print('append:', end = ' ')
    for item in a_list:
        print(item, end = ',')

def extend_o(a_list, element):
    print('extend:', end = ' ')
    for item in a_list:
        print(item, end = ',')

append_o(['ab'],['cd', 'ef'])
extend_o(['ab'],['cd', 'ef'])


append: ab,cd,
extend: ab,c,d,
append: ab,['cd', 'ef'],
extend: ab,cd,ef,
append: ab,['cd'],
extend: ab,cd,

@The Gr8 Adakron 2016-06-13 10:17:46

append(): It is basically used in Python to add one element.

Example 1:

>> a = [1, 2, 3, 4]
>> a.append(5)
>> print(a)
>> a = [1, 2, 3, 4, 5]

Example 2:

>> a = [1, 2, 3, 4]
>> a.append([5, 6])
>> print(a)
>> a = [1, 2, 3, 4, [5, 6]]

extend(): Where extend(), is used to merge two lists or insert multiple elements in one list.

Example 1:

>> a = [1, 2, 3, 4]
>> b = [5, 6, 7, 8]
>> a.extend(b)
>> print(a)
>> a = [1, 2, 3, 4, 5, 6, 7, 8]

Example 2:

>> a = [1, 2, 3, 4]
>> a.extend([5, 6])
>> print(a)
>> a = [1, 2, 3, 4, 5, 6]

@Crabime 2017-02-11 01:59:02

I hope I can make a useful supplement to this question. If your list stores a specific type object, for example Info, here is a situation that extend method is not suitable: In a for loop and and generating an Info object every time and using extend to store it into your list, it will fail. The exception is like below:

TypeError: 'Info' object is not iterable

But if you use the append method, the result is OK. Because every time using the extend method, it will always treat it as a list or any other collection type, iterate it, and place it after the previous list. A specific object can not be iterated, obviously.

@Shiv 2014-10-16 06:49:07

Append adds the entire data at once. The whole data will be added to the newly created index. On the other hand, extend, as it name suggests, extends the current array.

For example

list1 = [123, 456, 678]
list2 = [111, 222]

With append we get:

result = [123, 456, 678, [111, 222]]

While on extend we get:

result = [123, 456, 678, 111, 222]

@denfromufa 2013-08-26 11:21:12

You can use "+" for returning extend, instead of extending in place.



[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11]



[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 9, 8, 7, 6, 5, 4, 3, 2]

Similarly += for in place behavior, but with slight differences from append & extend. One of the biggest differences of += from append and extend is when it is used in function scopes, see this blog post.

@franklin 2015-07-19 03:59:07

Does using the '+' to return extend have any affect on time complexity?

@denfromufa 2015-07-21 14:50:35

@franklin, see this answer for details:

@pppery 2018-07-13 03:20:10

I don't see how this answers the question

@Erik 2012-08-20 21:11:00

The following two snippets are semantically equivalent:

for item in iterator:



The latter may be faster as the loop is implemented in C.

@Alex L 2012-12-27 08:29:23

Extending is ~4x faster on my machine than appending in a loop (16us vs 4us for 100 loops of zeros)

@Mad Physicist 2015-10-23 13:43:19

extend() probably preallocates, while append() likely does not.

@Soren Bjornstad 2019-07-28 03:43:53

@MadPhysicist: For completeness' sake, there would be times where extend() can't preallocate sensibly since some iterables don't implement __len__(), but like you I'd be surprised if it doesn't try. Some of the performance gain also comes from doing the iteration part in pure C instead of in Python, as pointed out in Aaron's answer.

@skdev75 2014-07-08 12:42:52

This is the equivalent of append and extend using the + operator:

>>> x = [1,2,3]
>>> x
[1, 2, 3]
>>> x = x + [4,5,6] # Extend
>>> x
[1, 2, 3, 4, 5, 6]
>>> x = x + [[7,8]] # Append
>>> x
[1, 2, 3, 4, 5, 6, [7, 8]]

@denfromufa 2015-09-13 02:18:57

Why not =+ ?! More concise

@bconstanzo 2014-08-05 16:58:25

An interesting point that has been hinted, but not explained, is that extend is faster than append. For any loop that has append inside should be considered to be replaced by list.extend(processed_elements).

Bear in mind that apprending new elements might result in the realloaction of the whole list to a better location in memory. If this is done several times because we are appending 1 element at a time, overall performance suffers. In this sense, list.extend is analogous to "".join(stringlist).

@Greg Hewgill 2008-10-31 05:57:32

append appends a single element. extend appends a list of elements.

Note that if you pass a list to append, it still adds one element:

>>> a = [1, 2, 3]
>>> a.append([4, 5, 6])
>>> a
[1, 2, 3, [4, 5, 6]]

Related Questions

Sponsored Content

41 Answered Questions

[SOLVED] What does the "yield" keyword do?

22 Answered Questions

[SOLVED] Difference between __str__ and __repr__?

7 Answered Questions

[SOLVED] What are the differences between type() and isinstance()?

26 Answered Questions

[SOLVED] Difference between staticmethod and classmethod

11 Answered Questions

[SOLVED] Difference between del, remove and pop on lists

  • 2012-07-17 10:21:41
  • sachin irukula
  • 1661021 View
  • 923 Score
  • 11 Answer
  • Tags:   python list

18 Answered Questions

[SOLVED] What's the difference between lists and tuples?

  • 2009-03-09 15:41:25
  • Lucas Gabriel Sánchez
  • 413071 View
  • 1018 Score
  • 18 Answer
  • Tags:   python list tuples

28 Answered Questions

[SOLVED] How to read a file line-by-line into a list?

18 Answered Questions

[SOLVED] How to remove an element from a list by index

  • 2009-03-09 18:16:11
  • Joan Venge
  • 2612093 View
  • 1502 Score
  • 18 Answer
  • Tags:   python list

Sponsored Content