Как добавлять значения в список python

Как добавить веденные значения в список?

Имеется список. Есть переменная var, она является его диапазоном. С помощью цикла в списке создаются определенное кол-во элементов, зависимое от веденного значения var, и этим элементам нужно ввести значение. А как веденные значения добавить в список и затем вывести его?

var = int(input()) l = list(range(1, var + 1)) for x in l: x = int(input('['+ str(x) + ']: ')) 

Отслеживать

задан 20 окт 2018 в 20:43

101 2 2 золотых знака 2 2 серебряных знака 11 11 бронзовых знаков

3 ответа 3

Сортировка: Сброс на вариант по умолчанию

Существует функция list.append() Она добавляет элемент в конец списка. Попробуй использовать ее.

Отслеживать

ответ дан 20 окт 2018 в 20:55

98 10 10 бронзовых знаков

Модификация списков поэлементно — Python: Списки

Как вы помните, элементы списков индексированы, то есть каждый элемент имеет порядковый номер. Первый элемент имеет индекс 0 , последний — len(list) — 1 .

Функция len возвращает длину списка, но работает она с различными типами, например — со строками и кортежами.

Элементы списка можно получать и заменять через присваивание по их индексу. Если указать отрицательный индекс, то элементы будут браться с конца.

Последний элемент списка будет иметь отрицательный индекс -1 . Увы, -0 использовать не получится. Вот пара примеров использования индексов со списком:

l = [0] * 3 l[0], l[1] = 10, 32 l[-1] = l[0] + l[1] print(l) # => [10, 32, 42] 

Обратите внимание, что мы создали список клонированием нулей. Так делать безопасно, потому что числа в Python — неизменяемые. Впрочем, все модификации списка сделаны через присваивание, поэтому ничего неожиданного мы бы не получили, даже если бы использовали изменяемые объекты.

pop и insert

Итак, получать и заменять элементы по одному мы умеем. Неплохо бы еще уметь удалять старые элементы и вставлять в середину списка новые. За это отвечают методы pop и insert соответственно. pop удаляет элемент по индексу.

Если не указать индекс, то удаляется последний элемент. При этом pop возвращает значение элемента, который удаляет:

l = [1, 2, 3] l.pop() # 3 print(l) # => [1, 2] l.pop(0) # 1 print(l) # => [2] 

А вот пример использования insert :

l = [1, 2, 3] l.insert(1, 100) print(l) # => [1, 100, 2, 3] l.insert(-1, 200) print(l) # => [1, 100, 2, 200, 3] 

insert всегда вставляет новый элемент перед элементом с указанным индексом относительно начала списка. При этом не важно, откуда мы индекс отсчитывали — от начала или от конца. И insert(-1, ..) вставляет элемент именно перед последним элементом.

Интересно, что l.insert(len(l), x) добавит элемент x в конец списка l , то есть сработает как l.append(x) .

Фактически здесь не будет элемента, перед которым будет вставлен новый, вот новый элемент и попадет в конец списка.

Имейте в виду эту особенность, но используйте append , хотя бы потому, что его вызов проще читается.

Ошибки индексации

Если попытаться вызвать pop() у пустого списка или указать индекс за пределами индексов существующих элементов, вы получите ошибку IndexError :

l = [] l.pop() # Traceback (most recent call last): # File "", line 1, in # IndexError: pop from empty list 

А вот insert более терпим к некорректным индексам и просто добавляет элементы с соответствующего края:

l = [0] l.insert(-500, 1) l.insert(1000, 2) print(l) # => [1, 0, 2] 

Однако полагаться на это не стоит — индексы все же лучше держать под контролем.

Сортировка и разворачивание

Списки чего-либо периодически приходится сортировать, а иногда и разворачивать. Желательно уметь это делать эффективно. Поэтому список уже имеет встроенные средства для выполнения обеих задач — методы sort и reverse . Оба метода изменяют список по месту. Посмотрим на несколько примеров:

