Операции над последовательностями

Ниже перечислены операторы, которые могут применяться к разным типам последовательностей, включая строки, списки и кортежи:

s + r Объединение

s * n, n * s  Умножение - создает n копий последовательности s

v1,v2..., vn = s Распаковывание последовательности в переменные(множественное присваивание)

s[i] Обращение к элементу по индексу

s[i:j] Получение среза

s[i:j:step] Получение среза с шагом step

x in s, x not in s Проверка на вхождение

for x in s: Цикл по элементам последовательности

all(s) Возвращает True, если все элементы последовательности s оцениваются, как истинные

any(s) Возвращает True, если хотя бы один элемент последовательности s оценивается, как истинный

len(s) Длина последовательности

min(s) Минимальный элемент в последовательности s

max(s) Максимальный элемент в последовательности s

sum(s [, initial]) Сумма элементов последовательности с необязательным начальным значением.

Оператор + объединяет две последовательности одного и того же типа.

Оператор s * n создает n копий последовательности s.

Копирование последовательностей следует рассмотреть отдельно.

Методы последовательностей

См. Функции и методы списков

Копирование последовательностей

Особенность копирования состоит в том, что последовательности хранятся в памяти как массивы ссылок (указателей) на объекты. Поэтому при копировании последовательностей копируются только ссылки (указатели) на элементы. Сами элементы не копируются!

Выполним пример:

a=list(range(0,8,1))

b=a

c=list(b)

a[4]=15

print ('a=',a)

print ('b=',b)

print ('c=',c)

В результате получим

a= [0, 1, 2, 3, 15, 5, 6, 7]

b= [0, 1, 2, 3, 15, 5, 6, 7]

c= [0, 1, 2, 3, 4, 5, 6, 7]

Таким образом, список b оказался буквальной копией списка a, то есть списком указателей на те же самые ячейки в памяти. Список c, созданный с помощью функции создания списка, c=list(b) представляет собой новую и независимую от a структуру данных.

 В качестве иллюстрации умножения списков рассмотрим следующий пример.

Получим списки b и c из списка a c помощью операции умножения, и изменим третий элемент исходного списка:

a=[0, 1, 2]

b=[a]*2

c=a*2

a[2]=15# изменим третий элемент исходного списка

print ('a=',a)

print ('b=',b)

print ('c=',c)

В результате получим

a= [0, 1, 15]

b= [[0, 1, 15], [0, 1, 15]]

c= [0, 1, 2, 0, 1, 2]

Обратите внимание, что изменения списка a коснулись сразу нескольких элементов в списке списка b, но не коснулись элементов списка c. Это связано с тем, что спискиaи b содержали ссылки (указатели) на одну и ту же область памяти.

Один из способов ликвидировать эту проблему состоит в том, чтобы вручную создать копируемую последовательность, продублировав содержимое списка a с помощью операции list(a):

a = [0, 1, 2]

b = [list(a) for j in range(2)] # Функция list() создает копию списка

Кроме того, для копирования объектов можно также использовать функцию copy из стандартной библиотеки.

Распаковывание последовательностей

Это (с некоторым преувеличением) уникальная возможность Python.

Распаковкой называется множественное поэлементное присваивание значений нескольким переменным через оператор присваивания "=". При этом в левой части стоит несколько переменных, а в правой – последовательность значений.

Например:

items = [3, 4, 5]

x,y,z = items

# x = 3, y = 4, z = 5

 

letters = "abc"

x,y,z = letters

# x = ‘a’, y = ‘b’, z = ‘c’

 

datetime = ((5, 19,2008), (10, 30,"am"))

(month,day,year),(hour,minute,am_pm)= datetime

Все перечисляемые типы могут быть распакованы.

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

Упаковка и распаковка аргументов функции

Осуществляется с помощью оператора ‘*’:

def summ(*elements):

#здесь эти элементы автоматически упакуются в кортеж

result = 0

 

for element in elements:

   result += element

 

return result

 

#передаем три элемента в функцию

print (summ(1, 2, 3))

 

mas = [1, 2, 3, 4, 5]

summ(*mas) #такой вызов эквивалентен вызову summ(1, 2, 3, 4, 5)