在列表中的特定索引处插入元素并返回更新后的列表

小开

最佳答案

我得到的最短的: b = a[:2] + [3] + a[2:]

>>>
>>> a = [1, 2, 4]
>>> print a
[1, 2, 4]
>>> b = a[:2] + [3] + a[2:]
>>> print a
[1, 2, 4]
>>> print b
[1, 2, 3, 4]

小开

l.insert(index, obj)实际上不返回任何内容，只是更新列表。

正如 ATO 所说，你可以做 b = a[:index] + [obj] + a[index:]。不过，另一种方式是:

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

小开

最有效的性能方法

也可以在列表中使用 切片索引切片索引插入元素，例如:

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

对于 在给定索引处插入多个元素，您所需要做的就是使用一个包含多个要插入的元素的 list。例如:

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

要了解更多关于 切片索引切片索引的信息，可以参考: 理解切片符号。

注意: 在 Python 3.x 中，切片索引切片索引和 list.index(...)之间的性能差异显著降低，两者几乎相当。然而，在 Python 2.x 中，这种差异非常明显。在后面的回答中，我分享了性能比较。

使用列表内涵 (但在性能方面非常缓慢):

作为一种替代方法，它也可以通过使用 列表内涵和 enumerate来实现。 (但请不要这样做，这只是为了说明):

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

所有解决方案的性能比较

下面是所有答案与 Python 3.9.1和 Python 2.7.16上的1000个元素列表的 timeit比较。答案是按照两个 Python 版本的性能顺序列出的。

Python 3.9.1

我的回答是使用切片插入-最快的(2.25 μsec/loop)

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

Rushy Panchal 的回答 使用 list.insert(...)-Second (2.33 μsec/loop)进行大部分投票

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

基于分片列表合并的 ATOzTOA 接受的答案 -Third (5.01 μsec/loop)

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

我的答案是用 列表内涵和 enumerate-Four (非常慢，每个循环135μsec)

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

我的答案使用切片插入-最快的 (每个循环2.09微秒)

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

Rushy Panchal 的回答 使用 list.insert(...)-Second (2.36 μsec/loop)进行大部分投票

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

基于分片列表合并的 ATOzTOA 接受的答案 -Third (4.44 μsec/loop)

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

我用 列表内涵和 enumerate-Four 回答 (非常慢，每个循环103μsec)

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

小开

使用 Python list insert ()方法。用法:

# 语法

Insert ()方法的语法-

list.insert(index, obj)

# 参数

Index-这是需要插入对象 obj 的 Index。
Obj-这是要插入到给定列表中的对象。

# 返回值此方法不返回任何值，但在给定索引处插入给定元素。

例如:

a = [1,2,4,5]


a.insert(2,3)


print(a)

返回 [1, 2, 3, 4, 5]

小开

最简洁的方法是复制列表，然后将对象插入到复制中。在 Python 3上，这可以通过 list.copy完成:

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

在 Python2上，可以通过 new = old[:]实现对列表的复制(这在 Python3上也可以实现)。

在性能方面，与其他拟议方法没有区别:

$ 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

小开

下面是添加单个项的方法，即在特定索引连接列表中的单个项与另一个列表连接

>>> expences = [2200, 2350, 2600, 2130, 2190]
>>> expences.append(1980)
>>> expences
[2200, 2350, 2600, 2130, 2190, 1980]


>>> expences.insert(1, 1200)


>>> expences
[2200, 1200, 2350, 2600, 2130, 2190, 1980]


>>> newElm = [2550, 2123, 2430]
>>> expences.extend(newElm)
>>> expences
[2200, 1200, 2350, 2600, 2130, 2190, 1980, 2550, 2123, 2430]
>>>