# Append integer to beginning of list in Python

## Question:

How do I prepend an integer to the beginning of a list?

``````[1, 2, 3]  ⟶  [42, 1, 2, 3]
``````

``````>>> x = 42
>>> xs = [1, 2, 3]
>>> [x] + xs
[42, 1, 2, 3]
``````

Note: don’t use `list` as a variable name.

``````>>> x = 42
>>> xs = [1, 2, 3]
>>> xs.insert(0, x)
>>> xs
[42, 1, 2, 3]
``````

How it works:

`list.insert(index, value)`

Insert an item at a given position. The first argument is the index of the element before which to insert, so `xs.insert(0, x)` inserts at the front of the list, and `xs.insert(len(xs), x)` is equivalent to `xs.append(x)`. Negative values are treated as being relative to the end of the list.

Another way of doing the same,

``````list[0:0] = [a]
``````

Note that if you are trying to do that operation often, especially in loops, a list is the wrong data structure.

Lists are not optimized for modifications at the front, and `somelist.insert(0, something)` is an O(n) operation.

`somelist.pop(0)` and `del somelist[0]` are also O(n) operations.

The correct data structure to use is a `deque` from the `collections` module. deques expose an interface that is similar to those of lists, but are optimized for modifications from both endpoints. They have an `appendleft` method for insertions at the front.

Demo:

``````In [1]: lst = [0]*1000
In [2]: timeit -n1000 lst.insert(0, 1)
1000 loops, best of 3: 794 ns per loop
In [3]: from collections import deque
In [4]: deq = deque([0]*1000)
In [5]: timeit -n1000 deq.appendleft(1)
1000 loops, best of 3: 73 ns per loop
``````

``````list1 = ['value1','value2','value3']
list2 = ['value0']
newlist=list2+list1
print(newlist)
``````

None of these worked for me. I converted the first element to be part of a series (a single element series), and converted the second element also to be a series, and used append function.

``````l = ((pd.Series(<first element>)).append(pd.Series(<list of other elements>))).tolist()
``````

Based on some (minimal) benchmarks using the `timeit` module it seems that the following has similar if not better performance than the accepted answer

``````new_lst = [a, *lst]
``````

As with `[a] + list` this will create a new list and not mutate `lst`.

If your intention is to mutate the list then use `lst.insert(0, a)`.

``````list_1.insert(0,ur_data)
``````

make sure that ur_data is of string type
so if u have `data= int(5)` convert it to `ur_data = str(data)`

You can use Unpack list:

a = 5

li = [1,2,3]

li = [a, *li]

=> [5, 1, 2, 3]

# Alternative:

``````>>> from collections import deque

>>> my_list = deque()
>>> my_list.append(1)       # append right
>>> my_list.append(2)       # append right
>>> my_list.append(3)       # append right
>>> my_list.appendleft(100) # append left
>>> my_list

deque([100, 1, 2, 3])

>>> my_list[0]

100
``````

[NOTE]:

`collections.deque` is faster than Python pure `list` in a loop Relevant-Post.

Categories: questions Tags: , , ,
Answers are sorted by their score. The answer accepted by the question owner as the best is marked with
at the top-right corner.