Как сложить списки в python

Как объединить два списка в Python

Объединение списков — это процесс создания единого списка из нескольких меньших списков путем их последовательного соединения.

В Python есть много способов объединения списков. В частности, в этой статье мы рассмотрим, как объединить два списка в Python с помощью оператора плюс, оператора распаковки, оператора умножения, цикла for , itertools.chain() и extend() .

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

list_a = [1, 2, 3, 4] list_b = [5, 6, 7, 8] 

Объединение списка операторов +

Самый простой и понятный способ объединить два списка в Python — это оператор плюс ( + ):

list_c = list_a + list_b print (list_c) # [1, 2, 3, 4, 5, 6, 7, 8] 

Конкатенация списка с помощью распаковки

Этот метод позволяет объединить несколько списков. Это довольно новая функция, доступная только в Python 3.6+. Оператор распаковки, как следует из названия, распаковывает объект iterable на его элементы. Распаковка полезна, когда мы хотим сгенерировать множество аргументов из одного списка. Например:

def foo(a, b, c, d): return a + b + c + d # We want to use the arguments of the following list with the foo function. # However, foo doesn't take a list, it takes 4 numbers, which is why we need to # unpack the list. foo(*list_a) # This is the same as if we were to call foo(1,2,3,4) 

Вкратце, мы используем конструктор списка ( [a,b..] ) и генерируем элементы нового списка по порядку, распаковывая несколько списков один за другим:

list_c = [*list_a, *list_b, *list_a] print (list_c) # [1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4] 

Объединение списков операторов умножения

Оператор multiply( * ) — это частный случай конкатенации списков в Python. Он используется для многократного повторения всего списка (поэтому он обозначается оператором умножения):

print(list_a * 2) # [1, 2, 3, 4, 1, 2, 3, 4] 

Конкатенация списка в цикле for

В этом методе мы пройдемся по одному списку, добавляя каждый его элемент в другой список один за другим. Когда цикл закончится, у вас будет единый список со всеми желаемыми элементами:

for i in list_b: list_a.append(i) print(list_a) # [1, 2, 3, 4, 5, 6, 7, 8] 

Объединение списков itertools.chain()

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

# Если бы мы вызывали itertools.chain () вот так iterator = itertools.chain([1, 2], [3, 4]) # По сути, итератор - это стрелка, которая может дать нам следующий элемент в последовательности, # поэтому, если мы вызываем конструктор list() с указанной итерацией, он работает следующим образом: list(iterator) 

# Итератор: следующий элемент в этом списке - 1 [1, 2], [3, 4] ^ # Итератор: следующий элемент в этом списке - 2 [1, 2], [3, 4] ^ # Итератор: следующий элемент в этом списке - 3 [1, 2], [3, 4] ^ # Итератор: следующий элемент в этом списке - 4 [1, 2], [3, 4] ^ # Итак, вызов list() выглядит примерно так: list([1,2,3,4]) # Имейте в виду, что это все псевдокод, Python не дает разработчику прямого контроля над итератором

Для этого метода вам нужно будет импортировать itertools :

import itertools list_c = list(itertools.chain(list_a, list_b)) print (list_c) # [1, 2, 3, 4, 5, 6, 7, 8] 

Конкатенация списков с extension()

Это встроенная функция, которую можно использовать для расширения списка. Здесь мы расширяем первый список, добавляя в него элементы второго списка:

list_a.extend(list_b) print (list_a) # [1, 2, 3, 4, 5, 6, 7, 8] 

Вывод

В этой статье мы рассмотрели пять способов объединения двух списков в Python — с помощью оператора плюс, оператора распаковки, оператора умножения, цикла for , itertools.chain() и extend() .

Мы уже писали об объединении в предыдущей статье «Конкатенация двух списков в Python». Эта статья являться более расширенным списком методов конкатенации.

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

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

