Размер списка может меняться во время работы программы питон

Список

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

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

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

Примеры списков:

• числа = [10, 20, 30, 40, 50]
• names = [«Сара», «Дэвид», «Уорнер», «Сэнди»]
• student_info = [«Сара», 1, «Химия»]

Создать список Python

Следующий список содержит все целочисленные значения:

>>> my_list1 = [5, 12, 13, 14] # the list contains all integer values
>>> print(my_list1)
[5, 12, 13, 14]
>>>

Следующий список содержит всю строку:

>>> my_list2 = ['red', 'blue', 'black', 'white'] # the list contains all string
values
>>> print(my_list2)
['red', 'blue', 'black', 'white']
>>>

Следующий список содержит строку, целое число и значения с плавающей точкой:

>>> my_list3 = ['red', 12, 112.12] # the list contains a string, an integer and
a float values
>>> print(my_list3)
['red', 12, 112.12]
>>>

Список без какого-либо элемента называется пустым списком. Смотрите следующие утверждения.

>>> my_list=[]
>>> print(my_list)
[]
>>>

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

>>> color_list1 = ["White", "Yellow"]
>>> color_list2 = ["Red", "Blue"]
>>> color_list3 = ["Green", "Black"]
>>> color_list = color_list1 + color_list2 + color_list3
>>> print(color_list)
['White', 'Yellow', 'Red', 'Blue', 'Green', 'Black']
>>> number = [1,2,3]
>>> print(number[0]*4)
4
>>> print(number*4)
[1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3]
>>>

Список индексов

Индексы списков работают так же, как строковые индексы, индексы списков начинаются с 0. Если индекс имеет положительное значение, он считается с начала и аналогичным образом считается обратным, если индекс имеет отрицательное значение. Как положительные целые числа используются для индексации с левого конца, так и отрицательные целые числа используются для индексации с правого конца, поэтому каждый элемент списка дает два альтернативных индекса. Давайте создадим список под названием color_list с четырьмя элементами.
color_list = [«RED», «Blue», «Green», «Black»]

Если вы дадите какое-либо значение индекса, выходящее за пределы диапазона, интерпретатор создаст сообщение об ошибке. Смотрите следующие утверждения.

>>> color_list=["Red", "Blue", "Green", "Black"] # The list have four elements
indices start at 0 and end at 3
>>> color_list[0] # Return the First Element
'Red'
>>> print(color_list[0],color_list[3]) # Print First and Last Elements
Red Black
>>> color_list[-1] # Return Last Element
'Black'
>>> print(color_list[4]) # Creates Error as the indices is out of range
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range
>>>

Добавить элемент в конец списка

Смотрите следующие заявления:

>>> color_list=["Red", "Blue", "Green", "Black"]
>>> print(color_list)
['Red', 'Blue', 'Green', 'Black']
>>> color_list.append("Yellow")
>>> print(color_list)
['Red', 'Blue', 'Green', 'Black', 'Yellow']
>>>

Вставить элемент в заданную позицию

Смотрите следующие заявления:

>>> color_list=["Red", "Blue", "Green", "Black"]
>>> print(color_list)
['Red', 'Blue', 'Green', 'Black']
>>> color_list.insert(2, "White") #Insert an item at third position
>>> print(color_list)
['Red', 'Blue', 'White', 'Green', 'Black']
>>>

Изменить элемент с помощью индекса элемента

Смотрите следующие заявления:

>>> color_list=["Red", "Blue", "Green", "Black"]
>>> print(color_list)
['Red', 'Blue', 'Green', 'Black']
>>> color_list[2]="Yellow"  #Change the third color
>>> print(color_list)
['Red', 'Blue', 'Yellow', 'Black']
>>>

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

Смотрите следующие заявления:

>>> color_list=["Red", "Blue", "Green", "Black"]
>>> print(color_list)
['Red', 'Blue', 'Green', 'Black']
>>> color_list.remove("Black")
>>> print(color_list)
['Red', 'Blue', 'Green']

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

Смотрите следующие заявления:

>>> color_list=["Red", "Blue", "Green", "Black"]
>>> print(color_list)
['Red', 'Blue', 'Green', 'Black']
>>> color_list.clear()
>>> print(color_list)
[]
>>>

Список ломтиков

Списки могут быть разрезаны как строки и другие последовательности.

Синтаксис:

 sliced_list = List_Name [startIndex: endIndex]

Это относится к элементам списка, начиная с индекса startIndex и заканчивая непосредственно перед индексом endIndex. Значениями по умолчанию для списка являются 0 (startIndex) и конец (endIndex) списка. Если вы пропустите оба индекса, срез создаст копию исходного списка.

