Как изменить размерность списка python

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

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

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

Как уже было сказано выше, список является изменяемым типом данных. При его создании в памяти резервируется область, которую можно условно назвать некоторым “контейнером”, в котором хранятся ссылки на другие элементы данных в памяти. В отличии от таких типов данных как число или строка, содержимое “контейнера” списка можно менять. Для того, чтобы лучше визуально представлять себе этот процесс взгляните на картинку ниже. Изначально был создан список содержащий ссылки на объекты 1 и 2, после операции a[1] = 3, вторая ссылка в списке стала указывать на объект 3.

Более подробно эти вопросы обсуждались в уроке 3 (Типы и модель данных).

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

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

>>> a = [] 
>>> type(a) 
<class 'list'> 
>>> b = list() 
>>> type(b) 
<class 'list'>

Также можно создать список с заранее заданным набором данных.

>>> a = [1, 2, 3] 
>>> type(a) 
<class 'list'>

Если у вас уже есть список и вы хотите создать его копию, то можно воспользоваться следующим способом:

>>> 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]

list.pop([i])

Удаляет элемент из позиции 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)
<class 'list'>

и посмотрим сколько она занимает памяти в байтах:

>>> sys.getsizeof(a)
192

Для создания объекта-генератора, используется синтаксис такой же как и для спискового включения, только вместо квадратных скобок используются круглые:

>>> b = (i for i in range(10))

>>> type(b)
<class 'generator'>

>>> 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. Урок 6. Работа с IPython и Jupyter Notebook   Python. Урок 8. Кортежи (tuple) >>>

a = [1, 2, 3]

print(a)

>>> [1, 2, 3]

b = ['cat', 123, True]

print(b)

>>> ['cat', 123, True]

c = [1, 2, [3, 4]]

print(c)

>>> [1, 2, [3, 4]]

a = [1, 2, 3]

print(a[1])

>>> 2

a = [1, 2, 3, 4]

a[0] # Обратится к 1
a[2] # Обратится к 3
a[3] # Обратится к 4
a[4] # Выведет ошибку

a = [1, 2, 3, 4]

a[0:2] # Получим [1, 2]

a = [1, 2, 3, 4, 5]

a[1:6:2] # Получим [2, 4]

a = [1, 2, 3]
a[1] = 4

print(a)
 
>>> [1, 4, 3]

a = [1, 2]
b = a
a[0] = 5

print(a)
print(b)

>> [5, 2]
>> [5, 2]

a = [1, 2]
b = [3, 4]
с = a + b

print(с)

>>> [1, 2, 3, 4]

a = [1, 2, 3]
d1, d2, d3 = a

print(d1)
print(d2)
print(d3)

>>> 1
>>> 2
>>> 3

animals = ['cat', 'dog', 'bat']
for animal in animals:
  print(animal)

>>> cat
>>> dog
>>> bat

animals = ['cat', 'dog', 'bat']
i = 0
while i < len(animals):
  print(animals[i])
  i += 1

>>> cat
>>> dog
>>> bat

a = [1, 2, 3]
b = [1, 2, 3]
print(a == b)

>>> True

a = [1, 2, 3]
b = a
print(a is b)

>>> True

a = [5, 3, 1]
len(a) # 3

a = [8, 1, 3, 2]
sorted(a) # [1, 2, 3, 8]

a = [1, 9, -2, 3]
min(a) # -2
max(a) # 9

a = [1, 2, 3]
a.append(4)
print(a) 

>>> [1, 2, 3, 4]

a = [1, 2, 3]
a.insert(0, 4)
print(a)

>>> [4, 1, 2, 3]

a = [1, 2, 3]
a.extend([4, 5])
print(a) 

>>> [1, 2, 3, 4, 5]

a = ['cat', 'dog', 'bat']
a.extend('mouse')
print(a)

>>> ['cat', 'dog', 'bat', 'm', 'o', 'u', 's', 'e']

a = [1, 2, 3, 1]
a.remove(1)
print(a) 

>>> [2, 3, 1]

a = [1, 2, 3, 1]
a.remove(5)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: list.remove(x): x not in list

a = [1, 2, 3]
a.clear()
print(a) 

>>> []

a = [1, 2, 3]
print(a.index(2)) 

>>> 1

