Вывести последовательность чисел python

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

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

Для хранения таких данных можно использовать структуру данных, называемую в Питоне список (в большинстве же языков программирования используется другой термин “массив”). Список представляет собой последовательность элементов, пронумерованных от 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 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 .

Обратите внимание, A[i] — это элемент списка, а не срез!

Источник

/привет/мир/etc

Непериодические заметки о программировании

суббота, 14 апреля 2018 г.

Работа с последовательностями в Python 3

Ниже обзор возможностей и приемов работы с последовательностями в 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.

Источник

Вывести последовательность чисел python

Числовые последовательности для цикла for в Python.

Запуск for произвольное число раз