Вырежьте первые два элемента из списка:

Смотрите следующие заявления:

>>> color_list=["Red", "Blue", "Green", "Black"] # The list have four elements 
indices start at 0 and end at 3
>>> print(color_list[0:2]) # cut first two items
['Red', 'Blue']
>>>

Вырезать второй элемент из списка:

Смотрите следующие заявления:

>>> color_list=["Red", "Blue", "Green", "Black"] # The list have four elements 
indices start at 0 and end at 3
>>> print(color_list[1:2])
['Blue']
>>> print(color_list[1:-2])
['Blue']
>>>

Вырежьте второй и третий элементы из списка:

Смотрите следующие заявления:

>>> color_list=["Red", "Blue", "Green", "Black"] # The list have four elements 
indices start at 0 and end at 3
>>> print(color_list[1:-1])
['Blue', 'Green']
>>>

Вырежьте первые три элемента из списка:

Смотрите следующие заявления:

>>> color_list=["Red", "Blue", "Green", "Black"] # The list have four elements 
indices start at 0 and end at 3
>>> print(color_list[:3]) # cut first three items
['Red', 'Blue', 'Green']
>>>

Создает копию оригинального списка:

Смотрите следующие заявления:

>>> color_list=["Red", "Blue", "Green", "Black"] # The list have four elements 
indices start at 0 and end at 3
>>> print(color_list[:]) # Creates copy of original list
['Red', 'Blue', 'Green', 'Black']
>>>

Удалить элемент в указанной позиции в списке и вернуть его

Смотрите следующие заявления:

>>> color_list=["Red", "Blue", "Green", "Black"]
>>> print(color_list)
['Red', 'Blue', 'Green', 'Black']
>>> color_list.pop(2) # Remove second item and return it
'Green'
>>> print(color_list)
['Red', 'Blue', 'Black']
>>>

Вернуть индекс в списке первого элемента, значение которого равно x

Смотрите следующие заявления:

>>> color_list=["Red", "Blue", "Green", "Black"]
>>> print(color_list)
['Red', 'Blue', 'Green', 'Black']
>>> color_list.index("Red")
0
>>> color_list.index("Black")
3
>>>

Вернуть количество раз, когда «х» появляются в списке

Смотрите следующие заявления:

>>> color_list=["Red", "Blue", "Green", "Black"]
>>> print(color_list)
['Red', 'Blue', 'Green', 'Black']
>>> color_list=["Red", "Blue", "Green", "Black", "Blue"]
>>> print(color_list)
['Red', 'Blue', 'Green', 'Black', 'Blue']
>>> color_list.count("Blue")
2
>>>

Сортировать элементы списка на месте

Смотрите следующие заявления:

>>> color_list=["Red", "Blue", "Green", "Black"]
>>> print(color_list)
['Red', 'Blue', 'Green', 'Black']
>>> color_list.sort(key=None, reverse=False)
>>> print(color_list)
['Black', 'Blue', 'Green', 'Red']
>>>

Поменяйте местами элементы списка

>>> color_list=["Red", "Blue", "Green", "Black"]
>>> print(color_list)
['Red', 'Blue', 'Green', 'Black']
>>> color_list.reverse()
>>> print(color_list)
['Black', 'Green', 'Blue', 'Red']
>>>

Вернуть мелкую копию списка

>>> color_list=["Red", "Blue", "Green", "Black"]
>>> print(color_list)
['Red', 'Blue', 'Green', 'Black']
>>> color_list.copy()
['Red', 'Blue', 'Green', 'Black']
>>>

Поиск в списках и найти элементы

>>> color_list=["Red", "Blue", "Green", "Black"]
>>> print(color_list)
['Red', 'Blue', 'Green', 'Black']
>>> color_list.index("Green")
2
>>>

Списки изменчивы

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

>>> color_list=["Red", "Blue", "Green", "Black"]
>>> print(color_list[0])
Red
>>> color_list[0]="White" # Change the value of first item "Red" to "White"
>>> print(color_list)
['White', 'Blue', 'Green', 'Black']
>>> print(color_list[0])
White
>>>

Преобразовать список в кортеж в Python

>>> listx = [1, 2, 3, 4]  
>>> print(listx)  
[1, 2, 3, 4]  
>>> tuplex = tuple(listx)  
>>> print(tuplex)  
(1, 2, 3, 4)   
>>>

Как использовать двойное двоеточие [::]?

