Как создать пустой список в python

Списки в Python

Здесь мы сохранили 2 переменные, в которых лежат названия фруктов. Но фруктов очень много. Что, если нам нужно работать с сотней таких записей? Например, если у вас интернет-магазин фруктов, придётся хранить очень много фруктов. Не создавать же сотню переменных…

Для таких задач есть списки:

fruits = ["Яблоко", "Банан", "Персик"] 

Список — это как бы способ сохранить много штук (строк, чисел и т.д.) в одной переменной. В этом случае в переменной fruits лежит сразу 3 строки: «Яблоко» , «Банан» и «Персик» .

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

0: “Яблоко”
1: “Банан”
2: “Персик”

Чтобы получить нулевой элемент, мы пишем fruits[0] . Такой код выведет Яблоко :

apple = fruits[0] print(apple) 

Как добавить элемент в список

Бывает такое, что мы хотим добавить в список что-нибудь. Например, в магазине расширился ассортимент и теперь он торгует апельсинами. Добавляет строки в список метод .append() :

new_fruit = "Апельсин" fruits.append(new_fruit) print(fruits) 

Список выведется с новым фруктом: [‘Яблоко’, ‘Банан’, ‘Персик’, ‘Апельсин’] .

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

Допустим, вы решили перестать торговать бананами. Нужно убрать их из списка. Поможет метод .remove() :

banana = "Банан" fruits.remove(banana) print(fruits) 

Список выведется без банана: [‘Яблоко’, ‘Персик’, ‘Апельсин’] .

Из списка можно удалять элементы по их индексу. Код удалит нулевой элемент списка:

del fruits[0] print(fruits) 

Список выведется без яблока: [‘Персик’, ‘Апельсин’] .

Как создать пустой список

Есть такая штука, как пустой список. Это когда в списке ничего не лежит. Создаётся он так:

empty_list = [] 

Так же, как и список с элементами, только без них. Вот так вот просто. В будущем этот список можно наполнить методом .append() .

Что дальше

Если статья не смогла объяснить что же такое списки или вы хотите почитать о них ещё, подойдут эти статьи:

• Списки на metanit
• Списки на pythontutor

Попробуйте бесплатные уроки по Python

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

Переходите на страницу учебных модулей «Девмана» и выбирайте тему.

Списки в Python: методы и основные операции

Рассмотрим создание списков в Python и разберём основные методы. Научимся изменять, сортировать и совершать другие операции над list.

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

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

1. Хранение в памяти
2. Создание списка
3. Срезы (slice)
4. Простые операции
5. Методы списков

Хранение в памяти

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

numbers = [1, 2] numbers[1] = 3 # обновлённый список: [1, 3] 

До замены элемента последовательности print(numbers[1]) выведет 2, а после замены — 3.

Создание списка в Python

Это можно сделать несколькими способами, например перечислением элементов списка в квадратных скобках:

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9] 

При этом единица будет на позиции 0, то есть print(numbers[0]) выведет 1.

Также можно использовать обработку итерируемого объекта функцией list() . Пусть у нас будет некоторая строка, тогда:

list('tproger') # ['t', 'p', 'r', 'o', 'g', 'e', 'r'] 

Также существуют генераторы списков, которые позволяют применить заданное выражение к каждому элементу последовательности. Допустим, необходимо создать list, состоящий из чисел от 1 до 5 включительно:

numbers = [i for i in range(1,6)] # [1, 2, 3, 4, 5] 

Срезы (slice) списка

Срезы позволяют получить некое подмножество значений. Следующий код вернёт список с элементами, начиная индексом 0 и не включая при этом индекс 2 и выше:

numbers = [1, 5, 9, 6] print(numbers[0:2]) # вывод [1, 5] 

Далее выведем всё, за исключением элемента на позиции 3:

print(numbers[:3]) # вывод [1, 5, 9] 

А теперь начиная с индекса 1 и до конца:

print(numbers[1:]) # вывод [5, 9, 6] 

Операции над списками Python

• x in l — true , если элемент x есть в списке l ;
• x not in l — true , если элемент x отсутствует в l ;
• l1 + l2 — объединение двух списков;
• l * n , n * l — копирует список n раз;
• len(l) — количество элементов в l ;
• min(l) — наименьший элемент;
• max(l) — наибольший элемент;
• sum(l) — сумма чисел списка;
• for i in list() — перебирает элементы слева направо.

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

Index

Возвращает положение первого совпавшего элемента. Поиск совпадения происходит слева направо. Пример:

numbers = [1, 5, 9, 6, 1, 2, 1] print(numbers.index(1)) # вывод 0: первая найденная единица на позиции 0 

Count

Данный метод считает, сколько раз указанное значение появляется в списке Python:

numbers = [1, 5, 9, 6, 1, 2, 1] print(numbers.count(1)) # вывод 3, потому что единица встречается 3 раза 

Append

Добавляет указанное значение в конец:

numbers = [1, 5, 9, 6] numbers.append(3) # обновлённый список: [1, 5, 9, 6, 3] 

Sort