a = [1, 2, 3]
print(a.index(4))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: 4 is not in list

a = [1, 2, 3]
print(a.pop())
print(a)

>>> 3
>>> [1, 2]

a = [1, 2, 3]
print(a.pop(1)) 
print(a) 

>>> 2
>>> [1, 3]

a = [1, 1, 1, 2]
print(a.count(1)) 

>>> 3

a = [4, 1, 5, 2]
a.sort() # [1, 2, 4, 5]

a = [4, 1, 5, 2]
a.sort(reverse=True) # [5, 4, 2, 1]

a = [1, 3, 2, 4]
a.reverse() # [4, 2, 3, 1]

a = [1, 2, 3]
b = a.copy()

print(b)

>>> [1, 2, 3]

Школа дронов для всех
Учим программировать беспилотники и управлять ими.
Узнать больше

Время прочтения
5 мин

Просмотры 43K

Предлагаю вашему вниманию статью, основанную на публикации Laurent Luce о реализации работы со списками в CPython. Она может быть полезна начинающим программистам на Python, либо готовящимся к собеседованию. Функции C показаны в сокращенном варианте и с моими комментариями. Полный текст функций можно найти в исходниках CPython 2.7.

Эта статья описывает реализацию объекта списка в CPython, наиболее популярной реализации Python. Списки в Python — это мощный инструмент, и интересно узнать, как они устроены внутри. Взгляните на простой скрипт, который добавляет несколько целых значений в список и выводит их:

>>> l = []
>>> l.append(1)
>>> l.append(2)
>>> l.append(3)
>>> l
[1, 2, 3]
>>> for e in l:
...   print e
...
1
2
3

Как вы можете видеть, список является итерируемым объектом.

C-структура объекта списка

Объект списка в CPython представлен нижеследующей структурой в C. ob_item — это список указателей на элементы списка, allocated — количество выделенной памяти.

typedef struct {
    PyObject_VAR_HEAD
    PyObject **ob_item;
    Py_ssize_t allocated;
} PyListObject;

Инициализация списка

Давайте посмотрим, что происходит при создании пустого списка, к примеру l = []. Вызывается функция PyList_New(0):

/* 
size - размер списка
*/
PyList_New(Py_ssize_t size)
{
    // Вычисляется реальный размер необходимой памяти
    nbytes = size * sizeof(PyObject *);

    // Инициализируется ob_item
    if (size <= 0)
        op->ob_item = NULL;
    else {
        op->ob_item = (PyObject **) PyMem_MALLOC(nbytes);
        memset(op->ob_item, 0, nbytes);
    }

    // Сохраняется количество выделенных ячеек
    op->allocated = size;

    return (PyObject *) op;
}

Важно понимать разницу между выделенной памятью и размером списка. Размер списка — это тоже самое, что и len(l). allocated — это количество выделенной памяти, которое зачастую может быть больше размера списка. Это делается для предотвращения вызовов realloc при каждом добавлении элементов. Мы разберемся в этом подробнее чуть позже.

Добавление элементов

Мы добавляем целое число в список: l.append(1). Что в этот момент происходит? Вызывается функция C PyList_Append(), которая, в свою очередь, вызывает функцию app1():

/*
self - указатель на объект списка
v - указатель на добавляемое значение
*/
app1(PyListObject *self, PyObject *v)
{
    // Если не удалось изменить размер списка, возвращаем ошибку - значение (-1)
    if (list_resize(self, n+1) == -1)
        return -1;

    // После изменения размера списка, устанавливаем значение элемента n в v
    PyList_SET_ITEM(self, n, v);
    
    // При успешном выполнении возвращаем 0
    return 0;
}

Давайте посмотрим на функцию list_resize(). Она выделяет больше памяти, чем нужно для предотвращения частых вызовов list_resize. Выделение памяти задается следующей последовательностью: 0, 4, 8, 16, 25, 35, 46, 58, 72, 88, …

