Как объединить два списка в 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». Эта статья являться более расширенным списком методов конкатенации.
8 методов для сложения и объединения списков в Python
В этой теме мы обсудим методы для сложения и объединения двух или более списков с разными функциями в Python. Прежде чем перейти к рассмотрению концепций, давайте кратко познакомимся со списком Python. Список Python — это набор нескольких элементов, сгруппированных под одним именем. Он может хранить элементы данных различных типов (целые, строковые, с плавающей запятой и т. д.) внутри квадратных скобок [], разделенных запятой(,).
Программа для печати списка Python
# list of characters List1 = ['A', 'B', 'C', 'D', 'E'] # list of integers List2 = [1, 2, 3, 4, 5,] # mixed lists List3 = ['A', 1, 'C', 'E', 5, 8] print(" Display the List1 ", List1) print(" Display the List2 ", List2) print(" Display the List3 ", List3)
Display the List1 ['A', 'B', 'C', 'D', 'E'] Display the List2 [1, 2, 3, 4, 5] Display the List3 ['A', 1, 'C', 'E', 5, 8]
Когда мы объединяем два или более списков вместе в программе Python, получается объединенный список. И этот процесс называется составлением или объединением списков.
Давайте обсудим различные способы объединения двух или более списков в Python:
- Объединяйте списки в Python с помощью функции join() и разделителей.
- Присоединяйтесь к списку с помощью функции join() без разделителей.
- Присоединяйтесь к списку двух целых чисел в Python с помощью функции map().
- Объедините два списка в Python, используя цикл for и функцию append().
- Объедините несколько списков с помощью метода itertools.chain().
- Соединяйте списки с помощью оператора(+).
- Соедините два списка в Python с помощью оператора умножения(*).
- Объедините списки с помощью функции extend().
Объединение списков с помощью функции join()
Функция join() используется для присоединения повторяющегося списка к другому списку, разделенному указанными разделителями, такими как запятая, символы, дефис и т. д.
str_name.join( iterable)
str_name: это имя разделителя, разделяющего повторяющийся список.
iterable: это список, который содержит набор элементов и объединяется с разделителем.
Возвращаемое значение: возвращает объединенный список, разделенный указанными разделителями.
Примечание. Если итерируемый список содержит какие-либо нестроковые значения или элементы, он вызывает исключение TypeError.
Программа для объединения двух списков с помощью функции join() и разделителя
List1 = [ "Apple", "Orange", "Banana", "Mango", "Grapes" ] Str2 = ", " # It is the comma delimiter # use join() function to join List1 with the " . " delimiter Str2 = Str2.join( List1) # print the join list print(" Display the concatenated List1 using join() function and delimiter", Str2) List2 = [ "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday" ] Str3 = " - " # It is the hyphen delimiter # use join() function to join List2 with the " - " delimiters Str3 = Str3.join( List2) # print the join list print(" Display the concatenated List2 using join() function and delimiter", Str3)
Display the concatenated List1 using join() function and delimiter Apple, Orange, Banana, Mango, Grapes Display the concatenated List2 using join() function and delimiter Sunday - Monday - Tuesday - Wednesday - Thursday
Программа для присоединения к списку без использования разделителя
# declare a python list Lt1 = [ 'j', 'a', 'v', 'a', 't', 'p', 'o', 'i', 'n', 't' ] print( " Display the elements of the List L1 " , Lt1) L2 = ' ' # declare any empty string without defining any delimiter Ret = L2.join( Lt1) # use join method to join L1 list with L2 print( " Display the List without using delimiters", Ret)
Display the elements of the List L1 ['j', 'a', 'v', 'a', 't', 'p', 'o', 'i', 'n', 't'] Display the List without using delimiters j a v a t p o i n t
Присоединение к списку двух целых чисел с помощью функции map()
Целочисленный список: он собирает все целые числа в списке, называемом целочисленным списком, и мы не можем объединить два целочисленных списка в Python с помощью функции join(). Поэтому мы используем функцию map(), которая преобразует целочисленный список в строку. После этого мы используем функцию join() для объединения результатов функции map() с соответствующими разделителями.
map(str, list_name)
В приведенном выше синтаксисе функция map() имеет два параметра: list_name и str. Где list_name — это имя списка целых чисел, а str — строка. Функция map() преобразует list_name в строку (str).
Программа для использования функции map() и функции join() в списке
Давайте создадим программу для преобразования заданного списка целых чисел в строку, используя функцию map(), а затем функцию join() для присоединения к списку.
lt = [1, 2, 3, 4, 5] # use map() function to convert integer list into string list_map = map(str, lt) lt2 = ', ' # use join() function to join lists and delimiter comma(,) res = lt2.join(list_map) print(" Display the concatenated integers list using map() and join() function ", res)
Display the concatenated integers list using map() and join() function 1, 2, 3, 4, 5
Программа для объединения двух списков в Python с помощью цикла for и функции append()
Функция append() используется для последовательного добавления или присоединения каждого элемента повторяющегося списка в конце другого списка с помощью цикла for. Давайте создадим простую программу для добавления элементов списка в конец другого списка с помощью функции append().
List1 = [1, 2, 3, 4, 5] # declare List1 List2 = [5, 6, 7, 8, 9, 10] # declare List2 print(" Given List1 ", List1) print(" Given List2 ", List2) # use for loop to iterate each element of Lt1 to l2 for i in List2: List1.append(i) # use append() function to insert each elements at the end of Lt1 print(" Display concatenation list using append() function ", List1)
Given List1 [1, 2, 3, 4, 5] Given List2 [5, 6, 7, 8, 9, 10] Display concatenation list using append() function [1, 2, 3, 4, 5, 5, 6, 7, 8, 9, 10]
Объединение нескольких списков с использованием метода itertools.chain()
Давайте создадим простую программу на Python для объединения нескольких списков с помощью метода chain(), импортировав пакет itertools.
# use Python itertools.chain() method to join two list import itertools # declare different lists a = [1, 2, 3, 4, 5] b = [6, 7, 8, 9, 10] c = [11, 12, 13, 14, 15] print(" Display the first list ", a) print(" Display the second list ", b) print(" Display the third list ", c) # use itertools.chain() method to join the list result = list(itertools.chain(a, b, c)) # pass the result variable in str() function to return the concatenated lists print(" Concatenated list in python using itertools.chain() method ", str(result))
Display the first list [1, 2, 3, 4, 5] Display the second list [6, 7, 8, 9, 10] Display the third list [11, 12, 13, 14, 15] Concatenated list in python using itertools.chain() method [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
Программа для объединения двух списков с помощью оператора +
Рассмотрим пример объединения двух списков в Python с помощью оператора(+) плюс.
# Create a program to join two lists in Python using the '+' operator # declare two lists of characters list1 = [ 'A', 'B', 'C', 'D', 'E'] list2 = [ 'F', 'G', 'H', 'I', 'J'] # join two characters lists using '+' operator lt_sum1 = list1 + list2 # declares two lists of integers list3 = [ '1', '2', '3', '4', '5'] list4 = [ '6', '7', '8', '9', '10'] # join two integers lists using '+' operator lt_sum2 = list3 + list4 # display the concatenation list print(" Join two list of characters in Python using + operator: ", str(lt_sum1)) # display the concatenation list print(" Join two list of integers in Python using + operator: ", str(lt_sum2))
Join two list of characters in Python using + operator: ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J'] Join two list of integers in Python using + operator: ['1', '2', '3', '4', '5', '6', '7', '8', '9', '10']
Объединение двух списков с оператором умножения(*)
Рассмотрим пример объединения двух списков в Python с помощью оператора *.
# declare two lists of characters List1 = [ 'A', 'B', 'C', 'D', 'E'] List2 = [ 'F', 'G', 'H', 'I', 'J'] print(" Display character List1 ", List1) print(" Display character List2 ", List2) # join two characters lists using '*' operator lt_sum1 = [*List1, *List2] # declares two lists of integers List3 = [ 1, 2, 3, 4, 5] List4 = [ 6, 7, 8, 9, 10] print(" Display integer List3 ", List3) print(" Display integer List4 ", List4) # join two integers lists using '*' operator lt_sum2 = [*List3, *List4] # display the concatenation list print(" Join two characters list in Python using * operator: "+ str(lt_sum1)) # display the concatenation list print(" Join two integers list in Python using * operator: "+ str(lt_sum2))
Display integer List3 [1, 2, 3, 4, 5] Display integer List4 [6, 7, 8, 9, 10] Join two characters list in Python using * operator: ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J'] Join two integers list in Python using * operator: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
Метод extend() для объединения двух списков в Python
Напишем простую программу для объединения двух списков с помощью метода extend() в Python.
# takes two integers lists List1 = [5, 10, 5] List2 = [ 2, 4, 6, 8] print(" Display the List1 ", List1) print(" Display the List1 ", List2) # takes two string lists List3 = [ 'RED', 'BLUE', 'BLACK'] List4 = [ 'BROWN', 'PURPLE', 'GREY' ] print(" Display the List3 ", List3) print(" Display the List4 ", List4) # use extend() method to join two lists List1.extend(List2) List3.extend(List4) # print concatenation lists print( "\n Adding two lists of integers in Python using the extend() function: ", str(List1)) print( "\n Adding two lists of strings in Python using the extend() function: ", str(List3))
Display the List1 [5, 10, 5] Display the List1 [2, 4, 6, 8] Display the List3 ['RED', 'BLUE', 'BLACK'] Display the List4 ['BROWN', 'PURPLE', 'GREY'] Adding two lists of integers in Python using the extend() function: [5, 10, 5, 2, 4, 6, 8] Adding two lists of strings in Python using the extend() function: ['RED', 'BLUE', 'BLACK', 'BROWN', 'PURPLE', 'GREY']
Как сложить списки в python
Большинство программ работает не с отдельными переменными, а с набором переменных. Например, программа может обрабатывать информацию об учащихся класса, считывая список учащихся с клавиатуры или из файла, при этом изменение количества учащихся в классе не должно требовать модификации исходного кода программы.
Раньше мы сталкивались с задачей обработки элементов последовательности, например, вычисляя наибольший элемент последовательности. Но при этом мы не сохраняли всю последовательность в памяти компьютера. Однако, во многих задачах нужно именно сохранять всю последовательность, например, если бы нам требовалось вывести все элементы последовательности в возрастающем порядке (“отсортировать последовательность”).
Для хранения таких данных можно использовать структуру данных, называемую в Питоне список (в большинстве же языков программирования используется другой термин “массив”). Список представляет собой последовательность элементов, пронумерованных от 0, как символы в строке. Список можно задать перечислением элементов списка в квадратных скобках, например, список можно задать так:
Primes = [2, 3, 5, 7, 11, 13] Rainbow = ['Red', 'Orange', 'Yellow', 'Green', 'Blue', 'Indigo', 'Violet']
В списке Primes — 6 элементов, а именно: Primes[0] == 2 , Primes[1] == 3 , Primes[2] == 5 , Primes[3] == 7 , Primes[4] == 11 , Primes[5] == 13 . Список Rainbow состоит из 7 элементов, каждый из которых является строкой.
Также как и символы в строке, элементы списка можно индексировать отрицательными числами с конца, например, Primes[-1] == 13 , Primes[-6] == 2 .
Длину списка, то есть количество элементов в нем, можно узнать при помощи функции len , например, len(Primes) == 6 .
В отличие от строк, элементы списка можно изменять, присваивая им новые значения.
Rainbow = ['Red', 'Orange', 'Yellow', 'Green', 'Blue', 'Indigo', 'Violet'] print(Rainbow[0]) Rainbow[0] = 'красный' print('Выведем радугу') for i in range(len(Rainbow)): print(Rainbow[i])
Рассмотрим несколько способов создания и считывания списков. Прежде всего, можно создать пустой список (не содержащий элементов, длины 0), а в конец списка можно добавлять элементы при помощи метода append . Например, пусть программа получает на вход количество элементов в списке n , а потом n элементов списка по одному в отдельной строке. Вот пример входных данных в таком формате:
5 1809 1854 1860 1891 1925
В этом случае организовать считывание списка можно так:
5 1809 1854 1860 1891 1925
a = [] # заводим пустой список n = int(input()) # считываем количество элемент в списке for i in range(n): new_element = int(input()) # считываем очередной элемент a.append(new_element) # добавляем его в список # последние две строки можно было заменить одной: # a.append(int(input())) print(a)
В этом примере создается пустой список, далее считывается количество элементов в списке, затем по одному считываются элементы списка и добавляются в его конец. То же самое можно записать, сэкономив переменную n :
5 1809 1854 1860 1891 1925
a = [] for i in range(int(input())): a.append(int(input())) print(a)
Для списков целиком определены следующие операции: конкатенация списков (сложение списков, т. е. приписывание к одному списку другого) и повторение списков (умножение списка на число). Например:
a = [1, 2, 3] b = [4, 5] c = a + b d = b * 3 print([7, 8] + [9]) print([0, 1] * 3)
В результате список c будет равен [1, 2, 3, 4, 5] , а список d будет равен [4, 5, 4, 5, 4, 5] . Это позволяет по-другому организовать процесс считывания списков: сначала считать размер списка и создать список из нужного числа элементов, затем организовать цикл по переменной i начиная с числа 0 и внутри цикла считывается i -й элемент списка:
5 1809 1854 1860 1891 1925
a = [0] * int(input()) for i in range(len(a)): a[i] = int(input())
Вывести элементы списка a можно одной инструкцией print(a) , при этом будут выведены квадратные скобки вокруг элементов списка и запятые между элементами списка. Такой вывод неудобен, чаще требуется просто вывести все элементы списка в одну строку или по одному элементу в строке. Приведем два примера, также отличающиеся организацией цикла:
a = [1, 2, 3, 4, 5] for i in range(len(a)): print(a[i])
Здесь в цикле меняется индекс элемента i , затем выводится элемент списка с индексом i .
a = [1, 2, 3, 4, 5] for elem in a: print(elem, end=' ')
В этом примере элементы списка выводятся в одну строку, разделенные пробелом, при этом в цикле меняется не индекс элемента списка, а само значение переменной (например, в цикле for elem in [‘red’, ‘green’, ‘blue’] переменная elem будет последовательно принимать значения ‘red’ , ‘green’ , ‘blue’ .
Обратите особое внимание на последний пример! Очень важная часть идеологии Питона — это цикл for , который предоставляет удобный способ перебрать все элементы некоторой последовательности. В этом отличие Питона от Паскаля, где вам обязательно надо перебирать именно индексы элементов, а не сами элементы.
Последовательностями в Питоне являются строки, списки, значения функции range() (это не списки), и ещё кое-какие другие объекты.
Приведем пример, демонстрирующий использование цикла for в ситуации, когда из строки надо выбрать все цифры и сложить их в массив как числа.
# дано: s = 'ab12c59p7dq' # надо: извлечь цифры в список digits, # чтобы стало так: # digits == [1, 2, 5, 9, 7] s = 'ab12c59p7dq' digits = [] for symbol in s: if '1234567890'.find(symbol) != -1: digits.append(int(symbol)) print(digits)
2. Методы split и join
Элементы списка могут вводиться по одному в строке, в этом случае строку целиком можно считать функцией input() . После этого можно использовать метод строки split() , возвращающий список строк, которые получатся, если исходную строку разрезать на части по пробелам. Пример:
1 2 3
# на вход подаётся строка # 1 2 3 s = input() # s == '1 2 3' a = s.split() # a == ['1', '2', '3']
Если при запуске этой программы ввести строку 1 2 3 , то список a будет равен [‘1’, ‘2’, ‘3’] . Обратите внимание, что список будет состоять из строк, а не из чисел. Если хочется получить список именно из чисел, то можно затем элементы списка по одному преобразовать в числа:
1 2 3
a = input().split() for i in range(len(a)): a[i] = int(a[i])
Используя специальную магию Питона — генераторы — то же самое можно сделать в одну строку:
1 2 3
a = [int(s) for s in input().split()]
Объяснение того, как работает этот код, будет дано в следующем разделе. Если нужно считать список действительных чисел, то нужно заменить тип int на тип float .
У метода split() есть необязательный параметр, который определяет, какая строка будет использоваться в качестве разделителя между элементами списка. Например, вызов метода split(‘.’) вернет список, полученный разрезанием исходной строки по символам ‘.’ :
a = '192.168.0.1'.split('.')
В Питоне можно вывести список строк при помощи однострочной команды. Для этого используется метод строки join . У этого метода один параметр: список строк. В результате возвращается строка, полученная соединением элементов переданного списка в одну строку, при этом между элементами списка вставляется разделитель, равный той строке, к которой применяется метод. Мы знаем, что вы не поняли предыдущее предложение с первого раза. Поэтому смотрите примеры:
a = ['red', 'green', 'blue'] print(' '.join(a)) # вернёт red green blue print(''.join(a)) # вернёт redgreenblue print('***'.join(a)) # вернёт red***green***blue
Если же список состоит из чисел, то придется использовать еще тёмную магию генераторов. Вывести элементы списка чисел, разделяя их пробелами, можно так:
a = [1, 2, 3] print(' '.join([str(i) for i in a])) # следующая строка, к сожалению, вызывает ошибку: # print(' '.join(a))
Впрочем, если вы не любитель тёмной магии, то вы можете достичь того же эффекта, используя цикл for .
3. Генераторы списков
Для создания списка, заполненного одинаковыми элементами, можно использовать оператор повторения списка, например:
n = 5 a = [0] * n
Для создания списков, заполненных по более сложным формулам можно использовать генераторы: выражения, позволяющие заполнить список некоторой формулой. Общий вид генератора следующий:
[выражение for переменная in последовательность]
где переменная — идентификатор некоторой переменной, последовательность — последовательность значений, который принимает данная переменная (это может быть список, строка или объект, полученный при помощи функции range ), выражение — некоторое выражение, как правило, зависящее от использованной в генераторе переменной, которым будут заполнены элементы списка.
Вот несколько примеров использования генераторов.
Создать список, состоящий из n нулей можно и при помощи генератора:
a = [0 for i in range(5)]
Создать список, заполненный квадратами целых чисел можно так:
n = 5 a = [i ** 2 for i in range(n)]
Если нужно заполнить список квадратами чисел от 1 до n , то можно изменить параметры функции range на range(1, n + 1) :
n = 5 a = [i ** 2 for i in range(1, n + 1)]
Вот так можно получить список, заполненный случайными числами от 1 до 9 (используя функцию randrange из модуля random ):
from random import randrange n = 10 a = [randrange(1, 10) for i in range(n)]
А в этом примере список будет состоять из строк, считанных со стандартного ввода: сначала нужно ввести число элементов списка (это значение будет использовано в качестве аргумента функции range ), потом — заданное количество строк:
5 a b 1 2 3
a = [input() for i in range(int(input()))]
4. Срезы
Со списками, так же как и со строками, можно делать срезы. А именно:
A[i:j] срез из j-i элементов A[i] , A[i+1] , . A[j-1] .
A[i:j:-1] срез из i-j элементов A[i] , A[i-1] , . A[j+1] (то есть меняется порядок элементов).
A[i:j:k] срез с шагом k : A[i] , A[i+k] , A[i+2*k] . . Если значение k
Каждое из чисел i или j может отсутствовать, что означает “начало строки” или “конец строки”
Списки, в отличии от строк, являются изменяемыми объектами: можно отдельному элементу списка присвоить новое значение. Но можно менять и целиком срезы. Например:
A = [1, 2, 3, 4, 5] A[2:4] = [7, 8, 9]
Получится список, у которого вместо двух элементов среза A[2:4] вставлен новый список уже из трех элементов. Теперь список стал равен [1, 2, 7, 8, 9, 5] .
A = [1, 2, 3, 4, 5, 6, 7] A[::-2] = [10, 20, 30, 40]
Получится список [40, 2, 30, 4, 20, 6, 10] . Здесь A[::-2] — это список из элементов A[-1] , A[-3] , A[-5] , A[-7] , которым присваиваются значения 10, 20, 30, 40 соответственно.
Если не непрерывному срезу (то есть срезу с шагом k , отличному от 1), присвоить новое значение, то количество элементов в старом и новом срезе обязательно должно совпадать, в противном случае произойдет ошибка ValueError .
Обратите внимание, A[i] — это элемент списка, а не срез!
Операции со списками
Со списками можно легко делать много разных операций.
| x in A | Проверить, содержится ли элемент в списке. Возвращает True или False |
| x not in A | То же самое, что not(x in A) |
| min(A) | Наименьший элемент списка |
| max(A) | Наибольший элемент списка |
| A.index(x) | Индекс первого вхождения элемента x в список, при его отсутствии генерирует исключение ValueError |
| A.count(x) | Количество вхождений элемента x в список |
Слияние списков в Python
Слияние списков в Python является часто используемой операцией у программистов. В данной статье рассмотрим различные методы в Python для решения этой задачи.
Введение
В процессе программирования могут возникать ситуации, когда нам нужно объединить два или более списков в Python. Мы рассмотрим различные способы, с помощью которых можно объединить два списка в Python.
Слияние списков методом append()
Мы можем использовать метод append() для объединения одного списка в другой. Метод append() используется для добавления новых элементов к существующему списку. Чтобы объединить два списка с помощью метода append(), возьмем третий список и будем добавлять в него элементы из других списков по одному с помощью цикла for.
Это можно сделать следующим образом:
list_one = [1, 3, 5, 7] list_two = [2, 4, 6, 8] print("Содержимое первого списка:") print(list_one) print("Содержимое второго списка:") print(list_two) list_merged = [] for i in list_one: list_merged.append(i) for i in list_two: list_merged.append(i) print("Объединенный список:") print(list_merged)
Содержимое первого списка: [1, 3, 5, 7] Содержимое второго списка: [2, 4, 6, 8] Объединенный список: [1, 3, 5, 7, 2, 4, 6, 8]
В процессе объединения списков с помощью метода append() третий список изменяется по мере добавления в него элементов из первого и второго входного списка. В то время как на первый и второй список, из которого мы извлекаем элементы для добавления в третий список, это никак не влияет.
Слияние списков методом append() и pop()
Наряду с методом append(), для объединения двух списков в Python можно использовать метод pop(). Метод pop() при вызове на любом списке удаляет последний элемент и возвращает его. Мы будем использовать метод pop() для удаления элементов из списка и будем использовать метод append() для добавления элементов в другой список. Это можно сделать следующим образом.
Использование метода append() и pop():
list_one = [1, 3, 5, 7] list_two = [2, 4, 6, 8] print("Содержимое первого списка:") print(list_one) print("Содержимое второго списка:") print(list_two) list_merged = [] while list_one: temp = list_one.pop() list_merged.append(temp) while list_two: temp = list_two.pop() list_merged.append(temp) print("Объединенный список:") print(list_merged)
Содержимое первого списка: [1, 3, 5, 7] Содержимое второго списка: [2, 4, 6, 8] Объединенный список: [7, 5, 3, 1, 8, 6, 4, 2]
При использовании описанного выше метода для объединения двух списков оба входных списка изменяются. Третий список изменяется по мере добавления элементов из других списков в третий список. Все элементы из первого и второго списка удаляются с помощью метода pop(), поэтому после слияния списков первый и второй список становится пустым. На выходе мы также видим, что элементы первого и второго списка появляются в обратном порядке в объединенном списке.
Слияние списков используя генератор списков
Мы также можем использовать генератор списков для объединения двух или более списков в python. Для этого мы сначала создадим список всех списков, которые нужно объединить, а затем с помощью генератор списка создадим объединенный список следующим образом.
list_one = [1, 3, 5, 7] list_two = [2, 4, 6, 8] print("Содержимое первого списка:") print(list_one) print("Содержимое второго списка:") print(list_two) combined_list = [list_one, list_two] list_merged = [i for sublist in combined_list for i in sublist] print("Объединенный список:") print(list_merged)
Содержимое первого списка: [1, 3, 5, 7] Содержимое второго списка: [2, 4, 6, 8] Объединенный список: [1, 3, 5, 7, 2, 4, 6, 8]
Когда мы объединяем списки с помощью понимания списка, ни один из входных списков, подлежащих объединению, не будет изменен.
Слияние списков используя оператор +
Мы можем напрямую объединить два или более списка с помощью оператора +, просто сложив все списки с помощью оператора + следующим образом:
list_one = [1, 3, 5, 7] list_two = [2, 4, 6, 8] print("Содержимое первого списка:") print(list_one) print("Содержимое второго списка:") print(list_two) list_merged = list_one + list_two print("Объединенный список:") print(list_merged)
Содержимое первого списка: [1, 3, 5, 7] Содержимое второго списка: [2, 4, 6, 8] Объединенный список: [1, 3, 5, 7, 2, 4, 6, 8]
Когда мы объединяем два списка с помощью оператора +, как показано в приведенной выше программе, ни один из входных списков, которые объединяются, не будет изменен.
Слияние списков используя оператор распаковки *
Мы можем использовать оператор распаковки * для упаковки двух или более списков вместе, чтобы объединить их следующим образом.
list_one = [1, 3, 5, 7] list_two = [2, 4, 6, 8] print("Содержимое первого списка:") print(list_one) print("Содержимое второго списка:") print(list_two) list_merged = [*list_one, *list_two] print("Объединенный список:") print(list_merged)
Содержимое первого списка: [1, 3, 5, 7] Содержимое второго списка: [2, 4, 6, 8] Объединенный список: [1, 3, 5, 7, 2, 4, 6, 8]
Когда мы используем оператор распаковки для слияния двух списков, ни один из входных списков, которые объединяются, не будет изменен. Этот метод также может быть удобен для объединения трех или более списков одновременно, так как мы можем включить элементы из каждого списка в выходной объединенный список, просто упомянув каждый список с помощью operator *. Мы можем использовать оператор распаковки * для упаковки двух или более списков вместе, чтобы объединить их следующим образом.
Слияние списков методом extend()
Чтобы объединить два или более списка с помощью метода extend(), мы можем выполнить расширение первого списка на месте, добавляя в него элементы других списков следующим образом.
list_one = [1, 3, 5, 7] list_two = [2, 4, 6, 8] print("Содержимое первого списка:") print(list_one) print("Содержимое второго списка:") print(list_two) list_one.extend(list_two) print("Объединенный список:") print(list_one)
Содержимое первого списка: [1, 3, 5, 7] Содержимое второго списка: [2, 4, 6, 8] Объединенный список: [1, 3, 5, 7, 2, 4, 6, 8]
Когда мы объединяем два списка с помощью метода extend(), список, для которого используется метод extend(), модифицируется по мере добавления в него элементов из других списков. Другие списки не затрагиваются этой операцией.
Слияние списков методом itertools.chain()
Мы также можем использовать метод itertools.chain() для объединения двух или более списков в python. Для этого мы передадим списки в качестве аргументов методу itertools.chain(), а метод вернет итерабельную таблицу, содержащую все элементы объединяемых списков, которые в дальнейшем можно преобразовать в список Это можно сделать следующим образом.
import itertools list_one = [1, 3, 5, 7] list_two = [2, 4, 6, 8] print("Содержимое первого списка:") print(list_one) print("Содержимое второго списка:") print(list_two) list_merged = list(itertools.chain(list_one, list_two)) print("Объединенный список:") print(list_merged)
Содержимое первого списка: [1, 3, 5, 7] Содержимое второго списка: [2, 4, 6, 8] Объединенный список: [1, 3, 5, 7, 2, 4, 6, 8]
Когда мы объединяем списки с помощью метода itertools.chain(), ни один из входных списков не изменяется. Этот способ объединения списков в python может быть удобен для объединения более двух списков, поскольку нам просто нужно передать входные списки в качестве параметров методу itertools.chain().
Заключение
В этой статье мы рассмотрели различные способы объединения двух или более списков в Python с использованием различных методов и модулей. Мы также можем написать программы, использованные в этой статье, с обработкой исключений, используя Python try except, чтобы сделать программы более надежными и систематически обрабатывать ошибки.
Оставайтесь с нами для получения новых информативных статей.