l = [1, 3, 7, 2, 10, 8] l.sort() print(l) # => [1, 2, 3, 7, 8, 10] l.reverse() print(l) # => [10, 8, 7, 3, 2, 1] 

Эти методы могут работать без параметров. В случае reverse нечего и параметризовывать: разворачивание — это всегда разворачивание.

А вот сортировка может производиться по разным критериям. Если вызывать sort без параметров, то элементы сортируются в порядке возрастания. Однако методу можно передать параметр-функцию, которая будет возвращать критерий сортировки, то есть ключ.

Функция будет вызвана по одному разу для каждого элемента списка, после чего элементы будут отсортированы по возрастанию значения ключа. Давайте объявим функцию, которая будет возвращать остаток от деления аргумента на два, и используем ее в роли ключа:

def mod2(x): return x % 2 l = [1, 2, 3, 6, 5, 4] l.sort(key=mod2) print(l) # => [2, 6, 4, 1, 3, 5] 

Обратите внимание, что функцию в метод sort мы передали по имени параметра. Такой синтаксис мы рассмотрим позже, но поэкспериментировать с методом sort и разными функциями-ключами вы уже сможете, указывая их по аналогии.

Функция mod2 вернула для четных и нечетных чисел 0 и 1 соответственно. Поэтому в начале списка оказались сначала четные числа.

Интересно, что в пределах своей группы числа сохранили порядок: 6 шла в списке перед 4 , и это взаимное расположение сохранилось.

Умение сохранить относительный порядок элементов, которые уже отсортированы относительно друг друга — важная характеристика алгоритма сортировки. Называется она стабильностью.

Сортировка в этом случае называется стабильной — и в Python сортировка именно такая.

Функция-ключ не обязана возвращать числа — она может возвращать любые значения, которые Python умеет сравнивать. Давайте в предыдущем примере усложним функцию-ключ:

def key(x): return (x % 2, x) l = [1, 2, 3, 6, 5, 4] l.sort(key=key) print(l) # => [2, 4, 6, 1, 3, 5] 

Теперь числа разбиты на группы и при этом еще и отсортированы внутри групп. Когда Python сравнивает кортежи, он сравнивает сначала первые элементы, а если те равны — вторые и так далее.

Значения сравниваются, пока не найдется первое неравенство. Либо пока не кончится один из кортежей — в этом случае более короткий будет меньше. Вот несколько примеров:

print((1, 2, 3)  (1, 2, 4)) # => True print((1, 1)  (1, 1, 1)) # => True print((1, 2) > (1, 1, 1)) # => True print((3, 4, 5) == (3, 4, 5)) # => True 

Открыть доступ

Курсы программирования для новичков и опытных разработчиков. Начните обучение бесплатно

• 130 курсов, 2000+ часов теории
• 1000 практических заданий в браузере
• 360 000 студентов

Наши выпускники работают в компаниях:

Создание списков в Python. Объединение списков в Python. Функция list() в Python

Популярность Python обуславливается его относительной простотой и широкими функциональными возможностями. Среди них — успешная работа со структурами данных — это списки, кортежи, словари и множества. В нашей сегодняшней статье мы разберёмся со списками, поговорим про добавление и поиск элементов, а напоследок подробно расскажем об особенностях сортировки в Python.

Что такое список в Python?

Список (list) представляет собой структуру данных, предназначенную для хранения объектов. При этом не стоит путать список с массивом.

Некоторые особенности списка в Python: — в списке можно хранить элементы разных типов; — размер списка можно изменять.

Как хранятся списки в памяти?

Во время создания списка в Python происходит резервирование пустой области в памяти. Условно можно сказать, что это некий контейнер, где содержатся ссылки на другие элементы данных. Однако в отличие от таких данных, как строка либо число, содержимое контейнера списка может меняться.