/*
self - указатель на объект списка
newsize - новый размер списка
*/
list_resize(PyListObject *self, Py_ssize_t newsize)
{
    // Если выделенной ранее памяти достаточно для заданного размера - дополнительной памяти не выделяем
    if (allocated >= newsize && newsize >= (allocated >> 1)) {
        assert(self->ob_item != NULL || newsize == 0);
        Py_SIZE(self) = newsize;
        return 0;
    }

    /* В противном случае выделяем необходимую память, а также резервируем 
     * дополнительную для следующих увеличений списка
     */
    new_allocated = (newsize >> 3) + (newsize < 9 ? 3 : 6);

    /* Проверяем на переполнение */
    if (new_allocated > PY_SIZE_MAX - newsize) {
        PyErr_NoMemory();
        return -1;
    } else {
        new_allocated += newsize;
    }

    // Выделяем память
    if (new_allocated <= (PY_SIZE_MAX / sizeof(PyObject *)))
        PyMem_RESIZE(items, PyObject *, new_allocated);

    return 0;
}

4 ячейки сейчас выделено для элементов списка и первый из них — это целое число 1. На изображении вы можете увидеть, что l[0] указывает на целое число, которое мы добавили в список. Квадраты, помеченные прерывистой линией, обозначают выделенную, но еще не использованную память.

Операция добавления элемента в список имеет сложность O(1).

Добавим еще один элемент в список: l.append(2). list_resize вызывается с n+1 = 2, но, так как размер выделенной памяти 4, нет необходимости выделять дополнительную память. То же самое происходить при добавлении еще двух целых чисел: l.append(3), l.append(4). На картинке показано, что мы имеем в итоге:

Вставка

Вставим новое целое число в позицию 1: l.insert(1,5) и посмотрим, что будет происходить на низком уровне. Вызывается функция ins1():

/*
self - указатель на объект списка
where - позиция, в которую вставляется новый элемент
v - указатель на вставляемое значение
*/
ins1(PyListObject *self, Py_ssize_t where, PyObject *v)
{
    n = Py_SIZE(self);

    // Изменяем размер списка и возвращаем ошибку в случае неудачи
    if (list_resize(self, n+1) == -1)
        return -1;

    // Если позиция отрицательна, то считаем с конца списка
    if (where < 0) {
        where += n;
        if (where < 0)
            where = 0;
    }
    // Если позиция больше длины списка, то вставляем в конец
    if (where > n)
        where = n;

    // Сдвигаем значения списка от конца до вставляемого элемента
    items = self->ob_item;
    for (i = n; --i >= where; )
        items[i+1] = items[i];
    // Вставляем новый элемент
    items[where] = v;

    return 0;
}

Квадраты, помеченные прерывистой линией, обозначают выделенную, но еще не использованную память. Итак, 8 ячеек выделено, но размер списка у нас сейчас 5.

Сложность операции вставки O(n).

Выталкивание

Когда вы выталкиваете элемент из списка, l.pop(), вызывается listpop(). list_resize вызывается внутри listpop() и в случае, если новый размер меньше половины выделенной памяти — то список сжимается.

/*
self - указатель на объект списка
args - параметры, указывающие на выталкиваемый элемент
*/
listpop(PyListObject *self, PyObject *args)
{
    // По умолчанию выталкиваем последний элемент
    Py_ssize_t i = -1;

    // Если список пуст - возвращаем NULL
    if (Py_SIZE(self) == 0) {
        return NULL;
    }

    // Если индекс отрицательный - считаем с конца
    if (i < 0)
        i += Py_SIZE(self);

    v = self->ob_item[i];
    // Если выталкивается последний элемент - вызывает list_resize и возвращаем вытолкнутое значение
    if (i == Py_SIZE(self) - 1) {
        status = list_resize(self, Py_SIZE(self) - 1);
        return v; 
    }

    // Если выталкивается элемент из внутренности списка, вызываем специальную функцию для изменения списка
    status = list_ass_slice(self, i, i+1, (PyObject *)NULL);

    return v;
}

Сложность операции O(1).

Вы можете наблюдать, что 4 ячейка все еще указывает на целое, но важно понимать, что размер списка у нас 4.

Вытолкнем еще один элемент. В list_resize(), size-1 = 4-1 = 3 меньше чем половина выделенных ячеек, поэтому список сжимается до 6 ячеек и новый размер списка становится 3.

Вы можете наблюдать, что 3 и 4 ячейка все еще указывают на целое, но важно понимать, что размер списка у нас 3.

Удаление

В Python объект списка имеет метод для удаления элемента с заданным значением: l.remove(5). Вызывается listremove().

