Метод append
Метод append позволяет вставить в конец какого-либо элемента другой элемент. Параметром метод принимает элемент, как правило созданный через createElement , либо строку. Можно добавить сразу несколько элементов или строк, перечислив их через запятую.
Синтаксис
родитель.append(элемент или строка);
Пример
Давайте создадим абзац, установим ему текст и поместим на страницу в конец блока #parent :
1
2
3
let parent = document.querySelector(‘#parent’); let p = document.createElement(‘p’); p.textContent = ‘!’; parent.append(p);
Результат выполнения кода:
Пример
Поместим сразу несколько абзацев в конец блока #parent :
1
2
3
let parent = document.querySelector(‘#parent’); let p1 = document.createElement(‘p’); p1.textContent = ‘a’; let p2 = document.createElement(‘p’); p2.textContent = ‘b’; parent.append(p1, p2);
Результат выполнения кода:
Пример
Давайте в качестве параметра метода используем строку:
1
2
3
let parent = document.querySelector(‘#parent’); parent.append(‘!’);
Результат выполнения кода:
Пример
Дан ul . Давайте разместим в нем 9 тегов li , при этом их текстом сделаем порядковые номера:
let parent = document.querySelector(‘#parent’); for (let i = 1; i
Результат выполнения кода:
Пример
Давайте заполним таблицу tr-ками и td-шками:
Результат выполнения кода:
| 1 | 2 | 3 |
| 1 | 2 | 3 |
| 1 | 2 | 3 |
Смотрите также
- метод prepend ,
который вставляет элементы в начало - метод appendChild ,
который вставляет элементы в конец - метод insertBefore ,
который вставляет элемент в перед элементом - метод insertAdjacentElement ,
который вставляет элемент в заданное место - метод insertAdjacentHTML ,
который вставляет теги в заданное место
Python. Урок 7. Работа со списками (list)
Одна из ключевых особенностей Python, благодаря которой он является таким популярным – это простота. Особенно подкупает простота работы с различными структурами данных – списками, кортежами, словарями и множествами. Сегодня мы рассмотрим работу со списками.
Что такое список (list) в Python?
Список (list) – это структура данных для хранения объектов различных типов. Если вы использовали другие языки программирования, то вам должно быть знакомо понятие массива. Так вот, список очень похож на массив, только, как было уже сказано выше, в нем можно хранить объекты различных типов. Размер списка не статичен, его можно изменять. Список по своей природе является изменяемым типом данных. Про типы данных можно подробно прочитать здесь . Переменная, определяемая как список, содержит ссылку на структуру в памяти, которая в свою очередь хранит ссылки на какие-либо другие объекты или структуры.
Как списки хранятся в памяти?
Как уже было сказано выше, список является изменяемым типом данных. При его создании в памяти резервируется область, которую можно условно назвать некоторым “контейнером”, в котором хранятся ссылки на другие элементы данных в памяти. В отличии от таких типов данных как число или строка, содержимое “контейнера” списка можно менять. Для того, чтобы лучше визуально представлять себе этот процесс взгляните на картинку ниже. Изначально был создан список содержащий ссылки на объекты 1 и 2, после операции a[1] = 3, вторая ссылка в списке стала указывать на объект 3.
Более подробно эти вопросы обсуждались в уроке 3 (Типы и модель данных).
Создание, изменение, удаление списков и работа с его элементами
Создать список можно одним из следующих способов.
>>> a = [] >>> type(a) >>> b = list() >>> type(b)
Также можно создать список с заранее заданным набором данных.
>>> a = [1, 2, 3] >>> type(a)
Если у вас уже есть список и вы хотите создать его копию, то можно воспользоваться следующим способом:
>>> a = [1, 3, 5, 7] >>> b = a[:] >>> print(a) [1, 3, 5, 7] >>> print(b) [1, 3, 5, 7]
или сделать это так:
>>> a = [1, 3, 5, 7] >>> b = list(a) >>> print(a) [1, 3, 5, 7] >>> print(b) [1, 3, 5, 7]
В случае, если вы выполните простое присвоение списков друг другу, то переменной b будет присвоена ссылка на тот же элемент данных в памяти, на который ссылается 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]
Изменить значение элемента списка, зная его индекс, можно напрямую к нему обратившись.
>>> d = [2, 4, 9] >>> print(d) [2, 4, 9] >>> d[1] = 17 >>> print(d) [2, 17, 9]
Очистить список можно просто заново его проинициализировав, так как будто вы его вновь создаете. Для получения доступа к элементу списка укажите индекс этого элемента в квадратных скобках.
>>> a = [3, 5, 7, 10, 3, 2, 6, 0] >>> a[2] 7
Можно использовать отрицательные индексы, в таком случае счет будет идти с конца, например для доступа к последнему элементу списка можно использовать вот такую команду:
>>> a[-1] 0
Для получения из списка некоторого подсписка в определенном диапазоне индексов, укажите начальный и конечный индекс в квадратных скобках, разделив их двоеточием.
>>> a[1:4] [5, 7, 10]
Методы списков
list.append(x)
Добавляет элемент в конец списка. Ту же операцию можно сделать так a[len(a):] = [x].
>>> a = [1, 2] >>> a.append(3) >>> print(a) [1, 2, 3]
list.extend(L)
Расширяет существующий список за счет добавления всех элементов из списка L. Эквивалентно команде a[len(a):] = L.
>>> a = [1, 2] >>> b = [3, 4] >>> a.extend(b) >>> print(a) [1, 2, 3, 4]
list.insert(i, x)
Вставить элемент x в позицию i. Первый аргумент – индекс элемента после которого будет вставлен элемент x.
>>> a = [1, 2] >>> a.insert(0, 5) >>> print(a) [5, 1, 2] >>> a.insert(len(a), 9) >>> print(a) [5, 1, 2, 9]
list.remove(x)
Удаляет первое вхождение элемента x из списка.
>>> a = [1, 2, 3] >>> a.remove(1) >>> print(a) [2, 3]
Удаляет элемент из позиции i и возвращает его. Если использовать метод без аргумента, то будет удален последний элемент из списка.
>>> a = [1, 2, 3, 4, 5] >>> print(a.pop(2)) 3 >>> print(a.pop()) 5 >>> print(a) [1, 2, 4]
list.clear()
Удаляет все элементы из списка. Эквивалентно del a[:].
>>> a = [1, 2, 3, 4, 5] >>> print(a) [1, 2, 3, 4, 5] >>> a.clear() >>> print(a) []
list.index(x[, start[, end]])
Возвращает индекс элемента.
>>> a = [1, 2, 3, 4, 5] >>> a.index(4) 3
list.count(x)
Возвращает количество вхождений элемента x в список.
>>> a=[1, 2, 2, 3, 3] >>> print(a.count(2)) 2
list.sort(key=None, reverse=False)
Сортирует элементы в списке по возрастанию. Для сортировки в обратном порядке используйте флаг reverse=True. Дополнительные возможности открывает параметр key, за более подробной информацией обратитесь к документации.
>>> a = [1, 4, 2, 8, 1] >>> a.sort() >>> print(a) [1, 1, 2, 4, 8]
list.reverse()
Изменяет порядок расположения элементов в списке на обратный.
>>> a = [1, 3, 5, 7] >>> a.reverse() >>> print(a) [7, 5, 3, 1]
list.copy()
Возвращает копию списка. Эквивалентно a[:].
>>> 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]
List Comprehensions
List Comprehensions чаще всего на русский язык переводят как абстракция списков или списковое включение, является частью синтаксиса языка, которая предоставляет простой способ построения списков. Проще всего работу list comprehensions показать на примере. Допустим вам необходимо создать список целых чисел от 0 до n, где n предварительно задается. Классический способ решения данной задачи выглядел бы так:
>>> n = int(input()) 7 >>> a=[] >>> for i in range(n): a.append(i) >>> print(a) [0, 1, 2, 3, 4, 5, 6]
Использование list comprehensions позволяет сделать это значительно проще:
>>> n = int(input()) 7 >>> a = [i for i in range(n)] >>> print(a) [0, 1, 2, 3, 4, 5, 6]
или вообще вот так, в случае если вам не нужно больше использовать n:
>>> a = [i for i in range(int(input()))] 7 >>> print(a) [0, 1, 2, 3, 4, 5, 6]
List Comprehensions как обработчик списков
В языке Python есть две очень мощные функции для работы с коллекциями: map и filter . Они позволяют использовать функциональный стиль программирования, не прибегая к помощи циклов, для работы с такими типами как list , tuple , set , dict и т.п. Списковое включение позволяет обойтись без этих функций. Приведем несколько примеров для того, чтобы понять о чем идет речь.
Пример с заменой функции map .
Пусть у нас есть список и нужно получить на базе него новый, который содержит элементы первого, возведенные в квадрат. Решим эту задачу с использованием циклов:
>>> a = [1, 2, 3, 4, 5, 6, 7] >>> b = [] >>> for i in a: b.append(i**2) >>> print('a = <>\nb = <>'.format(a, b)) a = [1, 2, 3, 4, 5, 6, 7] b = [1, 4, 9, 16, 25, 36, 49]
Та же задача, решенная с использованием map , будет выглядеть так:
>>> a = [1, 2, 3, 4, 5, 6, 7] >>> b = list(map(lambda x: x**2, a)) >>> print('a = <>\nb = <>'.format(a, b)) a = [1, 2, 3, 4, 5, 6, 7] b = [1, 4, 9, 16, 25, 36, 49]
В данном случае применена lambda -функция, о том, что это такое и как ее использовать можете прочитать здесь.
Через списковое включение эта задача будет решена так:
>>> a = [1, 2, 3, 4, 5, 6, 7] >>> b = [i**2 for i in a] >>> print('a = <>\nb = <>'.format(a, b)) a = [1, 2, 3, 4, 5, 6, 7] b = [1, 4, 9, 16, 25, 36, 49]
Пример с заменой функции filter .
Построим на базе существующего списка новый, состоящий только из четных чисел:
>>> a = [1, 2, 3, 4, 5, 6, 7] >>> b = [] >>> for i in a: if i%2 == 0: b.append(i) >>> print('a = <>\nb = <>'.format(a, b)) a = [1, 2, 3, 4, 5, 6, 7] b = [2, 4, 6]
Решим эту задачу с использованием filter :
>>> a = [1, 2, 3, 4, 5, 6, 7] >>> b = list(filter(lambda x: x % 2 == 0, a)) >>> print('a = <>\nb = <>'.format(a, b)) a = [1, 2, 3, 4, 5, 6, 7] b = [2, 4, 6]
Решение через списковое включение:
>>> a = [1, 2, 3, 4, 5, 6, 7] >>> b = [i for i in a if i % 2 == 0] >>> print('a = <>\nb = <>'.format(a, b)) a = [1, 2, 3, 4, 5, 6, 7] b = [2, 4, 6]
Слайсы / Срезы
Слайсы (срезы) являются очень мощной составляющей Python , которая позволяет быстро и лаконично решать задачи выборки элементов из списка. Выше уже был пример использования слайсов, здесь разберем более подробно работу с ними. Создадим список для экспериментов:
>>> a = [i for i in range(10)]
Слайс задается тройкой чисел, разделенных запятой: start:stop:step . Start – позиция с которой нужно начать выборку, stop – конечная позиция, step – шаг. При этом необходимо помнить, что выборка не включает элемент определяемый stop .
>>> # Получить копию списка >>> a[:] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] >>> # Получить первые пять элементов списка >>> a[0:5] [0, 1, 2, 3, 4] >>> # Получить элементы с 3-го по 7-ой >>> a[2:7] [2, 3, 4, 5, 6] >>> # Взять из списка элементы с шагом 2 >>> a[::2] [0, 2, 4, 6, 8] >>> # Взять из списка элементы со 2-го по 8-ой с шагом 2 >>> a[1:8:2] [1, 3, 5, 7]
Слайсы можно сконструировать заранее, а потом уже использовать по мере необходимости. Это возможно сделать, в виду того, что слайс – это объект класса slice . Ниже приведен пример, демонстрирующий эту функциональность:
>>> s = slice(0, 5, 1) >>> a[s] [0, 1, 2, 3, 4] >>> s = slice(1, 8, 2) >>> a[s] [1, 3, 5, 7]
Типо “List Comprehensions”… в генераторном режиме
Есть ещё одни способ создания списков, который похож на списковое включение, но результатом работы является не объект класса list , а генератор. Подробно про генераторы написано в “ Уроке 15. Итераторы и генераторы“.
Предварительно импортируем модуль sys , он нам понадобится:
>>> import sys
Создадим список, используя списковое включение :
>>> a = [i for i in range(10)]
проверим тип переменной a:
>>> type(a)
и посмотрим сколько она занимает памяти в байтах:
>>> sys.getsizeof(a) 192
Для создания объекта-генератора, используется синтаксис такой же как и для спискового включения, только вместо квадратных скобок используются круглые:
>>> b = (i for i in range(10)) >>> type(b) >>> sys.getsizeof(b) 120
Обратите внимание, что тип этого объекта ‘generator’ , и в памяти он занимает места меньше, чем список, это объясняется тем, что в первом случае в памяти хранится весь набор чисел от 0 до 9, а во втором функция, которая будет нам генерировать числа от 0 до 9. Для наших примеров разница в размере не существенна, рассмотрим вариант с 10000 элементами:
>>> c = [i for i in range(10000)] >>> sys.getsizeof(c) 87624 >>> d = (i for i in range(10000)) >>> sys.getsizeof(d) 120
Сейчас уже разница существенна, как вы уже поняли, размер генератора в данном случае не будет зависеть от количества чисел, которые он должен создать.
Если вы решаете задачу обхода списка, то принципиальной разницы между списком и генератором не будет:
>>> for val in a: print(val, end=' ') 0 1 2 3 4 5 6 7 8 9 >>> for val in b: print(val, end=' ') 0 1 2 3 4 5 6 7 8 9
Но с генератором нельзя работать также как и со списком: нельзя обратиться к элементу по индексу и т.п.
P.S.
Если вам интересна тема анализа данных, то мы рекомендуем ознакомиться с библиотекой Pandas. На нашем сайте вы можете найти вводные уроки по этой теме. Все уроки по библиотеке Pandas собраны в книге “Pandas. Работа с данными”.
Раздел: Python Уроки по Python Метки: Python, Уроки Python
Python. Урок 7. Работа со списками (list) : 53 комментария
- навруз 17.12.2017 там ошибка
Изменить значение элемента списка, зная его индекс, можно напрямую к нему обратившись. >>> d = [2, 4, 9]
>>> print(d)
[2, 4, 9]
>>> d[1] = 17 индекс указан первый, следовательно должен измениться первый элемент.
>>> print(d)
[2, 17, 9] а тут изменен второй элемент. Вывод должен выглядеть так [17, 4, 9] Если я не
ошибаюсь)))
- writer 18.12.2017 В Python элементы списка нумеруются с нуля. Поэтому в списке [2, 4, 9], элемент с индексом 1 – это 4, и если мы сделаем присваивание d[1] = 17, то поменяем средний элемент в списке, так как это показано в примере!
Удачи!
- навруз 20.12.2017 ой спасибо за обьяснение)) изивиняюсь за ложные обвинения и невнимательность)))
- writer 20.12.2017 Пожалуйста! Спасибо вам за интерес к блогу)))
Операции со списками в 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
python. как сохранить несколько значений в список через input
Вы можете сохранять переменную в файл и загружать ее из него с помощью встроенного модуля pickle :
import pickle import os storage_filename = "storage.pickle" list = ['спать', 'Машина', 'Мотоцикл', 'Еще что-нибудь', 'тд'] if not os.path.exists(storage_filename): # Если файла не существует with open(storage_filename, "wb") as f: # То создаем его pickle.dump(list, f) # Сохрняя в него наш список else: # Если же существует with open(storage_filename, "rb") as f: list = pickle.load(f) # То загружаем из него список num = input('Введите слово:') list.append(num) for i in list: print(i) with open(storage_filename, "wb") as f: pickle.dump(list, f) # Сохраняем измененный список в файл