Wstaw element o określonym indeksie na liście i zwróć zaktualizowaną listę

l.insert(index, obj) właściwie nic nie zwraca. To tylko aktualizuje listę.

Jak powiedział ATO, możesz to zrobić b = a[:index] + [obj] + a[index:]. Jednak Innym sposobem jest:

a = [1, 2, 4]
b = a[:]
b.insert(2, 3)

Najbardziej wydajne podejście

Można również wstawić element za pomocą slice indeksowania na liście. Na przykład:

>>> 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]

Aby wstawić wiele elementów razem w danym indeksie , wystarczy użyć list wielu elementów, które chcesz wstawić. Na przykład:

>>> 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]

Aby dowiedzieć się więcej o indeksowaniu slice, możesz odnieść się do: zrozumienie notacji slice .

Uwaga: W Pythonie 3.x, różnica wydajności pomiędzy indeksowaniem slice i list.index(...) jest znacznie zredukowana i oba są prawie równoważne. Jednak w Pythonie 2.x, ta różnica jest dość zauważalna. Podzieliłem się porównaniami wydajności w dalszej części tej odpowiedzi.

Alternatywny sposób rozumienia list (ale bardzo wolno pod względem wydajności):

Jako alternatywę można to osiągnąć za pomocą rozumienia listy z enumerate też. (ale proszę, nie rób tego w ten sposób. To tylko dla ilustracji):

>>> 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]

Porównanie wydajności wszystkich rozwiązań

Oto timeit porównanie wszystkich odpowiedzi z listą 1000 elementów w Pythonie 3.9.1 i Pythonie 2.7.16. Odpowiedzi są wymienione w kolejności wykonania dla obu wersji Pythona.

Python 3.9.1

1. moja odpowiedź użycie plasterków - najszybsze (2,25 µsec na pętla)

   python3 -m timeit -s "a = list(range(1000))" "b = a[:]; b[500:500] = [3]"
   100000 loops, best of 5: 2.25 µsec per loop
   

2. Rushy Panchal ' s answer z największą liczbą głosów przy użyciu list.insert(...)- Second (2.33 µsec na pętlę)

   python3 -m timeit -s "a = list(range(1000))" "b = a[:]; b.insert(500, 3)"
   100000 loops, best of 5: 2.33 µsec per loop
   

3. zaakceptowana odpowiedź ATOzTOA na podstawie scalania list pokrojonych-trzeci (5,01 µsec na pętlę)

   python3 -m timeit -s "a = list(range(1000))" "b = a[:500] + [3] + a[500:]"
   50000 loops, best of 5: 5.01 µsec per loop
   

4. moja odpowiedź z rozumieniem listy i enumerate - czwartym (bardzo wolno z 135 µsec na pętla)

   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

1. moja odpowiedź użycie plasterków - najszybsze (2.09 µsec na pętlę)

   python -m timeit -s "a = list(range(1000))" "b = a[:]; b[500:500] = [3]"
   100000 loops, best of 3: 2.09 µsec per loop
   

2. Rushy Panchal ' s answer z największą liczbą głosów przy użyciu list.insert(...)- Second (2.36 µsec na pętlę)

   python -m timeit -s "a = list(range(1000))" "b = a[:]; b.insert(500, 3)"
   100000 loops, best of 3: 2.36 µsec per loop
   

3. zaakceptowana odpowiedź ATOzTOA na podstawie połączenia list pokrojonych-trzeci (4,44 µsec na pętla)

   python -m timeit -s "a = list(range(1000))" "b = a[:500] + [3] + a[500:]"
   100000 loops, best of 3: 4.44 µsec per loop
   

4. moja odpowiedź z rozumieniem listy i enumerate - czwartym (bardzo wolnym z 103 µsec na pętlę)

   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
   

Najczystszym podejściem jest skopiowanie listy, a następnie wstawienie obiektu do kopii. W Pythonie 3 można to zrobić poprzez list.copy:

new = old.copy()
new.insert(index, value)

W Pythonie 2 Kopiowanie listy można uzyskać poprzez new = old[:] (działa to również w Pythonie 3).

Pod względem wydajności nie ma różnicy w stosunku do innych proponowanych metod:

$ python --version
Python 3.8.1
$ python -m timeit -s "a = list(range(1000))" "b = a.copy(); b.insert(500, 3)"
100000 loops, best of 5: 2.84 µsec per loop
$ python -m timeit -s "a = list(range(1000))" "b = a.copy(); b[500:500] = (3,)"
100000 loops, best of 5: 2.76 µsec per loop

Użyj metody Python list insert () . Sposób użycia:

#składnia

Składnia metody insert ()-

list.insert(index, obj)

#parametry

• index-jest to indeks, w którym należy wstawić obiekt obj.
• obj-jest to obiekt, który ma być wstawiony do podanej listy.

#Return Value Metoda ta nie zwraca żadnej wartości, ale wstawia dany element w podanym indeks.

Przykład:

a = [1,2,4,5]

a.insert(2,3)

print(a)

Zwraca [1, 2, 3, 4, 5]