Чтобы лучше представлять вышеописанный процесс, посмотрим на картинку. Мы увидим список, который содержит ссылки на объекты 1 и 2. При этом после выполнения операции a[1] = 3, вторая ссылка станет указывать на объект № 3 (в Питоне элементы списка нумеруются, начиная с нуля).

Создание, удаление и изменение списков, а также работа с его элементами

Создать список в Python можно следующим способом:

>>> a = [] >>> type(a) >>> b = list() >>> type(b)

Кроме того, возможно создание списка с заранее известным набором данных:

>>> a = [1, 2, 3] >>> type(a)

Если список уже есть и нужно создать копию, это тоже не проблема:

 
>>> a = [1, 3, 5, 7] >>> b = list(a) >>> print(a) [1, 3, 5, 7] >>> print(b) [1, 3, 5, 7]
Обратите внимание, что если вы делаете простое присваивание списков друг другу, то переменной (в нашем примере это b) присваивается ссылка на тот же самый элемент данных в памяти, как и в списке a (не на копию списка a). Таким образом, если захотите изменить список a, b тоже будет меняться.
 
>>> a = [1, 3, 5, 7] >>> b = a >>> print(a) [1, 3, 5, 7] >>> print(b) [1, 3, 5, 7] >>> a[1] = 10 >>> print(a) [1, 10, 5, 7] >>> print(b) [1, 10, 5, 7]
Если нужно добавить элемент в список, используем метод append() :
 
>>> a = [] >>> a.append(3) >>> a.append("hello") >>> print(a) [3, 'hello']
А если требуется удалить элемент из списка в том случае, когда его значение известно, рекомендуется применение метода remove(x) , который удалит первую ссылку на этот элемент:
 
>>> b = [2, 3, 5] >>> print(b) [2, 3, 5] >>> b.remove(3) >>> print(b) [2, 5]
Для удаления элемента по индексу подходит команда del имя_списка[индекс] :
 
>>> c = [3, 5, 1, 9, 6] >>> print(c) [3, 5, 1, 9, 6] >>> del c[2] >>> print(c) [3, 5, 9, 6]
Кроме того, можно изменить элемент списка в Python (его значение), напрямую к нему обратившись. Но для этого надо знать индекс элемента:
 
>>> d = [2, 4, 9] >>> print(d) [2, 4, 9] >>> d[1] = 17 >>> print(d) [2, 17, 9]
А что нужно сделать, если требуется очистить список в Python? Для этого можно заново его проинициализировать, как будто вновь его создаёте. А чтобы получить доступ к элементу списка, поместите индекс данного элемента в квадратные скобки:
 
>>> a = [3, 5, 7, 10, 3, 2, 6, 0] >>> a[2] 7
Можно применять и отрицательные индексы (счёт пойдёт с конца). Например, чтобы получить доступ к последнему элементу списка в Python, используют следующую команду:
 
>>> a[-1] 0
Также может понадобиться найти и получить из списка некоторый подсписок в заданном диапазоне индексов. Чтобы это реализовать, поместите начальный и конечный индексы в квадратные скобки и разделите их двоеточием:
 
>>> a[1:4] [5, 7, 10]
Объединить списки в Python тоже несложно. Объединение легко сделать с помощью метода extend :
 
combo_list = [1] one_list = [4, 5] a = combo_list.extend(one_list) print(a) # [1, 4, 5]
Также в Python можно объединить список с другим, просто добавив их вместе. Это довольно простой способ объединения:
 
my_list = [1, 2, 3] my_list2 = ["a", "b", "c"] combo_list = my_list + my_list2 print(combo_list) # [1, 2, 3, 'a', 'b', 'c']
Как видите, объединить списки достаточно легко.
Закрепляем методы списков в Python
Знание соответствующих методов и функций в Python позволит выполнить поиск, добавить нужный элемент, сделать сортировку и т. д. Итак, давайте перечислим основные методы списков и их функции (вспомним те, что уже упоминали, плюс добавим новые): 1. list.append(x) — обеспечивает добавление элемента в конец списка:
 
