Составьте краткое изложение этой истории. Вот краткое изложение содержания истории, основанное на фактах: Вот упрощенная версия содержания истории: Вот беззаботный взгляд на содержание истории: Исследуйте другую точку зрения: Покажите мне факты Объясните это так, будто мне 5 лет Дайте мне беззаботный пересказ
Документация не очень удобна для новичков, а в обучающих материалах часто встречаются пробелы. Изучение Python может показаться сложным, так что вы не одиноки. Чтобы решить эту проблему, я подготовил краткое и практичное руководство, которое поможет вам быстро улучшить навыки работы со списками в Python — и всё это менее чем за 30 минут!
Списки — это последовательность элементов, которые хранятся в памяти рядом друг с другом, подобно списку покупок на листе бумаги. Списки также предоставляют операции (называемые методами), позволяющие выполнять над ними действия. Например, чтобы добавить элемент в список, используйте my_shopping_list.append(‘молоко’). Существует множество методов, и по ходу дела мы рассмотрим наиболее важные из них.
Основы работы со списками: создание и доступ к элементам
Создание списка
Чтобы создать список, просто присвойте переменной квадратные скобки:
мой_список_покупок = []
Вы можете инициализировать списки с предопределенными элементами:
my_shopping_list = [«молоко», «хлеб», «сахар»]
Вы можете хранить различные типы данных в списках и даже в других списках:
my_shopping_list = [«молоко», 1, [1, 2, 3], Истина]
Прямые задания
Если в существующем списке есть элементы, мы можем напрямую изменить эти элементы:
my_shopping_list = [«молоко», «хлеб», «сахар»]
my_shopping_list[0] = «кофе»
печать(мой_список_покупок)
my_shopping_list[2] = «бананы»
печать(мой_список_покупок)
Число в квадратных скобках называется индексом, и мы используем его для обращения к отдельным элементам списка. Первый элемент всегда имеет номер 0, второй — 1 и так далее.
Элементы списка доступа
Теперь, когда в вашем списке есть элементы, вам нужно получить к ним доступ:
my_shopping_list = [«молоко», «хлеб», «сахар»]
печать(my_shopping_list[0])
печать(my_shopping_list[1])
Напротив, Python позволяет получать доступ к элементам, начиная с конца, используя отрицательные числа:
my_shopping_list = [«молоко», «хлеб», «сахар»]
печать(my_shopping_list[-1])
печать(my_shopping_list[-2])
Команда конечные числа начинать с -1а не 0.
Цикл по списку
A поиска В общем случае программирование — это конструкция, которая повторяет действие N раз. Например, если список содержит три элемента, цикл будет проходить по нему, позволяя выполнять действия над каждым элементом. Ниже приведён пример цикла for:
my_shopping_list = [«молоко», «хлеб», «сахар»]
для товара в my_shopping_list:
печать (элемент)
Для каждого товара из списка «my_shopping_list» цикл присваивает его переменной «item». Мы можем просто вывести эту переменную на экран, чтобы продемонстрировать, как это работает.
На каждом из них можно выполнить любое действие. пункт. Например, добавьте к элементу восклицательный знак и выведите его на печать:
my_shopping_list = [«молоко», «хлеб», «сахар»]
для товара в my_shopping_list:
print(item + «!») # Восклицательный знак.
Извлечение частей списка (также известное как нарезка)
Извлечение частей списка называется нарезка. Разбиение не изменяет исходный список, а возвращает новый список с нужными элементами.
Если вы хотите получить первые два элемента:
my_shopping_list = [«молоко», «хлеб», «сахар»]
печать(мой_список_покупок[0:2])
Вы можете видеть, что мы предоставляем индексы 0 и 2, разделенные двоеточием — это то же самое, что сказать ноль, до, но не включая, два.
Помните, что 0 и 1 — это первые два элемента.
Если вы не укажете число после или до двоеточия, будет возвращена оставшаяся часть списка. Например, следующий код возвращает второй элемент и оставшуюся часть списка:
my_shopping_list = [«молоко», «хлеб», «сахар»]
печать(мой_список_покупок[1:])
Это вернет все до 2:
my_shopping_list = [«молоко», «хлеб», «сахар»]
печать(мой_список_покупок[:2])
Обратная нарезка
Вы можете выполнять срезы в обратном порядке, используя отрицательные числа в качестве индексов. Python обрабатывает отрицательные индексы относительно конца списка; например, -1 означает последний элемент, а -2 — предпоследний элемент.
Следующий пример начинается с предпоследнего элемента (-2) и продолжается в конец списка.
my_shopping_list = [«молоко», «хлеб», «сахар»]
печать(my_shopping_list[-2:])
Помните, что конечные индексы не начинаются с 0; они начинаются с -1.
Изменение списка: добавление, удаление и сортировка элементов
Чтобы изменить структуру списка (а не его существующие значения), проще всего (и лучше всего) использовать стандартные методы, предоставляемые Python.
добавление ()
Добавить означает добавить в конец списка.
my_shopping_list = [«молоко», «хлеб», «сахар»]
my_shopping_list.append(«бананы»)
печать(мой_список_покупок)
my_shopping_list.append(«сыр»)
печать(мой_список_покупок)
вставка ()
Вставка похожа на добавление, за исключением того, что она добавляет элементы в указанный индекс.
my_shopping_list = [«молоко», «хлеб», «сахар»]
# 1
my_shopping_list.insert(0, «бананы»)
печать(мой_список_покупок)
# 2
my_shopping_list.insert(2, «сыр»)
печать(мой_список_покупок)
Видно, что вставка в индекс 0 помещает его в начало, а вставка в индекс 2 помещает его в третий элемент.
Использовать вставить Используйте этот метод с осторожностью. Для больших списков (например, миллионов) это может повлиять на производительность, поскольку Python перемещает каждый последующий элемент на одну позицию вверх, чтобы освободить место для нового элемента.
Удалить()
Обеспечьте удаление метод с образцом того, что вы хотите удалить, и он удалит первый экземпляр, с которым он сталкивается.
my_shopping_list = [«молоко», «хлеб», «сахар»]
# 1
my_shopping_list.remove(«молоко»)
печать(мой_список_покупок)
# 2
my_shopping_list.remove(«сахар»)
печать(мой_список_покупок)
Сортировка
Сортировка списка в Python проста, и у вас есть два варианта:
- На месте: изменяет список.
- Не на месте: возвращает новый список и не изменяет исходный список.
Команда sort метод находится на месте и изменяет исходный список.
my_shopping_list = [«молоко», «хлеб», «сахар»]
мой_список_покупок.сорт()
печать(мой_список_покупок)
Обратите внимание, что товары отсортированы по алфавиту? Также обратите внимание, что мы не переназначили «my_shopping_list», но при печати список был отсортирован. Это сортировка на месте.
Команда отсортированный метод неуместен и не изменяет исходный список.
my_shopping_list = [«молоко», «хлеб», «сахар»]
мой_сортированный_список = сортированный(мой_список_покупок)
печать(my_shopping_list) # 1
печать (мой_сортированный_список) # 2
Заметили, что список «my_shopping_list» остался неизменным? Метод «sorted» возвращает новый список: «my_sorted_list».
Использование информации из списка для принятия разумных решений
Проверка длины списка
Наиболее распространенной операцией со списком, вероятно, является проверка длины списка с помощью только функции.
my_shopping_list = [«молоко», «хлеб», «сахар»]
если len(my_shopping_list) > 0:
print(«Список не пуст.»)
Как видите, длина списка больше или равна нулю.
Условное использование списков
Списки можно использовать в условных операторах (например, if Пустой список является ложным (эквивалентно «ложь»); заполненный список является истинным (эквивалентно «истина»).
если []:
print(«Пустой список — это правда.») # Это не так.
если [«foo»]:
print(«Заполненный список правдив.»)
Это распространенный способ проверить, есть ли в списке любое предметы.
Сравнение списков
Чтобы сравнивать списки, важно понимать две ключевые концепции:
- Равенство: имеют ли списки одинаковые фактов?
- Идентичность: Являются ли списки точно такой же объект в памяти?
Проверка на равенство проверяет, содержат ли списки одинаковые элементы; если да, то списки считаются равными. Для проверки на равенство используется оператор «==».
один = [1]
два = [2]
также_один = [1]
если один == два:
print(«Разные списки равны.») # Это не так.
если один == один:
print(«Список равен самому себе.»)
если один == также_один:
print(«Разные списки с одинаковыми элементами равны.»)
Проверка идентичности сравнивает адреса памяти двух объектов (списков), чтобы определить, указывают ли они на одно и то же место в памяти. Мы используем is оператор для проведения проверки личности:
один = []
два = []
если один равен двум:
print(«Разные списки имеют одинаковую идентичность.») # Это не так.
если один один:
print(«Список имеет ту же идентичность, что и он сам.»)
Список членов
Вам часто понадобится узнать, содержит ли список что-либо, и вы можете сделать это с помощью специальной функции in оператор.
my_shopping_list = [«молоко», «хлеб», «сахар»]
если «молоко» в my_shopping_list:
print(«Есть молоко!»)
если «cookies» в my_shopping_list:
print(«Есть печенье!») # Нет.
Преобразование списков: превращение элементов во что-то другое
Используйте map() для изменения элементов
Карта — распространённый способ преобразования списков в большинстве языков программирования. В Python карта Функция циклически перебирает список и применяет заданную вами функцию к каждому элементу. Функция получает каждый элемент в качестве аргумента, и вы можете делать с ним всё, что захотите. Возвращаемое значение заменяет этот элемент в списке.
Вкратце: Map применяет к каждому элементу заданную пользователем функцию. Используйте эту функцию для преобразования каждого значения.
my_shopping_list = [«молоко», «хлеб», «сахар»]
def apply_uppercase(элемент):
вернуть item.upper()
map_object = map(apply_uppercase, my_shopping_list)
mapped_list = list(map_object) # Превращаем его обратно в список.
печать(отображенный_список)
Используйте filter() для удаления элементов
Фильтр работает примерно так же карта, за исключением того, что она удаляет элементы из списка. Функция получает каждое значение и определяет, сохранить или удалить элемент. Возвращение значения true означает, что сохранить ценность, и ложные средства отбрасывать.
my_shopping_list = [«молоко», «хлеб», «сахар»]
def sugar_free(элемент):
# Сохраните все, что не является сахаром.
return item != «sugar» # True: Сохранить; False: Выбросить.
объект_фильтра = фильтр(без_сахара, мой_список_покупок)
mapped_list = list(filter_object) # Превращаем его обратно в список.
печать(отображенный_список)
Бонусные советы: вам стоит это прочитать
Список рекомендаций
Генераторы списков — это компактный способ создания списка из другого списка. Он работает примерно так же, как карта (рассматривалось ранее).
my_shopping_list = [«молоко», «хлеб», «сахар»]
# 1
скопированный_лист = [элемент для элемента в my_shopping_list]
печать(скопированный_список)
# 2
changed_list = [item.upper() для товара в my_shopping_list]
печать(изменённый_список)
Команда второй понимание списка такое же как:
my_shopping_list = [«молоко», «хлеб», «сахар»]
# Функционально то же самое, что и #2.
измененный_список = []
для товара в my_shopping_list:
измененный_список.добавить(item.upper())
печать(изменённый_список)
На этом изображении показано, как представление списка соотносится с обычным списком Python.
- Токен 1: я его подчеркнул, и он связан с другим подчёркнутым токеном. Этот токен — переменная, с которой вы работаете; именно это значение вы меняете.
- Токен 2: относится к объявлению переменной; здесь вы присваиваете имя токену, в данном примере это «item».
- Токен 3: относится к списку, по которому выполняется цикл (итерация).
Списки распаковки
Получение элементов из списка может оказаться неприятным занятием:
my_shopping_list = [«молоко», «хлеб», «сахар»]
молоко = мой_список_покупок[0]
хлеб = мой_список_покупок[1]
сахар = мой_список_покупок[2]
Вместо этого предпочитайте распаковку списка — чистый метод извлечения каждого элемента в переменные:
my_shopping_list = [«молоко», «хлеб», «сахар»]
молоко, хлеб, сахар = my_shopping_list
печать(молоко, хлеб, сахар)
Позиции имён переменных соответствуют позициям в списке, а количество переменных должно соответствовать количеству элементов. Вот что произойдёт, если переменных недостаточно:
Чтобы исправить это, можно использовать оператор «звёздочка» (звёздочка) для элемента. В этом случае переменная со звёздочкой представляет собой список нескольких переменных — по сути, это всё остальное, что явно не присвоено переменной. Имейте в виду, что порядок имеет значение:
my_shopping_list = [«молоко», «хлеб», «масло», «бананы», «сахар»]
молоко, хлеб, *разное, сахар = my_shopping_list
печать(молоко, хлеб, разное, сахар)
Глубокое копирование
При использовании сложных объектов (экземпляров классов, списков и т. д.) важно понимать, что это не просто значения. Сохранение объекта в переменной фактически представляет собой адрес памяти, указывающий на место в памяти, где находится объект.
Возьмем следующий пример:
# Мы изменим это, и только этот список.
milk_and_bread = [«молоко», «хлеб»]
# Добавьте молоко и хлеб в оба списка покупок.
список_а = [«список_а», молоко_и_хлеб]
список_б = [«список_б», молоко_и_хлеб]
# Оригинал.
print(«ДО ИЗМЕНЕНИЯ»)
печать(список_а)
печать(список_b)
# Теперь меняем «молоко» на «яблоки».
# Обратите внимание, что мы не меняем list_a или list_b
milk_and_bread[0] = «яблоки»
# Оба изменились.
print(«ПОСЛЕ ИЗМЕНЕНИЯ»)
печать(список_а)
печать(список_b)
Изменения отражаются в обоих списках, поскольку «milk_and_bread» — это объект, а Python всегда работает с объектами через их адреса в памяти (т.е. ссылки). Добавляя объект в список, мы фактически добавляем ссылку на него. Теперь, когда мы изменяем объект, результат отражается везде.
Это важно, поскольку может стать источником ошибок. Если рассматривать сложные значения как ссылки, а не просто переменные, этой проблемы легче избежать. Избежать её не всегда возможно, и одним из решений является глубокое копирование списка:
из копирования импорт глубокое копирование
milk_and_bread = [«молоко», «хлеб»]
# Добавьте в оба списка покупок мягкое мясо и хлеб.
# но обратите внимание, что я применяю deepcopy ко всему списку.
list_a = deepcopy([«list_a», milk_and_bread])
list_b = deepcopy([«list_b», milk_and_bread])
# Оригинал.
print(«ДО ИЗМЕНЕНИЯ»)
печать(список_а)
печать(список_b)
# Теперь поменяем молоко на яблоки.
# Это ничего не даст, потому что list_a и list_b
# есть копии.
milk_and_bread[0] = «яблоки»
# Ни то, ни другое не изменилось.
print(«ПОСЛЕ ИЗМЕНЕНИЯ»)
печать(список_а)
печать(список_b)
Глубокое копирование позволяет углубиться в каждый объект и скопировать их все. Это рекурсивно.
Темы, затронутые здесь, должны удовлетворить большинство ваших потребностей в работе со списками, но они не охватывают более широкую тему Python. Для продолжения обучения вам могут быть полезны другие наши статьи, например, «Отличные игры, которые научат вас Python» или «Простые, но полезные скрипты Python для начала работы». Наконец, наше руководство по написанию кода в стиле Python включает дополнительные темы о списках, включая ВСЕ и каждую функции.
