Список Python INSERT () Метод

Автор оригинала: Chris.

Как вы можете вставить элемент в данный индекс в данном списке? Python Вставить () Метод твой друг.

В этом руководстве показано вам все, что вам нужно знать, чтобы помочь вам овладеть необходимым методом наиболее фундаментального типа контейнера данных в языке программирования Python.

Определение и использование :

list.insert (i, элемент) Способ добавляет элемент элемент к существующему Список На позиции Я Отказ Все элементы J> I будет перемещаться одним положением индекса вправо.

Вот краткий пример:

>>> lst = [1, 2, 3, 4]
>>> lst.insert(3, 99)
>>> lst
[1, 2, 3, 99, 4]

В первой строке примера вы создаете список lst Отказ Затем вы вставляете целочисленный элемент 99 в положение 3 списка. Результатом является список с пятью элементами [1, 2, 3, 99, 4] Отказ

Синтаксис :

Вы можете вызвать этот метод на каждом объекте списка в Python. Вот синтаксис:

list.insert (индекс, элемент)

Аргументы:

Видео:

Код головоломки:

Теперь вы знаете основы. Давайте углубим ваше понимание с коротким кодом головоломки – можешь решить это?

# Puzzle
# Puzzle created by Finxter Lee
lst = [1, 3, 4, 5, 6, 7, 8]
lst.insert(1, 2)
print(lst)
# What's the output of this code snippet?

Вы можете проверить решение на Приложение Finxter Отказ

Примеры:

Чтобы помочь вам полностью понять Ins и ауты Вставить () Метод, давайте погрузимся в несколько примеров.

>>> lst = [1, 2, 3]
>>> lst.insert(0, 99)
>>> lst
[99, 1, 2, 3]
>>> lst.insert(-1, 42)
>>> lst
[99, 1, 2, 42, 3]
>>> lst.insert(100, 0)
>>> lst
[99, 1, 2, 42, 3, 0]

Интересный случай – второй, где вы используете отрицательный индекс в Вставить () Метод:

Статьи по Теме:

• Окончательное руководство по спискам Python

Вот ваш бесплатный PDF чит-лист, показывающий вас все методы списка Python на одной простой странице. Нажмите на изображение, чтобы загрузить файл PDF с высоким разрешением, распечатать его и опубликовать его в свою офисную стену:

Список Python Вставка () Отрицательный индекс

Вы можете использовать отрицательный индекс в lst.insert (индекс, элемент) метод. С отрицательным индексом вы рассчитываете назад, начиная с права. Другими словами, индекс -1 Подпитывается для правого элемента в списке. Вставить () Способ вставляет элемент прямо перед позицией индекса. Таким образом, вы получаете следующее поведение, где элемент вставлен на вторую последнюю позицию:

>>> lst = ["Ann", "Bob", "Alice"]
>>> lst.insert(-1, "Liz")
>>> lst
['Ann', 'Bob', 'Liz', 'Alice']

Что произойдет, если вы рассчитываете дальше, то есть -2, -3 или даже -99? Давай проверим:

>>> lst.insert(-2, "Sam")
>>> lst
['Ann', 'Bob', 'Sam', 'Liz', 'Alice']

… а также …

>>> lst.insert(-3, "Bob")
>>> lst
['Ann', 'Bob', 'Bob', 'Sam', 'Liz', 'Alice']

… а также …

>>> lst.insert(-99, "Hans")
>>> lst
['Hans', 'Ann', 'Bob', 'Bob', 'Sam', 'Liz', 'Alice']

Таким образом, вы можете видеть, что каждый целочисленный индекс разрешен! Если вы завышете (например, -99), он просто будет вставлять в начале списка.

Список Python вставить () в начале

Вставить () Метод позволяет добавить элемент в начале списка. Просто используйте индекс 0 в вызове lst.insert (0, элемент) Чтобы добавить элемент в начало lst Отказ

Вот пример:

>>> lst = [1, 2, 3]
>>> lst.insert(0, 99)
>>> lst
[99, 1, 2, 3]

Вставить (я, х) Способ вставляет элемент х На позиции Я в списке. Таким образом, вы можете вставить элемент в каждую позицию в списке – даже в первой позиции. Обратите внимание, что если вы введете элемент в первую позицию, каждый последующий элемент будет перемещен на одну позицию. Другими словами, элемент Я Перейдет в положение Я + 1 Отказ