>>> a = [1, 2] >>> a.append(3) >>> print(a) [1, 2, 3]
2. list.extend(L) — расширяет имеющийся список путем добавления элементов из списка L.
 
>>> a = [1, 2] >>> b = [3, 4] >>> a.extend(b) >>> print(a) [1, 2, 3, 4]
3. list.insert(i, x) — добавляет, а точнее, вставляет элемент х в позицию i. В качестве первого аргумента выступает индекс элемента, после которого вставляется элемент х.
 
>>> a = [1, 2] >>> a.insert(0, 5) >>> print(a) [5, 1, 2] >>> a.insert(len(a), 9) >>> print(a) [5, 1, 2, 9]
4. list.remove(x) — служит для удаления первого вхождения элемента х, включённого в наш список.
 
>>> a = [1, 2, 3] >>> a.remove(1) >>> print(a) [2, 3]
5. list.pop([i]) — обеспечивает удаление элемента из позиции i. Если применять метод без аргумента, удаляется последний элемент, находящийся в списке.
 
>>> a = [1, 2, 3, 4, 5] >>> print(a.pop(2)) 3 >>> print(a.pop()) 5 >>> print(a) [1, 2, 4]
6. list.clear() — просто удаляет все элементы:
 
>>> a = [1, 2, 3, 4, 5] >>> print(a) [1, 2, 3, 4, 5] >>> a.clear() >>> print(a) []
7. list.index(x[, start[, end]]) — позволяет вернуть индекс элемента:
 
>>> a = [1, 2, 3, 4, 5] >>> a.index(4) 3
8. list.count(x) — возвращает число вхождений элемента х:
 
>>> a=[1, 2, 2, 3, 3] >>> print(a.count(2)) 2
9. list.sort(key=None, reverse=False) — сортирует элементы списков по возрастанию. Чтобы выполнить сортировку в обратном порядке используют флаг reverse=True. Кроме того, дополнительные возможности открываются параметром key.
 
>>> a = [1, 4, 2, 8, 1] >>> a.sort() >>> print(a) [1, 1, 2, 4, 8]
10. list.reverse() — порядок расположения элементов меняется на обратный:
 
>>> a = [1, 3, 5, 7] >>> a.reverse() >>> print(a) [7, 5, 3, 1]
11. list.copy() — копирует списки:
 
>>> a = [1, 7, 9] >>> b = a.copy() >>> print(a) [1, 7, 9] >>> print(b) [1, 7, 9] >>> b[0] = 8 >>> print(a) [1, 7, 9] >>> print(b) [8, 7, 9]
Сортировка с помощью функции sorted()
Давайте ещё раз вернёмся к вопросу сортировки в Python. Чтобы отсортировать данные и найти нужные значения, используют простую встроенную функцию sorted() , принимающую итерируемый тип и возвращающую отсортированный список.
 
a = [3, 2, 5 ,4, 7, 1] a = sorted(a) print(a) # [1, 2, 3, 4, 5, 7]
 
t = ('Zane', 'Bob', 'Janet') t = sorted(t) print(t) # ['Bob', 'Janet', 'Zane']
 
d = d = sorted(d) print(d) # [1, 2, 3]
Помните, что функция sorted() возвратит список каждый раз вне зависимости от того, какой тип будет передан.
Идём дальше. Мы уже упоминали ранее метод list.sort() . Так вот, он определён только для списков, зато функция sorted() позволит отсортировать любые итерируемые объекты:
 
>>> sorted() [1, 2, 3, 4, 5]
Сортировка по убыванию и возрастанию в Python
Ранее упомянутый параметр reverse есть не только у метода list.sort() , но и у функции sorted() . Он принимает boolean-значение и нужен для сортировки по убыванию либо возрастанию. Ниже мы сортируем учеников по убыванию их возраста:
 