/*
self - указатель на объект списка
v - указатель на удаляемое значение
*/
listremove(PyListObject *self, PyObject *v)
{
    Py_ssize_t i;

    // Пробегаемся по списку
    for (i = 0; i < Py_SIZE(self); i++) {
        int cmp = PyObject_RichCompareBool(self->ob_item[i], v, Py_EQ);

        // Если нашли подходящее значение - удаляем его и возвращаем Python None
        if (cmp > 0) {
            if (list_ass_slice(self, i, i+1,
                               (PyObject *)NULL) == 0)
                Py_RETURN_NONE;
            return NULL;
        }
        else if (cmp < 0)
            return NULL;
    }

    // Если не нашли элемент - возвращаем NULL
    return NULL;
}

Сложность операции удаления — O(n).

Содержание:развернуть

• Что такое список

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

• Базовая работа со списками

• Объявление списка

• Обращение к элементу списка в Python

• Добавление в список

• Добавление в список на указанную позицию

• Изменение элементов списка

• Удаление элемента из списка

• Как проверить наличие элемента в списке

• Объединение списков

• Копирование списка Python

• Цикл по списку

• Методы списков
• Вложенные списки
• Срезы
• Генераторы списков
• Best Practices

• Как получить список в обратном порядке

• Как перевести список в другой формат?

• Как узнать индекс элемента в списке?

• Как посчитать количество уникальных элементов в списке?

• Как проверить список на пустоту?

• Как создать список числовых элементов с шагом

Создание списка в Python может понадобиться для хранения в них коллекции объектов. Списки могут хранить объекты всех типов в одном, в отличие от массива в другом языке программирования. Также размер списка доступен к изменению.

Ниже разберёмся, как устроены списки, как с ними работать и приведём 6 примеров из практики.

Что такое список

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

[1, 33, 6, 9] # литерал списка в Python

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

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

Базовая C-структура списков в Python (CPython) выглядит следующим образом:

typedef struct {
PyObject_VAR_HEAD
PyObject **ob_item;
Py_ssize_t allocated;
} PyListObject;

Когда мы создаём список, в памяти под него резервируется объект, состоящий из 3-х частей:

• PyObject_VAR_HEAD — заголовок;
• ob_item — массив указателей на элементы списка;
• allocated — количество выделенной памяти под элементы списка.

Объект списка хранит указатели на объекты, а не на сами объекты

Python размещает элементы списка в памяти, затем размещает указатели на эти элементы. Таким образом, список в Python — это массив указателей.

Базовая работа со списками

Объявление списка

Объявление списка — самый первый и главный этап его создания. Для объявления списка в Python существует несколько способов.

Вариант №1: Через литерал (выражение, создающее объект):

>>> elements = [1, 3, 5, 6]

>>> print(elements)
[1, 3, 5, 6]

В данном примере мы создали список с заранее известными данными. Если нужен пустой список, в квадратных скобках ничего не указывается — elements = [].

Вариант №2: Через функцию list():

>>> elements = list()

>>> print(elements)
[]

В этом примере создается пустой список.

Обращение к элементу списка в Python

Чтобы обратиться к элементу списка, достаточно указать его индекс:

>>> elements = [1, 2, 3, 'word']

>>> elements[3]
'word'

Индекс — это порядковый номер элемента в списке. В примере выше индексы (позиции в списке) соответственно будут: 0, 1, 2, 3.

Нумерация элементов списка в Python начинается с нуля

Существует также отрицательный индекс, рассмотрим на примере:

>>> elements = [1, 2, 3, 'word']

>>> elements[-1]
'word'