Вставка списка Python () в конце

Хорошо, вы можете вставить элемент в каждую позицию в списке – просто используйте первый аргумент, чтобы определить индекс вставки. Следовательно, вы можете «вставить» элемент в конце списка, определив указатель, который больше или равный размер списка. Помните, Вставить (индекс, элемент) Вставляет элемент до Элемент, который в настоящее время находится в положении индекс Отказ Поэтому, если вы определяете индекс, который, по крайней мере, размер списка, вы вставите элемент в конце списка:

>>> lst = [1, 2, 3, 4, 5, 6]
>>> lst.insert(6, 99)
>>> lst
[1, 2, 3, 4, 5, 6, 99]
>>> lst.insert(100000, 42)
>>> lst
[1, 2, 3, 4, 5, 6, 99, 42]

Независимо от вашего конкретного выбора аргумента индекса, до тех пор, пока он больше или равен текущему размеру списка, ваш элемент будет вставлен в конце списка.

Однако это не имеет большого смысла, учитывая, что вы можете использовать Добавить (элемент) Способ, который добавляет элемент в конце списка – и является высокоэффективным (и читаемым). Узнайте больше о методе Append () в моей детальной статье блога.

Вот пример, добавляя те же элементы 99 и 42 до конца списка:

>>> lst = [1, 2, 3, 4, 5, 6]
>>> lst.append(99)
>>> lst.append(42)
>>> lst
[1, 2, 3, 4, 5, 6, 99, 42]

В Python обычно есть много способов достичь то же самое. Используя Добавить () Способ добавления элемента к концу списка лучше!

Python INSERT () в отсортированный список

Как вставить элемент в сортированный список (по возрастанию) и сохранить список отсортирован?

Наивный подход – пройти все элементы, от первого до последнего, пока элемент, который будет вставлен, все еще меньше, чем текущий элемент в списке. Как только он больше, вы верните одну позицию и вставьте его там.

Тем не менее, вычислительная сложность алгоритма наивных сортировков является плохой, потому что вам необходимо до n операций, чтобы вставить элемент в список n элементов.

Если вы заинтересованы правильным способом сделать это, вы можете использовать двоичный поиск и list.insert (i, x) Способ вставить элемент х На позиции Я в списке. Вот код для двоичного алгоритма поиска в Python:

def binary_search(lst, value):
    lo, hi = 0, len(lst)-1
    while lo <= hi:
        mid = (lo + hi) // 2
        if lst[mid] < value:
            lo = mid + 1
        elif value < lst[mid]:
            hi = mid - 1
        else:
            return mid
    return -1

    
l = [3, 6, 14, 16, 33, 55, 56, 89]
x = 56
print(binary_search(l,x))
# 6 (the index of the found element)

Не волнуйтесь, если код выглядит немного сложно!

Вы можете найти более подробное обсуждение алгоритма двоичного поиска в моем подробном руководстве по блоге Finxter.

Список Python вставка () несколько элементов

Как вы можете вставить несколько элементов в список? Просто позвоните Вставить () Метод несколько раз – один раз для каждого элемента, который будет вставлен! Но будьте осторожны: вы должны поменять заказ элементов, которые будут вставлены в первую очередь, если вы сохраните постоянную позицию вставки. Вот что я имею в виду:

>>> lst = [1, 2, 3, 4]
>>> insert = [42, 99]
>>> insert.reverse()
>>> for el in insert:
	lst.insert(2, el)

	
>>> lst
[1, 2, 42, 99, 3, 4]

Вы хотите вставить элементы 42 и 99 в положение 2 списка lst , в этой последовательности. Если вы просто проиграете в оба элементах, вы впервые вставляете элемент 42 до индекса 2. Теперь элемент 42 получает положение 2 в списке. Далее вы вставьте элемент 99 перед позицией 2. Теперь элемент 99 получает положение 2 в списке. Таким образом, в основном вы изменили исходный порядок элементов, которые будут вставлены. Поэтому вы должны позвонить в Обратный () Способ сначала перед вставкой элементов в список.

Там действительно нет лучшей альтернативы. Конечно, вы можете использовать конконтрацию списка, но это не так эффективно, потому что вы создадите новый список, а не изменять существующий список:

>>> lst = [1, 2, 3, 4]
>>> insert = [42, 99]
>>> lst = lst[:2] + insert + lst[2:]
>>> lst
[1, 2, 42, 99, 3, 4]

Это может быть более читаемо, но это не так эффективно, потому что Concatenation списка создает новый список каждый раз, когда он используется. Если вам нужно обновить ваши основные навыки нажатия на нарезку Python (например, в операции LST [: 2]), ознакомьтесь с этим подробным руководством блога.

Список Python вставка () сложность

Сложность времени: Вставить () Метод имеет постоянный Сложность времени O (1) Неважно, сколько элементов в списке. Причина в том, что Списки Python реализуются списками массива переменной длины Так что доступ к определенной позиции быстро. Также вставляя элемент в список массива быстро, потому что вам нужно только изменять указатели предыдущих и следующих элементов в списке.

Вставка списка Python () VS PROPEND ()

Разница между Добавить () и Вставить () Метод следующий:

• Приложение (x) Метод добавляет новый элемент х до конца списка и
• Вставить (я, х) Метод добавляет новый элемент х На позиции Я в списке. Он сдвигается все последующие элементы одно положение справа.

Вот пример, показывающий оба Добавить () и Вставить () Методы в действии:

>>> l = [1, 2, 3]
>>> l.append(99)
>>> l
[1, 2, 3, 99]
>>> l.insert(2, 42)
>>> l
[1, 2, 42, 3, 99]

Оба метода помогают вам добавлять новые элементы в список. Но вы можете спросить:

Что быстрее, добавьте () или вставить ()?

Все вещи равны, Добавить () Метод значительно быстрее, чем Вставить () метод.

Вот небольшой сценарий, который показывает, что Добавить () Метод имеет огромное преимущество производительности над Вставить () Метод при создании списка с 100 000 элементов.

import time

l1 = []
l2 = []

t1 = time.time()

for i in range(100000):
    l1.append(i)

t2 = time.time()

for i in range(100000):
    l2.insert(0,i)

t3 = time.time()


print("append(): " + str(t2 - t1) + " seconds")
print("insert(): " + str(t3 - t2) + " seconds")

# OUTPUT:
# append(): 0.015607357025146484 seconds
# insert(): 1.5420396327972412 seconds

Эксперименты проводились на моем ноутбуке с процессором INTEL (R) CORE (TM) I7-8565U 1,8 ГГц (с Turbo Boost до 4,6 ГГц) и 8 ГБ ОЗУ.

Альтернативы: Python List Append () VS Extend ()

Вместо того, чтобы вставлять элемент, вы также можете добавить один элемент до конца списка, используя Добавить () Метод или даже добавление нескольких элементов до конца списка с использованием продлить () метод.

Какая разница?

Я застрелил небольшое видео, объясняя разницу, а какой метод тоже быстрее:

Метод list.append (x) Добавляет элемент х до конца Список Отказ

Метод list.exdend (iTer) Добавляет все элементы в ИТЕР до конца Список Отказ

Разница между Приложение () а также продлевать() Это то, что первое добавляет только один элемент, а последний добавляет коллекцию элементов в список.

Вы можете увидеть это в следующем примере:

>>> l = []
>>> l.append(1)
>>> l.append(2)
>>> l
[1, 2]
>>> l.extend([3, 4, 5])
>>> l
[1, 2, 3, 4, 5]

В коде вы впервые добавляете целочисленные элементы 1 и 2 в список, используя два вызова к Добавить () метод. Затем вы используете метод Extend для добавления трех элементов 3, 4 и 5 в одном вызове продлить () метод.

Какой метод будет быстрее – расширяет () vs plapend ()?

Чтобы ответить на этот вопрос, я написал короткий скрипт, который тестирует производительность выполнения создания крупных списков увеличения размеров с использованием продлить () и Добавить () методы.

Наш тезис в том, что продлить () Метод должен быть быстрее для более крупных размеров списка, потому что Python может добавить элементы в список в список, а не, вызова тот же метод снова и снова.

Я использовал свою ноутбук с процессором INTEL (R) CORE (TM) I7-8565U 1,8 ГГц (с Turbo Boost до 4,6 ГГц) и 8 ГБ ОЗУ.

Затем я создал 100 списков с обоими методами, продлить () и Добавить () , с размерами от 10 000 элементов до 1000 000 элементов. В качестве элементов я просто увеличил целочисленные числа на один, начиная с 0.