>>> sorted(student_tuples, key=itemgetter(2), reverse=True) [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)] >>> sorted(student_objects, key=attrgetter('age'), reverse=True) [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
Стабильность сортировки, сложная сортировка
Начиная с Python версии 2.2, сортировки гарантированно стабильны. Речь о том, что если у записей одинаковые ключи, их порядок не меняется.
 
>>> data = [('red', 1), ('blue', 1), ('red', 2), ('blue', 2)] >>> sorted(data, key=itemgetter(0)) [('blue', 1), ('blue', 2), ('red', 1), ('red', 2)]
Здесь 2 записи с 'blue' сохранили изначальный порядок. Данное свойство позволяет сортировать сложные данные путём постепенных сортировок. Например, надо найти и отсортировать данные учеников как по возрасту в возрастающем порядке, так и по оценкам в порядке убывания. Сортировка буде выглядеть так:
 
>>> s = sorted(student_objects, key=attrgetter('age')) # по вторичному ключу >>> sorted(s, key=attrgetter('grade'), reverse=True) # по первичному [('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

Остались вопросы? Хотите поделиться своим личным опытом работы со списками? Нашли ошибку в тексте? Пишите комментарий!
Операции со списками в Python
Большинство создаваемых вами списков будут динамическими, то есть вы создадите список и затем добавляйте и удаляйте элементы из него, так обычно работают многие программы.
Например, вы можете создать игру, в которой игрок должен отстреливать инопланетян с неба. Вы можете сохранить первоначальный набор инопланетян в списке и затем удалять инопланетян из списка каждый раз, когда их сбивают. Каждый раз, когда на экране появляется новый инопланетянин, вы добавляете его в список. Ваш список инопланетян будет уменьшаться и увеличиваться в течение игры.
Изменение элементов в списке
Возможно, вы захотите добавить новый элемент в список по какой-либо причине. Например, по вышеописанной игре, вы захотите, чтобы новые инопланетяне появлялись в игре, добавляли новые данные в визуализацию или добавляли новых зарегистрированных пользователей на созданный вами веб-сайт, приложение или игру. Python предоставляет несколько способов добавления новых данных в существующие списки.
Добавление элементов в конец списка
Самый простой способ добавить новый элемент в список - использовать специальный для этого оператор append() . Когда вы добавляете элемент в список, он добавляется в конец списка. Используя тот же список, что и в статье "Списки в Python", мы добавим новый элемент 'ducati' в его конец:
motorcycles = ['honda', 'yamaha', 'suzuki'] print(motorcycles) motorcycles.append('ducati') print(motorcycles) 
Метод append () добавляет 'ducati' в конец списка, не затрагивая другие элементы в списке и получаем вот такой результат:
['honda', 'yamaha', 'suzuki'] ['honda', 'yamaha', 'suzuki', 'ducati']
Метод append () позволяет легко создавать списки динамически. Например, вы можете начать с пустого списка, а затем добавить элементы в список с помощью ряда операторов append () . Используя пустой список, давайте добавим в список элементы «honda», «yamaha» и «suzuki»:
motorcycles = [] motorcycles.append('honda') motorcycles.append('yamaha') motorcycles.append('suzuki') print(motorcycles) 
В итоге список выглядит точно так же, как списки в предыдущих примерах:
['honda', 'yamaha', 'suzuki']
Построение списков таким способом очень популярно, так как невозможно знать все данные, которые ваши пользователи хотят сохранить в программе, до ее запуска. Например, чтобы контролировать пользователей и процесс их регистрации, начните с пустого списка, в котором потом будут храниться значения пользователей. Затем следует добавить функцию, которая будет добавлять новое значение в этот список.
Вставка элементов в список
Вы можете добавить новый элемент в любую позицию списка, используя метод insert (). Это можно сделать, указав индекс нового элемента и значение нового элемента.
motorcycles = ['honda', 'yamaha', 'suzuki'] motorcycles.insert(0, 'ducati') print(motorcycles) 
В этом примере код вставляет значение «ducati» в начале списка. Метод insert () открывает пробел в позиции 0 и сохраняет значение 'ducati' в этом месте. Эта операция сдвигает все остальные значения в списке на одну позицию вправо. В итоге получаем вот такой результат:
['ducati', 'honda', 'yamaha', 'suzuki']
Удаление элементов из списка
Бывает, возникает необходимость удалить элемент или набор элементов из списка. На примере нашей воображаемой игры, когда игрок сбивает инопланетянина с неба, вы, скорее всего, захотите удалить этот элемент из списка активных инопланетян. Или когда пользователь решит удалить свою учетную запись в веб-приложении, которое вы создали, вы захотите удалить этого пользователя из списка активных пользователей. Вы можете удалить элемент в соответствии с его положением в списке или по его значению.
Удаление элемента с помощью оператора "del"
Если вам известна позиция элемента, который вы хотите удалить из списка, вы можете использовать оператор del .
motorcycles = ['honda', 'yamaha', 'suzuki'] print(motorcycles) del motorcycles[0] print(motorcycles) 
Код использует "del" для удаления первого элемента, «honda», из списка мотоциклов и получаем соответствующий результат:
['honda', 'yamaha', 'suzuki'] ['yamaha', 'suzuki']
Вы можете удалить элемент из любой позиции в списке, используя оператор del, если вы знаете его индекс. Например, вот как удалить второй элемент "yamaha" из списка:
motorcycles = ['honda', 'yamaha', 'suzuki'] print(motorcycles) del motorcycles[1] print(motorcycles) 
Второй мотоцикл удален из списка и получаем результат:
['honda', 'yamaha', 'suzuki'] ['honda', 'suzuki']
Примечание: В обоих примерах вы больше не можете получить доступ к значению, которое было удалено из списка после использования оператора del .
Удаление элемента с помощью оператора pop ()
Иногда есть необходимость использовать значение элемента после его удаления из списка. Например, вы можете получить координаты x и y в корабля пришельца в нашей воображаемой игре, который только что сбили, чтобы вы могли нарисовать взрыв в этой позиции. В веб-приложении, например, может потребоваться удалить пользователя из списка активных участников, а затем добавить этого пользователя в список неактивных участников.
Метод pop () удаляет последний элемент в списке, но позволяет вам работать с этим элементом после его удаления. Термин «pop» происходит от того, что вы думаете о списке как о пачке предметов и выталкиваете один предмет из верхней его части. Давайте удалим мотоцикл из нашего списка:
motorcycles = ['honda', 'yamaha', 'suzuki'] print(motorcycles) popped_motorcycle = motorcycles.pop() print(motorcycles) print(popped_motorcycle) 
Начнем с определения и вывода списка мотоциклов, затем мы извлекаем значение из списка и сохраняем его в переменной "popped_motorcycle". Далее выводим список, чтобы показать, что значение было удалено из списка. Затем мы выводим удалённое значение, чтобы доказать, что у нас все еще есть доступ к удаленному значению. Вывод показывает, что значение "suzuki" было удалено из конца списка и теперь хранится в переменной "popped_motorcycle":
['honda', 'yamaha', 'suzuki'] ['honda', 'yamaha'] suzuki
Чем ещё может быть полезен метод pop () ? Представьте, что мотоциклы в списке хранятся в хронологическом порядке в зависимости от того, когда мы владели ими. Если это так, мы можем использовать метод pop () , чтобы напечатать инструкцию о последнем мотоцикле, который мы купили:
motorcycles = ['honda', 'yamaha', 'suzuki'] last_owned = motorcycles.pop() print("The last motorcycle I owned was a " + last_owned.title() + ".") 
Вывод представляет собой простое предложение о самом последнем мотоцикле, который у нас был:
The last motorcycle I owned was a Suzuki.
Удаление элементов из любой позиции в списке
На самом деле вы можете использовать pop () для удаления элемента в списке в любой позиции, включив в скобки индекс элемента, который вы хотите удалить.
motorcycles = ['honda', 'yamaha', 'suzuki'] first_owned = motorcycles.pop(0) print('The first motorcycle I owned was a ' + first_owned.title() + '.') 
В этом примере мы указываем, чтобы в выводе появлялся первый элемент списка и выводим его на экран, соответственно получаем:
The first motorcycle I owned was a Honda.
Помните, что каждый раз, когда вы используете pop () , элемент, с которым вы работаете, больше не сохраняется в списке, но он доступен в другой переменной. Если вы не уверены, использовать ли оператор del или метод pop () , вот простой способ, чтобы решить: когда вы хотите удалить элемент из списка и никоим образом не использовать этот элемент, используйте оператор del ; если вы хотите использовать элемент при его удалении, используйте метод pop () .
Удаление элемента по значению
Иногда вы не знаете положение элемента в списке, которое хотите удалить из него. Если вам известно только значение элемента, который вы хотите удалить, вы можете использовать метод remove () .
Например, допустим, мы хотим удалить значение «ducati» из списка мотоциклов.
motorcycles = ['honda', 'yamaha', 'suzuki', 'ducati'] print(motorcycles) motorcycles.remove('ducati') print(motorcycles) 
Код сообщает Python, чтобы выяснить, где в списке появляется «ducati», и удалить этот элемент:
['honda', 'yamaha', 'suzuki', 'ducati'] ['honda', 'yamaha', 'suzuki']
Вы также можете использовать метод remove () для работы со значением, которое удаляется из списка. Давайте удалим значение "ducati" и напишем причину его удаления из списка:
motorcycles = ['honda', 'yamaha', 'suzuki', 'ducati'] print(motorcycles) too_expensive = 'ducati' motorcycles.remove(too_expensive) print(motorcycles) print("\nA " + too_expensive.title() + " is too expensive for me.") 
После определения списка мы сохраняем значение "ducati" в переменной с именем "too_expensive". Затем используйте эту переменную, чтобы сообщить Python, какое значение удалить из списка. Значение "ducati" было удалено из списка, но все еще сохраняется в переменной "too_expensive", что позволяет нам распечатать заявление о том, почему мы удалили "ducati" из списка мотоциклов:
['honda', 'yamaha', 'suzuki', 'ducati'] ['honda', 'yamaha', 'suzuki'] A Ducati is too expensive for me.
Примечание: Метод remove () удаляет только первое вхождение указанного вами значения. Если существует вероятность, что значение появляется в списке более одного раза, нужно использовать циклы, чтобы определить, все ли значения этого значения были удалены. Вы узнаете, как это сделать, в статье Циклы в Python.
Работа над списком
Зачастую списки формируются в непредсказуемом порядке, не всегда можно контролировать, как пользователи предоставляют свои данные. Часто требуется представлять информацию в определенном порядке. Иногда нужно сохранить первоначальный порядок в списке, а в других случаях нужно изменить его. Python предоставляет несколько различных способов организации ваших списков, в зависимости от ситуации.
Постоянная сортировка списка с помощью метода sort ()
Метод sort () позволяет относительно легко сортировать список. Представьте, что у нас есть список автомобилей, и мы хотим представить его в алфавитном порядке. Чтобы упростить задачу, давайте предположим, что все значения в списке строчные.
cars = ['bmw', 'audi', 'toyota', 'subaru'] cars.sort() print(cars) 
Метод sort () , показанный в примере, хранит перечень автомобилей в алфавитном порядке, и далее нельзя его переделать к первоначальному состоянию:
['audi', 'bmw', 'subaru', 'toyota']
Вы также можете отсортировать этот список в обратном алфавитном порядке, передав аргумент reverse = True методу sort ( ). Следующий пример сортирует список автомобилей в обратном алфавитном порядке:
cars = ['bmw', 'audi', 'toyota', 'subaru'] cars.sort(reverse=True) print(cars) 
И получаем вот такой соответствующий вывод данных:
['toyota', 'subaru', 'bmw', 'audi']
Временная сортировка списка с помощью функции sorted ()
Чтобы сохранить первоначальный порядок списка, но представить его в отсортированном порядке, вы можете использовать функцию sorted () . Функция sorted () позволяет вам отображать ваш список в определенном порядке, но не влияет на фактический порядок списка. Давайте попробуем эту функцию в списке автомобилей:
cars = ['bmw', 'audi', 'toyota', 'subaru'] print("Here is the original list:") print(cars) print("\nHere is the sorted list:") print(sorted(cars)) print("\nHere is the original list again:") print(cars) 
Сначала мы печатаем список в исходном порядке, а затем в алфавитном порядке. После отображения списка в новом порядке, мы показываем, что список все еще сохраняется в своем первоначальном порядке.
Here is the original list: ['bmw', 'audi', 'toyota', 'subaru'] Here is the sorted list: ['audi', 'bmw', 'subaru', 'toyota'] Here is the original list again: ['bmw', 'audi', 'toyota', 'subaru']
Обратите внимание, что список все еще существует в своем первоначальном порядке после использования функции sorted () . Функция sorted () также может принимать аргумент reverse = True , если вы хотите отобразить список в обратном алфавитном порядке.
Примечание: Сортировка списка по алфавиту немного сложнее, когда все значения не в нижнем регистре. Есть несколько способов интерпретировать заглавные буквы, когда вы выбираете порядок сортировки, и указание точного порядка может быть более сложным, чем мы хотим сделать в данный момент. Однако большинство подходов к сортировке будут основываться непосредственно на том, что вы узнали в этом разделе.
Вывод списка в обратном порядке
Чтобы изменить исходный порядок списка, вы можете использовать метод reverse () . Если бы мы изначально хранили список автомобилей в хронологическом порядке в соответствии с тем, когда мы его составляли, мы можем легко перестроить список в обратном хронологическом порядке:
cars = ['bmw', 'audi', 'toyota', 'subaru'] print(cars) cars.reverse() print(cars) 
Обратите внимание, что reverse () не сортирует в обратном порядке по алфавиту; он просто меняет порядок списка:
['bmw', 'audi', 'toyota', 'subaru'] ['subaru', 'toyota', 'audi', 'bmw']
Метод reverse ( ) постоянно меняет порядок списка, но вы можете в любое время вернуться к исходному порядку, применив reverse () к тому же списку во второй раз.
Определение длины списка
Вы можете быстро определить количество элементов в списке с помощью функции len () . Список в нашем примере состоит из четырех элементов:
cars = ['bmw', 'audi', 'toyota', 'subaru'] print(len(names)) 
Соотвественно получаем вывод:
Вы дальнейшем Вы поймёте как функция len () полезна, например в нашей воображаемой игре нужно определить количество инопланетян, которые все еще необходимо сбить, или определить количество данных, которыми вы должны управлять в визуализации, или выяснить количество зарегистрированных пользователи на сайте и так далее.
Примечание
Основная статья: Циклы со списками в Python

Основная статья: Дополнительные операции со списками в Python
В этой статье вы узнали, что такое списки и как работать с отдельными элементами в списке. Вы узнали, как определить список и как добавлять и удалять элементы в нём. Вы научились сортировать списки постоянно и временно для отображения.
В дальнейших статьях вы узнаете, как более эффективно работать с элементами в списке, как создавать циклы каждого элемента в списке, используя всего несколько строк кода, вы сможете эффективно работать, даже если ваш список содержит тысячи или миллионы данных. Если возникли вопросы, комментарии, то оставляйте их на странице обсуждения.
Другие статьи о Python
Язык программирования Python

Операции со строкой
Операции со списками
Дополнительные операции со списками
Операции со словарями
Циклы
Циклы со списками
Дополнительные операции со словарями
Ввод данных
Условные операторы
Циклы со словарями
Функции
Классы
Работа с файлами в Python
Тестирование кода в Python

Читать:
Как подключить видео в zoom