# заполнение переменных a = [1, 2, 3, 4] b = [1, 2, 3] # обработка c = map(sum, zip(a + [0,]*(len(b)-len(a)), b + [0,]*(len(a)-len(b)))) # вывод результата print(list(c)) 

Вариант 3:

В Python 3.8 появился «морж» — оператор := Если важно не повторить функционал:

# заполнение переменных a = [1, 2, 3, 4] b = [1, 2, 3] # обработка c = map(sum, zip(a + [0, ] * (x := len(b) - len(a)), b + [0, ] * -x)) # вывод результата print(list(c)) Результат: > [2, 4, 6, 4] 

Отслеживать
ответ дан 19 мар 2021 в 13:02
121 6 6 бронзовых знаков
Вариант забавный, но 1) он меняет исходные списки, 2) повторяет функционал itertools.zip_longest
19 мар 2021 в 13:10
Так то пусть будет, разные ответы это хорошо )
19 мар 2021 в 13:19
согласен, не без недостатков, но как вариант для «по быстрому»
19 мар 2021 в 13:20
добавил варианты без изменения исходных списков и вариант для Python 3.8 без повтора функционала
19 мар 2021 в 13:54

Если вы еще не «прошли ‘from’ ‘import'», то наиболее простой вариант выглядит вот так:

с=list(map(lambda x, y: x + y, a, b)) 

c1 = [x+y for x,y in zip(a,b)] + (a if len(a) >= len(b) else b)[min(len(a), len(b)):] 

При необходимости обернуть это в вызов функции, надеюсь, сможете сделать самостоятельно: на вход a и b, указанные выражения — в качестве параметра в return.

Отслеживать
ответ дан 22 дек 2019 в 14:14
11.8k 2 2 золотых знака 10 10 серебряных знаков 16 16 бронзовых знаков

