I have an integer and a list. I would like to make a new list of them beginning with the variable and ending with the list.
Writing `a + list`

I get errors. The compiler handles `a`

as integer, thus I cannot use append, or extend either.
How would you do this?

# Append integer to beginning of list in Python

## The Question :

*557 people think this question is useful*

*The Question Comments :*

## The Answer 1

*875 people think this answer is useful*

>>>var=7 >>>array = [1,2,3,4,5,6] >>>array.insert(0,var) >>>array [7, 1, 2, 3, 4, 5, 6]

How it works:

`array.insert(index, value)`

Insert an item at a given position. The first argument is the index of the element before which to insert, so `array.insert(0, x)`

inserts at the front of the list, and `array.insert(len(array), x)`

is equivalent to `array.append(x)`

.Negative values are treated as being relative to the end of the array.

## The Answer 2

*542 people think this answer is useful*

>>> a = 5 >>> li = [1, 2, 3] >>> [a] + li # Don't use 'list' as variable name. [5, 1, 2, 3]

## The Answer 3

*106 people think this answer is useful*

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

## The Answer 4

*44 people think this answer is useful*

Another way of doing the same,

list[0:0] = [a]

## The Answer 5

*15 people think this answer is useful*

You can use Unpack list:

a = 5

li = [1,2,3]

li = [a, *li]

=>

[5, 1, 2, 3]

## The Answer 6

*5 people think this answer is useful*

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)`

.

## The Answer 7

*3 people think this answer is useful*

# 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}.

## The Answer 8

*2 people think this answer is useful*

New lists can be made by simply adding lists together.

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

## The Answer 9

*2 people think this answer is useful*

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)`

## The Answer 10

*1 people think this answer is useful*

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()