>>> listx=[1, 5, 7, 3, 2, 4, 6]
>>> print(listx)
[1, 5, 7, 3, 2, 4, 6]
>>> sublist=listx[2:7:2] #list[start:stop:step], #step specify an increment
between the elements to cut of the list.
>>> print(sublist)
[7, 2, 6]
>>> sublist=listx[::3] #returns a list with a jump every 2 times.
>>> print(sublist)
[1, 3, 6]
>>> sublist=listx[6:2:-2] #when step is negative the jump is made back
>>> print(sublist)
[6, 2]
>>>

Найти самый большой и самый маленький элемент в списке

>>> listx=[5, 10, 3, 25, 7, 4, 15]
>>> print(listx)
[5, 10, 3, 25, 7, 4, 15]
>>> print(max(listx))	# the max() function of built-in allows to know the highest
value in the list.
25
>>> print(min(listx)) #the min() function of built-in allows to know the lowest
value in the list.
3
>>>

Сравните два списка в Python

>>> listx1, listx2=[3, 5, 7, 9], [3, 5, 7, 9]
>>> print (listx1 == listx2)
True
>>> listx1, listx2=[9, 7, 5, 3], [3, 5, 7, 9]	#create two lists equal, but unsorted.
>>> print(listx1 == listx2)
False
>>> listx1, listx2 =[2, 3, 5, 7], [3, 5, 7, 9]	#create two different list
>>> print(listx1 == listx2)
False
>>> print(listx1.sort() == listx2.sort())	#order and compare
True
>>>

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

>>> listx = [["Hello", "World"], [0, 1, 2, 3, 4, 5]]
>>> print(listx)
[['Hello', 'World'], [0, 1, 2, 3, 4, 5]]
>>> listx = [["Hello", "World"], [0, 1, 2, 3, 3, 5]]
>>> print(listx)
[['Hello', 'World'], [0, 1, 2, 3, 3, 5]]
>>> print(listx[0][1])		#The first [] indicates the index of the outer list.
World
>>> print(listx[1][3])		#the second [] indicates the index nested lists.
3
>>> listx.append([True, False])		#add new items
>>> print(listx)
[['Hello', 'World'], [0, 1, 2, 3, 3, 5], [True, False]]		
>>> listx[1][2]=4
>>> print(listx)
[['Hello', 'World'], [0, 1, 4, 3, 3, 5], [True, False]]		#update value items
>>>

Как я могу получить индекс элемента, содержащегося в списке?

>>> listy = list("HELLO WORLD")
>>> print(listy)
['H', 'E', 'L', 'L', 'O', ' ', 'W', 'O', 'R', 'L', 'D']
>>> index = listy.index("L")	#get index of the first item whose value is passed as parameter
>>> print(index)
2
>>> index = listy.index("L", 4)	#define the index from which you want to search
>>> print(index)
9
>>> index = listy.index("O", 3, 5)	#define the segment of the list to be searched
>>> print(index)
4
>>>

Использование списков в качестве стеков

>>> color_list=["Red", "Blue", "Green", "Black"]
>>> print(color_list)
['Red', 'Blue', 'Green', 'Black']
>>> color_list.append("White")
>>> color_list.append("Yellow")
>>> print(color_list)
['Red', 'Blue', 'Green', 'Black', 'White', 'Yellow']
>>> color_list.pop()
'Yellow'
>>> color_list.pop()
'White'
>>> color_list.pop()
'Black'
>>> color_list
['Red', 'Blue', 'Green']
>>>

Использование списков в качестве очередей

>>> from collections import deque
>>> color_list = deque(["Red", "Blue", "Green", "Black"])
>>> color_list.append("White")      # White arrive
>>> print(color_list)
deque(['Red', 'Blue', 'Green', 'Black', 'White'])
>>> color_list.append("Yellow")     # Yellow arrive
>>> print(color_list)
deque(['Red', 'Blue', 'Green', 'Black', 'White', 'Yellow'])
>>> color_list.popleft()            # The first to arrive now leaves
'Red'
>>> print(color_list)
deque(['Blue', 'Green', 'Black', 'White', 'Yellow'])
>>> color_list.popleft()            # The second to arrive now leaves
'Blue'
>>> print(color_list)
deque(['Green', 'Black', 'White', 'Yellow'])
>>> print(color_list)               # Remaining queue in order of arrival
deque(['Green', 'Black', 'White', 'Yellow'])
>>>

Предыдущая: Форматирование строки Python
Далее: Словарь Python

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

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

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

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

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

• Обращение к элементу списка в 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, списки встречаются довольно часто. Знание основ работы со списками поможет быстро и качественно писать программный код 😉.