Отрицательные индексы работают справа налево (то есть индекс значения ‘1’ — -4, а отрицательный индекс ‘word’ — -1.

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

Добавление в список

В списках доступно добавление, изменение, удаление элементов. Рассмотрим каждый способ изменения элементов на примерах.

Для того чтобы добавить новый элемент в список, используется list.append(x), где list — список, x — нужное значение.

>>> elements = [1, 2, 3, 'word']
>>> elements.append('meow')

>>> print(elements)
[1, 2, 3, 'word', 'meow']

Для простого примера, рассмотрим создание списка с нуля с помощью метода append() :

>>> elements = []
>>> elements.append(1)
>>> elements.append('word')
>>> elements.append('meow')

>>> print(elements)
[1, 'word', 'meow']

Добавление в список на указанную позицию

Немаловажно обратить внимание на метод list.insert(i, x), где list — список, i — позиция, x — нужное значение.

>>> elements = [1, 2, 4]
>>> print(elements)
[1, 2, 4]

>>> elements.insert(2, 3)
>>> print(elements)
[1, 2, 3, 4]

Изменение элементов списка

Изменение элементов списка происходит следующим образом: нужно выбрать элемент по индексу (порядковому номеру элемента) и присвоить новое значение.

>>> elements = [2, 4, 6]
>>> elements[2] = 8

>>> print(elements)
[2, 4, 8]

В примере выше мы заменили 6 на 8.

Не забывайте, что счёт начинается с нуля, и в данном списке цифра 6 это 2-й элемент

Удаление элемента из списка

Для удаление из списка используют инструкцию del list[i], где list — список, i — индекс (позиция) элемента в списке:

>>> elements = [1, "test", 5, 7]
>>> del elements[1]
>>> print(elements)
[1, 5, 7]

Удалять можно как из текущего списка, так и из вложенных списков:

>>> my_list = ["hello", "world", "!"]
>>> elements = [1, my_list, "ok"]
>>> del elements[1][2]

>>> print(elements)
[1, ['hello', 'world'], 'ok']

Можно удалять целыми диапазонами:

>>> elements = [2, 4, 6, 8, 12]
>>> del elements[2:] # удаляем все элементы после 2-го элемента (включительно)
>>> print(elements)
[2, 4]

>>> elements = [2, 4, 6, 8, 12]
>>> del elements[1:3] # удаляем от 1-го элемента включительно до 3-го элемента
>>> print(elements)
[2, 8, 12]

Еще один способ удаления из списка — list.remove(x), где list — список, x — значение, которое нужно удалить:

>>> elements = [2, "test", 4]
>>> elements.remove("test")
>>> print(elements)
[2, 4]

Как проверить наличие элемента в списке

Для того чтобы проверить существование какого-либо элемента в списке, нужно воспользоваться оператором in. Рассмотрим на примере:

>>> elements = ['слон', 'кот', 'лошадь', 'змея', 'рыба']
>>> if 'кот' in elements:
print('meow')

meow

Объединение списков

Списки в Python можно объединять с помощью оператора + или метода extend . Выглядит это так:

>>> a = [1, 3, 5]
>>> b = [1, 2, 4, 6]
>>> print(a + b)
[1, 3, 5, 1, 2, 4, 6]

>>> hello = ["h", "e", "l", "l", "o"]
>>> world = ["w", "o", "r", "l", "d"]
>>> hello.extend(world) # extends не возвращает новый список, а дополняет текущий
>>> print(hello)
['h', 'e', 'l', 'l', 'o', 'w', 'o', 'r', 'l', 'd']

Копирование списка Python

Если вы захотите скопировать список оператором =, вы скопируете не сам список, а только его ссылку.

>>> a = [1, 2, 3]
>>> b = a # переменной b присваивается не значение списка a, а его адрес

>>> b.append(4)
>>> print(a, b)
[1, 2, 3, 4] [1, 2, 3, 4]

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

• elements.copy() — встроенный метод copy (доступен с Python 3.3);
• list(elements) — через встроенную функцию list() ;
• copy.copy(elements) — функция copy() из пакета copy;
• elements[:] — через создание среза (устаревший синтаксис).

Рассмотрим на примере каждый из этих способов:

>>> a = ["кот", "слон", "змея"]

>>> c = a[:] # устаревший синтаксис
>>> print(id(a), id(c), a, c)
56467336 60458408 ['кот', 'слон', 'змея'] ['кот', 'слон', 'змея']

Важно: copy.copy(a) делает поверхностное копирование. Объекты внутри списка будут скопированы как ссылки на них (как в случае с оператором =). Если необходимо рекурсивно копировать всех элементов в списке, используйте copy.deepcopy(a)

Скопировать часть списка можно с помощью срезов. Есть несколько вариантов использования:

>>> a = ["кот", "слон", "змея"]

>>> a = [1, 2, 3, 4, 5, 6, 7, 8]
>>> e = a[0:8:2] # c 0-го элемента по 8-й элемент с шагом 2
>>> print(e)
[1, 3, 5, 7]

Цикл по списку

Для перебора списков в Python есть два цикла: for и while.

elements = [1, 2, 3, "meow"]
for el in elements:
print(el)

Результат выполнения:

1
2
3
meow

Попробуем построить цикл while. Он выполняется, когда есть какое-либо определённое условие:

elements = [1, 2, 3, "meow"]
elements_len = len(elements)
i = 0
while i < elements_len:
print(elements[i])
i += 1

Результат выполнения:

1
2
3
meow

Из примеров выше можем сделать вывод, что конструкция for выглядит заметно компактнее, чем while.

Методы списков

• list.append(x) — позволяет добавлять элемент в конец списка;
• list1.extend(list2) — предназначен для сложения списков;
• list.insert(i, x) — служит для добавления элемента на указанную позицию(i — позиция, x — элемент);
• list.remove(x) — удаляет элемент из списка (только первое вхождение);
• list.clear() — предназначен для удаления всех элементов (после этой операции список становится пустым []);
• list.copy() — служит для копирования списков.
• list.count(x) — посчитает количество элементов x в списке;
• list.index(x) — вернет позицию первого найденного элемента x в списке;
• list.pop(i) — удалит элемент из позиции i ;
• list.reverse() — меняет порядок элементов в списке на противоположный;
• list.sort() — сортирует список.

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

# append
>>> a = [1, 2, 3]
>>> a.append(4)
print(a)
[1, 2, 3, 4]

# sort (по убыванию)
>>> elements = [3, 19, 0, 3, 102, 3, 1]
>>> elements.sort(reverse = True)
>>> print(elements)
[102, 19, 3, 3, 3, 1, 0]

Вложенные списки

Список может содержать объекты разных типов: числовые, буквенные, а также списки. Список списков выглядит следующим образом:

>>> elements = [1, 2, [0.1, 0.2, 0.3]]

Для обращения к элементу вложенного списка нужно использовать два индекса: первый указывает на индекс главного списка, второй — индекс элемента во вложенном списке. Вот пример:

>>> elements = [["яблоки", 50], ["апельсины", 190], ["груши", 100]]

>>> print(elements[1][0])
апельсины

Срезы

Срезы (slices) — это подмножества элементов списка. Срезу нужны, когда необходимо извлечь часть списка из полного списка.

У них есть свой собственный синтаксис. Записывается срез так же, как обращение к элементу, используя индекс. Пример:

elements[START:STOP:STEP]

В этом случае берётся срез от номера start (включительно) до stop (не включая его), а step — это шаг. По умолчанию start и stop равны 0, step равен 1.

>>> elements = [0.1, 0.2, 1, 2, 3, 4, 0.3, 0.4]
>>> int_elements = elements[2:6] # с 2-го элемента включительно по 6-й элемент

>>> print(int_elements)
[1, 2, 3, 4]

Генераторы списков

Генератором списка называется способ построения списка с применением выражения к каждому элементу, входящему в последовательность. Есть схожесть генератора списка и цикла for. На этом примере мы рассмотрим простейший генератор списков:

>>> c = [c * 3 for c in 'list']

>>> print(c)
['lll', 'iii', 'sss', 'ttt']

Таким образом мы получили отдельно взятые утроенные буквы слова, введённого в кавычки. Есть множество вариантов применения генератора списков.

Пример генератора списка:

>>> nums = [i for i in range(1, 15)]
>>> print(nums)
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]

