Списки

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

Создание пустого списка выглядит так:

empty_list = []

Создадим список, состоящий из нескольких чисел:

numbers = [40, 20, 90, 11, 5]

Настало время строковых переменных:

fruits = ['Apple', 'Grape', 'Peach', 'Banan', 'Orange']

Не будем забывать и о дробях:

fractions = [3.14, 2.72, 1.41, 1.73, 17.9]

Мы можем создать список, состоящий из различных типов данных:

values = [3.14, 10, 'Hello world!', False, 'Python is the best']

И такое возможно

list_of_lists = [[2, 4, 0], [11, 2, 10], [0, 19, 27]]

Индексирование

Что же такое индексирование? Это загадочное слово обозначает операцию обращения к элементу по его порядковому номеру ( ( ･ω･)ア напоминаю, что нумерация начинается с нуля). Проиллюстрируем это на примере:

fruits = ['Apple', 'Grape', 'Peach', 'Banan', 'Orange']  
print(fruits[0])  
print(fruits[1])  
print(fruits[4])

>>> Apple  
>>> Grape  
>>> Orange

Списки в Python являются изменяемым типом данных. Мы можем изменять содержимое каждой из ячеек:

fruits = ['Apple', 'Grape', 'Peach', 'Banan', 'Orange']  
fruits[0] = 'Watermelon'  
fruits[3] = 'Lemon'  
print(fruits)

>>> ['Watermelon', 'Grape', 'Peach', 'Lemon', 'Orange']

Индексирование работает и в обратную сторону. Как такое возможно? Всё просто, мы обращаемся к элементу списка по отрицательному индексу. Индекс с номером -1 дает нам доступ к последнему элементу, -2 к предпоследнему и так далее.

fruits = ['Apple', 'Grape', 'Peach', 'Banan', 'Orange']  
print(fruits[-1])  
print(fruits[-2])  
print(fruits[-3])  
print(fruits[-4])

>>> Orange  
>>> Banan  
>>> Peach  
>>> Grape

Создание списка с помощью list()

Переходим к способам создания списка. Самый простой из них был приведен выше. Еще раз для закрепления:

smiles = ['(ಠ_ಠ)', '(￣﹃￣)', '( ͡° ͜ʖ ͡°)', '(╮°-°)╮']

А есть еще способы? Да, есть. Один из них — создание списка с помощью функции list() В неё мы можем передать любой итерируемый объект (да-да, тот самый по которому можно запустить цикл (• ᵕ •) )

Рассмотрим несколько примеров:

letters = list('abcdef')  
numbers = list(range(10))  
even_numbers = list(range(0, 10, 2))  
print(letters)  
print(numbers)  
print(even_numbers)

>>> ['a', 'b', 'c', 'd', 'e', 'f'  
>>> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]  
>>> [0, 2, 4, 6, 8]

Длина списка

С созданием списка вроде разобрались. Следующий вопрос: как узнать длину списка? Можно, конечно, просто посчитать количество элементов... (⊙_⊙) Но есть способ получше! Функция len() возвращает длину любой итерируемой переменной, переменной, по которой можно запустить цикл. Рассмотрим пример:

fruits = ['Apple', 'Grape', 'Peach', 'Banan', 'Orange']  
print(len(fruits))

>>> 5

numbers = [40, 20, 90]  
print(len(numbers))

>>> 3

"...любой итерируемой", а это значит:

string = 'Hello world'  
print(len(string))  
# 11

>>> 11

