Как считать список python
Скачай курс
в приложении
Перейти в приложение
Открыть мобильную версию сайта
© 2013 — 2023. Stepik
Наши условия использования и конфиденциальности
Public user contributions licensed under cc-wiki license with attribution required
Списки
Большинство программ работает не с отдельными переменными, а с набором переменных. Например, программа может обрабатывать информацию об учащихся класса, считывая список учащихся с клавиатуры или из файла, при этом изменение количества учащихся в классе не должно требовать модификации исходного кода программы.
Раньше мы сталкивались с задачей обработки элементов последовательности, например, вычисляя наибольший элемент последовательности. Но при этом мы не сохраняли всю последовательность в памяти компьютера, однако, во многих задачах нужно именно сохранять всю последовательность, например, если бы нам требовалось вывести все элементы последовательности в возрастающем порядке (“отсортировать последовательность”).
Для хранения таких данных можно использовать структуру данных, называемую в Питоне список (в большинстве же языков программирования используется другой термин “массив”). Список представляет собой последовательность элементов, пронумерованных от 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(A) == 6 .
Рассмотрим несколько способов создания и считывания списков. Прежде всего можно создать пустой список (не содержащий элементов, длины 0), в конец списка можно добавлять элементы при помощи метода append . Например, если программа получает на вход количество элементов в списке n , а потом n элементов списка по одному в отдельной строке, то организовать считывание списка можно так:
A = [] for i in range(int(input()): A.append(int(input())
В этом примере создается пустой список, далее считывается количество элементов в списке, затем по одному считываются элементы списка и добавляются в его конец.
Для списков целиком определены следующие операции: конкатенация списков (добавление одного списка в конец другого) и повторение списков (умножение списка на число). Например:
A = [1, 2, 3] B = [4, 5] C = A + B D = B * 3
В результате список C будет равен [1, 2, 3, 4, 5] , а список D будет равен [4, 5, 4, 5, 4, 5] . Это позволяет по-другому организовать процесс считывания списков: сначала считать размер списка и создать список из нужного числа элементов, затем организовать цикл по переменной i начиная с числа 0 и внутри цикла считывается i -й элемент списка:
A = [0] * int(input()) for i in range(len(A)): A[i] = int(input())
Вывести элементы списка A можно одной инструкцией print(A) , при этом будут выведены квадратные скобки вокруг элементов списка и запятые между элементами списка. Такой вывод неудобен, чаще требуется просто вывести все элементы списка в одну строку или по одному элементу в строке. Приведем два примера, также отличающиеся организацией цикла:
for i in range(len(A)): print(A[i])
Здесь в цикле меняется индекс элемента i , затем выводится элемент списка с индексом i .
for elem in A: print(elem, end = ' ')
В этом примере элементы списка выводятся в одну строку, разделенные пробелом, при этом в цикле меняется не индекс элемента списка, а само значение переменной (например, в цикле for elem in [‘red’, ‘green’, ‘blue’] переменная elem будет последовательно принимать значения ‘red’ , ‘green’ , ‘blue’ .
Методы split и join
Элементы списка могут вводиться по одному в строке, в этом случае строку можно считать функцией 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 = [0] * n
Для создания списков, заполненных по более сложным формулам можно использовать генераторы: выражения, позволяющие заполнить список некоторой формулой. Общий вид генератора следующий:
[ выражение for переменная in список]
где переменная — идентификатор некоторой переменной, список — список значений, который принимает данная переменная (как правило, полученный при помощи функции range ), выражение — некоторое выражение, которым будут заполнены элементы списка, как правило, зависящее от использованной в генераторе переменной.
Вот несколько примеров использования генераторов.
Создать список, состоящий из n нулей можно и при помощи генератора:
A = [ 0 for i in range(n)]
Создать список, заполненный квадратами целых чисел можно так:
A = [ i ** 2 for i in range(n)]
Если нужно заполнить список квадратами чисел от 1 до n , то можно изменить параметры функции range на range(1, n + 1) :
A = [ i ** 2 for i in range(1, n + 1)]
Вот так можно получить список, заполненный случайными числами от 1 до 9 (используя функцию randint из модуля random ):
A = [ randint(1, 9) for i in range(n)]
А в этом примере список будет состоять из строк, считанных со стандартного ввода: сначала нужно ввести число элементов списка (это значение будет использовано в качестве аргумента функции range ), потом — заданное количество строк:
A = [ input() for i in range(int(input()))]
Упражнения
Во всех задачах этого листка программа получает на вход строку из целых чисел, разделенных пробелами. В конце строки также могут быть пробелы. Данную строку необходимо считать в список целых чисел.
A: Четные индексы
Выведите все элементы списка с четными индексами (то есть A[0] , A[2] , A[4] , . ).
Списки
Список в Python – это встроенный тип (класс) данных, представляющий собой одну из разновидностей структур данных. Структуру данных можно представить как сложную единицу, объединяющую в себе группу более простых. Каждая разновидность структур данных имеет свои особенности. Список – это изменяемая последовательность произвольных элементов.
В большинстве других языков программирования есть такой тип данных как массив. В Питоне такого встроенного типа нет. Однако при знакомстве с программированием списки условно можно считать аналогом массивов за одним исключением. Составляющие массив элементы должны принадлежать одному типу данных, для списков такого ограничения нет.
Например, массив может содержать только целые числа или только вещественные числа или только строки. Список также может содержать элементы исключительно одного типа, что делает его похожим на массив. Но вполне допустимо, чтобы в одном списке содержались как числа, так и строки или иные типы данных.
Создавать списки можно разными способами. Создадим его простым перечисление элементов:
>>> a = [12, 3.85, "black", -4] >>> a [12, 3.85, 'black', -4]
Итак, у нас имеется список, присвоенный переменной a . В Python список определяется квадратными скобками. Он содержит четыре элемента. Если где-то в программе нам понадобится весь этот список, мы получим доступ к нему, указав всего лишь одну переменную – a .
Элементы в списке упорядочены, то есть имеет значение, в каком порядке они расположены. Каждому элементу соответствует свой индекс, или номер. Индексация начинается с нуля. В данном случае число 12 имеет индекс 0, строка «black» – индекс 2. Чтобы извлечь определенный элемент, надо после имени переменной указать в квадратных скобках его индекс:
>>> a = [12, 3.85, "black", -4] >>> a[0] 12 >>> a[3] -4
В Python существует также индексация с конца. Она начинается с -1:
>>> a[-1] -4 >>> a[-2] 'black' >>> a[-3], a[-4] (3.85, 12)
Часто требуется извлечь не один элемент, а так называемый срез – часть списка. В этом случае указывается индекс первого элемента среза и индекс следующего за последним элементом среза:
>>> a[0:2] [12, 3.85]
В данном случае извлекаются первые два элемента с индексами 0 и 1. Элемент с индексом 2 в срез уже не входит. В таком случае возникает вопрос, как извлечь срез, включающий в себя последний элемент? Если какой-либо индекс не указан, то считается, что имеется в виду начало или конец:
>>> a = [12, 3.85, "black", -4] >>> a[:3] [12, 3.85, 'black'] >>> a[2:] ['black', -4] >>> a[:] [12, 3.85, 'black', -4]
Списки – изменяемые объекты. Это значит, что в них можно добавлять элементы, удалять их, изменять существующие. Проще всего изменить значение элемента. Для этого надо обратиться к нему по индексу и перезаписать значение в заданной позиции:
>>> a[1] = 4 >>> a [12, 4, 'black', -4]
Добавлять и удалять лучше с помощью специальных встроенных методов списка:
>>> a.append('wood') >>> a [12, 4, 'black', -4, 'wood'] >>> a.insert(1, 'circle') >>> a [12, 'circle', 4, 'black', -4, 'wood'] >>> a.remove(4) >>> a [12, 'circle', 'black', -4, 'wood'] >>> a.pop() 'wood' >>> a [12, 'circle', 'black', -4] >>> a.pop(2) 'black' >>> a [12, 'circle', -4]
Перечень всех методов списка можно узнать с помощью встроенной в Python функции dir() , передав в качестве аргумента переменную, связанную со списком, или название класса (в данном случае – list ). В полученном из dir() списке надо смотреть имена без двойных подчеркиваний.
Для получения информации о конкретном методе следует воспользоваться встроенной функцией help() , передав ей в качестве аргумента имя метода, связанное с объектом или классом. Например, help(a.pop) или help(list.index) . Выход из справки – q.
Можно изменять списки не используя методы, а с помощью взятия и объединения срезов:
>>> b = [1, 2, 3, 4, 5, 6] >>> b = b[:2] + b[3:] >>> b [1, 2, 4, 5, 6]
Здесь берется срез из первых двух элементов и срез, начиная с четвертого элемента (индекс 3) и до конца. После чего срезы объединяются с помощью оператора «сложения».
Можно изменить не один элемент, а целый срез:
>>> mylist = ['ab','ra','ka','da','bra'] >>> mylist[0:2] = [10, 20] >>> mylist [10, 20, 'ka', 'da', 'bra']
Пример создания пустого списка с последующим заполнением его в цикле случайными числами:
>>> import random >>> c = [] >>> i = 0 >>> while i < 10: . c.append(random.randint(0,100)) . i += 1 . >>> c [30, 44, 35, 77, 53, 44, 49, 17, 61, 82]
Практическая работа
- Напишите программу, которая запрашивает с ввода восемь чисел, добавляет их в список. На экран выводит их сумму, максимальное и минимальное из них. Для нахождения суммы, максимума и минимума воспользуйтесь встроенными в Python функциями sum() , max() и min() .
- Напишите программу, которая генерирует сто случайных вещественных чисел и заполняет ими список. Выводит получившийся список на экран по десять элементов в ряд. Далее сортирует список с помощью метода sort() и снова выводит его на экран по десять элементов в строке. Для вывода списка напишите отдельную функцию, в качестве аргумента она должна принимать список.
Примеры решения и дополнительные уроки в pdf-версии курса
X Скрыть Наверх
Python. Введение в программирование
Lesson 7
Списки
Большинство программ работают не только с переменными. Они также используют списки переменных. Например, программа может обрабатывать информацию о студентах в классе, читая список учеников с клавиатуры или из файла. Изменение количества учащихся в классе не требует модификации исходного кода программы.
Раньше мы уже столкнулись с задачей обработки элементов последовательности — например, при вычислении самого большого элемента последовательности. Но мы не сохранили всю последовательность в памяти компьютера. Однако во многих проблемах необходимо сохранить всю последовательность, как если бы нам пришлось распечатывать все элементы последовательности в порядке возрастания («сортировать последовательность»).
Для хранения таких данных в 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 .
В отличие от строк, элементы списка изменяемы; их можно изменить, назначив им новые значения.
None
Rainbow = ['Red', 'Orange', 'Yellow', 'Green', 'Blue', 'Indigo', 'Violet'] print(Rainbow[0]) Rainbow[0] = 'red' print('Print the rainbow') 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 (интермедиат (вход ())) print(a)
В показанном примере создается пустой список, затем считывается количество элементов, затем вы читаете элементы списка по очереди и добавляете их в конец. То же самое можно сделать, сохранив переменную n :
5 1809 1854 1860 1891 1925
a = [] for i in range(int(input())): a.append(int(input())) print(a)
Существует несколько операций, определенных для списков: объединение списков (добавление списков, т.е. «склейка» одного списка в другой) и повторение (умножение списка на число). Например:
None
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) ; это отображает элементы списка, окруженные квадратными скобками и разделенные запятыми. В общем, это неудобно; в общем, вы собираетесь распечатать все элементы в одной строке или по одному элементу в строке. Вот два примера этого, используя другие формы цикла:
None
a = [1, 2, 3, 4, 5] for i in range(len(a)): print(a[i])
Здесь индекс i изменяется, затем отображается элемент a[i] .
None
a = [1, 2, 3, 4, 5] for elem in a: print(elem, end=' ')
В этом примере элементы списка отображаются в одной строке, разделенной пробелами, и это не индекс, который изменяется, а скорее значение самой переменной (например, в цикле for elem in [‘red’, ‘green’, ‘blue’] variable elem будет принимать значения ‘red’ , ‘green’ , ‘blue’ подряд.
Обратите особое внимание на последний пример! Очень важная часть идеологии Python является for цикла, что обеспечивает удобный способ для перебора всех элементов некоторой последовательности. Здесь Python отличается от Pascal, где вам нужно перебирать индексы элементов, но не над самими элементами.
Последовательности в Python — это строки, списки, значения range() функций range() (это не списки) и некоторые другие объекты.
Вот пример, показывающий использование цикла for когда вам нужно извлечь все цифры из строки и сделать их числовым.
None
# данный: s = 'ab12c59p7dq' # вам нужно извлечь цифры из списка s # сделать так: # цифры == [1, 2, 5, 9, 7] s = 'ab12c59p7dq' digits = [] for symbol in s: if '1234567890'.find(symbol) != -1: digits.append(int(symbol)) print(digits)
Advertising by Google, may be based on your interests
2. Методы разделения и объединения
Элементы списка могут быть указаны в одной строке, разделенной символом; в этом случае весь список можно прочитать с помощью input() . Затем вы можете использовать метод string split() , который возвращает список строк, возникающих после сокращения начальной строки пробелами. Пример:
1 2 3
# вход представляет собой строку # 1 2 3 s = input() # s == '1 2 3' a = s.split() # a == ['1', '2', '3'] print(a)
Если вы запустите эту программу с входными данными 1 2 3 , список a будет равен [‘1’, ‘2’, ‘3’] . Обратите внимание, что список будет состоять из строк, а не цифр. Если вы хотите получить список номеров, вам нужно преобразовать элементы списка по одному в целые числа:
1 2 3
a = input().split() for i in range(len(a)): a[i] = int(a[i]) print(a)
Используя специальную магию Python — генераторов — то же самое можно сделать в одной строке:
1 2 3
a = [int(s) for s in input().split()] print(a)
(Мы объясним, как этот код работает в следующем разделе.) Если вы хотите прочитать список реальных чисел, вам нужно изменить тип int для float .
Метод split() имеет необязательный параметр, который определяет, какая строка будет использоваться в качестве разделителя между элементами списка. Например, вызов метода split(‘.’) Возвращает список, полученный путем разбиения исходной строки, где символ ‘.’ встречается:
None
a = '192.168.0.1'.split('.') print(a)
В Python вы можете отображать список строк, используя однострочные команды. Для этого используется join метода; этот метод имеет один параметр: список строк. Он возвращает строку, полученную конкатенацией данных элементов, и разделитель вставлен между элементами списка; этот разделитель равен строке, на которой применяется метод. Мы знаем, что вы не поняли предыдущее предложение с первого раза. 🙂 Посмотрите на примеры:
None
a = ['red', 'green', 'blue'] print(' '.join(a)) # возврат красный зеленый синий print(''.join(a)) # return redgreenblue print('***'.join(a)) # возвращает красный *** зеленый *** синий
Если список состоит из цифр, вы должны использовать темную магию генераторов. Вот как вы можете распечатать элементы списка, разделенные пробелами:
None
a = [1, 2, 3] print(' '.join([str(i) for i in a])) # следующая строка вызывает ошибку типа, # поскольку join () может только конкатенировать strs # print ('.join (a))
Однако, если вы не поклонник темной магии, вы можете добиться того же эффекта, используя цикл for .
Advertising by Google, may be based on your interests
3. Генераторы
Чтобы создать список, заполненный идентичными элементами, вы можете использовать повторение списка, например:
None
n = 5 a = [0] * n print(a)
Для создания более сложных списков вы можете использовать генераторы : выражения, позволяющие заполнить список в соответствии с формулой. Общая форма генератора следующая:
[expression for variable in sequence]
где variable — это идентификатор некоторой переменной, sequence — это последовательность значений, которая принимает переменную (это может быть список, строка или объект, полученный с использованием range функций), expression — некоторое выражение, обычно в зависимости от переменной используемый в генераторе. Элементы списка будут заполнены в соответствии с этим выражением.
Вот несколько примеров использования генераторов.
Вот как вы создаете список из n нулей с помощью генератора:
None
a = [0 for i in range(5)] print(a)
Вот как вы создаете список, заполненный квадратами целых чисел:
None
n = 5 a = [i ** 2 for i in range(n)] print(a)
Если вам нужно заполнить список квадратов чисел от 1 до n , вы можете изменить настройки range до range(1, n + 1) :
None
n = 5 a = [i ** 2 for i in range(1, n + 1)] print(a)
Вот как вы можете получить список, заполненный случайными числами от 1 до 9 (используя randrange из модуля random ):
None
from random import randrange n = 10 a = [randrange(1, 10) for i in range(n)] print(a)
И в этом примере список будет состоять из строк, считанных со стандартного ввода: во-первых, вам нужно ввести количество элементов списка (это значение будет использоваться как аргумент range функций), второе — это количество строк:
5 a b 1 2 3
a = [input() for i in range(int(input()))] print(a)
Advertising by Google, may be based on your interests
4. Ломтики
Со списками и строками вы можете делать срезы. А именно:
A[i:j] slice ji элементы A[i] , A[i+1] , . A[j-1] .
A[i:j:-1] среза ij элементов 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 может отсутствовать, что означает «начало строки» или «конец строки»,
Списки, в отличие от строк, являются изменяемыми объектами : вы можете назначить элемент списка новому значению. Кроме того, можно изменять целые срезы. Например:
None
A = [1, 2, 3, 4, 5] A[2:4] = [7, 8, 9] print(A)
Здесь мы получили список [1, 2, 3, 4, 5] , а затем попытаемся заменить два элемента среза A[2:4] новым списком из трех элементов. Полученный список выглядит следующим образом: [1, 2, 7, 8, 9, 5] .
None
A = [1, 2, 3, 4, 5, 6, 7] A[::-2] = [10, 20, 30, 40] print(A)
И здесь результирующий список будет [40, 2, 30, 4, 20, 6, 10] . Причина в том, что A[::-2] — это список элементов A[-1] , A[-3] , A[-5] , A[-7] и что элементы назначены на 10, 20, 30, 40, соответственно.
Если для прерывистого среза (то есть среза с шагом k , k > 1 ) присваивается новое значение, то число элементов в старом и новом срезах обязательно совпадает, в противном случае возникает ошибка ValueError .
Обратите внимание, что A[i] — это элемент списка, а не фрагмент!