Вот код, который я использовал для измерения и сюжета результатов: какой метод быстрее – Добавить () или продлить () ?

import time


def list_by_append(n):
    '''Creates a list & appends n elements'''
    lst = []
    for i in range(n):
        lst.append(n)
    return lst


def list_by_extend(n):
    '''Creates a list & extends it with n elements'''
    lst = []
    lst.extend(range(n))
    return lst


# Compare runtime of both methods
list_sizes = [i * 10000 for i in range(100)]
append_runtimes = []
extend_runtimes = []

for size in list_sizes:

    # Get time stamps
    time_0 = time.time()
    list_by_append(size)
    time_1 = time.time()
    list_by_extend(size)
    time_2 = time.time()

    # Calculate runtimes
    append_runtimes.append((size, time_1 - time_0))
    extend_runtimes.append((size, time_2 - time_1))


# Plot everything
import matplotlib.pyplot as plt
import numpy as np

append_runtimes = np.array(append_runtimes)
extend_runtimes = np.array(extend_runtimes)

print(append_runtimes)
print(extend_runtimes)

plt.plot(append_runtimes[:,0], append_runtimes[:,1], label='append()')
plt.plot(extend_runtimes[:,0], extend_runtimes[:,1], label='extend()')

plt.xlabel('list size')
plt.ylabel('runtime (seconds)')

plt.legend()
plt.savefig('append_vs_extend.jpg')
plt.show()

Код состоит из трех частей высокого уровня:

• В первой части кода вы определяете две функции list_by_append (n) и list_by_extend (n) которые принимают в качестве аргумента в качестве входного аргумента, размер целочисленного списка N и создавать списки последовательно увеличения целочисленных элементов, используя Добавить () и продлить () Методы соответственно.
• Во второй части кода вы сравниваете время выполнения обеих функций, используя 100 различных значений для размера списка N Отказ
• В третьей части кода вы записали все, используя Python Библиотека Matplotlib Отказ

Вот результирующий график, который сравнивает время выполнения двух методов PROPEND () VS EXTEND (). На оси X вы можете увидеть размер списка от 0 до 1 000 000 элементов. На оси Y вы можете увидеть время выполнения в секундах, необходимых для выполнения соответствующих функций.

Полученный график показывает, что оба метода чрезвычайно быстры для нескольких десятков тысяч элементов. На самом деле, они настолько быстро, что Время () Функция модуль времени не может захватить прошедшее время.

Но, когда вы увеличиваете размер списков до сотен тысяч элементов, продлить () Метод начинает выиграть:

Для больших списков с одним миллионом элементов выполнение времени выполнения продлевать() Метод на 60% быстрее, чем время выполнения Приложение () метод.

Причина является уже упомянутой дозированием индивидуальных добавок.

Однако эффект воспроизводится только для очень больших списков. Для небольших списков вы можете выбрать любой метод. Ну, для ясности вашего кода, это все равно имеет смысл предпочтить продлить () над Добавить () Если вам нужно добавить кучу элементов, а не только один элемент.

Список Python INSERT () возвращает нет

Возвращаемое значение Вставить () Метод это Нет Отказ Возвращаемое значение Вставить () Метод не является модифицированным списком с добавленными элементами. Предполагая, что это общий источник ошибок.

Вот такая ошибка, когда кодер ошибочно предположил это:

>>> lst = [1, 2].insert(1, 99)
>>> lst[0]
Traceback (most recent call last):
  File "", line 1, in 
    lst[0]
TypeError: 'NoneType' object is not subscriptable

Это не имеет смысла назначать результат Вставить () метод другой переменной – потому что это всегда Нет Отказ Вместо этого Вставить () Метод изменяет объект списка без создания (и возврата) нового списка.

Вот правильная версия того же кода:

>>> lst = [1, 2]
>>> lst.insert(1, 99)
>>> lst[1]
99

Теперь вы измените сам объект списка, позвонив Вставить () Метод на нем. Вы прочь Нет Возвращаемое значение, потому что он не нужен.

Список Python INSERT () Вернуть новый список

Если вы используете lst.insert (индекс, элемент) Операция, вы добавляете элемент в существующий список lst Отказ Но что, если вы хотите создать новый список, где были добавлены все элементы?