print(len(range(10))

>>> 10

Срезы

В начале статьи что-то говорилось о "срезах". Давайте разберем подробнее, что это такое. Срезом называется некоторая подпоследовательность. Принцип действия срезов очень прост: мы "отрезаем" кусок от исходной последовательности элемента, не меняя её при этом. Я сказал "последовательность", а не "список", потому что срезы работают и с другими итерируемыми типами данных, например, со строками.

fruits = ['Apple', 'Grape', 'Peach', 'Banan', 'Orange']  
part_of_fruits = fruits[0:3]  
print(part_of_fruits)

>>> ['Apple', 'Grape', 'Peach']

Детально рассмотрим синтаксис срезов:

итерируемая_переменная[начальный_индекс:конечный_индекс - 1:длина_шага]

Обращаю ваше внимание, что мы делаем срез от начального индекса до конечного индекса - 1. То есть i = начальный_индекс и i < конечный индекс

Больше примеров!

fruits = ['Apple', 'Grape', 'Peach', 'Banan', 'Orange']  
print(fruits[0:1]) 
 
# Если начальный индекс равен 0, то его можно опустить  
print(fruits[:2])  
print(fruits[:3])  
print(fruits[:4])  
print(fruits[:5])  

# Если конечный индекс равен длине списка, то его тоже можно опустить  
print(fruits[:len(fruits)])  
print(fruits[::])

>>> ['Apple']  
>>> ['Apple', 'Grape']  
>>> ['Apple', 'Grape', 'Peach']  
>>> ['Apple', 'Grape', 'Peach', 'Banan']  
>>> ['Apple', 'Grape', 'Peach', 'Banan', 'Orange']  
>>> ['Apple', 'Grape', 'Peach', 'Banan', 'Orange']  
>>> ['Apple', 'Grape', 'Peach', 'Banan', 'Orange']

Самое время понять, что делает третий параметр среза - длина шага!

fruits = ['Apple', 'Grape', 'Peach', 'Banan', 'Orange']  
print(fruits[::2])  
print(fruits[::3])  

# Длина шага тоже может быть отрицательной!  
print(fruits[::-1])  
print(fruits[4:2:-1])  
print(fruits[3:1:-1])

>>> ['Apple', 'Peach', 'Orange']  
>>> ['Apple', 'Banan']  
>>> ['Orange', 'Banan', 'Peach', 'Grape', 'Apple']  
>>> ['Orange', 'Banan']  
>>> ['Banan', 'Peach']

А теперь вспоминаем всё, что мы знаем о циклах. В Python их целых два! Цикл for и цикл while Нас интересует цикл for, с его помощью мы можем перебирать значения и индексы наших последовательностей. Начнем с перебора значений:

fruits = ['Apple', 'Grape', 'Peach', 'Banan', 'Orange']  
for fruit in fruits:  
    print(fruit, end=' ')

>>> Apple Grape Peach Banan Orange

Выглядит несложно, правда? В переменную fruit объявленную в цикле по очереди записываются значения всех элементов списка fruits

А что там с перебором индексов?

for index in range(len(fruits)):  
    print(fruits[index], end=' ')

Этот пример гораздо интереснее предыдущего! Что же здесь происходит? Для начала разберемся, что делает функция range(len(fruits))

Мы с вами знаем, что функция len() возвращает длину списка, а range() генерирует диапазон целых чисел от 0 до len()-1.

Сложив 2+2, мы получим, что переменная index принимает значения в диапазоне от 0 до len()-1. Идем дальше, fruits[index] - это обращение по индексу к элементу с индексом index списка fruits. А так как переменная index принимает значения всех индексов списка fruits, то в цикле мы переберем значения всех элементов нашего списка!

Операция in

С помощью in мы можем проверить наличие элемента в списке, строке и любой другой итерируемой переменной.

fruits = ['Apple', 'Grape', 'Peach', 'Banan', 'Orange']  

if 'Apple' in fruits:  
    print('В списке есть элемент Apple')

>>> В списке есть элемент Apple

fruits = ['Apple', 'Grape', 'Peach', 'Banan', 'Orange']  

if 'Lemon' in fruits:  
    print('В списке есть элемент Lemon')  
else:'  
    print('В списке НЕТ элемента Lemon')

>>> В списке НЕТ элемента Lemon

Приведу более сложный пример:

all_fruits = ['Apple', 'Grape', 'Peach', 'Banan', 'Orange']  
my_favorite_fruits = ['Apple', 'Banan', 'Orange']  
for item in all_fruits:  
    if item in my_favorite_fruits:  
        print(item + ' is my favorite fruit')  
    else:  
        print('I do not like ' + item)

>>> Apple is my favorite fruit  
>>> I do not like Grape  
>>> I do not like Peach  
>>> Banan is my favorite fruit  
>>> Orange is my favorite fruit

Методы для работы со списками

Начнем с метода append(), который добавляет элемент в конец списка:

# Создаем список, состоящий из четных чисел от 0 до 8 включительно  
numbers = list(range(0,10,2))  

# Добавляем число 200 в конец списка  
numbers.append(200)  
numbers.append(1)  
numbers.append(2)  
numbers.append(3)  

print(numbers)

>>> [0, 2, 4, 6, 8, 200, 1, 2, 3]

Мы можем передавать методу append() абсолютно любые значения:

all_types = [10, 3.14, 'Python', ['I', 'am', 'list']]  
all_types.append(1024)  
all_types.append('Hello world!')  
all_types.append([1, 2, 3])  
print(all_types)

>>> [10, 3.14, 'Python', ['I', 'am', 'list'], 1024, 'Hello world!', [1, 2, 3]]

Метод append() отлично выполняет свою функцию. Но, что делать, если нам нужно добавить элемент в середину списка? Это умеет метод insert(). Он добавляет элемент в список на произвольную позицию. insert() принимает в качестве первого аргумента позицию, на которую нужно вставить элемент, а вторым — сам элемент.

# Создадим список чисел от 0 до 9  
numbers = list(range(10))  

# Добавление элемента 999 на позицию с индексом 0  
numbers.insert(0, 999)  
print(numbers) # первый print  

numbers.insert(2, 1024)  
print(numbers) # второй print  

numbers.insert(5, 'Засланная строка-шпион')  
print(numbers) # третий print

>>> [999, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9] # первый print  
>>> [999, 0, 1024, 1, 2, 3, 4, 5, 6, 7, 8, 9] # второй print  
>>> [999, 0, 1024, 1, 2, 'Засланная строка-шпион', 3, 4, 5, 6, 7, 8, 9] # третий print

Отлично! Добавлять элементы в список мы научились, осталось понять, как их из него удалять. Метод pop() удаляет элемент из списка по его индексу:

numbers = list(range(10))  
print(numbers) # 1  

# Удаляем первый элемент  
numbers.pop(0)  
print(numbers) # 2  

numbers.pop(0)  
print(numbers) # 3  

numbers.pop(2)  
print(numbers) # 4  

# Чтобы удалить последний элемент, вызовем метод pop без аргументов  
numbers.pop()  
print(numbers) # 5  

numbers.pop()  
print(numbers) # 6

>>> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] # 1  
>>> [1, 2, 3, 4, 5, 6, 7, 8, 9] # 2  
>>> [2, 3, 4, 5, 6, 7, 8, 9] # 3  
>>> [2, 3, 5, 6, 7, 8, 9] # 4  
>>> [2, 3, 5, 6, 7, 8] # 5  
>>> [2, 3, 5, 6, 7] # 6

