How to Add an Element to the Beginning of a List in Python

To add an element to the beginning of a list in Python, call list.insert(0, item). Index 0 is the first position, so the new item goes in front and everything else shifts one place to the right:

orders.insert(0, "A-1001")

The sample data is a short list of order numbers, and every output below is a real run on Python 3.12.5.

Below you’ll find what insert() returns, how to add several items at once, two order traps, how slow front inserts get on big lists, and when deque is the better tool.

Add an element to the beginning of a list with insert(0, x)

insert() changes the list in place. That’s why it returns None, and why insert(-1, x) doesn’t do what many people expect:

orders = ["A-1002", "A-1003", "A-1004"]

orders.insert(0, "A-1001")          # put the new order at the front
print(orders)

result = orders.insert(0, "A-1000")
print("insert returned:", result)   # None: the list is changed in place
print(orders)

orders.insert(-1, "A-9999")         # -1 means "before the last item", not "at the end"
print(orders)

Output:

['A-1001', 'A-1002', 'A-1003', 'A-1004']
insert returned: None
['A-1000', 'A-1001', 'A-1002', 'A-1003', 'A-1004']
['A-1000', 'A-1001', 'A-1002', 'A-1003', 'A-9999', 'A-1004']

If you want the opposite end, use append(). For a side-by-side look at every way to put items in front, see my guide to prepending to a list in Python.

Add several items to the front of a list

For more than one item, you have two clean options. new + old builds a new list. Slice assignment, lst[:0] = new, changes the list itself:

cities = ["Denver", "Boston"]
new = ["Austin", "Seattle", "Miami"]

combined = new + cities                 # new list, original untouched
print("new + cities:", combined)

alias = cities
cities[:0] = new                        # in place: every reference sees the change
print("cities[:0] = new:", cities, "| alias sees it:", alias is cities)

backwards = ["Denver"]
for city in ["Austin", "Seattle", "Miami"]:
    backwards.insert(0, city)           # each insert lands in front of the previous one
print("insert(0) in a loop:", backwards)

Output:

new + cities: ['Austin', 'Seattle', 'Miami', 'Denver', 'Boston']
cities[:0] = new: ['Austin', 'Seattle', 'Miami', 'Denver', 'Boston'] | alias sees it: True
insert(0) in a loop: ['Miami', 'Seattle', 'Austin', 'Denver']

That loop result catches people out: each new item lands in front of the last one, so the batch comes out reversed. Adding items at the end, by contrast, is covered in appending multiple items to a list.

Is insert(0) slow on large lists?

Yes, for big lists. A Python list stores items in one block, so every front insert moves all the others over (more on how lists differ from arrays). Here are 50,000 front inserts against two alternatives:

import timeit
from collections import deque

n = 50_000

def list_insert():
    items = []
    for i in range(n):
        items.insert(0, i)

def list_append_then_reverse():
    items = []
    for i in range(n):
        items.append(i)
    items.reverse()

def deque_appendleft():
    items = deque()
    for i in range(n):
        items.appendleft(i)

for fn in (list_insert, list_append_then_reverse, deque_appendleft):
    t = min(timeit.repeat(fn, number=1, repeat=3))
    print(f"{fn.__name__:<26} {t * 1000:>8.1f} ms for {n:,} items")

Output:

list_insert                   263.3 ms for 50,000 items
list_append_then_reverse        1.4 ms for 50,000 items
deque_appendleft                1.6 ms for 50,000 items

For a handful of items it doesn’t matter. It hurts when you add to the front inside a loop over thousands of records. The same “shift everything” cost applies when you remove an element from a list by index near the start.

Use collections.deque to add to the front quickly

A deque (double-ended queue) adds and removes at both ends in constant time. Watch the order with extendleft(), though:

from collections import deque

queue = deque(["A-1003", "A-1004"])
queue.appendleft("A-1002")
print(queue)

queue.extendleft(["A-1001", "A-1000"])         # adds them one at a time, so order flips
print(queue)

queue.extendleft(reversed(["B-1", "B-2"]))     # reverse first to keep your order
print(queue)
print("as a list:", list(queue))

Output:

deque(['A-1002', 'A-1003', 'A-1004'])
deque(['A-1000', 'A-1001', 'A-1002', 'A-1003', 'A-1004'])
deque(['B-1', 'B-2', 'A-1000', 'A-1001', 'A-1002', 'A-1003', 'A-1004'])
as a list: ['B-1', 'B-2', 'A-1000', 'A-1001', 'A-1002', 'A-1003', 'A-1004']

Convert back with list(queue) when the rest of your code expects a list. If you’re building a list from scratch first, creating a list in Python shows the options.

Which way should you add to the front?

Situation	Use
One item, small or medium list	lst.insert(0, item)
Several items, keep the same list	lst[:0] = items
Several items, new list is fine	items + lst
Adding to the front in a big loop	collections.deque and appendleft()
Build up, then flip once	append() in the loop, then reverse()

You might also want these list guides:

• Add elements to an empty list in Python
• Remove the last element from a list in Python
• Check if an element is not in a list
• Create an empty list in Python

Frequently asked questions