Числовые последовательности для цикла for в Python.
Если вам нужно перебрать последовательность чисел, в этом вам поможет встроенная функция range() . Эта функция генерирует арифметические прогрессии:
В примере выше, указанный аргумент range() число 5 — конечная точка, никогда не является частью сгенерированной последовательности. Например, range(10) генерирует 10 значений, для элементов последовательности длиной 10, проще для понимания от 0 до 9. В классе range() можно менять диапазон, указывая начальное значение, отличное от 0 или указать другое приращение последовательности (задать "шаг"), даже отрицательное:
Чтобы перебрать индексы последовательности, вы можете комбинировать range() ]f-range и len() следующим образом:
В большинстве таких случаев удобно использовать функцию enumerate() .
Странная вещь происходит, если вы просто распечатаете range(10) :
Во многих отношениях возвращаемый объект range() ведет себя так, как будто это список, но на самом деле range() не создает список. Это объект, который возвращает элементы желаемой последовательности, только тогда, когда вы выполняете итерацию, тем самым экономя оперативную память.
Мы говорим, что такой объект является итеративным, то есть пригодным для функций или конструкции, которые ожидают что-то, из чего они могут получать последовательные элементы до тех пор, пока они не закончатся. Выше мы видели, что оператор for является такой конструкцией, а примером функции принимающей итеративный объект, является sum() :
Позже мы увидим больше функций, которые возвращают итерируемые значения и принимают их как аргументы. И наконец, может быть, вам интересно, как получить список list() из диапазона range ?
Как вывести последовательность чисел в питоне
Большинство программ работает не с отдельными переменными, а с набором переменных. Например, программа может обрабатывать информацию об учащихся класса, считывая список учащихся с клавиатуры или из файла, при этом изменение количества учащихся в классе не должно требовать модификации исходного кода программы.
Раньше мы сталкивались с задачей обработки элементов последовательности, например, вычисляя наибольший элемент последовательности. Но при этом мы не сохраняли всю последовательность в памяти компьютера. Однако, во многих задачах нужно именно сохранять всю последовательность, например, если бы нам требовалось вывести все элементы последовательности в возрастающем порядке (“отсортировать последовательность”).
Для хранения таких данных можно использовать структуру данных, называемую в Питоне список (в большинстве же языков программирования используется другой термин “массив”). Список представляет собой последовательность элементов, пронумерованных от 0, как символы в строке. Список можно задать перечислением элементов списка в квадратных скобках, например, список можно задать так:
В списке Primes — 6 элементов, а именно: Primes[0] == 2 , Primes[1] == 3 , Primes[2] == 5 , Primes[3] == 7 , Primes[4] == 11 , Primes[5] == 13 . Список Rainbow состоит из 7 элементов, каждый из которых является строкой.
Длину списка, то есть количество элементов в нем, можно узнать при помощи функции len , например, len(Primes) == 6 .
В отличие от строк, элементы списка можно изменять, присваивая им новые значения.
Рассмотрим несколько способов создания и считывания списков. Прежде всего, можно создать пустой список (не содержащий элементов, длины 0), а в конец списка можно добавлять элементы при помощи метода append . Например, пусть программа получает на вход количество элементов в списке n , а потом n элементов списка по одному в отдельной строке. Вот пример входных данных в таком формате:
В этом примере создается пустой список, далее считывается количество элементов в списке, затем по одному считываются элементы списка и добавляются в его конец. То же самое можно записать, сэкономив переменную n :
Для списков целиком определены следующие операции: конкатенация списков (сложение списков, т. е. приписывание к одному списку другого) и повторение списков (умножение списка на число). Например:
В результате список c будет равен [1, 2, 3, 4, 5] , а список d будет равен [4, 5, 4, 5, 4, 5] . Это позволяет по-другому организовать процесс считывания списков: сначала считать размер списка и создать список из нужного числа элементов, затем организовать цикл по переменной i начиная с числа 0 и внутри цикла считывается i -й элемент списка:
Вывести элементы списка a можно одной инструкцией print(a) , при этом будут выведены квадратные скобки вокруг элементов списка и запятые между элементами списка. Такой вывод неудобен, чаще требуется просто вывести все элементы списка в одну строку или по одному элементу в строке. Приведем два примера, также отличающиеся организацией цикла:
Здесь в цикле меняется индекс элемента i , затем выводится элемент списка с индексом i .
В этом примере элементы списка выводятся в одну строку, разделенные пробелом, при этом в цикле меняется не индекс элемента списка, а само значение переменной (например, в цикле for elem in [‘red’, ‘green’, ‘blue’] переменная elem будет последовательно принимать значения ‘red’ , ‘green’ , ‘blue’ .
Последовательностями в Питоне являются строки, списки, значения функции range() (это не списки), и ещё кое-какие другие объекты.
Приведем пример, демонстрирующий использование цикла for в ситуации, когда из строки надо выбрать все цифры и сложить их в массив как числа.
2. Методы split и join
Элементы списка могут вводиться по одному в строке, в этом случае строку целиком можно считать функцией input() . После этого можно использовать метод строки split() , возвращающий список строк, которые получатся, если исходную строку разрезать на части по пробелам. Пример:
Если при запуске этой программы ввести строку 1 2 3 , то список a будет равен [‘1’, ‘2’, ‘3’] . Обратите внимание, что список будет состоять из строк, а не из чисел. Если хочется получить список именно из чисел, то можно затем элементы списка по одному преобразовать в числа:
Используя специальную магию Питона — генераторы — то же самое можно сделать в одну строку:
Объяснение того, как работает этот код, будет дано в следующем разделе. Если нужно считать список действительных чисел, то нужно заменить тип int на тип float .
У метода split() есть необязательный параметр, который определяет, какая строка будет использоваться в качестве разделителя между элементами списка. Например, вызов метода split(‘.’) вернет список, полученный разрезанием исходной строки по символам ‘.’ :
В Питоне можно вывести список строк при помощи однострочной команды. Для этого используется метод строки join . У этого метода один параметр: список строк. В результате возвращается строка, полученная соединением элементов переданного списка в одну строку, при этом между элементами списка вставляется разделитель, равный той строке, к которой применяется метод. Мы знаем, что вы не поняли предыдущее предложение с первого раза. Поэтому смотрите примеры:
Если же список состоит из чисел, то придется использовать еще тёмную магию генераторов. Вывести элементы списка чисел, разделяя их пробелами, можно так:
Впрочем, если вы не любитель тёмной магии, то вы можете достичь того же эффекта, используя цикл for .
3. Генераторы списков
Для создания списка, заполненного одинаковыми элементами, можно использовать оператор повторения списка, например:
Для создания списков, заполненных по более сложным формулам можно использовать генераторы: выражения, позволяющие заполнить список некоторой формулой. Общий вид генератора следующий:
где переменная — идентификатор некоторой переменной, последовательность — последовательность значений, который принимает данная переменная (это может быть список, строка или объект, полученный при помощи функции range ), выражение — некоторое выражение, как правило, зависящее от использованной в генераторе переменной, которым будут заполнены элементы списка.
Вот несколько примеров использования генераторов.
Создать список, состоящий из n нулей можно и при помощи генератора:
Создать список, заполненный квадратами целых чисел можно так:
Если нужно заполнить список квадратами чисел от 1 до n , то можно изменить параметры функции range на range(1, n + 1) :
Вот так можно получить список, заполненный случайными числами от 1 до 9 (используя функцию randrange из модуля random ):
А в этом примере список будет состоять из строк, считанных со стандартного ввода: сначала нужно ввести число элементов списка (это значение будет использовано в качестве аргумента функции range ), потом — заданное количество строк:
4. Срезы
Со списками, так же как и со строками, можно делать срезы. А именно:
A[i:j] срез из j-i элементов A[i] , A[i+1] , . A[j-1] .
A[i:j:-1] срез из i-j элементов A[i] , A[i-1] , . A[j+1] (то есть меняется порядок элементов).
A[i:j:k] срез с шагом k : A[i] , A[i+k] , A[i+2*k] . . Если значение k <0, то элементы идут в противоположном порядке.
Каждое из чисел i или j может отсутствовать, что означает “начало строки” или “конец строки”
Списки, в отличии от строк, являются изменяемыми объектами: можно отдельному элементу списка присвоить новое значение. Но можно менять и целиком срезы. Например:
Получится список, у которого вместо двух элементов среза A[2:4] вставлен новый список уже из трех элементов. Теперь список стал равен [1, 2, 7, 8, 9, 5] .
Получится список [40, 2, 30, 4, 20, 6, 10] . Здесь A[::-2] — это список из элементов A[-1] , A[-3] , A[-5] , A[-7] , которым присваиваются значения 10, 20, 30, 40 соответственно.
Если не непрерывному срезу (то есть срезу с шагом k , отличному от 1), присвоить новое значение, то количество элементов в старом и новом срезе обязательно должно совпадать, в противном случае произойдет ошибка ValueError .
/привет/мир/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.