Теперь мы знаем, как удалять элемент из списка по его индексу. Но что, если мы не знаем индекса элемента, но знаем его значение? Для такого случая у нас есть метод remove(), который удаляет первый найденный по значению элемент в списке.

all_types = [10, 'Python', 10, 3.14, 'Python', ['I', 'am', 'list']]  
all_types.remove(3.14)  

print(all_types) # 1  
all_types.remove(10)  

print(all_types) # 2  
all_types.remove('Python')  

print(all_types) # 3

>>> [10, 'Python', 10, 'Python', ['I', 'am', 'list']] # 1  
>>> ['Python', 10, 'Python', ['I', 'am', 'list']] # 2  
>>> [10, 'Python', ['I', 'am', 'list']] # 3

А сейчас немного посчитаем, посчитаем элементы списка с помощью метода count()

numbers = [100, 100, 100, 200, 200, 500, 500, 500, 500, 500, 999]
  
print(numbers.count(100)) # 1  
print(numbers.count(200)) # 2  
print(numbers.count(500)) # 3  
print(numbers.count(999)) # 4

>>> 3 # 1  
>>> 2 # 2  
>>> 5 # 3  
>>> 1 # 4

В программировании, как и в жизни, проще работать с упорядоченными данными, в них легче ориентироваться и что-либо искать. Метод sort() сортирует список по возрастанию значений его элементов.

numbers = [100, 2, 11, 9, 3, 1024, 567, 78]  
numbers.sort()  
print(numbers) # 1  

fruits = ['Orange', 'Grape', 'Peach', 'Banan', 'Apple']  
fruits.sort()  
print(fruits) # 2

>>> [2, 3, 9, 11, 78, 100, 567, 1024] # 1  
>>> ['Apple', 'Banan', 'Grape', 'Orange', 'Peach'] # 2

Мы можем изменять порядок сортировки с помощью параметра reverse. По умолчанию этот параметр равен False

