To extend a list, you just use list.extend. To insert elements from any iterable at an index, you can use slice assignment...
>>> a = list(range(10))
>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> a[5:5] = range(10, 13)
>>> a
[0, 1, 2, 3, 4, 10, 11, 12, 5, 6, 7, 8, 9]
To extend a list, you just use list.extend. To insert elements from any iterable at an index, you can use slice assignment...
>>> a = list(range(10))
>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> a[5:5] = range(10, 13)
>>> a
[0, 1, 2, 3, 4, 10, 11, 12, 5, 6, 7, 8, 9]
Python lists do not have such a method. Here is helper function that takes two lists and places the second list into the first list at the specified position:
def insert_position(position, list1, list2):
return list1[:position] + list2 + list1[position:]
l.insert(index, obj) doesn't actually return anything. It just updates the list.
As ATO said, you can do b = a[:index] + [obj] + a[index:].
However, another way is:
a = [1, 2, 4]
b = a[:]
b.insert(2, 3)
Most performance efficient approach
You may also insert the element using the slice indexing in the list. For example:
>>> a = [1, 2, 4]
>>> insert_at = 2 # Index at which you want to insert item
>>> b = a[:] # Created copy of list "a" as "b".
# Skip this step if you are ok with modifying the original list
>>> b[insert_at:insert_at] = [3] # Insert "3" within "b"
>>> b
[1, 2, 3, 4]
For inserting multiple elements together at a given index, all you need to do is to use a list of multiple elements that you want to insert. For example:
>>> a = [1, 2, 4]
>>> insert_at = 2 # Index starting from which multiple elements will be inserted
# List of elements that you want to insert together at "index_at" (above) position
>>> insert_elements = [3, 5, 6]
>>> a[insert_at:insert_at] = insert_elements
>>> a # [3, 5, 6] are inserted together in `a` starting at index "2"
[1, 2, 3, 5, 6, 4]
To know more about slice indexing, you can refer: Understanding slice notation.
Note: In Python 3.x, difference of performance between slice indexing and list.index(...) is significantly reduced and both are almost equivalent. However, in Python 2.x, this difference is quite noticeable. I have shared performance comparisons later in this answer.
Alternative using list comprehension (but very slow in terms of performance):
As an alternative, it can be achieved using list comprehension with enumerate too. (But please don't do it this way. It is just for illustration):
>>> a = [1, 2, 4]
>>> insert_at = 2
>>> b = [y for i, x in enumerate(a) for y in ((3, x) if i == insert_at else (x, ))]
>>> b
[1, 2, 3, 4]
Performance comparison of all solutions
Here's the timeit comparison of all the answers with list of 1000 elements on Python 3.9.1 and Python 2.7.16. Answers are listed in the order of performance for both the Python versions.
Python 3.9.1
My answer using sliced insertion - Fastest ( 2.25 µsec per loop)
python3 -m timeit -s "a = list(range(1000))" "b = a[:]; b[500:500] = [3]" 100000 loops, best of 5: 2.25 µsec per loopRushy Panchal's answer with most votes using
list.insert(...)- Second (2.33 µsec per loop)python3 -m timeit -s "a = list(range(1000))" "b = a[:]; b.insert(500, 3)" 100000 loops, best of 5: 2.33 µsec per loopATOzTOA's accepted answer based on merge of sliced lists - Third (5.01 µsec per loop)
python3 -m timeit -s "a = list(range(1000))" "b = a[:500] + [3] + a[500:]" 50000 loops, best of 5: 5.01 µsec per loopMy answer with List Comprehension and
enumerate- Fourth (very slow with 135 µsec per loop)python3 -m timeit -s "a = list(range(1000))" "[y for i, x in enumerate(a) for y in ((3, x) if i == 500 else (x, )) ]" 2000 loops, best of 5: 135 µsec per loop
Python 2.7.16
My answer using sliced insertion - Fastest (2.09 µsec per loop)
python -m timeit -s "a = list(range(1000))" "b = a[:]; b[500:500] = [3]" 100000 loops, best of 3: 2.09 µsec per loopRushy Panchal's answer with most votes using
list.insert(...)- Second (2.36 µsec per loop)python -m timeit -s "a = list(range(1000))" "b = a[:]; b.insert(500, 3)" 100000 loops, best of 3: 2.36 µsec per loopATOzTOA's accepted answer based on merge of sliced lists - Third (4.44 µsec per loop)
python -m timeit -s "a = list(range(1000))" "b = a[:500] + [3] + a[500:]" 100000 loops, best of 3: 4.44 µsec per loopMy answer with List Comprehension and
enumerate- Fourth (very slow with 103 µsec per loop)python -m timeit -s "a = list(range(1000))" "[y for i, x in enumerate(a) for y in ((3, x) if i == 500 else (x, )) ]" 10000 loops, best of 3: 103 µsec per loop
Many languages (e.g. JavaScript, Perl) have a splice function of some sort to modify list contents. They allow you to insert list items or change existing ones to new sublists.
Python uses a "slice" approach, allowing you to specify many list edits without a specific splice function.
>>> myList = ["banana", "orange", "apple", "cherry", "grape"]
>>> myList[3:3] = ["mango", "papaya"]
>>> myList
['banana', 'orange', 'apple', 'mango', 'papaya', 'cherry', 'grape']
By the way, if this is hard to understand, this cheat sheet may help:
["banana", "orange", "apple", "cherry", "grape"]
0_______ 1_______ 2______ 3_______ 4______ 5 # item index
0:1_____ 1:2_____ 2:3____ 3:4_____ 4:5____ # equiv slice notation
^ ^ ^ ^ ^ ^ # slice notation for
0:0 1:1 2:2 3:3 4:4 5:5 # 0_length positions
# between items
0:2________________ 2:5_______________________ # misc longer slice
1:4_________________________ # examples
1:5_________________________________
1:__________________________________
0:____________________________________________
:_____________________________________________
:3__________________________
:1______
There are also negative indices (counting from the end of the list). Let's not get into those right now!
Note that .insert will modify the list in-place, so after the call result and myList will refer to the same list.
Your code is OK. If you wanted a bit of a shorter option, you could use slicing:
listName[n:n] = [var1, var2]
This inserts both var1 and var2 after the nth item in the list.