Спасибо тебе за ответ) мне нужно просто без комприхенш`на может просто через def и внутри def через for буду рад если поможете = )

23 дек 2019 в 8:51

Если у вас списка ВСЕГДА точно будут одной длины, то можно воспользоваться генератор списков и zip:

a = [1, 2, 3] b = [4, 5, 6] c = [x+y for x, y in zip(a, b)] print(c) #[5, 7, 9] 

Но если вы НЕ уверены, что длина списков будет одинаковой хоть раз, то здесь нужно воспользоваться крутой библиотекой itertools:

from itertools import zip_longest a = [1, 2, 3] b = [4, 5, 6, 10] c = [x+y for x, y in zip_longest(a, b, fillvalue=0) #fillvalue нужен, если ваши списки разных рамеров и там где не достаёт элементов, добьёт нулями. print(c) #[5, 7, 9, 10] 

Ответ на комментарий:

from itertools import zip_longest def add_list(a, b): c = [x+y for x, y in zip_longest(a, b, fillvalue=0)] return c a = [1, 2, 3] b = [4, 5, 6, 10] summ_list = add_list(a, b) print(summ_list) 

Списки в Python: что это такое и как с ними работать

Рассказали всё самое важное о списках для тех, кто только становится «змееустом».

Иллюстрация: Оля Ежак для Skillbox Media

Дмитрий Зверев

Любитель научной фантастики и технологического прогресса. Хорошо сочетает в себе заумного технаря и утончённого гуманитария. Пишет про IT и радуется этому.

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

В статье есть всё, что начинающим разработчикам нужно знать о списках в Python:

• Что это такое
• Как создавать списки в Python
• Какие с ними можно выполнять операции
• Как работать совстроенными функциями
• Какие вPython есть методы управления элементами

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

Список (list) — это упорядоченный набор элементов, каждый из которых имеет свой номер, или индекс, позволяющий быстро получить к нему доступ. Нумерация элементов в списке начинается с 0: почему-то так сложилось в C, а C — это база. Теорий на этот счёт много — на «Хабре» даже вышло большое расследование 🙂

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

Все элементы в списке пронумерованы. Мы можем без проблем узнать индекс элемента и обратиться по нему.

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

Когда мы создаём объект list, в памяти компьютера под него резервируется место. Нам не нужно переживать о том, сколько выделяется места и когда оно освобождается, — Python всё сделает сам. Например, когда мы добавляем новые элементы, он выделяет память, а когда удаляем старые — освобождает.

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

Однако в списках Python можно хранить объекты разного размера и типа. Более того, размер массива ограничен, а размер списка в Python — нет. Но всё равно мы знаем, сколько у нас элементов, а значит, можем обратиться к любому из них с помощью индексов.

И тут есть небольшой трюк: списки в Python представляют собой массив ссылок. Да-да, решение очень элегантное — каждый элемент такого массива хранит не сами данные, а ссылку на их расположение в памяти компьютера!

Как создать список в Python

Чтобы создать объект list, в Python используют квадратные скобки — []. Внутри них перечисляют элементы через запятую:

Операции со списками

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

Индексация

Доступ к элементам списка получают по индексам, через квадратные скобки []:

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

Поэтому, когда мы присвоили списку b список a, то на самом деле присвоили ему ссылку на первый элемент — по сути, сделав их одним списком.

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

Иногда полезно объединить два списка. Чтобы это сделать, используют оператор +:

insert()

Добавляет новый элемент по индексу:

clear()

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

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

index()

Возвращает индекс элемента списка в Python:

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

Если элемента нет в списке, выведется ошибка:

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

pop()

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

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]

count()

Считает, сколько раз элемент повторяется в списке:

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

sort()

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

Если нам нужно отсортировать в обратном порядке — от большего к меньшему, — в методе есть дополнительный параметр reverse:

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

reverse()

Переставляет элементы в обратном порядке:

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

copy()

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

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

Метод	Что делает
a.append(x)	Добавляет элемент x в конец списка a. Если x — список, то он появится в a как вложенный
a.extend(b)	Добавляет в конец a все элементы списка b
a.insert(i, x)	Вставляет элемент x на позицию i
a.remove(x)	Удаляет в a первый элемент, значение которого равно x
a.clear()	Удаляет все элементы из списка a и делает его пустым
a.index(x)	Возвращает индекс элемента списка
a.pop(i)	Удаляет элемент по индексу и возвращает его
a.count(x)	Считает, сколько раз элемент повторяется в списке
a.sort()	Сортирует список. Чтобы отсортировать элементы в обратном порядке, нужно установить дополнительный аргумент reverse=True
a.reverse()	Возвращает обратный итератор списка a
a.copy()	Создаёт поверхностную копию списка. Для создания глубокой копии используйте метод deepcopy из модуля copy

Что запомнить

Лучше не учить это всё, а применять на практике. А ещё лучше — попытаться написать каждый метод самостоятельно, не используя никакие встроенные функции.

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

Больше интересного про код в нашем телеграм-канале. Подписывайтесь!

Читайте также:

• Как изучить Python самостоятельно и бесплатно: алгоритм
• Тест: сможете отличить Zen of Python от философии Лао-цзы?
• Rust: зачем он нужен, где применяется и за что его все любят

Списки в Python: 11 вопросов, которые могут задать на собеседовании

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

Цокто Жигмытов

Кандидат философских наук, специалист по математическому моделированию. Пишет про Data Science, AI и программирование на Python.

Список — базовая структура данных в Python. На собеседовании на позицию младшего Python-разработчика речь о нём зайдёт практически наверняка.

Мы выбрали самые популярные вопросы с собеседований, касающиеся списков, и оценили их сложность в эмодзи: (◡‿◡), (ー_ー) и (> ⌒ <). В большинстве случаев в качестве ответа достаточно написать код и прокомментировать его.

Если на вашем компьютере нет интерпретатора Python, можно воспользоваться онлайн-сервисами: Repl.it, Python Fiddle, CodeChef и другими — в них можно кодить прямо из браузера. Просто выберите язык Python версии 3.* и запускайте примеры на исполнение.

Главное, что нужно помнить о списках

• Список — это упорядоченный набор элементов, перечисленных через запятую, заключённый в квадратные скобки.
• Элементы списка могут быть разных типов, в отличие от элементов массива (array), но, как правило, используются списки из элементов одного типа.
• Список может содержать одинаковые элементы, в отличие от множества (set).
• Список можно изменить после создания, в отличие от кортежa (tuple).
• Список может содержать другие списки.

Вопрос 1. Как объединить списки?

Сложность: (◡‿◡)

Проще всего списки объединяются с помощью сложения +.

a = [1, 2] b = ['a', 'c'] print(a + b) >>> [1, 2, 'a', 'c'] print(b + a) >>> ['a', 'c', 1, 2]

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

Также списки можно объединить с помощью функции extend (). О ней ниже.

Вопрос 2. Как умножать списки?

Сложность: (◡‿◡)

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

Умножим список [1, 2, ‘b’] на 2:

list_a = [1, 2, 'b'] * 2 print(list_a) >>> [1, 2, 'b', 1, 2, 'b']

Содержание списка [1, 2, ‘b’] повторилось дважды. Если умножить список на 0 или отрицательное число, то получим пустой список.

Вопрос 3. Как проверить, существует ли значение в списке?

Сложность: (◡‿◡)

Для проверки используем in:

'a' in ['a', 'c', 'd', 'e', 'b', 'c'] >>> True 3 in ['a', 'c', 'd', 'e', 'b', 'c'] >>> False

В этом примере in возвращает True, когда элемент в списке есть, и False — если нет.

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

Сложность: (◡‿◡)

Список переворачивается с помощью функции .reverse (). При этом она меняет исходный список.

list_1 = ['a', 'b', 'c', 'd', 'e'] print(list_1) >>> ['a', 'b', 'c', 'd', 'e'] list_1.reverse() print(list_1) >>> ['e', 'd', 'c', 'b', 'a']

Сначала создали список list_1, затем вывели его на экран. Потом перевернули список с помощью .reverse () и вывели на экран уже изменённый список.

Вопрос 5. В чём разница между append и extend?

Сложность: (ー_ー)

Если кратко, то append () добавляет в конец списка значения поодиночке, а extend () добавляет их же и туда же, но уже списками.

Как работает append ():

list_a = ['a', 'b', 'c'] # создали первый список list_a.append('d') print(list_a) >>> ['a', 'b', 'c', 'd']

С помощью функции append () мы добавили одиночное значение ‘d‘ к первому списку list_a и в следующей строке вывели получившийся список на экран. Как видим, в конец списка добавился ещё один элемент ‘d‘.

Как работает extend ():

list_b = [1, 2, 3] # создали второй список list_b.extend(list_a) print(list_b) >>> [1, 2, 3, 'a', 'b', 'c', 'd']

Мы применили ко второму списку list_b функцию extend (), аргументом у которой стал другой список, list_a из кода выше. Вывод показал, что оба списка слились в один и стали новым списком list_b.

Тот же результат будет, если сложить два списка (list_b + list_a) и присвоить результат переменной list_b. Сможете написать код самостоятельно?

Вопрос 6. Как удалить из списка дубликаты?

Сложность: (ー_ー)

Это можно сделать путём преобразования списка во множество (set, иногда ещё его называют «набор»), а затем обратно в список:

list_b = [1, 1, 3, 1, 4, 8, 4] # список с дубликатами list_b = list(set(list_b)) # здесь основная магия print(list_b) >>> [8, 1, 3, 4]

С помощью функции set () преобразовали список list_b во множество, затем тут же, в этой же строке, обратно в список (с помощью уже знакомой нам функции list), и присвоили полученный результат той же переменной list_b. Python очень гибкий язык!

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

Вопрос 7. Преобразуйте цикл for в генератор списков

Сложность: (ー_ー)

Питонисты очень любят решения в одну строчку. Цикл for содержит минимум две строки, поэтому здесь есть где развернуться.

Дан следующий цикл for:

a = [1, 2, 3, 4, 5] # первый список, по которому бежим a2 = [] # пустой список, который надо заполнить for i in a: a2.append(i + 1) # заполняем его в цикле for print(a2) >>> [2, 3, 4, 5, 6]

Пока i бежит по первому списку a, цикл заполняет второй список значениями на единицу больше текущего значения i. Итого четыре строки, не считая вывода итогового списка.

Как сделать то же самое, но с помощью генератора списка:

a = [1, 2, 3, 4, 5] # первый список, по которому бежим a3 = [i+1 for i in a] # генератор и сразу итоговый список print(a3) >>> [2, 3, 4, 5, 6]

Получили точно такой же список, но уже за две строки и без манипуляций с функцией append () в теле цикла for. Генератор списка принято считать более каноническим способом в Python, если он остаётся понятным.

Вопрос 8. В чём разница между remove, pop и del?

Сложность: (ー_ー)

Каждый из этих трёх методов (точнее, двух методов и одной команды) удаляет элементы списка. Но каждый делает это по-своему и, соответственно, применяется в разных ситуациях.

remove ()

Метод remove () удаляет из списка первое совпадающее значение.

Возьмём список и удалим из него элемент ‘b‘:

list_1 = ['a', 'b', 'c', 'd', 'e', 'b', 'c'] list_1.remove('b') print(list_1) >>> ['a', 'c', 'd', 'e', 'b', 'c']

Первая ‘b‘ исчезла, но вторая ‘b‘ осталась в списке.

pop ()

Метод pop () удаляет элемент по индексу и возвращает этот элемент:

list_3 = ['a','b','c','d'] list_3.pop(2) >>> 'c' print(list_3) >>> ['a', 'b', 'd']

Индексация в Python идёт с нуля, поэтому элемент с индексом 2 — третий по счёту. В последних строчках мы вывели изменённый список.

del

Команда del тоже удаляет элемент списка по его индексу, но имеет отличный от pop () синтаксис и ничего не возвращает:

list_1 = ['a', 'c', 'd', 'e', 'b', 'c'] del list_1[4] print(list_1) >>> ['a', 'c', 'd', 'e', 'c']

Мы недосчитались четвёртого по индексу (и пятого по счёту) элемента, то есть ‘b‘.

Также команда del может удалять из списка срезы (slices):

list_2 = [-1, 1, 66.25, 333, 337, 1234.5] del list_2[2:4] print(list_2) >>> [-1, 1, 337, 1234.5]

При указании границ среза в Python последний элемент в срез не входит. Поэтому из списка удалены элементы с третьего (индекс 2) по пятый (индекс 4), исключая последний, то есть 66.25 и 333.

Наконец, del может удалять целые переменные.

list_2 = [-1, 1, 66.25, 333, 333, 1234.5] print(list_2) >>> [-1, 1, 66.25, 333, 333, 1234.5] del list_2 print(list_2) Traceback (most recent call last): File "", line 1, in list_2 NameError: name 'list_2' is not defined

Сначала создали список, затем вывели его на экран, чтобы убедиться, что он существует. Потом применили к нему команду del и вызвали снова. Ошибка! Python забыл, что вообще была такая переменная list_2.

Вопрос 9. Чем список отличается от других структур?

Сложность: (> ⌒ <)

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

Список и кортеж (tuple)

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

Список и множество (set)

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

Список и словарь (dictionary)

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

Список и массив (array)

Для использования массива нужно вызывать библиотеку array, а списки встроены в Python. В массиве могут содержаться элементы только одного типа. Массив не может содержать другие массивы или списки. Массив занимает меньше памяти и поэтому быстрее, чем одномерный список.

Список и массив NumPy (numpy.array)

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

Вопрос 10. Как объединить два списка в список кортежей?

Сложность: (> ⌒ <)

Для объединения двух списков в список кортежей можно использовать функцию zip, причём не только для двух, но и для трёх и более списков. Это полезно для формирования, например, матриц из векторов.

list_a = ['a' ,'b' ,'c', 'd'] list_b = [1, 2, 3, 4] list_c = [(k, v) for k, v in zip(list_a, list_b)]) print(list_c) >>> [('a', 1), ('b', 2), ('c', 3), ('d', 4)]

В первых двух строчках мы создали два списка, которые надо объединить. В третьей с помощью конструкции, похожей на двойной генератор, создали список, состоящий из кортежей вида (k, v), где k и v берутся из двух наших списков с помощью функции zip (). К слову, она не зря носит такое название: в переводе zip означает «застёжка-молния», и эта функция как бы сшивает два списка в один.

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

Вопрос 11. Как работает функция range?

Сложность: (ー_ー)

Функция range () генерирует три разных вида последовательностей из целых чисел и часто используется для быстрого создания списков — поэтому этот вопрос и попал в нашу подборку. Да и объяснять работу функции удобнее всего именно с помощью списка.

Последовательность от нуля до n

Используется range (n):

list_a = [i for i in range(10)] # первый способ print(list_a) >>> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] list_b = list(range(10)) # второй способ print(list_b) >>> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Функция range (n) сгенерировала последовательность от нуля до n (исключая n), а мы эту последовательность двумя способами обернули в список. Первый способ вы уже узнали — это генератор списков, а второй использует функцию list, которая превращает подходящий аргумент в список.

Попробуйте передать в range () отрицательное (-7) или дробное (3.14) число. Получится ли какой-нибудь список из этого, и если да, то какой?

Последовательность от n до m

Здесь в функцию range () нужно передать уже два аргумента: тогда range (n, m) сгенерирует целые числа от n до m (исключая m):

list_a = [i for i in range(3, 12)] # первый способ print(list_a) >>> [3, 4, 5, 6, 7, 8, 9, 10, 11] list_b = list(range(9, 20)) # второй способ print(list_a) >>> [9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

Последовательность от n до m с шагом k

Если в функцию range () передать три аргумента n, m, k, то она снова создаст последовательность от n до m (снова исключая m), но уже с шагом k:

list_a = [i for i in range(2, 34, 4)] # первый способ print(list_a) >>> [2, 6, 10, 14, 18, 22, 26, 30] list_b = list(range(2, 34, 4)) # второй способ print(list_b) >>> [2, 6, 10, 14, 18, 22, 26, 30]

Разница между элементами (шаг) равна третьему аргументу, то есть 4. Так как последний элемент (34) исключён, то список у нас заканчивается на 30.

Дайте мне список, и я переверну мир

Так (или примерно так) говорил ещё Архимед, а кто мы такие, чтоб с ним спорить. Список — простой, понятный и надёжный инструмент: в любой непонятной ситуации попробуйте сначала применить список, и даже если он не подойдёт, то подскажет, как и чем решать задачу дальше. Обязательно посмотрите другие методы списков из официальной документации Python, чтобы они не оказались для вас сюрпризом на собеседовании.

Конечно, Python — это не только списки, и изучать его лучше на родном языке в компании единомышленников. Приходите на наш курс «Профессия Python-разработчик». Под руководством опытных наставников вы станете настоящим укротителем питонов повелителем списков, массивов и словарей, а заодно получите востребованную и высокооплачиваемую специальность.

Читайте также:

• 5 проектов, которые можно сделать на Python
• Это классика, это знать надо: DRY, KISS, SOLID, YAGNI и другие полезные сокращения
• Как начать программировать на Python: экспресс-гайд