Массивы
Элементы списка могут вводиться по одному в строке, в этом случае строку можно считать функцией input(). После этого можно использовать метод строки split, возвращающий список строк, разрезав исходную строку на части по пробелам. Пример:
A = input().split()
Если при запуске этой программы ввести строку 1 2 3, то список A будет равен [‘1’, ‘2’, ‘3’]. Обратите внимание, что список будет состоять из строк, а не из чисел. Если хочется получить список именно из чисел, то можно затем элементы списка по одному преобразовать в числа:
for i in range(len(A)):
A[i] = int(A[i])
Используя функции языка map и list то же самое можно сделать в одну строку:
A = list(map(int, input().split()))
Объяснений, как работает этот код, пока не будет. Если нужно считать список действительных чисел, то нужно заменить тип int на тип float.
У метода split есть необязательный параметр, который определяет, какая строка будет использоваться в качестве разделителя между элементами списка. Например, метод split(‘.’) вернет список, полученный разрезанием исходной строки по символам ‘.’.
Используя “обратные” методы можно вывести список при помощи однострочной команды. Для этого используется метод строки join. У этого метода один параметр: список строк. В результате получается строка, полученная соединением элементов списка (которые переданы в качестве параметра) в одну строку, при этом между элементами списка вставляется разделитель, равный той строке, к которой применяется метод. Например программа
A = ['red', 'green', 'blue']
print(' '.join(A))
print(''.join(A))
print('***'.join(A))
выведет строки ‘red green blue’, redgreenblue и red***green***blue.
Если же список состоит из чисел, то придется использовать еще и функцию map. То есть вывести элементы списка чисел, разделяя их пробелами, можно так:
print(' '.join(map(str, A)))
Многомерные списки
Часто в задачах приходится хранить прямоугольные таблицы с данными. Такие таблицы называются матрицами или двумерными массивами. В языке программирования Питон таблицу можно представить в виде списка строк, каждый элемент которого является в свою очередь списком, например, чисел. Например, создать числовую таблицу из двух строк и трех столбцов можно так:
a = [[1, 2, 3], [4, 5, 6]]
Здесь первая строка списка a[0] является списком из чисел [1, 2, 3] . То есть a[0][0] == 1 , значение a[0][1] == 2 , a[0][2] == 3 , a[1][0] == 4 , a[1][1] == 5 , a[1][2] == 6 .
Для обработки и вывода списка как правило используется два вложенных цикла. Первый цикл по номеру строки, второй цикл по элементам внутри строки. Например, вывести двумерный числовой список на экран построчно, разделяя числа пробелами внутри одной строки, можно так:
for i in range(len(a)): for j in range(len(a[i])): print(a[i][j], end=' ') print()
То же самое, но циклы не по индексу, а по значениям списка:
for row in a: for elem in row: print(elem, end=' ') print()
Естественно для вывода одной строки можно воспользоваться методом join :
for row in a: print(' '.join(map(str, row)))
Используем два вложенных цикла для подсчета суммы всех чисел в списке:
s = 0 for i in range(len(a)): for j in range(len(a[i])): s += a[i][j]
Или то же самое с циклом не по индексу, а по значениям строк:
s = 0 for row in a: for elem in row: s += elem
Создание списка
Пусть даны два числа: количество строк n и количество столбцов m . Необходимо создать список размером n × m , заполненный нулями.
Очевидное решение оказывается неверным:
a = [[0] * m] * n
В этом легко убедиться, если присвоить элементу a[0][0] значение 1 , а потом вывести значение другого элемента a[1][0] — оно тоже будет равно 1! Дело в том, что [0] * m возвращает ccылку на список из m нулей. Но последующее повторение этого элемента создает список из n элементов, которые являются ссылкой на один и тот же список (точно так же, как выполнение операции b = a для списков не создает новый список), поэтому все строки результирующего списка на самом деле являются одной и той же строкой.
Таким образом, двумерный список нельзя создавать при помощи операции повторения одной строки. Что же делать?
Первый способ: сначала создадим список из n элементов (для начала просто из n нулей). Затем сделаем каждый элемент списка ссылкой на другой одномерный список из m элементов:
a = [0] * n for i in range(n): a[i] = [0] * m
Другой (но похожий) способ: создать пустой список, потом n раз добавить в него новый элемент, являющийся списком-строкой:
a = [] for i in range(n): a.append([0] * m)
Но еще проще воспользоваться генератором: создать список из n элементов, каждый из которых будет списком, состоящих из m нулей:
a = [[0] * m for i in range(n)]
В этом случае каждый элемент создается независимо от остальных (заново конструируется список [0] * m для заполнения очередного элемента списка), а не копируются ссылки на один и тот же список.
Ввод списка
Пусть программа получает на вход двумерный массив, в виде n строк, каждая из которых содержит m чисел, разделенных пробелами. Как их считать? Например, так:
a = [] for i in range(n): a.append(list(map(int, input().split())))
Или, без использования сложных вложенных вызовов функций:
a = [] for i in range(n): row = input().split() for i in range(len(row)): row[i] = int(row[i]) a.append(row)
Можно сделать то же самое и при помощи генератора:
a = [list(map(int, input().split())) for i in range(n)]
Сложный пример обработки массива
Пусть дан квадратный массив из n строк и n столбцов. Необходимо элементам, находящимся на главной диагонали, проходящей из левого верхнего угла в правый нижний (то есть тем элементам a[i][j] , для которых i == j ) присвоить значение 1 , элементам, находящимся выше главной диагонали – значение 0, элементам, находящимся ниже главной диагонали – значение 2. То есть получить такой массив (пример для n==4 ):
1 0 0 0 2 1 0 0 2 2 1 0 2 2 2 1
Рассмотрим несколько способов решения этой задачи. Элементы, которые лежат выше главной диагонали – это элементы a[i][j] , для которых i < j , а для элементов ниже главной диагонали i >j . Таким образом, мы можем сравнивать значения i и j и по ним определять значение a[i][j] . Получаем следующий алгоритм:
for i in range(n): for j in range(n): if i < j: a[i][j] = 0 elif i >j: a[i][j] = 2 else: a[i][j] = 1
Данный алгоритм плох, поскольку выполняет одну или две инструкции if для обработки каждого элемента. Если мы усложним алгоритм, то мы сможем обойтись вообще без условных инструкций.
Сначала заполним главную диагональ, для чего нам понадобится один цикл:
for i in range(n): a[i][i] = 1
Затем заполним значением 0 все элементы выше главной диагонали, для чего нам понадобится в каждой из строк с номером i присвоить значение элементам a[i][j] для j = i+1 , . n-1 . Здесь нам понадобятся вложенные циклы:
for i in range(n): for j in range(i + 1, n): a[i][j] = 0
Аналогично присваиваем значение 2 элементам a[i][j] для j = 0 , . i-1 :
for i in range(n): for j in range(0, i): a[i][j] = 2
Можно также внешние циклы объединить в один и получить еще одно, более компактное решение:
for i in range(n): for j in range(0, i): a[i][j] = 2 a[i][i] = 1 for j in range(i + 1, n): a[i][j] = 0
А вот такое решение использует операцию повторения списков для построения очередной строки списка. i -я строка списка состоит из i чисел 2 , затем идет одно число 1 , затем идет n-i-1 число 0 :
for i in range(n): a[i] = [2] * i + [1] + [0] * (n - i - 1)
А можно заменить цикл на генератор:
a = [[2] * i + [1] + [0] * (n - i - 1) for i in range(n)]
Форматирование вывода
В некоторых заданиях этого листка требуется выводить элементы списка аккуратными столбцами, выравнивая числа по правому краю с фиксированной шириной столбца. Это можно сделать разными способами, один из способов: использование метода rjust .
rjust — метод объекта типа str , принимающий два параметра: длину новой строки (ширина поля вывода) и символ-заполнитель: rjust(n, ch) . Например, s.rjust(10, ‘.’) . Метод возвращает новую строку, длина которой равна n символов, исходная строка находится в конце результата (то есть исходная строка “выравнивается” по правому краю), лишние позиции заполняются символом ch. Если опустить ch, то в качестве символа-заполнителя используется пробел. Если длина исходной строки была больше n, то возвращается исходная строка без изменений (строка не обрезается).
Аналогично есть методы ljust , выравнивающий строку по левому краю и center , выравнивающий строку по центру результата.
Как вывести каждый элемент списка в новой строке python
Большинство программ работает не с отдельными переменными, а с набором переменных. Например, программа может обрабатывать информацию об учащихся класса, считывая список учащихся с клавиатуры или из файла, при этом изменение количества учащихся в классе не должно требовать модификации исходного кода программы.
Раньше мы сталкивались с задачей обработки элементов последовательности, например, вычисляя наибольший элемент последовательности. Но при этом мы не сохраняли всю последовательность в памяти компьютера. Однако, во многих задачах нужно именно сохранять всю последовательность, например, если бы нам требовалось вывести все элементы последовательности в возрастающем порядке (“отсортировать последовательность”).
Для хранения таких данных можно использовать структуру данных, называемую в Питоне список (в большинстве же языков программирования используется другой термин “массив”). Список представляет собой последовательность элементов, пронумерованных от 0, как символы в строке. Список можно задать перечислением элементов списка в квадратных скобках, например, список можно задать так:
Primes = [2, 3, 5, 7, 11, 13] Rainbow = ['Red', 'Orange', 'Yellow', 'Green', 'Blue', 'Indigo', 'Violet']
В списке Primes — 6 элементов, а именно: Primes[0] == 2 , Primes[1] == 3 , Primes[2] == 5 , Primes[3] == 7 , Primes[4] == 11 , Primes[5] == 13 . Список Rainbow состоит из 7 элементов, каждый из которых является строкой.
Также как и символы в строке, элементы списка можно индексировать отрицательными числами с конца, например, Primes[-1] == 13 , Primes[-6] == 2 .
Длину списка, то есть количество элементов в нем, можно узнать при помощи функции len , например, len(Primes) == 6 .
В отличие от строк, элементы списка можно изменять, присваивая им новые значения.
Rainbow = ['Red', 'Orange', 'Yellow', 'Green', 'Blue', 'Indigo', 'Violet'] print(Rainbow[0]) Rainbow[0] = 'красный' print('Выведем радугу') for i in range(len(Rainbow)): print(Rainbow[i])
Рассмотрим несколько способов создания и считывания списков. Прежде всего, можно создать пустой список (не содержащий элементов, длины 0), а в конец списка можно добавлять элементы при помощи метода append . Например, пусть программа получает на вход количество элементов в списке n , а потом n элементов списка по одному в отдельной строке. Вот пример входных данных в таком формате:
5 1809 1854 1860 1891 1925
В этом случае организовать считывание списка можно так:
5 1809 1854 1860 1891 1925
a = [] # заводим пустой список n = int(input()) # считываем количество элемент в списке for i in range(n): new_element = int(input()) # считываем очередной элемент a.append(new_element) # добавляем его в список # последние две строки можно было заменить одной: # a.append(int(input())) print(a)
В этом примере создается пустой список, далее считывается количество элементов в списке, затем по одному считываются элементы списка и добавляются в его конец. То же самое можно записать, сэкономив переменную n :
5 1809 1854 1860 1891 1925
a = [] for i in range(int(input())): a.append(int(input())) print(a)
Для списков целиком определены следующие операции: конкатенация списков (сложение списков, т. е. приписывание к одному списку другого) и повторение списков (умножение списка на число). Например:
a = [1, 2, 3] b = [4, 5] c = a + b d = b * 3 print([7, 8] + [9]) print([0, 1] * 3)
В результате список c будет равен [1, 2, 3, 4, 5] , а список d будет равен [4, 5, 4, 5, 4, 5] . Это позволяет по-другому организовать процесс считывания списков: сначала считать размер списка и создать список из нужного числа элементов, затем организовать цикл по переменной i начиная с числа 0 и внутри цикла считывается i -й элемент списка:
5 1809 1854 1860 1891 1925
a = [0] * int(input()) for i in range(len(a)): a[i] = int(input())
Вывести элементы списка a можно одной инструкцией print(a) , при этом будут выведены квадратные скобки вокруг элементов списка и запятые между элементами списка. Такой вывод неудобен, чаще требуется просто вывести все элементы списка в одну строку или по одному элементу в строке. Приведем два примера, также отличающиеся организацией цикла:
a = [1, 2, 3, 4, 5] for i in range(len(a)): print(a[i])
Здесь в цикле меняется индекс элемента i , затем выводится элемент списка с индексом i .
a = [1, 2, 3, 4, 5] for elem in a: print(elem, end=' ')
В этом примере элементы списка выводятся в одну строку, разделенные пробелом, при этом в цикле меняется не индекс элемента списка, а само значение переменной (например, в цикле for elem in [‘red’, ‘green’, ‘blue’] переменная elem будет последовательно принимать значения ‘red’ , ‘green’ , ‘blue’ .
Обратите особое внимание на последний пример! Очень важная часть идеологии Питона — это цикл for , который предоставляет удобный способ перебрать все элементы некоторой последовательности. В этом отличие Питона от Паскаля, где вам обязательно надо перебирать именно индексы элементов, а не сами элементы.
Последовательностями в Питоне являются строки, списки, значения функции range() (это не списки), и ещё кое-какие другие объекты.
Приведем пример, демонстрирующий использование цикла for в ситуации, когда из строки надо выбрать все цифры и сложить их в массив как числа.
# дано: s = 'ab12c59p7dq' # надо: извлечь цифры в список digits, # чтобы стало так: # digits == [1, 2, 5, 9, 7] s = 'ab12c59p7dq' digits = [] for symbol in s: if '1234567890'.find(symbol) != -1: digits.append(int(symbol)) print(digits)
2. Методы split и join
Элементы списка могут вводиться по одному в строке, в этом случае строку целиком можно считать функцией input() . После этого можно использовать метод строки split() , возвращающий список строк, которые получатся, если исходную строку разрезать на части по пробелам. Пример:
1 2 3
# на вход подаётся строка # 1 2 3 s = input() # s == '1 2 3' a = s.split() # a == ['1', '2', '3']
Если при запуске этой программы ввести строку 1 2 3 , то список a будет равен [‘1’, ‘2’, ‘3’] . Обратите внимание, что список будет состоять из строк, а не из чисел. Если хочется получить список именно из чисел, то можно затем элементы списка по одному преобразовать в числа:
1 2 3
a = input().split() for i in range(len(a)): a[i] = int(a[i])
Используя специальную магию Питона — генераторы — то же самое можно сделать в одну строку:
1 2 3
a = [int(s) for s in input().split()]
Объяснение того, как работает этот код, будет дано в следующем разделе. Если нужно считать список действительных чисел, то нужно заменить тип int на тип float .
У метода split() есть необязательный параметр, который определяет, какая строка будет использоваться в качестве разделителя между элементами списка. Например, вызов метода split(‘.’) вернет список, полученный разрезанием исходной строки по символам ‘.’ :
a = '192.168.0.1'.split('.')
В Питоне можно вывести список строк при помощи однострочной команды. Для этого используется метод строки join . У этого метода один параметр: список строк. В результате возвращается строка, полученная соединением элементов переданного списка в одну строку, при этом между элементами списка вставляется разделитель, равный той строке, к которой применяется метод. Мы знаем, что вы не поняли предыдущее предложение с первого раза. Поэтому смотрите примеры:
a = ['red', 'green', 'blue'] print(' '.join(a)) # вернёт red green blue print(''.join(a)) # вернёт redgreenblue print('***'.join(a)) # вернёт red***green***blue
Если же список состоит из чисел, то придется использовать еще тёмную магию генераторов. Вывести элементы списка чисел, разделяя их пробелами, можно так:
a = [1, 2, 3] print(' '.join([str(i) for i in a])) # следующая строка, к сожалению, вызывает ошибку: # print(' '.join(a))
Впрочем, если вы не любитель тёмной магии, то вы можете достичь того же эффекта, используя цикл for .
3. Генераторы списков
Для создания списка, заполненного одинаковыми элементами, можно использовать оператор повторения списка, например:
n = 5 a = [0] * n
Для создания списков, заполненных по более сложным формулам можно использовать генераторы: выражения, позволяющие заполнить список некоторой формулой. Общий вид генератора следующий:
[выражение for переменная in последовательность]
где переменная — идентификатор некоторой переменной, последовательность — последовательность значений, который принимает данная переменная (это может быть список, строка или объект, полученный при помощи функции range ), выражение — некоторое выражение, как правило, зависящее от использованной в генераторе переменной, которым будут заполнены элементы списка.
Вот несколько примеров использования генераторов.
Создать список, состоящий из n нулей можно и при помощи генератора:
a = [0 for i in range(5)]
Создать список, заполненный квадратами целых чисел можно так:
n = 5 a = [i ** 2 for i in range(n)]
Если нужно заполнить список квадратами чисел от 1 до n , то можно изменить параметры функции range на range(1, n + 1) :
n = 5 a = [i ** 2 for i in range(1, n + 1)]
Вот так можно получить список, заполненный случайными числами от 1 до 9 (используя функцию randrange из модуля random ):
from random import randrange n = 10 a = [randrange(1, 10) for i in range(n)]
А в этом примере список будет состоять из строк, считанных со стандартного ввода: сначала нужно ввести число элементов списка (это значение будет использовано в качестве аргумента функции range ), потом — заданное количество строк:
5 a b 1 2 3
a = [input() for i in range(int(input()))]
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 = [1, 2, 3, 4, 5] A[2:4] = [7, 8, 9]
Получится список, у которого вместо двух элементов среза A[2:4] вставлен новый список уже из трех элементов. Теперь список стал равен [1, 2, 7, 8, 9, 5] .
A = [1, 2, 3, 4, 5, 6, 7] A[::-2] = [10, 20, 30, 40]
Получится список [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] — это элемент списка, а не срез!
Операции со списками
Со списками можно легко делать много разных операций.
| x in A | Проверить, содержится ли элемент в списке. Возвращает True или False |
| x not in A | То же самое, что not(x in A) |
| min(A) | Наименьший элемент списка |
| max(A) | Наибольший элемент списка |
| A.index(x) | Индекс первого вхождения элемента x в список, при его отсутствии генерирует исключение ValueError |
| A.count(x) | Количество вхождений элемента x в список |
Как преобразовать список в строку в Python
Рассказываем о методе join() и других полезных инструментах для конвертирования Python‑списков в строки.
Иллюстрация: Оля Ежак для Skillbox Media
Иван Стуков
Журналист, изучает Python. Любит разбираться в мелочах, общаться с людьми и понимать их.
В Python существует два основных способа сделать из списка строку: с помощью цикла и с помощью метода join(). У обоих есть нюансы, о которых мы сейчас расскажем.
Преобразование с помощью цикла
Более понятный для новичка, но и более громоздкий способ перевести список в строку — воспользоваться циклом. Если вы уже знаете его и просто хотите узнать более эффективный и быстрый метод, то сразу переходите к следующему разделу. А если нет, то давайте разбираться.
Как это работает: мы создаём пустую строку, потом с помощью цикла переберём каждый элемент списка и на каждой итерации будем добавлять к строке текущий элемент списка.
lst = ['Преобразование','через','цикл'] #Создаём пустую строку string = '' #По очереди добавляем к ней каждый элемент списка for el in lst: string += el print(string) >>> Преобразованиечерезцикл
Однако такой код не будет работать, если в списке есть не только строки, но и, например, числа. Дело в том, что в Python нельзя смешивать данные разных типов.
Поэтому, перед тем как добавлять элемент в список, его нужно преобразовать в строку. Делается это с помощью функции str(). Добавим её в наш код.
#Создаём список, в котором есть как строки, так и цифры lst = ['Преобразование','через','цикл', 2] string = '' for el in lst: string += str(el) #Превращаем каждый элемент списка в строку print(string) >>> Преобразованиечерезцикл2
Если нужно установить разделитель между строками, то для него нужно прописать отдельную строчку кода внутри цикла.
lst = ['Преобразование','через','цикл', 3] string = '' for el in lst: #Добавляем к строке элемент списка string += str(el) #Добавляем к строке разделитель — в данном случае пробел string += ' ' print(string) >>> Преобразование через цикл 3
Обратите внимание: раз мы добавляем разделитель на каждой итерации, пробел будет и после цифры 3 нашего последнего элемента. Это легко проверить, если вместо пробела добавлять какой-то другой, видимый символ.
Эту проблему можно решить — ещё больше усложнив код. Например, введя условие, которое проверяет, последний это элемент в списке или нет. Однако гораздо проще и удобнее превратить список в строку, используя встроенный метод join().
Преобразование с помощью метода join()
Метод join(), по сути, делает всё то же самое, что и наш цикл, но лучше, удобнее и занимает всего одну строку. Вот как его применяют:
string.join(lst)
В качестве аргумента lst он получает список, элементы которого и будет объединять в строку, а string — это разделитель. Если мы не хотим его устанавливать, то в качестве string нужно указать пустую строку.
Посмотрим, как join() применяется на практике.
lst = ['Преобразование', 'через', 'метод', 'join()'] #Объединяем элементы списка с пустым разделителем print(''.join(lst)) >>> Преобразованиечерезметодjoin() #Устанавливаем пробел в качестве разделителя print(' '.join(lst)) >>> Преобразование через метод join()
Заметили особенность? Разделители ставятся только между элементами, а не после каждого элемента, как было в нашем цикле. join() — умница. Однако и тут есть ахиллесова пята: если в списке встречаются нестроковые элементы, мы получим ошибку. Чтобы этого избежать, надо опять-таки сначала превратить все нестроки в строки. Сделать это можно двумя способами.
Использовать выражение-генератор
Выражение-генератор — это конструкция, которая позволяет провести операцию над каждым элементом списка. Оно возвращает генератор, с которым метод join() обращается точно так же, как и со списками.
lst = [1, 1.2, 'строка', False] print(' '.join(str(el) for el in lst)) >>> 1 1.2 строка False
Конструкция str(el) for el in lst означает, что каждый элемент el в списке lst будет превращён в строку с помощью функции str (стандартной функции Python, которую мы уже использовали, когда работали с циклом).
Использовать функцию map()
Функция map() умеет делать то же самое, что и выражение-генератор, но их синтаксис отличается. В качестве первого аргумента она принимает саму операцию, в качестве второго — список, к элементам которого эта операция применяется.
lst = [1, 1.2, 'строка', False] print(' '.join(map(str, lst))) >>> 1 1.2 строка False
Конструкция map(str, lst) означает, что каждый элемент в списке lst будет превращён в строку с помощью функции str. Обратите внимание, что в качестве аргумента в map() передаётся только название функции, без скобок.
Итоги
Преобразовать список в строку можно с помощью цикла, но для этого есть и более удобный инструмент — метод join().
Если содержит нестроковые элементы, то их для начала придётся превратить в строки — иначе выскочит ошибка. Для этого можно воспользоваться выражением-генератором или функцией map().
Читайте также:
- Списки в Python: что это такое и как с ними работать
- Тест. Какой язык создадите вы — Java или Python?
- Язык Go: что под капотом и зачем программисту учить его как второй