В качестве продолжения к Python: Массивы и списки (Часть 1). В данной части будут рассмотрены:

• Изменение массивов
• Поиск в списках (массивах)

Изменение массивов:

В списках можно устанавливать индивидуальные значения или куски. Под куском, обрубком или отрезком я понимаю какой либо кусок массива. Как пример со второго по пятый элемент. Ну, как-то так, привыкайте. =) А еще можно удалять отдельные элементы.

L[i] = obj
L[i:j] = sequence

Заметьте, что операции, которые изменяют списки должны изменять их тут же. Имеется в виду то, что если Вы имеете несколько переменных, указывающих на один и тот же список, то все они будут изменены одновременно.

L = []
M = L[:] # создаем копию
# Изменяем только список L
L.append(obj)

Вы так же можете добавить записей в существующую последовательность. Функция append добавляет одну запись в конец списка, extend добавляет строку из другого списка или выражения в конец списка и, наконец, insert добавляет строку по указаному индексу.

L.append(item)
L.extend(sequence)
L.insert(index, item)

Для того, что бы вставить группу записей надо делать так:

L[index:index] = sequence

Так же можно удалять определенные позиции списка с помощью команды del. Так же есть метод pop, он в свою очередь, не просто удаляет элемент по его номеру, но перед этим возвращает его значение. А для того, что бы удалить элемент по его содержанию (с использованием поиска) надо использовать функцию remove.

del L[i]
del L[i:j]
item = L.pop() # последний элемент
item = L.pop(0) # первый элемент
item = L.pop(index)
L.remove(item)

По сути del и pop делают одно и то же. Но pop возвращает значение удалемой переменной. Вот и вся разница.

Разумеется, в Python можно легко и просто развернуть массив задом на перед. Вот так:

L.reverse()

Обратите внимание на то, что for-in работает по внутренним индексам, который увеличивается на каждой итерации цикла. Это означает, что если Вы измените список индексы могут рассинхронизоваться. Это может привести к тому, что по одному и тому же элементу цикл может пройтись несколько раз. Что бы этого избежать можно создать цикл с копией списка.

for object in L[:]:
    if not condition:
        del L[index]

Как альтернативный вариант: Вы можете создать новый список и аппендить его.

out = []
for object in L:
    if condition:
        out.append(object)

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

for index, object in enumerate(L):
    L[index] = function(object)
 
out = []
for object in L:
    out.append(function(object))

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

out = map(function, L)
 
out = [function(object) for object in L]

Для простых вызовов функций, map является более эффективным, так как функция объекта должна сработать лишь раз. Для других конструкций (например, выражения или вызовы методов объектов), Вам придется использовать функцию обратного вызова (callback) или lambda; в таких случаях, список понимании является более эффективной, и обычно легче читать.

Опять же, сли Вам нужен и индекс и значение, то следует использовать enumerate:

out = [function(index, object) for index, object in enumerate(L)]

Вы можете использовать список типов для осуществления простых структур данных, таких как стеки и очереди.

stack = []
stack.append(object) # кладем
object = stack.pop() # берем с конца
 
queue = []
queue.append(object) # кладем
object = queue.pop(0) # берем с начала

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

Еще структура данных, для которой список хорошо работает на практике, до тех пор, пока структура достаточно мала, является LRU (last-recently-used) контейнер. Такая схема перемещает объект в конец списка:

lru.remove(item)
lru.append(item)

Поиск в списках:

Оператор in может быть использован для проверки нахождения элемента в списке:

if value in L:
    print "list contains", value

Для получения индекса первого совпавшего элемента используйте оператор index():

i = L.index(value)

Оператор index() производит линейный поиск по всему массиву и останавливается на первом совпавшем пункте. Если же элемента, который Вы ищите, нет в списке, то возникнет исключение ValueError:

try:
    i = L.index(value)
except ValueError:
    i = -1 # совпадений небыло

Для получения индексов всех совпадающих элементов, следует использовать цикл:

i = -1
try:
    while 1:
        i = L.index(value, i+1)
        print "match at", i
except ValueError:
    pass

Если переместить цикл в функцию-помощник, будет проще пользоваться:

def findall(L, value, start=0):
    i = start - 1
    try:
        i = L.index(value, i+i)
        yield i
    except ValueError:
        pass
 
for index in findall(L, value):
    print "match at", i

Для того, что бы узнать количество совпадений используйте функцию count():

n = L.count(value)

Помните, что count будет пробегаться по всему списку, поэтому, если Вам надо всего лишь узнать о наличии нужного элемента в списке, то используйте in, или, где возможно, index.

Для получения наименьшего или наибольшего значения в списке используйте min и max методы:

lo = min(L)
hi = max(L)

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

lo = min(L, key=int)
hi = max(L, key=int)

В следующей части:

• Сортировка списков
• Печать списков
• Заметки о производительности