Сортирует список в Пайтоне. По умолчанию от меньшего к большему:

numbers = [1, 5, 9, 6] numbers.sort() # обновлённый список: [1, 5, 6, 9] 

Также можно сортировать последовательность элементов от большего к меньшему:

numbers = [1, 5, 9, 6] numbers.sort(reverse = true) # обновлённый список: [9, 6, 5, 1] 

Insert

Вставляет элемент перед указанным индексом:

numbers = [1, 5, 9, 6] numbers.insert(3, [2, 3]) # обновлённый список: [1, 5, 9, [2, 3], 6] 

Remove

Удаляет первое попавшееся вхождение элемента в списке Python:

numbers = [1, 5, 9, 6, 1, 2, 1] numbers.remove(1) # обновлённый список: [5, 9, 6, 1, 2, 1] 

Extend

Подобно методу append() , добавляет элементы, но преимущество метода extend() в том, что он также позволяет добавлять списки:

numbers = [1, 5, 9, 6] numbers.extend([2, 3]) # обновлённый список: [1, 5, 9, 6, 2, 3] 

Pop

А данный метод удаляет элемент в конкретно указанном индексе, а также выводит удалённый элемент. Если индекс не указан, метод по умолчанию удалит последний элемент:

numbers = [1, 5, 9, 6] numbers.pop(1) # получаем: # 5 # [1, 9, 6] 

Join

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

mylist = ['сайт', 'типичный', 'программист'] print(', '.join(mylist)) # вывод 'сайт, типичный, программист' 

Как в питоне объявить список фиксированной длины, но не заполнять его?

Вызове ошибку MemoryError , потому, что список в добавок к объявлению заполняется числами от 0 до 999999999.

Отслеживать
149k 12 12 золотых знаков 59 59 серебряных знаков 132 132 бронзовых знака
задан 15 янв 2018 в 11:44
alex romancov alex romancov
416 1 1 золотой знак 3 3 серебряных знака 15 15 бронзовых знаков

Встречный вопрос — а зачем? Если вы больше раскажете о своей задаче, то вам могут подсказать другие решения. PS не стоит применять шаблоны С/С++ в Python

15 янв 2018 в 11:47

«Вот в с++ к примеру это делается легко», правда, результат немного не компилируется 🙂 ideone.com/Or9N3C

– user181100
15 янв 2018 в 11:54

Вы не можете создать список фиксированной длины, не заполнив его, ни в питоне, ни c++, ни в си, ни в любом другом языке. Список обязательно будет заполнен хоть чем-нибудь — например, нулями, null или None. И в любом из этих случаев вы рискуете получить MemoryError или его аналог в любом языке.

15 янв 2018 в 12:00
int arr[10]; тоже выделяет память для массива.
15 янв 2018 в 12:11

5 ответов 5

Сортировка: Сброс на вариант по умолчанию

Список фиксированной длины — это скорее всего МАССИВ. Тогда так:

import numpy as np MAXSIZE = 1000000 l = np.empty(MAXSIZE, dtype=np.int16) 

только он будет заполнен «остаточным мусором», а не «Ничем». Ничем вам показали в другом ответе )
Реализация массива в numpy намного более экономна по расходованию памяти, чем стандартный список, но не позволяет хранить объекты разных типов и добавлять или удалять элементы массива.
Кстати — если тип не указывать, то будет массив float

Отслеживать
ответ дан 15 янв 2018 в 12:06
Vasyl Kolomiets Vasyl Kolomiets
4,030 5 5 золотых знаков 26 26 серебряных знаков 46 46 бронзовых знаков
И всё равно на больших размерах будет MemoryError
15 янв 2018 в 12:08