Пример посложнее:

>>> c = [c + d for c in 'list' if c != 'i' for d in 'spam' if d != 'a']
>>> print(c)
['ls', 'lp', 'lm', 'ss', 'sp', 'sm', 'ts', 'tp', 'tm']

Это усложнённая конструкция генератора списков, в которой мы сделали все возможные наборы сочетаний букв из введённых слов. Буквы-исключения видны по циклу, где стоит знак != для одной переменной и другой.

Best Practices

Последние абзацы статьи будут посвящены лучшим решениям практических задач, с которыми так или иначе сталкивается Python-разработчик.

Как получить список в обратном порядке

Изменить порядок размещения элементов в списке помогает функция list.reverse():

>>> elements = [1, 2, 3, 4, 5, 6]
>>> elements.reverse()

>>> print(elements)
[6, 5, 4, 3, 2, 1]

Как перевести список в другой формат?

Иногда требуется перевести список в строку, в словарь или в JSON. Для этого нужно будет вывести список без скобок.

Перевод списка в строку осуществляется с помощью функции join(). На примере это выглядит так:

>>> fruits = ["яблоко", "груша", "ананас"]

>>> print(', '.join(fruits))
яблоко, груша, ананас

В данном случае в качестве разделителя используется запятая.

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

>>> elements = [['1', 'a'],['2', 'b'],['3', 'c']]
>>> my_dict = dict(elements)