fruits = ['Orange', 'Grape', 'Peach', 'Banan', 'Apple']  
fruits.sort()  
print(fruits) # 1 
 
fruits.sort(reverse=True)  
print(fruits) # 2

>>> ['Apple', 'Banan', 'Grape', 'Orange', 'Peach'] # 1  
>>> ['Peach', 'Orange', 'Grape', 'Banan', 'Apple'] # 2

Иногда нам нужно перевернуть список, не спрашивайте меня зачем... Для этого в самом лучшем языке программирования на этой планете JavaScr..Python есть метод reverse():

numbers = [100, 2, 11, 9, 3, 1024, 567, 78]  
numbers.reverse()  
print(numbers) # 1  

fruits = ['Orange', 'Grape', 'Peach', 'Banan', 'Apple']  
fruits.reverse()  
print(fruits) # 2

>>> [78, 567, 1024, 3, 9, 11, 2, 100] # 1  
>>> ['Apple', 'Banan', 'Peach', 'Grape', 'Orange'] # 2

Допустим, у нас есть два списка и нам нужно их объединить. Программисты на C++ cразу же кинулись писать циклы for, но мы пишем на python, а в python у списков есть полезный метод extend(). Этот метод вызывается для одного списка, а в качестве аргумента ему передается другой список, extend() записывает в конец первого из них начало второго:

fruits = ['Banana', 'Apple', 'Grape']  
vegetables = ['Tomato', 'Cucumber', 'Potato', 'Carrot']  
fruits.extend(vegetables)  
print(fruits)

>>> ['Banana', 'Apple', 'Grape', 'Tomato', 'Cucumber', 'Potato', 'Carrot']

В природе существует специальный метод для очистки списка — clear()

fruits = ['Banana', 'Apple', 'Grape']  
vegetables = ['Tomato', 'Cucumber', 'Potato', 'Carrot']  

fruits.clear()  
vegetables.clear()  

print(fruits)  
print(vegetables)

>>> []  
>>> []

Осталось совсем чуть-чуть всего лишь пара методов, так что делаем последний рывок! Метод index() возвращает индекс элемента. Работает это так: вы передаете в качестве аргумента в index() значение элемента, а метод возвращает его индекс:

fruits = ['Banana', 'Apple', 'Grape'] 
 
print(fruits.index('Apple'))  
print(fruits.index('Banana'))  
print(fruits.index('Grape'))

>>> 1  
>>> 0  
>>> 2

Финишная прямая! Метод copy(), только не падайте, копирует список и возвращает его брата-близнеца. Вообще, копирование списков - это тема достаточно интересная, давайте рассмотрим её по-подробнее.

Во-первых, если мы просто присвоим уже существующий список новой переменной, то на первый взгляд всё выглядит неплохо:

fruits = ['Banana', 'Apple', 'Grape']  

new_fruits = fruits  
print(fruits)  
print(new_fruits)

>>> ['Banana', 'Apple', 'Grape']  
>>> ['Banana', 'Apple', 'Grape']

Но есть одно маленькое "НО":

fruits = ['Banana', 'Apple', 'Grape']  
new_fruits = fruits  

fruits.pop()  

print(fruits)  
print(new_fruits)

# Внезапно, из списка new_fruits исчез последний элемент  
>>> ['Banana', 'Apple']  
>>> ['Banana', 'Apple']

При прямом присваивании списков копирования не происходит. Обе переменные начинают ссылаться на один и тот же список! То есть если мы изменим один из них, то изменится и другой. Что же тогда делать? Пользоваться методом copy(), конечно:

fruits = ['Banana', 'Apple', 'Grape']  

new_fruits = fruits.copy()  
fruits.pop()  

print(fruits)  
print(new_fruits)

>>> ['Banana', 'Apple']  
>>> ['Banana', 'Apple', 'Grape']

Отлично! Но что если у нас список в списке? Скопируется ли внутренний список с помощью метода copy() — нет:

fruits = ['Banana', 'Apple', 'Grape', ['Orange','Peach']]  
new_fruits = fruits.copy()  

fruits[-1].pop()  

print(fruits) # 1  
print(new_fruits) # 2

>>> ['Banana', 'Apple', 'Grape', ['Orange']] # 1  
>>> ['Banana', 'Apple', 'Grape', ['Orange']] # 2