@Александр ну для решения этой проблемы есть распределенное хранение данных на нескольких серверах, SPARK в конце концов. Как известно — память ограничена физически, а натуральный ряд — нет. (: Всегда найдется «слишком большой» размер массива

15 янв 2018 в 12:10

Удивительно, что автор принял и этот ответ тоже, ведь он не решает ни одной из проблем, обозначенных в вопросе (в котором, кстати, правок не было)

15 янв 2018 в 12:25
@andreymal — я привел точный аналог int arr[10]; для пайтона. Это то что хотел автор.
15 янв 2018 в 12:28

@КонстантинЛи этот ответ также к MemoryError ведёт (может быть с небольшой задержкой. К примеру, у меня на телефоне numpy.empty(10**9) вызывает MemoryError

15 янв 2018 в 15:11

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

L = [None] * 10**9 

необходимо место под сами ссылки и рано или поздно вы получите MemoryError (мне не известны реализации Питона, где списки лениво создаются). См. Размер списка в Python и объём оперативной памяти

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

и добавлять к нему элементы к нему по мере необходимости ( L.append(<>) ). Это не спасёт от MemoryError при достаточно большом количестве элементов.

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

import array a = array.array('i', [0]) * 10**9 

Это меньше памяти чем обычный список может занимать, но от MemoryError при достаточно больших размерах это не спасёт (также как и numpy.empty(10**9) ). Reserve memory for list in Python?

Чтобы память не требовать, можно использовать ленивые последовательности, к примеру, в Питоне 3:

R = range(10**9) 

Нужные элементы на лету могут создаваться. Большие размеры, такие как range(10**21) , не приводят к MemoryError в этом случае. Можно также свои классы создавать, к примеру, размер GmtimeOverflowTable практически не ограничен.

Работа со списками (list) в Python

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

>>> elements = list() >>> type(elements) >>> print(elements) []

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

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

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

>>> elements = [1, 2, 3, ‘word’] >>> elements[3] ‘word’

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

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

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

>>> elements = [1, 2, 3, ‘word’] >>> elements[-4] 1 >>> 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[:3] # удаляем все элементы до 3-го элемента >>> print(elements) [8, 12] >>> 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, а его адрес >>> print(id(a), id(b)) 56466376 56466376 # a и b ссылаются на один и тот же список >>> 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 = [«кот», «слон», «змея»] >>> b = a.copy() >>> print(id(a), id(b), a, b) 56467336 56467016 [‘кот’, ‘слон’, ‘змея’] [‘кот’, ‘слон’, ‘змея’] >>> d = list(a) >>> print(id(a), id(d), a, d) 56467336 60493768 [‘кот’, ‘слон’, ‘змея’] [‘кот’, ‘слон’, ‘змея’] >>> import copy >>> e = copy.copy(a) # >>> print(id(a), id(e), a, e) 56467336 60491304 [‘кот’, ‘слон’, ‘змея’] [‘кот’, ‘слон’, ‘змея’] >>> f = copy.deepcopy(a) >>> print(id(a), id(f), a, f) 56467336 56467400 [‘кот’, ‘слон’, ‘змея’] [‘кот’, ‘слон’, ‘змея’] >>> c = a[:] # устаревший синтаксис >>> print(id(a), id(c), a, c) 56467336 60458408 [‘кот’, ‘слон’, ‘змея’] [‘кот’, ‘слон’, ‘змея’]

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

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

>>> a = [«кот», «слон», «змея»] >>> b = a[2:] # с 2-го элемента (включительно) до конца списка >>> print(b) [‘змея’] >>> c = a[:2] # с начала списка по 2-й элемент >>> print(c) [‘кот’, ‘слон’] >>> d = a[1:2] # с 1-го элемента (включительно) по 2-й элемент >>> print(d) [‘слон’] >>> 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)

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

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

Из примеров выше можем сделать вывод, что конструкция 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] # extend >>> elements = [1, 2, 3, «meow»] >>> elements.extend([4, 5, «gaf»]) >>> print(elements) [1, 2, 3, ‘meow’, 4, 5, ‘gaf’] # insert >>> a = [1, 3, 4] >>> a.insert(1, 2) # insert добавит на позицию 1 цифру 2 >>> print(a) [1, 2, 3, 4] # remove >>> elements = [1, «meow», 3, «meow»] >>> elements.remove(«meow») # remove удалит только первое вхождение >>> print(elements) [1, 3, ‘meow’] # clear >>> a = [1, 2, 3] >>> a.clear() >>> print(a) [] # copy >>> a = [1, 2, 3] >>> b = a.copy() >>> print(id(a), id(b), a, b) 60458408 60491880 [1, 2, 3] [1, 2, 3] # count >>> elements = [«one», «two», «three», «one», «two», «one»] >>> print(elements.count(«one»)) 3 # index >>> elements = [«one», «two», «three», «one», «two», «three»] >>> print(elements.index(«three»)) # index вернет первый найденный индекс 2 # pop (положительный индекс) >>> elements = [1, «meow», 3, «wow»] >>> elements.pop(1) # удаляет элемент с индексом 1 ‘meow’ # pop возвращает удаленный элемент списка >>> print(elements) [1, 3, ‘wow’] # pop (отрицательный индекс) [удаление с конца списка, начиная с -1] elements = [«hello», «world», «!»] elements.pop(-2) ‘world’ >>> print(elements) [‘hello’, ‘!’] # pop (без индекса) [удалит из списка последний элемент] >>> elements = [1, 2, 3] >>> elements.pop() # по умолчанию, в методе pop индекс равен -1 3 >>> print(elements) [1, 2] # reverse >>> a = [1, 2, 3] >>> a.reverse() >>> print(a) [3, 2, 1] # sort (по возрастанию) >>> elements = [3, 19, 0, 3, 102, 3, 1] >>> elements.sort() >>> print(elements) [0, 1, 3, 3, 3, 19, 102] # 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[0]) [‘яблоки’, 50] >>> print(elements[1][0]) апельсины

Срезы

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

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

В этом случае берётся срез от номера 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(id(elements), id(int_elements)) # elements и int_elements — 2 разных списка 53219112 53183848 >>> print(elements) [0.1, 0.2, 1, 2, 3, 4, 0.3, 0.4] # срез не модифицирует исходный список >>> 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)

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»] >>> print(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, списки встречаются довольно часто. Знание основ работы со списками поможет быстро и качественно писать программный код ��.