Одним из самых часто применяемых типов данных в Python является список. Вызвано это тем, что использовать его очень удобно, но у всего есть своя цена. В данном случае этой ценой является скорость. В этом уроке мы рассмотрим основные операции над списками.
- Как создать список?
- Доступ к элементам списка
- Срезы (slice) списка
- Изменение элементов в списке
- Методы и функции списков python
- Метод Index
- Метод Count
- Метод Sort
- Метод Append
- Метод Remove
- Метод Pop
- Метод Extend
- Метод Insert
- Простые операции над списками
- Примеры использование функций со списками:
- Операторы + и * для списков
- Оператор in и not in
- Итерация по списку с использованием цикла for
- Преобразование списка в строку
Как создать список?
Чтобы объявить (создать) список, необходимо объявить переменную и присвоить ей пустые квадратные скобки.
список = []
print(type(список))
# Вывод:
<class 'list'>
Второй способ – использовать встроенную функцию list().
список = list()
print(type(список))
# Вывод:
<class 'list'>
Так же, как и в случае остальных типов данных, в Питоне можно при объявлении переменной сразу наполнить её значениями. В качестве таких значений могут выступать данные любого типа.
список_1 = [1, 'a', ['qwerty']]
список_2 = list(({'a':1}, {1, 2, 3}, (1, 2, 3)))
print(type(список_1), type(список_2))
print('список_1', список_1, 'список_2', список_2, sep='\n')
# Вывод:
<class 'list'> <class 'list'>
список_1
[1, 'a', ['qwerty']]
список_2
[{'a': 1}, {1, 2, 3}, (1, 2, 3)]
Как видите, список_1 хранит значения типов int, string и list, а список_2 – dict, set и tuple.
Доступ к элементам списка
Ещё одним удобством является то, что данная структура запоминает порядок, в котором хранит значения. Это даёт возможность обращаться к значениям по индексу – порядковому номеру значения (у программистов принято что нумерация начинается с нуля).
список_1 = [1, 'a', ['qwerty']]
print('список_1[0]', список_1[0])
print('список_1[1]', список_1[1])
print('список_1[2]', список_1[2])
# Вывод:
список_1[0] 1
список_1[1] a
список_1[2] ['qwerty']
Можно также использовать отрицательный индекс, тогда отсчёт будет производится от последнего элемента (последний элемент последовательности при такой нумерации имеет индекс «-1»).
список_1 = [1, 'a', ['qwerty']]
print('список_1[-1]', список_1[-1])
print('список_1[-2]', список_1[-2])
print('список_1[-3]', список_1[-3])
# Вывод:
список_1[-1] ['qwerty']
список_1[-2] a
список_1[-3] 1
Это бывает полезно, особенно, если Вам неизвестна длина списка.
Ко всем элементам можно обращаться как по положительному, так и по отрицательному индексу.
список_1 = [1, 'a', ['qwerty']]
print('список_1[-1]', список_1[-1])
print('список_1[2]', список_1[2])
# Вывод:
список_1[-1] ['qwerty']
список_1[2] ['qwerty']
Срезы (slice) списка
Мы уже разбирали срезы в других уроках, но давайте освежим в памяти как пользоваться этим замечательным инструментом. Срез позволяет используя индексы обратиться не к конкретному элементу, а к их набору. Для этого в квадратных скобках указываем индекс начального элемента, индекс элемента, до которого будем получать элементы. Третий аргумент – шаг выборки. Все аргументы могут быть как положительными, так и отрицательными, все элементы необязательны. Если указать отрицательным шаг, то элементы будут выданы в обратном порядке.
список_1 = list(range(11))
print('список_1[0:5:-1]', список_1[0:5:-1]) # Элементы с первого по пятый в обратном порядке
print('список_1[2:]',
список_1[2:]) # Все элементы, начиная с третьего. Аргументы можно пропускать, но двоеточия указать придётся
print('список_1[::2]', список_1[::2]) # Все чётные элементы
print('список_1[:]', список_1[:]) # Такая запись вернёт все элементы
# Но это копия, а не тот же список
список_2 = список_1
список_3 = список_1[:]
print('Равенство списков:')
print('список_2 == список_1', список_2 == список_1)
print('список_3 == список_1', список_3 == список_1)
print('Идентичность списков:')
print('список_2 is список_1', список_2 is список_1)
print('список_3 is список_1', список_3 is список_1)
# Вывод:
список_1[0:5:-1] []
список_1[2:] [2, 3, 4, 5, 6, 7, 8, 9, 10]
список_1[::2] [0, 2, 4, 6, 8, 10]
список_1[:] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
Равенство списков:
список_2 == список_1 True
список_3 == список_1 True
Идентичность списков:
список_2 is список_1 True
список_3 is список_1 False
Изменение элементов в списке
После создания списка его элементы можно менять.
список_1 = list(range(11))
print('список_1', список_1)
список_1 = список_1[::-1]
print('список_1 после изменения:', список_1)
# Вывод:
список_1 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
список_1 после изменения: [10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
Методы и функции списков python
Посколку, как и всё в Пайтоне, тип данных список является объектом, у него есть методы. Эти методы дают возможность выполнять различные распространённые операции. Давайте рассмотрим их.
Метод Index
Метод index позволяет узнать индекс элемента с определённым значением.
список_1 = ['Петя', 'Вася', 'Ваня']
print('Номер элемента со значением "Ваня":', список_1.index('Ваня'))
# Вывод:
Номер элемента со значением "Ваня": 2
Если таких элементов несколько, то метод вернёт индекс первого встреченного.
список_1 = ['Петя', 'Ваня', 'Вася', 'Ваня']
print('Номер элемента со значением "Ваня":', список_1.index('Ваня'))
# Вывод:
Номер элемента со значением "Ваня": 1
Но Вы можете указать вторым аргументом с какого индекса начинать поиск.
список_1 = ['Петя', 'Ваня', 'Вася', 'Ваня']
print('Номер элемента со значением "Ваня":', список_1.index('Ваня', 2))
# Вывод:
Номер элемента со значением "Ваня": 3
Метод Count
Этот метод возвращает количество вхождений определённого элемента.
список_1 = ['Петя', 'Ваня', 'Вася', 'Ваня']
print('Количество элементов со значением "Ваня":', список_1.count('Ваня'))
# Вывод:
Количество элементов со значением "Ваня": 2
Метод Sort
Метод sort сортирует по возрастанию и меняет исходный список. Можно указать обратный порядок сортировки передав необязательный именованный аргумент reverse=true.
import random
список_1 = [random.randint(0, 10) for i in range(10)]
print('Значения в случайном порядке:', список_1)
список_1.sort()
print('Упорядоченные значения:', список_1)
список_1.sort(reverse=True)
print('Значения по убыванию', список_1)
# Вывод:
Значения в случайном порядке: [1, 8, 7, 0, 9, 0, 4, 6, 2, 2]
Упорядоченные значения: [0, 0, 1, 2, 2, 4, 6, 7, 8, 9]
Значения по убыванию [9, 8, 7, 6, 4, 2, 2, 1, 0, 0]
Сортировать, естественно, можно и строки.
список_1 = ['Lorem', 'ipsum', 'dolor', 'sit', 'amet', 'consectetur', 'adipisicing', 'elit']
список_1.sort()
print('Упорядоченные значения:', список_1)
# Вывод:
Упорядоченные значения: ['Lorem', 'adipisicing', 'amet', 'consectetur', 'dolor', 'elit', 'ipsum', 'sit']
Метод Append
Метод append добавляет элемент в конец списка.
список_1 = ['Lorem', 'ipsum', 'dolor', 'sit', 'amet', 'consectetur', 'adipisicing', 'elit']
список_1.append('Ваня')
print('список_1:', список_1)
# Вывод:
список_1: ['Lorem', 'ipsum', 'dolor', 'sit', 'amet', 'consectetur', 'adipisicing', 'elit', 'Ваня']
Метод Remove
Метод remove удаляет первое вхождение значения в списке.
список_1 = ['Петя', 'Вася', 'Ваня']
список_1.remove('Ваня')
print('Номер элемента со значением "Ваня":', список_1.index('Ваня'))
# Вывод:
Traceback (most recent call last):
File "C:\Users\ivand\AppData\Roaming\JetBrains\PyCharm2021.2\scratches\scratch.py", line 3, in
print('Номер элемента со значением "Ваня":', список_1.index('Ваня'))
ValueError: 'Ваня' is not in list
Метод Pop
Метод pop удаляет элемент в указанном индексе. Этот метод также вернет элемент, который был удален из списка. В случае, если вы не указали индекс, он по умолчанию удалит элемент по последнему индексу.
список_1 = ['Петя', 'Вася', 'Ваня']
print('Удаляем элемент:', список_1.pop(0))
print('Удаляем элемент:', список_1.pop())
print('Вот что осталось:', список_1)
# Вывод:
Удаляем элемент: Петя
Удаляем элемент: Ваня
Вот что осталось: ['Вася']
Метод Extend
Метод extend расширяет список, добавляя элементы. Преимущество над append в том, что вы можете добавлять списки, автоматически их распаковывая.
список_1 = ['Петя', 'Вася', 'Ваня']
список_1.append(['Эдуард', 'Эразм'])
print('список_1:', список_1)
список_2 = ['Петя', 'Вася', 'Ваня']
список_2.extend(['Эдуард', 'Эразм'])
print('список_2:', список_2)
# Вывод:
список_1: ['Петя', 'Вася', 'Ваня', ['Эдуард', 'Эразм']]
список_2: ['Петя', 'Вася', 'Ваня', 'Эдуард', 'Эразм']
То же самое можно было бы сделать, используя +.
список_1 = ['Петя', 'Вася', 'Ваня']
список_1 += ['Эдуард', 'Эразм']
print('список_1:', список_1)
# Вывод:
список_1: ['Петя', 'Вася', 'Ваня', 'Эдуард', 'Эразм']
Метод Insert
Метод insert вставляет элемент перед указанным индексом.
список_1 = ['Петя', 'Вася', 'Ваня']
список_1.insert(1, 'Сид')
print('список_1:', список_1)
# Вывод:
список_1: ['Петя', 'Сид', 'Вася', 'Ваня']
Простые операции над списками
| Метод | Описание |
| x in s | True если элемент x находится в списке s |
| x not in s | True если элемент x не находится в списке s |
| s1 + s2 | Объединение списков s1 и s2 |
| s * n , n * s | Копирует список s n раз |
| len(s) | Длина списка s, т.e. количество элементов в s |
| min(s) | Наименьший элемент списка s |
| max(s) | Наибольший элемент списка s |
| sum(s) | Сумма чисел списка s |
| for i in list() | Перебирает элементы слева направо в цикле for |
Примеры использование функций со списками:
список_1 = ['Петя', 15, 'Вася', 1==1, 'Ваня', [('a', 1), {3, 4}]]
print('15 in список_1:', 15 in список_1)
print('True not in список_1:', True not in список_1)
print('Длина списка:', len(список_1))
print('Длина вложенного списка:', len(список_1[-1]))
print('Длина вложенного вложенного ;) списка:', len(список_1[-1][1]))
print('Сумма:', sum(список_1[5][-1]))
print('Минимальное значение:', min(список_1[5][-1]))
print('Генерируем новый список при помощи спискового включения:')
список_2 = [(i*10//2)**2 for i in range(10)]
print(список_2)
print('Разворачиваем список:')
список_2.reverse()
print(список_2)
# Вывод:
15 in список_1: True
True not in список_1: False
Длина списка: 6
Длина вложенного списка: 2
Длина вложенного вложенного ;) списка: 2
Сумма: 7
Минимальное значение: 3
Генерируем новый список при помощи спискового включения:
[0, 25, 100, 225, 400, 625, 900, 1225, 1600, 2025]
Разворачиваем список:
[2025, 1600, 1225, 900, 625, 400, 225, 100, 25, 0]
Операторы + и * для списков
+ объединяет два списка.
список_1 = ['Петя', 15, 'Вася', 1==1]
список_1 += ['Ваня', [('a', 1), {3, 4}]]
print(список_1)
# Вывод:
['Петя', 15, 'Вася', True, 'Ваня', [('a', 1), {3, 4}]]
* копирует элементы в списке.
список_1 = ['Петя', 15, 'Вася', 1==1]
список_1 *= 3
print(список_1)
# Вывод:
['Петя', 15, 'Вася', True, 'Петя', 15, 'Вася', True, 'Петя', 15, 'Вася', True]
Оператор in и not in
Оператор in проверяет находится ли элемент в списке. При успешном результате он возвращает True, в случае неудачи, возвращает False .
список_1 = ['Петя', 15, 'Вася', 1==1]
print(16 in список_1)
# Вывод:
False
Аналогично not in возвращает противоположный от оператора in результат.
список_1 = ['Петя', 15, 'Вася', 1==1]
print('A' not in список_1)
# Вывод:
True
Итерация по списку с использованием цикла for
Список — последовательность. Ниже способ, которые вы можете использовать для цикла, чтобы перебрать все элементы списка.
list1 = [1,2,3,4,5]
for i in list1:
print(i, end=" ")
# Вывод:
Петя
15
Вася
True
Преобразование списка в строку
Во-первых, если это список строк, вы можете просто использовать join() следующим образом.
список_1 = ['Петя', 'Вася', 'Эльвира']
строка = ', '.join(список_1)
print(строка, type(строка))
# Вывод:
Петя, Вася, Эльвира <class 'str'>
Однако этот простой метод не работает, если список содержит не строчные объекты, такие как целые числа. В таком случае приходится пойти на некоторые ухищрения и привести тип каждого элемента по отдельности к строковому.
список_1 = ['Петя', 15, 'Вася', 1==1]
строка = ', '.join([str(i) for i in список_1])
print(строка, type(строка))
# Вывод:
Петя, 15, Вася, True <class 'str'>
