Как создать список в 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 в список |
Как заполнить список длиной N числами от 1 до N?
Как можно сделать, что бы список заполнялся от 1 до N числа. К примеру, я ввожу число 10, и нужно, чтобы ответ вывелся так 1 2 3 4 5 6 7 8 9 10.
Отслеживать
13.7k 12 12 золотых знаков 43 43 серебряных знака 75 75 бронзовых знаков
задан 9 окт 2018 в 10:44
MISHAEL OVECHKIN MISHAEL OVECHKIN
33 1 1 золотой знак 2 2 серебряных знака 8 8 бронзовых знаков
3 ответа 3
Сортировка: Сброс на вариант по умолчанию
Для формирования списка нужного размера можно использовать функцию range
N = int(input("Введите размер списка: ")) spam = list(range(1, N+1)) print(spam) > Введите размер списка: 10 > [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] Отслеживать
ответ дан 9 окт 2018 в 10:49
Alexshev92 Alexshev92
3,135 6 6 золотых знаков 18 18 серебряных знаков 34 34 бронзовых знака
9 окт 2018 в 10:58
В python-2.x достаточно следующего кода:
N = 3 print range(1, N + 1) # [1, 2, 3] N = 3 print " ".join(map(str, range(1, N + 1))) # 1 2 3 В python-3.x схема работы range изменена, напрямую возвращает класс, поэтому чтобы вывести список принудительно проводим через list :
print(list(range(1, N+1))) # [1, 2, 3] print(" ".join(map(str, range(1, N+1)))) # 1 2 3 Списки в Python: методы и основные операции
Рассмотрим создание списков в Python и разберём основные методы. Научимся изменять, сортировать и совершать другие операции над list.
Списки в Python представляют собой упорядоченные изменяемые наборы объектов, пронумерованных от 0. При этом объекты могут быть разными — от целых чисел до строк. Списки могут также хранить в себе списки.
В статье разберёмся с базовыми принципами списков в Питоне, а также рассмотрим методы работы с ними. Если вы изучаете Python с нуля, предлагаем также ознакомиться с дорожной картой для начинающих.
- Хранение в памяти
- Создание списка
- Срезы (slice)
- Простые операции
- Методы списков
Хранение в памяти
При создании списка, в памяти резервируется пустая область. С одной стороны, это ничем не отличается от создания любого другого типа данных, но разница в том, что содержимое list может меняться:
numbers = [1, 2] numbers[1] = 3 # обновлённый список: [1, 3] До замены элемента последовательности print(numbers[1]) выведет 2, а после замены — 3.
Создание списка в Python
Это можно сделать несколькими способами, например перечислением элементов списка в квадратных скобках:
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9] При этом единица будет на позиции 0, то есть print(numbers[0]) выведет 1.
Также можно использовать обработку итерируемого объекта функцией list() . Пусть у нас будет некоторая строка, тогда:
list('tproger') # ['t', 'p', 'r', 'o', 'g', 'e', 'r'] Также существуют генераторы списков, которые позволяют применить заданное выражение к каждому элементу последовательности. Допустим, необходимо создать list, состоящий из чисел от 1 до 5 включительно:
numbers = [i for i in range(1,6)] # [1, 2, 3, 4, 5] Срезы (slice) списка
Срезы позволяют получить некое подмножество значений. Следующий код вернёт список с элементами, начиная индексом 0 и не включая при этом индекс 2 и выше:
numbers = [1, 5, 9, 6] print(numbers[0:2]) # вывод [1, 5] Далее выведем всё, за исключением элемента на позиции 3:
print(numbers[:3]) # вывод [1, 5, 9] А теперь начиная с индекса 1 и до конца:
print(numbers[1:]) # вывод [5, 9, 6] Операции над списками Python
- x in l — true , если элемент x есть в списке l ;
- x not in l — true , если элемент x отсутствует в l ;
- l1 + l2 — объединение двух списков;
- l * n , n * l — копирует список n раз;
- len(l) — количество элементов в l ;
- min(l) — наименьший элемент;
- max(l) — наибольший элемент;
- sum(l) — сумма чисел списка;
- for i in list() — перебирает элементы слева направо.
Методы списков Python
Index
Возвращает положение первого совпавшего элемента. Поиск совпадения происходит слева направо. Пример:
numbers = [1, 5, 9, 6, 1, 2, 1] print(numbers.index(1)) # вывод 0: первая найденная единица на позиции 0 Count
Данный метод считает, сколько раз указанное значение появляется в списке Python:
numbers = [1, 5, 9, 6, 1, 2, 1] print(numbers.count(1)) # вывод 3, потому что единица встречается 3 раза Append
Добавляет указанное значение в конец:
numbers = [1, 5, 9, 6] numbers.append(3) # обновлённый список: [1, 5, 9, 6, 3] Sort
Сортирует список в Пайтоне. По умолчанию от меньшего к большему:
numbers = [1, 5, 9, 6] numbers.sort() # обновлённый список: [1, 5, 6, 9] Также можно сортировать последовательность элементов от большего к меньшему:
numbers = [1, 5, 9, 6] numbers.sort(reverse = true) # обновлённый список: [9, 6, 5, 1] Insert
Вставляет элемент перед указанным индексом:
numbers = [1, 5, 9, 6] numbers.insert(3, [2, 3]) # обновлённый список: [1, 5, 9, [2, 3], 6] Remove
Удаляет первое попавшееся вхождение элемента в списке Python:
numbers = [1, 5, 9, 6, 1, 2, 1] numbers.remove(1) # обновлённый список: [5, 9, 6, 1, 2, 1] Extend
Подобно методу append() , добавляет элементы, но преимущество метода extend() в том, что он также позволяет добавлять списки:
numbers = [1, 5, 9, 6] numbers.extend([2, 3]) # обновлённый список: [1, 5, 9, 6, 2, 3] Pop
А данный метод удаляет элемент в конкретно указанном индексе, а также выводит удалённый элемент. Если индекс не указан, метод по умолчанию удалит последний элемент:
numbers = [1, 5, 9, 6] numbers.pop(1) # получаем: # 5 # [1, 9, 6] Join
Преобразовывает список в строку. Разделитель элементов пишут в кавычках перед методом, а сам список Питона должен состоять из строк:
mylist = ['сайт', 'типичный', 'программист'] print(', '.join(mylist)) # вывод 'сайт, типичный, программист' Создание списка чисел в определенном диапазоне в Python
Часто при программировании на Python возникает необходимость создать список чисел, которые находятся в определенном диапазоне. Возьмем для примера ситуацию, когда требуется создать список, содержащий числа от 5 до 10. Что нужно сделать, чтобы получить такой список?
[5, 6, 7, 8, 9, 10]
Для решения данной задачи в Python есть несколько способов.
Использование функции range()
Самый простой и популярный способ — использование встроенной функции range() . Эта функция генерирует последовательность чисел в заданном диапазоне.
list(range(5, 11))
В данном случае, функция range() генерирует числа от 5 до 10 включительно. Функция list() используется для преобразования этих чисел в список.
Использование генератора списка
Второй способ — использование генератора списка. Генераторы списков — это удобный инструмент для создания списков в Python.
Ниже приведен пример создания списка чисел от 5 до 10 с использованием генератора списка:
[i for i in range(5, 11)]
В этом примере используется такой же вызов функции range() , как и в предыдущем примере, но вместо функции list() используется генератор списка.
Таким образом, Python предлагает несколько простых и эффективных способов создания списка чисел в заданном диапазоне.