Соединить два list python

Объединение списков в Python: инструкция

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

Основные методы объединения списков Python 3

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

• конкатенация с оператором + ,
• умножение с оператором * ,
• с циклом for ,
• с функцией join() ,
• с функцией extend() ,
• с функцией map() ,
• методом itertools.chain() .

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

Конкатенация с оператором +

Пожалуй, самый простой способ, который не требует особых пояснений:

>>> sequence1 = [57, 69, 45, 25, 36]>>> sequence2 = ['g', 'w', 'm', 'a', 't']>>> joined = sequence1 + sequence2
>>> print(joined)
[57, 69, 45, 25, 36, 'g', 'w', 'm', 'a', 't']

Мы создали два списка с целочисленными и буквенными значениями и объединили их путем простого сложения. Заметим, что при этом все элементы списков останутся на своих местах, то есть сначала будут выведены элементы sequence1 , а уже за ним пойдет sequence2 , причем в той же последовательности.

Умножение с оператором *

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

>>> print(sequence2 * 3)
['g', 'w', 'm', 'a', 't', 'g', 'w', 'm', 'a', 't', 'g', 'w', 'm', 'a', 't']

Как видим, все элементы выдаются в той же последовательности заданное число раз.

Варианты с циклом for

Любителям циклического программирования подойдет такой вариант:

>>> numbers1 = [38, 98, 17, 37, 12]>>> numbers2 = [34, 30, 78, 75, 11]>>> for num in numbers2: 
numbers1.append(num)
>>> print(numbers1)
[38, 98, 17, 37, 12, 34, 30, 78, 75, 11]

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

Также с помощью цикла for можно выполнить объединение двух вложенных списков Python . Допустим, у нас есть два таких вложенных списка, которые мы должны объединить:

Чтобы это сделать, нужно написать следующий код:

>>> merged = [element for each_list in integers for element in each_list]>>> print(merged)
[60, 85, 57, 31]

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

>>> merged = [x for l in integers for x in l]>>> print(merged)

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

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

>>> athletes = [['Bolshunov Aleksandr', 25, 'cross_country_skiing'], 
['Fourcade Martin', 33, 'biathlon'], 
['Klaebo Johannes', 25, 'cross_country_skiing'], 
['Boe Johannes', 29, 'biathlon']]

А объединить их в словарь можно с помощью следующего кода:

>>> athletes_dictionary = 
>>> print(athletes_dictionary) 

Функция join()

Функция join() в Python помогает выполнять объединение элементов списка в строку :

>>> piece_of_poetry = ['Человек', 'собаке', 'друг:', 'это', 'знают', 'все', 'вокруг.']>>> piece_string = ' '.join(piece_of_poetry)
>>> print(piece_string)
Человек собаке друг: это знают все вокруг.

Чтобы строка получилась с отступами между элементами, мы в качестве имени разделителя добавили в код пробел: ‘ ‘.join . Есть и более длинный вариант добавления разделителя через переменную. Слегка изменим часть кода из примера выше:

>>> delimit = ' '
>>> piece_str = delimit.join(piece_of_poetry)
>>> print(piece_str)

Функция extend()

Еще одна простая функция, при помощи которой нетрудно объединить списки. Этот код тоже не требует пояснений:

>>> numbers1 = [38, 98, 17, 37, 12]>>> numbers2 = [34, 30, 78, 75, 11]>>> numbers1.extend(numbers2)
>>> print(numbers1)
[38, 98, 17, 37, 12, 34, 30, 78, 75, 11]

Функция map()

Польза этой функции в том, что она преобразует список, составленный из целых чисел, в строку. Причем map() хорошо работает вместе с уже известной нам join() , вот пример:

>>> integers = [38, 98, 17, 37, 12, 34, 30, 78, 75, 11]>>> maplist = map(str, integers)
>>> delimit = ', '
>>> result = delimit.join(maplist)
>>> print(result)
38, 98, 17, 37, 12, 34, 30, 78, 75, 11

Обратите внимание, что str — это обозначение объекта «строка», поэтому изменять его недопустимо (вы увидите здесь характерную подсветку синтаксиса Python). А вот integers , maplist , delimit и result изменяемые, поскольку это переменные. Мы снова выбрали «говорящие» названия, но вы можете назначить им любые другие, лишь бы они были корректными с точки зрения синтаксиса.

Метод itertools.chain()

itertools — вызываемая функция, поэтому для начала вызовем ее командой import :

>>> import itertools
>>> integers = [39, 97, 18, 36, 11, 35, 29, 77, 74, 10]>>> letters = ['g', 'w', 'm', 'a', 't', 'y', 'c', 'k', 'b', 'u']>>> result = list(itertools.chain(integers, letters))
>>> print(result)
[39, 97, 18, 36, 11, 35, 29, 77, 74, 10, 'g', 'w', 'm', 'a', 't', 'y', 'c', 'k', 'b', 'u']

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

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

>>> integers1 = [38, 98, 17, 37, 12, 34, 30, 78, 75, 11]>>> integers2 = [39, 97, 18, 36, 11, 35, 29, 77, 74, 10]>>> integers3 = integers1 + integers2
>>> print(integers3)
[38, 98, 17, 37, 12, 34, 30, 78, 75, 11, 39, 97, 18, 36, 11, 35, 29, 77, 74, 10]>>> sorted(integers3)
[10, 11, 11, 12, 17, 18, 29, 30, 34, 35, 36, 37, 38, 39, 74, 75, 77, 78, 97, 98]

Простая функция sorted отсортирует новый список в порядке от меньшего к большему. Это же касается и буквенных значений (немного оптимизируем код и сразу сделаем вывод отсортированного списка, как обычно и требуется):

>>> letters1 = ['g', 'w', 'm', 'a', 't']>>> letters2 = ['y', 'c', 'k', 'b', 'u']>>> letters3 = letters1 + letters2
>>> sorted(letters3)
['a', 'b', 'c', 'g', 'k', 'm', 't', 'u', 'w', 'y']

Еще короче получается код с помощью моржового оператора:

>>> letters1 = ['g', 'w', 'm', 'a', 't']>>> letters2 = ['y', 'c', 'k', 'b', 'u']>>> sorted(letters3 := letters1 + letters2)
['a', 'b', 'c', 'g', 'k', 'm', 't', 'u', 'w', 'y']

И помните, что сортировать можно только объекты одного типа: например, при попытке сортировки числовых и буквенных значений интерпретатор 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». Эта статья являться более расширенным списком методов конкатенации.

Источник