>>> print(my_dict)
{'1': 'a', '2': 'b', '3': 'c'}

JSON — это JavaScript Object Notation. В Python находится встроенный модуль json для кодирования и декодирования данных JSON. С применением метода json.dumps(x) можно запросто преобразовать список в строку JSON.

>>> import json
>>> json.dumps(['word', 'eye', 'ear'])
'["word", "eye", "ear"]'

Как узнать индекс элемента в списке?

Узнать позицию элемента в последовательности списка бывает необходимым, когда элементов много, вручную их не сосчитать, и нужно обращение по индексу. Для того чтобы узнать индекс элемента, используют функцию list.index(x).

>>> elements = [1, 3, 6, 9, 55]

>>> print(elements.index(9))
3

В качестве аргумента передаем значение, а на выходе получаем его индекс.

Как посчитать количество уникальных элементов в списке?

Самый простой способ — приведение списка к set (множеству). После этого останутся только уникальные элементы, которые мы посчитаем функцией len():

>>> words = ["one", "two", "one", "three", "one"]
>>> len(set(words))
3

Как проверить список на пустоту?

>>> a = []
>>> if not a:
print("список пуст!")

список пуст!

Как создать список числовых элементов с шагом

Создание списка числовых элементов с шагом может понадобиться не так и часто, но мы рассмотрим пример построения такого списка.

Шагом называется переход от одного элемента к другому. Если шаг отрицательный, произойдёт реверс массива, то есть отсчёт пойдёт справа налево. Вот так выглядит список с шагом.

>>> elements = [1, 2, 3, 4, 5, 8, 9, 10, 11, 14, 20]
>>> print(elements[0:11:2])
[1, 3, 5, 9, 11, 20]

Еще один вариант — воспользоваться генератором списков:

>>> elements = [c for c in range(0, 10, 2)] # от 0 (включительно) до 10 с шагом 2

>>> print(elements)
[0, 2, 4, 6, 8]

При разработке на языке Python, списки встречаются довольно часто. Знание основ работы со списками поможет быстро и качественно писать программный код 😉.

Список

Назад в начало

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

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

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

Решение задач

1. Создайте список из 10 четных чисел и выведите его с помощью цикла for

2. Создайте список из 5 элементов. Сделайте срез от второго индекса до четвертого

3. Создайте пустой список и добавьте в него 10 случайных чисел и выведите их. В данной задаче нужно использовать функцию randint.

from random import randint

n = randint(1, 10) # Случайное число от 1 до 10

4. Удалите все элементы из списка, созданного в задании 3

5. Создайте список из введенной пользователем строки и удалите из него символы ‘a’, ‘e’, ‘o’

6. Даны два списка, удалите все элементы первого списка из второго

a = [1, 3, 4, 5]

b = [4, 5, 6, 7]

# Вывод

>>> [6, 7]

7. Создайте список из случайных чисел и найдите наибольший элемент в нем.

8. Найдите наименьший элемент в списке из задания 7

9. Найдите сумму элементов списка из задания 7

10.Найдите среднее арифметическое элементов списка из задания 7

Сложные задачи

1. Создайте список из случайных чисел. Найдите номер его последнего локального максимума (локальный максимум — это элемент, который больше любого из своих соседей).

2. Создайте список из случайных чисел. Найдите максимальное количество его одинаковых элементов.

3. Создайте список из случайных чисел. Найдите второй максимум.

a = [1, 2, 3] # Первый максимум == 3, второй == 2

4. Создайте список из случайных чисел. Найдите количество различных элементов в нем.