Ответ просто использовать Список конкатенации Операция lst [: index] + [Элемент] + lst [index:] который создает новый список каждый раз, когда он используется. Оригинальный список lst не будет затронута операцией конкатенации списка.

Вот пример, который показывает, что Вставить () Способ изменяет только существующий список:

>>> lst_1 = [1, 2, 3]
>>> lst_2 = lst_1.insert(1, 42)
>>> lst_1
[1, 42, 2, 3]
>>> lst_2
None

И вот пример, который показывает, как создать новый список, вставляющий элемент 42 при индексе 2:

>>> lst_1 = [1, 2, 3]
>>> lst_2 = lst_1[:1] + [42] + lst_1[1:]
>>> lst_1
[1, 2, 3]
>>> lst_2
[1, 42, 2, 3]

Используя операцию ConcateNation List, вы можете создать новый список, а не вставлять элемент в существующий список.

Список Python INSERT () Безопасная резьба

У вас есть несколько потоков, которые одновременно получают доступ к вашему списку? Тогда вы должны быть уверены, что перечисленные операции (такие как вставка () ) на самом деле резьба безопасна Отказ

Другими словами: вы можете позвонить в Вставить () Операция в двух потоках в том же списке одновременно? (И вы можете быть уверены, что результат является значимым?)

Ответ да (если вы используете Mokef Cpython внедрение). Причина – Питона Блокировка глобального интерпретатора Это гарантирует, что поток, работающий в данный момент в этом коде, сначала завершит текущую базовую операцию Python, как определено реализацией CPYPHON. Только если оно завершится с помощью этой операции, сможет получить следующий поток для доступа к вычислительному ресурсу. Это обеспечивается сложной схемой блокировки в результате реализации CPYPHON.

Единственное, что вам нужно знать, состоит в том, что каждая основная операция в реализации CPYPHON является атомный Отказ Он выполнен полностью и сразу, прежде чем любой другой поток имеет возможность запустить на одном виртуальном двигателе. Поэтому нет условий расы. Примером для такого состояния гонки будет следующее: Первый поток считывает значение из списка, вторые потоки перезаписывают значение, и первая тема перезаписывает значение снова недействительным в операции второго потока.

Все операции Cpython являются потоковыми безопасными. Но если вы объединяете эти операции на функции более высокого уровня, это не в целом без резьбы, поскольку они состоят из многих (возможно, чередующихся) операций.

Куда пойти отсюда?

list.insert (индекс, элемент) Метод вставляет элемент до конца Список до данного индекс должность.

Вы узнали INS и ауты этого важного способа списка Python.

Если вы продолжаете бороться с теми основными командами Python, и вы чувствуете застрявшие в своем прогрессе обучения, у меня есть что-то для вас: Python One-listers (Amazon Link).

В книге я дам вам тщательный обзор темы критических компьютерных наук, таких как машинное обучение, регулярное выражение, наука о данных, Numpy и Python Basics – все в одной линейке кода Python!

Получите книгу от Amazon!

Официальная книга Описание: Python One-Listers покажет читателям, как выполнить полезные задачи с одной строкой кода Python. Следуя краткому переподготовку Python, книга охватывает важные продвинутые темы, такие как нарезка, понимание списка, вещание, функции лямбда, алгоритмы, регулярные выражения, нейронные сети, логистические регрессии и др .. Каждая из 50 секций книг вводит проблему для решения, проходит читателя через навыки, необходимые для решения этой проблемы, затем предоставляет краткое однонаправленное решение Python с подробным объяснением.

Работая в качестве исследователя в распределенных системах, доктор Кристиан Майер нашел свою любовь к учению студентов компьютерных наук.

Чтобы помочь студентам достичь более высоких уровней успеха Python, он основал сайт программирования образования Finxter.com Отказ Он автор популярной книги программирования Python One-listers (Nostarch 2020), Coauthor of Кофе-брейк Python Серия самооставленных книг, энтузиаста компьютерных наук, Фрилансера и владелец одного из лучших 10 крупнейших Питон блоги по всему миру.

Его страсти пишут, чтение и кодирование. Но его величайшая страсть состоит в том, чтобы служить стремлению кодер через Finxter и помогать им повысить свои навыки. Вы можете присоединиться к его бесплатной академии электронной почты здесь.