Последовательности в Python
Последовательность — это коллекция, элементы которого представляют собой некую последовательность.
На любой элемент последовательности можно ссылаться, используя его индекс, например, s[0] и s[1] .
Индексы последовательности начинаются с 0, а не с 1. Поэтому первый элемент — s[0] , а второй — s[1] . Если последовательность s состоит из n элементов, то последним элементом будет s[n-1] .
В Python есть встроенные типы последовательностей: списки, байтовые массивы, строки, кортежи, диапазоны и байты. Последовательности могут быть изменяемыми и неизменяемыми.
Изменяемые: списки и байтовые массивы, неизменяемые: строки, кортежи, диапазоны и байты.
Последовательность может быть однородной или неоднородной. В однородной последовательности все элементы имеют одинаковый тип. Например, строки — это однородные последовательности, поскольку каждый элемент строки — символ — один и тот же тип.
А списки — неоднородные последовательности, потому что в них можно хранить элементы различных типов, включая целые числа, строки, объекты и т.д.
Примечание. C точки зрения хранения и операций однородные типы последовательностей более эффективны, чем неоднородные.
Последовательности и итерируемые объекты: разница
Итерируемый объект (iterable) — это коллекция объектов, в которой можно получить каждый элемент по очереди. Поэтому любая последовательность является итерируемой. Например, список — итерируемый объект.
Однако итерируемый объект может не быть последовательностью. Например, множество является итерируемым объектом, но не является последовательностью.
Примечание. Итерируемые объекты — более общий тип, чем последовательности.
Стандартные методы последовательностей
Ниже описаны некоторые встроенные в Python методы последовательностей:
1) Количество элементов последовательности
Чтобы получить количество элементов последовательности, можно использовать встроенную функцию len() :
Пример
Вывод
2) Проверка вхождения элемента в последовательность
Чтобы проверить, находится ли элемент в последовательности, можно использовать оператор in :
Пример 1
Проверим, есть ли ‘Новосибирск’ в последовательности cities .
Вывод
Чтобы проверить, отсутсвует ли элемент в последовательности, используется оператор not in .
Пример 2
Проверим, отсутсвует ли ‘Новосибирск’ в последовательности cities .
Вывод
3) Поиска индекса элемента в последовательности
Чтобы узнать индекс первого вхождения определенного элемента в последовательности, используется метод index() .
Пример 1
Вывод
Индекс первого появления числа 5 в списке numbers — 2. Если числа в последовательности нет, Python сообщит об ошибке:
Вывод
Чтобы найти индекс вхождения элемента после определенного индекса, можно использовать метод index() в таком виде:
Пример 2
В следующем примере возвращается индекс первого вхождения числа 5 после третьего индекса:
Вывод
Чтобы найти индекс вхождения элемента между двумя определенными индексами, можно использовать метод index() в такой форме:
Поиск элемента будет осуществляться между i и j .
Пример 3
Вывод
4) Слайсинг последовательности
Чтобы получить срез от индекса i до индекса j (не включая его), используйте следующий синтаксис:
Пример 1
Вывод
Когда вы «слайсите» последовательность, представляйте, что индексы последовательности располагаются между двумя элементами, как показано на рисунке:
Расширенный слайсинг позволяет получить срез последовательности от индекса i до j (не включая его) с шагом k :
Пример 2
Вывод
5) Получение максимального и минимального значений из последовательности
Если задан порядок между элементами в последовательности, можно использовать встроенные функции min() и max() для нахождения минимального и максимального элементов:
6) Объединение (конкатенация) последовательностей
Чтобы объединить две последовательности в одну, используется оператор + :
Пример
Вывод
Неизменяемые последовательно объединять безопасно. В следующем примере мы доблавяем один элемент к списку west . И это не влияет на последовательность cities :
Вывод
Однако когда вы работаете с изменяемыми последовательностями, стоит быть внимательными. . В следующем примере показано, как объединить список самого с собой.
Вывод
Поскольку список является изменяемой последовательностью, адреса памяти первого и второго элементов из списка citites одинаковы:
Кроме того, при изменении значения из исходного списка изменяется и объединенный список:
Соберем все вместе:
Вывод
7) Повторение последовательности
Чтобы повторить последовательность несколько раз, используется оператор умножения * .
/привет/мир/etc
Ниже обзор возможностей и приемов работы с последовательностями в Python 3, включая следующие темы (но не ограничиваясь ими):
- задание последовательностей,
- доступ к элементам последовательности для чтения и изменения,
- методы, общие для последовательностей,
- преобразования последовательностей,
- агрегирование элементов последовательности.
Последовательности конструируются явно, с помощью литерала или другой последовательности, или аналитически, с помощью итератора или генератора. Примеры явно заданных последовательностей:
Список ( list ) и массив байтов ( bytearray ) — изменяемые последовательности, кортеж ( tuple ), строка ( str ) и строка байтов ( bytes ) — неизменяемые.
Примеры последовательностей, построенных с помощью итератора, предоставленного функцией range() :
Функция range() также позволяет задать шаг, в том числе отрицательный:
Генератор — это объект класса generator , который Python автоматически создает при вызове функции c предложением yield внутри:
Каждый генератор — это итератор, так что можно инициализировать последовательность с его помощью:
Элементы всякой последовательности доступны по индексу, причем
- индексирование от начала последовательности начинается с 0 и заканчивается числом, равным длине последовательности минус один, а
- индексирование с конца начинается с -1 и заканчивается отрицательным числом, равным длине последовательности.
Замечательной возможностью является срез ( slice ), позволяющий из исходной последовательности получить подпоследовательность, задаваемую начальным и конечным индексами и (опционально) шагом. В сущности, срез — это фильтр по индексу, порождающий из исходной последовательности новую:
В последнем примере последовательность обращается. Обращение последовательности нагляднее всего продемонстрировать на строке:
Срез без ограничений с двух сторон включает все элементы исходной последовательности и создает ее копию:
Само собой, срез позволяет получить копию только изменяемой последовательности, а в случае с неизменяемой последовательностью возвращает ее саму:
Если срез последовательности используется слева от знака присваивания, то семантика совсем другая: вместо создания новой последовательности выполняется замена элементов среза на значение справа от знака присваивания:
При использовании среза с шагом, каждому значению среза должно соответствовать значение справа от знака присваивания, иначе возникает ошибка:
Следующая таблица представляет операции и методы, общие для всех последовательностей Python:
| Операция | Описание | Работает с range ? |
|---|---|---|
| x in s | True, если в s есть элемент, равный x, иначе False | да |
| x not in s | False, если в s нет элемента, равного x, иначе True | да |
| s + t | конкатенация s и t | |
| s * n или n * s | конкатенация s с собой n раз | |
| s[i] | i-ый элемент s, считая с 0 | да |
| s[i:j] | срез s от i до j | да |
| s[i:j:k] | срез s от i до j с шагом k | да |
| len(s) | длина s | да |
| min(s) | наименьший элемент s | да |
| max(s) | наибольший элемент s | да |
| s.index(x[, i[, j]]) | индекс первого вхождения x в s (начиная с i и заканчивая j) | да |
| s.count(x) | всего вхождений x в s | да |
Операции in и not in для строк и строк байтов способны проверить вхождение не только отдельных элементов, но и подпоследовательностей из нескольких элементов:
Для других последовательностей проверятся вхождение ровно одного элемента:
Конкатенация создает новую последовательность, содержащую элементы исходных последовательностей:
Тип range можно рассматривать как неизменяемую последовательность с некоторыми ограничениями на общие операции. Так, нельзя сложить (конкатенировать) два объекта range или умножить объект range на целое число, зато объект range можно индексировать, срезать, проверять вхождение в него значений.
Если срез, или slice — это фильтр по индексам, то встроенная функция filter() позволяет отфильтровать элементы последовательности по их значениям с помощью заданной функции (обычно лямбда):
Встроенная функция map() позволяет получить новую последовательность из исходной путем замены каждого элемента на значение, вычисленное с помощью заданной функции (обычно лямбда):
Композиция filter() и map() позволяет и отфильтровать элементы по значению и получить новые значения из исходных:
Конструкция list comprehension (как это по-русски?) может работать как filter() , map() или их комбинация:
А следующий фрагмент демонстрирует, как с помощью list comprehension и метода count() найти повторяющиеся элементы в последовательности:
List comprehension поддерживает вложенность как циклов, так и условий:
Последнее предложение эквивалентно следующему фрагменту:
Вложенные условия в list comprehension эквивалентны составному условию с оператором and или вложенным if внутри цикла:
Если list comprehension немедленно порождает список (объект класса list ), то генераторное выражение, заключенное, в отличие от list comprehension, в обычные скобки ( и ) , порождает генератор, который будет возвращать элементы последовательности, когда они понадобятся:
От list comprehension генераторное выражение отличается только ленивым предоставлением элементов последовательности, в остальном поддерживая синтаксис и семантику list comprehension. Для передачи генераторного выражения в качестве аргумента функции достаточно одной пары скобок:
Встроенные функции max() , min() и sum() возвращают максимальное, минимальное значение и сумму элементов последовательности, соответственно. Вместо готовой последовательности эти функции принимают также итерируемые объекты:
Что если нужно найти не сумму, а произведение элементов? Или сумму их квадратов? С этим нам поможет функция reduce() из модуля functools :
Здесь первый параметр x лямбда-функции есть аккумулятор, в котором накапливается результат вычисления, а второй параметр y — каждый следующий элемент последовательности. Перед началом вычисления аккумулятору присваивается значение первого элемента. Если же необходимо использовать другое начальное значение, то оно передается третьим аргументом:
Мы удвоили каждую букву в слове, но без третьего аргумента этого бы сделать не удалось:
Теперь посчитаем сумму квадратов элементов списка a , инициализировав аккумулятор нулем:
Еще две встроенные функции, сводящие последовательность к единственному значению, — это any() и all() , возвращающие булевы значения.
Функция any() возвращает True , если хотя бы один из элементов последовательности оценивается как True , иначе — возвращает False . Функция all() возвращает True , если все элементы последовательности оцениваются как True , иначе — False . С помощью этих функций и генераторного выражения легко проверить, удовлетворяют ли элементы последовательности некоторому условию:
Циклы, list comprehension и генераторное выражение позволяют обходить все элементы последовательности. А для параллельного обхода нескольких последовательностей — двух и более — Python предлагает функцию zip() :
Функция zip() завершает работу по концу самой короткой из последовательностей:
Если необходимо дойти до конца самой длинной из последовательностей, то нужно воспользоваться функцией zip_longest() из модуля itertools :
Вместо None на месте отсутствующих элементов можно получить значение, заданное с помощью именованного параметра fillvalue :
В завершение обзора, приведу операции и методы, общие для изменяемых последовательностей, то есть, для list и bytearray :
| Операция | Описание |
|---|---|
| s[i] = x | замена i-го элемента s на x |
| del s[i] | удаление i-го элемента из s |
| s[i:j] = t | замена среза s от i до j на содержимое t |
| del s[i:j] | то же, что и s[i:j] = [] |
| s[i:j:k] = t | замена элементов s[i:j:k] на элементы t |
| del s[i:j:k] | удаление элементов s[i:j:k] из s |
| s.append(x) | добавление x в конец последовательности (эквивалентно s[len(s):len(s)] = [x] ) |
| s.clear() | удаление всех элементов из s (эквивалентно del s[:] ) |
| s.copy() | создание поверхностной копии s (эквивалентно s[:] ) |
| s.extend(t) или s += t |
расширяет s содержимым t |
| s *= n | обновляет s его содержимым, повторенным n раз |
| s.insert(i, x) | вставляет x в s по индексу i (эквивалентно s[i:i] = [x] ) |
| s.pop([i]) | извлекает элемент с индексом i и удаляет его из s |
| s.remove(x) | удаляет первое вхождение x в s |
| s.reverse() | меняет порядок элементов в s на обратный |
Часть перечисленных операций и методов были продемонстрированы в действии, другие ждут ваших экспериментов с ними.
Это был (неисчерпывающий) обзор возможностей и приемов работы с последовательностями в Python 3.
Проверить список на непрерывное возрастание чисел и получить [дубликат]
Создавал предыдущий вопрос но не совсем уточнил точные действия. И так у нас есть список из чисел:
Нам требуется проверить, если в этом списке есть 5 чисел которые нарастают непрерывно, то есть — 1, 2, 3, 4, 5, а так же вывести то число до какого идет непрерывное возрастание, в нашем случае 5 Так же списки могут быть разными, к примеру у нас будет такой список:
Тут мы видим что нарастание идет уже из 8 цифр, нам требовалось проверить наростают ли 5 цифр, в этом случае мы должны получить что непрерывно наростают у нас 3,4,5,6,7 (то есть получаем максимальное число)
Как проверить последовательность чисел в Питоне
Потребовалось проверить последовательность чисел в таблице: надо было, чтобы они были последовательны (проверка работы прошлого скрипта, на самом деле). То есть 001, 002, 003, 004… и так далее — чтобы найти строки в таблице, где последовательность сбивается. Таблица большая, больше 1000 строк — оттого проверять вручную неудобно, и можно ошибиться. Поскольку среда выполнения Питона у меня уже настроена, решил, что самым быстрым и простым решением будет написать короткую программу на нем.